def __init__(self):
# Initialize Model
self.model = pyo.AbstractModel()
self.model.dual = pyo.Suffix(direction=pyo.Suffix.IMPORT)
# Declare Parameters
self.model.users = pyo.Param(within=pyo.NonNegativeIntegers)
self.model.nodes = pyo.Param(within=pyo.NonNegativeIntegers)
self.model.links = pyo.Param(within=pyo.NonNegativeIntegers)
self.model.nodes_idx = pyo.Param(within=pyo.NonNegativeIntegers)
self.model.operators = pyo.Param(within=pyo.NonNegativeIntegers)
# Set initialization
self.model.u = pyo.RangeSet(1, self.model.users)
self.model.n = pyo.RangeSet(1, self.model.nodes)
self.model.l = pyo.RangeSet(1, self.model.links)
self.model.i = pyo.RangeSet(1, self.model.nodes_idx)
self.model.o = pyo.RangeSet(1, self.model.operators)
# Parameters
self.model.origin = pyo.Param(self.model.l)
self.model.destination = pyo.Param(self.model.l)
self.model.t = pyo.Param(self.model.l)
self.model.c = pyo.Param(self.model.l)
self.model.w = pyo.Param(self.model.l)
self.model.link_oper = pyo.Param(self.model.l)
self.model.d = pyo.Param(self.model.u)
self.model.O = pyo.Param(self.model.u)
self.model.D = pyo.Param(self.model.u)
self.model.utility = pyo.Param(self.model.u)
self.model.N = pyo.Param(self.model.n)
self.model.heads = pyo.Param(self.model.i, self.model.i, default=0)
self.model.tails = pyo.Param(self.model.i, self.model.i, default=0)
def setUp(self):
##### Creating a Pyomo Model from the data in Chan et al. Example 1 #####
A = np.array([[2, 5], [2, -3], [2, 1], [-2, -1]])
#b = np.array([[10],[-6],[4],[-10]])
x0 = np.array([[2.5], [3]])
test_model = pyo.ConcreteModel()
test_model.varindex = pyo.RangeSet(2)
test_model.numvars = pyo.Param(initialize=2)
test_model.eqindex = pyo.RangeSet(4)
test_model.numeqs = pyo.Param(initialize=4)
test_model.x = pyo.Var(test_model.varindex)
##### Importing the A and b as param objects #####
def A_mat_func(model, i, j):
return A[i - 1, j - 1]
test_model.Amat = pyo.Param(test_model.eqindex,
test_model.varindex,
rule=A_mat_func)
test_model.bvec = pyo.Param(test_model.eqindex,
initialize={
1: 10,
2: -6,
3: 4,
4: -10
})
##### Creating the GIO Objects #####
self.example1Chan = GIO(test_model.Amat,test_model.bvec,x0,\
4,2,'T')
self.ex1Chan_testingGIOallmethod = GIO(test_model.Amat,test_model.bvec,x0,\
4,2,'T')
def max_sum_rate_opt(H):
"""
Single-cell sum rate maximization, as an example to show that the
analytical expression
w_mmse_k = + ∑_{i≠k} q_i h_i h_i^H)^{-1} h_k
\sqrt{p_k} ---------------------------------------
||(I + ∑_{i≠k} q_i h_i h_i^H)^{-1} h_k||
H:
complex CSI, shape is (K, M)
Returns
-------
"""
model = pe.ConcreteModel()
K, M = H.shape[0], H.shape[1]
users = pe.RangeSet(K)
antennas = pe.RangeSet(M)
complex = pe.RangeSet(2)
model.w = pe.Var(users, antennas, complex, domain=pe.Reals) # (K, M,
# 2) real-value
def comp_norm(x, y):
return x * x + y * y
def cons_norm(model, u):
norm_u = pe.quicksum(
comp_norm(model.w[u][a][0], model.w[u][a][1]) for a in antennas)
return norm_u <= 1
model.cons_norm = pe.Constraint(users, rule=cons_norm)
def create_model9():
# clplatea OXR2-MN-V-0
model = aml.ConcreteModel()
p = 71
wght = -0.1
hp2 = 0.5 * p**2
model.x = aml.Var(aml.RangeSet(1, p), aml.RangeSet(1, p), initialize=0.0)
def f(model):
return sum(0.5 * (model.x[i, j] - model.x[i, j - 1]) ** 2 + \
0.5 * (model.x[i, j] - model.x[i - 1, j]) ** 2 + \
hp2 * (model.x[i, j] - model.x[i, j - 1]) ** 4 + \
hp2 * (model.x[i, j] - model.x[i - 1, j]) ** 4 \
for i in range(2, p + 1) for j in range(2, p + 1)) + (wght * model.x[p, p])
model.f = aml.Objective(rule=f)
for j in range(1, p + 1):
model.x[1, j] = 0.0
model.x[1, j].fixed = True
return model
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 model():
m = pyo.ConcreteModel()
m.fs = FlowsheetBlock(default={"dynamic": False})
m.fs.prop_water = iapws95.Iapws95ParameterBlock()
n_waterwalls = 10
m.fs.ww_zones = pyo.RangeSet(n_waterwalls)
m.fs.Waterwalls = WaterwallSection(
m.fs.ww_zones,
default={
"dynamic": False,
"has_holdup": False,
"property_package": m.fs.prop_water,
"has_heat_transfer": True,
"has_pressure_change": True,
},
)
def arc_rule(b, i):
return {
"source": m.fs.Waterwalls[i].outlet,
"destination": m.fs.Waterwalls[i + 1].inlet
}
m.arc = Arc(pyo.RangeSet(n_waterwalls - 1), rule=arc_rule)
# Pyomo expands arcs writing constraints outlet unit 1 = inlet unit 2
pyo.TransformationFactory("network.expand_arcs").apply_to(m)
return m
def multiclass_SVM(weights, SVM_regularization_parameter, label_to_train,
new_label_values, data_to_train, number_of_renewable_energy,
correspondence_time_period_line_all_samples,
sample_to_train, sample_by_line):
model = pe.ConcreteModel('multiclass_SVM')
model.label_to_train = label_to_train
model.data_to_train = data_to_train
model.SVM_regularization_parameter = SVM_regularization_parameter
model.weights = pd.concat([weights] * (1 + number_of_renewable_energy))
model.correspondence_time_period_line_all_samples = correspondence_time_period_line_all_samples
model.sample_to_train = sample_to_train
model.sample_by_line = sample_by_line
number_of_labels = max(new_label_values)
number_of_time_periods = len(label_to_train)
model.indexes_labels = pe.RangeSet(number_of_labels)
model.indexes_time_periods = pe.RangeSet(number_of_time_periods)
model.alpha_variables = pe.Var(model.indexes_labels,
model.indexes_time_periods,
within=pe.NonNegativeReals)
model.constraint_sum_variables_equal_one = pe.Constraint(
model.indexes_time_periods, rule=constraint_sum_variables_equal_one)
model.objective_function = pe.Objective(rule=objective_function,
sense=pe.minimize)
return model
def _prepare_pyomo_get_inverse_cost_vector_model(self):
model2 = pyo.AbstractModel()
model2.m = pyo.Param(
within=pyo.NonNegativeIntegers) # количество ограничений
model2.n = pyo.Param(
within=pyo.NonNegativeIntegers) # количество переменных
model2.nx = pyo.Param(
within=pyo.NonNegativeIntegers) # количество обычных переменных
model2.nbin = pyo.Param(
within=pyo.NonNegativeIntegers) # количество бинарных переменных
model2.I = pyo.RangeSet(1, model2.m) # индексы ограничений
model2.J = pyo.RangeSet(1, model2.n) # индексы переменных
model2.Jx = pyo.RangeSet(1, model2.nx) # индексы обычных переменных
model2.Jbin = pyo.RangeSet(1,
model2.nbin) # индексы бинарных переменных
model2.Ax = pyo.Param(model2.I,
model2.Jx) # объявляем матрицу ограничений для x
model2.Abin = pyo.Param(
model2.I, model2.Jbin) # объявляем матрицу ограничений для bin
model2.b = pyo.Param(model2.I) # правые части
model2.c = pyo.Param(model2.Jx) # коэффициенты цф
model2.bounds = pyo.Param(model2.J) # границы
model2.sense = pyo.Param(model2.I) # знаки в ограничениях
# the next line declares a variable indexed by the set J
model2.x = pyo.Var(model2.Jx, domain=pyo.Reals)
model2.bin = pyo.Var(model2.Jbin, domain=pyo.Binary)
def obj_expression(m):
return pyo.summation(m.c, m.x)
model2.OBJ = pyo.Objective(rule=obj_expression)
def ax_constraint_rule(m, i):
if m.sense[i] == -1:
return sum(m.Ax[i, j] * m.x[j]
for j in m.Jx) + sum(m.Abin[i, j] * m.bin[j]
for j in m.Jbin) <= m.b[i]
if m.sense[i] == 0:
return sum(m.Ax[i, j] * m.x[j]
for j in m.Jx) + sum(m.Abin[i, j] * m.bin[j]
for j in m.Jbin) == m.b[i]
if m.sense[i] == 1:
return sum(m.Ax[i, j] * m.x[j]
for j in m.Jx) + sum(m.Abin[i, j] * m.bin[j]
for j in m.Jbin) >= m.b[i]
# the next line creates one constraint for each member of the set model.I
model2.AxbConstraint = pyo.Constraint(model2.I,
rule=ax_constraint_rule)
def bounds_rule(m, j):
return (m.bounds[j][0], m.x[j], m.bounds[j][1])
model2.boundx = pyo.Constraint(model2.Jx, rule=bounds_rule)
self._solve_tool_inverse_MPEC_model = model2
def __setup_model(self):
# Number of timestamps
self.model.n_timestamps = pyo.Param(domain=pyo.PositiveIntegers)
# Number of Pods
self.model.n_pods = pyo.Param(domain=pyo.PositiveIntegers)
self.model.T = pyo.RangeSet(0, self.model.n_timestamps - 1) # 0..95
self.model.N = pyo.RangeSet(0, self.model.n_pods - 1) # 0..n - 1
def create_sudoku_model(board):
model = pyo.ConcreteModel()
# store the starting board for the model
model.board = board
# create sets for rows columns and squares
model.ROWS = pyo.RangeSet(1, 9)
model.COLS = pyo.RangeSet(1, 9)
model.SUBSQUARES = pyo.RangeSet(1, 9)
model.VALUES = pyo.RangeSet(1, 9)
# create the binary variables to define the values
model.y = pyo.Var(model.ROWS, model.COLS, model.VALUES, within=pyo.Binary)
# fix variables based on the current board
for (r, c, v) in board:
model.y[r, c, v].fix(1)
# create the objective - this is a feasibility problem
# so we just make it a constant
model.obj = pyo.Objective(expr=1.0)
# @row_col_cons:
# exactly one number in each row
def _RowCon(model, r, v):
return sum(model.y[r, c, v] for c in model.COLS) == 1
model.RowCon = pyo.Constraint(model.ROWS, model.VALUES, rule=_RowCon)
# exactly one number in each column
def _ColCon(model, c, v):
return sum(model.y[r, c, v] for r in model.ROWS) == 1
model.ColCon = pyo.Constraint(model.COLS, model.VALUES, rule=_ColCon)
# @:row_col_cons
# @subsq_con:
# exactly one number in each subsquare
def _SqCon(model, s, v):
return sum(model.y[r, c, v] for (r, c) in subsq_to_row_col[s]) == 1
model.SqCon = pyo.Constraint(model.SUBSQUARES, model.VALUES, rule=_SqCon)
# @:subsq_con
# @num_con:
# exactly one number in each cell
def _ValueCon(model, r, c):
return sum(model.y[r, c, v] for v in model.VALUES) == 1
model.ValueCon = pyo.Constraint(model.ROWS, model.COLS, rule=_ValueCon)
# @:num_con
return model
def __init__(
self,
demand,
t_max=30,
a_max=3,
initial_inventory={
1: 0,
2: 36
},
fixed_order_cost=225,
variable_order_cost=650,
holding_cost=130,
emergency_procurement_cost=3250,
wastage_cost=650,
M=100,
additional_fifo_constraints=True,
weekly_policy=False,
shelf_life_at_arrival_dist=[0, 0, 1],
):
self.model = pyo.ConcreteModel()
# Check that `shelf_life_at_arrival_dist` sums to 1 and had right
# number of elements
assert (
len(shelf_life_at_arrival_dist) == a_max
), "`shelf_life_at_arrival_dist` must have number of elements equal to `a_max`"
assert (np.sum(shelf_life_at_arrival_dist) == 1
), "`shelf_life_at_arrival_dist` must sum to 1"
self.shelf_life_at_arrival_dist = shelf_life_at_arrival_dist
self.model.T = pyo.RangeSet(1, t_max)
self.model.A = pyo.RangeSet(1, a_max)
self.weekly_policy = weekly_policy
if self.weekly_policy:
self.model.Wd = pyo.RangeSet(0, 6)
self.model.M = M
# Hydra doesn't support integer keys so convert here if needed
self.model.initial_inventory = {
int(k): v
for k, v in initial_inventory.items()
}
self.additional_fifo_constraints = additional_fifo_constraints
self.model.demand = demand
self.model.CssF = fixed_order_cost
self.model.CssP = variable_order_cost
self.model.CssH = holding_cost
self.model.CssE = emergency_procurement_cost
self.model.CssW = wastage_cost
self.model.cons = pyo.ConstraintList()
def create_master_problem(params: Parameter) -> pyo.ConcreteModel:
"""
This function creates a master problem.
:param params: Parameter object containing all relevant parameters.
:return: master problem
"""
master = pyo.ConcreteModel()
# Save parameters as a model instance to access parameters in constraint
# functions.
master.params = params
# Hour sets
master.H = pyo.RangeSet(1, len(params.HOURS) - 1)
master.H_all = pyo.RangeSet(0, len(params.HOURS) - 1)
# Variables
# Unit commitment for generator
master.u = pyo.Var(master.H_all, within=pyo.Binary)
# Initialization for u
master.u[0].fix(0)
# Electricity purchased with the forward contract
master.p1 = pyo.Var(master.H_all, within=pyo.NonNegativeReals)
# Initialization for p1
master.p1[0].fix(0)
# Value function for second stage problem
master.alpha = pyo.Var(master.H_all)
# Initialization for p1
master.alpha[0].fix(0)
def master_obj(model):
return sum(params.c1 * model.u[h] + params.l1 * model.p1[h] +
model.alpha[h] for h in model.H)
master.OBJ = pyo.Objective(rule=master_obj)
# Constraints
# Alpha down (-500) is an arbitrary selected bound.
def alphacon1(model, hour):
return model.alpha[hour] >= -500
master.alphacon1 = pyo.Constraint(master.H, rule=alphacon1)
master.min_uptime = pyo.Constraint(master.H, rule=__min_uptime)
master.min_downtime = pyo.Constraint(master.H, rule=__min_downtime)
return master
def _prepare_pyomo_function3(self):
model3 = pyo.AbstractModel()
model3.m = pyo.Param(
within=pyo.NonNegativeIntegers) # количество ограничений
model3.n = pyo.Param(
within=pyo.NonNegativeIntegers) # количество переменных всего
model3.nx = pyo.Param(
within=pyo.NonNegativeIntegers) # количество обычных переменных
model3.nz = pyo.Param(
within=pyo.NonNegativeIntegers) # количество бинарных переменных
model3.I = pyo.RangeSet(1, model3.m) # индексы ограничений
model3.J = pyo.RangeSet(1, model3.n) # индексы переменных
model3.Jx = pyo.RangeSet(1, model3.nx) # индексы обычных переменных
model3.Jz = pyo.RangeSet(1, model3.nz) # индексы бинарных переменных
model3.two = pyo.RangeSet(1, 2)
model3.Ax = pyo.Param(model3.I,
model3.Jx) # объявляем матрицу ограничений для x
model3.Az = pyo.Param(model3.I,
model3.Jz) # объявляем матрицу ограничений для z
model3.rhs = pyo.Param(model3.I, model3.two) # rhs
# variables
model3.x = pyo.Var(model3.Jx, domain=pyo.Reals)
model3.z = pyo.Var(model3.Jz, domain=pyo.Binary)
def obj_expression(m):
return sum(m.x[i] * m.x[i + m.nz] for i in m.Jz)
model3.OBJ = pyo.Objective(rule=obj_expression)
def ax_constraint_rule(m, i):
if m.rhs[i, 2] == -1:
return sum(m.Ax[i, j] * m.x[j]
for j in m.Jx) + sum(m.Az[i, j] * m.z[j]
for j in m.Jz) <= m.rhs[i, 1]
if m.rhs[i, 2] == 0:
return sum(m.Ax[i, j] * m.x[j]
for j in m.Jx) + sum(m.Az[i, j] * m.z[j]
for j in m.Jz) == m.rhs[i, 1]
if m.rhs[i, 2] == 1:
return sum(m.Ax[i, j] * m.x[j]
for j in m.Jx) + sum(m.Az[i, j] * m.z[j]
for j in m.Jz) >= m.rhs[i, 1]
# the next line creates one constraint for each member of the set model.I
model3.AxbConstraint = pyo.Constraint(model3.I,
rule=ax_constraint_rule)
self._solve_tool_partial_inverse_model = model3
def _genModelConstraints(self, model, prepared_constraints):
for iType, iConstraint in prepared_constraints.items():
if iType=="Box":
model.lb = pyo.Param(model.N)
model.ub = pyo.Param(model.N)
model.BoxConstraint = pyo.Constraint(model.N, rule=BoxConstraint)
elif iType=="LinearIn":
model.m1 = pyo.Param(within=pyo.PositiveIntegers)
model.M1 = pyo.RangeSet(0, model.m1-1)
model.A = pyo.Param(model.M1, model.N)
model.b = pyo.Param(model.M1)
model.LinearInConstraint = pyo.Constraint(model.M1, rule=LinearInConstraint)
elif iType=="LinearEq":
model.m2 = pyo.Param(within=pyo.PositiveIntegers)
model.M2 = pyo.RangeSet(0, model.m2-1)
model.Aeq = pyo.Param(model.M2, model.N)
model.beq = pyo.Param(model.M2)
model.LinearEqConstraint = pyo.Constraint(model.M2, rule=LinearEqConstraint)
elif iType=="Quadratic":
for j, jSubConstraint in enumerate(iConstraint):
j = str(j)
setattr(model, "Sigma"+j, pyo.Param(model.N, model.N))
setattr(model, "Mu"+j, pyo.Param(model.N))
setattr(model, "q"+j, pyo.Param(within=pyo.Reals))
setattr(model, "QuadraticConstraint"+j, pyo.Constraint(rule=lambda m: QuadraticConstraint(m, j)))
elif iType=="L1":
for j, jSubConstraint in enumerate(iConstraint):
j = str(j)
setattr(model, "l"+j, pyo.Param(within=pyo.Reals))
setattr(model, "c"+j, pyo.Param(model.N))
setattr(model, "L1Constraint"+j, pyo.Constraint(rule=lambda m: L1Constraint(m, j)))
elif iType=="Pos":
for j, jSubConstraint in enumerate(iConstraint):
j = str(j)
setattr(model, "l_pos"+j, pyo.Param(within=pyo.Reals))
setattr(model, "c_pos"+j, pyo.Param(model.N))
setattr(model, "PosConstraint"+j, pyo.Constraint(rule=lambda m: PosConstraint(m, j)))
elif iType=="Neg":
for j, jSubConstraint in enumerate(iConstraint):
j = str(j)
setattr(model, "l_neg"+j, pyo.Param(within=pyo.Reals))
setattr(model, "c_neg"+j, pyo.Param(model.N))
setattr(model, "NegConstraint"+j, pyo.Constraint(rule=lambda m: NegConstraint(m, j)))
elif iType=="NonZeroNum":
for j, jSubConstraint in enumerate(iConstraint):
j = str(j)
setattr(model, "b"+j, pyo.Param(within=model.N))
setattr(model, "N"+j, pyo.Param(within=pyo.PositiveIntegers))
setattr(model, "NonZeroNumConstraint"+j, pyo.Constraint(rule=lambda m: NonZeroNumConstraint(m, j)))
return model
def perturb_point(model, gen_pert, delta):
model.c = gen_multi.randint(1, model.n)
print(model.c.value)
model.p.value = model.n.value - model.c.value
model.C = pe.RangeSet(1, model.c)
model.P = pe.RangeSet(model.c + 1, model.n)
print(model.P.value)
print(model.C.value)
print("C value ", model.c.value)
for i in model.N:
model.x[i] = model.x[i].value * (1 + gen_pert.uniform(-1, 1) * delta)
model.x[i] = max(model.lb, min(model.x[i].value, model.ub))
model.y[i] = model.y[i].value * (1 + gen_pert.uniform(-1, 1) * delta)
model.y[i] = max(model.lb, min(model.y[i].value, model.ub))
def optimization_problem_second_step(
alpha_variables, number_of_nodes, new_label_values, label_to_train,
SVM_regularization_parameter, data_to_train,
correspondence_time_period_line_all_samples, sample_by_line,
sample_to_train, sample_alpha_variables, number_of_renewable_energy,
initial_variables_multistart, label_alpha_variables,
data_alpha_variables):
model = pe.ConcreteModel('optimization_problem_second_step')
model.label_to_train = label_to_train
model.SVM_regularization_parameter = SVM_regularization_parameter
model.data_to_train = data_to_train
model.correspondence_time_period_line_all_samples = correspondence_time_period_line_all_samples
model.sample_by_line = sample_by_line
model.sample_to_train = sample_to_train
model.sample_alpha_variables = sample_alpha_variables
model.number_of_renewable_energy = number_of_renewable_energy
model.number_of_nodes = number_of_nodes
model.label_alpha_variables = label_alpha_variables
model.data_alpha_variables = data_alpha_variables
number_of_labels = max(new_label_values)
number_of_time_periods = len(label_to_train)
number_of_time_periods_first_sample = alpha_variables.shape[1]
model.alpha_variables = alpha_variables
model.indexes_nodes = pe.RangeSet(model.number_of_nodes)
model.indexes_time_periods = pe.RangeSet(number_of_time_periods)
model.indexes_labels = pe.RangeSet(number_of_labels)
model.indexes_time_periods_first_sample = pe.RangeSet(
number_of_time_periods_first_sample)
initial_variables_multistart.index = model.indexes_nodes
model.weights_variables = pe.Var(
model.indexes_nodes,
within=pe.NonNegativeReals,
initialize=initial_variables_multistart.iloc[:, 0].to_dict())
model.epigraph_variables = pe.Var(model.indexes_time_periods,
within=pe.Reals)
model.constraint_epigraph = pe.Constraint(model.indexes_time_periods,
model.indexes_labels,
rule=constraint_epigraph)
model.objective_function = pe.Objective(rule=objective_function,
sense=pe.minimize)
return model
def runBackpackAlgorithm():
# LOCAL FUNCTIONS
# Objective Function
def obj_func(model):
return sum(model.X[t] * model.w[t] for t in model.T)
# Constraint Generation
def humanContactConstraint(model, T):
# Human Contact Limit
V = 20
return sum(model.X[t] * model.c[t] for t in model.T) <= V
schedules = [
] # array of schedules, _ is an invisible variable for iterations
print("Please be patient while possible schedules are generated...")
for _ in range(1, 100):
# generate some integers for weighting
value1 = randint(0, 10000)
value2 = randint(0, 10000)
value3 = randint(0, 10000)
value4 = randint(0, 10000)
seed(value1)
factors = {1: 7, 2: 7, 3: 10, 4: 10}
weight = {1: value1, 2: value2, 3: value3, 4: value4}
# Model intialization
model = pyo.ConcreteModel()
# Indexes for timeslots t
# Number of time slots
t = 4
model.T = pyo.RangeSet(t)
# Parameter variable xt
model.X = pyo.Var(model.T, within=pyo.Binary)
# Item sizes matrix ct
model.c = pyo.Param(model.T, initialize=factors, default=0)
# Item weights matrix
model.w = pyo.Param(model.T, initialize=weight, default=0)
model.objective = pyo.Objective(rule=obj_func, sense=pyo.maximize)
model.const1 = pyo.Constraint(model.T, rule=humanContactConstraint)
# Solves knapsack using Gurobi
solver = pyo.SolverFactory('gurobi')
solver.solve(model, tee=False)
options = []
for i in list(model.X.keys()):
if model.X[i]() != 0:
options.append(i)
schedules.append(options)
return schedules # These are the feabile schedules used later on
def xyb_rule(b, t):
b.x = pyo.Var()
b.I = pyo.RangeSet(t)
b.y = pyo.Var(b.I, initialize=1.0)
def _b_c_rule(_b):
return _b.x == 1.0 - sum(_b.y[i] for i in _b.I)
b.c = pyo.Constraint(rule=_b_c_rule)
def declare_parameters(self):
# style - set of all beer styles
self.model.styles = pyo.Set(initialize = self.beer_styles)
self.multiplier = 8
# num - range for each style
self.model.num_range = pyo.RangeSet(1,self.multiplier)
# B_{i, n}
# Marginal change in value for style i tap n
self.model.marginal_profit_set = pyo.Set(dimen=2, initialize = {(style, num) for style in self.model.styles for num in self.model.num_range})
def marginal_profit_init(model, style, num):
if style in self.beer_promo_dict:
if self.beer_promo_dict[style] != 0:
self.beer_promo_dict[style] = self.beer_promo_dict[style] - 1
self.mandate_list_volume[(style,num)] = self.marginal_values[(style,num)]["Promo"][1]
return self.marginal_values[(style,num)]["Promo"][0]
else:
self.mandate_list_volume[(style,num)] = self.marginal_values[(style,num)]["No_Promo"][1]
return self.marginal_values[(style,num)]["No_Promo"][0]
else:
self.mandate_list_volume[(style,num)] = self.marginal_values[(style,num)]["No_Promo"][1]
return self.marginal_values[(style,num)]["No_Promo"][0]
self.model.marginal_profit = pyo.Param(self.model.marginal_profit_set, initialize = marginal_profit_init)
def __init__(self, model, E_price, solar_cf, ASM_price):
self.model = model
self.model.IDX = pyo.RangeSet(0, 8759)
self.model.E_price = E_price
self.model.ASM_price = ASM_price
self.model.solar_cf = solar_cf
def generate_cut_gen_problem(self):
if not hasattr(self, 'equip_exists'):
pass
elif abs(self.equip_exists.value) <= 1E-3:
# Do not solve cut generation problem for inactive units
return None
if not hasattr(self, 'apply_NLP'):
return None
self.apply_NLP()
num_vars = count_vars(self)
if num_vars < 1:
return None
b = pe.ConcreteModel(name=self.local_name)
# self.cg_prob = b
var_set = b.var_set = pe.RangeSet(num_vars)
b.lbda = pe.Var(b.var_set,
domain=pe.NonNegativeReals,
bounds=(0, 1),
initialize=0)
b.lbda_sum = pe.Constraint(expr=sum(b.lbda[vs]
for vs in b.var_set) == 1)
clone_block(self, b, var_set, b.lbda)
sum_sq_diff = get_sum_sq_diff(self, b)
b.obj = pe.Objective(expr=sum_sq_diff, sense=pe.minimize)
return b
def _genMeanVarianceModel(self, nvar, prepared_objective, prepared_constraints):
Model = pyo.AbstractModel()
Model.n = pyo.Param(within=pyo.PositiveIntegers)
Model.N = pyo.RangeSet(0, Model.n-1)
Model.x = pyo.Var(Model.N, domain=pyo.Reals)
if "f" in prepared_objective: Model.f = pyo.Param(Model.N)
if "lambda1" in prepared_objective:
Model.lambda1 = pyo.Param(within=pyo.Reals)
Model.c = pyo.Param(Model.N)
if "lambda2" in prepared_objective:
Model.lambda2 = pyo.Param(within=pyo.Reals)
Model.c_pos = pyo.Param(Model.N)
if "lambda3" in prepared_objective:
Model.lambda3 = pyo.Param(within=pyo.Reals)
Model.c_neg = pyo.Param(Model.N)
if ("X" in prepared_objective) or ("Sigma" in prepared_objective): Model.Sigma = pyo.Param(Model.N, Model.N)
if "Mu" in prepared_objective: Model.Mu = pyo.Param(Model.N)
if prepared_objective["type"]=="Linear":
Model.OBJ = pyo.Objective(rule=LinearObjective, sense=pyo.minimize)
elif prepared_objective["type"]=="L1_Linear":
Model.OBJ = pyo.Objective(rule=L1_LinearObjective, sense=pyo.minimize)
elif prepared_objective["type"]=="Quadratic":
Model.OBJ = pyo.Objective(rule=QuadraticObjective, sense=pyo.minimize)
elif prepared_objective["type"]=="L1_Quadratic":
Model.OBJ = pyo.Objective(rule=L1_QuadraticObjective, sense=pyo.minimize)
return self._genModelConstraints(Model, prepared_constraints)
def access_obj_values():
import pyomo.environ as pyo
from pyomo.opt import SolverFactory
# Create a solver
opt = SolverFactory('glpk')
# A simple model with binary variables and
# an empty constraint list.
model = pyo.ConcreteModel()
model.n = pyo.Param(default=4)
model.x = pyo.Var(pyo.RangeSet(model.n), within=pyo.Binary)
# Note: model.x creates an interable using rangeset and returns
# 4 values of x indexed using the vals created in the rangeset funct.
[print(model.x[i]) for i in range(1,5)]
def o_rule(model):
return summation(model.x)
model.o = pyo.Objective(rule=o_rule)
model.c = pyo.ConstraintList()
results = opt.solve(model)
# Print All Variables
for v in model.component_objects(pyo.Var, active=True):
print("Variable",v)
# Print All Values Assigned to variables
for index in v:
print (" ",index, pyo.value(v[index]))
# Print All Parameters
for parmobject in model.component_objects(pyo.Param, active=True):
nametoprint = str(str(parmobject.name))
print ("Parameter ", nametoprint) # doctest: +SKIP
for index in parmobject:
vtoprint = pyo.value(parmobject[index])
print (" ",index, vtoprint) # doctest: +SKIP
def create_model(m):
"""Create unit models"""
m.fs.ww_zones = pyo.RangeSet(10)
m.fs.drum = Drum(
default={
"property_package": m.fs.prop_water,
"has_holdup": False,
"has_heat_transfer": True,
"has_pressure_change": True,
})
m.fs.downcomer = Downcomer(
default={
"property_package": m.fs.prop_water,
"has_holdup": False,
"has_heat_transfer": True,
})
m.fs.Waterwalls = WaterwallSection(
m.fs.ww_zones,
default={
"dynamic": False,
"has_holdup": False,
"property_package": m.fs.prop_water,
"has_heat_transfer": True,
"has_pressure_change": True,
},
)
m.fs.stream_drum_out = Arc(source=m.fs.drum.liquid_outlet,
destination=m.fs.downcomer.inlet)
m.fs.stream_dcmr_out = Arc(source=m.fs.downcomer.outlet,
destination=m.fs.Waterwalls[1].inlet)
def arc_rule(b, i):
return {
"source": m.fs.Waterwalls[i].outlet,
"destination": m.fs.Waterwalls[i + 1].inlet
}
m.arc = Arc(pyo.RangeSet(9), rule=arc_rule)
m.fs.stream_ww14 = Arc(source=m.fs.Waterwalls[10].outlet,
destination=m.fs.drum.water_steam_inlet)
# pyomo arcs expand constraints for inlet = outlet ports
pyo.TransformationFactory("network.expand_arcs").apply_to(m)
def _build_model_objects(self, model):
model.Epitopes = aml.RangeSet(0,
len(self._params.epitope_immunogen) - 1)
model.Aminoacids = aml.RangeSet(0, len(self._params.pcm_matrix) - 1)
model.EpitopePositions = aml.RangeSet(0,
self._params.vaccine_length - 1)
model.SpacerPositions = aml.RangeSet(0,
self._params.vaccine_length - 2)
model.AminoacidPositions = aml.RangeSet(
0, self._params.max_spacer_length - 1)
model.PcmIdx = aml.RangeSet(-4, 1)
model.SequenceLength = aml.Param(initialize=(
self._params.vaccine_length * self._params.epitope_length +
(self._params.vaccine_length - 1) *
self._params.max_spacer_length - 1))
model.SequencePositions = aml.RangeSet(0, model.SequenceLength)
model.PositionInsideEpitope = aml.RangeSet(
0, self._params.epitope_length - 1)
model.MinSpacerLength = aml.Param(
initialize=self._params.min_spacer_length)
model.MaxSpacerLength = aml.Param(
initialize=self._params.max_spacer_length)
model.VaccineLength = aml.Param(initialize=self._params.vaccine_length)
model.EpitopeLength = aml.Param(initialize=self._params.epitope_length)
model.PssmMatrix = aml.Param(
model.Aminoacids * model.PcmIdx,
initialize=lambda model, i, j: self._params.pcm_matrix[i][j])
model.EpitopeImmunogen = aml.Param(
model.Epitopes,
initialize=lambda model, i: self._params.epitope_immunogen[i])
model.EpitopeSequences = aml.Param(
model.Epitopes * model.PositionInsideEpitope,
initialize=lambda model, i, j: self._params.all_epitopes[i][j])
# x(ij) = 1 iff epitope i is in position j
model.x = aml.Var(model.Epitopes * model.EpitopePositions,
domain=aml.Binary,
initialize=0)
# y(ijk) = 1 iff aminoacid k is in position j of spacer i
model.y = aml.Var(model.SpacerPositions * model.AminoacidPositions *
model.Aminoacids,
domain=aml.Binary,
initialize=0)
# a(ij) = 1 iff aminoacid j is in position i of the *whole* sequence (epitopes + spacers)
model.a = aml.Var(model.SequencePositions * model.Aminoacids,
domain=aml.Binary,
initialize=0)
# i(i) is the computed cleavage at position i
model.i = aml.Var(model.SequencePositions,
domain=aml.Reals,
initialize=0)
def output_datarate_optimization_PYOMO(q,
w,
N,
M,
P,
T_s,
U_max=1000,
Q_max=1,
tol=1e-7):
if N == 0:
return []
m = pyo.ConcreteModel()
m.N = pyo.RangeSet(0, N - 1)
m.M = pyo.RangeSet(0, M - 1)
m.q = pyo.Param(m.N, initialize={i: q[i] for i in m.N}, within=pyo.Reals)
m.w = pyo.Param(m.N,
initialize={i: w[i]
for i in m.N},
within=pyo.NonNegativeReals)
m.P = pyo.Param(m.N,
m.M,
initialize={(i, j): P[i][j]
for j in m.M for i in m.N},
within=pyo.NonNegativeReals)
m.T_s = pyo.Param(initialize=T_s, within=pyo.NonNegativeReals)
m.U_max = pyo.Param(initialize=U_max, within=pyo.NonNegativeReals)
m.Q_max = pyo.Param(initialize=Q_max, within=pyo.NonNegativeReals)
m.u_k = pyo.Var(m.N, m.M, domain=pyo.NonNegativeReals)
m.visible_basestation_constraint = pyo.Constraint(
m.N, m.M, rule=visible_basestation_constraint_rule)
m.max_U_constraint = pyo.Constraint(m.M, rule=max_U_constraint_rule)
m.queue_constraint_lower = pyo.Constraint(m.N,
rule=queue_constraint_lower_rule)
m.queue_constraint_upper = pyo.Constraint(m.N,
rule=queue_constraint_upper_rule)
m.obj = pyo.Objective(rule=obj_rule)
opt = pyo.SolverFactory("ipopt", executable="ipopt-win64\\ipopt.exe")
ret = opt.solve(m)
u_final = np.zeros((N, M))
for i in range(N):
for j in range(M):
u_final[i, j] = pyo.value(m.u_k[i, j])
return u_final
def Create_Model_Stg1():
"""Create Pyomo model.
Model consists of
1. Functions to properly initialize number of weaks and respective bound from global data loader class
2. Variables to optimize
3. Objective function
4. Constraints
"""
def Weeks_Init(Model, PPG_index):
return Globals.EDLP_Events[PPG_index]
def Weeks_bound(Model, PPG_index):
return (Globals.Min_EDLP_Events[PPG_index], Globals.Max_EDLP_Events[PPG_index])
def TPR_Bound_Init(Model, P):
LB = min(Globals.TPR_Perc_Val[P])
UB = max(Globals.TPR_Perc_Val[P])
return (LB, UB)
def TPR_Initial(Model, P):
UB = max(Globals.TPR_Perc_Val[P])
return UB
Model = pyo.ConcreteModel(name="Spend_Optim")
Model.PPGs = pyo.Param(initialize=Globals.Tot_Prod, domain=pyo.PositiveIntegers)
Model.PPG_index = pyo.RangeSet(0, Model.PPGs - 1)
Model.EDLP = pyo.Var(
Model.PPG_index,
initialize=Globals.EDLP_UB,
domain=pyo.NonNegativeReals,
bounds=(Globals.EDLP_LB, Globals.EDLP_UB),
)
Model.TPR = pyo.Var(
Model.PPG_index,
initialize=TPR_Initial,
domain=pyo.NonNegativeReals,
bounds=TPR_Bound_Init,
)
Model.Weeks = pyo.Var(
Model.PPG_index,
initialize=Weeks_Init,
domain=pyo.PositiveIntegers,
bounds=Weeks_bound,
)
Model.Obj = pyo.Objective(rule=Dollar_Sales_Stg1_Fn, sense=pyo.maximize)
# Model.Tot_Spent_Bnd = pyo.Constraint(Model.PPG_index, rule=Total_Trade_Spent_Bnd_Stg1_Fn)
Model.EDLP_Bnd = pyo.Constraint(Model.PPG_index, rule=EDLP_Trade_Spent_Bnd_Stg1_Fn)
Model.TPR_Bnd = pyo.Constraint(Model.PPG_index, rule=TPR_Trade_Spent_Bnd_Stg1_Fn)
Model.Overall = pyo.Constraint(rule=Overall_Total_Trade_Spent_Stg1_Fn)
return Model
def _prepare_pyomo_function1(self):
model1 = pyo.AbstractModel()
model1.m = pyo.Param(
within=pyo.NonNegativeIntegers) # количество ограничений
model1.n = pyo.Param(
within=pyo.NonNegativeIntegers) # количество переменных
model1.I = pyo.RangeSet(1, model1.m) # индексы ограничений
model1.J = pyo.RangeSet(1, model1.n) # индексы переменных
model1.a = pyo.Param(model1.I,
model1.J) # объявляем матрицу ограничений
model1.b = pyo.Param(model1.I) # правые части
model1.c = pyo.Param(model1.J) # коэффициенты цф
model1.lb = pyo.Param(model1.J) # нижние границы
model1.sense = pyo.Param(model1.I) # знаки в ограничениях
# the next line declares a variable indexed by the set J
model1.x = pyo.Var(model1.J)
def obj_expression(m):
return pyo.summation(m.c, m.x)
model1.OBJ = pyo.Objective(rule=obj_expression)
def ax_constraint_rule(m, i):
if m.sense[i] == -1:
return sum(m.a[i, j] * m.x[j] for j in m.J) <= m.b[i]
if m.sense[i] == 0:
return sum(m.a[i, j] * m.x[j] for j in m.J) == m.b[i]
if m.sense[i] == 1:
return sum(m.a[i, j] * m.x[j] for j in m.J) >= m.b[i]
# the next line creates one constraint for each member of the set model.I
model1.AxbConstraint = pyo.Constraint(model1.I,
rule=ax_constraint_rule)
def bounds_rule(m, j):
return (m.lb[j], m.x[j], None)
model1.boundx = pyo.Constraint(model1.J, rule=bounds_rule)
self._inverse_cost_vector_model = model1
def __init__(self):
pe.ConcreteModel.__init__(self)
#
# Metadata [Component Objects]
self.__chem = dict() # Name to chemical mapping
#
# Model sets
self.comp = pe.Set() # Stream components
self.prop = pe.RangeSet(0,10) # Coefficient set
#
# Model parameters
self.MW = pe.Param(self.comp, default=0) # Molecular weight
self.tc = pe.Param(self.comp, default=298) # Critric temperature
self.pc = pe.Param(self.comp, default=101325) # Critic pressure
self.mu_coef = pe.Param(self.comp, self.prop,
mutable = True, default = 0) # Viscosity coefficients
self.rho_coef = pe.Param(self.comp, self.prop,
mutable = True, default =0) # Density coefficients
#
# Model variables
# Basic properties
self.mass_flow = pe.Var(domain = pe.PositiveReals) # Mass flow [kg/s]
self.molar_flow = pe.Var(domain = pe.PositiveReals) # Mole flow [mol/s]
self.vol_flow = pe.Var(domain = pe.PositiveReals) # Volume flow [m3/s]
self.T = pe.Var(domain = pe.PositiveReals, initialize=298) # Temperature [K]
self.P = pe.Var(domain = pe.PositiveReals, initialize=101325) # Pressure [Pa]
# TODO : Implement new types of properties
# Component properties
self.xw = pe.Var(self.comp, bounds=(0,1)) # Mass fraction
self.xm = pe.Var(self.comp, bounds=(0,1)) # Molar fraction
self.vf = pe.Var(self.comp, bounds=(0,1)) # Volume fraction
self.rho = pe.Var(self.comp, domain = pe.PositiveReals) # Component density [kg/m3]
self.dymu = pe.Var(self.comp, domain = pe.PositiveReals) # Component absolut viscosity [mPa.s]
self.kimu = pe.Var(self.comp, domain = pe.PositiveReals) # Component kynetic viscosiy [cSt]
# Mixture properties
self.Rho = pe.Var(domain = pe.PositiveReals) # Mixture density [kg/m3]
self.Dmu = pe.Var(domain = pe.PositiveReals) # Mixture dynamic viscosity
self.Kmu = pe.Var(domain = pe.PositiveReals) # Mixture kinematic viscosity
#
# Balance constraints flags
self.__massbal_flag = False # Boolean : Activated mass balance
self.__molarbal_flag = False # Boolean : Activated molar balance
self.__volbal_flag = False # Boolean : Activated
def insert_constraint(self, params, model, solver):
cs = {} # we create components here, then insert them with the prefixed name
cs['Options'] = aml.RangeSet(0, len(self._epitope_coverage[0]) - 1)
# for every option, indicates which epitopes cover it
# FIXME terrible for caching as we iterate over columns
cs['Coverage'] = aml.Param(cs['Options'], initialize=lambda _, o: set(
i for i, epi_cov in enumerate(self._epitope_coverage) if epi_cov[o]
))
if self._min_coverage is not None:
cs['IsOptionCovered'] = aml.Var(cs['Options'], domain=aml.Binary, initialize=0)
cs['AssignIsOptionCovered'] = aml.Constraint(
cs['Options'], rule=lambda model, option: sum(
model.x[e, p]
for e in cs['Coverage'][option]
for p in model.EpitopePositions
) >= cs['IsOptionCovered'][option]
)
cs['MinCoverage'] = aml.Param(initialize=(
int(self._min_coverage) if self._min_coverage > 1
else math.ceil(self._min_coverage * len(self._epitope_coverage[0]))
), mutable=True)
cs['MinCoverageConstraint'] = aml.Constraint(rule=lambda model: sum(
cs['IsOptionCovered'][o] for o in cs['Options']
) >= cs['MinCoverage'])
if self._min_conservation is not None:
cs['MinConservation'] = aml.Param(initialize=(
int(self._min_conservation) if self._min_conservation > 1
else math.ceil(self._min_conservation * len(self._epitope_coverage[0]))
), mutable=True)
cs['MinConservationConstraint'] = aml.Constraint(rule=lambda model: sum(
model.x[e, p]
for o in cs['Options']
for e in cs['Coverage'][o]
for p in model.EpitopePositions
) >= cs['MinConservation'] * model.VaccineLength)
for k, v in cs.items():
name = '%s_%s' % (self._name, k)
setattr(model, name, v)
if isinstance(v, aml.Constraint):
self._constraints.append(name)
elif isinstance(v, aml.Var):
self._variables.append(name)
self._cs = cs
super().insert_constraint(params, model, solver)
