Good Optimization Modeling Practices

with Pyomo
All You Wanted to Know About Practical Optimization but Were Afraid to Ask
Andres Ramos
[Link]
[Link]@[Link]
arght@[Link]
Good Optimization Modeling Practices with Pyomo. May 2024 1
Do not confuse the ingredients of the recipe
• Mathematical formulation
• LP, MIP, NLP, QCP, MCP
• Modeling language
• GAMS, Pyomo
• Solver
• CPLEX, Gurobi
• Optimization algorithm
• Primal simplex, dual simplex,
interior point
• Input/output interface
• Text file, CSV, Microsoft Excel
• Operating system
• Windows, Linux, macOS
Good Optimization Modeling Practices with Pyomo. May 2024 2
 What is relevant in an optimization model?

Appealing Name

Documentation
Maintainability
and reusability
Code attributes:
• Clarity
• Modularity
• Completeness
• Interoperability
• Maintainability
• Standardization

Good Optimization Modeling Practices with Pyomo. May 2024 3

 Picture: MITECO

Developer's Principle

Don't Let Reality Spoil a

Beautiful Mathematical Model

Good Optimization Modeling Practices with Pyomo. May 2024 4

Why Pyomo?
[Link]
[Link]
[Link]

• “Open-source optimization modeling language with a

diverse set of optimization capabilities.”
• No language license is required. Install
conda install –c conda-forge pyomo
• Allows the use of several solvers (open-source –SCIP,
HiGHS, GLPK, and CBC– or proprietary –Gurobi, CPLEX–)
pyomo help -s

Good Optimization Modeling Practices with Pyomo. May 2024 5

 GAMS Pyomo

• Pros: • Pros:
• Consistency • Flexibility, multiple choices
• Maturity. Everything has • Powerful Python libraries to
already been written be used (e.g., input data,
• Documentation output results, visualization)
• Customer support • Cons:
• Documentation is a Babel
tower, mined when using
ChatGPT
• Getting the duals
GAMS “Performance in Optimization Models: A Comparative Analysis of GAMS, Pyomo, GurobiPy,
and JuMP” July 2023
Good Optimization Modeling Practices with Pyomo. May 2024 6
Python vs. Julia

Good Optimization Modeling Practices with Pyomo. May 2024 7

 Comparison between GAMS and Pyomo (by
chatGPT)

1. GAMS has been around for longer than Pyomo, which means 1. Pyomo is open-source software, which means it is free to use
it has a more established user community and more extensive and modify, while GAMS is a commercial software that requires
documentation and support. a license to use.
2. GAMS is specifically designed for mathematical programming, 2. Pyomo is based on Python, a popular general-purpose
programming language that has a large and active user
whereas Pyomo is a general-purpose modeling tool that
community, while GAMS has its own proprietary modeling
includes mathematical programming as one of its features.
language that can have a steeper learning curve.
3. GAMS provides a powerful, integrated modeling language that 3. Pyomo provides more flexibility than GAMS, allowing users to
allows you to specify models using a concise syntax, while integrate their optimization models with other Python libraries
Pyomo requires you to write Python code to define your and tools.
models. 4. Pyomo can be used for a wide range of optimization problems,
4. GAMS has a wide range of solvers available, including not just mathematical programming, such as stochastic
commercial and open-source options, and it can seamlessly programming, optimization under uncertainty, and mixed-
switch between solvers, whereas Pyomo requires more effort integer nonlinear programming.
to switch between solvers. 5. Pyomo has a more modular design that makes it easier to add
new features or extensions, while GAMS has a more monolithic
5. GAMS includes built-in functionality for handling linear,
architecture that can be harder to customize.
nonlinear, and mixed-integer programming problems,
whereas Pyomo requires additional libraries to handle some
types of optimization problems.

Good Optimization Modeling Practices with Pyomo. May 2024 8

 Advantages/disadvantage of Pyomo (by ChatGPT)
1. Extensive modeling capabilities: Pyomo offers a wide range of modeling 1. Learning curve: Pyomo's powerful modeling capabilities come with a
components and constructs that allow users to represent complex learning curve, especially for users who are new to mathematical
optimization problems in a flexible and expressive manner. It supports a optimization or programming in Python. Understanding the syntax,
variety of mathematical formulations, including linear programming (LP), constructs, and best practices of Pyomo may require some initial effort
mixed-integer programming (MIP), and nonlinear programming (NLP). and familiarity with optimization modeling concepts.
2. Solver compatibility: Pyomo has built-in support for interfacing with a variety 2. Limited solver support: While Pyomo supports interfacing with multiple
of optimization solvers, both open-source and commercial. This allows users solvers, the availability of specific solvers may be limited compared to
to leverage the strengths of different solvers and choose the most suitable other optimization libraries. Some specialized or proprietary solvers may
one for their problem. Pyomo provides a unified interface for interacting not have direct support in Pyomo, requiring additional effort to integrate
with solvers, making it easy to switch between different solver backends. or interface with them.
3. Python integration: Pyomo is implemented in Python, a widely-used and 3. Performance overhead: Pyomo's flexibility and generality in modeling can
accessible programming language. This integration with Python provides sometimes come with a performance overhead. Depending on the
several advantages, including a large ecosystem of libraries and tools, complexity of the model and the chosen solver, Pyomo may not always
extensive documentation and support, and the ability to leverage Python's achieve the same level of performance as more specialized modeling
data manipulation and analysis capabilities. languages or libraries.
4. Scalability: Pyomo is designed to handle large-scale optimization problems 4. Documentation completeness: While Pyomo has documentation available,
efficiently. It supports parallel computation and provides options for it may not cover all aspects of the library or provide in-depth explanations
distributed computing, enabling users to solve computationally intensive for specific modeling techniques or functionalities. Users may need to
problems more effectively. Additionally, Pyomo can leverage the refer to external resources or rely on community support to find detailed
performance benefits of optimization solvers to handle large models and information on certain topics.
datasets.
5. Tool maturity: Pyomo, like other optimization libraries, has undergone
5. Active development and community support: Pyomo benefits from an active significant development over the years. However, it may still be considered
development community, ensuring regular updates, bug fixes, and less mature compared to some other well-established optimization
improvements. It also has an active user community that provides support, libraries. This means that there may be areas where Pyomo's toolset or
shares examples, and contributes to the development of additional libraries functionality is less refined or lacks certain advanced features available in
and extensions, making it easier for users to get started and find solutions to other libraries.
their optimization problems.
Good Optimization Modeling Practices with Pyomo. May 2024 10
 Creating an optimization model
