def test_temp_swing(self): # Create a flash model with the CO2-H2O property package m = ConcreteModel() m.fs = FlowsheetBlock(default={"dynamic": False}) m.fs.properties = GenericParameterBlock(default=configuration) m.fs.flash = Flash(default={"property_package": m.fs.properties}) # Fix inlet stream state variables m.fs.flash.inlet.flow_mol.fix(9.89433124673833) # mol/s m.fs.flash.inlet.mole_frac_comp[0, 'CO2'].fix(0.13805801934749645) m.fs.flash.inlet.mole_frac_comp[0, 'H2O'].fix(0.8619419806525035) m.fs.flash.inlet.pressure.fix(183430) # Pa m.fs.flash.inlet.temperature.fix(396.79057912844183) # K # Fix flash and its outlet conditions m.fs.flash.deltaP.fix(0) m.fs.flash.vap_outlet.temperature.fix(313.15) # Initialize the flash model m.fs.flash.initialize() # Create a dictionary of expected solution for flash outlet temperature # sweep temp_range = list(np.linspace(313, 396)) expected_vapor_frac = [ 0.14388, 0.14445, 0.14508, 0.14576, 0.1465, 0.14731, 0.14818, 0.14913, 0.15017, 0.15129, 0.15251, 0.15384, 0.15528, 0.15685, 0.15856, 0.16042, 0.16245, 0.16467, 0.16709, 0.16974, 0.17265, 0.17584, 0.17935, 0.18323, 0.18751, 0.19226, 0.19755, 0.20346, 0.21008, 0.21755, 0.22601, 0.23565, 0.24673, 0.25956, 0.27456, 0.29229, 0.31354, 0.33942, 0.37157, 0.4125, 0.46628, 0.53993, 0.64678, 0.81547, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] expected_heat_duty = [ -396276.55508, -394859.42896, -393421.28226, -391960.40602, -390474.94512, -388962.88119, -387422.01297, -385849.93371, -384244.00483, -382601.32549, -380918.69691, -379192.58068, -377419.04976, -375593.73054, -373711.73419, -371767.57480, -369755.07135, -367667.22968, -365496.09940, -363232.59958, -360866.30485, -358385.18097, -355775.25563, -353020.20490, -350100.82935, -346994.38367, -343673.70980, -340106.10300, -336251.80960, -332062.00898, -327476.06061, -322417.68382, -316789.55435, -310465.49473, -303278.90949, -295005.17406, -285333.93764, -273823.89005, -259825.51107, -242341.82570, -219760.16114, -189290.02362, -145647.55666, -77469.59283, -3219.88910, -2631.66067, -2043.09220, -1454.17760, -864.91585, -275.30623 ] outvals = zip(expected_vapor_frac, expected_heat_duty) expected_sol = dict(zip(temp_range, outvals)) # Solve the model for a range of flash outlet temperatures # Perform flash outlet temperature sweep and test the solution for t in temp_range: m.fs.flash.vap_outlet.temperature.fix(t) res = solver.solve(m) assert res.solver.termination_condition == "optimal" frac = value(m.fs.flash.vap_outlet.flow_mol[0]) \ / value(m.fs.flash.inlet.flow_mol[0]) assert frac == pytest.approx(expected_sol[t][0], abs=1e-4) hduty = value(m.fs.flash.heat_duty[0]) assert hduty == pytest.approx(expected_sol[t][1], rel=1e-4)
def test_len_empty(self): """Test len method""" model = ConcreteModel() model.c = Constraint() self.assertEqual(len(model.c), 0)
def __init__(self, y, x, orient, rts, yref=None, xref=None): """DEA model Args: y (float): output variable. x (float): input variables. orient (String): ORIENT_IO (input orientation) or ORIENT_OO (output orientation) rts (String): RTS_VRS (variable returns to scale) or RTS_CRS (constant returns to scale) yref (String, optional): reference output. Defaults to None. xref (String, optional): reference inputs. Defaults to None. """ # TODO(error/warning handling): Check the configuration of the model exist # Initialize DEA model self.__model__ = ConcreteModel() self.x = self.__to_2d_list(x.tolist()) self.y = self.__to_2d_list(y.tolist()) self.orient = orient self.rts = rts self.__reference = False if type(yref) != type(None): self.__reference = True self.yref = self._DEA__to_2d_list(yref) self.xref = self._DEA__to_2d_list(xref) self.__model__.R = Set(initialize=range(len(self.yref))) # Initialize sets self.__model__.I = Set(initialize=range(len(self.y))) self.__model__.J = Set(initialize=range(len(self.x[0]))) self.__model__.K = Set(initialize=range(len(self.y[0]))) # Initialize variable self.__model__.theta = Var(self.__model__.I, doc='efficiency') self.__model__.lamda = Var(self.__model__.I, self.__model__.I, bounds=(0.0, None), doc='intensity variables') # Setup the objective function and constraints if self.orient == ORIENT_IO: self.__model__.objective = Objective(rule=self.__objective_rule(), sense=minimize, doc='objective function') else: self.__model__.objective = Objective(rule=self.__objective_rule(), sense=maximize, doc='objective function') self.__model__.input = Constraint(self.__model__.I, self.__model__.J, rule=self.__input_rule(), doc='input constraint') self.__model__.output = Constraint(self.__model__.I, self.__model__.K, rule=self.__output_rule(), doc='output constraint') if self.rts == RTS_VRS: self.__model__.vrs = Constraint(self.__model__.I, rule=self.__vrs_rule(), doc='various return to scale rule') # Optimize model self.optimization_status = 0 self.problem_status = 0
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
def test_dim(self): """Test dim method""" model = ConcreteModel() model.c = Constraint() self.assertEqual(model.c.dim(),0)
def make_model(): m = ConcreteModel() m.time = ContinuousSet(bounds=(0, 10)) m.space = ContinuousSet(bounds=(0, 5)) m.set1 = Set(initialize=['a', 'b', 'c']) m.set2 = Set(initialize=['d', 'e', 'f']) m.fs = Block() m.fs.v0 = Var(m.space, initialize=1) @m.fs.Block() def b1(b): b.v = Var(m.time, m.space, initialize=1) b.dv = DerivativeVar(b.v, wrt=m.time, initialize=0) b.con = Constraint(m.time, m.space, rule=lambda b, t, x: b.dv[t, x] == 7 - b.v[t, x]) # Inconsistent @b.Block(m.time) def b2(b, t): b.v = Var(initialize=2) @m.fs.Block(m.time, m.space) def b2(b, t, x): b.v = Var(m.set1, initialize=2) @b.Block(m.set1) def b3(b, c): b.v = Var(m.set2, initialize=3) @b.Constraint(m.set2) def con(b, s): return (5 * b.v[s] == m.fs.b2[m.time.first(), m.space.first()].v[c]) # inconsistent @m.fs.Constraint(m.time) def con1(fs, t): return fs.b1.v[t, m.space.last()] == 5 # Will be inconsistent @m.fs.Constraint(m.space) def con2(fs, x): return fs.b1.v[m.time.first(), x] == fs.v0[x] # will be consistent @m.fs.Constraint(m.time, m.space) def con3(fs, t, x): if x == m.space.first(): return Constraint.Skip return fs.b2[t, x].v['a'] == 7. disc = TransformationFactory('dae.collocation') disc.apply_to(m, wrt=m.time, nfe=5, ncp=2, scheme='LAGRANGE-RADAU') disc.apply_to(m, wrt=m.space, nfe=5, ncp=2, scheme='LAGRANGE-RADAU') return m
t_start = time.time() # Run start time m.fs.TGA.initialize() t_initialize = time.time() # Initialization time solver = get_solver('ipopt', optarg) # create solver initialize_by_time_element(m.fs, m.fs.time, solver=solver) solver.solve(m, tee=True) t_simulation = time.time() # Simulation time print("\n") print("----------------------------------------------------------") print('Total initialization time: ', value(t_initialize - t_start), " s") print("----------------------------------------------------------") print("\n") print("----------------------------------------------------------") print('Total simulation time: ', value(t_simulation - t_start), " s") print("----------------------------------------------------------") return m # ----------------------------------------------------------------------------- if __name__ == "__main__": m = ConcreteModel() m = main(m)
def test_staticmethod(self): class Init(object): @staticmethod def a_init(m): return 0 @staticmethod def x_init(m, i): return i + 1 @staticmethod def x2_init(m): return 0 @staticmethod def y_init(m, i, j): return j * (i + 1) m = ConcreteModel() a = Initializer(Init.a_init) self.assertIs(type(a), ScalarCallInitializer) self.assertFalse(a.constant()) self.assertFalse(a.verified) self.assertFalse(a.contains_indices()) self.assertEqual(a(None, 1), 0) m.x = Var([1, 2, 3]) a = Initializer(Init.x_init) self.assertIs(type(a), IndexedCallInitializer) self.assertFalse(a.constant()) self.assertFalse(a.verified) self.assertFalse(a.contains_indices()) self.assertEqual(a(None, 1), 2) a = Initializer(Init.x2_init) self.assertIs(type(a), ScalarCallInitializer) self.assertFalse(a.constant()) self.assertFalse(a.verified) self.assertFalse(a.contains_indices()) self.assertEqual(a(None, 1), 0) m.y = Var([1, 2, 3], [4, 5, 6]) a = Initializer(Init.y_init) self.assertIs(type(a), IndexedCallInitializer) self.assertFalse(a.constant()) self.assertFalse(a.verified) self.assertFalse(a.contains_indices()) self.assertEqual(a(None, (1, 4)), 8) b = CountedCallInitializer(m.x, a) self.assertIs(type(b), CountedCallInitializer) self.assertFalse(b.constant()) self.assertFalse(b.verified) self.assertFalse(a.contains_indices()) self.assertFalse(b._scalar) self.assertIs(a._fcn, b._fcn) c = b(None, 1) self.assertIs(type(c), CountedCallGenerator) self.assertEqual(next(c), 2) self.assertEqual(next(c), 3) self.assertEqual(next(c), 4)
def test_simple_sat_model(self): m = ConcreteModel() m.x = Var() m.c = Constraint(expr=1 == m.x) m.o = Objective(expr=m.x) self.assertTrue(satisfiable(m))
def build_turbine(): m = ConcreteModel() m.fs = FlowsheetBlock(default={"dynamic": False}) m.fs.properties = iapws95.Iapws95ParameterBlock() m.fs.turb = TurbineStage(default={"property_package": m.fs.properties}) return m
def model(self): model = ConcreteModel() model.params = ASM1ParameterBlock() return model
# Copyright (c) 2008-2022 # National Technology and Engineering Solutions of Sandia, LLC # Under the terms of Contract DE-NA0003525 with National Technology and # Engineering Solutions of Sandia, LLC, the U.S. Government retains certain # rights in this software. # This software is distributed under the 3-clause BSD License. # ___________________________________________________________________________ from pyomo.environ import ConcreteModel, RangeSet, Param, Var, Reals, Binary, Objective, Constraint, ConstraintList import math N = 5 M = 6 P = 3 model = ConcreteModel() model.Locations = RangeSet(1, N) model.Customers = RangeSet(1, M) def d_rule(model, n, m): return math.sin(n * 2.33333 + m * 7.99999) model.d = Param(model.Locations, model.Customers, initialize=d_rule, within=Reals)
def build_model_pyomo(resite, params: Dict): """Model build-up using pyomo""" from pyomo.environ import ConcreteModel, NonNegativeReals, Var from resite.models.pyomo_utils import capacity_bigger_than_existing, minimize_total_cost data = resite.data_dict load = data["load"].values regions = resite.regions technologies = resite.technologies tech_points_tuples = list(resite.tech_points_tuples) time_slices = define_time_slices(params["time_resolution"], resite.timestamps) generation_potential_df = data["cap_factor_df"] * data["cap_potential_ds"] costs_df = get_cost_df(technologies, resite.timestamps) model = ConcreteModel() # - Parameters - # covered_load_perc_per_region = dict(zip(regions, params["perc_per_region"])) # - Variables - # # Energy not served model.ens = Var(list(regions), np.arange(len(resite.timestamps)), within=NonNegativeReals) # Portion of capacity at each location for each technology model.y = Var(tech_points_tuples, within=NonNegativeReals, bounds=(0, 1)) # Generation at each time step model.p = Var(tech_points_tuples, np.arange(len(resite.timestamps)), within=NonNegativeReals) # - Constraints - # # Generation limited by generation potential from pyomo.environ import Constraint def generation_limit(model, tech, lon, lat, t): return model.p[tech, lon, lat, t] <= model.y[tech, lon, lat] * generation_potential_df.iloc[t][(tech, lon, lat)] model.generation_limit = Constraint(tech_points_tuples, np.arange(len(resite.timestamps)), rule=generation_limit) # Create generation dictionary for building speed up # Compute a sum of generation per time-step per region region_p_dict = dict.fromkeys(regions) for region in regions: # Get generation potential for points in region for each techno region_tech_points = resite.tech_points_regions_ds[resite.tech_points_regions_ds == region].index region_p_sum = pd.Series([sum(model.p[tech, lon, lat, t] for tech, lon, lat in region_tech_points) for t in np.arange(len(resite.timestamps))], index=np.arange(len(resite.timestamps))) region_p_dict[region] = region_p_sum # Impose a certain percentage of the load to be covered over each time slice def generation_check_rule(model, region, u): return sum(region_p_dict[region][t] for t in time_slices[u]) + \ sum(model.ens[region, t] for t in time_slices[u]) >= \ sum(load[t, regions.index(region)] for t in time_slices[u]) * covered_load_perc_per_region[region] model.generation_check = Constraint(regions, np.arange(len(time_slices)), rule=generation_check_rule) # Percentage of capacity installed must be bigger than existing percentage existing_cap_percentage_ds = data["existing_cap_ds"].divide(data["cap_potential_ds"]) model.potential_constraint = capacity_bigger_than_existing(model, existing_cap_percentage_ds, tech_points_tuples) # - Objective - # # Minimize the capacity that is deployed model.objective = minimize_total_cost(model, data["cap_potential_ds"], regions, np.arange(len(resite.timestamps)), costs_df) resite.instance = model
def test_build(self): model = ConcreteModel() model.params = GenericParameterBlock(default=configuration) assert isinstance(model.params.phase_list, Set) assert len(model.params.phase_list) == 2 for i in model.params.phase_list: assert i in ["Liq", "Vap"] assert model.params.Liq.is_liquid_phase() assert model.params.Vap.is_vapor_phase() assert isinstance(model.params.component_list, Set) assert len(model.params.component_list) == 2 for i in model.params.component_list: assert i in ['H2O', 'CO2'] assert isinstance(model.params.get_component(i), Component) assert isinstance(model.params._phase_component_set, Set) assert len(model.params._phase_component_set) == 3 for i in model.params._phase_component_set: assert i in [("Liq", "H2O"), ("Vap", "H2O"), ("Vap", "CO2")] assert model.params.config.state_definition == FTPx assertStructuredAlmostEqual( model.params.config.state_bounds, { "flow_mol": (0, 10, 20, pyunits.mol / pyunits.s), "temperature": (273.15, 323.15, 1000, pyunits.K), "pressure": (5e4, 108900, 1e7, pyunits.Pa), "mole_frac_comp": { "H2O": (0, 0.5, 1), "CO2": (0, 0.5, 1) } }, item_callback=_as_quantity, ) assert model.params.config.phase_equilibrium_state == { ("Vap", "Liq"): SmoothVLE } assert isinstance(model.params.phase_equilibrium_idx, Set) assert len(model.params.phase_equilibrium_idx) == 1 for i in model.params.phase_equilibrium_idx: assert i in ["PE1"] assert model.params.phase_equilibrium_list == { "PE1": { "H2O": ("Vap", "Liq") } } assert model.params.pressure_ref.value == 101325 assert model.params.temperature_ref.value == 298.15 assert model.params.H2O.mw.value == 18.0153E-3 assert model.params.H2O.pressure_crit.value == 220.64E5 assert model.params.H2O.temperature_crit.value == 647 assert model.params.CO2.mw.value == 44.0095E-3 assert model.params.CO2.pressure_crit.value == 73.825E5 assert model.params.CO2.temperature_crit.value == 304.23 assert_units_consistent(model)
def test_costing(subtype): m = ConcreteModel() m.db = Database() m.fs = FlowsheetBlock(default={"dynamic": False}) m.fs.params = WaterParameterBlock(default={"solute_list": ["sulfur", "toc", "tss"]}) m.fs.costing = ZeroOrderCosting() m.fs.unit1 = FixedBedZO( default={ "property_package": m.fs.params, "database": m.db, "process_subtype": subtype, } ) m.fs.unit1.inlet.flow_mass_comp[0, "H2O"].fix(10000) m.fs.unit1.inlet.flow_mass_comp[0, "sulfur"].fix(1) m.fs.unit1.inlet.flow_mass_comp[0, "toc"].fix(2) m.fs.unit1.inlet.flow_mass_comp[0, "tss"].fix(3) m.fs.unit1.load_parameters_from_database(use_default_removal=True) assert degrees_of_freedom(m.fs.unit1) == 0 m.fs.unit1.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.costing} ) assert isinstance(m.fs.costing.fixed_bed, Block) assert isinstance(m.fs.costing.fixed_bed.capital_a_parameter, Var) assert isinstance(m.fs.costing.fixed_bed.capital_b_parameter, Var) assert isinstance(m.fs.costing.fixed_bed.reference_state, Var) assert isinstance(m.fs.unit1.costing.capital_cost, Var) assert isinstance(m.fs.unit1.costing.capital_cost_constraint, Constraint) assert_units_consistent(m.fs) assert degrees_of_freedom(m.fs.unit1) == 0 assert m.fs.unit1.electricity[0] in m.fs.costing._registered_flows["electricity"] assert ( m.fs.unit1.acetic_acid_demand[0] in m.fs.costing._registered_flows["acetic_acid"] ) assert ( m.fs.unit1.phosphoric_acid_demand[0] in m.fs.costing._registered_flows["phosphoric_acid"] ) assert ( m.fs.unit1.ferric_chloride_demand[0] in m.fs.costing._registered_flows["ferric_chloride"] ) assert ( m.fs.unit1.activated_carbon_demand[0] in m.fs.costing._registered_flows["activated_carbon"] ) assert m.fs.unit1.sand_demand[0] in m.fs.costing._registered_flows["sand"] assert ( m.fs.unit1.anthracite_demand[0] in m.fs.costing._registered_flows["anthracite"] ) assert ( m.fs.unit1.cationic_polymer_demand[0] in m.fs.costing._registered_flows["cationic_polymer"] )
def test_integer_domains(self): m = ConcreteModel() m.x1 = Var(domain=PositiveIntegers) m.c1 = Constraint(expr=m.x1 == 0.5) self.assertFalse(satisfiable(m))
def test_sum3(self): model = ConcreteModel() model.A = Set(initialize=[1,2,3], doc='set A') model.x = Var(model.A) expr = quicksum(model.x) self.assertEqual( expr, 6)
def test_real_domains(self): m = ConcreteModel() m.x1 = Var(domain=NonNegativeReals) m.c1 = Constraint(expr=m.x1 == -1.3) self.assertFalse(satisfiable(m))
def test_power_law_equil_no_order(): m = ConcreteModel() # # Add a test thermo package for validation m.pparams = PhysicalParameterTestBlock() # Add a solid phase for testing m.pparams.sol = SolidPhase() m.thermo = m.pparams.build_state_block([1]) # Create a dummy reaction parameter block m.rparams = GenericReactionParameterBlock( default={ "property_package": m.pparams, "base_units": { "time": pyunits.s, "mass": pyunits.kg, "amount": pyunits.mol, "length": pyunits.m, "temperature": pyunits.K }, "equilibrium_reactions": { "r1": { "stoichiometry": { ("p1", "c1"): -1, ("p1", "c2"): 2, ("sol", "c1"): -3, ("sol", "c2"): 4 }, "equilibrium_form": power_law_equil, "concentration_form": ConcentrationForm.moleFraction } } }) # Create a dummy state block m.rxn = Block([1]) add_object_reference(m.rxn[1], "phase_component_set", m.pparams._phase_component_set) add_object_reference(m.rxn[1], "params", m.rparams) add_object_reference(m.rxn[1], "state_ref", m.thermo[1]) m.rxn[1].k_eq = Var(["r1"], initialize=1) power_law_equil.build_parameters( m.rparams.reaction_r1, m.rparams.config.equilibrium_reactions["r1"]) # Check parameter construction assert isinstance(m.rparams.reaction_r1.reaction_order, Var) assert len(m.rparams.reaction_r1.reaction_order) == 6 assert m.rparams.reaction_r1.reaction_order["p1", "c1"].value == -1 assert m.rparams.reaction_r1.reaction_order["p1", "c2"].value == 2 assert m.rparams.reaction_r1.reaction_order["p2", "c1"].value == 0 assert m.rparams.reaction_r1.reaction_order["p2", "c2"].value == 0 # Solids should have zero order, as they are excluded assert m.rparams.reaction_r1.reaction_order["sol", "c1"].value == 0 assert m.rparams.reaction_r1.reaction_order["sol", "c2"].value == 0 # Check reaction form rform = power_law_equil.return_expression(m.rxn[1], m.rparams.reaction_r1, "r1", 300) assert str(rform) == str(m.rxn[1].k_eq["r1"] == ( m.thermo[1].mole_frac_phase_comp[ "p1", "c1"]**m.rparams.reaction_r1.reaction_order["p1", "c1"] * m.thermo[1].mole_frac_phase_comp[ "p1", "c2"]**m.rparams.reaction_r1.reaction_order["p1", "c2"]))
def test_binary_domains(self): m = ConcreteModel() m.x1 = Var(domain=Binary) m.c1 = Constraint(expr=m.x1 == 2) self.assertFalse(satisfiable(m))
def build(): # flowsheet set up m = ConcreteModel() m.fs = FlowsheetBlock(default={'dynamic': False}) m.fs.properties = props.NaClParameterBlock() m.fs.costing = WaterTAPCosting() # unit models m.fs.feed = Feed(default={'property_package': m.fs.properties}) m.fs.S1 = Separator(default={ "property_package": m.fs.properties, "outlet_list": ['P1', 'PXR'] }) m.fs.P1 = Pump(default={'property_package': m.fs.properties}) m.fs.PXR = PressureExchanger(default={'property_package': m.fs.properties}) m.fs.P2 = Pump(default={'property_package': m.fs.properties}) m.fs.M1 = Mixer( default={ "property_package": m.fs.properties, "momentum_mixing_type": MomentumMixingType.equality, # booster pump will match pressure "inlet_list": ['P1', 'P2'] }) m.fs.RO = ReverseOsmosis0D( default={ "property_package": m.fs.properties, "has_pressure_change": True, "pressure_change_type": PressureChangeType.calculated, "mass_transfer_coefficient": MassTransferCoefficient.calculated, "concentration_polarization_type": ConcentrationPolarizationType.calculated, }) m.fs.product = Product(default={'property_package': m.fs.properties}) m.fs.disposal = Product(default={'property_package': m.fs.properties}) # costing m.fs.costing.cost_flow( pyunits.convert(m.fs.P1.work_mechanical[0], to_units=pyunits.kW), "electricity") m.fs.costing.cost_flow( pyunits.convert(m.fs.P2.work_mechanical[0], to_units=pyunits.kW), "electricity") m.fs.P1.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.costing}) m.fs.P2.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.costing}) m.fs.RO.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.costing}) m.fs.PXR.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.costing}) m.fs.costing.cost_process() m.fs.costing.add_LCOW(m.fs.product.properties[0].flow_vol) m.fs.costing.add_specific_energy_consumption( m.fs.product.properties[0].flow_vol) # connections m.fs.s01 = Arc(source=m.fs.feed.outlet, destination=m.fs.S1.inlet) m.fs.s02 = Arc(source=m.fs.S1.P1, destination=m.fs.P1.inlet) m.fs.s03 = Arc(source=m.fs.P1.outlet, destination=m.fs.M1.P1) m.fs.s04 = Arc(source=m.fs.M1.outlet, destination=m.fs.RO.inlet) m.fs.s05 = Arc(source=m.fs.RO.permeate, destination=m.fs.product.inlet) m.fs.s06 = Arc(source=m.fs.RO.retentate, destination=m.fs.PXR.high_pressure_inlet) m.fs.s07 = Arc(source=m.fs.PXR.high_pressure_outlet, destination=m.fs.disposal.inlet) m.fs.s08 = Arc(source=m.fs.S1.PXR, destination=m.fs.PXR.low_pressure_inlet) m.fs.s09 = Arc(source=m.fs.PXR.low_pressure_outlet, destination=m.fs.P2.inlet) m.fs.s10 = Arc(source=m.fs.P2.outlet, destination=m.fs.M1.P2) TransformationFactory("network.expand_arcs").apply_to(m) # scaling # set default property values m.fs.properties.set_default_scaling('flow_mass_phase_comp', 1, index=('Liq', 'H2O')) m.fs.properties.set_default_scaling('flow_mass_phase_comp', 1e2, index=('Liq', 'NaCl')) # set unit model values iscale.set_scaling_factor(m.fs.P1.control_volume.work, 1e-3) iscale.set_scaling_factor(m.fs.P2.control_volume.work, 1e-3) iscale.set_scaling_factor(m.fs.PXR.low_pressure_side.work, 1e-3) iscale.set_scaling_factor(m.fs.PXR.high_pressure_side.work, 1e-3) # touch properties used in specifying and initializing the model m.fs.feed.properties[0].flow_vol_phase['Liq'] m.fs.feed.properties[0].mass_frac_phase_comp['Liq', 'NaCl'] m.fs.S1.mixed_state[0].mass_frac_phase_comp m.fs.S1.PXR_state[0].flow_vol_phase['Liq'] # unused scaling factors needed by IDAES base costing module # calculate and propagate scaling factors iscale.calculate_scaling_factors(m) return m
def test_bounds_sat(self): m = ConcreteModel() m.x = Var(bounds=(0, 5)) m.c1 = Constraint(expr=4.99 == m.x) m.o = Objective(expr=m.x) self.assertTrue(satisfiable(m))
def test_mutable_novalue_param_upper_bound(self): model = ConcreteModel() model.x = Var() model.p = Param(mutable=True) model.p.value = None model.c = Constraint(expr=model.x - model.p <= 0) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=model.x <= model.p) self.assertTrue(model.c.upper is model.p) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=model.x + 1 <= model.p) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=model.x <= model.p + 1) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=model.x <= (model.p + 1)**2) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=(model.p + 1, model.x, model.p)) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=0 >= model.x - model.p) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=model.p >= model.x) self.assertTrue(model.c.upper is model.p) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=model.p >= model.x + 1) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=model.p + 1 >= model.x) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=(model.p + 1)**2 >= model.x) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=(None, model.x, model.p)) self.assertTrue(model.c.upper is model.p) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=(None, model.x + 1, model.p)) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=(None, model.x, model.p + 1)) self.assertEqual(model.c.equality, False) model.del_component(model.c) model.c = Constraint(expr=(1, model.x, model.p)) self.assertEqual(model.c.equality, False) model.del_component(model.c)
def test_lower_bound_unsat(self): m = ConcreteModel() m.x = Var(bounds=(0, 5)) m.c = Constraint(expr=-0.01 == m.x) m.o = Objective(expr=m.x) self.assertFalse(satisfiable(m))
def test_keys_empty(self): """Test keys method""" model = ConcreteModel() model.c = Constraint() self.assertEqual(list(model.c.keys()),[])
def test_unhandled_expressions(self): m = ConcreteModel() m.x = Var() m.c1 = Constraint(expr=0 <= log(m.x)) self.assertTrue(satisfiable(m))
def create_model(self): model = ConcreteModel() model.A = Set(initialize=[1,2,3,4]) return model
def test_abs_expressions(self): m = ConcreteModel() m.x = Var() m.c1 = Constraint(expr=-0.001 >= abs(m.x)) m.o = Objective(expr=m.x) self.assertFalse(satisfiable(m))
def __init__(self, y, x, b=None, gy=[1], gx=[1], gb=None, rts=RTS_VRS, yref=None, xref=None, bref=None): """DEA DDF model Args: y (float): output variable. x (float): input variables. b (float), optional): undesirable output variables. Defaults to None. gy (list, optional): output directional vector. Defaults to [1]. gx (list, optional): input directional vector. Defaults to [1]. gb (list, optional): undesirable output directional vector. Defaults to None. rts (String): RTS_VRS (variable returns to scale) or RTS_CRS (constant returns to scale) yref (String, optional): reference output. Defaults to None. xref (String, optional): reference inputs. Defaults to None. bref (String, optional): reference undesirable output. Defaults to None. """ # Initialize DEA model self.__model__ = ConcreteModel() self.x = self._DEA__to_2d_list(x.tolist()) self.y = self._DEA__to_2d_list(y.tolist()) self.rts = rts self.gy = self.__to_1d_list(gy) self.gx = self.__to_1d_list(gx) self.__undesirable_output = False self.__reference = False if type(b) != type(None): self.__undesirable_output = True self.b = self._DEA__to_2d_list(b.tolist()) self.gb = self.__to_1d_list(gb) if type(yref) != type(None): self.__reference = True self.yref = self._DEA__to_2d_list(yref) self.xref = self._DEA__to_2d_list(xref) if self.__undesirable_output: self.bref = self._DEA__to_2d_list(bref) self.__model__.R = Set(initialize=range(len(self.yref))) # Initialize sets self.__model__.I = Set(initialize=range(len(self.y))) self.__model__.J = Set(initialize=range(len(self.x[0]))) self.__model__.K = Set(initialize=range(len(self.y[0]))) if self.__undesirable_output: self.__model__.L = Set(initialize=range(len(self.b[0]))) # Initialize variable self.__model__.theta = Var(self.__model__.I, doc='directional distance') if self.__reference: self.__model__.lamda = Var(self.__model__.I, self.__model__.R, bounds=(0.0, None), doc='intensity variables') else: self.__model__.lamda = Var(self.__model__.I, self.__model__.I, bounds=(0.0, None), doc='intensity variables') # Setup the objective function and constraints self.__model__.objective = Objective(rule=self._DEA__objective_rule(), sense=maximize, doc='objective function') self.__model__.input = Constraint(self.__model__.I, self.__model__.J, rule=self.__input_rule(), doc='input constraint') self.__model__.output = Constraint(self.__model__.I, self.__model__.K, rule=self.__output_rule(), doc='output constraint') if self.__undesirable_output: self.__model__.undesirable_output = Constraint( self.__model__.I, self.__model__.L, rule=self.__undesirable_output_rule(), doc='undesirable output constraint') if self.rts == RTS_VRS: self.__model__.vrs = Constraint(self.__model__.I, rule=self.__vrs_rule(), doc='various return to scale rule') # Optimize model self.optimization_status = 0 self.problem_status = 0
def test_build(self): model = ConcreteModel() model.params = GenericParameterBlock(default=configuration) assert isinstance(model.params.phase_list, Set) assert len(model.params.phase_list) == 2 for i in model.params.phase_list: assert i in ["Liq", "Vap"] assert model.params.Liq.is_liquid_phase() assert model.params.Vap.is_vapor_phase() assert isinstance(model.params.component_list, Set) assert len(model.params.component_list) == 3 for i in model.params.component_list: assert i in ['nitrogen', 'argon', 'oxygen'] assert isinstance(model.params.get_component(i), Component) assert isinstance(model.params._phase_component_set, Set) assert len(model.params._phase_component_set) == 6 for i in model.params._phase_component_set: assert i in [("Liq", "nitrogen"), ("Liq", "argon"), ("Liq", "oxygen"), ("Vap", "nitrogen"), ("Vap", "argon"), ("Vap", "oxygen")] assert model.params.config.state_definition == FTPx assert model.params.config.state_bounds == { "flow_mol": (0, 100, 1000, pyunits.mol / pyunits.s), "temperature": (10, 300, 350, pyunits.K), "pressure": (5e4, 1e5, 1e7, pyunits.Pa) } assert model.params.config.phase_equilibrium_state == { ("Vap", "Liq"): SmoothVLE } assert isinstance(model.params.phase_equilibrium_idx, Set) assert len(model.params.phase_equilibrium_idx) == 3 for i in model.params.phase_equilibrium_idx: assert i in ["PE1", "PE2", "PE3"] assert model.params.phase_equilibrium_list == { "PE1": { "nitrogen": ("Vap", "Liq") }, "PE2": { "argon": ("Vap", "Liq") }, "PE3": { "oxygen": ("Vap", "Liq") } } assert model.params.pressure_ref.value == 101325 assert model.params.temperature_ref.value == 298.15 assert model.params.nitrogen.mw.value == 28.0135E-3 assert model.params.nitrogen.pressure_crit.value == 34e5 assert model.params.nitrogen.temperature_crit.value == 126.2 assert model.params.argon.mw.value == 39.948E-3 assert model.params.argon.pressure_crit.value == 48.98e5 assert model.params.argon.temperature_crit.value == 150.86 assert model.params.oxygen.mw.value == 31.999E-3 assert model.params.oxygen.pressure_crit.value == 50.43e5 assert model.params.oxygen.temperature_crit.value == 154.58 assert_units_consistent(model)