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