• Interactive Development Environment (IDE)
• PyCharm ([Link]
• Visual Studio Code ([Link]
• JupyterLab: A Next-Generation Notebook Interface ([Link]

• Data manipulation
• pandas - Python Data Analysis Library ([Link]

• Plotting
• Plotly Open Source Graphing Library for Python ([Link]
• Matplotlib Visualization with Python ([Link]
• Vega-Altair Declarative Visualization in Python ([Link]

• Documentation
• reStructuredText ([Link]
• Sphinx makes it easy to create intelligent and beautiful documentation ([Link]
• ReadtheDocs. Build, host, and share documentation, all with a single platform
([Link]

Good Optimization Modeling Practices with Pyomo. May 2024 11

Good Optimization Modeling Practices with Pyomo. May 2024 12
 1. My First Example
2. Additional Features
3. Power Systems Models

My first example
Code conventions
• Must be defined in blocks. For example, a set and all its subsets
should constitute one block in the set section.
• Names are intended to be meaningful. Follow conventions
• Items with the same name represent the same concept in different
models
• Units should be used in all definitions
• Parameters are named pParameterName (e.g., pOperReserveDw)
• Variables are named vVariableName (e.g., vReserveDown)
• Equations are named eEquationName (e.g., eOperReserveDw)
• Use short set names (one or two letters) for easier reading
• Equations are laid out as clearly as possible

Good Optimization Modeling Practices with Pyomo. May 2024 14

Transportation model
There are can factories and consumption markets. Each
factory has a maximum capacity of 𝑖 cases, and each market
demands a quantity of 𝑗 cases (it is assumed that the total
production capacity is greater than the total market demand for
the problem to be feasible). The transportation cost between
each factory and each market for each case is 𝑖𝑗. The demand
must be satisfied at a minimum cost.
The decision variables of the problem will be cases transported
between each factory and each market , 𝑖𝑗.

Good Optimization Modeling Practices with Pyomo. May 2024 15

 My first GAMS transportation model
[Link]

sets min 𝑐 𝑥
I origins / VIGO, ALGECIRAS /
J destinations / MADRID, BARCELONA, VALENCIA /

parameters 𝑥 ≤ 𝑎 ∀𝑖
pA(i) origin capacity
/ VIGO 350
ALGECIRAS 700 /
𝑥 ≥ 𝑏 ∀𝑗
pB(j) destination demand
/ MADRID 400 A. Mizielinska y D. Mizielinski Atlas del mundo: Un insólito viaje por las
BARCELONA 450 𝑥 ≥0 mil curiosidades y maravillas del mundo Ed. Maeva 2015
VALENCIA 150 /

table pC(i,j) per unit transportation cost

MADRID BARCELONA VALENCIA
VIGO 0.06 0.12 0.09
ALGECIRAS 0.05 0.15 0.11

variables
vX(i,j) units transported
vCost transportation cost

positive variable vX

equations
eCost transportation cost
eCapacity(i) maximum capacity of each origin
eDemand (j) demand supply at destination ;

eCost .. sum[(i,j), pC(i,j) * vX(i,j)] =e= vCost ;

eCapacity(i) .. sum[ j , vX(i,j)] =l= pA(i) ;
eDemand (j) .. sum[ i , vX(i,j)] =g= pB(j) ;

model mTransport / all /

solve mTransport using LP minimizing vCost

Good Optimization Modeling Practices with Pyomo. May 2024 16

 My first Pyomo transportation model
[Link]

import [Link] as pyo

from [Link] import ConcreteModel, Set, Param, Var, NonNegativeReals, Constraint, Objective, minimize, Suffix
from [Link] import SolverFactory min 𝑐 𝑥
mTransport = ConcreteModel('Transportation Problem')

mTransport.i = Set(initialize=['Vigo', 'Algeciras' ], doc='origins' )

mTransport.j = Set(initialize=['Madrid', 'Barcelona', 'Valencia'], doc='destinations')
𝑥 ≤ 𝑎 ∀𝑖
[Link] = Param(mTransport.i, initialize={'Vigo' : 350, 'Algeciras': 700 }, doc='origin capacity' )
[Link] = Param(mTransport.j, initialize={'Madrid': 400, 'Barcelona': 450, 'Valencia': 150}, doc='destination demand')

TransportationCost = {
('Vigo',
('Vigo',
'Madrid' ):
'Barcelona'):
0.06,
0.12,
𝑥 ≥ 𝑏 ∀𝑗
('Vigo', 'Valencia' ): 0.09,
('Algeciras', 'Madrid' ): 0.05,
('Algeciras', 'Barcelona'):
('Algeciras', 'Valencia' ):
0.15,
0.11,
𝑥 ≥0
}

[Link] = Param(mTransport.i, mTransport.j, initialize=TransportationCost, doc='per unit transportation cost')

A. Mizielinska y D. Mizielinski Atlas del mundo: Un insólito viaje por las
[Link] = Var (mTransport.i, mTransport.j, bounds=(0.0,None), doc='units transported', within=NonNegativeReals)
mil curiosidades y maravillas del mundo Ed. Maeva 2015
def eCapacity(mTransport, i):
return sum([Link][i,j] for j in mTransport.j) <= [Link][i]
[Link] = Constraint(mTransport.i, rule=eCapacity, doc='maximum capacity of each origin')

def eDemand (mTransport, j):

return sum([Link][i,j] for i in mTransport.i) >= [Link][j]
[Link] = Constraint(mTransport.j, rule=eDemand, doc='demand supply at destination' )

def eCost(mTransport):
return sum([Link][i,j]*[Link][i,j] for i,j in mTransport.i*mTransport.j)
[Link] = Objective(rule=eCost, sense=minimize, doc='transportation cost')

[Link]('[Link]', io_options={'symbolic_solver_labels': True})

[Link] = Suffix(direction=[Link])

Solver = SolverFactory('gurobi')
[Link]['LogFile'] = '[Link]'
SolverResults = [Link](mTransport, tee=True)

[Link]()
[Link]()

[Link]()
for j in mTransport.j:
print([Link][[Link][j]])

Good Optimization Modeling Practices with Pyomo. May 2024 17

 LP File: [Link]('[Link]', io_options={'symbolic_solver_labels’: True})

\* Source Pyomo model name=unknown *\ c_l_eDemand(Barcelona)_:

+1 vX(Algeciras_Barcelona)
min +1 vX(Vigo_Barcelona)
eCost: >= 450
+0.14999999999999999 vX(Algeciras_Barcelona)
+0.050000000000000003 vX(Algeciras_Madrid) c_l_eDemand(Madrid)_:
+0.11 vX(Algeciras_Valencia) +1 vX(Algeciras_Madrid)
+0.12 vX(Vigo_Barcelona) +1 vX(Vigo_Madrid)
+0.059999999999999998 vX(Vigo_Madrid) >= 400
+0.089999999999999997 vX(Vigo_Valencia)
c_l_eDemand(Valencia)_:
s.t. +1 vX(Algeciras_Valencia)
+1 vX(Vigo_Valencia)
c_u_eCapacity(Algeciras)_: >= 150
+1 vX(Algeciras_Barcelona)
+1 vX(Algeciras_Madrid) c_e_ONE_VAR_CONSTANT:
+1 vX(Algeciras_Valencia) ONE_VAR_CONSTANT = 1.0
<= 700
bounds
c_u_eCapacity(Vigo)_: 0 <= vX(Algeciras_Barcelona) <= +inf
+1 vX(Vigo_Barcelona) 0 <= vX(Algeciras_Madrid) <= +inf
+1 vX(Vigo_Madrid) 0 <= vX(Algeciras_Valencia) <= +inf
+1 vX(Vigo_Valencia) 0 <= vX(Vigo_Barcelona) <= +inf
<= 350 0 <= vX(Vigo_Madrid) <= +inf
0 <= vX(Vigo_Valencia) <= +inf
end
Good Optimization Modeling Practices with Pyomo. May 2024 18
Problem summary: [Link]()
# ==========================================================
# = Solver Results =
# ==========================================================
# ----------------------------------------------------------
# Problem Information
# ----------------------------------------------------------
Problem:
- Name: x7
Lower bound: 93.5
Upper bound: 93.5
Number of objectives: 1
Number of constraints: 6
Number of variables: 7
Number of binary variables: 0
Number of integer variables: 0
Number of continuous variables: 7
Number of nonzeros: 13
Sense: minimize
# ----------------------------------------------------------
# Solver Information
# ----------------------------------------------------------
Solver:
- Status: ok
Return code: 0
Message: Model was solved to optimality (subject to tolerances), and an optimal solution is available.
Termination condition: optimal
Termination message: Model was solved to optimality (subject to tolerances), and an optimal solution is available.
Wall time: 0.020067214965820312
Error rc: 0
Time: 0.30008649826049805
# ----------------------------------------------------------
# Solution Information
# ----------------------------------------------------------
Solution:
- number of solutions: 0
number of solutions displayed: 0

Good Optimization Modeling Practices with Pyomo. May 2024 19

 Optimal results: [Link]()
4 Set Declarations 1 Var Declarations
i : origins
vX : units transported
Dim=0, Dimen=1, Size=2, Domain=None, Ordered=False, Bounds=None
Size=6, Index=vX_index
['Algecirass', 'Vigo']
j : destinations Key : Lower : Value : Upper : Fixed : Stale : Domain
Dim=0, Dimen=1, Size=3, Domain=None, Ordered=False, Bounds=None ('Algeciras', 'Barcelona') : 0.0 : 100.0 : None : False : False : Reals
['Barcelona', 'Madrid', 'Valencia'] ('Algeciras', 'Madrid') : 0.0 : 400.0 : None : False : False : Reals
pC_index : Dim=0, Dimen=2, Size=6, Domain=None, Ordered=False, Bounds=None ('Algeciras', 'Valencia') : 0.0 : 150.0 : None : False : False : Reals
Virtual ('Vigo', 'Barcelona') : 0.0 : 350.0 : None : False : False : Reals
vX_index : Dim=0, Dimen=2, Size=6, Domain=None, Ordered=False, Bounds=None ('Vigo', 'Madrid') : 0.0 : 0.0 : None : False : False : Reals
Virtual ('Vigo', 'Valencia') : 0.0 : 0.0 : None : False : False : Reals
3 Param Declarations 1 Objective Declarations
pA : origin capacity eCost : transportation cost
Size=2, Index=i, Domain=Any, Default=None, Mutable=False Size=1, Index=None, Active=True
Key : Value
Key : Active : Sense : Expression
Algeciras : 700
Vigo : 350
None : True : minimize : 0.06*vX[Vigo,Madrid] + 0.12*vX[Vigo,Barcelona] + 0.09*vX[Vigo,Valencia] +
pB : destination demand 0.05*vX[Algeciras,Madrid] + 0.15*vX[Algeciras,Barcelona] + 0.11*vX[Algeciras,Valencia]
Size=3, Index=j, Domain=Any, Default=None, Mutable=False 2 Constraint Declarations
Key : Value eCapacity : maximum capacity of each origin
Barcelona : 450 Size=2, Index=i, Active=True
Madrid : 400 Key : Lower : Body : Upper : Active
Valencia : 150 Algeciras : -Inf : vX[Algeciras,Madrid] + vX[Algeciras,Barcelona] + vX[Algeciras,Valencia] : 700.0 : True
pC : per unit transportation cost Vigo : -Inf : vX[Vigo,Madrid] + vX[Vigo,Barcelona] + vX[Vigo,Valencia] : 350.0 : True
Size=6, Index=pC_index, Domain=Any, Default=None, Mutable=False eDemand : demand supply at destination
Key : Value Size=3, Index=j, Active=True
('Algeciras', 'Barcelona') : 0.15
Key : Lower : Body : Upper : Active
('Algeciras', 'Madrid') : 0.05
Barcelona : 450.0 : vX[Vigo,Barcelona] + vX[Algeciras,Barcelona] : +Inf : True
('Algeciras', 'Valencia') : 0.11
('Vigo', 'Barcelona') : 0.12 Madrid : 400.0 : vX[Vigo,Madrid] + vX[Algeciras,Madrid] : +Inf : True
('Vigo', 'Madrid') : 0.06 Valencia : 150.0 : vX[Vigo,Valencia] + vX[Algeciras,Valencia] : +Inf : True
('Vigo', 'Valencia') : 0.09 11 Declarations: j pA pB pC_index pC vX_index vX eCapacity eDemand eCost i

Good Optimization Modeling Practices with Pyomo. May 2024 20

GAMSPy 0.12.4 ([Link]
• Combines the high-performance GAMS execution system
with the flexible Python language, creating a powerful
mathematical optimization package
• Acts as a bridge between the expressive Python language
and the robust GAMS system, allowing you to create
complex mathematical models effortlessly

Good Optimization Modeling Practices with Pyomo. May 2024 21

 Transportation model
[Link]

import pandas as pd
capacities = [Link](
[["seattle", 350], ["san-diego", 600]], columns=["city", "capacity"] c = Parameter(
).set_index("city") container=m,
demands = [Link]( name="c",
[["new-york", 325], ["chicago", 300], ["topeka", 275]], columns=["city", "demand"] domain=[i, j],
).set_index("city") description="cost per unit of shipment between plant i and market j",
distances = [Link]( )
[ cost = freight_cost * distances / 1000
["seattle", "new-york", 2.5], [Link](cost.reset_index())
["seattle", "chicago", 1.7], x = Variable(
["seattle", "topeka", 1.8], container=m,
["san-diego", "new-york", 2.5], name="x",
["san-diego", "chicago", 1.8], domain=[i, j],
["san-diego", "topeka", 1.4], type="Positive",
], description="amount of commodity to ship from plant i to market j",
columns=["from", "to", "distance"], )
).set_index(["from", "to"]) supply = Equation(
freight_cost = 90 container=m, name="supply", domain=i, description="observe supply limit at plant i"
from gamspy import Container, Set, Parameter, Variable, Equation, Model, Sum, Sense )
m = Container() demand = Equation(
i = Set(container=m, name="i", description="plants") container=m, name="demand", domain=j, description="satisfy demand at market j"
[Link]([Link]) )
j = Set(container=m, name="j", description="markets", records=[Link]) obj = Sum((i, j), c[i, j] * x[i, j])
a = Parameter( transport = Model(
container=m, m,
name="a", name="transport",
domain=i, equations=[supply, demand],
description="supply of commodity at plant i (in cases)", problem="LP",
records=capacities.reset_index(), sense=[Link],
) objective=obj,
b = Parameter( )
container=m, import sys
name="b", [Link](output=[Link])
domain=j, [Link].set_index(["i", "j"])
description="demand for commodity at market j (in cases)", transport.objective_value
records=demands.reset_index(),
)

Good Optimization Modeling Practices with Pyomo. May 2024 22

 1. My First Example
2. Additional Features
3. Power Systems Models

Additional Features
Sets
• Subsets
mSDUC.g = Set(initialize=[Link], ordered=False, doc='generating units', filter=lambda mSDUC,gg: gg in [Link] and pRatedMaxPower[gg] > 0.0)
mSDUC.t = Set(initialize=mSDUC.g , ordered=False, doc='thermal units', filter=lambda mSDUC,g : g in mSDUC.g and pLinearVarCost [g] > 0.0)

• Lag and lead operators: first()/last(), prev(,)/next(,)

def eUCStrShut(mTEPES,sc,p,n,nr):
if n == [Link]():
return [Link][sc,p,n,nr] - pInitialUC[nr] == [Link][sc,p,n,nr] - [Link][sc,p,n,nr]
else:
return [Link][sc,p,n,nr] - [Link][sc,p,[Link](n),nr] == [Link][sc,p,n,nr] - [Link][sc,p,n,nr]
[Link] = Constraint([Link], mTEPES.p, mTEPES.n, [Link], rule=eUCStrShut, doc='relation among commitment startup and shutdown’)

.fix
# fixing the ESS inventory at the last load level .unfix
for sc,p,es in [Link]*mTEPES.p*[Link]: .free
[Link][sc,p,[Link](),es].fix(pESSInitialInventory[es]) .setlb
.setub

• Circular indexes (prew/nextw)

# non-RES units, they can be committed and also
• Union (|), intersection (-) of sets contribute to the operating reserves
[Link] = mTEPES.g - [Link]
# existing electric lines (le)
[Link] = [Link] - [Link]
# ESS and hydro units
[Link] = [Link] | mTEPES.h

Good Optimization Modeling Practices with Pyomo. May 2024 24

Sparse index sets in a network
• Set of lines (initial node, final node, circuit)
[Link] = Set(initialize=[Link]*[Link]*[Link], ordered=False, doc='all lines', filter=lambda mTEPES,ni,nf,cc: (ni,nf,cc) in pLineX)

• All the connections (ni,nf,cc) vs. real lines (lc)

def eInstalNetCap1(mTEPES,sc,p,n,ni,nf,cc):
return [Link][sc,p,n,ni,nf,cc] / [Link][ni,nf,cc] >= - [Link][ni,nf,cc]
mTEPES.eInstalNetCap1 = Constraint([Link], mTEPES.p, mTEPES.n, [Link], rule=eInstalNetCap1, doc='maximum flow by installed
network capacity [p.u.]')

Good Optimization Modeling Practices with Pyomo. May 2024 25

 Constraint
#%% maximum angular difference between any two nodes
def eMaxThetaDiff(mTEPES,sc,p,n,ni,nf):
if ni > nf and nf != [Link]:
return (-[Link][ni,nf], vTheta[sc,p,n,ni] - vTheta[sc,p,n,nf], [Link][ni,nf])
else:
return [Link]
[Link] = Constraint([Link], mTEPES.p, mTEPES.n, [Link], [Link], rule=eMaxThetaDiff, doc='maximum angle difference [rad]')

Good Optimization Modeling Practices with Pyomo. May 2024 27

Sizing and timing
F1 C 21 C 22 C 23 F21 F22 F23 C 31 C 32 C 33 C 34 C 35 C 36 C 37 C 38 C39

• Counting constraints
print('eBalance ... ', len([Link]), ' rows’)

• Counting time
StartTime = [Link]()

# constraint creation

GeneratingRBITime = [Link]() - StartTime

print('Generating reserves/balance/inventory ... ', round(GeneratingRBITime), 's' )

Good Optimization Modeling Practices with Pyomo. May 2024 28

Boosting performance
• Threads
[Link]['Threads'] = int((psutil.cpu_count(logical=True) + psutil.cpu_count(logical=False))/2)

• Sensitivity analysis with persistent solvers

• Sequential resolution of similar problems in memory
Solver.remove_constraint([Link])
model.del_component([Link])
Solver.add_constraint([Link])

• Distributed computing
• Create the problems and send them to be solved in parallel
• Retrieve the solution once solved
[Link]()
model.del_component([Link])
[Link]()

Good Optimization Modeling Practices with Pyomo. May 2024 29

Modeling extensions
• Auto-Persistent Pyomo Solver Interfaces (APPSI).
Sensitivity analysis
• Stochastic Programming
• Equivalent to GAMS/EMP. Formulate the deterministic problem
and define the scenario tree
• Bilevel Programming
• MPEC
• Dynamic Optimization with [Link]
• Generalized Disjunctive Programming
• Pyomo Network
Good Optimization Modeling Practices with Pyomo. May 2024 30
Preprocessing by Gurobi Python shell (gurobipy)
• Before and after presolve can help you detect
improvements in the formulation
• Allows getting the optimization problem after the
presolve
ModelName = read(“[Link]")
ModelNamePresolved = [Link]()
[Link](“[Link]")

• Gurobi Model Analyzer (gurobi_modelanalyzer) allows to

detect numerical problems

Good Optimization Modeling Practices with Pyomo. May 2024 31

 Transportation Problem with demand scenarios
Auto-Persistent Pyomo Solver Interfaces (APPSI)
[Link]
import numpy as np
import [Link] as pyo
from [Link] import ConcreteModel, Set, Param, Var, NonNegativeReals, Constraint, Objective, minimize, Suffix
from [Link] import SolverFactory
from [Link] import appsi
from [Link] import HierarchicalTimer

# Developed by
#
# Andres Ramos
# Instituto de Investigacion Tecnologica
# Escuela Tecnica Superior de Ingenieria - ICAI
# UNIVERSIDAD PONTIFICIA COMILLAS
# Alberto Aguilera 23
# 28015 Madrid, Spain
# [Link]@[Link]
# [Link]
#
# May 8, 2023

mTransport = ConcreteModel('Transportation Problem with many demand scenarios')

mTransport.i = Set(initialize=['Vigo', 'Algeciras' ], doc='origins' )

mTransport.j = Set(initialize=['Madrid', 'Barcelona', 'Valencia'], doc='destinations') [Link] = Param(mTransport.i, mTransport.j, initialize=TransportationCost, doc='per unit transportation cost')

[Link] = Param(mTransport.i, initialize={'Vigo' : 350, 'Algeciras': 700 }, doc='origin capacity' ) [Link] = Var (mTransport.i, mTransport.j, bounds=(0.0,None), doc='units transported',
[Link] = Param(mTransport.j, initialize={'Madrid': 400, 'Barcelona': 450, 'Valencia': 150}, doc='destination demand', mutable=True) within=NonNegativeReals)
[Link] = Param(mTransport.j, initialize={'Madrid': 400, 'Barcelona': 450, 'Valencia': 150}, doc='destination demand', mutable=True)
def eCapacity(mTransport, i):
TransportationCost = { return sum([Link][i,j] for j in mTransport.j) <= [Link][i]
('Vigo', 'Madrid' ): 0.06, [Link] = Constraint(mTransport.i, rule=eCapacity, doc='maximum capacity of each origin')
('Vigo', 'Barcelona'): 0.12,
('Vigo', 'Valencia' ): 0.09, def eDemand (mTransport, j):
('Algeciras', 'Madrid' ): 0.05, return sum([Link][i,j] for i in mTransport.i) >= [Link][j]
('Algeciras', 'Barcelona'): 0.15, [Link] = Constraint(mTransport.j, rule=eDemand, doc='demand supply at destination' )
('Algeciras', 'Valencia' ): 0.11,
} def eCost(mTransport):
return sum([Link][i,j]*[Link][i,j] for i,j in mTransport.i*mTransport.j)
[Link] = Objective(rule=eCost, sense=minimize, doc='transportation cost')

[Link]('[Link]', io_options={'symbolic_solver_labels': True})

[Link] = Suffix(direction=[Link])

opt = [Link]()
timer = HierarchicalTimer()
for p_val in [Link](0.8, 1):
for j in mTransport.j:
[Link][j] = float(p_val)*[Link][j]
res = [Link](mTransport, timer=timer)
assert res.termination_condition == [Link]
Good Optimization Modeling Practices with Pyomo. May 2024
print([Link]())
print(timer)
32
Hashi puzzle ([Link]
Connect bridges between islands, according to their values, to form
one interconnecting path
7

1 2 3 4 5 6 7 8 9 10 11 12 13
Good Optimization Modeling Practices with Pyomo. May 2024 33
# Developed by
# Andres Ramos
[Link]
# Instituto de Investigacion Tecnologica
# Escuela Tecnica Superior de Ingenieria - ICAI
# UNIVERSIDAD PONTIFICIA COMILLAS
# Alberto Aguilera 23
# 28015 Madrid, Spain
# [Link]@[Link]

import pandas as pd
from [Link] import ConcreteModel, NonNegativeIntegers, Set, Param, Var, Constraint, Objective, minimize
from [Link] import SolverFactory
from collections import defaultdict

SolverName = 'gurobi'

# model declaration
mHP = ConcreteModel('Hashi puzzle')

def plain_run(mHP, SolverName):

mHP.x = Set(initialize=['x00', 'x01', 'x02', 'x03', 'x04', 'x05', 'x06', 'x07', 'x08', 'x09', 'x10', 'x11'], ordered=True, doc='abscises' )
mHP.y = Set(initialize=['y00', 'y01', 'y02', 'y03', 'y04', 'y05', 'y06', 'y07', 'y08', 'y09', 'y10', 'y11'], ordered=True, doc='ordinates')

Nodes = {
('x05', 'y01'): 1,
('x02', 'y02'): 3,
('x04', 'y02'): 3,
('x06', 'y02'): 4, Arcs = set()
('x03', 'y03'): 7, Neighbors = defaultdict(list)
('x05', 'y03'): 6, for x,y,xx,yy in mHP.x*mHP.y*mHP.x*mHP.y:
('x09', 'y03'): 1, if (x,y) in Nodes and (xx,yy) in Nodes:
('x04', 'y04'): 7, if [Link](x) > 2 and [Link](x) < len(mHP.x)-2 and [Link](y) > 1 and [Link](y) < len(mHP.y)-1:
('x06', 'y04'): 6, if ((xx,yy) == ([Link](x),[Link](y)) or (xx,yy) == ([Link](x,2),y) or (xx,yy) == ([Link](x),[Link](y)) or
('x10', 'y04'): 7, (xx,yy) == ([Link](x),[Link](y)) or (xx,yy) == ([Link](x,2),y) or (xx,yy) == ([Link](x),[Link](y))):
('x07', 'y05'): 5, # add the arc and its neighbors to the list
('x09', 'y05'): 7, [Link]((x, y, xx, yy))
('x11', 'y05'): 4, [Link]((xx, yy, x, y))
('x06', 'y06'): 5, Neighbors[x,y].append((xx,yy))
('x08', 'y06'): 6,
} # parameters
[Link] = Param(mHP.x, mHP.y, initialize=Nodes, doc='number of connections per node')

# Variables
[Link] = Var(Arcs, within=NonNegativeIntegers, doc='connections between two neighbor nodes')

def eTotalConnections(mHP):
return sum([Link][x,y,xx,yy] for x,y,xx,yy in Arcs)
[Link] = Objective(rule=eTotalConnections, sense=minimize, doc='total number of connections')

def eConnections(mHP, x, y):

if [Link](x) > 2 and [Link](x) < len(mHP.x)-2 and [Link](y) > 1 and [Link](y) < len(mHP.y)-1:
return sum([Link][x,y,xx,yy] + [Link][xx,yy,x,y] for xx,yy in Neighbors[x,y]) == [Link][x,y]
else:
return [Link]
[Link] = Constraint(Nodes, rule=eConnections, doc='connections on every node')

Solver = SolverFactory(SolverName)
[Link]('[Link]', io_options={'symbolic_solver_labels': True})
SolverResults = [Link](mHP, tee=True)
[Link]() # summary of the solver results
[Link]()

if __name__ == "__main__":
plain_run(mHP, SolverName)
Good Optimization Modeling Practices with Pyomo. May 2024 34
Picking the right campsite
[Link]

• Selecting the ideal camping site requires careful consideration of many factors
such as the proximity to water, availability of firewood and protection from the
elements. Your potential camping sites are shown in the corresponding map.
The map consists of 64 sites each with varying characteristics, including water,
wood, swamp and mosquitoes.
• The quality of a site is determined by a points system. A site that contains water
receives +3 points and a site that is near water receives +1 point. A site that
contains wood receives +2 points and a site that is near wood receives +1 point.
A site that contains a swamp is -2 points and a site that is near a swamp is -1
point. A site that contains mosquitoes receives -3 points and a site that is near
mosquitoes is -2 points.
• “Near” is defined as adjacent sites including diagonals. For example, site B5 is
worth 1 point (based on +3 on water, +1 near wood, -2 near mosquitoes, -1
near swamp). Note that you only count points once for each type of
characteristic.
• Where is the best campsite?

Good Optimization Modeling Practices with Pyomo. May 2024 35

 Fixed-Charge Transportation Problem (FCTP)
O.F. of the
• Bd Relaxed Master subproblem at
iteration 𝑙
min 𝑓 𝑦 +𝜃
,
Dual variables of
Flows linking constraints
(second stage) 𝛿 𝜃−𝜃 ≥ 𝜋 𝑀 (𝑦 − 𝑦 ) 𝑙 = 1, … , 𝑘 at iteration 𝑙
Investment
Complete problem
decisions 𝑦 ∈ 0,1 Master proposal at
(first stage) iteration 𝑙
min 𝑓 𝑦 +𝑐 𝑥
,

Capacity of each min 𝑐 𝑥

𝑥 ≤𝑎 ∀𝑖
origin
• Bd Subproblem
Demand of each 𝑥 ≤𝑎 ∀𝑖
destination 𝑥 ≥𝑏 ∀𝑗

Flow can pass 𝑥 ≤𝑀 𝑦 ∀𝑖𝑗 𝑥 ≥𝑏 ∀𝑗

only for installed 𝑥 ≥ 0, 𝑦 ∈ 0,1
connections 𝑥 ≤𝑀 𝑦 ∀𝑖𝑗 :𝜋
𝑥 ≥0

Good Optimization Modeling Practices with Pyomo. May 2024 36

Fixed-Charge Transportation Problem. Bd Solution
• Possible arcs I I I I I

I I I

• Solutions along Benders

decomposition iterations

Good Optimization Modeling Practices with Pyomo. May 2024 37

Fixed-Charge Transportation Problem. Bd
Convergence Iteration Lower Bound Upper Bound
1a6  
7 140 390
8 140 390
9 140 390
10 360 390
11 370 390
12 380 380
450
400
350
Objective function

300
250
200 Lower Bound
150 Upper Bound
100
50
0
7 8 9 10 11 12
Iterations

Good Optimization Modeling Practices with Pyomo. May 2024 38

FCTP solved by Benders decomposition (i)
[Link]

import pandas as pd
import [Link] as pyo
from [Link] import ConcreteModel, Set, Param, Var, Binary, NonNegativeReals, RealSet, Constraint, Objective, minimize, Suffix, TerminationCondition
from [Link] import SolverFactory

mFCTP = ConcreteModel('Fixed-Charge Transportation Problem')

mMaster_Bd = ConcreteModel('Master problem')

mFCTP.i = Set(initialize=['i1', 'i2', 'i3', 'i4'], doc='origins' )

mFCTP.j = Set(initialize=['j1', 'j2', 'j3' ], doc='destinations')

mMaster_Bd.l = Set(initialize=['it1', 'it2', 'it3', 'it4', 'it5', 'it6', 'it7', 'it8', 'it9', 'it10'], ordered=True, doc='iterations')
mMaster_Bd.ll = Set( doc='iterations')

[Link] = Param(mFCTP.i, initialize={'i1': 20, 'i2': 30, 'i3': 40, 'i4': 20}, doc='origin capacity' )
[Link] = Param(mFCTP.j, initialize={'j1': 20, 'j2': 50, 'j3':30 }, doc='destination demand')

FixedCost = {
('i1', 'j1'): 10,
('i1', 'j2'): 20,
('i1', 'j3'): 30,
('i2', 'j1'): 20,
('i2', 'j2'): 30,
('i2', 'j3'): 40,
('i3', 'j1'): 30,
('i3', 'j2'): 40,
('i3', 'j3'): 50,
('i4', 'j1'): 40,
('i4', 'j2'): 50,
('i4', 'j3'): 60,
}

TransportationCost = {
('i1', 'j1'): 1,
('i1', 'j2'): 2,
('i1', 'j3'): 3,
('i2', 'j1'): 3,
('i2', 'j2'): 2,
('i2', 'j3'): 1,
('i3', 'j1'): 2,
('i3', 'j2'): 3,
('i3', 'j3'): 4,
('i4', 'j1'): 4,
('i4', 'j2'): 3,
('i4', 'j3'): 2,
} Good Optimization Modeling Practices with Pyomo. May 2024 39
 FCTP solved by Benders decomposition (ii)
[Link] = Param(mFCTP.i, mFCTP.j, initialize=FixedCost, doc='fixed investment cost' )
[Link] = Param(mFCTP.i, mFCTP.j, initialize=TransportationCost, doc='per unit transportation cost')

[Link] = Var (mFCTP.i, mFCTP.j, bounds=(0,1), doc='units transported', within=Binary)

mMaster_Bd.vY = Var (mFCTP.i, mFCTP.j, bounds=(0,1), doc='units transported', within=Binary)

mMaster_Bd.vTheta = Var(doc='transportation cost', within=RealSet)

[Link] = Var (mFCTP.i, mFCTP.j, bounds=(0.0,None), doc='units transported', within=NonNegativeReals)

[Link] = Var ( mFCTP.j, bounds=(0.0,None), doc='demand not served', within=NonNegativeReals)

def eCostMst(mMaster_Bd):
return sum([Link][i,j]*mMaster_Bd.vY[i,j] for i,j in mFCTP.i*mFCTP.j) + mMaster_Bd.vTheta
mMaster_Bd.eCostMst = Objective(rule=eCostMst, sense=minimize, doc='total cost')

def eBd_Cuts(mMaster_Bd, ll):

return mMaster_Bd.vTheta - Z2_L[ll] >= - sum(PI_L[ll,i,j] * min([Link][i],[Link][j]) * (Y_L[ll,i,j] - mMaster_Bd.vY[i,j]) for i,j in mFCTP.i*mFCTP.j)

def eCostSubp(mFCTP):
return sum([Link][i,j]*[Link][i,j] for i,j in mFCTP.i*mFCTP.j) + sum([Link][j]*1000 for j in mFCTP.j)
[Link] = Objective(rule=eCostSubp, sense=minimize, doc='transportation cost')

def eCapacity(mFCTP, i):

return sum([Link][i,j] for j in mFCTP.j) <= [Link][i]
[Link] = Constraint(mFCTP.i, rule=eCapacity, doc='maximum capacity of each origin')

def eDemand (mFCTP, j):

return sum([Link][i,j] for i in mFCTP.i) + [Link][j] >= [Link][j]
[Link] = Constraint( mFCTP.j, rule=eDemand, doc='demand supply at destination' )

def eFlowLimit(mFCTP, i, j):

return [Link][i,j] <= min([Link][i],[Link][j])*[Link][i,j]
[Link] = Constraint(mFCTP.i*mFCTP.j, rule=eFlowLimit, doc='arc flow limit' )

Solver = SolverFactory('gurobi')
[Link]['LogFile'] = '[Link]'
[Link] = Suffix(direction=[Link])

# initialization
Z_Lower = float('-inf')
Z_Upper = float(' inf')
BdTol = 1e-6

Y_L = [Link]([0 ]*len(mMaster_Bd.l*mFCTP.i*mFCTP.j), index=[Link].from_tuples(mMaster_Bd.l*mFCTP.i*mFCTP.j))

PI_L = [Link]([0.]*len(mMaster_Bd.l*mFCTP.i*mFCTP.j), index=[Link].from_tuples(mMaster_Bd.l*mFCTP.i*mFCTP.j))
Z2_L = [Link]([0.]*len(mMaster_Bd.l ), index=mMaster_Bd.l)
Delta = [Link]([0 ]*len(mMaster_Bd.l ), index=mMaster_Bd.l) Good Optimization Modeling Practices with Pyomo. May 2024 40
 FCTP solved by Benders decomposition (iii)
# Benders algorithm
mMaster_Bd.[Link](0)
for l in mMaster_Bd.l:
if abs(1-Z_Lower/Z_Upper) > BdTol or l == mMaster_Bd.[Link]():

# solving master problem

SolverResultsMst = [Link](mMaster_Bd)
Z1 = mMaster_Bd.eCostMst()

for i,j in mFCTP.i*mFCTP.j:

# storing the master solution
Y_L[l,i,j] = mMaster_Bd.vY[i,j]()
# fix investment decision for the subproblem
[Link][i,j].fix(Y_L[l,i,j])

# solving subproblem
SolverResultsSbp = [Link](mFCTP)
Z2 = [Link]()
Z2_L[l] = Z2

# storing parameters to build a new Benders cut

if [Link].termination_condition == [Link]:
# the problem has to be feasible because I am not able to obtain the sum of infeasibilities of the phase I
Delta[l] = 0
else:
# updating lower and upper bound
Z_Lower = Z1
Z_Upper = min(Z_Upper, Z1 - mMaster_Bd.vTheta() + Z2)
print('Iteration ', l, ' Z_Lower ... ', Z_Lower)
print('Iteration ', l, ' Z_Upper ... ', Z_Upper)

mMaster_Bd.[Link]()

Delta[l] = 1

for i,j in mFCTP.i*mFCTP.j:

PI_L[l,i,j] = [Link][[Link][i,j]]

mMaster_Bd.[Link]()

# add one cut

mMaster_Bd.[Link](l)
ll = mMaster_Bd.ll
mMaster_Bd.eBd_Cuts = Constraint(mMaster_Bd.ll, rule=eBd_Cuts, doc='Benders cuts')

[Link]()
[Link]()

def eCost(mFCTP):
return sum([Link][i,j]*[Link][i,j] for i,j in mFCTP.i*mFCTP.j) + sum([Link][i,j]*[Link][i,j] for i,j in mFCTP.i*mFCTP.j) + sum([Link][j]*1000 for j in mFCTP.j)
[Link] = Objective(rule=eCost, sense=minimize, doc='total cost')

SolverResults = [Link](mFCTP, tee=True)

[Link]()
Good Optimization Modeling Practices with Pyomo. May 2024 41
 1. My First Example
2. Additional Features
3. Power Systems Models

Power Systems Models

Simplicity and transparency
• Replicating the GAMS structure and elegance in
Python/Pyomo
• Separation between
• Dictionaries of sets
• Parameters
• Variables
• Equations
• Solve
• Output results
• Input data and output results in text format (csv)
Good Optimization Modeling Practices with Pyomo. May 2024 43
 openSDUC
[Link]
[Link]

• Open Stochastic Daily Unit Commitment of Thermal and

ESS Units
• Web page created with sphinx

The openSDUC code is provided under the

GNU General Public License:
•the code can’t become part of a closed-
source commercial software product
•any future changes and improvements to
the code remain free and open

Disclaimer:
This model is a work in progress and will be
updated accordingly.

Good Optimization Modeling Practices with Pyomo. May 2024 44

Stochastic Daily Unit Commitment (i)
# Open Stochastic Daily Unit Commitment of Thermal and ESS Units (openSDUC) - Version 1.3.29 - January 22, 2023
# simplicity and transparency in power systems planning

# Developed by

# Andres Ramos
# Instituto de Investigacion Tecnologica
# Escuela Tecnica Superior de Ingenieria - ICAI
# UNIVERSIDAD PONTIFICIA COMILLAS
# Alberto Aguilera 23
# 28015 Madrid, Spain
# [Link]@[Link]
# [Link]

# with the very valuable collaboration from David Dominguez ([Link]@[Link]) and Alejandro Rodriguez (argallego@[Link]), our local Python gurus

#%% Libraries
import argparse
import os
import pandas as pd
import time # count clock time
import psutil # access the number of CPUs
import [Link] as pyo
from [Link] import Set, Var, Binary, NonNegativeReals, RealSet, Constraint, ConcreteModel, Objective, minimize, Suffix, DataPortal
from [Link] import SolverFactory

import [Link] as plt

print('\n #### Academic research license - for non-commercial use only #### \n')

StartTime = [Link]()

parser = [Link](description='Introducing main parameters...')

parser.add_argument('--case', type=str, default=None)
parser.add_argument('--dir', type=str, default=None)
parser.add_argument('--solver', type=str, default=None)

DIR = [Link](__file__)
CASE = '16g'
SOLVER = 'gurobi'

Good Optimization Modeling Practices with Pyomo. May 2024 46

Stochastic Daily Unit Commitment (ii)
def main():
args = parser.parse_args()
if [Link] is None:
[Link] = input('Input Dir Name (Default {}): '.format(DIR))
if [Link] == '':
[Link] = DIR
if [Link] is None:
[Link] = input('Input Case Name (Default {}): '.format(CASE))
if [Link] == '':
[Link] = CASE
if [Link] is None:
[Link] = input('Input Solver Name (Default {}): '.format(SOLVER))
if [Link] == '':
[Link] = SOLVER
print([Link])
print([Link])
print([Link])
import sys
print([Link])
print(args)
openSDUC_run([Link], [Link], [Link])

Good Optimization Modeling Practices with Pyomo. May 2024 47

Stochastic Daily Unit Commitment (iii)
def openSDUC_run(DirName, CaseName, SolverName):

_path = [Link](DirName, CaseName)

StartTime = [Link]()

#%% model declaration

mSDUC = ConcreteModel('Open Stochastic Daily Unit Commitment of Thermal and ESS Units (openSDUC) - Version 1.3.29 - January 22, 2023')

#%% reading the sets

dictSets = DataPortal()
[Link](filename=_path+'/oUC_Dict_Scenario_' +CaseName+'.csv', set='sc', format='set')
[Link](filename=_path+'/oUC_Dict_LoadLevel_' +CaseName+'.csv', set='n' , format='set')
[Link](filename=_path+'/oUC_Dict_Generation_'+CaseName+'.csv', set='g' , format='set')
[Link](filename=_path+'/oUC_Dict_Storage_' +CaseName+'.csv', set='st', format='set')
[Link](filename=_path+'/oUC_Dict_Technology_'+CaseName+'.csv', set='gt', format='set')
[Link](filename=_path+'/oUC_Dict_Company_' +CaseName+'.csv', set='co', format='set')

[Link] = Set(initialize=dictSets['sc'], ordered=True, doc='scenarios' )

[Link] = Set(initialize=dictSets['n' ], ordered=True, doc='load levels' )
[Link] = Set(initialize=dictSets['g' ], ordered=False, doc='units' )
[Link] = Set(initialize=dictSets['gt'], ordered=False, doc='technologies')
[Link] = Set(initialize=dictSets['co'], ordered=False, doc='companies' )
[Link] = Set(initialize=dictSets['st'], ordered=False, doc='ESS types' )

#%% reading data from CSV files

dfParameter = pd.read_csv(_path+'/oUC_Data_Parameter_' +CaseName+'.csv', index_col=[0 ])
dfDuration = pd.read_csv(_path+'/oUC_Data_Duration_' +CaseName+'.csv', index_col=[0 ])
dfScenario = pd.read_csv(_path+'/oUC_Data_Scenario_' +CaseName+'.csv', index_col=[0 ])
dfDemand = pd.read_csv(_path+'/oUC_Data_Demand_' +CaseName+'.csv', index_col=[0, 1])
dfOperatingReserve = pd.read_csv(_path+'/oUC_Data_OperatingReserve_' +CaseName+'.csv', index_col=[0,1])
dfGeneration = pd.read_csv(_path+'/oUC_Data_Generation_' +CaseName+'.csv', index_col=[0 ])
dfVariableMinPower = pd.read_csv(_path+'/oUC_Data_MinimumGeneration_'+CaseName+'.csv', index_col=[0,1])
dfVariableMaxPower = pd.read_csv(_path+'/oUC_Data_MaximumGeneration_'+CaseName+'.csv', index_col=[0,1])
dfVariableMinStorage = pd.read_csv(_path+'/oUC_Data_MinimumStorage_' +CaseName+'.csv', index_col=[0,1])
dfVariableMaxStorage = pd.read_csv(_path+'/oUC_Data_MaximumStorage_' +CaseName+'.csv', index_col=[0,1])
dfEnergyInflows = pd.read_csv(_path+'/oUC_Data_EnergyInflows_' +CaseName+'.csv', index_col=[0,1])

Good Optimization Modeling Practices with Pyomo. May 2024 48

 Stochastic Daily Unit Commitment (iv)
# substitute NaN by 0
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link](0.0, inplace=True)
[Link](0.0, inplace=True)
[Link] (0.0, inplace=True)

#%% general parameters

pENSCost = dfParameter['ENSCost' ][0] * 1e-3 # cost of energy not served [MEUR/GWh]
pCO2Cost = dfParameter['CO2Cost' ][0] # cost of CO2 emission [EUR/CO2 ton]
pTimeStep = dfParameter['TimeStep'][0].astype('int') # duration of the unit time step [h]

pDuration = dfDuration ['Duration' ] * pTimeStep # duration of load levels [h]

pScenProb = dfScenario ['Probability' ] # probabilities of scenarios [p.u.]
pDemand = dfDemand ['Demand' ] * 1e-3 # demand [GW]
pOperReserveUp = dfOperatingReserve ['Up' ] * 1e-3 # operating reserve up [GW]
pOperReserveDw = dfOperatingReserve ['Down' ] * 1e-3 # operating reserve down [GW]
pVariableMinPower = dfVariableMinPower [list([Link])] * 1e-3 # dynamic variable minimum power [GW]
pVariableMaxPower = dfVariableMaxPower [list([Link])] * 1e-3 # dynamic variable maximum power [GW]
pVariableMinStorage = dfVariableMinStorage[list([Link])] # dynamic variable minimum storage [GWh]
pVariableMaxStorage = dfVariableMaxStorage[list([Link])] # dynamic variable maximum storage [GWh]
pEnergyInflows = dfEnergyInflows [list([Link])] * 1e-3 # dynamic energy inflows [GW]

# compute the demand as the mean over the time step load levels and assign it to active load levels. Idem for operating reserve, variable max power, variable min and max storage
capacity and inflows
pDemand = [Link] (pTimeStep).mean()
pOperReserveUp = [Link] (pTimeStep).mean()
pOperReserveDw = [Link] (pTimeStep).mean()
pVariableMinPower = [Link] (pTimeStep).mean()
pVariableMaxPower = [Link] (pTimeStep).mean()
pVariableMinStorage = [Link](pTimeStep).mean()
pVariableMaxStorage = [Link](pTimeStep).mean()
pEnergyInflows = [Link] (pTimeStep).mean()

Good Optimization Modeling Practices with Pyomo. May 2024 49

 Stochastic Daily Unit Commitment (v)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link] (0.0, inplace=True)
[Link](0.0, inplace=True)
[Link](0.0, inplace=True)
[Link] (0.0, inplace=True)

if pTimeStep > 1:
# assign duration 0 to load levels not being considered, active load levels are at the end of every pTimeStep
for i in range(pTimeStep-2,-1,-1):
pDuration[range(i,len([Link]),pTimeStep)] = 0

#%% generation parameters

pGenToTechnology = dfGeneration['Technology' ] # generator association to technology
pGenToCompany = dfGeneration['Company' ] # generator association to company
pRatedMinPower = dfGeneration['MinimumPower' ] * 1e-3 # rated minimum power [GW]
pRatedMaxPower = dfGeneration['MaximumPower' ] * 1e-3 # rated maximum power [GW]
pLinearVarCost = dfGeneration['LinearTerm' ] * 1e-3 * dfGeneration['FuelCost'] + dfGeneration['OMVariableCost'] * 1e-3 # linear term variable cost [MEUR/GWh]
pConstantVarCost = dfGeneration['ConstantTerm' ] * 1e-6 * dfGeneration['FuelCost'] # constant term variable cost [MEUR/h]
pStartUpCost = dfGeneration['StartUpCost' ] # startup cost [MEUR]
pShutDownCost = dfGeneration['ShutDownCost' ] # shutdown cost [MEUR]
pRampUp = dfGeneration['RampUp' ] * 1e-3 # ramp up rate [GW/h]
pRampDw = dfGeneration['RampDown' ] * 1e-3 # ramp down rate [GW/h]
pCO2EmissionRate = dfGeneration['CO2EmissionRate'] * 1e-3 # emission rate [t CO2/MWh]
pUpTime = dfGeneration['UpTime' ] # minimum up time [h]
pDwTime = dfGeneration['DownTime' ] # minimum down time [h]
pMaxCharge = dfGeneration['MaximumCharge' ] * 1e-3 # maximum ESS charge [GW]
pInitialInventory = dfGeneration['InitialStorage' ] # initial ESS storage [GWh]
pRatedMinStorage = dfGeneration['MinimumStorage' ] # minimum ESS storage [GWh]
pRatedMaxStorage = dfGeneration['MaximumStorage' ] # maximum ESS storage [GWh]
pEfficiency = dfGeneration['Efficiency' ] # ESS efficiency [p.u.]
pStorageType = dfGeneration['StorageType' ] # ESS type

Good Optimization Modeling Practices with Pyomo. May 2024 50

 Stochastic Daily Unit Commitment (vi)
ReadingDataTime = [Link]() - StartTime
StartTime = [Link]()
print('Reading input data ... ', round(ReadingDataTime), 's')

#%% defining subsets: active load levels (n), thermal units (t), ESS units (es), all the lines (la), candidate lines (lc) and lines with losses (ll)
mSDUC.n = Set(initialize=[Link], ordered=True , doc='load levels' , filter=lambda mSDUC,nn: nn in [Link] and pDuration [nn] > 0 )
mSDUC.n2 = Set(initialize=[Link], ordered=True , doc='load levels' , filter=lambda mSDUC,nn: nn in [Link] and pDuration [nn] > 0 )
mSDUC.g = Set(initialize=[Link], ordered=False, doc='generating units', filter=lambda mSDUC,gg: gg in [Link] and pRatedMaxPower[gg] > 0.0)
mSDUC.t = Set(initialize=mSDUC.g , ordered=False, doc='thermal units', filter=lambda mSDUC,g : g in mSDUC.g and pLinearVarCost [g] > 0.0)
mSDUC.r = Set(initialize=mSDUC.g , ordered=False, doc='RES units', filter=lambda mSDUC,g : g in mSDUC.g and pLinearVarCost [g] == 0.0 and pRatedMaxStorage[g] == 0.0)
[Link] = Set(initialize=mSDUC.g , ordered=False, doc='ESS units', filter=lambda mSDUC,g : g in mSDUC.g and pRatedMaxStorage[g] > 0.0)

# non-RES units
[Link] = mSDUC.g - mSDUC.r

if pTimeStep > 1:
# drop levels with duration 0
pDuration = [Link] [[Link]*mSDUC.n]
pDemand = [Link] [[Link]*mSDUC.n]
pOperReserveUp = [Link] [[Link]*mSDUC.n]
pOperReserveDw = [Link] [[Link]*mSDUC.n]
pVariableMinPower = [Link] [[Link]*mSDUC.n]
pVariableMaxPower = [Link] [[Link]*mSDUC.n]
pVariableMinStorage = [Link][[Link]*mSDUC.n]
pVariableMaxStorage = [Link][[Link]*mSDUC.n]
pEnergyInflows = [Link] [[Link]*mSDUC.n]

# variable minimum and maximum power

pVariableMinPower = [Link](0.0, float('nan'))
pVariableMaxPower = [Link](0.0, float('nan'))
pMinPower = [Link]([pRatedMinPower]*len([Link]), index=[Link].from_tuples([Link]), columns=[Link])
pMaxPower = [Link]([pRatedMaxPower]*len([Link]), index=[Link].from_tuples([Link]), columns=[Link])
pMinPower = [Link] (sorted([Link] ), axis=1)
pMaxPower = [Link] (sorted([Link] ), axis=1)
pVariableMinPower = [Link](sorted([Link]), axis=1)
pVariableMaxPower = [Link](sorted([Link]), axis=1)
pMinPower = [Link](pVariableMinPower > pMinPower, other=pMaxPower)
pMaxPower = [Link](pVariableMaxPower < pMaxPower, other=pMaxPower)
pMaxPower2ndBlock = pMaxPower - pMinPower

Good Optimization Modeling Practices with Pyomo. May 2024 51

 Stochastic Daily Unit Commitment (vii)
# variable minimum and maximum storage capacity
pVariableMinStorage = [Link](0.0, float('nan'))
pVariableMaxStorage = [Link](0.0, float('nan'))
pMinStorage = [Link]([pRatedMinStorage]*len([Link]), index=[Link].from_tuples([Link]), columns=[Link])
pMaxStorage = [Link]([pRatedMaxStorage]*len([Link]), index=[Link].from_tuples([Link]), columns=[Link])
pMinStorage = [Link] (sorted([Link] ), axis=1)
pMaxStorage = [Link] (sorted([Link] ), axis=1)
pVariableMinStorage = [Link](sorted([Link]), axis=1)
pVariableMaxStorage = [Link](sorted([Link]), axis=1)
pMinStorage = [Link](pVariableMinStorage > pMinStorage, other=pMinStorage)
pMaxStorage = [Link](pVariableMaxStorage < pMaxStorage, other=pMaxStorage)

# values < 1e-5 times the maximum system demand are converted to 0
pEpsilon = [Link]()*1e-5
# these parameters are in GW
pDemand [pDemand < pEpsilon] = 0.0
pOperReserveUp [pOperReserveUp < pEpsilon] = 0.0
pOperReserveDw [pOperReserveDw < pEpsilon] = 0.0
pMinPower [pMinPower < pEpsilon] = 0.0
pMaxPower [pMaxPower < pEpsilon] = 0.0
pMaxPower2ndBlock[pMaxPower2ndBlock < pEpsilon] = 0.0
pMaxCharge [pMaxCharge < pEpsilon] = 0.0
pEnergyInflows [pEnergyInflows < pEpsilon/pTimeStep] = 0.0
# these parameters are in GWh
pMinStorage [pMinStorage < pEpsilon] = 0.0
pMaxStorage [pMaxStorage < pEpsilon] = 0.0

# this option avoids a warning in the following assignments

[Link].chained_assignment = None

# minimum up- and downtime converted to an integer number of time steps

pUpTime = round(pUpTime/pTimeStep).astype('int')
pDwTime = round(pDwTime/pTimeStep).astype('int')

# thermal and variable units ordered by increasing variable cost

[Link] = pLinearVarCost.sort_values().index

# determine the initial committed units and their output

pInitialOutput = [Link]([0.0]*len(mSDUC.g), [Link])
pInitialUC = [Link]([0.0]*len(mSDUC.g), [Link])
pSystemOutput = 0.0
for go in [Link]:
n1 = next(iter([Link]*mSDUC.n))
if pSystemOutput < pDemand[n1]:
if go in mSDUC.r:
pInitialOutput[go] = pMaxPower[go][n1]
else:
pInitialOutput[go] = pMinPower[go][n1]
pInitialUC [go] = 1
pSystemOutput += pInitialOutput[go]

Good Optimization Modeling Practices with Pyomo. May 2024 52

 Stochastic Daily Unit Commitment (viii)
#%% variables
[Link] = Var( within=NonNegativeReals, doc='total system variable cost [MEUR]')
[Link] = Var( within=NonNegativeReals, doc='total system emission cost [MEUR]')
[Link] = Var([Link], mSDUC.n, mSDUC.g , within=NonNegativeReals, bounds=lambda mSDUC,sc,n,g :(0.0,pMaxPower [g ][sc,n]), doc='total output of the unit [GW]')
mSDUC.vOutput2ndBlock = Var([Link], mSDUC.n, [Link], within=NonNegativeReals, bounds=lambda mSDUC,sc,n,nr:(0.0,pMaxPower2ndBlock [nr][sc,n]), doc='second block of the unit [GW]')
[Link] = Var([Link], mSDUC.n, [Link], within=NonNegativeReals, bounds=lambda mSDUC,sc,n,nr:(0.0,pMaxPower2ndBlock [nr][sc,n]), doc='operating reserve up [GW]')
[Link] = Var([Link], mSDUC.n, [Link], within=NonNegativeReals, bounds=lambda mSDUC,sc,n,nr:(0.0,pMaxPower2ndBlock [nr][sc,n]), doc='operating reserve down [GW]')
[Link] = Var([Link], mSDUC.n, [Link], within=NonNegativeReals, bounds=lambda mSDUC,sc,n,es:(pMinStorage[es][sc,n],pMaxStorage[es][sc,n]), doc='ESS inventory [GWh]')
[Link] = Var([Link], mSDUC.n, [Link], within=NonNegativeReals, doc='ESS spillage [GWh]')
[Link] = Var([Link], mSDUC.n, [Link], within=NonNegativeReals, bounds=lambda mSDUC,sc,n,es:(0.0,pMaxCharge [es] ), doc='ESS charge power [GW]')
[Link] = Var([Link], mSDUC.n, within=NonNegativeReals, bounds=lambda mSDUC,sc,n :(0.0,pDemand [sc,n]), doc='energy not served in node [GW]')

[Link] = Var( mSDUC.n, [Link], within=Binary, doc='commitment of the unit {0,1}')

[Link] = Var( mSDUC.n, [Link], within=Binary, doc='StartUp of the unit {0,1}')
[Link] = Var( mSDUC.n, [Link], within=Binary, doc='ShutDown of the unit {0,1}')

# fixing the ESS inventory at the last load level at the end of the time scope
for sc,es in [Link]*[Link]:
[Link][sc,[Link](),es].fix(pInitialInventory[es])

#%% definition of the time-steps leap to observe the stored energy at ESS
pCycleTimeStep = pUpTime*0
for es in [Link]:
if pStorageType[es] == 'Daily' :
pCycleTimeStep[es] = 1
if pStorageType[es] == 'Weekly' :
pCycleTimeStep[es] = int( 24/pTimeStep)
if pStorageType[es] == 'Monthly' :
pCycleTimeStep[es] = int( 168/pTimeStep)

# fixing the ESS inventory at the end of the following pCycleTimeStep (weekly, yearly), i.e., for daily ESS is fixed at the end of the week, for weekly/monthly ESS is fixed at the end of the year
for sc,n,es in [Link]*mSDUC.n*[Link]:
if pStorageType[es] == 'Daily' and [Link](n) % ( 168/pTimeStep) == 0:
[Link][sc,n,es].fix(pInitialInventory[es])
if pStorageType[es] == 'Weekly' and [Link](n) % (8736/pTimeStep) == 0:
[Link][sc,n,es].fix(pInitialInventory[es])
if pStorageType[es] == 'Monthly' and [Link](n) % (8736/pTimeStep) == 0:
[Link][sc,n,es].fix(pInitialInventory[es])

SettingUpDataTime = [Link]() - StartTime

StartTime = [Link]()
print('Setting up input data ... ', round(SettingUpDataTime), 's')

Good Optimization Modeling Practices with Pyomo. May 2024 53

 Stochastic Daily Unit Commitment (ix)
def eTotalVCost(mSDUC):
return [Link] == (sum(pScenProb[sc] * pDuration[n] * pENSCost * [Link] [sc,n ] for sc,n in [Link]*mSDUC.n ) +
sum(pScenProb[sc] * pDuration[n] * pLinearVarCost [nr] * [Link][sc,n,nr] for sc,n,nr in [Link]*mSDUC.n*[Link]) +
sum( pDuration[n] * pConstantVarCost[nr] * [Link] [ n,nr] +
pStartUpCost [nr] * [Link] [ n,nr] +
pShutDownCost [nr] * [Link] [ n,nr] for n,nr in mSDUC.n*[Link]) )
[Link] = Constraint(rule=eTotalVCost, doc='total system variable cost [MEUR]')

def eTotalECost(mSDUC):
return [Link] == sum(pScenProb[sc] * pCO2Cost * pCO2EmissionRate[nr] * [Link][sc,n,nr] for sc,n,nr in [Link]*mSDUC.n*[Link])
[Link] = Constraint(rule=eTotalECost, doc='total system emission cost [MEUR]')

def eTotalTCost(mSDUC):
return [Link] + [Link]
[Link] = Objective(rule=eTotalTCost, sense=minimize, doc='total system cost [MEUR]')

GeneratingOFTime = [Link]() - StartTime

StartTime = [Link]()
print('Generating objective function ... ', round(GeneratingOFTime), 's')

#%% constraints
def eOperReserveUp(mSDUC,sc,n):
if pOperReserveUp[sc,n]:
return sum([Link] [sc,n,nr] for nr in [Link]) >= pOperReserveUp[sc,n]
else:
return [Link]
[Link] = Constraint([Link], mSDUC.n, rule=eOperReserveUp, doc='up operating reserve [GW]')

def eOperReserveDw(mSDUC,sc,n):
if pOperReserveDw[sc,n]:
return sum([Link][sc,n,nr] for nr in [Link]) >= pOperReserveDw[sc,n]
else:
return [Link]
[Link] = Constraint([Link], mSDUC.n, rule=eOperReserveDw, doc='down operating reserve [GW]')

def eBalance(mSDUC,sc,n):
return sum([Link][sc,n,g] for g in mSDUC.g) - sum([Link][sc,n,es] for es in [Link]) + [Link][sc,n] == pDemand[sc,n]
[Link] = Constraint([Link], mSDUC.n, rule=eBalance, doc='load generation balance [GW]')

def eESSInventory(mSDUC,sc,n,es):
if [Link](n) == pCycleTimeStep[es]:
return pInitialInventory[es] + sum(pDuration[n2]*(pEnergyInflows[es][sc,n2] - [Link][sc,n2,es] + pEfficiency[es]*[Link][sc,n2,es]) for n2
in list(mSDUC.n2)[[Link](n)-pCycleTimeStep[es]:[Link](n)]) == [Link][sc,n,es] + [Link][sc,n,es]
elif [Link](n) > pCycleTimeStep[es] and [Link](n) % pCycleTimeStep[es] == 0:
return [Link][sc,[Link](n,pCycleTimeStep[es]),es] + sum(pDuration[n2]*(pEnergyInflows[es][sc,n2] - [Link][sc,n2,es] + pEfficiency[es]*[Link][sc,n2,es]) for n2
in list(mSDUC.n2)[[Link](n)-pCycleTimeStep[es]:[Link](n)]) == [Link][sc,n,es] + [Link][sc,n,es]
else:
return [Link]
[Link] = Constraint([Link], mSDUC.n, [Link], rule=eESSInventory, doc='ESS inventory balance [GWh]')

GeneratingRBITime = [Link]() - StartTime

StartTime = [Link]()
print('Generating reserves/balance/inventory ... ', round(GeneratingRBITime), 's') Good Optimization Modeling Practices with Pyomo. May 2024 54
 Stochastic Daily Unit Commitment (x)
#%%
def eMaxOutput2ndBlock(mSDUC,sc,n,nr):
if pOperReserveUp[sc,n] and pMaxPower2ndBlock[nr][sc,n]:
return (mSDUC.vOutput2ndBlock[sc,n,nr] + [Link] [sc,n,nr]) / pMaxPower2ndBlock[nr][sc,n] <= [Link][n,nr]
else:
return [Link]
mSDUC.eMaxOutput2ndBlock = Constraint([Link], mSDUC.n, [Link], rule=eMaxOutput2ndBlock, doc='max output of the second block of a committed unit [p.u.]')

def eMinOutput2ndBlock(mSDUC,sc,n,nr):
if pOperReserveDw[sc,n] and pMaxPower2ndBlock[nr][sc,n]:
return (mSDUC.vOutput2ndBlock[sc,n,nr] + [Link][sc,n,nr]) / pMaxPower2ndBlock[nr][sc,n] >= 0.0
else:
return [Link]
mSDUC.eMinOutput2ndBlock = Constraint([Link], mSDUC.n, [Link], rule=eMinOutput2ndBlock, doc='min output of the second block of a committed unit [p.u.]')

def eTotalOutput(mSDUC,sc,n,nr):
if pMinPower[nr][sc,n] == 0.0:
return [Link][sc,n,nr] == mSDUC.vOutput2ndBlock[sc,n,nr]
else:
return [Link][sc,n,nr] / pMinPower[nr][sc,n] == [Link][n,nr] + mSDUC.vOutput2ndBlock[sc,n,nr] / pMinPower[nr][sc,n]
[Link] = Constraint([Link], mSDUC.n, [Link], rule=eTotalOutput, doc='total output of a unit [GW]')

def eUCStrShut(mSDUC,n,nr):
if n == [Link]():
return [Link][n,nr] - pInitialUC[nr] == [Link][n,nr] - [Link][n,nr]
else:
return [Link][n,nr] - [Link][[Link](n),nr] == [Link][n,nr] - [Link][n,nr]
[Link] = Constraint(mSDUC.n, [Link], rule=eUCStrShut, doc='relation among commitment startup and shutdown')

GeneratingGenConsTime = [Link]() - StartTime

StartTime = [Link]()
print('Generating generation constraints ... ', round(GeneratingGenConsTime), 's')

#%%
def eRampUp(mSDUC,sc,n,t):
if pRampUp[t] and pRampUp[t] < pMaxPower2ndBlock[t][sc,n] and n == [Link]():
return (mSDUC.vOutput2ndBlock[sc,n,t] - max(pInitialOutput[t]-pMinPower[t][sc,n],0.0) + [Link] [sc,n,t]) / pDuration[n] / pRampUp[t] <= [Link][n,t] - [Link][n,t]
elif pRampUp[t] and pRampUp[t] < pMaxPower2ndBlock[t][sc,n]:
return (mSDUC.vOutput2ndBlock[sc,n,t] - mSDUC.vOutput2ndBlock[sc,[Link](n),t] + [Link] [sc,n,t]) / pDuration[n] / pRampUp[t] <= [Link][n,t] - [Link][n,t]
else:
return [Link]
[Link] = Constraint([Link], mSDUC.n, mSDUC.t, rule=eRampUp, doc='maximum ramp up [p.u.]')

def eRampDw(mSDUC,sc,n,t):
if pRampDw[t] and pRampDw[t] < pMaxPower2ndBlock[t][sc,n] and n == [Link]():
return (mSDUC.vOutput2ndBlock[sc,n,t] - max(pInitialOutput[t]-pMinPower[t][sc,n],0.0) - [Link][sc,n,t]) / pDuration[n] / pRampDw[t] >= - pInitialUC[t] + [Link][n,t]
elif pRampDw[t] and pRampDw[t] < pMaxPower2ndBlock[t][sc,n]:
return (mSDUC.vOutput2ndBlock[sc,n,t] - mSDUC.vOutput2ndBlock[sc,[Link](n),t] - [Link][sc,n,t]) / pDuration[n] / pRampDw[t] >= - [Link][[Link](n),t] + [Link][n,t]
else:
return [Link]
[Link] = Constraint([Link], mSDUC.n, mSDUC.t, rule=eRampDw, doc='maximum ramp down [p.u.]')

GeneratingRampsTime = [Link]() - StartTime

StartTime = [Link]()
print('Generating ramps up/down ... ', round(GeneratingRampsTime), 's') Good Optimization Modeling Practices with Pyomo. May 2024 55
 Stochastic Daily Unit Commitment (xi)
#%%
def eMinUpTime(mSDUC,n,t):
if pUpTime[t] > 1 and [Link](n) >= pUpTime[t]:
return sum([Link] [n2,t] for n2 in list(mSDUC.n2)[[Link](n)-pUpTime[t]:[Link](n)]) <= [Link][n,t]
else:
return [Link]
[Link] = Constraint(mSDUC.n, mSDUC.t, rule=eMinUpTime , doc='minimum up time [h]')

def eMinDownTime(mSDUC,n,t):
if pDwTime[t] > 1 and [Link](n) >= pDwTime[t]:
return sum([Link][n2,t] for n2 in list(mSDUC.n2)[[Link](n)-pDwTime[t]:[Link](n)]) <= 1 - [Link][n,t]
else:
return [Link]
[Link] = Constraint(mSDUC.n, mSDUC.t, rule=eMinDownTime, doc='minimum down time [h]')

GeneratingMinUDTime = [Link]() - StartTime

StartTime = [Link]()
print('Generating minimum up/down time ... ', round(GeneratingMinUDTime), 's')

#%% solving the problem

[Link](_path+'/openSDUC_'+CaseName+'.lp', io_options={'symbolic_solver_labels': True}) # create lp-format file
Solver = SolverFactory(SolverName) # select solver
if SolverName == 'gurobi':
[Link]['LogFile' ] = _path+'/openSDUC_'+CaseName+'.log'
#[Link]['IISFile' ] = 'openSDUC_'+CaseName+'.ilp' # should be uncommented to show results of IIS
#[Link]['Method' ] = 2 # barrier method
[Link]['MIPGap' ] = 0.02
[Link]['Threads' ] = int((psutil.cpu_count(logical=True) + psutil.cpu_count(logical=False))/2)
#[Link]['TimeLimit' ] = 7200
#[Link]['IterationLimit'] = 7200000
SolverResults = [Link](mSDUC, tee=True) # tee=True displays the output of the solver
[Link]() # summary of the solver results

#%% fix values of binary variables to get dual variables and solve it again
for n,nr in mSDUC.n*[Link]:
[Link][n,nr].fix(round([Link][n,nr]()))
[Link] [n,nr].fix(round([Link] [n,nr]()))
[Link] [n,nr].fix(round([Link] [n,nr]()))

[Link] = Suffix(direction=[Link])
SolverResults = [Link](mSDUC, tee=True) # tee=True displays the output of the solver
[Link]() # summary of the solver results

SolvingTime = [Link]() - StartTime

StartTime = [Link]()
print('Solving ... ', round(SolvingTime), 's')

print('Objective function value ', [Link]())

Good Optimization Modeling Practices with Pyomo. May 2024 56

 Stochastic Daily Unit Commitment (xii)
#%% inverse index generator to technology and to company
pTechnologyToGen = pGenToTechnology.reset_index().set_index('Technology').set_axis(['Generator'], axis=1, copy=False)[['Generator']]
pTechnologyToGen = [Link][pTechnologyToGen['Generator'].isin(mSDUC.g)]
pTechnology2Gen = pTechnologyToGen.reset_index().set_index(['Technology', 'Generator'])

mSDUC.t2g = Set(initialize=[Link], ordered=False, doc='technology to generator')

#%% outputting the generation operation

OutputResults = [Link](data=[[Link][n,nr]() for n,nr in mSDUC.n*[Link]], index=[Link].from_tuples(list(mSDUC.n*[Link])))

OutputResults.to_frame(name='p.u.').reset_index().pivot_table(index=['level_0'], columns='level_1', values='p.u.').rename_axis(['LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_GenerationCommitment_'+CaseName+'.csv', sep=',')
OutputResults = [Link](data=[[Link] [n,nr]() for n,nr in mSDUC.n*[Link]], index=[Link].from_tuples(list(mSDUC.n*[Link])))
OutputResults.to_frame(name='p.u.').reset_index().pivot_table(index=['level_0'], columns='level_1', values='p.u.').rename_axis(['LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_GenerationStartUp_' +CaseName+'.csv', sep=',')
OutputResults = [Link](data=[[Link] [n,nr]() for n,nr in mSDUC.n*[Link]], index=[Link].from_tuples(list(mSDUC.n*[Link])))
OutputResults.to_frame(name='p.u.').reset_index().pivot_table(index=['level_0'], columns='level_1', values='p.u.').rename_axis(['LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_GenerationShutDown_' +CaseName+'.csv', sep=',')

if sum(pOperReserveUp[sc,n] for sc,n in [Link]*mSDUC.n):

OutputResults = [Link](data=[[Link] [sc,n,nr]()*1e3 for sc,n,nr in [Link]*mSDUC.n*[Link]], index=[Link].from_tuples(list([Link]*mSDUC.n*[Link])))
OutputResults.to_frame(name='MW').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='MW').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_GenerationReserveUp_'+CaseName+'.csv', sep=',')

if sum(pOperReserveDw[sc,n] for sc,n in [Link]*mSDUC.n):

OutputResults = [Link](data=[[Link][sc,n,nr]()*1e3 for sc,n,nr in [Link]*mSDUC.n*[Link]], index=[Link].from_tuples(list([Link]*mSDUC.n*[Link])))
OutputResults.to_frame(name='MW').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='MW').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_GenerationReserveDown_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[[Link][sc,n,g]()*1e3 for sc,n,g in [Link]*mSDUC.n*mSDUC.g], index=[Link].from_tuples(list([Link]*mSDUC.n*mSDUC.g)))

OutputResults.to_frame(name='MW').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='MW').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_GenerationOutput_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[[Link][sc,n]()*1e3 for sc,n in [Link]*mSDUC.n], index=[Link].from_tuples(list([Link]*mSDUC.n)))

OutputResults.to_frame(name='MW').reset_index().pivot_table(index=['level_0','level_1'], values='MW').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_PNS_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[[Link][sc,n]()*pDuration[n] for sc,n in [Link]*mSDUC.n], index=[Link].from_tuples(list([Link]*mSDUC.n)))

OutputResults.to_frame(name='GWh').reset_index().pivot_table(index=['level_0','level_1'], values='GWh').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_ENS_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[([Link][sc,n,g].[Link][sc,n,g]())*1e3 for sc,n,g in [Link]*mSDUC.n*mSDUC.r], index=[Link].from_tuples(list([Link]*mSDUC.n*mSDUC.r)))

OutputResults.to_frame(name='MW').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='MW').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_RESCurtailment_'+CaseName+'.csv', sep=',')

Good Optimization Modeling Practices with Pyomo. May 2024 57

 Stochastic Daily Unit Commitment (xiii)
#%% plot SRMC for all the scenarios
RESCurtailment = [Link][:,:,:]

fig, fg = [Link]()
for r in mSDUC.r:
[Link](range(len([Link]*mSDUC.n)), RESCurtailment[:,:,r], label=r)
[Link](xlabel='Hours', ylabel='MW')
fg.set_ybound(lower=0)
[Link]('RES Curtailment')
fg.tick_params(axis='x', rotation=90)
[Link]()
plt.tight_layout()
#[Link]()
[Link](_path+'/oUC_Plot_RESCurtailment_'+CaseName+'.png', bbox_inches=None)

OutputResults = [Link](data=[[Link][sc,n,g]()*pDuration[n] for sc,n,g in [Link]*mSDUC.n*mSDUC.g], index=[Link].from_tuples(list([Link]*mSDUC.n*mSDUC.g)))

OutputResults.to_frame(name='GWh' ).reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='GWh' ).rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_GenerationEnergy_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[[Link][sc,n,nr]()*pCO2EmissionRate[nr]*1e3 for sc,n,nr in [Link]*mSDUC.n*mSDUC.t], index=[Link].from_tuples(list([Link]*mSDUC.n*mSDUC.t)))

OutputResults.to_frame(name='tCO2').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='tCO2').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_GenerationEmission_'+CaseName+'.csv', sep=',')

#%% outputting the ESS operation

if len([Link]):
OutputResults = [Link](data=[[Link][sc,n,es]()*1e3 for sc,n,es in [Link]*mSDUC.n*[Link]], index=[Link].from_tuples(list([Link]*mSDUC.n*[Link])))
OutputResults.to_frame(name='MW' ).reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='MW' ).rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_ESSChargeOutput_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[sum(OutputResults[sc,n,es] for es in [Link] if (gt,es) in mSDUC.t2g) for sc,n,gt in [Link]*mSDUC.n*[Link] if sum(1 for es in [Link] if (gt,es) in mSDUC.t2g)], index=[Link].from_tuples([(sc,n,gt) for
sc,n,gt in [Link]*mSDUC.n*[Link] if sum(1 for es in [Link] if (gt,es) in mSDUC.t2g)]))
OutputResults.to_frame(name='MW' ).reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='MW' ).rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_TechnologyCharge_'+CaseName+'.csv', sep=',')

TechnologyCharge = [Link][:,:,:]

OutputResults = [Link](data=[[Link][sc,n,es]()*pDuration[n] for sc,n,es in [Link]*mSDUC.n*[Link]], index=[Link].from_tuples(list([Link]*mSDUC.n*[Link])))

OutputResults.to_frame(name='GWh').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='GWh').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_ESSChargeEnergy_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[sum(OutputResults[sc,n,es] for es in [Link] if (gt,es) in mSDUC.t2g) for sc,n,gt in [Link]*mSDUC.n*[Link] if sum(1 for es in [Link] if (gt,es) in mSDUC.t2g)], index=[Link].from_tuples([(sc,n,gt) for
sc,n,gt in [Link]*mSDUC.n*[Link] if sum(1 for es in [Link] if (gt,es) in mSDUC.t2g)]))
OutputResults.to_frame(name='GWh').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='GWh').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_ESSTechnologyEnergy_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[[Link][sc,n,es]() for sc,n,es in [Link]*mSDUC.n*[Link]], index=[Link].from_tuples(list([Link]*mSDUC.n*[Link])))

OutputResults.to_frame(name='GWh').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='GWh', dropna=False).rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_ESSInventory_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[[Link] [sc,n,es]() for sc,n,es in [Link]*mSDUC.n*[Link]], index=[Link].from_tuples(list([Link]*mSDUC.n*[Link])))

