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(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 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 #