def __init__(self, xL, xU, yL, yU): assert xL <= xU assert yL <= yU self._model = pmo.block() x = self._model.x = pmo.variable(lb=xL, ub=xU) y = self._model.y = pmo.variable(lb=yL, ub=yU) x2 = self._model.x2 = pmo.variable(lb=-pybnb.inf, ub=pybnb.inf) x2y = self._model.x2y = pmo.variable(lb=-pybnb.inf, ub=pybnb.inf) self._model.x2_c = SquaredEnvelope(x, x2) # Temporarily provide bounds to the x2 variable so # they can be used to build the McCormick # constraints for x2y. After that, they are no # longer needed as they are enforced by the # McCormickEnvelope constraints. x2.bounds = self._model.x2_c.derived_output_bounds() self._model.x2y_c = McCormickEnvelope(x2, y, x2y) x2.bounds = (-pybnb.inf, pybnb.inf) # original objective self._model.f = pmo.expression( (x**4 - 2 * (x**2) * y + 0.5 * (x**2) - x + (y**2) + 0.5)) # convex relaxation self._model.f_convex = pmo.expression( (x**4 - 2 * x2y + 0.5 * (x**2) - x + (y**2) + 0.5)) self._model.objective = pmo.objective(sense=pmo.minimize) self._ipopt = pmo.SolverFactory("ipopt") self._ipopt.options["tol"] = 1e-9 self._last_bound_was_feasible = False # make sure the PyomoProblem initializer is called # after the model is built super(Rosenbrock2D, self).__init__()
def _generate_model(self): self.model = pmo.block() model = self.model model._name = self.description model.a1 = pmo.parameter(value=1.0) model.a2 = pmo.parameter_dict({1: pmo.parameter(value=1.0)}) model.a3 = pmo.parameter(value=1.0) model.a4 = pmo.parameter_dict({1: pmo.parameter(value=1.0)}) model.x = pmo.variable(domain=NonNegativeReals) model.y = pmo.variable(domain=NonNegativeReals) model.z1 = pmo.variable() model.z2 = pmo.variable() model.dummy_expr1 = pmo.expression(model.a1 * model.a2[1]) model.dummy_expr2 = pmo.expression(model.y / model.a3 * model.a4[1]) model.inactive_obj = pmo.objective(model.x + 3.0 * model.y + 1.0 + model.z1 - model.z2) model.inactive_obj.deactivate() model.p = pmo.parameter(value=0.0) model.obj = pmo.objective(model.p + model.inactive_obj) model.c1 = pmo.constraint( model.dummy_expr1 <= pmo.noclone(model.dummy_expr2)) model.c2 = pmo.constraint((2.0, model.x / model.a3 - model.y, 10)) model.c3 = pmo.constraint((0, model.z1 + 1, 10)) model.c4 = pmo.constraint((-10, model.z2 + 1, 0))
def _generate_model(self): self.model = pmo.block() model = self.model model._name = self.description model.a1 = pmo.parameter(value=1.0) model.a2 = pmo.parameter_dict( {1: pmo.parameter(value=1.0)}) model.a3 = pmo.parameter(value=1.0) model.a4 = pmo.parameter_dict( {1: pmo.parameter(value=1.0)}) model.x = pmo.variable(domain=NonNegativeReals) model.y = pmo.variable(domain=NonNegativeReals) model.z1 = pmo.variable() model.z2 = pmo.variable() model.dummy_expr1 = pmo.expression(model.a1*model.a2[1]) model.dummy_expr2 = pmo.expression(model.y/model.a3*model.a4[1]) model.inactive_obj = pmo.objective( model.x + 3.0*model.y + 1.0 + model.z1 - model.z2) model.inactive_obj.deactivate() model.p = pmo.parameter(value=0.0) model.obj = pmo.objective(model.p + model.inactive_obj) model.c1 = pmo.constraint(model.dummy_expr1 <= pmo.noclone(model.dummy_expr2)) model.c2 = pmo.constraint((2.0, model.x/model.a3 - model.y, 10)) model.c3 = pmo.constraint((0, model.z1 + 1, 10)) model.c4 = pmo.constraint((-10, model.z2 + 1, 0))
def test_type_hack(self): for obj in [pmo.variable(), pmo.constraint(), pmo.objective(), pmo.expression(), pmo.parameter(), pmo.suffix(), pmo.sos([]), pmo.block()]: ctype = obj.ctype self.assertIs(obj.__class__._ctype, ctype) self.assertIs(obj.type(), ctype)
def test_type_hack(self): for obj in [ pmo.variable(), pmo.constraint(), pmo.objective(), pmo.expression(), pmo.parameter(), pmo.suffix(), pmo.sos([]), pmo.block() ]: ctype = obj.ctype self.assertIs(obj.__class__._ctype, ctype) self.assertIs(obj.type(), ctype)
def __init__(self, V, W, pyomo_solver="ipopt", pyomo_solver_io="nl", integer_tolerance=1e-4): assert V > 0 assert integer_tolerance > 0 self.V = V self.W = W self._integer_tolerance = integer_tolerance N = range(len(self.W)) m = self.model = pmo.block() x = m.x = pmo.variable_dict() y = m.y = pmo.variable_dict() for i in N: y[i] = pmo.variable(domain=pmo.Binary) for j in N: x[i,j] = pmo.variable(domain=pmo.Binary) m.B = pmo.expression(sum(y.values())) m.objective = pmo.objective(m.B, sense=pmo.minimize) m.B_nontrivial = pmo.constraint(m.B >= 1) m.capacity = pmo.constraint_dict() for i in N: m.capacity[i] = pmo.constraint( sum(x[i,j]*self.W[j] for j in N) <= self.V*y[i]) m.assign_1 = pmo.constraint_dict() for j in N: m.assign_1[j] = pmo.constraint( sum(x[i,j] for i in N) == 1) # relax everything for the bound solves, # since the objective uses a simple heuristic self.true_domain_type = pmo.ComponentMap() for xij in self.model.x.components(): self.true_domain_type[xij] = xij.domain_type xij.domain_type = pmo.RealSet for yi in self.model.y.components(): self.true_domain_type[yi] = yi.domain_type yi.domain_type = pmo.RealSet self.opt = pmo.SolverFactory( pyomo_solver, solver_io=pyomo_solver_io)
def __init__( self, interval_set, params: dict, ): super().__init__() ## Setup self.id = params["name"] self.objective_terms = {} ## Params # Decide if we want load as mutable param - need to use param object # not sure what difference is with raw numpy - may be pyomo mutability - check this # self.load = aml.parameter_dict() self.load = params["load"] # for interval in interval_set: # self.load[interval] = params["load"][interval] ## Expressions self.net_export = aml.expression_dict() for interval in interval_set: self.net_export[interval] = aml.expression(-self.load[interval])
import pyomo.kernel as pmo v = pmo.variable(value=2) # # Expressions # e = pmo.expression() assert e() == None assert e.expr == None e = pmo.expression(expr=v**2 + 1) assert e() == 5 assert pmo.value(e) == 5 assert pmo.value(e.expr) == 5 e = pmo.expression() e.expr = v - 1 assert pmo.value(e) == 1 esub = pmo.expression(expr=v + 1) e = pmo.expression(expr=esub + 1) assert pmo.value(esub) == 3 assert pmo.value(e) == 4 esub.expr = v - 1 assert pmo.value(esub) == 1 assert pmo.value(e) == 2 c = pmo.constraint()
sum(model.var_x[(_worker, _task)] for _task in model.set_tasks) <= 1)) ## Each task is assigned to exactly 1 worker model.con_task = pmo.constraint_list() for _task in model.set_tasks: model.con_task.append( pmo.constraint( sum(model.var_x[(_worker, _task)] for _worker in model.set_workers) == 1)) # Create the objective expr = pmo.expression_list() for _worker in model.set_workers: for _task in model.set_tasks: expr.append( pmo.expression(model.param_cost[(_worker, _task)] * model.var_x[(_worker, _task)])) model.obj = pmo.objective(sum(expr), sense=pmo.minimize) # Solve opt = pmo.SolverFactory('cplex') result = opt.solve(model) # Print the solution if result.solver.termination_condition == TerminationCondition.optimal or result.solver.status == SolverStatus.ok: print('Total cost = ', pmo.value(model.obj), '\n') for i in range(NUM_WORKERS): for j in range(NUM_TASKS): # Test if x[i,j] is 1 (with tolerance for floating point arithmetic). if model.var_x[(i, j)].value > 0.5: print('Worker %d assigned to task %d. Cost = %d' % (i, j, costs[i][j]))
for i in m.s: for j in m.q: m.cd[i,j] = \ pmo.constraint( body=m.vd[i], rhs=j) # @Constraints_dict # @Constraints_list # uses 0-based indexing m.cl = pmo.constraint_list() for j in m.q: m.cl.append(pmo.constraint(lb=-5, body=m.vl[j] - m.v, ub=5)) # @Constraints_list # @Expressions_single m.e = pmo.expression(-m.v) # @Expressions_single # @Expressions_dict m.ed = pmo.expression_dict() for i in m.s: m.ed[i] = \ pmo.expression(-m.vd[i]) # @Expressions_dict # @Expressions_list # uses 0-based indexed m.el = pmo.expression_list() for j in m.q: m.el.append(pmo.expression(-m.vl[j])) # @Expressions_list # @Objectives_single
def __init__(self, p, input=None): super(Widget, self).__init__() self.p = pmo.parameter(value=p) self.input = pmo.expression(expr=input) self.output = pmo.variable() self.c = pmo.constraint(self.output == self.input**2 / self.p)
def __init__( self, interval_set, params: dict, ): super().__init__() ## Setup # self.id = uuid4() self.id = params["name"] self.objective_terms = {} ## Parameters self.maxMW = aml.parameter(params["maxMW"]) self.minMW = aml.parameter(params["minMW"]) self.max_ramp = aml.parameter(params["max_ramp"]) self.marginal_cost = aml.parameter(params["marginal_cost"]) self.initial_commit = aml.parameter(params["initial_commit"]) ## Variables self.output = aml.variable_dict() for interval in interval_set: self.output[interval] = aml.variable(lb=0, ub=self.maxMW) self.commit = aml.variable_dict() for interval in interval_set: self.commit[interval] = aml.variable(domain=aml.Binary) ## Expressions - this is where we define a common interface for model resource elements # Note in Optopy we have to have a generic and dynamic common interface for market products, different time indices, etc. # Will just use net_export as an interface for now self.net_export = aml.expression_dict() for interval in interval_set: self.net_export[interval] = aml.expression(expr=self.output) ## Constraints # Can express constraints abstractly (lhs, rhs, body, ub, lb, etc.) or with interpreted syntax - see below self.con_output_commit_upper_bound = aml.constraint_dict() for interval in interval_set: # body_expr = self.output[interval] - self.commit[interval] * self.maxMW # self.con_output_commit_upper_bound[interval] = aml.constraint(body=body_expr, ub=0) self.con_output_commit_upper_bound[interval] = aml.constraint( self.output[interval] - self.commit[interval] * self.maxMW <= 0) self.con_output_commit_lower_bound = aml.constraint_dict() for interval in interval_set: # body_expr = self.commit[interval] * self.minMW - self.output[interval] # self.con_output_commit_lower_bound[interval] = aml.constraint(body=body_expr, ub=0) self.con_output_commit_lower_bound[interval] = aml.constraint( self.commit[interval] * self.minMW - self.output[interval] <= 0) # todo Add constraints/costs for ramping, min up, min down, startup/shutdown costs, etc. ## Objective Terms # Unclear whether this expression object needs to be added to block/model - may be enough just to have it in the objective self.interval_cost = aml.expression_dict() for interval in interval_set: self.interval_cost[interval] = aml.expression( self.marginal_cost * self.output[interval]) self.objective_terms["total_cost"] = sum(self.interval_cost[interval] for interval in interval_set)
import pyomo.kernel as pmo v = pmo.variable(value=2) # # Expressions # e = pmo.expression() assert e() == None assert e.expr == None e = pmo.expression(expr= v**2 + 1) assert e() == 5 assert pmo.value(e) == 5 assert pmo.value(e.expr) == 5 e = pmo.expression() e.expr = v - 1 assert pmo.value(e) == 1 esub = pmo.expression(expr= v + 1) e = pmo.expression(expr= esub + 1) assert pmo.value(esub) == 3 assert pmo.value(e) == 4 esub.expr = v - 1 assert pmo.value(esub) == 1 assert pmo.value(e) == 2 c = pmo.constraint()
# @Constraints_dict # @Constraints_list # uses 0-based indexing m.cl = pmo.constraint_list() for j in m.q: m.cl.append( pmo.constraint( lb=-5, body=m.vl[j]-m.v, ub=5)) # @Constraints_list # @Expressions_single m.e = pmo.expression(-m.v) # @Expressions_single # @Expressions_dict m.ed = pmo.expression_dict() for i in m.s: m.ed[i] = \ pmo.expression(-m.vd[i]) # @Expressions_dict # @Expressions_list # uses 0-based indexed m.el = pmo.expression_list() for j in m.q: m.el.append( pmo.expression(-m.vl[j])) # @Expressions_list