OutputResults.to_frame(name='GWh').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='GWh', dropna=False).rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_ESSSpillage_'+CaseName+'.csv', sep=',')

OutputResults = [Link](data=[[Link][sc,n,g]()*1e3 for sc,n,g in [Link]*mSDUC.n*mSDUC.g ], index=[Link].from_tuples(list([Link]*mSDUC.n*mSDUC.g )))

OutputResults = [Link](data=[sum(OutputResults[sc,n,g] for g in mSDUC.g if (gt,g ) in mSDUC.t2g) for sc,n,gt in [Link]*mSDUC.n*[Link] if sum(1 for g in mSDUC.g if (gt,g) in mSDUC.t2g)], index=[Link].from_tuples([(sc,n,gt) for sc,n,gt
in [Link]*mSDUC.n*[Link] if sum(1 for g in mSDUC.g if (gt,g) in mSDUC.t2g)]))
OutputResults.to_frame(name='MW').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='MW').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None], axis=1).to_csv(_path+'/oUC_Result_TechnologyOutput_'+CaseName+'.csv',
sep=',')

TechnologyOutput = [Link][:,:,:]

Good Optimization Modeling Practices with Pyomo. May 2024 58

 Stochastic Daily Unit Commitment (xiv)
for sc in [Link]:
fig, fg = [Link]()
[Link](range(len(mSDUC.n)), [Link][sc,:,:].[Link](len(mSDUC.n),len([Link])).transpose().tolist(), baseline='zero', labels=list([Link]))
[Link] (range(len(mSDUC.n)), -[Link][sc,:,'ESS'], label='ESSCharge', linewidth=0.5, color='b')
[Link] (range(len(mSDUC.n)), pDemand[sc]*1e3, label='Demand' , linewidth=0.5, color='k')
[Link](xlabel='Hours', ylabel='MW')
[Link](sc)
fg.tick_params(axis='x', rotation=90)
[Link]()
plt.tight_layout()
#[Link]()
[Link](_path+'/oUC_Plot_TechnologyOutput_'+sc+'_'+CaseName+'.png', bbox_inches=None)

