def MeetShortage_rule(model): lt_q = pyo.sum_product(model.LT_QF, model.LT_ACTION) mt_q = pyo.quicksum(model.LT_QF[i] * model.LT_ACTION[i] * model.MT_EXP[i] for i in model.LT) st_q = pyo.quicksum(model.ST_Q[k] for k in model.ST) tot_q = lt_q + mt_q + st_q return tot_q >= model.SHORTAGE_Q['SH']
def test_quicksum(self): m = ConcreteModel() m.y = Var(domain=Binary) m.c = Constraint(expr=quicksum([m.y, m.y], linear=True) == 1) lbl = NumericLabeler('x') smap = SymbolMap(lbl) tc = StorageTreeChecker(m) self.assertEqual(("x1 + x1", False), expression_to_string(m.c.body, tc, smap=smap)) m.x = Var() m.c2 = Constraint(expr=quicksum([m.x, m.y], linear=True) == 1) self.assertEqual(("x2 + x1", False), expression_to_string(m.c2.body, tc, smap=smap)) m.y.fix(1) lbl = NumericLabeler('x') smap = SymbolMap(lbl) tc = StorageTreeChecker(m) self.assertEqual(("1 + 1", False), expression_to_string(m.c.body, tc, smap=smap)) m.x = Var() m.c2 = Constraint(expr=quicksum([m.x, m.y], linear=True) == 1) self.assertEqual(("x1 + 1", False), expression_to_string(m.c2.body, tc, smap=smap))
def minimumDownTime2(pyM, loc, compName, p, t): downTimeMin = getattr(compDict[compName], 'downTimeMin') if t >= downTimeMin: return opVarBin[loc, compName, p, t] <= 1 -pyomo.quicksum(opVarStopBin[loc, compName, p, t_down] for t_down in range(t-downTimeMin+1, t)) else: return opVarBin[loc, compName, p, t] <= 1 -pyomo.quicksum(opVarStopBin[loc, compName, p, t_down] for t_down in range(0, t)) \ - pyomo.quicksum(opVarStopBin[loc, compName, p, t_down] for t_down in range(numberOfTimeSteps-(downTimeMin-t), numberOfTimeSteps))
def test_convex_relaxation_with_quadratic_only(): m = pe.ConcreteModel() m.I = range(10) m.x = pe.Var(m.I) m.obj = pe.Objective(expr=pe.quicksum(m.x[i]*m.x[i] for i in m.I)) m.c0 = pe.Constraint(expr=pe.quicksum(2 * m.x[i] * m.x[i] for i in m.I) >= 0) dag = problem_from_pyomo_model(m) relaxation = _convex_relaxation(dag) relaxed = relaxation.relax(dag) assert relaxed.objective # original constraint + 10 for disaggregated squares assert len(relaxed.constraints) == 1 + 10 objective = relaxed.objective constraint = relaxed.constraints[0] assert isinstance(objective.root_expr, LinearExpression) assert len(objective.root_expr.children) == 10 for constraint in relaxed.constraints[:-1]: assert isinstance(constraint.root_expr, SumExpression) children = constraint.root_expr.children assert len(children) == 2 assert isinstance(children[0], LinearExpression) assert isinstance(children[1], QuadraticExpression) constraint = relaxed.constraints[-1] assert len(constraint.root_expr.children) == 10 assert isinstance(constraint.root_expr, LinearExpression)
def test_linear_relaxation_with_quadratic_and_linear(): m = pe.ConcreteModel() m.I = range(10) m.x = pe.Var(m.I, bounds=(0, 1)) m.obj = pe.Objective( expr=pe.quicksum(m.x[i]*m.x[i] for i in m.I) + pe.quicksum(m.x[i] for i in m.I) ) m.c0 = pe.Constraint( expr=pe.quicksum(2 * m.x[i] * m.x[i] for i in m.I) + pe.quicksum(m.x[i] for i in m.I) >= 0 ) dag = problem_from_pyomo_model(m) relaxation = _linear_relaxation(dag) relaxed = relaxation.relax(dag) print_problem(relaxed) assert relaxed.objective # 1 objective, 1 c0, 4 * 10 x^2 (3 mccormick, 1 midpoint) assert len(relaxed.constraints) == 1 + 1 + 4*10 objective = relaxed.objective constraint = relaxed.constraint('c0') assert isinstance(objective.root_expr, LinearExpression) assert isinstance(constraint.root_expr, SumExpression) # Root is only objvar assert len(objective.root_expr.children) == 1 c0, c1 = constraint.root_expr.children assert isinstance(c0, LinearExpression) assert isinstance(c1, LinearExpression) assert len(c0.children) == 10 assert len(c1.children) == 10
def minimumUpTime2(pyM, loc, compName, p, t): upTimeMin = getattr(compDict[compName], 'upTimeMin') if t >= upTimeMin: return opVarBin[loc, compName, p, t] >= pyomo.quicksum(opVarStartBin[loc, compName, p, t_up] for t_up in range(t-upTimeMin+1, t)) else: return opVarBin[loc, compName, p, t] >= pyomo.quicksum(opVarStartBin[loc, compName, p, t_up] for t_up in range(0, t)) \ + pyomo.quicksum(opVarStartBin[loc, compName, p, t_up] for t_up in range(numberOfTimeSteps-(upTimeMin-t), numberOfTimeSteps))
def rule(x, compute_values=False): if compute_values: return (quicksum(value(index_coef_dict[i]) * x[i] for i in x) + value(constant)) else: return quicksum(index_coef_dict[i] * x[i] for i in x) + constant
def MeetShortage_rule(model): lt_q = model.LT_ACTION['RETRO'] exp_vop_q = pyo.quicksum(model.EXP_VOP_ACTION[i] * model.LT_EXP_PERMIT_ACTION[i] for i in model.LT_EXP) st_q = pyo.quicksum(model.ST_ACTION[i] for i in model.ST) short_q = pyo.quicksum(model.SHORT_ACTION[i] for i in model.SHORT_ACTION) return lt_q + st_q + exp_vop_q + short_q >= model.SHORTAGE_Q['SH']
def ComputeSecondStageCost_rule(model): expansion_cost = pyo.quicksum(model.EXP_ACTION[i] * model.LT_EXP_COST[i] for i in model.LT_EXP) baseline_op_cost = pyo.quicksum(model.EXP_BOP_ACTION[i] * data['LT_EXP'][i]['baseline_op_cost'] for i in model.LT_EXP) return expansion_cost + baseline_op_cost
def ComputeThirdStageCost_rule(model): st_actions = pyo.sum_product(model.C_ST, model.ST_ACTION) short_cost = pyo.quicksum(model.SHORT_ACTION[i] * model.SHORT_COST[i] for i in model.SHORT_ACTION) exp_op_cost = pyo.quicksum(model.EXP_VOP_ACTION[i] * data['LT_EXP'][i]['variable_op_cost'] for i in model.LT_EXP) return st_actions + short_cost + exp_op_cost
def test_fixed_linear_expr(self): # Note that this checks both that a fixed variable is fixed, and # that the resulting model type is correctly classified (in this # case, fixing a binary makes this an LP) m = ConcreteModel() m.y = Var(within=Binary) m.y.fix(0) m.x = Var(bounds=(0,None)) m.c1 = Constraint(expr=quicksum([m.y, m.y], linear=True) >= 0) m.c2 = Constraint(expr=quicksum([m.x, m.y], linear=True) == 1) m.obj = Objective(expr=m.x) self._check_baseline(m)
def Objective_mls(mod): ''' multivariate response least squares objective ''' M = mod.M P = mod.P T = mod.T return (pyo.quicksum(mod.Q[m][p1, p2] * mod.beta[m, p1] * mod.beta[m, p2] for m in range(M) for p1 in range(P) for p2 in range(P)) + pyo.quicksum(mod.R[m][p] * mod.beta[m, p] for m in range(M) for p in range(P)) + pyo.quicksum(mod.C))
def Objective_mls_shrinkl1(mod): M = mod.M P = mod.P T = mod.T return (pyo.quicksum(mod.Q[m][p1, p2] * mod.beta[m, p1] * mod.beta[m, p2] for m in range(M) for p1 in range(P) for p2 in range(P)) + pyo.quicksum(mod.R[m][p] * mod.beta[m, p] for m in range(M) for p in range(P)) + pyo.quicksum(mod.C) + pyo.quicksum(mod.param_gamma * (mod.beta_tilde[m, p, 0] + mod.beta_tilde[m, p, 1]) for p in range(P) for m in range(M)))
def test_sum2(self): model = ConcreteModel() model.A = Set(initialize=[1,2,3], doc='set A') model.x = Var(model.A) expr = quicksum(model.x[i] for i in model.x) baseline = "x[1] + x[2] + x[3]" self.assertEqual( str(expr), baseline )
def conv_rule(model, scenario_name, var_name): return model.x[var_name] \ + model.slack_plus[scenario_name, var_name] \ - model.slack_minus[scenario_name, var_name] \ == pyo.quicksum(model.conv[scenario_name, ix] * points[scenario_name][ix][var_name] for ix in range(len(points[scenario_name])))
def Portfolio(): m = pe.ConcreteModel() m.cons = pe.ConstraintList() N = 5 index = list(range(N)) mean = [0.1, 0.3, 0.5, 0.7, 0.4] m.x = pe.Var(index, bounds=(0, 1)) m.z = pe.Var(within=pe.PositiveReals) m.U = ro.UncSet() m.r = ro.UncParam(index, uncset=m.U, nominal=mean) r = m.r expr = 0 for i in index: expr += (m.r[i] - mean[i])**2 m.U.cons = pe.Constraint(expr=expr <= 0.0005) m.Elib = ro.uncset.EllipsoidalSet(mean, [[0.0005, 0, 0, 0, 0], [0, 0.0005, 0, 0, 0], [0, 0, 0.0005, 0, 0], [0, 0, 0, 0.0005, 0], [0, 0, 0, 0, 0.0005]]) P = [[1, 1, 0, 0, 0], [-1, 1, 0, 0, 0], [1, -1, 0, 0, 0], [-1, -1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, -1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, -1, 0], [0, 0, 0, 0, 1], [0, 0, 0, 0, -1]] rhs = [0.001 + mean[0] + mean[1], 0.001 - mean[0] + mean[1], 0.001 + mean[0] - mean[1], 0.001 - mean[0] - mean[1], 0.001 + mean[2], 0.001 - mean[2], 0.001 + mean[3], 0.001 - mean[3], 0.001 + mean[4], 0.001 - mean[4]] m.Plib = ro.uncset.PolyhedralSet(P, rhs) m.P = ro.UncSet() m.P.cons = pe.ConstraintList() for i, row in enumerate(P): m.P.cons.add(expr=pe.quicksum(row[j]*m.r[j] for j in m.r) <= rhs[i]) m.Obj = pe.Objective(expr=m.z, sense=pe.maximize) # x0 = m.x[0] # expr = x0*3 expr = sum([m.x[i] for i in index]) == 1 m.cons.add(expr) m.cons.add(sum([r[i]*m.x[i] for i in index]) >= m.z) return m
def _extract_objective(self, mip): ''' Extract the original part of the provided MIP's objective function (no dual or prox terms), and create a copy containing the QP variables in place of the MIP variables. Args: mip (Pyomo ConcreteModel): MIP model for a scenario or bundle. Returns: obj (Pyomo Objective): objective function extracted from the MIP new (Pyomo Expression): expression from the MIP model objective with the MIP variables replaced by QP variables. Does not inculde dual or prox terms. Notes: Acts on either a single-scenario model or a bundle ''' mip_to_qp = mip._mpisppy_data.mip_to_qp obj = find_active_objective(mip) repn = generate_standard_repn(obj.expr, quadratic=True) if len(repn.nonlinear_vars) > 0: raise ValueError("FWPH does not support models with nonlinear objective functions") linear_vars = [mip_to_qp[id(var)] for var in repn.linear_vars] new = LinearExpression( constant=repn.constant, linear_coefs=repn.linear_coefs, linear_vars=linear_vars ) if repn.quadratic_vars: quadratic_vars = ( (mip_to_qp[id(x)], mip_to_qp[id(y)]) for x,y in repn.quadratic_vars ) new += pyo.quicksum( (coef*x*y for coef,(x,y) in zip(repn.quadratic_coefs, quadratic_vars)) ) return obj, new
def distribution_system_pumping_power_rule( problem, time_step ): # Distributed Secondary Pumping if distributed_secondary_pumping: rule = ( problem.distribution_system_total_power[time_step] == py.quicksum( (1 / self.parameters.distribution_system["pump efficiency secondary pump [-]"]) * self.parameters.physics["water density [kg/m^3]"] * self.parameters.physics["gravitational acceleration [m^2/s]"] * ds_head_differences_time_array[str(time_step)][building_id] * problem.ets_flows_var[time_step, building_id] for building_id in problem.building_ids ) ) return rule # Central Secondary Pumping else: rule = ( problem.distribution_system_total_power[time_step] == ( (1 / self.parameters.distribution_system["pump efficiency secondary pump [-]"]) * self.parameters.physics["water density [kg/m^3]"] * self.parameters.physics["gravitational acceleration [m^2/s]"] * ds_head_differences_time_array[str(time_step)].max() * problem.total_flow_demand[time_step] ) ) return rule
def __prevent_excessive_township_supply_constraint(self): """ Prevent excessive supply from warehouses to townships, especially during profit maximisation. """ for t in self.model.T: self.model.prevent_excessive_township_supply_constraint.add( pyo.quicksum(self.model.x_assign[w, t] for w in self.model.W) <= self.model.t_demand[t])
def __township_demand_fulfillment_constraint(self): """ All township demands must be fulfilled. """ for t in self.model.T: self.model.township_demand_fulfillment_constraint.add( pyo.quicksum(self.model.x_assign[w, t] for w in self.model.W) >= self.model.t_demand[t])
def __warehouse_supply_constraint(self): """ Warehouse supply to townships must not exceed warehouse's capacity (volume). """ for w in self.model.W: self.model.warehouse_supply_constraint.add( pyo.quicksum(self.model.x_assign[w, t] for t in self.model.T) <= self.model.w_volume[w])
def scenario_creator_callback(self, scenario_name, **kwargs): ## fist, get the model out model = self._scenario_tree_instance_factory.construct_scenario_instance( scenario_name, self._pysp_scenario_tree) tree_scenario = self._pysp_scenario_tree.get_scenario(scenario_name) non_leaf_nodes = tree_scenario.node_list[:-1] for node in non_leaf_nodes: if node.is_leaf_node(): raise Exception("Unexpected leaf node") node._mpisppy_cost_expression = _get_cost_expression( model, node._cost_variable) node._mpisppy_nonant_list = _get_nonant_list(model, node) node._mpisppy_nonant_ef_suppl_list = _get_derived_nonant_list( model, node) ## add the things mpisppy expects to the model model._mpisppy_probability = tree_scenario.probability model._mpisppy_node_list = [ mpisppyScenarioNode( name=node._mpisppy_name, cond_prob=node.conditional_probability, stage=node._mpisppy_stage, cost_expression=node._mpisppy_cost_expression, scen_name_list=None, nonant_list=node._mpisppy_nonant_list, scen_model=None, nonant_ef_suppl_list=node._mpisppy_nonant_ef_suppl_list, parent_name=node._mpisppy_parent_name, ) for node in non_leaf_nodes ] for _ in model.component_data_objects(pyo.Objective, active=True, descend_into=True): break else: # no break print( "Provided model has no objective; using PySP auto-generated objective" ) # attach PySP objective leaf_node = tree_scenario.node_list[-1] leaf_node._mpisppy_cost_expression = _get_cost_expression( model, leaf_node._cost_variable) if hasattr(model, "_PySPModel_objective"): raise RuntimeError( "provided model has attribute _PySPModel_objective") model._PySPModel_objective = pyo.Objective(expr=\ pyo.quicksum(node._mpisppy_cost_expression for node in tree_scenario.node_list)) return model
def test_uncparam_has_no_uncset(self): m = pe.ConcreteModel() m.w = ro.UncParam(range(3), nominal=(1, 2, 3)) m.x = pe.Var(range(3)) expr = pe.quicksum(m.w[i] * m.x[i] for i in range(3)) m.cons = pe.Constraint(expr=expr <= 5) m.obj = pe.Objective(expr=m.x[0], sense=pe.maximize) solver = pe.SolverFactory('romodel.reformulation') self.assertRaises(AssertionError, lambda: solver.solve(m))
def __warehouse_selection_constraint(self): """ Warehouse selection constraint to apply fixed monthly cost if any supply is provided from a warehouse. """ for w in self.model.W: self.model.warehouse_selection_constraint.add( pyo.quicksum( self.model.x_assign[w, t] for t in self.model.T) <= 9_999_999 * self.model.x[w])
def test_quicksum_integer_var_fixed(self): m = ConcreteModel() m.x = Var() m.y = Var(domain=Binary) m.c = Constraint(expr=quicksum([m.y, m.y], linear=True) == 1) m.o = Objective(expr=m.x ** 2) m.y.fix(1) outs = StringIO() m.write(outs, format='gams') self.assertIn("USING nlp", outs.getvalue())
def e_negentropy(model): """ Calculation of the negative Shannon entropy for minimization problem Parameters ---------- model : InvPBaseModel """ return quicksum(model.PEST[n] * log(model.PEST[n]) for n in model.NZPSET)
def objective_cost_minimum( problem ): rule = ( py.quicksum( ( problem.costs[time_step] ) for time_step in problem.time_set ) ) return rule
def ComputeFirstStageCost_rule(model): lt_actions = pyo.sum_product(model.C_LT, model.LT_ACTION) lt_exp_actions = pyo.sum_product(model.LT_EXP_ACTION, model.LT_EXP_COST) lt_exp_permit_action = pyo.quicksum(model.LT_EXP_PERMIT_ACTION[i] * model.LT_EXP_PERMIT_COST[i] for i in model.LT_EXP) return lt_actions + lt_exp_actions + lt_exp_permit_action
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 build_scenario_model(fname, scenario_ix): ''' Multiple threads could be parsing the same file at the same time but they're all read-only, should this should not present any problems (famous last words) ''' data = parse(fname, scenario_ix=scenario_ix) num_nodes = data['N'] adj = data['A'] # Adjacency matrix edges = data['el'] # Edge list c = data['c'] # First-stage cost matrix (per edge) d = data['d'] # Second-stage cost matrix (per edge) u = data['u'] # Capacity of each arc b = data['b'] # Demand of each node p = data['p'] # Probability of scenario model = pyo.ConcreteModel() model.x = pyo.Var(edges, domain=pyo.Binary) # First stage vars model.y = pyo.Var(edges, domain=pyo.NonNegativeReals) # Second stage vars model.edges = edges model.PySP_prob = p ''' Objective ''' model.FirstStageCost = pyo.quicksum(c[e] * model.x[e] for e in edges) model.SecondStageCost = pyo.quicksum(d[e] * model.y[e] for e in edges) obj_expr = model.FirstStageCost + model.SecondStageCost model.MinCost = pyo.Objective(expr=obj_expr, sense=pyo.minimize) ''' Variable upper bound constraints on each edge ''' model.vubs = pyo.ConstraintList() for e in edges: expr = model.y[e] - u[e] * model.x[e] model.vubs.add(expr <= 0) ''' Flow balance constraints for each node ''' model.bals = pyo.ConstraintList() for i in range(num_nodes): in_nbs = np.where(adj[:, i] > 0)[0] out_nbs = np.where(adj[i, :] > 0)[0] lhs = pyo.quicksum(model.y[i,j] for j in out_nbs) - \ pyo.quicksum(model.y[j,i] for j in in_nbs) model.bals.add(lhs == b[i]) return model