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)