OutputResults = [Link](data=[[Link][sc,n,g]()*pDuration[n] for sc,n,g in [Link]*mSDUC.n*mSDUC.g], index=[Link].from_tuples(list([Link]*mSDUC.n*mSDUC.g)))

OutputResults = [Link](data=[sum(OutputResults[sc,n,g] for g in mSDUC.g if (gt,g) in mSDUC.t2g) for sc,n,gt in [Link]*mSDUC.n*[Link] if sum(1 for g in mSDUC.g if (gt,g) in mSDUC.t2g)], index=[Link].from_tuples([(sc,n,gt) for sc,n,gt in
[Link]*mSDUC.n*[Link] if sum(1 for g in mSDUC.g if (gt,g) in mSDUC.t2g)]))
OutputResults.to_frame(name='GWh').reset_index().pivot_table(index=['level_0','level_1'], columns='level_2', values='GWh').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None],
axis=1).to_csv(_path+'/oUC_Result_TechnologyEnergy_'+CaseName+'.csv', sep=',')

#%% outputting the SRMC

if SolverName == 'gurobi':
OutputResults = [Link](data=[[Link][[Link][sc,n]]*1e3/pScenProb[sc]/pDuration[n] for sc,n in [Link]*mSDUC.n], index=[Link].from_tuples(list([Link]*mSDUC.n)))
OutputResults.to_frame(name='SRMC').reset_index().pivot_table(index=['level_0','level_1'], values='SRMC').rename_axis(['Scenario','LoadLevel'], axis=0).rename_axis([None], axis=1).to_csv(_path+'/oUC_Result_SRMC_'+CaseName+'.csv', sep=',')

