def obj_rule(_model): return ( pyo.summation(_model.f, _model.y) # cost of opening facilities + pyo.summation( _model.t, _model.x) # cost of moving units from facilities to clients )
def model(self): m = pyo.ConcreteModel() m.fs = fs = pyo.Block() fs.input = pyo.Var(['a', 'b'], within=pyo.UnitInterval, initialize=0.5) fs.output = pyo.Var(['c', 'd'], within=pyo.UnitInterval, initialize=0.5) fs.slack = pyo.Var(['ab_slack', 'cd_slack'], bounds=(0, 0), initialize=0.0) fs.slack_penalty = pyo.Param(default=1000., mutable=True, within=pyo.PositiveReals) fs.ab_constr = pyo.Constraint( expr=(fs.output['c'] + fs.slack['ab_slack'] == 2 * fs.input['a'])) fs.cd_constr = pyo.Constraint( expr=(fs.output['d'] + fs.slack['cd_slack'] == 3 * fs.input['b'])) fs.performance = pyo.Expression(expr=pyo.summation(fs.output)) m.objective = pyo.Objective( expr=m.fs.performance - m.fs.slack_penalty * pyo.summation(m.fs.slack), sense=pyo.maximize) return m
def _build_model(self): Model._build_model(self) # Constraint: sum(x forage) [<= >=] 20% self._diet.p_forage = pyo.Param(self._diet.s_var_set, initialize=self.data.d_forage) self._diet.p_rhs_forage_ge = pyo.Param(within=pyo.Any, initialize=0.2) self._diet.p_rhs_forage_le = pyo.Param(within=pyo.Any, initialize=0.2) self._diet.c_forage_ge = pyo.Constraint(expr=pyo.summation( self._diet.p_forage, self._diet.v_x) >= self._diet.p_rhs_forage_ge) self._diet.c_forage_le = pyo.Constraint(expr=pyo.summation( self._diet.p_forage, self._diet.v_x) <= self._diet.p_rhs_forage_le) if self.parameters.e_forage_sense == "G": self._diet.c_forage_ge.activate() self._diet.c_forage_le.deactivate() elif self.parameters.e_forage_sense == "L": self._diet.c_forage_ge.deactivate() self._diet.c_forage_le.activate() else: self._diet.c_forage_ge.activate() self._diet.c_forage_le.deactivate() # Constraint: sum(x lca) <= LCA_rhs self._diet.p_lca = pyo.Param(self._diet.s_var_set, within=pyo.Any, mutable=True) self._diet.p_rhs_lca = pyo.Param(within=pyo.Any, mutable=True) self._diet.c_lca = pyo.Constraint(expr=pyo.summation( self._diet.p_lca, self._diet.v_x) <= self._diet.p_rhs_lca)
def rule(model): scaling = 0.2 affinity = np.outer(c.AFFINITY_COGNITIVE, self.task_cognitive_load) # TODO(cathywu) replace this code when "simple slicing" is clarified zeros1 = np.zeros((1, self.num_tasks)) zeros2 = np.zeros((2, self.num_tasks)) zeros3 = np.zeros((3, self.num_tasks)) total = summation(affinity, model.A) total += summation(affinity, model.A2) total += summation(affinity, model.A3) total += summation(affinity, model.A4) total += summation(np.vstack((affinity[1:, :], zeros1)), model.A2) total += summation(np.vstack((affinity[1:, :], zeros1)), model.A3) total += summation(np.vstack((affinity[1:, :], zeros1)), model.A4) total += summation(np.vstack((affinity[2:, :], zeros2)), model.A3) total += summation(np.vstack((affinity[2:, :], zeros2)), model.A4) total += summation(np.vstack((affinity[3:, :], zeros3)), model.A4) total *= scaling return model.Affinity_cognitive_total == total
def demand_rule(model,r,f,b,t): vp=pe.summation(model.Vposition, index = [(p, r, f, b, t) for p in model.nonfix_pilots]) tp=pe.summation(model.Tposition, index = [(p, r, f, b, t) for p in model.trainer_pilots]) traineep= pe.summation(model.Trainee_po, index = [(p, r, f, b, t) for p in model.fleet_pilots]) vfixp= pe.summation(model.Vfix_position, index = [(p, r, f, b, t) for p in model.fix_pilots]) curr_fixed = fixed_df[(fixed_df.Rank==r)&(fixed_df.Cur_Fleet==f)&(fixed_df.Current_Base==b)]['Crew_ID'].values pilot = len(curr_fixed) nonfix_pilot = pe.summation(model.Y, index = [(p, r, f, b, t) for p in model.nonfix_pilots]) rhs = pilot + nonfix_pilot - vp - tp - vfixp - traineep + model.shortage[r,f,b,t] - model.surplus[r,f,b,t] demand = get_demand(r,f,b,t) return rhs == demand
def Objective_fn(m): # Link demand / value not yet implemented fn = summation(m.nodeValueDB, m.nodeDeliveryDB) \ - 10 * summation(m.floodStorage) \ - 5 * summation(m.nodeSpill) \ # - 1 * summation(m.emptyStorage) # - 1000 * summation(m.virtualPrecipGain) \ fn_debug_gain = -1000 * summation(m.debugGain) if debug_gain else 0 fn_debug_loss = -1000 * summation(m.debugLoss) if debug_loss else 0 return fn + fn_debug_gain + fn_debug_loss
def QuadraticObjective(model): Expr = pyo.summation(model.Mu, model.x) for i in model.N: Expr += model.Sigma[i, i] * model.x[i]**2 for j in range(i+1, len(model.N)): Expr += 2 * model.Sigma[i, j] * model.x[i] * model.x[j] return Expr
def run(): model = pyo.ConcreteModel() #Parameter and Sets model.T = pyo.Param(initialize=10) model.M = pyo.Param(initialize=4) model.LimProd = pyo.Param(initialize=10) model.setT = pyo.RangeSet(1, model.T) model.setM = pyo.RangeSet(1, model.M) #variables model.x = pyo.Var(model.setM, model.setT, within=pyo.Integers) #obj function model.obj = pyo.Objective(expr=pyo.summation(model.x), sense=pyo.maximize) #constraints model.C1 = pyo.Constraint(model.setT, rule=firstRule) model.C2 = pyo.Constraint(range(3, model.T + 1), rule=secondRule) model.C3 = pyo.Constraint(model.setT, rule=thirdRule) model.C4 = pyo.Constraint(range(2, model.T + 1), rule=fourthRule) model.C5 = pyo.Constraint(model.setM, model.setT, rule=fifthRule) #solve opt = SolverFactory('gurobi') opt.options['MIPgap'] = 0 opt.options['TimeLimit'] = 10 results = opt.solve(model, tee=True) print(pyo.value(model.obj))
def create_and_solve_simple_model_with_battery(a, d, c_u, q_u, P_max): model = pyo.ConcreteModel(name="with battery") model.productors_index = range(len(a)) model.q = pyo.Var(model.productors_index, domain=pyo.NonNegativeReals) model.u = pyo.Var(domain=pyo.NonNegativeReals) obj_func = lambda model : (pyo.summation(a, model.q) + c_u*model.u) def equality(model, d): return pyo.summation(model.q) + model.u - d == 0 def prod_constraint(model, i): return model.q[i] <= P_max[i] def battery_constraint(model): return model.u <= q_u model.balance_constraint = pyo.Constraint(rule=lambda model : equality(model, d)) model.production_constraint = pyo.Constraint(model.productors_index, rule=prod_constraint) model.battery = pyo.Constraint(rule=battery_constraint) model.obj = pyo.Objective(rule=obj_func) # Export and import floating point data model.dual = pyo.Suffix(direction=pyo.Suffix.IMPORT_EXPORT) solver = pyo.SolverFactory('gurobi') solver.solve(model, tee=True) results = [pyo.value(model.q[i]) for i in model.productors_index] return model
def distribute_clusters(n, n_clusters, focus_weights=None, solver_name=None): if solver_name is None: solver_name = snakemake.config['solving']['solver']['name'] L = (n.loads_t.p_set.mean().groupby(n.loads.bus).sum().groupby( [n.buses.country, n.buses.sub_network]).sum().pipe(normed)) N = n.buses.groupby(['country', 'sub_network']).size() assert n_clusters >= len(N) and n_clusters <= N.sum(), \ "Number of clusters must be {} <= n_clusters <= {} for this selection of countries.".format(len(N), N.sum()) if focus_weights is not None: total_focus = sum(list(focus_weights.values())) assert total_focus <= 1.0, "The sum of focus weights must be less than or equal to 1." for country, weight in focus_weights.items(): L[country] = weight / len(L[country]) remainder = [ c not in focus_weights.keys() for c in L.index.get_level_values('country') ] L[remainder] = L.loc[remainder].pipe(normed) * (1 - total_focus) logger.warning( 'Using custom focus weights for determining number of clusters.') assert np.isclose( L.sum(), 1.0, rtol=1e-3 ), "Country weights L must sum up to 1.0 when distributing clusters. Is {}.".format( L.sum()) m = po.ConcreteModel() def n_bounds(model, *n_id): return (1, N[n_id]) m.n = po.Var(list(L.index), bounds=n_bounds, domain=po.Integers) m.tot = po.Constraint(expr=(po.summation(m.n) == n_clusters)) m.objective = po.Objective(expr=sum( (m.n[i] - L.loc[i] * n_clusters)**2 for i in L.index), sense=po.minimize) opt = po.SolverFactory(solver_name) if not opt.has_capability('quadratic_objective'): logger.warning( f'The configured solver `{solver_name}` does not support quadratic objectives. Falling back to `ipopt`.' ) opt = po.SolverFactory('ipopt') results = opt.solve(m) assert results['Solver'][0][ 'Status'].key == 'ok', "Solver returned non-optimally: {}".format( results) return pd.Series(m.n.get_values(), index=L.index).astype(int)
def computeSecondStageCost(model): """ Method to compute second stage cost of stochastic programming, i.e. maximum NPVs @ In, model, instance, pyomo abstract model instance @ Out, expr, pyomo.expression, second stage cost """ expr = pyomo.summation(model.net_present_values, model.x) return expr
def computeFirstStageCost(model): """" Method to compute first stage cost of stochastic programming @ In, model, instance, pyomo abstract model instance @ Out, expr, float, first stage cost """ expr = -model.epsilon * model.gamma + pyomo.summation(model.prob, model.nu) return expr
def rule(model): den = self.num_tasks * slots num = 20 weights = np.ones((7, self.num_tasks)) for j in range(self.num_tasks): weights[:, j] = self.task_spread[j] total = summation(weights, model.S) / den * num return model.S_total == total
def expectProfit(model): """ Method to compute the expect profit of stochastic programming @ In, model, instance, pyomo abstract model instance @ Out, expr, pyomo.expression, constraint to compute the expect profit """ return model.expectProfit - pyomo.summation( model.net_present_values, model.x) == 0
def L1_LinearObjective(model): Expr = pyo.summation(model.f, model.x) if hasattr(model, "lambda1"): Expr += model.lambda1 * sum(abs(model.x[i]-model.c[i]) for i in model.N) if hasattr(model, "lambda2"): Expr += model.lambda2 * sum((abs(model.x[i]-model.c_pos[i])+(model.x[i]-model.c_pos[i]))/2 for i in model.N) if hasattr(model, "lambda3"): Expr += model.lambda3 * sum((abs(model.x[i]-model.c_pos[i])-(model.x[i]-model.c_neg[i]))/2 for i in model.N) return Expr
def computeSecondStageCost(model): """ Method to compute second stage cost of stochastic programming @ In, model, instance, pyomo abstract model instance @ Out, expr, pyomo.expression, second stage cost """ expr = pyomo.summation(model.net_present_values, model.x) * (1.-model._lambda) - \ model._lambda/(1.0-model.alpha)*model.nu return expr
def QuadraticConstraint(model, suffix): Sigma = getattr(model, "Sigma"+suffix) Mu = getattr(model, "Mu"+suffix) q = getattr(model, "q"+suffix) Expr = pyo.summation(Mu, model.x) for i in model.N: for j in model.N: Expr += model.x[i]*Sigma[i, j]*model.x[j] return (Expr<=q)
def Objective_fn(m): # Link demand / value not yet implemented fn = summation(m.nodeValueDB, m.nodeDeliveryDB) \ + summation(m.nodeStorageValueDB, m.nodeStorageDB) \ + summation(m.nodeBaseHydropowerValueDB, m.nodeHydropowerDB) \ + summation(m.nodeExcessValue, m.nodeExcessHydropower) \ + summation(m.nodeViolationCost, m.nodeFlowRequirementDelivery) \ - 10 * summation(m.floodStorage) \ - 5 * summation(m.nodeSpill) \ # - 1 * summation(m.emptyStorage) # - 1000 * summation(m.virtualPrecipGain) \ fn_debug_gain = - 1000 * summation(m.debugGain) if debug_gain else 0 fn_debug_loss = - 1000 * summation(m.debugLoss) if debug_loss else 0 return fn + fn_debug_gain + fn_debug_loss
def L1_QuadraticObjective(model): Expr = pyo.summation(model.Mu, model.x) for i in model.N: for j in model.N: Expr += model.x[i]*model.Sigma[i, j]*model.x[j] if hasattr(model, "lambda1"): Expr += model.lambda1 * sum(abs(model.x[i]-model.c[i]) for i in model.N) if hasattr(model, "lambda2"): Expr += model.lambda2 * sum((abs(model.x[i]-model.c_pos[i])+(model.x[i]-model.c_pos[i]))/2 for i in model.N) if hasattr(model, "lambda3"): Expr += model.lambda3 * sum((abs(model.x[i]-model.c_pos[i])-(model.x[i]-model.c_neg[i]))/2 for i in model.N) return Expr
def distribute_clusters_optim(n, n_clusters, solver_name=None): if solver_name is None: solver_name = snakemake.config['solver']['solver']['name'] L = (n.loads_t.p_set.mean().groupby(n.loads.bus).sum().groupby( [n.buses.country, n.buses.sub_network]).sum().pipe(normed)) m = po.ConcreteModel() m.n = po.Var(list(L.index), bounds=(1, None), domain=po.Integers) m.tot = po.Constraint(expr=(po.summation(m.n) == n_clusters)) m.objective = po.Objective(expr=po.sum( (m.n[i] - L.loc[i] * n_clusters)**2 for i in L.index), sense=po.minimize) opt = po.SolverFactory(solver_name) if isinstance(opt, pypsa.opf.PersistentSolver): opt.set_instance(m) results = opt.solve(m) assert results['Solver'][0][ 'Status'].key == 'ok', "Solver returned non-optimally: {}".format( results) return pd.Series(m.n.get_values(), index=L.index).astype(int)
def distribute_clusters(n, n_clusters, solver_name=None): if solver_name is None: solver_name = snakemake.config['solver']['solver']['name'] L = (n.loads_t.p_set.mean().groupby(n.loads.bus).sum().groupby( [n.buses.country, n.buses.sub_network]).sum().pipe(normed)) N = n.buses.groupby(['country', 'sub_network']).size() assert n_clusters >= len(N) and n_clusters <= N.sum(), \ "Number of clusters must be {} <= n_clusters <= {} for this selection of countries.".format(len(N), N.sum()) m = po.ConcreteModel() def n_bounds(model, *n_id): return (1, N[n_id]) m.n = po.Var(list(L.index), bounds=n_bounds, domain=po.Integers) m.tot = po.Constraint(expr=(po.summation(m.n) == n_clusters)) m.objective = po.Objective(expr=po.sum( (m.n[i] - L.loc[i] * n_clusters)**2 for i in L.index), sense=po.minimize) opt = po.SolverFactory(solver_name) if not opt.has_capability('quadratic_objective'): logger.warn( f'The configured solver `{solver_name}` does not support quadratic objectives. Falling back to `ipopt`.' ) opt = po.SolverFactory('ipopt') results = opt.solve(m) assert results['Solver'][0][ 'Status'].key == 'ok', "Solver returned non-optimally: {}".format( results) return pd.Series(m.n.get_values(), index=L.index).astype(int)
def one_out_rule(model, n): return ( pe.summation(model.y, index=model.g.out_edges(n)) == 1)
return model.Yall[p,r,f,b,t] == model.Y[p,r,f,b,t] model.yall_y_binding = pe.Constraint(model.nonfix_var_set*model.time, rule = yall_y_binding_rule) ###Yall setting rule(for fix-pilot part) def yall_setting_rule(model, p, r, f, b, t): df_new = fixed_df.set_index(['Crew_ID','Rank','Cur_Fleet','Current_Base']) if (p, r, f, b) in df_new.index: return model.Yall[p,r,f,b,t] == 1 else: return model.Yall[p,r,f,b,t] == 0 model.yall_setting = pe.Constraint(model.fix_var_set*model.time, rule = yall_setting_rule) ###OBJ### ###Normal Operation: model.total_normal_cost = pe.summation(model.normal_cost, model.Y) ###Transitions: # changing (p, r, f, b, 25)'s to (p, r, f, b, ) model.total_fleet_trans_cost = pe.summation(model.fleet_transition_cost, model.Y, index = [(p, r, f, b, len(demand_df)-1) for(p, r, f, b) in model.to_pos if p in model.fleet_pilots ]) model.total_base_trans_cost = pe.summation(model.base_transition_cost, model.Y, index = [(p, r, f, b, len(demand_df)-1) for(p, r, f, b) in model.to_pos if p in model.base_pilots ]) model.total_trans_cost = model.total_fleet_trans_cost + model.total_base_trans_cost ###Shortages: model.total_shortage_cost = pe.summation(model.short_cost, model.shortage) ###Vacation Penalty: model.total_vacation_penalty = pe.summation(model.vacation_penalty, model.VP) model.total_seniority_reward = pe.summation(model.seniority_reward, model.VS) model.OBJ = pe.Objective(expr = model.total_shortage_cost + model.total_trans_cost + model.total_normal_cost + model.total_vacation_penalty - model.total_seniority_reward, sense=pe.minimize) solver = pyomo.opt.SolverFactory('cplex')
def utilityCalc(model): return (model.UTILITY == kwargs['tstep'] * kwargs['scale1'] * pe.summation(model.CEMUTOTPER) + kwargs['scale2'])
def y_flow(model, depot): return pe.summation(model.y, index=[arc for arc in model.arc_set if arc[1] == depot]) == pe.summation( model.y, index=[arc for arc in model.arc_set if arc[0] == depot] )
def forth_const(model, j): return pe.summation(model.y, index=[arc for arc in model.arc_set if arc[0] == j]) == 1
def six_const(model, depot): return pe.summation(model.y, index=[arc for arc in model.arc_set if arc[0] == depot]) <= model.K
def o_rule(model): return pyo.summation(model.x)
def _obj_expression(model): """Objective Expression: Minimizing Shipping Costs""" return pyo.summation(model.ShippingCosts, model.Flows)
def _obj_expression(model): """Objective Expression: Maximizing Value""" return pyo.summation(model.Cost, model.Blend)
def create_pyomo_network_lp(g,edge_cost_field='VehicleCost',node_rhs_field='b'): ## Create the model model = pe.ConcreteModel() ## Tell pyomo to read in dual-variable information from the solver model.dual = pe.Suffix(direction=pe.Suffix.IMPORT) ## Associate the graph with this model model.g = g ## Create the problem data model.node_set = pe.Set( initialize=g.nodes() ) model.edge_set = pe.Set( initialize=g.edges() ) model.depot_node = pe.Set(initialize=[1]) model.node_rhs = pe.Param( model.node_set, initialize=lambda model, n: model.g.node[n].get(node_rhs_field,0)) ## Only edge_cost is vehicle cost, no other cost model.edge_costs = pe.Param( model.edge_set, initialize=lambda model, i,j: model.g.edge[i][j].get(edge_cost_field,0)) ## Create the node variables, t_i model.x = pe.Var(model.node_set, domain=pe.NonNegativeReals) model.x_depot = pe.Var(model.depot_node, domain=pe.NonNegativeReals) model.x_except_depot = pe.Var(model.node_set-model.depot_node, domain=pe.NonNegativeReals) ## Create the variables model.y = pe.Var(model.edge_set, domain=pe.Binary) ## Create the objective model.OBJ = pe.Objective(expr = pe.summation(model.edge_costs, model.y)+pe.summation(model.edge_costs, model.y)) ## Create the constraints, one for each node def one_in_rule(model, n): return ( pe.summation(model.y, index=model.g.in_edges(n)) == 1) def one_out_rule(model, n): return ( pe.summation(model.y, index=model.g.out_edges(n)) == 1) def time_A_rule(model, n): return ( model.x[n] >= model.g.node[n]['A_1']) def time_B_rule(model, n): return ( model.x[n] <= model.g.node[n]['B_1']) def anti_cycle_rule(model,i,j): if((i != 1) & (j != 1)): return(model.x_except_depot[i] + model.g.edge[i][j]['cost'] - model.x_except_depot[j]<= max((model.g.node[i]['B_1'] + model.g.edge[i][j]['cost'] - model.g.node[j]['A_1']),0)*(1-model.y[(i,j)])) else: return pe.Constraint.Skip model.OneIn = pe.Constraint(model.node_set-model.depot_node, rule=one_in_rule) model.OneOut = pe.Constraint(model.node_set-model.depot_node, rule=one_out_rule) model.TimeA = pe.Constraint(model.node_set-model.depot_node, rule=time_A_rule) model.TimeB = pe.Constraint(model.node_set-model.depot_node, rule=time_B_rule) model.AntiCycle = pe.Constraint(model.edge_set, rule=anti_cycle_rule) # Solve the model model.create() solver = pyomo.opt.SolverFactory('cplex') results = solver.solve(model, tee=True, keepfiles=True) # Check that we actually computed an optimal solution, load results if (results.solver.status != pyomo.opt.SolverStatus.ok): logging.warning('Check solver not ok?') if (results.solver.termination_condition != pyomo.opt.TerminationCondition.optimal): logging.warning('Check solver optimality?') model.load(results) # Print the model objective print 'Optimal solution value:', model.OBJ() # Load solution data back into the networkx object # for e in model.edge_set: # model.g.edge[e[0]][e[1]]['flow_val'] = model.y[e].value # for n in model.node_set: # model.g.node[n]['dual_val'] = model.dual[ model.FlowBalance[n] ] return model
return model.Yall[p,r,f,b,t] == model.Y[p,r,f,b,t] model.yall_y_binding = pe.Constraint(model.nonfix_var_set*model.time, rule = yall_y_binding_rule) ###Yall setting rule(for fix-pilot part) def yall_setting_rule(model, p, r, f, b, t): df_new = fixed_df.set_index(['Crew_ID','Rank','Cur_Fleet','Current_Base']) if (p, r, f, b) in df_new.index: return model.Yall[p,r,f,b,t] == 1 else: return model.Yall[p,r,f,b,t] == 0 model.yall_setting = pe.Constraint(model.fix_var_set*model.time, rule = yall_setting_rule) ###OBJ### ###Transitions: model.total_fleet_trans_cost = pe.summation(model.fleet_transition_cost, model.Y, index = [(p, r, f, b, model.endtime) for(p, r, f, b) in model.to_pos if p in model.fleet_pilots ]) model.total_base_trans_cost = pe.summation(model.base_transition_cost, model.Y, index = [(p, r, f, b, model.endtime) for(p, r, f, b) in model.to_pos if p in model.base_pilots ]) model.total_trans_cost = model.total_fleet_trans_cost + model.total_base_trans_cost ###Shortages: model.total_shortage_cost = pe.summation(model.short_cost, model.shortage) ###Vacation Penalty: model.total_vacation_penalty = pe.summation(model.vacation_penalty, model.VP) model.total_seniority_reward = pe.summation(model.seniority_reward, model.VS) ###Vacation reward: model.total_vacation_reward = pe.summation(model.vacation_reward,model.V) ###Daily operation cost: model.operationcost = pe.summation(model.dailycost,model.Yall) model.operationminus = pe.summation(model.dailycost,model.Ynowork) model.OBJ = pe.Objective(expr = model.total_shortage_cost + model.total_trans_cost + model.total_vacation_penalty + 7*model.operationcost - 7*model.operationminus - model.total_seniority_reward - model.total_vacation_reward, sense=pe.minimize)
def _obj_expression(model): """Objective Expression: Maximizing Value""" return pyo.summation(model.Values, model.NumActivity)
from pyomo.opt import SolverFactory m = pyo.ConcreteModel() #sets and parameters m.setMachine = pyo.Set(initialize=['A', 'B', 'C']) m.Demand = 10000 M = 1e6 #variables m.C = pyo.Var(m.setMachine, bounds=(0, None)) m.P = pyo.Var(m.setMachine, within=pyo.Integers, bounds=(0, None)) m.B = pyo.Var(m.setMachine, within=pyo.Binary) #objective function m.obj = pyo.Objective(expr=pyo.summation(m.C), sense=pyo.minimize) #constraints m.C1 = pyo.Constraint(expr=pyo.summation(m.P) == m.Demand) m.C2 = pyo.Constraint(expr=m.C['A'] == 0.1 * m.P['A']**2 + 0.5 * m.P['A'] + m.B['A'] * 0.1) m.C3 = pyo.Constraint(expr=m.C['B'] == 0.3 * m.P['B'] + m.B['B'] * 0.5) m.C4 = pyo.Constraint(expr=m.C['C'] == 0.01 * m.P['C']**3) m.C5 = pyo.Constraint(expr=m.P['A'] <= m.B['A'] * M) m.C6 = pyo.Constraint(expr=m.P['B'] <= m.B['B'] * M) #solve opt = SolverFactory('couenne') m.results = opt.solve(m)
def _conservation_constraint_rule(model): return pyo.summation(model.Blend) == 1
df_new = fixed_df.set_index( ['Crew_ID', 'Rank', 'Cur_Fleet', 'Current_Base']) if (p, r, f, b) in df_new.index: return model.Yall[p, r, f, b, t] == 1 else: return model.Yall[p, r, f, b, t] == 0 model.yall_setting = pe.Constraint(model.fix_var_set * model.time, rule=yall_setting_rule) ###OBJ### ###Transitions: model.total_fleet_trans_cost = pe.summation(model.fleet_transition_cost, model.Y, index=[(p, r, f, b, model.endtime) for (p, r, f, b) in model.to_pos if p in model.fleet_pilots]) model.total_base_trans_cost = pe.summation(model.base_transition_cost, model.Y, index=[(p, r, f, b, model.endtime) for (p, r, f, b) in model.to_pos if p in model.base_pilots]) model.total_trans_cost = model.total_fleet_trans_cost + model.total_base_trans_cost ###Shortages: model.total_shortage_cost = pe.summation(model.short_cost, model.shortage) ###Vacation Penalty: model.total_vacation_penalty = pe.summation(model.vacation_penalty, model.VP) model.total_seniority_reward = pe.summation(model.seniority_reward, model.VS) ###Vacation reward:
def pilot_pos_rule(model, pilot, t): lhs = pe.summation(model.Y, index = [(p, r, f, b, t) for (p, r, f, b) in variable_set if p == pilot]) return lhs == 1
#Parameter and Sets model.T = pyo.Param(initialize=10) T = model.T model.M = pyo.Param(initialize=4) M = model.M model.LimProd = pyo.Param(initialize=10) model.setT = pyo.RangeSet(1, T) model.setM = pyo.RangeSet(1, M) #variables model.x = pyo.Var(model.setM, model.setT, within=pyo.Integers) x = model.x #obj function model.obj = pyo.Objective(expr=pyo.summation(x), sense=pyo.maximize) #constraints model.C1 = pyo.ConstraintList() for t in model.setT: model.C1.add(expr=2 * x[2, t] - 8 * x[3, t] <= 0) model.C2 = pyo.ConstraintList() for t in range(3, T + 1): model.C2.add(expr=x[2, t] - 2 * x[3, t - 2] + x[4, t] >= 1) model.C3 = pyo.ConstraintList() for t in model.setT: model.C3.add(expr=sum([x[m, t] for m in range(1, M + 1)]) <= 50) model.C4 = pyo.ConstraintList()
def ball_constraint(model): return summation(model.Variable) == num_balls
def create_pyomo_network_lp_primal(g): model = pe.ConcreteModel() model.g = g # Create the problem data p = list(powerset(g.nodes())) model.power_set = pe.Set(initialize=p, dimen=None) ## Write some additional code here defining sets, parameters, variables # create index model.node_set = pe.Set(initialize=model.g.nodes()) model.arc_set = pe.Set(initialize=model.g.edges()) departure_arc = [] for arc in g.edges(): if arc[0] == "407 Radam Ln": departure_arc.append(arc) model.departure_arc = pe.Set(initialize=departure_arc) return_arc = [] for arc in g.edges(): if arc[1] == "407 Radam Ln": return_arc.append(arc) model.return_arc = pe.Set(initialize=return_arc) model.customer_arc = model.arc_set - model.departure_arc - model.return_arc model.depotnode = pe.Set(initialize=["407 Radam Ln"]) model.customer_node = model.node_set - model.depotnode model.vehicle = pe.Set(initialize=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) costcf = [1, 1.2, 1.5, 1.8, 2, 2, 2, 2, 2, 2] vcostcf = [1, 1.5, 2, 3, 3, 3, 3, 3, 3, 3] car_capacity = [100, 200, 300, 500, 600, 600, 600, 600, 600, 600] def indexrule(model): return [(v, i, j) for v in model.vehicle for i, j in model.arc_set] model.veh_arc_set = pe.Set(dimen=3, initialize=indexrule) # create parameters model.cost = pe.Param( model.veh_arc_set, initialize=lambda model, v, i, j: costcf[v] * model.g.edge[i][j]["cost"], mutable=True ) model.vcost = pe.Param( model.veh_arc_set, initialize=lambda model, v, i, j: vcostcf[v] * model.g.edge[i][j]["VehicleCost"], mutable=True, ) model.demand = pe.Param(model.customer_node, initialize=lambda model, n: model.g.node[n]["Demand"], mutable=True) model.loadingtime = pe.Param(model.customer_node, initialize=0.25, mutable=True) model.Tij = pe.Param(model.arc_set, initialize=lambda model, i, j: model.g.edge[i][j]["cost"], mutable=True) model.big_M = 10000 model.K = len(model.vehicle) # create variables model.x = pe.Var(model.veh_arc_set, domain=pe.Binary) model.y = pe.Var(model.arc_set, domain=pe.Binary) model.iv = pe.Var(model.customer_node, domain=pe.Binary) model.t = pe.Var(model.customer_node, domain=pe.NonNegativeReals) model.t_depot = 9 model.wt = pe.Var(model.arc_set, domain=pe.NonNegativeReals) ## Define objective and constraints def pset_rule(model, *q): if len(q) == 0 or ("407 Radam Ln" in q): return pe.Constraint.Skip lhs = 0 empty = True for i in q: for j in q: if model.g.has_edge(i, j): empty = False lhs = lhs + model.y[(i, j)] if empty: return pe.Constraint.Skip return lhs <= len(q) - 1 model.PSetConst = pe.Constraint(model.power_set, rule=pset_rule) ## Write some code here defining the objective function, rest of constraints etc # define objective function # model.OBJ = pe.Objective(expr = pe.summation(model.cost, model.x), sense=pe.minimize) model.OBJ = pe.Objective( expr=pe.summation(model.cost, model.x) + pe.summation(model.vcost, model.x) + pe.summation(model.wt), sense=pe.minimize, ) # define flow constraint def flow_bal(model, v, n): return ( pe.summation(model.x, index=[(a, i, j) for a, i, j in model.veh_arc_set if j == n if a == v]) - pe.summation(model.x, index=[(a, i, j) for a, i, j in model.veh_arc_set if i == n if a == v]) == 0 ) model.FlowConst_v1 = pe.Constraint(model.vehicle, model.node_set, rule=flow_bal) # define the second constraint def sec_const(model, i, j): return pe.summation(model.x, index=[(v, i, j) for v in model.vehicle]) == model.y[(i, j)] model.ArcConst = pe.Constraint(model.arc_set, rule=sec_const) def third_const(model, j): return pe.summation(model.y, index=[arc for arc in model.arc_set if arc[1] == j]) == 1 model.ThirdConst = pe.Constraint(model.customer_node, rule=third_const) def forth_const(model, j): return pe.summation(model.y, index=[arc for arc in model.arc_set if arc[0] == j]) == 1 model.ForthConst = pe.Constraint(model.customer_node, rule=forth_const) def fif_const(model, depot): return pe.summation(model.y, index=[arc for arc in model.arc_set if arc[1] == depot]) <= model.K model.FifConst = pe.Constraint(model.depotnode, rule=fif_const) def six_const(model, depot): return pe.summation(model.y, index=[arc for arc in model.arc_set if arc[0] == depot]) <= model.K model.SixConst = pe.Constraint(model.depotnode, rule=six_const) def y_flow(model, depot): return pe.summation(model.y, index=[arc for arc in model.arc_set if arc[1] == depot]) == pe.summation( model.y, index=[arc for arc in model.arc_set if arc[0] == depot] ) model.yflowconst = pe.Constraint(model.depotnode, rule=y_flow) def const7(model, k): summ = 0 for j in model.customer_node: arclist = [arc for arc in model.arc_set if arc[1] == j] for arc in arclist: summ = summ + model.demand[j] * model.x[(k, arc[0], arc[1])] return summ <= car_capacity[k] model.const7 = pe.Constraint(model.vehicle, rule=const7) ###################################################################### # define timewindow constraint def timewindow_const1(model, n): return model.g.node[n]["A_1"] * model.iv[n] + model.g.node[n]["A_2"] * (1 - model.iv[n]) <= model.t[n] model.timeconst1 = pe.Constraint(model.customer_node, rule=timewindow_const1) def timewindow_const2(model, n): return model.t[n] <= model.g.node[n]["B_1"] * model.iv[n] + model.g.node[n]["B_2"] * (1 - model.iv[n]) model.timeconst2 = pe.Constraint(model.customer_node, rule=timewindow_const2) def finconst(model, i, j): return model.t[i] + model.loadingtime[i] + model.Tij[(i, j)] + model.wt[(i, j)] - model.t[j] <= model.big_M * ( 1 - model.y[(i, j)] ) model.finconst = pe.Constraint(model.customer_arc, rule=finconst) def finconst2(model, i, j): return model.t[i] + model.loadingtime[i] + model.Tij[(i, j)] + model.wt[(i, j)] - model.t[j] >= -model.big_M * ( 1 - model.y[(i, j)] ) model.finconst2 = pe.Constraint(model.customer_arc, rule=finconst2) def finconst3(model, n): return model.t_depot + model.Tij[("407 Radam Ln", n)] + model.wt[("407 Radam Ln", n)] <= model.t[n] model.finconst3 = pe.Constraint(model.customer_node, rule=finconst3) # Solve the model model.create() model = resolve_mip(model) # Print the model objective print "Primal objective function value:", model.OBJ() return model
def block_limit_rule(model): model.attacks = self._attacks return pe.summation(model.x) <= model.attacks # pylint: disable=no-member
def flow_bal(model, v, n): return ( pe.summation(model.x, index=[(a, i, j) for a, i, j in model.veh_arc_set if j == n if a == v]) - pe.summation(model.x, index=[(a, i, j) for a, i, j in model.veh_arc_set if i == n if a == v]) == 0 )
def block_limit_rule(model): model.attacks = self.attacks return pe.summation(model.x) <= model.attacks
def sec_const(model, i, j): return pe.summation(model.x, index=[(v, i, j) for v in model.vehicle]) == model.y[(i, j)]
def third_const(model, j): return pe.summation(model.y, index=[arc for arc in model.arc_set if arc[1] == j]) == 1
def Objective_fn(m): return summation(m.P_DB, m.D_DB) + summation(m.P_RB, m.S_RB) + summation(m.P_LB, m.Q_LB)