def define_model(**kwds):
sense = kwds.pop("sense")
m = block()
m.x = variable_list()
m.Fx = variable_list()
m.piecewise = block_list()
for i in range(4):
m.x.append(variable(lb=0, ub=6))
m.Fx.append(variable())
m.piecewise.append(
piecewise(breakpoints, values,
input=m.x[i],
output=m.Fx[i],
**kwds))
m.obj = objective(expr=sum(m.Fx),
sense=sense)
# fix the answer for testing purposes
m.set_answer = constraint_list()
m.set_answer.append(constraint(m.x[0] == 0.0))
m.set_answer.append(constraint(m.x[1] == 3.0))
m.set_answer.append(constraint(m.x[2] == 5.5))
m.set_answer.append(constraint(m.x[3] == 6.0))
return m
def define_model(**kwds):
sense = kwds.pop("sense")
m = pmo.block()
m.x = pmo.variable_list()
m.Fx = pmo.variable_list()
m.piecewise = pmo.block_list()
for i in range(7):
m.x.append(pmo.variable(lb=-5, ub=4))
m.Fx.append(pmo.variable())
m.piecewise.append(
pmo.piecewise(breakpoints, values,
input=m.x[i],
output=m.Fx[i],
**kwds))
m.obj = pmo.objective(expr=sum(m.Fx),
sense=sense)
# fix the answer for testing purposes
m.set_answer = pmo.constraint_list()
m.set_answer.append(pmo.constraint(m.x[0] == -5.0))
m.set_answer.append(pmo.constraint(m.x[1] == -3.0))
m.set_answer.append(pmo.constraint(m.x[2] == -2.5))
m.set_answer.append(pmo.constraint(m.x[3] == -1.5))
m.set_answer.append(pmo.constraint(m.x[4] == 2.0))
m.set_answer.append(pmo.constraint(m.x[5] == 3.5))
m.set_answer.append(pmo.constraint(m.x[6] == 4.0))
return m
def define_model(**kwds):
sense = kwds.pop("sense")
m = pmo.block()
m.x = pmo.variable_list()
m.Fx = pmo.variable_list()
m.piecewise = pmo.block_list()
for i in range(7):
m.x.append(pmo.variable(lb=-5, ub=4))
m.Fx.append(pmo.variable())
m.piecewise.append(
pmo.piecewise(breakpoints, values,
input=m.x[i],
output=m.Fx[i],
**kwds))
m.obj = pmo.objective(expr=sum(m.Fx),
sense=sense)
# fix the answer for testing purposes
m.set_answer = pmo.constraint_list()
m.set_answer.append(pmo.constraint(m.x[0] == -5.0))
m.set_answer.append(pmo.constraint(m.x[1] == -3.0))
m.set_answer.append(pmo.constraint(m.x[2] == -2.5))
m.set_answer.append(pmo.constraint(m.x[3] == -1.5))
m.set_answer.append(pmo.constraint(m.x[4] == 2.0))
m.set_answer.append(pmo.constraint(m.x[5] == 3.5))
m.set_answer.append(pmo.constraint(m.x[6] == 4.0))
return m
def define_model(**kwds):
sense = kwds.pop("sense")
m = pmo.block()
m.x = pmo.variable_list()
m.Fx = pmo.variable_list()
m.piecewise = pmo.block_list()
for i in range(4):
m.x.append(pmo.variable(lb=0, ub=3))
m.Fx.append(pmo.variable())
m.piecewise.append(
pmo.piecewise(breakpoints, values,
input=m.x[i],
output=m.Fx[i],
**kwds))
m.obj = pmo.objective(expr=sum(m.Fx) + sum(m.x),
sense=sense)
# fix the answer for testing purposes
m.set_answer = pmo.constraint_list()
# Fx1 should solve to 0
m.set_answer.append(pmo.constraint(expr= m.x[0] == 0.5))
m.set_answer.append(pmo.constraint(expr= m.x[1] == 1.0))
m.set_answer.append(pmo.constraint(expr= m.Fx[1] == 0.5))
# Fx[2] should solve to 1
m.set_answer.append(pmo.constraint(expr= m.x[2] == 1.5))
# Fx[3] should solve to 1.5
m.set_answer.append(pmo.constraint(expr= m.x[3] == 2.5))
return m
def get_mock_model_with_priorities(self):
m = pmo.block()
m.x = pmo.variable(domain=Integers)
m.s = range(10)
m.y = pmo.variable_list(pmo.variable(domain=Integers) for _ in m.s)
m.o = pmo.objective(expr=m.x + sum(m.y), sense=minimize)
m.c = pmo.constraint(expr=m.x >= 1)
m.c2 = pmo.constraint(expr=quicksum(m.y[i] for i in m.s) >= 10)
m.priority = pmo.suffix(direction=Suffix.EXPORT, datatype=Suffix.INT)
m.direction = pmo.suffix(direction=Suffix.EXPORT, datatype=Suffix.INT)
m.priority[m.x] = 1
m.priority[m.y] = 2
m.direction[m.y] = BranchDirection.down
m.direction[m.y[-1]] = BranchDirection.up
return m
def solve_pyomo_kernel(self, solver='cplex'):
"""
Solve the problem using the kernel library of the Pyomo package.
Parameters
----------
solver (str, default:'cplex'): defines the solver used to solve the optimization problem
Returns
-------
obj_fun (real): objective function
sol (list): optimal solution of variables
"""
# Model
m = pk.block()
# Sets
m.i = range(self.nvar)
m.j = range(self.ncon)
# Variables
m.x = pk.variable_list()
for _ in m.i:
m.x.append(pk.variable(domain=pk.Reals, lb=0))
# Objective function
m.obj = pk.objective(pe.quicksum(self.c[i] * m.x[i] for i in m.i),
sense=pk.minimize)
# Constraints
m.con = pk.constraint_list()
for j in m.j:
m.con.append(
pk.constraint(body=pe.quicksum(self.A[j][i] * m.x[i]
for i in m.i),
lb=None,
ub=self.b[j]))
# Solve problem
res = pe.SolverFactory(solver).solve(m,
symbolic_solver_labels=True,
tee=True)
print(res['Solver'][0])
# Output
return round(m.obj(), 2), [round(m.x[i].value, 2) for i in m.i]
def test_iter_component_kernel(self):
model = pmo.block()
model.x = pmo.variable_list(pmo.variable(value=0) for _ in [1, 2, 3])
model.z = pmo.variable(value=0)
model.con = pmo.constraint_dict(
(i, pmo.constraint(expr=model.x[i - 1] + model.z == i))
for i in [1, 2, 3])
model.zcon = pmo.constraint(expr=model.z >= model.x[2])
model.param_t = pmo.parameter_tuple(
pmo.parameter(value=36) for _ in [1, 2, 3])
model.param = pmo.parameter(value=42)
self.assertSameComponents(list(iter_component(model.x)), list(model.x))
self.assertSameComponents(list(iter_component(model.z)), [model.z])
self.assertSameComponents(list(iter_component(model.con)),
list(model.con.values()))
self.assertSameComponents(list(iter_component(model.zcon)),
[model.zcon])
self.assertSameComponents(list(iter_component(model.param_t)),
list(model.param_t))
self.assertSameComponents(list(iter_component(model.param)),
[model.param])
# @Variables_single
m.v = pmo.variable(value=1,
lb=1,
ub=4)
# @Variables_single
# @Variables_dict
m.vd = pmo.variable_dict()
for i in m.s:
m.vd[i] = pmo.variable(ub=9)
# @Variables_dict
# @Variables_list
# used 0-based indexing
m.vl = pmo.variable_list()
for j in m.q:
m.vl.append(
pmo.variable(lb=i))
# @Variables_list
# @Constraints_single
m.c = pmo.constraint(
sum(m.vd.values()) <= 9)
# @Constraints_single
# @Constraints_dict
m.cd = pmo.constraint_dict()
for i in m.s:
# using data expressions
d = pmo.expression_list(
pmo.data_expression() for i in range(2))
s = pmo.sos([v1,v2], weights=d)
assert len(s.weights) == 2
d[0].expr = p[0] + 1
d[1].expr = p[0] + p[1]
assert tuple(pmo.value(w) for w in s.weights) == (2, 3)
#
# Example model (discontiguous variable domain)
#
domain = [-1.1, 4.49, 8.1, -30.2, 12.5]
m = pmo.block()
m.z = pmo.variable_list(
pmo.variable(lb=0)
for i in range(len(domain)))
m.y = pmo.variable()
m.o = pmo.objective(m.y, sense=pmo.maximize)
m.c1 = pmo.constraint(
m.y == sum(v*z for v,z in zip(m.z, domain)))
m.c2 = pmo.constraint(
sum(m.z) == 1)
m.s = pmo.sos1(m.z)
def build_staticvariable_list():
"""Build a variable_list of static variables with no
references to external objects so its size can be
computed."""
return variable_list(_staticvariable() for i in range(N))
def build_variable_list():
"""Build a variable_list with no references to external
objects so its size can be computed."""
return variable_list(
variable(domain_type=None, lb=None, ub=None, value=None)
for i in range(N))
import pyomo.kernel as pmo # # Suffixes # # collect dual information when the model is solved b = pmo.block() b.x = pmo.variable() b.c = pmo.constraint(expr=b.x >= 1) b.o = pmo.objective(expr=b.x) b.dual = pmo.suffix(direction=pmo.suffix.IMPORT) # suffixes behave as dictionaries that map # components to values s = pmo.suffix() assert len(s) == 0 v = pmo.variable() s[v] = 2 assert len(s) == 1 assert bool(v in s) == True assert s[v] == 2 # error (a dict / list container is not a component) vlist = pmo.variable_list() s[vlist] = 1
import six
from six import StringIO
class IJunk(IBlock):
__slots__ = ()
class junk(pmo.block):
_ctype = IJunk
class junk_list(pmo.block_list):
__slots__ = ()
_ctype = IJunk
_model = pmo.block()
_model.v = pmo.variable()
_model.V = pmo.variable_list()
_model.V.append(pmo.variable())
_model.V.append(pmo.variable_list())
_model.V[1].append(pmo.variable())
_model.c = pmo.constraint()
_model.C = pmo.constraint_list()
_model.C.append(pmo.constraint())
_model.C.append(pmo.constraint_list())
_model.C[1].append(pmo.constraint())
b_clone = _model.clone()
_model.b = b_clone.clone()
_model.B = pmo.block_list()
_model.B.append(b_clone.clone())
_model.B.append(pmo.block_list())
_model.B[1].append(b_clone.clone())
del b_clone
def build_staticvariable_list():
"""Build a variable_list of static variables with no
references to external objects so its size can be
computed."""
return variable_list(_staticvariable()
for i in range(N))
def build_variable_list():
"""Build a variable_list with no references to external
objects so its size can be computed."""
return variable_list(
variable(domain_type=None, lb=None, ub=None, value=None)
for i in range(N))
def create_optimization_model(self, config):
self.logger.info('Creating optimization model.')
# Consider using context managers
# limit_sell = False
# GET COMPONENTS FROM SYSTEM
if self.system.has_battery:
battery = self.system.get_battery_object()
if self.system.has_external_grid:
supply = self.system.get_external_grid_object()
# STARTING MODEL
m = pk.block()
# Track the default attributes of the model to be aware of which the user adds.
default_attributes = set(m.__dict__.keys())
default_attributes.add('default_attributes')
# SETS
m.periods = range(config['periods'])
m.E_set = []
# VARIABLES
m.E = pk.variable_dict()
if self.system.has_stochastic_generators and not self.system.has_external_grid:
m.E_set.append('stochastic')
m.E['stochastic'] = pk.variable_list()
for t in m.periods:
m.E['stochastic'].append(
pk.variable(domain_type=pk.RealSet,
lb=0,
ub=self.system.stochastic_electrical_gen[t]))
if self.system.has_external_grid:
m.E_set.append('buy')
m.E_set.append('sell')
m.E['buy'] = pk.variable_list()
for _ in m.periods:
m.E['buy'].append(pk.variable(domain=pk.NonNegativeReals))
m.E['sell'] = pk.variable_list()
for _ in m.periods:
m.E['sell'].append(pk.variable(domain=pk.NonNegativeReals))
m.y_grid = pk.variable_list()
for _ in m.periods:
m.y_grid.append(
pk.variable(domain_type=pk.IntegerSet, lb=0, ub=1))
if self.system.has_battery:
m.E_set.append('batt_chrg')
m.E_set.append('batt_dis')
m.E['batt_chrg'] = pk.variable_list()
for _ in m.periods:
# The upper bound are impose in the constraints below
m.E['batt_chrg'].append(
pk.variable(domain_type=pk.RealSet, lb=0))
m.E['batt_dis'] = pk.variable_list()
for _ in m.periods:
m.E['batt_dis'].append(
pk.variable(domain_type=pk.RealSet, lb=0))
m.y_bat = pk.variable_list()
for _ in m.periods:
m.y_bat.append(
pk.variable(domain_type=pk.IntegerSet, lb=0, ub=1))
m.soc = pk.variable_list()
for _ in m.periods:
m.soc.append(
pk.variable(domain_type=pk.RealSet,
lb=battery.soc_lb,
ub=battery.soc_ub))
# Extra soc variable for the last value of soc that should be >= soc_l
m.soc.append(
pk.variable(domain_type=pk.RealSet,
lb=battery.soc_l,
ub=battery.soc_ub))
# PARAMETERS
if self.system.has_external_grid:
m.prices = {
'buy': supply.electricity_purchase_prices.copy(),
'sell': supply.electricity_selling_prices.copy(),
}
# OBJECTIVE FUNCTION
obj_exp = 0
obj_sense = pk.minimize
if self.system.has_external_grid:
obj_exp = quicksum((m.E['buy'][t] * m.prices['buy'][t] for t in m.periods), linear=True) \
- quicksum((m.E['sell'][t] * m.prices['sell'][t] for t in m.periods), linear=True)
m.obj = pk.objective(obj_exp, sense=obj_sense)
# CONSTRAINTS
# Grid constraints
# if limit_sell:
# m.c_limit_sell = pk.constraint(
# lb=0, body=system['selling_ratio']
# * sum(m.E['buy'][t] + system['E_pv'][t] for t in m.periods)
# - sum(m.E['sell'][t] for t in m.periods))
grid_m = 1e5
m.cl_y_buy = pk.constraint_list()
for t in m.periods:
m.cl_y_buy.append(
pk.constraint(body=m.y_grid[t] * grid_m - m.E['buy'][t], lb=0))
m.cl_y_sell = pk.constraint_list()
for t in m.periods:
m.cl_y_sell.append(
pk.constraint(body=(1 - m.y_grid[t]) * grid_m - m.E['sell'][t],
lb=0))
# Balance constraints
energy_balance_exp = [0 for _ in m.periods]
if self.system.has_fix_loads:
for t in m.periods:
energy_balance_exp[t] = -1 * self.system.fix_electrical_load[t]
if self.system.has_external_grid:
for t in m.periods:
energy_balance_exp[
t] = energy_balance_exp[t] + m.E['buy'][t] - m.E['sell'][t]
if self.system.has_battery:
for t in m.periods:
energy_balance_exp[t] = energy_balance_exp[t] + m.E[
'batt_dis'][t] - m.E['batt_chrg'][t]
if self.system.has_stochastic_generators and not self.system.has_external_grid:
for t in m.periods:
energy_balance_exp[
t] = energy_balance_exp[t] + m.E['stochastic'][t]
else:
for t in m.periods:
energy_balance_exp[t] = energy_balance_exp[
t] + self.system.stochastic_electrical_gen[t]
m.cl_balance = pk.constraint_list()
for t in m.periods:
m.cl_balance.append(
pk.constraint(body=energy_balance_exp[t], rhs=0))
# Battery constraints and restrictions
if self.system.has_battery:
m.soc[0].fix(battery.soc_0)
m.cl_soc = pk.constraint_list()
for t in m.periods:
m.cl_soc.append(
pk.constraint(
body=battery.batt_C * (m.soc[t + 1] - m.soc[t]) +
1 / battery.batt_dis_per * m.E['batt_dis'][t] -
battery.batt_chrg_per * m.E['batt_chrg'][t],
rhs=0))
m.cl_y_char = pk.constraint_list()
for t in m.periods:
m.cl_y_char.append(
pk.constraint(body=m.y_bat[t] * battery.batt_chrg_speed -
m.E['batt_chrg'][t],
lb=0))
m.cl_y_dis = pk.constraint_list()
for t in m.periods:
m.cl_y_char.append(
pk.constraint(
body=(1 - m.y_bat[t]) * battery.batt_dis_speed -
m.E['batt_dis'][t],
lb=0))
# FINISHING
# Determine the user defined attributes (written in this source code) by subtracting the defaults one.
all_attributes = set(m.__dict__.keys())
m.user_defined_attributes = list(all_attributes - default_attributes)
self.optimization_model = m
return m
import pyomo.kernel as pmo
#
# List containers
#
vl = pmo.variable_list(
pmo.variable() for i in range(10))
cl = pmo.constraint_list()
for i in range(10):
cl.append(pmo.constraint(vl[-1] == 1))
cl.insert(0, pmo.constraint(vl[0]**2 >= 1))
del cl[0]
#
# Dict containers
#
vd = pmo.variable_dict(
((str(i), pmo.variable()) for i in range(10)))
cd = pmo.constraint_dict(
(i, pmo.constraint(v == 1)) for i,v in vd.items())
cd = pmo.constraint_dict()
for i, v in vd.items():
cd[i] = pmo.constraint(v == 1)
class IJunk(IBlock):
__slots__ = ()
class junk(pmo.block):
_ctype = IJunk
class junk_list(pmo.block_list):
__slots__ = ()
_ctype = IJunk
_model = pmo.block()
_model.v = pmo.variable()
_model.V = pmo.variable_list()
_model.V.append(pmo.variable())
_model.V.append(pmo.variable_list())
_model.V[1].append(pmo.variable())
_model.c = pmo.constraint()
_model.C = pmo.constraint_list()
_model.C.append(pmo.constraint())
_model.C.append(pmo.constraint_list())
_model.C[1].append(pmo.constraint())
b_clone = _model.clone()
_model.b = b_clone.clone()
_model.B = pmo.block_list()
_model.B.append(b_clone.clone())
_model.B.append(pmo.block_list())
_model.B[1].append(b_clone.clone())
del b_clone
m.pl = pmo.parameter_list()
for j in m.q:
m.pl.append(pmo.parameter(j))
# @Parameters_list
# @Variables_single
m.v = pmo.variable(value=1, lb=1, ub=4)
# @Variables_single
# @Variables_dict
m.vd = pmo.variable_dict()
for i in m.s:
m.vd[i] = pmo.variable(ub=9)
# @Variables_dict
# @Variables_list
# used 0-based indexing
m.vl = pmo.variable_list()
for j in m.q:
m.vl.append(pmo.variable(lb=i))
# @Variables_list
# @Constraints_single
m.c = pmo.constraint(sum(m.vd.values()) <= 9)
# @Constraints_single
# @Constraints_dict
m.cd = pmo.constraint_dict()
for i in m.s:
for j in m.q:
m.cd[i,j] = \
pmo.constraint(
body=m.vd[i],
# define a simple optimization model
b = pmo.block()
b.x = pmo.variable()
b.c = pmo.constraint(expr=b.x >= 1)
b.o = pmo.objective(expr=b.x)
# define an optimization model with indexed containers
b = pmo.block()
b.p = pmo.parameter()
b.plist = pmo.parameter_list(pmo.parameter() for i in range(10))
b.pdict = pmo.parameter_dict(
((i, j), pmo.parameter()) for i in range(10) for j in range(10))
b.x = pmo.variable()
b.xlist = pmo.variable_list(pmo.variable() for i in range(10))
b.xdict = pmo.variable_dict(
((i, j), pmo.variable()) for i in range(10) for j in range(10))
b.c = pmo.constraint(b.x >= 1)
b.clist = pmo.constraint_list(
pmo.constraint(b.xlist[i] >= i) for i in range(10))
b.cdict = pmo.constraint_dict(((i, j), pmo.constraint(b.xdict[i, j] >= i * j))
for i in range(10) for j in range(10))
b.o = pmo.objective(b.x + sum(b.xlist) + sum(b.xdict.values()))
#
# Define a custom tiny_block
#