#%% plot SRMC for all the scenarios

SRMC = [Link][:,:]

fig, fg = [Link]()
for sc in [Link]:
[Link](range(len(mSDUC.n)), SRMC[sc], label=sc)
[Link](xlabel='Hours', ylabel='EUR/MWh')
fg.set_ybound(lower=0, upper=100)
[Link]('SRMC')
fg.tick_params(axis='x', rotation=90)
[Link]()
plt.tight_layout()
#[Link]()
[Link](_path+'/oUC_Plot_SRMC_'+CaseName+'.png', bbox_inches=None)

WritingResultsTime = [Link]() - StartTime

StartTime = [Link]()
print('Writing output results ... ', round(WritingResultsTime), 's')
print('Total time ... ', round(ReadingDataTime + GeneratingOFTime + GeneratingRBITime + GeneratingGenConsTime + GeneratingRampsTime + GeneratingMinUDTime + SolvingTime + WritingResultsTime), 's')
print('\n #### Academic research license - for non-commercial use only #### \n')

if __name__ == '__main__':
main()

Good Optimization Modeling Practices with Pyomo. May 2024 59

JuanitoJaimitoJorgito
[Link]

• Simple Unit Commitment with profit maximization

against the day-ahead market prices

Good Optimization Modeling Practices with Pyomo. May 2024 60

 openTEPES
[Link]
[Link]

• Open Generation, Storage, and Transmission Operation

and Expansion Planning Model with RES and ESS
• Web page created with sphinx

The openTEPES code is provided under the

GNU General Public License:
•the code can’t become part of a closed-
source commercial software product
•any future changes and improvements to
the code remain free and open

Disclaimer:
This model is a work in progress and will be
updated accordingly.

Good Optimization Modeling Practices with Pyomo. May 2024 61

 Picture: WWF

Formulating, writing and solving

optimization models

Thank you for your attention

Prof. Andres Ramos
[Link]
[Link]@[Link]
arght@[Link]

Good Optimization Modeling Practices with Pyomo. May 2024 63