def test_mgv0(self):
from lms2 import MainGridV0
from pyomo.environ import AbstractModel, TransformationFactory, Param, Var
from pyomo.dae import ContinuousSet
from pyomo.network import Port
m = AbstractModel()
m.time = ContinuousSet(bounds=(0, 10))
m.mg = MainGridV0()
data_main_grid_v0 = {'time': {None: [0, 2]}, 'cost': {None: 0.15}}
data = \
{None:
{
'time' : {None: [0, 10]},
'mg' : data_main_grid_v0
}
}
inst = m.create_instance(data)
TransformationFactory('dae.finite_difference').apply_to(inst, nfe=2)
self.assertTrue(hasattr(m.mg, 'outlet'))
self.assertIsInstance(m.mg.outlet, Port)
def test_pickle_abstract_model_virtual_set(self):
model = AbstractModel()
model._a = Set(initialize=[1,2,3])
model.A = model._a * model._a
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
def test_pickle_abstract_model_indexed_constraint(self):
model = AbstractModel()
model.x = Var()
model.A = Constraint([1,2,3], rule=simple_con_rule)
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
def test_none_key(self):
model = AbstractModel()
model.b = Block()
inst = model.create_instance()
self.assertEqual(id(inst.b), id(inst.b[None]))
def test_abs(self):
from lms2 import FlowSource
from pyomo.environ import AbstractModel, TransformationFactory
from pyomo.dae import ContinuousSet
from pyomo.network import Port
m = AbstractModel()
m.time = ContinuousSet()
m.u = FlowSource(flow_name='p')
data_unit = dict(time={None: [0, 15]})
data = \
{None:
{
'time': {None: [0, 15]},
'u': data_unit
}
}
inst = m.create_instance(data)
TransformationFactory('dae.finite_difference').apply_to(inst, nfe=1)
self.assertTrue(hasattr(m.u, 'p'))
self.assertTrue(hasattr(m.u, 'outlet'))
self.assertIsInstance(m.u.outlet, Port)
self.assertEqual(inst.u.time.data(), (0, 15))
self.assertEqual(inst.time.data(), (0, 15))
def test_len(self):
model = AbstractModel()
model.e = Expression()
self.assertEqual(len(model.e), 0)
inst = model.create_instance()
self.assertEqual(len(inst.e), 1)
def test_join_sets(self):
"""
:return:
"""
mod = AbstractModel()
# If set list empty
set_list_empty_actual = auxiliary_module_to_test.join_sets(mod, [])
self.assertListEqual(set_list_empty_actual, [])
# If single set in list
mod.set1 = [1, 2, 3]
set_list_single_set = ["set1"]
single_set_expected = [1, 2, 3]
single_set_actual = auxiliary_module_to_test.join_sets(mod, set_list_single_set)
self.assertListEqual(single_set_expected, single_set_actual)
# If more than one set
mod.set2 = [4, 5, 6]
set_list_two_sets = ["set1", "set2"]
two_sets_joined_expected = [1, 2, 3, 4, 5, 6]
two_sets_joined_actual = auxiliary_module_to_test.join_sets(
mod, set_list_two_sets
)
self.assertListEqual(two_sets_joined_expected, two_sets_joined_actual)
def test_error1(self):
model = AbstractModel()
try:
model.a = BuildCheck()
self.fail("Expected ValueError")
except ValueError:
pass
def test_create_from_dict(self):
model = AbstractModel()
model.A = RangeSet(2)
def _b_rule(b, id):
b.S = Set()
b.P = Param()
b.Q = Param(b.S)
model.B = Block(model.A, rule=_b_rule)
instance = model.create_instance( {None:{'B': \
{1:{'S':{None:['a','b','c']}, \
'P':{None:4}, \
'Q':{('a',):1,('b',):2,('c',):3}}, \
2:{'S':{None:[]}, \
'P':{None:3}} \
} \
}} )
self.assertEqual(set(instance.B[1].S), set(['a', 'b', 'c']))
self.assertEqual(value(instance.B[1].P), 4)
self.assertEqual(value(instance.B[1].Q['a']), 1)
self.assertEqual(value(instance.B[1].Q['b']), 2)
self.assertEqual(value(instance.B[1].Q['c']), 3)
self.assertEqual(value(instance.B[2].P), 3)
def test_instanciate_prog(self):
from lms2 import ProgrammableLoad, DebugSource
from pyomo.environ import AbstractModel, TransformationFactory, Param, Var
from pyomo.dae import ContinuousSet
import pandas as pd
m = AbstractModel()
m.time = ContinuousSet(bounds=(0, 1))
m.prog = ProgrammableLoad()
UB = 1e6
df = pd.Series({0: 0, 1: 1, 2: 2, 3: 1, 4: 0})
data_prog = {
'time': {None: [0, 10]},
'w1': {None: 3},
'w2': {None: 8},
'window': {None: [2, 8]},
'profile_index': {None: df.index},
'profile_value': df.to_dict()}
data = \
{None:
{
'time': {None: [0, 10]},
'prog': data_prog
}
}
inst = m.create_instance(data)
TransformationFactory('dae.finite_difference').apply_to(inst, nfe=10)
inst.prog.compile()
def test_pickle_abstract_model_objective(self):
model = AbstractModel()
model.x = Var()
model.A = Objective(expr=model.x <= 0)
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
def test_pickle_abstract_model_constraint(self):
model = AbstractModel()
model.x = Var()
model.A = Constraint(expr=model.x <= 0)
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
def __init__(self, name, description='', version=''):
self.pyomo_model = AbstractModel(name=name)
self.name = name
self.namespace = '{}_namespace'.format(name.lower().replace(' ', '_'))
self.description = description
self.version = version
self.problem_detail = None
self._set_component_problems()
def test_len(self):
"""Test len method"""
model = AbstractModel()
model.x = Var()
model.c = Constraint(rule=lambda m: m.x == 1)
self.assertEqual(len(model.c),0)
inst = model.create_instance()
self.assertEqual(len(inst.c),1)
def test_error2(self):
try:
model = AbstractModel()
model.a = Var(initialize=[1, 2, 3])
model.b = Var(model.a)
self.fail("test_error2")
except TypeError:
pass
def setUp(self):
#
# Create model instance
#
model = AbstractModel()
model.A = Param(initialize=3.3, mutable=True)
model.action1 = BuildAction(rule=action1_fn)
self.instance = model.create_instance()
def get_model():
"""This function prepares the abstract model"""
model = AbstractModel()
add_params(model)
add_vars(model)
add_constraints(model)
model.OBJ = Objective(rule=objective, sense=minimize)
return model
def test_abstract_index(self):
model = AbstractModel()
model.A = Set(initialize=[0])
model.B = Set(initialize=[1])
model.C = model.A | model.B
M = ConcreteModel()
M.x = Var([1,2,3])
M.c = SOSConstraint(model.C, var=M.x, sos=1, index={0:[1,2], 1:[2,3]})
def test_len(self):
"""Test len method"""
model = AbstractModel()
model.x = Var()
model.c = Constraint(rule=lambda m: m.x == 1)
self.assertEqual(len(model.c), 0)
inst = model.create_instance()
self.assertEqual(len(inst.c), 1)
def test_init_abstract_indexed(self):
model = AbstractModel()
model.ec = Expression([1,2,3],initialize=1.0)
model.obj = Objective(rule=lambda m: 1.0+sum_product(m.ec,index=[1,2,3]))
inst = model.create_instance()
self.assertEqual(inst.obj.expr(),4.0)
inst.ec[1].set_value(2.0)
self.assertEqual(inst.obj.expr(),5.0)
def create_model(self,abstract=False):
if abstract is True:
model = AbstractModel()
else:
model = ConcreteModel()
model.x = Var()
model.y = Var()
model.z = Var()
return model
def test_mgv2(self):
from lms2 import MainGridV2
from pyomo.environ import AbstractModel, TransformationFactory, Param, Var
from pyomo.dae import ContinuousSet
from pyomo.network import Port
m = AbstractModel()
m.time = ContinuousSet(bounds=(0, 10))
m.mg = MainGridV2()
data_main_grid_v2 = {
'time': {
None: [0, 2]
},
'pmax': {
None: +100.0
},
'pmin': {
None: -100.0
},
'cost_in_index': {
None: [0, 1, 2]
},
'cost_out_index': {
None: [0, 1, 2]
},
'cost_in_value': dict(zip([0, 1, 2], [0.1, 0.12, 0.12])),
'cost_out_value': dict(zip([0, 1, 2], [0.15, 0.13, 0.13]))
}
data = \
{None:
{
'time': {None: [0, 10]},
'mg': data_main_grid_v2
}
}
inst = m.create_instance(data)
TransformationFactory('dae.finite_difference').apply_to(inst, nfe=2)
self.assertTrue(hasattr(m.mg, 'outlet'))
self.assertIsInstance(m.mg.outlet, Port)
self.assertEqual(inst.mg.cost_out.extract_values(), {
0: 0.15,
1.0: 0.13,
2: 0.13
})
self.assertEqual(inst.mg.cost_in.extract_values(), {
0: 0.1,
1.0: 0.12,
2: 0.12
})
self.assertEqual(inst.mg.cost_in_index.data(), (0, 1, 2))
self.assertEqual(inst.mg.cost_out_index.data(), (0, 1, 2))
def test_len(self):
model = AbstractModel()
model.b = Block()
# TODO: I think the correct answer should be zero before
# construction
self.assertEqual(len(model.b), 1)
inst = model.create_instance()
self.assertEqual(len(inst.b), 1)
def test_nonindexed_block_immutable_param(self):
model = AbstractModel()
def _b_rule(b):
b.A = Param(initialize=2.0)
model.B = Block(rule=_b_rule)
instance = model.create_instance()
self.assertEqual(value(instance.B.A), 2.0)
def test_getattr1(self):
"""
Verify the behavior of non-standard suffixes with simple variable
"""
model = AbstractModel()
model.a = Var()
model.suffix = Suffix(datatype=Suffix.INT)
instance = model.create_instance()
self.assertEqual(instance.suffix.get(instance.a), None)
instance.suffix.set_value(instance.a, True)
self.assertEqual(instance.suffix.get(instance.a), True)
def test_mutable_var_bounds_upper(self):
model = AbstractModel()
model.Q = Param(initialize=2.0, mutable=True)
model.X = Var(bounds=(model.Q, None))
instance = model.create_instance()
self.assertEqual(instance.X.bounds, (2.0, None))
instance.Q = 4.0
self.assertEqual(instance.X.bounds, (4.0, None))
def test_indexed_block_immutable_param(self):
model = AbstractModel()
model.A = RangeSet(2)
def _b_rule(b, id):
b.A = Param(initialize=id)
model.B = Block(model.A, rule=_b_rule)
instance = model.create_instance()
self.assertEqual(value(instance.B[1].A), 1)
self.assertEqual(value(instance.B[2].A), 2)
def test_unbounded_mip(self):
with SolverFactory("cplex", solver_io="python") as opt:
model = AbstractModel()
model.X = Var(within=Integers)
model.O = Objective(expr=model.X)
instance = model.create_instance()
results = opt.solve(instance)
self.assertIn(results.solver.termination_condition,
(TerminationCondition.unbounded,
TerminationCondition.infeasibleOrUnbounded))
def test_expr2(self):
model = AbstractModel()
model.A = Set(initialize=[1, 2, 3])
model.B = Param(model.A,
initialize={
1: 100,
2: 200,
3: 300
},
mutable=True)
model.C = Param(model.A,
initialize={
1: 100,
2: 200,
3: 300
},
mutable=False)
model.x = Var(model.A)
model.y = Var(model.A)
instance = model.create_instance()
expr = sum_product(instance.x, instance.B, instance.y, index=[1, 3])
baseline = "B[1]*x[1]*y[1] + B[3]*x[3]*y[3]"
self.assertEqual(str(expr), baseline)
expr = sum_product(instance.x, instance.C, instance.y, index=[1, 3])
self.assertEqual(str(expr), "100*x[1]*y[1] + 300*x[3]*y[3]")
def setUp(self):
# This class tests the Pyomo 5.x expression trees
def d_fn(model):
return model.c+model.c
self.model = AbstractModel()
self.model.a = Var(initialize=1.0)
self.model.b = Var(initialize=2.0)
self.model.c = Param(initialize=1, mutable=True)
self.model.d = Param(initialize=d_fn, mutable=True)
self.model.e = Param(initialize=d_fn, mutable=False)
self.model.f = Param(initialize=0, mutable=True)
self.model.g = Var(initialize=0)
self.instance = self.model.create_instance()
class PyomoModel(unittest.TestCase):
def setUp(self):
self.model = AbstractModel()
self.instance = None
def tearDown(self):
self.model = None
self.instance = None
def construct(self, filename=None):
if filename is not None:
self.instance = self.model.create_instance(filename)
else:
self.instance = self.model.create_instance()
def inf_conc_mod(seed_set: Sequence[Hashable], abs_mod: AbstractModel,
input_graph: Graph,
solve: Optional[bool] = None) -> Union[float,
ConcreteModel]:
"""Instantiate a concrete instance of the model."""
inst = abs_mod.create_instance()
# Sets
inst.S = Set(initialize=seed_set)
inst.VmS = inst.V - inst.S
# Objective Function
o_expr = sum(inst.pi[i] for i in inst.VmS)
inst.obj = Objective(expr=o_expr, sense=minimize)
# Constraints
inst.flow_profit = Constraint(inst.E,
rule=(lambda model, i, j:
(model.pi[i] - model.pi[j] <=
input_graph.es[
input_graph.get_eid(i, j)]["q"])
)
)
inst.seed = Constraint(inst.S, rule=lambda model, i: model.pi[i] == 1)
if solve:
SOLVER.solve(inst)
return value(inst.obj) + len(seed_set)
# else
return inst
def test_min_data_check(self):
from switch_model.utilities import _add_min_data_check
from pyomo.environ import AbstractModel, Param, Set
mod = AbstractModel()
_add_min_data_check(mod)
mod.set_A = Set(initialize=[1,2])
mod.paramA_full = Param(mod.set_A, initialize={1:'a',2:'b'})
mod.paramA_empty = Param(mod.set_A)
mod.min_data_check('set_A', 'paramA_full')
self.assertIsNotNone(mod.create_instance())
mod.min_data_check('set_A', 'paramA_empty')
# Fiddle with the pyomo logger to suppress its error message
logger = logging.getLogger('pyomo.core')
orig_log_level = logger.level
logger.setLevel(logging.FATAL)
with self.assertRaises(ValueError):
mod.create_instance()
logger.setLevel(orig_log_level)
from pyomo.environ import \
AbstractModel, Var, Set, Param,\
Objective, Constraint, minimize, NonNegativeReals
from pyomo.opt import SolverFactory, SolverManagerFactory
model = AbstractModel()
model.NUTR = Set()
model.FOOD = Set()
model.cost = Param(model.FOOD)
model.f_min = Param(model.FOOD)
model.f_max = Param(model.FOOD)
model.n_min = Param(model.NUTR)
model.n_max = Param(model.NUTR)
model.amt = Param(model.NUTR, model.FOOD)
def variable_constraints_function(model, i):
return (model.f_min[i], model.f_max[i])
model.buy = Var(
model.FOOD, domain=NonNegativeReals, bounds=variable_constraints_function
)
def total_cost_function(model):
return sum(model.buy[i]*model.cost[i] for i in model.FOOD)
model.total_cost = Objective(rule=total_cost_function, sense=minimize)
from pyomo.environ import \
AbstractModel, Var, Set, Param,\
Objective, Constraint, maximize, NonNegativeReals
from pyomo.opt import SolverFactory, SolverManagerFactory
modelo = AbstractModel()
modelo.productos = Set()
modelo.plantas = Set()
modelo.tiempo_disponible = Param(modelo.plantas)
modelo.ganancia_unitaria = Param(modelo.productos)
modelo.tiempo_produccion = Param(modelo.plantas, modelo.productos)
modelo.produccion = Var(modelo.productos, domain=NonNegativeReals)
def funcion_disponibilidad_tiempo(modelo, planta):
return (
sum(
modelo.tiempo_produccion[planta, producto] *
modelo.produccion[producto]
for producto in modelo.productos
) <= modelo.tiempo_disponible[planta]
)
modelo.disponibilidad_tiempo = Constraint(
modelo.plantas, rule=funcion_disponibilidad_tiempo
)
def funcion_ganancias(modelo):
def test_abstract_index(self):
model = AbstractModel()
model.A = Set()
model.B = Set()
model.C = model.A | model.B
model.x = Constraint(model.C)
def disjunctionToCut(lp, pi, pi0, integerIndices = None, sense = '>=',
sol = None, debug_print = False, use_cylp = True):
me = "cglp_cuts: "
if sol is None:
sol = lp.primalVariableSolution['x']
infinity = lp.getCoinInfinity()
if debug_print:
print(me, "constraints sense = ", sense)
print(me, "con lower bounds = ", lp.constraintsLower)
print(me, "con upper bounds = ", lp.constraintsUpper)
print(me, "con matrix = ", lp.coefMatrix.toarray())
print(me, "vars lower bounds = ", lp.variablesLower)
print(me, "vars upper bounds = ", lp.variablesUpper)
print(me, "Assuming objective is to minimize")
print(me, "objective = ", lp.objective)
print(me, "infinity = ", infinity)
print(me, "current point = ", sol)
print(me, "pi = ", pi)
print(me, "pi0 = ", pi0)
A = lp.coefMatrix.toarray()
#c = lp.objective
## Convert to >= if the problem is in <= form.
if sense == '<=':
b = deepcopy(lp.constraintsUpper)
b = -1.0*b
A = -1.0*A
else:
b = deepcopy(lp.constraintsLower)
#Add bounds on variables as explicit constraints
for i in range(lp.nCols):
e = np.zeros((1, lp.nCols))
if lp.variablesUpper[i] < infinity:
b.resize(b.size+1, refcheck = False)
e[0, i] = -1.0
b[-1] = -1.0*lp.variablesUpper[i]
A = np.vstack((A, e))
if lp.variablesLower[i] > -infinity:
b.resize(b.size+1, refcheck = False)
e[0, i] = 1.0
b[-1] = lp.variablesLower[i]
A = np.vstack((A, e))
A = csc_matrixPlus(A)
############################################################################
## There are two given LPs:
## s.t. Ax >= b s.t. Ax >= b
## -pi.x >= -pi_0 pi.x >= pi_0+1
## A, b, c, pi, pi_0 are given
##
## CGLP: alpha.x >= beta should be valid for both LPs above
##
## min alpha.x* - beta
## uA - u0.pi = alpha
## vA + v0.pi = alpha
## ub - u0.pi_0 >= beta
## vb + v0.(pi_0 + 1) >= beta
## u0 + v0 = 1
## u, v, u0, v0 >= 0
## if min value comes out < 0, then (alpha.x >= beta) is a cut.
############################################################################
b = CyLPArray(b)
pi = CyLPArray(pi)
Atran = A.transpose()
if use_cylp:
sp = CyLPModel()
u = sp.addVariable('u', A.shape[0], isInt = False)
v = sp.addVariable('v', A.shape[0], isInt = False)
u0 = sp.addVariable('u0', 1, isInt = False)
v0 = sp.addVariable('v0', 1, isInt = False)
alpha = sp.addVariable('alpha', lp.nVariables, isInt = False)
beta = sp.addVariable('beta', 1, isInt = False)
for i in range(A.shape[1]):
sp += alpha[i] - sum(Atran[i,j]*u[j] for j in range(A.shape[0])) + pi[i]*u0 == 0
for i in range(A.shape[1]):
sp += alpha[i] - sum(Atran[i,j]*v[j] for j in range(A.shape[0])) - pi[i]*v0 == 0
sp += beta - b*u + pi0*u0 <= 0
sp += beta - b*v - (pi0 + 1)*v0 <= 0
sp += u0 + v0 == 1
if sense == '<=':
sp += u >= 0
sp += v >= 0
sp += u0 >= 0
sp += v0 >= 0
else:
#TODO this direction is not debugged
# Is this all we need?
sp += u <= 0
sp += v <= 0
sp += u0 <= 0
sp += v0 <= 0
sp.objective = sum(sol[i]*alpha[i] for i in range(A.shape[1])) - beta
cbcModel = CyClpSimplex(sp).getCbcModel()
cbcModel.logLevel = 0
#cbcModel.maximumSeconds = 5
cbcModel.solve()
beta = cbcModel.primalVariableSolution['beta'][0]
alpha = cbcModel.primalVariableSolution['alpha']
u = cbcModel.primalVariableSolution['u']
v = cbcModel.primalVariableSolution['v']
u0 = cbcModel.primalVariableSolution['u0'][0]
v0 = cbcModel.primalVariableSolution['v0'][0]
if debug_print:
print('Objective Value: ', cbcModel.objectiveValue)
print('alpha: ', alpha, 'alpha*sol: ', np.dot(alpha, sol))
print('beta: ', beta)
print('Violation of cut: ', np.dot(alpha, sol) - beta)
else:
CG = AbstractModel()
CG.u = Var(list(range(A.shape[0])), domain=NonNegativeReals,
bounds = (0.0, None))
CG.v = Var(list(range(A.shape[0])), domain=NonNegativeReals,
bounds = (0.0, None))
CG.u0 = Var(domain=NonNegativeReals, bounds = (0.0, None))
CG.v0 = Var(domain=NonNegativeReals, bounds = (0.0, None))
CG.alpha = Var(list(range(A.shape[0])), domain=Reals,
bounds = (None, None))
CG.beta = Var(domain=Reals, bounds = (None, None))
## Constraints
def pi_rule_left(CG, i):
x = float(pi[i])
return(sum(Atran[i, j]*CG.u[j] for j in range(A.shape[0])) -
x*CG.u0 - CG.alpha[i] == 0.0)
CG.pi_rule_left = Constraint(list(range(A.shape[1])), rule=pi_rule_left)
def pi_rule_right(CG, i):
x = float(pi[i])
return(sum(Atran[i, j]*CG.v[j] for j in range(A.shape[0])) +
x*CG.v0 - CG.alpha[i] == 0.0)
CG.pi_rule_right = Constraint(list(range(A.shape[1])), rule=pi_rule_right)
def pi0_rule_left(CG):
return(sum(b[j]*CG.u[j] for j in range(A.shape[0])) -
pi0*CG.u0 - CG.beta >= 0.0)
CG.pi0_rule_left = Constraint(rule=pi0_rule_left)
def pi0_rule_right(CG):
return(sum(b[j]*CG.v[j] for j in range(A.shape[0])) +
(pi0 + 1)*CG.v0 - CG.beta >= 0.0)
CG.pi0_rule_right = Constraint(rule=pi0_rule_right)
def normalization_rule(CG):
return(CG.u0 + CG.v0 == 1.0)
CG.normalization_rule = Constraint(rule=normalization_rule)
def objective_rule(CG):
return(sum(sol[i]*CG.alpha[i] for i in range(A.shape[1])) -
CG.beta)
CG.objective = Objective(sense=minimize, rule=objective_rule)
opt = SolverFactory("cbc")
instance = CG.create_instance()
#instance.pprint()
#instance.write("foo.nl", format = "nl")
#opt.options['bonmin.bb_log_level'] = 5
#opt.options['bonmin.bb_log_interval'] = 1
results = opt.solve(instance, tee=False)
#results = opt.solve(instance)
instance.solutions.load_from(results)
beta = instance.beta.value
alpha = np.array([instance.alpha[i].value
for i in range(lp.nVariables)])
violation = beta - np.dot(alpha, sol)
if debug_print:
print(me, 'Beta: ', beta)
print(me, 'alpha: ', alpha)
print(me, 'Violation of cut: ', violation)
if violation > 0.001:
if (sense == ">="):
return [(alpha, beta)]
else:
return [(-alpha, -beta)]
return []
from pyomo.environ import AbstractModel, Set, Var, NonNegativeReals model = AbstractModel() model.vertices = Set() model.edges = Set(model.vertices * model.vertices) model.flows = Var(model.edges, within=NonNegativeReals, bounds=(0, 1))
def new_scenario_tree_model():
# https://software.sandia.gov/trac/coopr/browser/coopr.pysp/trunk/coopr/pysp/util/scenariomodels.py
scenario_tree_model = AbstractModel()
# all set/parameter values are strings, representing the names of various
# entities/variables.
scenario_tree_model.Stages = Set(ordered=True)
scenario_tree_model.Nodes = Set()
scenario_tree_model.NodeStage = Param(scenario_tree_model.Nodes,
within=scenario_tree_model.Stages)
scenario_tree_model.Children = Set(scenario_tree_model.Nodes,
within=scenario_tree_model.Nodes, ordered=True)
scenario_tree_model.ConditionalProbability = Param(
scenario_tree_model.Nodes)
scenario_tree_model.Scenarios = Set(ordered=True)
scenario_tree_model.ScenarioLeafNode = Param(scenario_tree_model.Scenarios,
within=scenario_tree_model.Nodes)
scenario_tree_model.StageVariables = Set(scenario_tree_model.Stages)
scenario_tree_model.StageCostVariable = Param(scenario_tree_model.Stages)
# scenario data can be populated in one of two ways. the first is "scenario-based",
# in which a single .dat file contains all of the data for each scenario. the .dat
# file prefix must correspond to the scenario name. the second is "node-based",
# in which a single .dat file contains only the data for each node in the scenario
# tree. the node-based method is more compact, but the scenario-based method is
# often more natural when parameter data is generated via simulation. the default
# is scenario-based.
scenario_tree_model.ScenarioBasedData = Param(within=Boolean,
default=True, mutable=True)
# do we bundle, and if so, how?
scenario_tree_model.Bundling = Param(within=Boolean,
default=False, mutable=True)
scenario_tree_model.Bundles = Set() # bundle names
scenario_tree_model.BundleScenarios = Set(scenario_tree_model.Bundles)
return scenario_tree_model
def test_expression_constructor_coverage(self):
def rule1(model):
expr = model.x
expr = expr == 0.0
expr = expr >= 1.0
return expr
model = AbstractModel()
model.x = Var()
model.y = Var()
model.z = Var()
model.o = Constraint(rule=rule1)
self.assertRaises(TypeError, model.create_instance)
#
def rule1(model):
expr = model.U >= model.x
expr = expr >= model.L
return expr
model = ConcreteModel()
model.x = Var()
model.L = Param(initialize=0)
model.U = Param(initialize=1)
model.o = Constraint(rule=rule1)
#
def rule1(model):
expr = model.x <= model.z
expr = expr >= model.y
return expr
model = AbstractModel()
model.x = Var()
model.y = Var()
model.z = Var()
model.o = Constraint(rule=rule1)
#self.assertRaises(ValueError, model.create_instance)
#
def rule1(model):
expr = model.x >= model.z
expr = model.y >= expr
return expr
model = AbstractModel()
model.x = Var()
model.y = Var()
model.z = Var()
model.o = Constraint(rule=rule1)
#self.assertRaises(ValueError, model.create_instance)
#
def rule1(model):
expr = model.y <= model.x
expr = model.y >= expr
return expr
model = AbstractModel()
model.x = Var()
model.y = Var()
model.o = Constraint(rule=rule1)
#self.assertRaises(ValueError, model.create_instance)
#
def rule1(model):
expr = model.x >= model.L
return expr
model = ConcreteModel()
model.x = Var()
model.L = Param(initialize=0)
model.o = Constraint(rule=rule1)
#
def rule1(model):
expr = model.U >= model.x
return expr
model = ConcreteModel()
model.x = Var()
model.U = Param(initialize=0)
model.o = Constraint(rule=rule1)
#
def rule1(model):
expr=model.x
expr = expr == 0.0
expr = expr <= 1.0
return expr
model = AbstractModel()
model.x = Var()
model.y = Var()
model.z = Var()
model.o = Constraint(rule=rule1)
self.assertRaises(TypeError, model.create_instance)
#
def rule1(model):
expr = model.U <= model.x
expr = expr <= model.L
return expr
model = ConcreteModel()
model.x = Var()
model.L = Param(initialize=0)
model.U = Param(initialize=1)
model.o = Constraint(rule=rule1)
#
def rule1(model):
expr = model.x >= model.z
expr = expr <= model.y
return expr
model = AbstractModel()
model.x = Var()
model.y = Var()
model.z = Var()
model.o = Constraint(rule=rule1)
#self.assertRaises(ValueError, model.create_instance)
#
def rule1(model):
expr = model.x <= model.z
expr = model.y <= expr
return expr
model = AbstractModel()
model.x = Var()
model.y = Var()
model.z = Var()
model.o = Constraint(rule=rule1)
#self.assertRaises(ValueError, model.create_instance)
#
def rule1(model):
expr = model.x <= model.L
return expr
model = ConcreteModel()
model.x = Var()
model.L = Param(initialize=0)
model.o = Constraint(rule=rule1)
#
def rule1(model):
expr = model.y >= model.x
expr = model.y <= expr
return expr
model = AbstractModel()
model.x = Var()
model.y = Var()
model.o = Constraint(rule=rule1)
#self.assertRaises(ValueError, model.create_instance)
#
def rule1(model):
expr = model.U <= model.x
return expr
model = ConcreteModel()
model.x = Var()
model.U = Param(initialize=0)
model.o = Constraint(rule=rule1)
#
def rule1(model):
return model.x+model.x
model = ConcreteModel()
model.x = Var()
try:
model.o = Constraint(rule=rule1)
self.fail("Cannot return an unbounded expression")
except ValueError:
pass
class TestIO(unittest.TestCase):
def setUp(self):
#
# Create Model
#
self.model = AbstractModel()
self.instance = None
def tearDown(self):
if os.path.exists("diffset.dat"):
os.remove("diffset.dat")
self.model = None
self.instance = None
def test_io1(self):
OUTPUT = open("diffset.dat", "w")
OUTPUT.write("data;\n")
OUTPUT.write("set A := 1 3 5 7;\n")
OUTPUT.write("end;\n")
OUTPUT.close()
self.model.A = ContinuousSet()
self.instance = self.model.create_instance("diffset.dat")
self.assertEqual(len(self.instance.A), 4)
def test_io2(self):
OUTPUT = open("diffset.dat", "w")
OUTPUT.write("data;\n")
OUTPUT.write("set A := 1 3 5;\n")
OUTPUT.write("end;\n")
OUTPUT.close()
self.model.A = ContinuousSet(bounds=(0, 4))
self.instance = self.model.create_instance("diffset.dat")
self.assertEqual(len(self.instance.A), 4)
def test_io3(self):
OUTPUT = open("diffset.dat", "w")
OUTPUT.write("data;\n")
OUTPUT.write("set A := 1 3 5;\n")
OUTPUT.write("end;\n")
OUTPUT.close()
self.model.A = ContinuousSet(bounds=(2, 6))
self.instance = self.model.create_instance("diffset.dat")
self.assertEqual(len(self.instance.A), 4)
def test_io4(self):
OUTPUT = open("diffset.dat", "w")
OUTPUT.write("data;\n")
OUTPUT.write("set A := 1 3 5;\n")
OUTPUT.write("end;\n")
OUTPUT.close()
self.model.A = ContinuousSet(bounds=(2, 4))
self.instance = self.model.create_instance("diffset.dat")
self.assertEqual(len(self.instance.A), 3)
def test_io5(self):
OUTPUT = open("diffset.dat", "w")
OUTPUT.write("data;\n")
OUTPUT.write("set A := 1 3 5;\n")
OUTPUT.write("end;\n")
OUTPUT.close()
self.model.A = ContinuousSet(bounds=(0, 6))
self.instance = self.model.create_instance("diffset.dat")
self.assertEqual(len(self.instance.A), 5)
def test_io6(self):
OUTPUT = open("diffset.dat", "w")
OUTPUT.write("data;\n")
OUTPUT.write("set B := 1;\n")
OUTPUT.write("end;\n")
OUTPUT.close()
# Expected ValueError because data set has only one value and no
# bounds are specified
self.model.B = ContinuousSet()
with self.assertRaises(ValueError):
self.instance = self.model.create_instance("diffset.dat")
def test_io7(self):
OUTPUT = open("diffset.dat", "w")
OUTPUT.write("data;\n")
OUTPUT.write("set B := 1;\n")
OUTPUT.write("end;\n")
OUTPUT.close()
self.model.B = ContinuousSet(bounds=(0, 1))
self.instance = self.model.create_instance("diffset.dat")
self.assertEqual(len(self.instance.B), 2)
def setUp(self):
#
# Create Model
#
self.model = AbstractModel()
self.instance = None
