def test_assert_units_consistent_on_datas(self): u = units m = ConcreteModel() m.S = Set(initialize=[1, 2, 3]) m.x = Var(m.S, units=u.m) m.t = Var(m.S, units=u.s) m.v = Var(m.S, units=u.m / u.s) m.unitless = Var(m.S) @m.Constraint(m.S) def vel_con(m, i): return m.v[i] == m.x[i] / m.t[i] @m.Constraint(m.S) def unitless_con(m, i): return m.unitless[i] == 42.0 @m.Constraint(m.S) def sqrt_con(m, i): return sqrt(m.v[i]) == sqrt(m.x[i] / m.t[i]) m.obj = Objective(expr=m.v, sense=maximize) assert_units_consistent(m) # check model assert_units_consistent(m.x) # check var assert_units_consistent(m.t) # check var assert_units_consistent(m.v) # check var assert_units_consistent(m.unitless) # check var assert_units_consistent(m.vel_con) # check constraint assert_units_consistent(m.unitless_con) # check unitless constraint assert_units_consistent(m.x[2]) # check var data assert_units_consistent(m.t[2]) # check var data assert_units_consistent(m.v[2]) # check var data assert_units_consistent(m.unitless[2]) # check var assert_units_consistent(m.vel_con[2]) # check constraint data assert_units_consistent( m.unitless_con[2]) # check unitless constraint data assert_units_equivalent(m.x[2], m.x[1]) # check var data assert_units_equivalent(m.t[2], u.s) # check var data assert_units_equivalent(m.v[2], u.m / u.s) # check var data assert_units_equivalent(m.unitless[2], u.dimensionless) # check var data unitless assert_units_equivalent(m.unitless[2], None) # check var assert_units_equivalent(m.vel_con[2].body, u.m / u.s) # check constraint data assert_units_equivalent( m.unitless_con[2].body, u.dimensionless) # check unitless constraint data @m.Constraint(m.S) def broken(m, i): return m.x[i] == 42.0 * m.v[i] with self.assertRaises(UnitsError): assert_units_consistent(m) with self.assertRaises(UnitsError): assert_units_consistent(m.broken) with self.assertRaises(UnitsError): assert_units_consistent(m.broken[1]) # all of these should still work assert_units_consistent(m.x) # check var assert_units_consistent(m.t) # check var assert_units_consistent(m.v) # check var assert_units_consistent(m.unitless) # check var assert_units_consistent(m.vel_con) # check constraint assert_units_consistent(m.unitless_con) # check unitless constraint assert_units_consistent(m.x[2]) # check var data assert_units_consistent(m.t[2]) # check var data assert_units_consistent(m.v[2]) # check var data assert_units_consistent(m.unitless[2]) # check var assert_units_consistent(m.vel_con[2]) # check constraint data assert_units_consistent( m.unitless_con[2]) # check unitless constraint data
def test_units(build_downcomer): assert_units_consistent(build_downcomer)
def test_units(build_drum): assert_units_consistent(build_drum)
def test_unit_consistency(boiler): assert_units_consistent(boiler)
def add_costing(m): prtrt = m.fs.pretreatment desal = m.fs.desalination psttrt = m.fs.posttreatment # Add costing package for zero-order units m.fs.zo_costing = ZeroOrderCosting() m.fs.ro_costing = WaterTAPCosting() # Add costing to zero order units # Pre-treatment units # This really looks like it should be a feed block in its own right # prtrt.intake.costing = UnitModelCostingBlock(default={ # "flowsheet_costing_block": m.fs.zo_costing}) prtrt.ferric_chloride_addition.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) prtrt.chlorination.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) prtrt.static_mixer.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) prtrt.storage_tank_1.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) prtrt.media_filtration.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) prtrt.backwash_handling.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) prtrt.anti_scalant_addition.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) prtrt.cartridge_filtration.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) # RO Train # RO equipment is costed using more detailed costing package desal.P1.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.ro_costing} ) desal.RO.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.ro_costing} ) if m.erd_type == "pressure_exchanger": # desal.S1.costing = UnitModelCostingBlock(default={ # "flowsheet_costing_block": m.fs.ro_costing}) desal.M1.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.ro_costing} ) desal.PXR.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.ro_costing} ) desal.P2.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.ro_costing} ) elif m.erd_type == "pump_as_turbine": pass # desal.ERD.costing = UnitModelCostingBlock(default={ # "flowsheet_costing_block": m.fs.ro_costing}) else: raise ConfigurationError( f"erd_type was {m.erd_type}, costing only implemented " "for pressure_exchanger or pump_as_turbine" ) # For non-zero order unit operations, we need to register costed flows # separately. # However, to keep costs consistent, we will register these with the ZO # Costing package m.fs.zo_costing.cost_flow(desal.P1.work_mechanical[0], "electricity") if m.erd_type == "pressure_exchanger": m.fs.zo_costing.cost_flow(desal.P2.work_mechanical[0], "electricity") elif m.erd_type == "pump_as_turbine": pass # m.fs.zo_costing.cost_flow( # desal.ERD.work_mechanical[0], "electricity") else: raise ConfigurationError( f"erd_type was {m.erd_type}, costing only implemented " "for pressure_exchanger or pump_as_turbine" ) # Post-treatment units psttrt.storage_tank_2.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) psttrt.uv_aop.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) psttrt.co2_addition.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) psttrt.lime_addition.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) psttrt.storage_tank_3.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) # Product and disposal m.fs.municipal.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) m.fs.landfill.costing = UnitModelCostingBlock( default={"flowsheet_costing_block": m.fs.zo_costing} ) # Aggregate unit level costs and calculate overall process costs m.fs.zo_costing.cost_process() m.fs.ro_costing.cost_process() # Combine results from costing packages and calculate overall metrics @m.Expression() def total_capital_cost(b): return ( pyunits.convert( m.fs.zo_costing.total_capital_cost, to_units=pyunits.USD_2018 ) + m.fs.ro_costing.total_investment_cost ) @m.Expression() def total_operating_cost(b): return ( pyunits.convert( m.fs.zo_costing.total_fixed_operating_cost, to_units=pyunits.USD_2018 / pyunits.year, ) + pyunits.convert( m.fs.zo_costing.total_variable_operating_cost, to_units=pyunits.USD_2018 / pyunits.year, ) + m.fs.ro_costing.total_operating_cost ) @m.Expression() def LCOW(b): return ( b.total_capital_cost * b.fs.zo_costing.capital_recovery_factor + b.total_operating_cost ) / ( pyunits.convert( b.fs.municipal.properties[0].flow_vol, to_units=pyunits.m**3 / pyunits.year, ) * b.fs.zo_costing.utilization_factor ) assert_units_consistent(m)
def test_units_consistent(self, iron_oc): assert_units_consistent(iron_oc)
def test_units(self, iapws): assert_units_consistent(iapws) assert_units_equivalent(iapws.fs.unit.work_mechanical[0], units.W) assert_units_equivalent(iapws.fs.unit.deltaP[0], units.Pa)
def test_units_FcTP(self, btx_fctp): assert_units_consistent(btx_fctp)
def test_units(self, phe): assert_units_equivalent(phe.fs.unit.Re_hot[0], pyunits.dimensionless) assert_units_equivalent(phe.fs.unit.Re_cold[0], pyunits.dimensionless) assert_units_consistent(phe)
def test_build(self, system_frame): m = system_frame # model set up assert isinstance(m, ConcreteModel) assert isinstance(m.fs, FlowsheetBlock) assert isinstance(m.fs.properties, props.NaClParameterBlock) assert isinstance(m.fs.costing, Block) # unit models fs = m.fs assert isinstance(fs.feed, Feed) assert isinstance(fs.S1, Separator) assert isinstance(fs.P1, Pump) assert isinstance(fs.PXR, PressureExchanger) assert isinstance(fs.P2, Pump) assert isinstance(fs.M1, Mixer) assert isinstance(fs.RO, ReverseOsmosis0D) assert isinstance(fs.product, Product) assert isinstance(fs.disposal, Product) # unit model options # separator assert isinstance(fs.S1.P1, Port) assert isinstance(fs.S1.PXR, Port) # mixer assert isinstance(fs.M1.P1, Port) assert isinstance(fs.M1.P2, Port) assert isinstance(fs.M1.pressure_equality_constraints, Constraint) # RO assert isinstance(fs.RO.deltaP, Var) # additional expressions assert isinstance(fs.recovery, Expression) assert isinstance(fs.annual_water_production, Expression) assert isinstance(fs.specific_energy_consumption, Expression) # costing blocks blk_str_list = ['P1', 'P2', 'RO', 'PXR'] for blk_str in blk_str_list: blk = getattr(fs, blk_str) c_blk = getattr(blk, 'costing') assert isinstance(c_blk, Block) assert isinstance(getattr(c_blk, 'capital_cost'), Var) assert isinstance(getattr(c_blk, 'operating_cost'), Var) var_str_list = [ 'capital_cost_total', 'investment_cost_total', 'operating_cost_MLC', 'operating_cost_total', 'LCOW' ] for var_str in var_str_list: var = getattr(fs.costing, var_str) assert isinstance(var, Var) # arcs arc_dict = { fs.s01: (fs.feed.outlet, fs.S1.inlet), fs.s02: (fs.S1.P1, fs.P1.inlet), fs.s03: (fs.P1.outlet, fs.M1.P1), fs.s04: (fs.M1.outlet, fs.RO.inlet), fs.s05: (fs.RO.permeate, fs.product.inlet), fs.s06: (fs.RO.retentate, fs.PXR.high_pressure_inlet), fs.s07: (fs.PXR.high_pressure_outlet, fs.disposal.inlet), fs.s08: (fs.S1.PXR, fs.PXR.low_pressure_inlet), fs.s09: (fs.PXR.low_pressure_outlet, fs.P2.inlet), fs.s10: (fs.P2.outlet, fs.M1.P2) } for arc, port_tpl in arc_dict.items(): assert arc.source is port_tpl[0] assert arc.destination is port_tpl[1] # units assert_units_consistent(fs)
def test_units_FTPz(self, btx_ftpz, btx_fctp): assert_units_consistent(btx_ftpz)
def test_units(self, sapon): assert_units_consistent(sapon) assert_units_equivalent(sapon.fs.unit.heat_duty[0], units.W) assert_units_equivalent(sapon.fs.unit.deltaP[0], units.Pa)
def test_unit_consistency(self, frame): assert_units_consistent(frame)
def test_assert_units_consistent_equivalent(self): u = units m = ConcreteModel() m.dx = Var(units=u.m, initialize=0.10188943773836046) m.dy = Var(units=u.m, initialize=0.0) m.vx = Var(units=u.m / u.s, initialize=0.7071067769802851) m.vy = Var(units=u.m / u.s, initialize=0.7071067769802851) m.t = Var(units=u.min, bounds=(1e-5, 10.0), initialize=0.0024015570927624456) m.theta = Var(bounds=(0, 0.49 * 3.14), initialize=0.7853981693583533, units=u.radians) m.a = Param(initialize=-32.2, units=u.ft / u.s**2) m.x_unitless = Var() m.obj = Objective(expr=m.dx, sense=maximize) m.vx_con = Constraint(expr=m.vx == 1.0 * u.m / u.s * cos(m.theta)) m.vy_con = Constraint(expr=m.vy == 1.0 * u.m / u.s * sin(m.theta)) m.dx_con = Constraint(expr=m.dx == m.vx * u.convert(m.t, to_units=u.s)) m.dy_con = Constraint( expr=m.dy == m.vy * u.convert(m.t, to_units=u.s) + 0.5 * (u.convert(m.a, to_units=u.m / u.s**2)) * (u.convert(m.t, to_units=u.s))**2) m.ground = Constraint(expr=m.dy == 0) m.unitless_con = Constraint(expr=m.x_unitless == 5.0) assert_units_consistent(m) # check model assert_units_consistent(m.dx) # check var - this should never fail assert_units_consistent( m.x_unitless) # check unitless var - this should never fail assert_units_consistent(m.vx_con) # check constraint assert_units_consistent(m.unitless_con) # check unitless constraint assert_units_equivalent(m.dx, m.dy) # check var assert_units_equivalent(m.x_unitless, u.dimensionless) # check unitless var assert_units_equivalent(m.x_unitless, None) # check unitless var assert_units_equivalent(m.vx_con.body, u.m / u.s) # check constraint assert_units_equivalent(m.unitless_con.body, u.dimensionless) # check unitless constraint assert_units_equivalent(m.dx, m.dy) # check var assert_units_equivalent(m.x_unitless, u.dimensionless) # check unitless var assert_units_equivalent(m.x_unitless, None) # check unitless var assert_units_equivalent(m.vx_con.body, u.m / u.s) # check constraint m.broken = Constraint(expr=m.dy == 42.0 * u.kg) with self.assertRaises(UnitsError): assert_units_consistent(m) assert_units_consistent(m.dx) assert_units_consistent(m.vx_con) with self.assertRaises(UnitsError): assert_units_consistent(m.broken) self.assertTrue(check_units_equivalent(m.dx, m.dy)) self.assertFalse(check_units_equivalent(m.dx, m.vx))
def test_unit_consistency(model): assert_units_consistent(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=lambda x: value(x) * (pyunits.get_units(x) or pyunits.dimensionless)._get_pint_unit()) 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_units(self, sapon): assert_units_consistent(sapon) assert_units_equivalent(sapon.fs.unit.heat_duty[0], units.W) assert_units_equivalent(sapon.fs.unit.deltaP[0], units.Pa) assert_units_equivalent(sapon.fs.unit.rate_reaction_extent[0, "R1"], units.mol / units.s)
def test_build(self): model = ConcreteModel() model.params = GenericParameterBlock( default=configuration_Dowling_2015) 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 == 33.943875e5 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.737325e5 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.45985e5 assert model.params.oxygen.temperature_crit.value == 154.58 assert_units_consistent(model)
def test_units(self, btx): assert_units_consistent(btx) assert_units_equivalent(btx.fs.unit.work_mechanical[0], units.W) assert_units_equivalent(btx.fs.unit.deltaP[0], units.Pa)
def test_units_consistent(): assert_units_consistent(m.fs) assert_units_consistent(m.fs1)
def test_units(self, sapon): assert_units_consistent(sapon) assert_units_equivalent(sapon.fs.unit.work_mechanical[0], units.W) assert_units_equivalent(sapon.fs.unit.deltaP[0], units.Pa)
def test_units(self, valve_model): assert_units_consistent(valve_model) assert_units_equivalent(valve_model.fs.valve.flow_var[0], units.mol / units.s)
def test_seawater_data(): m = ConcreteModel() m.fs = FlowsheetBlock(default={'dynamic': False}) m.fs.properties = DSPMDEParameterBlock( default={ "solute_list": ["Ca_2+", "SO4_2-", "Na_+", "Cl_-", "Mg_2+"], "diffusivity_data": { ("Liq", "Ca_2+"): 0.792e-9, ("Liq", "SO4_2-"): 1.06e-9, ("Liq", "Na_+"): 1.33e-9, ("Liq", "Cl_-"): 2.03e-9, ("Liq", "Mg_2+"): 0.706e-9 }, "mw_data": { "H2O": 18e-3, "Na_+": 23e-3, "Ca_2+": 40e-3, "Mg_2+": 24e-3, "Cl_-": 35e-3, "SO4_2-": 96e-3 }, "stokes_radius_data": { "Na_+": 0.184e-9, "Ca_2+": 0.309e-9, "Mg_2+": 0.347e-9, "Cl_-": 0.121e-9, "SO4_2-": 0.230e-9 }, "charge": { "Na_+": 1, "Ca_2+": 2, "Mg_2+": 2, "Cl_-": -1, "SO4_2-": -2 }, }) m.fs.stream = stream = m.fs.properties.build_state_block( [0], default={'defined_state': True}) mass_flow_in = 1 * pyunits.kg / pyunits.s feed_mass_frac = { 'Na_+': 11122e-6, 'Ca_2+': 382e-6, 'Mg_2+': 1394e-6, 'SO4_2-': 2136e-6, 'Cl_-': 20300e-6 } for ion, x in feed_mass_frac.items(): mol_comp_flow = x * pyunits.kg / pyunits.kg * mass_flow_in / stream[ 0].mw_comp[ion] stream[0].flow_mol_phase_comp['Liq', ion].fix(mol_comp_flow) H2O_mass_frac = 1 - sum(x for x in feed_mass_frac.values()) H2O_mol_comp_flow = H2O_mass_frac * pyunits.kg / pyunits.kg * mass_flow_in / stream[ 0].mw_comp['H2O'] stream[0].flow_mol_phase_comp['Liq', 'H2O'].fix(H2O_mol_comp_flow) stream[0].temperature.fix(298.15) stream[0].pressure.fix(101325) stream[0].assert_electroneutrality(tol=1e-2) metadata = m.fs.properties.get_metadata().properties for v_name in metadata: getattr(stream[0], v_name) assert stream[0].is_property_constructed('conc_mol_phase_comp') assert_units_consistent(m) check_dof(m, fail_flag=True) m.fs.properties.set_default_scaling('flow_mol_phase_comp', 1, index=('Liq', 'H2O')) m.fs.properties.set_default_scaling('flow_mol_phase_comp', 1, index=('Liq', 'Na_+')) m.fs.properties.set_default_scaling('flow_mol_phase_comp', 1, index=('Liq', 'Cl_-')) m.fs.properties.set_default_scaling('flow_mol_phase_comp', 1e1, index=('Liq', 'Ca_2+')) m.fs.properties.set_default_scaling('flow_mol_phase_comp', 1e1, index=('Liq', 'SO4_2-')) m.fs.properties.set_default_scaling('flow_mol_phase_comp', 1, index=('Liq', 'Mg_2+')) calculate_scaling_factors(m) # check if any variables are badly scaled badly_scaled_var_list = list(badly_scaled_var_generator(m)) assert len(badly_scaled_var_list) == 0 stream.initialize() # check if any variables are badly scaled badly_scaled_var_list = list(badly_scaled_var_generator(m)) assert len(badly_scaled_var_list) == 0 results = solver.solve(m) assert_optimal_termination(results) assert value(stream[0].flow_vol_phase['Liq']) == pytest.approx(0.001, rel=1e-3) assert value(stream[0].flow_mol_phase_comp['Liq', 'H2O']) == pytest.approx( 53.59256, rel=1e-3) assert value(stream[0].flow_mol_phase_comp['Liq', 'Na_+']) == pytest.approx( 0.4836, rel=1e-3) assert value(stream[0].flow_mol_phase_comp['Liq', 'Ca_2+']) == pytest.approx( 0.00955, rel=1e-3) assert value(stream[0].flow_mol_phase_comp['Liq', 'Mg_2+']) == pytest.approx( 0.05808, rel=1e-3) assert value(stream[0].flow_mol_phase_comp['Liq', 'Cl_-']) == pytest.approx( 0.58, rel=1e-3) assert value(stream[0].flow_mol_phase_comp['Liq', 'SO4_2-']) == pytest.approx( 0.02225, rel=1e-3) assert value(stream[0].dens_mass_phase['Liq']) == pytest.approx(1000, rel=1e-3) assert value(stream[0].pressure_osm) == pytest.approx(28.593e5, rel=1e-3) assert value(stream[0].flow_vol) == pytest.approx(0.001, rel=1e-3) assert value( sum(stream[0].conc_mass_phase_comp['Liq', j] for j in m.fs.properties.solute_set)) == pytest.approx(35.334, rel=1e-3) assert value( sum(stream[0].mass_frac_phase_comp['Liq', j] for j in m.fs.properties.solute_set)) == pytest.approx(35334e-6, rel=1e-3) assert value( sum(stream[0].mass_frac_phase_comp['Liq', j] for j in m.fs.properties.component_list)) == pytest.approx( 1, rel=1e-3) assert value( sum(stream[0].mole_frac_phase_comp['Liq', j] for j in m.fs.properties.component_list)) == pytest.approx( 1, rel=1e-3) assert value(stream[0].conc_mol_phase_comp['Liq', 'Na_+']) == pytest.approx( 483.565, rel=1e-3) assert value(stream[0].conc_mol_phase_comp['Liq', 'Cl_-']) == pytest.approx( 580, rel=1e-3) assert value(stream[0].conc_mol_phase_comp['Liq', 'Ca_2+']) == pytest.approx( 9.55, rel=1e-3) assert value(stream[0].conc_mol_phase_comp['Liq', 'SO4_2-']) == pytest.approx( 22.25, rel=1e-3) assert value(stream[0].conc_mol_phase_comp['Liq', 'Mg_2+']) == pytest.approx( 58.08, rel=1e-3) assert value(stream[0].conc_mass_phase_comp['Liq', 'Na_+']) == pytest.approx( 11.122, rel=1e-3) assert value(stream[0].conc_mass_phase_comp['Liq', 'Cl_-']) == pytest.approx( 20.3, rel=1e-3) assert value(stream[0].conc_mass_phase_comp['Liq', 'Ca_2+']) == pytest.approx( 0.382, rel=1e-3) assert value(stream[0].conc_mass_phase_comp['Liq', 'SO4_2-']) == pytest.approx( 2.136, rel=1e-3) assert value(stream[0].conc_mass_phase_comp['Liq', 'Mg_2+']) == pytest.approx( 1.394, rel=1e-3) assert value(stream[0].mole_frac_phase_comp['Liq', 'Na_+']) == pytest.approx( 8.833e-3, rel=1e-3) assert value(stream[0].mole_frac_phase_comp['Liq', 'Cl_-']) == pytest.approx( 1.059e-2, rel=1e-3) assert value(stream[0].mole_frac_phase_comp['Liq', 'Ca_2+']) == pytest.approx( 1.744e-4, rel=1e-3) assert value(stream[0].mole_frac_phase_comp['Liq', 'SO4_2-']) == pytest.approx( 4.064e-4, rel=1e-3) assert value(stream[0].mole_frac_phase_comp['Liq', 'Mg_2+']) == pytest.approx( 1.061e-3, rel=1e-3) assert value(stream[0].mass_frac_phase_comp['Liq', 'Na_+']) == pytest.approx( 1.112e-2, rel=1e-3) assert value(stream[0].mass_frac_phase_comp['Liq', 'Cl_-']) == pytest.approx( 2.03e-2, rel=1e-3) assert value(stream[0].mass_frac_phase_comp['Liq', 'Ca_2+']) == pytest.approx( 3.82e-4, rel=1e-3) assert value(stream[0].mass_frac_phase_comp['Liq', 'SO4_2-']) == pytest.approx( 2.136e-3, rel=1e-3) assert value(stream[0].mass_frac_phase_comp['Liq', 'Mg_2+']) == pytest.approx( 1.394e-3, rel=1e-3)
def test_units(self, sapon): assert_units_consistent(sapon)
def test_units(self, model): assert_units_consistent(model) assert_units_equivalent(model.fs.unit.heat_duty[0], units.W)
def test_units(self, btx): assert_units_consistent(btx)
def test_unit_consistency(self, model): assert_units_consistent(model.fs.unit)
def test_units(self, iapws): assert_units_consistent(iapws)
def test_build(self): model = ConcreteModel() model.params = GenericParameterBlock(default=configuration_vap) assert isinstance(model.params.phase_list, Set) assert len(model.params.phase_list) == 1 for i in model.params.phase_list: assert i in ["Vap"] assert model.params.Vap.is_vapor_phase() assert isinstance(model.params.component_list, Set) assert len(model.params.component_list) == 13 for i in model.params.component_list: assert i in [ 'hydrogen', 'methane', 'ethane', 'propane', 'nbutane', 'ibutane', 'ethylene', 'propene', 'butene', 'pentene', 'hexene', 'heptene', 'octene' ] assert isinstance(model.params.get_component(i), Component) assert isinstance(model.params._phase_component_set, Set) assert len(model.params._phase_component_set) == 13 for i in model.params._phase_component_set: assert i in [("Vap", "hydrogen"), ("Vap", "methane"), ("Vap", "ethane"), ("Vap", "propane"), ("Vap", "nbutane"), ("Vap", "ibutane"), ("Vap", "ethylene"), ("Vap", "propene"), ("Vap", "butene"), ("Vap", "pentene"), ("Vap", "hexene"), ("Vap", "heptene"), ("Vap", "octene")] assert model.params.config.state_definition == FTPx assert model.params.config.state_bounds == { "flow_mol": (0, 100, 1000, pyunits.mol / pyunits.s), "temperature": (273.15, 300, 1500, pyunits.K), "pressure": (5e4, 1e5, 1e7, pyunits.Pa) } assert model.params.pressure_ref.value == 101325 assert model.params.temperature_ref.value == 298.15 assert model.params.hydrogen.mw.value == 2.016E-3 assert model.params.hydrogen.pressure_crit.value == 12.9e5 assert model.params.hydrogen.temperature_crit.value == 33.2 assert model.params.methane.mw.value == 16.043E-3 assert model.params.methane.pressure_crit.value == 46e5 assert model.params.methane.temperature_crit.value == 190.4 assert model.params.ethane.mw.value == 30.070E-3 assert model.params.ethane.pressure_crit.value == 48.8e5 assert model.params.ethane.temperature_crit.value == 305.4 assert model.params.propane.mw.value == 44.094E-3 assert model.params.propane.pressure_crit.value == 42.5e5 assert model.params.propane.temperature_crit.value == 369.8 assert model.params.nbutane.mw.value == 58.124E-3 assert model.params.nbutane.pressure_crit.value == 38.0e5 assert model.params.nbutane.temperature_crit.value == 425.2 assert model.params.ibutane.mw.value == 58.124E-3 assert model.params.ibutane.pressure_crit.value == 36.5e5 assert model.params.ibutane.temperature_crit.value == 408.2 assert model.params.ethylene.mw.value == 28.054E-3 assert model.params.ethylene.pressure_crit.value == 50.5e5 assert model.params.ethylene.temperature_crit.value == 282.4 assert model.params.propene.mw.value == 42.081E-3 assert model.params.propene.pressure_crit.value == 46.2e5 assert model.params.propene.temperature_crit.value == 365.0 assert model.params.butene.mw.value == 56.104E-3 assert model.params.butene.pressure_crit.value == 40.2e5 assert model.params.butene.temperature_crit.value == 419.3 assert model.params.pentene.mw.value == 70.135E-3 assert model.params.pentene.pressure_crit.value == 40.5e5 assert model.params.pentene.temperature_crit.value == 464.7 assert model.params.hexene.mw.value == 84.162E-3 assert model.params.hexene.pressure_crit.value == 31.7e5 assert model.params.hexene.temperature_crit.value == 504.0 assert model.params.heptene.mw.value == 98.189E-3 assert model.params.heptene.pressure_crit.value == 25.4e5 assert model.params.heptene.temperature_crit.value == 537.2 assert model.params.octene.mw.value == 112.216E-3 assert model.params.octene.pressure_crit.value == 26.2e5 assert model.params.octene.temperature_crit.value == 566.6 assert_units_consistent(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) == 13 for i in model.params.component_list: assert i in [ 'hydrogen', 'methane', 'ethane', 'propane', 'nbutane', 'ibutane', 'ethylene', 'propene', 'butene', 'pentene', 'hexene', 'heptene', 'octene' ] assert isinstance(model.params.get_component(i), Component) assert isinstance(model.params._phase_component_set, Set) assert len(model.params._phase_component_set) == 24 for i in model.params._phase_component_set: assert i in [("Liq", "ethane"), ("Vap", "hydrogen"), ("Vap", "methane"), ("Vap", "ethane"), ("Liq", "propane"), ("Liq", "nbutane"), ("Liq", "ibutane"), ("Vap", "propane"), ("Vap", "nbutane"), ("Vap", "ibutane"), ("Liq", "ethylene"), ("Liq", "propene"), ("Liq", "butene"), ("Vap", "ethylene"), ("Vap", "propene"), ("Vap", "butene"), ("Liq", "pentene"), ("Liq", "hexene"), ("Liq", "heptene"), ("Vap", "pentene"), ("Vap", "hexene"), ("Vap", "heptene"), ("Liq", "octene"), ("Vap", "octene")] assert model.params.config.state_definition == FTPx assertStructuredAlmostEqual( model.params.config.state_bounds, { "flow_mol": (0, 100, 1000, pyunits.mol / pyunits.s), "temperature": (273.15, 300, 1500, pyunits.K), "pressure": (5e4, 1e5, 1e7, pyunits.Pa) }, 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) == 11 for i in model.params.phase_equilibrium_idx: assert i in [ "PE1", "PE2", "PE3", "PE4", "PE5", "PE6", "PE7", "PE8", "PE9", "PE10", "PE11" ] assert model.params.phase_equilibrium_list == { "PE1": { "ethane": ("Vap", "Liq") }, "PE2": { "propane": ("Vap", "Liq") }, "PE3": { "nbutane": ("Vap", "Liq") }, "PE4": { "ibutane": ("Vap", "Liq") }, "PE5": { "ethylene": ("Vap", "Liq") }, "PE6": { "propene": ("Vap", "Liq") }, "PE7": { "butene": ("Vap", "Liq") }, "PE8": { "pentene": ("Vap", "Liq") }, "PE9": { "hexene": ("Vap", "Liq") }, "PE10": { "heptene": ("Vap", "Liq") }, "PE11": { "octene": ("Vap", "Liq") } } assert model.params.pressure_ref.value == 101325 assert model.params.temperature_ref.value == 298.15 assert model.params.hydrogen.mw.value == 2.016E-3 assert model.params.hydrogen.pressure_crit.value == 12.9e5 assert model.params.hydrogen.temperature_crit.value == 33.2 assert model.params.methane.mw.value == 16.043E-3 assert model.params.methane.pressure_crit.value == 46e5 assert model.params.methane.temperature_crit.value == 190.4 assert model.params.ethane.mw.value == 30.070E-3 assert model.params.ethane.pressure_crit.value == 48.8e5 assert model.params.ethane.temperature_crit.value == 305.4 assert model.params.propane.mw.value == 44.094E-3 assert model.params.propane.pressure_crit.value == 42.5e5 assert model.params.propane.temperature_crit.value == 369.8 assert model.params.nbutane.mw.value == 58.124E-3 assert model.params.nbutane.pressure_crit.value == 38.0e5 assert model.params.nbutane.temperature_crit.value == 425.2 assert model.params.ibutane.mw.value == 58.124E-3 assert model.params.ibutane.pressure_crit.value == 36.5e5 assert model.params.ibutane.temperature_crit.value == 408.2 assert model.params.ethylene.mw.value == 28.054E-3 assert model.params.ethylene.pressure_crit.value == 50.5e5 assert model.params.ethylene.temperature_crit.value == 282.4 assert model.params.propene.mw.value == 42.081E-3 assert model.params.propene.pressure_crit.value == 46.2e5 assert model.params.propene.temperature_crit.value == 365.0 assert model.params.butene.mw.value == 56.104E-3 assert model.params.butene.pressure_crit.value == 40.2e5 assert model.params.butene.temperature_crit.value == 419.3 assert model.params.pentene.mw.value == 70.135E-3 assert model.params.pentene.pressure_crit.value == 40.5e5 assert model.params.pentene.temperature_crit.value == 464.7 assert model.params.hexene.mw.value == 84.162E-3 assert model.params.hexene.pressure_crit.value == 31.7e5 assert model.params.hexene.temperature_crit.value == 504.0 assert model.params.heptene.mw.value == 98.189E-3 assert model.params.heptene.pressure_crit.value == 25.4e5 assert model.params.heptene.temperature_crit.value == 537.2 assert model.params.octene.mw.value == 112.216E-3 assert model.params.octene.pressure_crit.value == 26.2e5 assert model.params.octene.temperature_crit.value == 566.6 assert_units_consistent(model)