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 = None
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=1.0)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=NonNegativeReals)
model.inactive_obj = pmo.objective(model.y)
model.inactive_obj.deactivate()
model.obj = pmo.objective(model.x**2 + 3.0*model.inactive_obj**2 + 1.0)
model.c1 = pmo.constraint(model.a <= model.y)
model.c2 = pmo.constraint((2.0, model.x/model.a - model.y, 10))
def solve_nonlinear(Aw, Af, alpha, beta, gamma, delta):
m = pmo.block()
m.h = pmo.variable(lb=0)
m.w = pmo.variable(lb=0)
m.d = pmo.variable(lb=0)
m.c = pmo.constraint_tuple([
pmo.constraint(body=2*(m.h*m.w + m.h*m.d), ub=Aw),
pmo.constraint(body=m.w*m.d,
ub=Af),
pmo.constraint(lb=alpha,
body=m.h/m.w,
ub=beta),
pmo.constraint(lb=gamma,
body=m.d/m.w,
ub=delta)])
m.o = pmo.objective(m.h * m.w * m.d,
sense=pmo.maximize)
m.h.value, m.w.value, m.d.value = (1,1,1)
ipopt = pmo.SolverFactory("ipopt")
result = ipopt.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("nonlinear solution:")
print("h: {0:.4f}, w: {1:.4f}, d: {2:.4f}".\
format(m.h(), m.w(), m.d()))
print("volume: {0: .5f}".\
format(m.o()))
print("")
def _generate_model(self):
self.model = None
self.model = pmo.block()
model = self.model
model._name = self.description
model.s = list(range(1,13))
model.x = pmo.variable_dict(
(i, pmo.variable()) for i in model.s)
model.x[1].lb = -1
model.x[1].ub = 1
model.x[2].lb = -1
model.x[2].ub = 1
model.obj = pmo.objective(sum(model.x[i]*((-1)**(i+1))
for i in model.s))
model.c = pmo.constraint_dict()
# to make the variable used in the constraint match the name
model.c[3] = pmo.constraint(model.x[3]>=-1.)
model.c[4] = pmo.constraint(model.x[4]<=1.)
model.c[5] = pmo.constraint(model.x[5]==-1.)
model.c[6] = pmo.constraint(model.x[6]==-1.)
model.c[7] = pmo.constraint(model.x[7]==1.)
model.c[8] = pmo.constraint(model.x[8]==1.)
model.c[9] = pmo.constraint((-1.,model.x[9],-1.))
model.c[10] = pmo.constraint((-1.,model.x[10],-1.))
model.c[11] = pmo.constraint((1.,model.x[11],1.))
model.c[12] = pmo.constraint((1.,model.x[12],1.))
model.c_inactive = pmo.constraint_dict()
# to make the variable used in the constraint match the name
model.c_inactive[3] = pmo.constraint(model.x[3]>=-2.)
model.c_inactive[4] = pmo.constraint(model.x[4]<=2.)
def define_model(**kwds):
sense = kwds.pop("sense")
m = pmo.block()
m.x = pmo.variable_list()
m.Fx = pmo.variable_list()
m.piecewise = pmo.block_list()
for i in range(4):
m.x.append(pmo.variable(lb=0, ub=3))
m.Fx.append(pmo.variable())
m.piecewise.append(
pmo.piecewise(breakpoints, values,
input=m.x[i],
output=m.Fx[i],
**kwds))
m.obj = pmo.objective(expr=sum(m.Fx) + sum(m.x),
sense=sense)
# fix the answer for testing purposes
m.set_answer = pmo.constraint_list()
# Fx1 should solve to 0
m.set_answer.append(pmo.constraint(expr= m.x[0] == 0.5))
m.set_answer.append(pmo.constraint(expr= m.x[1] == 1.0))
m.set_answer.append(pmo.constraint(expr= m.Fx[1] == 0.5))
# Fx[2] should solve to 1
m.set_answer.append(pmo.constraint(expr= m.x[2] == 1.5))
# Fx[3] should solve to 1.5
m.set_answer.append(pmo.constraint(expr= m.x[3] == 2.5))
return m
def solve_nonlinear():
m = pmo.block()
m.x = pmo.variable()
m.y = pmo.variable()
m.z = pmo.variable()
m.c = pmo.constraint_tuple([
pmo.constraint(body=0.1*pmo.sqrt(m.x) + (2.0/m.y),
ub=1),
pmo.constraint(body=(1.0/m.z) + (m.y/(m.x**2)),
ub=1)])
m.o = pmo.objective(m.x + (m.y**2)*m.z,
sense=pmo.minimize)
m.x.value, m.y.value, m.z.value = (1,1,1)
ipopt = pmo.SolverFactory("ipopt")
result = ipopt.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("nonlinear solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(m.x(), m.y(), m.z()))
print("objective: {0: .5f}".\
format(m.o()))
print("")
def build_small_block_with_objects():
"""Build an empty block."""
b = block()
b.x = build_variable()
b.c = constraint()
b.o = objective()
return b
def define_model(**kwds):
sense = kwds.pop("sense")
m = pmo.block()
m.x = pmo.variable_list()
m.Fx = pmo.variable_list()
m.piecewise = pmo.block_list()
for i in range(7):
m.x.append(pmo.variable(lb=-5, ub=4))
m.Fx.append(pmo.variable())
m.piecewise.append(
pmo.piecewise(breakpoints, values,
input=m.x[i],
output=m.Fx[i],
**kwds))
m.obj = pmo.objective(expr=sum(m.Fx),
sense=sense)
# fix the answer for testing purposes
m.set_answer = pmo.constraint_list()
m.set_answer.append(pmo.constraint(m.x[0] == -5.0))
m.set_answer.append(pmo.constraint(m.x[1] == -3.0))
m.set_answer.append(pmo.constraint(m.x[2] == -2.5))
m.set_answer.append(pmo.constraint(m.x[3] == -1.5))
m.set_answer.append(pmo.constraint(m.x[4] == 2.0))
m.set_answer.append(pmo.constraint(m.x[5] == 3.5))
m.set_answer.append(pmo.constraint(m.x[6] == 4.0))
return m
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.f = pmo.variable()
model.x = pmo.variable(lb=1,ub=3)
model.fi = pmo.parameter_dict()
model.fi[1] = pmo.parameter(value=1.0)
model.fi[2] = pmo.parameter(value=2.0)
model.fi[3] = pmo.parameter(value=0.0)
model.xi = pmo.parameter_dict()
model.xi[1] = pmo.parameter(value=1.0)
model.xi[2] = pmo.parameter(value=2.0)
model.xi[3] = pmo.parameter(value=3.0)
model.p = pmo.variable(domain=NonNegativeReals)
model.n = pmo.variable(domain=NonNegativeReals)
model.lmbda = pmo.variable_dict(
(i, pmo.variable()) for i in range(1,4))
model.obj = pmo.objective(model.p+model.n)
model.c1 = pmo.constraint_dict()
model.c1[1] = pmo.constraint((0.0, model.lmbda[1], 1.0))
model.c1[2] = pmo.constraint((0.0, model.lmbda[2], 1.0))
model.c1[3] = pmo.constraint(0.0 <= model.lmbda[3])
model.c2 = pmo.sos2(model.lmbda.values())
model.c3 = pmo.constraint(sum(model.lmbda.values()) == 1)
model.c4 = pmo.constraint(model.f==sum(model.fi[i]*model.lmbda[i]
for i in model.lmbda))
model.c5 = pmo.constraint(model.x==sum(model.xi[i]*model.lmbda[i]
for i in model.lmbda))
model.x.fix(2.75)
# Make an empty SOS constraint
model.c6 = pmo.sos2([])
def _generate_base_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.s = list(range(1,13))
model.x = pmo.variable_dict(
((i, pmo.variable()) for i in model.s))
model.x[1].lb = -1
model.x[1].ub = 1
model.x[2].lb = -1
model.x[2].ub = 1
model.obj = pmo.objective(expr=sum(model.x[i]*((-1)**(i+1))
for i in model.s))
variable_order = [
model.x[3],
model.x[4],
model.x[5],
model.x[6],
model.x[7],
model.x[8],
model.x[9],
model.x[10],
model.x[11],
model.x[12]]
return variable_order
def solve_conic():
m = pmo.block()
m.t = pmo.variable()
m.u = pmo.variable()
m.v = pmo.variable()
m.w = pmo.variable()
m.k = pmo.block_tuple([
# exp(u-t) + exp(2v + w - t) <= 1
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.u - m.t),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=2*m.v + m.w - m.t),
# exp(0.5u + log(0.1)) + exp(-v + log(2)) <= 1
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=0.5*m.u + pmo.log(0.1)),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=-m.v + pmo.log(2)),
# exp(-w) + exp(v-2u) <= 1
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=-m.w),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.v - 2*m.u)])
m.c = pmo.constraint_tuple([
pmo.constraint(body=m.k[0].r + m.k[1].r,
ub=1),
pmo.constraint(body=m.k[2].r + m.k[3].r,
ub=1),
pmo.constraint(body=m.k[4].r + m.k[5].r,
ub=1)])
m.o = pmo.objective(m.t,
sense=pmo.minimize)
mosek = pmo.SolverFactory("mosek")
result = mosek.solve(m)
assert str(result.solver.termination_condition) == "optimal"
x, y, z = pmo.exp(m.u()), pmo.exp(m.v()), pmo.exp(m.w())
print("conic solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(x, y, z))
print("objective: {0: .5f}".\
format(x + (y**2)*z))
print("")
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=NonNegativeReals)
model.obj = pmo.objective(model.x-model.x)
model.con = pmo.constraint(model.x == 1.0)
def build_block_with_objects():
"""Build an empty block."""
b = block()
b._activate_large_storage_mode()
b.x = build_variable()
b.c = constraint()
b.o = objective()
return b
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.b = pmo.block()
model.B = pmo.block_dict((i, pmo.block())
for i in range(1,4))
model.a = pmo.parameter(value=1.0)
model.b.x = pmo.variable(lb=0)
model.B[1].x = pmo.variable(lb=0)
model.obj = pmo.objective(expr=model.b.x + 3.0*model.B[1].x)
model.obj.deactivate()
model.B[2].c = pmo.constraint(expr=-model.B[1].x <= -model.a)
model.B[2].obj = pmo.objective(expr=model.b.x + 3.0*model.B[1].x + 2)
model.B[3].c = pmo.constraint(expr=(2.0, model.b.x/model.a - model.B[1].x, 10))
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=NonNegativeReals)
model.obj = pmo.objective(0.0)
model.con = pmo.linear_constraint(terms=[(model.x,1.0)],
rhs=1.0)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=pmo.Integers)
model.y = pmo.variable(domain=pmo.Integers)
model.o = pmo.objective(model.x+model.y)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(lb=1)
model.y = pmo.variable(lb=1)
model.o = pmo.objective(model.x+model.y)
model.c = pmo.constraint(model.x+model.y <= 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 _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.s = [1,2]
model.x = pmo.variable()
model.y = pmo.variable()
model.z = pmo.variable(lb=0)
model.obj = pmo.objective_dict()
for i in model.s:
model.obj[i] = pmo.objective(
inactive_index_LP_obj_rule(model,i))
model.OBJ = pmo.objective(model.x+model.y)
model.obj[1].deactivate()
model.OBJ.deactivate()
model.c1 = pmo.constraint_dict()
model.c1[1] = pmo.constraint(model.x<=1)
model.c1[2] = pmo.constraint(model.x>=-1)
model.c1[3] = pmo.constraint(model.y<=1)
model.c1[4] = pmo.constraint(model.y>=-1)
model.c1[1].deactivate()
model.c1[4].deactivate()
model.c2 = pmo.constraint_dict()
for i in model.s:
model.c2[i] = pmo.constraint(
inactive_index_LP_c2_rule(model, i))
model.b = pmo.block()
model.b.c = pmo.constraint(model.z >= 2)
model.B = pmo.block_dict()
model.B[1] = pmo.block()
model.B[1].c = pmo.constraint(model.z >= 3)
model.B[2] = pmo.block()
model.B[2].c = pmo.constraint(model.z >= 1)
model.b.deactivate()
model.B[1].deactivate()
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=Binary)
model.y = pmo.variable(domain=Binary)
model.z = pmo.variable(domain=Binary)
model.obj = pmo.objective(model.x,sense=maximize)
model.c0 = pmo.constraint(model.x+model.y+model.z == 1)
model.qc0 = pmo.constraint(model.x**2 + model.y**2 <= model.z**2)
model.qc1 = pmo.constraint(model.x**2 <= model.y*model.z)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=Binary)
model.y = pmo.variable(domain=Binary)
model.z = pmo.variable(domain=Binary)
model.o = pmo.objective(-model.x-model.y-model.z)
model.c1 = pmo.constraint(model.x+model.y <= 1)
model.c2 = pmo.constraint(model.x+model.z <= 1)
model.c3 = pmo.constraint(model.y+model.z <= 1)
model.c4 = pmo.constraint(model.x+model.y+model.z >= 1.5)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=NonNegativeReals)
model.z = pmo.variable(domain=NonNegativeReals)
model.fixed_var = pmo.variable()
model.fixed_var.fix(0.2)
model.q1 = pmo.variable(ub=0.2)
model.q2 = pmo.variable(lb=-2)
model.obj = pmo.objective(model.x+model.q1-model.q2,sense=maximize)
model.c0 = pmo.constraint(model.x+model.y+model.z == 1)
model.qc0 = pmo.constraint(model.x**2 + model.y**2 + model.fixed_var <= model.z**2)
model.qc1 = pmo.constraint(model.x**2 <= model.y*model.z)
model.c = pmo.constraint_dict()
model.c[1] = pmo.constraint(lb=0, body=-model.q1**2 + model.fixed_var)
model.c[2] = pmo.constraint(body=model.q2**2 + model.fixed_var, ub=5)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=0.1)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable_dict()
model.y[1] = pmo.variable(domain=NonNegativeReals)
model.y[2] = pmo.variable(domain=NonNegativeReals)
model.obj = pmo.objective(model.x + model.y[1]+2*model.y[2])
model.c1 = pmo.constraint(model.a <= model.y[2])
model.c2 = pmo.constraint((2.0, model.x, 10.0))
model.c3 = pmo.sos1(model.y.values())
model.c4 = pmo.constraint(sum(model.y.values()) == 1)
# Make an empty SOS constraint
model.c5 = pmo.sos1([])
def solve_conic(Aw, Af, alpha, beta, gamma, delta):
m = pmo.block()
m.x = pmo.variable()
m.y = pmo.variable()
m.z = pmo.variable()
m.k = pmo.block_tuple([
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.x + m.y + pmo.log(2.0/Aw)),
pmo.conic.primal_exponential.\
as_domain(r=None,
x1=1,
x2=m.x + m.z + pmo.log(2.0/Aw))])
m.c = pmo.constraint_tuple([
pmo.constraint(body=m.k[0].r + m.k[1].r,
ub=1),
pmo.constraint(body=m.y + m.z, ub=pmo.log(Af)),
pmo.constraint(lb=pmo.log(alpha),
body=m.x - m.y,
ub=pmo.log(beta)),
pmo.constraint(lb=pmo.log(gamma),
body=m.z - m.y,
ub=pmo.log(delta))])
m.o = pmo.objective(m.x + m.y + m.z,
sense=pmo.maximize)
mosek = pmo.SolverFactory("mosek")
result = mosek.solve(m)
assert str(result.solver.termination_condition) == "optimal"
h, w, d = pmo.exp(m.x()), pmo.exp(m.y()), pmo.exp(m.z())
print("conic solution:")
print("h: {0:.4f}, w: {1:.4f}, d: {2:.4f}".\
format(h, w, d))
print("volume: {0: .5f}".\
format(h*w*d))
print("")
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.w2 = pmo.variable(domain=pmo.Binary)
model.x2 = pmo.variable(domain_type=pmo.IntegerSet,
lb=0, ub=1)
model.yb = pmo.variable(domain_type=pmo.IntegerSet,
lb=1, ub=1)
model.zb = pmo.variable(domain_type=pmo.IntegerSet,
lb=0, ub=0)
model.yi = pmo.variable(domain=pmo.Integers, lb=-1)
model.zi = pmo.variable(domain=pmo.Integers, ub=1)
model.obj = pmo.objective(model.w2 - model.x2 +\
model.yb - model.zb +\
model.yi - model.zi)
model.c3 = pmo.constraint(model.w2 >= 0)
model.c4 = pmo.constraint(model.x2 <= 1)
def solve_conic():
m = pmo.block()
m.x = pmo.variable(lb=0)
m.y = pmo.variable(lb=0)
m.z = pmo.variable(lb=0)
m.p = pmo.variable()
m.q = pmo.variable()
m.r = pmo.variable(lb=0)
m.k = pmo.block_tuple([
pmo.conic.primal_power.as_domain(r1=m.x,
r2=m.y,
x=[None],
alpha=0.2),
pmo.conic.primal_power.as_domain(r1=m.z,
r2=1,
x=[None],
alpha=0.4)])
m.c = pmo.constraint(body=m.x + m.y + 0.5*m.z,
rhs=2)
m.o = pmo.objective(m.k[0].x[0] + m.k[1].x[0] - m.x,
sense=pmo.maximize)
mosek = pmo.SolverFactory("mosek")
result = mosek.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("conic solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(m.x(), m.y(), m.z()))
print("objective: {0: .5f}".\
format(m.o()))
print("")
def _generate_model(self):
self.model = None
self.model = pmo.block()
model = self.model
model._name = self.description
model.x = pmo.variable(domain=RealInterval(bounds=(float('-inf'), None)))
model.y = pmo.variable(ub=float('inf'))
model.obj = pmo.objective(model.x - model.y)
model.c = pmo.constraint_dict()
model.c[1] = pmo.constraint(model.x >= -2)
model.c[2] = pmo.constraint(model.y <= 3)
cdata = model.c[3] = pmo.constraint((0, 1, 3))
assert cdata.lb == 0
assert cdata.ub == 3
assert cdata.body() == 1
assert not cdata.equality
cdata = model.c[4] = pmo.constraint((0, 2, 3))
assert cdata.lb == 0
assert cdata.ub == 3
assert cdata.body() == 2
assert not cdata.equality
cdata = model.c[5] = pmo.constraint((0, 1, None))
assert cdata.lb == 0
assert cdata.ub is None
assert cdata.body() == 1
assert not cdata.equality
cdata = model.c[6] = pmo.constraint((None, 0, 1))
assert cdata.lb is None
assert cdata.ub == 1
assert cdata.body() == 0
assert not cdata.equality
cdata = model.c[7] = pmo.constraint((1,1))
assert cdata.lb == 1
assert cdata.ub == 1
assert cdata.body() == 1
assert cdata.equality
def solve_nonlinear():
m = pmo.block()
m.x = pmo.variable(lb=0)
m.y = pmo.variable(lb=0)
m.z = pmo.variable(lb=0)
m.c = pmo.constraint(body=m.x + m.y + 0.5*m.z,
rhs=2)
m.o = pmo.objective((m.x**0.2)*(m.y**0.8) + (m.z**0.4) - m.x,
sense=pmo.maximize)
m.x.value, m.y.value, m.z.value = (1,1,1)
ipopt = pmo.SolverFactory("ipopt")
result = ipopt.solve(m)
assert str(result.solver.termination_condition) == "optimal"
print("nonlinear solution:")
print("x: {0:.4f}, y: {1:.4f}, z: {2:.4f}".\
format(m.x(), m.y(), m.z()))
print("objective: {0: .5f}".\
format(m.o()))
print("")
def create_optimization_model(self, config):
self.logger.info('Creating optimization model.')
# Consider using context managers
# limit_sell = False
# GET COMPONENTS FROM SYSTEM
if self.system.has_battery:
battery = self.system.get_battery_object()
if self.system.has_external_grid:
supply = self.system.get_external_grid_object()
# STARTING MODEL
m = pk.block()
# Track the default attributes of the model to be aware of which the user adds.
default_attributes = set(m.__dict__.keys())
default_attributes.add('default_attributes')
# SETS
m.periods = range(config['periods'])
m.E_set = []
# VARIABLES
m.E = pk.variable_dict()
if self.system.has_stochastic_generators and not self.system.has_external_grid:
m.E_set.append('stochastic')
m.E['stochastic'] = pk.variable_list()
for t in m.periods:
m.E['stochastic'].append(
pk.variable(domain_type=pk.RealSet,
lb=0,
ub=self.system.stochastic_electrical_gen[t]))
if self.system.has_external_grid:
m.E_set.append('buy')
m.E_set.append('sell')
m.E['buy'] = pk.variable_list()
for _ in m.periods:
m.E['buy'].append(pk.variable(domain=pk.NonNegativeReals))
m.E['sell'] = pk.variable_list()
for _ in m.periods:
m.E['sell'].append(pk.variable(domain=pk.NonNegativeReals))
m.y_grid = pk.variable_list()
for _ in m.periods:
m.y_grid.append(
pk.variable(domain_type=pk.IntegerSet, lb=0, ub=1))
if self.system.has_battery:
m.E_set.append('batt_chrg')
m.E_set.append('batt_dis')
m.E['batt_chrg'] = pk.variable_list()
for _ in m.periods:
# The upper bound are impose in the constraints below
m.E['batt_chrg'].append(
pk.variable(domain_type=pk.RealSet, lb=0))
m.E['batt_dis'] = pk.variable_list()
for _ in m.periods:
m.E['batt_dis'].append(
pk.variable(domain_type=pk.RealSet, lb=0))
m.y_bat = pk.variable_list()
for _ in m.periods:
m.y_bat.append(
pk.variable(domain_type=pk.IntegerSet, lb=0, ub=1))
m.soc = pk.variable_list()
for _ in m.periods:
m.soc.append(
pk.variable(domain_type=pk.RealSet,
lb=battery.soc_lb,
ub=battery.soc_ub))
# Extra soc variable for the last value of soc that should be >= soc_l
m.soc.append(
pk.variable(domain_type=pk.RealSet,
lb=battery.soc_l,
ub=battery.soc_ub))
# PARAMETERS
if self.system.has_external_grid:
m.prices = {
'buy': supply.electricity_purchase_prices.copy(),
'sell': supply.electricity_selling_prices.copy(),
}
# OBJECTIVE FUNCTION
obj_exp = 0
obj_sense = pk.minimize
if self.system.has_external_grid:
obj_exp = quicksum((m.E['buy'][t] * m.prices['buy'][t] for t in m.periods), linear=True) \
- quicksum((m.E['sell'][t] * m.prices['sell'][t] for t in m.periods), linear=True)
m.obj = pk.objective(obj_exp, sense=obj_sense)
# CONSTRAINTS
# Grid constraints
# if limit_sell:
# m.c_limit_sell = pk.constraint(
# lb=0, body=system['selling_ratio']
# * sum(m.E['buy'][t] + system['E_pv'][t] for t in m.periods)
# - sum(m.E['sell'][t] for t in m.periods))
grid_m = 1e5
m.cl_y_buy = pk.constraint_list()
for t in m.periods:
m.cl_y_buy.append(
pk.constraint(body=m.y_grid[t] * grid_m - m.E['buy'][t], lb=0))
m.cl_y_sell = pk.constraint_list()
for t in m.periods:
m.cl_y_sell.append(
pk.constraint(body=(1 - m.y_grid[t]) * grid_m - m.E['sell'][t],
lb=0))
# Balance constraints
energy_balance_exp = [0 for _ in m.periods]
if self.system.has_fix_loads:
for t in m.periods:
energy_balance_exp[t] = -1 * self.system.fix_electrical_load[t]
if self.system.has_external_grid:
for t in m.periods:
energy_balance_exp[
t] = energy_balance_exp[t] + m.E['buy'][t] - m.E['sell'][t]
if self.system.has_battery:
for t in m.periods:
energy_balance_exp[t] = energy_balance_exp[t] + m.E[
'batt_dis'][t] - m.E['batt_chrg'][t]
if self.system.has_stochastic_generators and not self.system.has_external_grid:
for t in m.periods:
energy_balance_exp[
t] = energy_balance_exp[t] + m.E['stochastic'][t]
else:
for t in m.periods:
energy_balance_exp[t] = energy_balance_exp[
t] + self.system.stochastic_electrical_gen[t]
m.cl_balance = pk.constraint_list()
for t in m.periods:
m.cl_balance.append(
pk.constraint(body=energy_balance_exp[t], rhs=0))
# Battery constraints and restrictions
if self.system.has_battery:
m.soc[0].fix(battery.soc_0)
m.cl_soc = pk.constraint_list()
for t in m.periods:
m.cl_soc.append(
pk.constraint(
body=battery.batt_C * (m.soc[t + 1] - m.soc[t]) +
1 / battery.batt_dis_per * m.E['batt_dis'][t] -
battery.batt_chrg_per * m.E['batt_chrg'][t],
rhs=0))
m.cl_y_char = pk.constraint_list()
for t in m.periods:
m.cl_y_char.append(
pk.constraint(body=m.y_bat[t] * battery.batt_chrg_speed -
m.E['batt_chrg'][t],
lb=0))
m.cl_y_dis = pk.constraint_list()
for t in m.periods:
m.cl_y_char.append(
pk.constraint(
body=(1 - m.y_bat[t]) * battery.batt_dis_speed -
m.E['batt_dis'][t],
lb=0))
# FINISHING
# Determine the user defined attributes (written in this source code) by subtracting the defaults one.
all_attributes = set(m.__dict__.keys())
m.user_defined_attributes = list(all_attributes - default_attributes)
self.optimization_model = m
return m
# @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
m.o = pmo.objective(-m.v)
# @Objectives_single
# @Objectives_dict
m.od = pmo.objective_dict()
for i in m.s:
m.od[i] = \
pmo.objective(-m.vd[i])
# @Objectives_dict
# @Objectives_list
# uses 0-based indexing
m.ol = pmo.objective_list()
for j in m.q:
m.ol.append(pmo.objective(-m.vl[j]))
# @Objectives_list
# @SOS_single
-2.0 * package.sqrt(0.5 * (x**2 + y**2))) -
package.exp(
0.5 * (package.cos(2*np.pi*x) + \
package.cos(2*np.pi*y))) + \
np.e + 20.0)
def g(x, y, package=pmo):
return (x - 3)**2 + (y - 1)**2
m = pmo.block()
m.x = pmo.variable(lb=-5, ub=5)
m.y = pmo.variable(lb=-5, ub=5)
m.z = pmo.variable()
m.obj = pmo.objective(m.z)
m.real = pmo.block()
m.real.f = pmo.constraint(m.z >= f(m.x, m.y))
m.real.g = pmo.constraint(m.z == g(m.x, m.y))
#
# Approximate f and g using piecewise-linear functions
#
m.approx = pmo.block()
tri = pmo.component_piecewise.util.generate_delaunay([m.x, m.y], num=25)
pw_xarray, pw_yarray = np.transpose(tri.points)
fvals = f(pw_xarray, pw_yarray, package=np)
model.con_capacity = pmo.constraint_list()
for j in model.set_bins:
model.con_capacity.append(
pmo.constraint(
sum(model.var_pack[(i, j)] * weights[i]
for i in model.set_items) <= capacity))
model.con_ispack = pmo.constraint_list()
for i in model.set_items:
model.con_ispack.append(
pmo.constraint(
sum(model.var_pack[(i, j)] for j in model.set_bins) == 1))
model.con_use = pmo.constraint_list()
K = 10
for j in model.set_bins:
model.con_use.append(
pmo.constraint(
sum(model.var_pack[(i, j)]
for i in model.set_items) - K * model.var_bin[j] <= 0))
# Create the objective
model.obj = pmo.objective(sum(model.var_bin[j] for j in model.set_bins))
# Solve
opt = pmo.SolverFactory('cplex')
result = opt.solve(model, tee=True)
print('Total value = ', pmo.value(model.obj), '\n')
# %%
# using data expressions
d = pmo.expression_list(
pmo.data_expression() for i in range(2))
s = pmo.sos([v1,v2], weights=d)
assert len(s.weights) == 2
d[0].expr = p[0] + 1
d[1].expr = p[0] + p[1]
assert tuple(pmo.value(w) for w in s.weights) == (2, 3)
#
# Example model (discontiguous variable domain)
#
domain = [-1.1, 4.49, 8.1, -30.2, 12.5]
m = pmo.block()
m.z = pmo.variable_list(
pmo.variable(lb=0)
for i in range(len(domain)))
m.y = pmo.variable()
m.o = pmo.objective(m.y, sense=pmo.maximize)
m.c1 = pmo.constraint(
m.y == sum(v*z for v,z in zip(m.z, domain)))
m.c2 = pmo.constraint(
sum(m.z) == 1)
m.s = pmo.sos1(m.z)
def get_mock_model(self):
model = pmo.block()
model.x = pmo.variable(domain=Binary)
model.con = pmo.constraint(expr=model.x >= 1)
model.obj = pmo.objective(expr=model.x)
return model
import pyomo.kernel as pmo
#
# Blocks
#
# define a simple optimization model
b = pmo.block()
b.x = pmo.variable()
b.c = pmo.constraint(expr=b.x >= 1)
b.o = pmo.objective(expr=b.x)
# define an optimization model with indexed containers
b = pmo.block()
b.p = pmo.parameter()
b.plist = pmo.parameter_list(pmo.parameter() for i in range(10))
b.pdict = pmo.parameter_dict(
((i, j), pmo.parameter()) for i in range(10) for j in range(10))
b.x = pmo.variable()
b.xlist = pmo.variable_list(pmo.variable() for i in range(10))
b.xdict = pmo.variable_dict(
((i, j), pmo.variable()) for i in range(10) for j in range(10))
b.c = pmo.constraint(b.x >= 1)
b.clist = pmo.constraint_list(
pmo.constraint(b.xlist[i] >= i) for i in range(10))
b.cdict = pmo.constraint_dict(((i, j), pmo.constraint(b.xdict[i, j] >= i * j))
for i in range(10) for j in range(10))
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.s = [1, 2]
model.x_unused = pmo.variable(domain=pmo.Integers)
model.x_unused.stale = False
model.x_unused_initialy_stale = pmo.variable(domain=pmo.Integers)
model.x_unused_initialy_stale.stale = True
model.X_unused = pmo.create_variable_dict(keys=model.s,
domain=pmo.Integers)
model.X_unused_initialy_stale = \
pmo.create_variable_dict(keys=model.s,
domain=pmo.Integers)
for i in model.s:
model.X_unused[i].stale = False
model.X_unused_initialy_stale[i].stale = True
model.x = pmo.variable(domain=pmo.IntegerInterval(bounds=(None, None)))
model.x.stale = False
model.x_initialy_stale = pmo.variable(domain=pmo.Integers)
model.x_initialy_stale.stale = True
model.X = pmo.create_variable_dict(keys=model.s, domain=pmo.Integers)
model.X_initialy_stale = pmo.create_variable_dict(keys=model.s,
domain=pmo.Integers)
for i in model.s:
model.X[i].stale = False
model.X_initialy_stale[i].stale = True
model.obj = pmo.objective(model.x + \
model.x_initialy_stale + \
sum(model.X.values()) + \
sum(model.X_initialy_stale.values()))
model.c = pmo.constraint_dict()
model.c[1] = pmo.constraint(model.x >= 1)
model.c[2] = pmo.constraint(model.x_initialy_stale >= 1)
model.c[3] = pmo.constraint(model.X[1] >= 0)
model.c[4] = pmo.constraint(model.X[2] >= 1)
model.c[5] = pmo.constraint(model.X_initialy_stale[1] >= 0)
model.c[6] = pmo.constraint(model.X_initialy_stale[2] >= 1)
# Test that stale flags do not get updated
# on inactive blocks (where "inactive blocks" mean blocks
# that do NOT follow a path of all active parent blocks
# up to the top-level model)
flat_model = model.clone()
model.b = pmo.block()
model.B = pmo.block_dict()
model.b.b = flat_model.clone()
model.B[1] = pmo.tiny_block()
model.B[1].b = flat_model.clone()
model.B[2] = pmo.tiny_block()
model.B[2].b = flat_model.clone()
model.b.deactivate()
model.B.deactivate(shallow=False)
model.b.b.activate()
model.B[1].b.activate()
model.B[2].b.deactivate()
assert model.b.active is False
assert model.B[1].active is False
assert model.B[1].active is False
assert model.b.b.active is True
assert model.B[1].b.active is True
assert model.B[2].b.active is False
def test_conic(self):
model = pmo.block()
model.o = pmo.objective(0.0)
model.c = pmo.constraint(body=0.0, rhs=1)
b = model.quadratic = pmo.block()
b.x = pmo.variable_tuple((pmo.variable(), pmo.variable()))
b.r = pmo.variable(lb=0)
b.c = pmo.conic.quadratic(x=b.x, r=b.r)
model.o.expr += b.r
model.c.body += b.r
del b
b = model.rotated_quadratic = pmo.block()
b.x = pmo.variable_tuple((pmo.variable(), pmo.variable()))
b.r1 = pmo.variable(lb=0)
b.r2 = pmo.variable(lb=0)
b.c = pmo.conic.rotated_quadratic(x=b.x, r1=b.r1, r2=b.r2)
model.o.expr += b.r1 + b.r2
model.c.body += b.r1 + b.r2
del b
if mosek_version >= (9, 0, 0):
b = model.primal_exponential = pmo.block()
b.x1 = pmo.variable(lb=0)
b.x2 = pmo.variable()
b.r = pmo.variable(lb=0)
b.c = pmo.conic.primal_exponential(x1=b.x1, x2=b.x2, r=b.r)
model.o.expr += b.r
model.c.body += b.r
del b
b = model.primal_power = pmo.block()
b.x = pmo.variable_tuple((pmo.variable(), pmo.variable()))
b.r1 = pmo.variable(lb=0)
b.r2 = pmo.variable(lb=0)
b.c = pmo.conic.primal_power(x=b.x, r1=b.r1, r2=b.r2, alpha=0.6)
model.o.expr += b.r1 + b.r2
model.c.body += b.r1 + b.r2
del b
b = model.dual_exponential = pmo.block()
b.x1 = pmo.variable()
b.x2 = pmo.variable(ub=0)
b.r = pmo.variable(lb=0)
b.c = pmo.conic.dual_exponential(x1=b.x1, x2=b.x2, r=b.r)
model.o.expr += b.r
model.c.body += b.r
del b
b = model.dual_power = pmo.block()
b.x = pmo.variable_tuple((pmo.variable(), pmo.variable()))
b.r1 = pmo.variable(lb=0)
b.r2 = pmo.variable(lb=0)
b.c = pmo.conic.dual_power(x=b.x, r1=b.r1, r2=b.r2, alpha=0.4)
model.o.expr += b.r1 + b.r2
model.c.body += b.r1 + b.r2
opt = pmo.SolverFactory("mosek")
results = opt.solve(model)
self.assertEqual(results.solution.status, SolutionStatus.optimal)
def __init__(self):
self._pyomo_model = pmo.block()
self._pyomo_model.o = pmo.objective(sense=pmo.minimize)
self._pyomo_model_objective = self._pyomo_model.o
super(Min, self).__init__()
import pyomo.kernel as pmo
model = pmo.block()
model.x = pmo.variable()
model.c = pmo.constraint(model.x >= 1)
model.o = pmo.objective(model.x)
opt = pmo.SolverFactory("ipopt")
result = opt.solve(model)
assert str(result.solver.termination_condition) == "optimal"
import pyomo.kernel as pmo # # Suffixes # # collect dual information when the model is solved b = pmo.block() b.x = pmo.variable() b.c = pmo.constraint(expr=b.x >= 1) b.o = pmo.objective(expr=b.x) b.dual = pmo.suffix(direction=pmo.suffix.IMPORT) # suffixes behave as dictionaries that map # components to values s = pmo.suffix() assert len(s) == 0 v = pmo.variable() s[v] = 2 assert len(s) == 1 assert bool(v in s) == True assert s[v] == 2 # error (a dict / list container is not a component) vlist = pmo.variable_list() s[vlist] = 1
pmo.constraint(
sum(model.var_x[(_worker, _task)] for _worker in team1
for _task in model.set_tasks) <= TEAM_MAX))
model.con_team.append(
pmo.constraint(
sum(model.var_x[(_worker, _task)] for _worker in team2
for _task in model.set_tasks) <= TEAM_MAX))
# 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]))
