def build_parameters(cobj): cobj.cp_mol_liq_comp_coeff_1 = Var( doc="Parameter 1 for liquid phase molar heat capacity", units=pyunits.J * pyunits.kmol**-1 * pyunits.K**-1) set_param_from_config(cobj, param="cp_mol_liq_comp_coeff", index="1") cobj.cp_mol_liq_comp_coeff_2 = Var( doc="Parameter 2 for liquid phase molar heat capacity", units=pyunits.J * pyunits.kmol**-1 * pyunits.K**-2) set_param_from_config(cobj, param="cp_mol_liq_comp_coeff", index="2") cobj.cp_mol_liq_comp_coeff_3 = Var( doc="Parameter 3 for liquid phase molar heat capacity", units=pyunits.J * pyunits.kmol**-1 * pyunits.K**-3) set_param_from_config(cobj, param="cp_mol_liq_comp_coeff", index="3") cobj.cp_mol_liq_comp_coeff_4 = Var( doc="Parameter 4 for liquid phase molar heat capacity", units=pyunits.J * pyunits.kmol**-1 * pyunits.K**-4) set_param_from_config(cobj, param="cp_mol_liq_comp_coeff", index="4") cobj.cp_mol_liq_comp_coeff_5 = Var( doc="Parameter 5 for liquid phase molar heat capacity", units=pyunits.J * pyunits.kmol**-1 * pyunits.K**-5) set_param_from_config(cobj, param="cp_mol_liq_comp_coeff", index="5")
def build_parameters(cobj): cobj.vol_mol_liq_comp_coeff_a = Var( doc="Parameter a for liquid phase molar volume", units=pyunits.mL / pyunits.mol) set_param_from_config(cobj, param="vol_mol_liq_comp_coeff", index="a") cobj.vol_mol_liq_comp_coeff_b = Var( doc="Parameter b for liquid phase molar volume", units=pyunits.mL / pyunits.mol) set_param_from_config(cobj, param="vol_mol_liq_comp_coeff", index="b") cobj.vol_mol_liq_comp_coeff_c = Var( doc="Parameter c for liquid phase molar volume", units=pyunits.mL / pyunits.mol) set_param_from_config(cobj, param="vol_mol_liq_comp_coeff", index="c") cobj.vol_mol_liq_comp_coeff_d = Var( doc="Parameter d for liquid phase molar volume", units=pyunits.mL / pyunits.mol) set_param_from_config(cobj, param="vol_mol_liq_comp_coeff", index="d") cobj.vol_mol_liq_comp_coeff_e = Var( doc="Parameter e for liquid phase molar volume", units=pyunits.mL / pyunits.mol) set_param_from_config(cobj, param="vol_mol_liq_comp_coeff", index="e")
def build_parameters(cobj): if not hasattr(cobj, "cp_mass_liq_comp_coeff_1"): CpMolSolvent.build_parameters(cobj) cobj.dh_vap = Var(doc="Heat of absorption of component @ Tref", units=pyunits.J / pyunits.mol) set_param_from_config(cobj, param="dh_vap")
def build_parameters(rblock, config): parent = rblock.parent_block() units = parent.get_metadata().derived_units c_form = config.concentration_form if c_form is None: raise ConfigurationError( "{} concentration_form configuration argument was not set. " "Please ensure that this argument is included in your " "configuration dict.".format(rblock.name)) elif not (c_form == ConcentrationForm.moleFraction or c_form == ConcentrationForm.activity): raise ConfigurationError( "{} calculation of equilibrium constant based on Gibbs energy " "is only supported for mole fraction or activity forms. " "Currently selected form: {}".format(rblock.name, c_form)) # Check that heat of reaction is constant if config.heat_of_reaction is not constant_dh_rxn: raise ConfigurationError( "{} calculating equilibrium constants from Gibbs energy " "assumes constant heat of reaction. Please ensure you are " "using the constant_dh_rxn method for this reaction".format( rblock.name)) rblock.ds_rxn_ref = Var( doc="Specific molar entropy of reaction at reference state", units=units["entropy_mole"]) set_param_from_config(rblock, param="ds_rxn_ref", config=config) rblock.T_eq_ref = Var( doc="Reference temperature for equilibrium constant", units=units["temperature"]) set_param_from_config(rblock, param="T_eq_ref", config=config)
def build_parameters(rblock, config): parent = rblock.parent_block() units = parent.get_metadata().derived_units rbasis = parent.config.reaction_basis if rbasis == MaterialFlowBasis.molar: r_base = units["amount"] elif rbasis == MaterialFlowBasis.mass: r_base = units["mass"] else: raise BurntToast( "{} for unexpected reaction basis {}. This should not happen " "so please contact the IDAES developers with this bug." .format(rblock.name, rbasis)) c_form = config.concentration_form if c_form is None: raise ConfigurationError( "{} concentration_form configuration argument was not set. " "Please ensure that this argument is included in your " "configuration dict.".format(rblock.name)) elif (c_form == ConcentrationForm.moleFraction or c_form == ConcentrationForm.massFraction): r_units = r_base*units["volume"]**-1*units["time"]**-1 else: order = 0 for p, j in parent.config.property_package._phase_component_set: order += -rblock.reaction_order[p, j].value if (c_form == ConcentrationForm.molarity or c_form == ConcentrationForm.activity): c_units = units["density_mole"] elif c_form == ConcentrationForm.molality: c_units = units["amount"]*units["mass"]**-1 elif c_form == ConcentrationForm.partialPressure: c_units = units["pressure"] else: raise BurntToast( "{} get_concentration_term received unrecognised " "ConcentrationForm ({}). This should not happen - please " "contact the IDAES developers with this bug." .format(rblock.name, c_form)) r_units = (r_base * units["length"]**-3 * units["time"]**-1 * c_units**order) rblock.arrhenius_const = Var( doc="Arrhenius constant (pre-exponential factor)", units=r_units) set_param_from_config(rblock, param="arrhenius_const", config=config) rblock.energy_activation = Var( doc="Activation energy", units=units["energy_mole"]) set_param_from_config(rblock, param="energy_activation", config=config)
def build_parameters(cobj): if not hasattr(cobj, "cp_mol_ig_comp_coeff_a0"): cp_mol_ig_comp.build_parameters(cobj) units = cobj.parent_block().get_metadata().derived_units cobj.entr_mol_form_vap_comp_ref = Var( doc="Vapor phase molar entropy of formation @ Tref", units=units["entropy_mole"]) set_param_from_config(cobj, param="entr_mol_form_vap_comp_ref")
def build_parameters(cobj): if not hasattr(cobj, "cp_mol_liq_comp_coeff"): Constant.cp_mol_liq_comp.build_parameters(cobj) units = cobj.parent_block().get_metadata().derived_units cobj.entr_mol_form_liq_comp_ref = Var( doc="Liquid phase molar entropy of formation @ Tref", units=units["entropy_mole"]) set_param_from_config(cobj, param="entr_mol_form_liq_comp_ref")
def build_parameters(rblock, config): parent = rblock.parent_block() units = parent.get_metadata().derived_units c_form = config.concentration_form if c_form is None: raise ConfigurationError( "{} concentration_form configuration argument was not set. " "Please ensure that this argument is included in your " "configuration dict.".format(rblock.name)) elif (c_form == ConcentrationForm.moleFraction or c_form == ConcentrationForm.massFraction or c_form == ConcentrationForm.activity): e_units = pyunits.dimensionless else: order = 0 try: # This will work for Reaction Packages pc_set = parent.config.property_package._phase_component_set except AttributeError: # Need to allow for inherent reactions in Property Packages if not parent._electrolyte: # In most cases ,should have _phase_component_set pc_set = parent._phase_component_set else: # However, for electrolytes need true species set pc_set = parent.true_phase_component_set for p, j in pc_set: order += rblock.reaction_order[p, j].value if c_form == ConcentrationForm.molarity: c_units = units["density_mole"] elif c_form == ConcentrationForm.molality: c_units = units["amount"] * units["mass"]**-1 elif c_form == ConcentrationForm.partialPressure: c_units = units["pressure"] else: raise BurntToast( "{} get_concentration_term received unrecognised " "ConcentrationForm ({}). This should not happen - please " "contact the IDAES developers with this bug.".format( rblock.name, c_form)) e_units = c_units**order rblock.k_eq_ref = Var(doc="Equilibrium constant at reference state", units=e_units) set_param_from_config(rblock, param="k_eq_ref", config=config) rblock.T_eq_ref = Var( doc="Reference temperature for equilibrium constant", units=units["temperature"]) set_param_from_config(rblock, param="T_eq_ref", config=config)
def test_indexed(self): m = ConcreteModel() m.b = Block() m.b.config = ConfigBlock(implicit=True) m.b.config.parameter_data = {"test_param": {"1": 42}} m.b.test_param_1 = Var(initialize=1) set_param_from_config(m.b, "test_param", index="1") assert m.b.test_param_1.value == 42
def test_no_param(self): m = ConcreteModel() m.b = Block() m.b.config = ConfigBlock(implicit=True) m.b.config.parameter_data = {"test_param": 42} with pytest.raises(AttributeError, match="b - set_param_from_config method was " "provided with param argument test_param, but no " "attribute of that name exists."): set_param_from_config(m.b, "test_param")
def build_parameters(cobj): if not hasattr(cobj, "cp_mol_ig_comp_coeff_A"): cp_mol_ig_comp.build_parameters(cobj) base_units = cobj.parent_block().get_metadata().default_units h_units = (base_units["mass"] * base_units["length"]**2 * base_units["time"]**-2 * base_units["amount"]**-1) cobj.enth_mol_form_vap_comp_ref = Var( doc="Vapor phase molar heat of formation @ Tref", units=h_units) set_param_from_config(cobj, param="enth_mol_form_vap_comp_ref")
def test_invalid_config(self): m = ConcreteModel() m.b = Block() m.b.config = "foo" m.b.test_param = Var(initialize=1) with pytest.raises(TypeError, match="b - set_param_from_config - config argument " "provided is not an instance of a Config Block."): set_param_from_config(m.b, "test_param")
def build_parameters(cobj): if not hasattr(cobj, "cp_mol_ig_comp_coeff"): Constant.cp_mol_ig_comp.build_parameters(cobj) if cobj.parent_block().config.include_enthalpy_of_formation: units = cobj.parent_block().get_metadata().derived_units cobj.enth_mol_form_ig_comp_ref = Var( doc="Ideal gas molar heat of formation @ Tref", units=units["energy_mole"]) set_param_from_config(cobj, param="enth_mol_form_ig_comp_ref")
def test_specified_config(self): m = ConcreteModel() m.b = Block() m.b.config2 = ConfigBlock(implicit=True) m.b.config2.parameter_data = {"test_param": 42} m.b.test_param = Var(initialize=1) set_param_from_config(m.b, "test_param", config=m.b.config2) assert m.b.test_param.value == 42
def build_parameters(rblock, config): parent = rblock.parent_block() units = parent.get_metadata().derived_units c_form = config.concentration_form if c_form is None: raise ConfigurationError( "{} concentration_form configuration argument was not set. " "Please ensure that this argument is included in your " "configuration dict.".format(rblock.name)) elif (c_form == ConcentrationForm.molarity or c_form == ConcentrationForm.activity): order = 0 try: # This will work for Reaction Packages pc_set = parent.config.property_package._phase_component_set except AttributeError: # Need to allow for inherent reactions in Property Packages if not parent._electrolyte: # In most cases ,should have _phase_component_set pc_set = parent._phase_component_set else: # However, for electrolytes need true species set pc_set = parent.true_phase_component_set for p, j in pc_set: order += rblock.reaction_order[p, j].value rblock._keq_units = (pyunits.convert(1 * pyunits.mol / pyunits.L, units["density_mole"]))**order else: raise ConfigurationError( "{} calculation of equilibrium constant based on Gibbs energy " "is only supported for molarity or activity forms. " "Currently selected form: {}".format(rblock.name, c_form)) # Check that heat of reaction is constant if config.heat_of_reaction is not constant_dh_rxn: raise ConfigurationError( "{} calculating equilibrium constants from Gibbs energy " "assumes constant heat of reaction. Please ensure you are " "using the constant_dh_rxn method for this reaction".format( rblock.name)) rblock.ds_rxn_ref = Var( doc="Specific molar entropy of reaction at reference state", units=units["entropy_mole"]) set_param_from_config(rblock, param="ds_rxn_ref", config=config) rblock.T_eq_ref = Var( doc="Reference temperature for equilibrium constant", units=units["temperature"]) set_param_from_config(rblock, param="T_eq_ref", config=config)
def test_no_config(self): m = ConcreteModel() m.b = Block() m.b.test_param = Var(initialize=1) with pytest.raises(AttributeError, match="b - set_param_from_config method was " "not provided with a config argument, but no " "default Config block exists. Please specify the " "Config block to use via the config argument."): set_param_from_config(m.b, "test_param")
def test_consistent_units(self, caplog): caplog.set_level(idaeslog.DEBUG, logger=("idaes.core.util.misc")) m = ConcreteModel() m.b = Block() m.b.config = ConfigBlock(implicit=True) m.b.config.parameter_data = {"test_param": (42, units.m)} m.b.test_param = Var(initialize=1, units=units.m) set_param_from_config(m.b, "test_param") assert m.b.test_param.value == 42
def test_no_parameter_data(self): m = ConcreteModel() m.b = Block() m.b.config = ConfigBlock(implicit=True) m.b.config.parameter_data = {} m.b.test_param = Var(initialize=1) with pytest.raises(KeyError, match="b - set_param_from_config method was " "provided with param argument test_param, but the " "config block does not contain a value for this " "parameter."): set_param_from_config(m.b, "test_param")
def test_no_parameter_data_indexed(self): m = ConcreteModel() m.b = Block() m.b.config = ConfigBlock(implicit=True) m.b.config.parameter_data = {"test_param": {"2": 42}} m.b.test_param_1 = Var(initialize=1) with pytest.raises(KeyError, match="b - set_param_from_config method was " "provided with param and index arguments " "test_param 1, but the config block does not " "contain a value for this parameter and index."): set_param_from_config(m.b, "test_param", index="1")
def build_parameters(rblock, config): units = rblock.parent_block().get_metadata().derived_units rbasis = rblock.parent_block().config.reaction_basis if rbasis == MaterialFlowBasis.molar: basis = "mole" elif rbasis == MaterialFlowBasis.mass: basis = "mass" rblock.dh_rxn_ref = Var( doc="Specific heat of reaction at reference state", units=units["energy_" + basis]) set_param_from_config(rblock, param="dh_rxn_ref", config=config)
def test_inconsistent_units_none_2(self, caplog): caplog.set_level(idaeslog.DEBUG, logger=("idaes.core.util.misc")) m = ConcreteModel() m.b = Block() m.b.config = ConfigBlock(implicit=True) m.b.config.parameter_data = {"test_param": (42, units.s)} m.b.test_param = Var(initialize=1, units=None) with pytest.raises(UnitsError, match="Cannot convert s to None. Units " "are not compatible."): set_param_from_config(m.b, "test_param")
def test_no_param_indexed(self): m = ConcreteModel() m.b = Block() m.b.config = ConfigBlock(implicit=True) m.b.config.parameter_data = {"test_param": {"1": 42}} m.b.test_param = Var(initialize=1) with pytest.raises(AttributeError, match="b - set_param_from_config method was " "provided with param and index arguments " "test_param 1, but no attribute with that " "combination \(test_param_1\) exists."): set_param_from_config(m.b, "test_param", index="1")
def test_unitted_default(self, caplog): caplog.set_level(idaeslog.DEBUG, logger=("idaes.core.util.misc")) m = ConcreteModel() m.b = Block() m.b.config = ConfigBlock(implicit=True) m.b.config.parameter_data = {"test_param": 42} m.b.test_param = Var(initialize=1, units=units.m) set_param_from_config(m.b, "test_param") assert m.b.test_param.value == 42 assert ("b no units provided for parameter test_param - assuming " "default units" in caplog.text)
def build(self): super(ComponentData, self).build() # If the component_list does not exist, add reference to new Component # The IF is mostly for backwards compatability, to allow for old-style # property packages where the component_list already exists but we # need to add new Component objects if not self.config._component_list_exists: if not self.config._electrolyte: self.__add_to_component_list() else: self._add_to_electrolyte_component_list() base_units = self.parent_block().get_metadata().default_units if isinstance(base_units["mass"], _PyomoUnit): # Backwards compatability check p_units = (base_units["mass"] / base_units["length"] / base_units["time"]**2) else: # Backwards compatability check p_units = None # Create Param for molecular weight if provided if "mw" in self.config.parameter_data: if isinstance(self.config.parameter_data["mw"], tuple): mw_init = pyunits.convert_value( self.config.parameter_data["mw"][0], from_units=self.config.parameter_data["mw"][1], to_units=base_units["mass"] / base_units["amount"]) else: _log.debug("{} no units provided for parameter mw - assuming " "default units".format(self.name)) mw_init = self.config.parameter_data["mw"] self.mw = Param(initialize=mw_init, units=base_units["mass"] / base_units["amount"]) # Create Vars for common parameters param_dict = { "pressure_crit": p_units, "temperature_crit": base_units["temperature"], "omega": None } for p, u in param_dict.items(): if p in self.config.parameter_data: self.add_component(p, Var(units=u)) set_param_from_config(self, p)
def build_parameters(rblock, config): parent = rblock.parent_block() units = parent.get_metadata().derived_units c_form = config.concentration_form if c_form is None: raise ConfigurationError( "{} concentration_form configuration argument was not set. " "Please ensure that this argument is included in your " "configuration dict.".format(rblock.name)) elif (c_form == ConcentrationForm.moleFraction or c_form == ConcentrationForm.massFraction): e_units = None else: order = 0 for p, j in parent.config.property_package._phase_component_set: order += rblock.reaction_order[p, j].value if (c_form == ConcentrationForm.molarity or c_form == ConcentrationForm.activity): c_units = units["density_mole"] elif c_form == ConcentrationForm.molality: c_units = units["amount"]*units["mass"]**-1 elif c_form == ConcentrationForm.partialPressure: c_units = units["pressure"] else: raise BurntToast( "{} get_concentration_term received unrecognised " "ConcentrationForm ({}). This should not happen - please " "contact the IDAES developers with this bug." .format(rblock.name, c_form)) e_units = c_units**order rblock.k_eq_ref = Var( doc="Equilibrium constant at reference state", units=e_units) set_param_from_config(rblock, param="k_eq_ref", config=config) rblock.T_eq_ref = Var( doc="Reference temperature for equilibrium constant", units=units["temperature"]) set_param_from_config(rblock, param="T_eq_ref", config=config)
def build_parameters(cobj, phase): cobj.diffus_phase_comp_coeff_1 = Var( doc="Parameter 1 for liquid phase diffusivity model", units=pyunits.m**2 / pyunits.s) set_param_from_config(cobj, param="diffus_phase_comp_coeff", index="1") cobj.diffus_phase_comp_coeff_2 = Var( doc="Parameter 2 for liquid phase diffusivity model", units=pyunits.m**5 / pyunits.kmol / pyunits.s) set_param_from_config(cobj, param="diffus_phase_comp_coeff", index="2") cobj.diffus_phase_comp_coeff_3 = Var( doc="Parameter 3 for liquid phase diffusivity model", units=pyunits.m**8 / pyunits.kmol**2 / pyunits.s) set_param_from_config(cobj, param="diffus_phase_comp_coeff", index="3") cobj.diffus_phase_comp_coeff_4 = Var( doc="Parameter 4 for liquid phase diffusivity model", units=pyunits.K) set_param_from_config(cobj, param="diffus_phase_comp_coeff", index="4") cobj.diffus_phase_comp_coeff_5 = Var( doc="Parameter 5 for liquid phase diffusivity model", units=(pyunits.m**3) * pyunits.K / pyunits.kmol) set_param_from_config(cobj, param="diffus_phase_comp_coeff", index="5")
def build_parameters(cobj): cobj.dens_mol_liq_comp_coeff_eqn_type = Param( mutable=True, doc="Liquid molar density equation form") try: set_param_from_config(cobj, param="dens_mol_liq_comp_coeff", index="eqn_type") except KeyError: _log.warning("DEPRECATED - {} dens_mol_liq_comp_coeff index " "'eqn_type' should be specified, defaulting to " "equation form 1.".format(cobj)) # default to equation form 1 if not specified cobj.dens_mol_liq_comp_coeff_eqn_type.value = 1 if cobj.dens_mol_liq_comp_coeff_eqn_type.value == 1: dens_mol_liq_comp_eqn_1.build_parameters(cobj) elif cobj.dens_mol_liq_comp_coeff_eqn_type.value == 2: dens_mol_liq_comp_eqn_2.build_parameters(cobj) else: raise ConfigurationError( f"{cobj.name} unrecognized value for " f"dens_mol_liq_comp equation type: " f"{cobj.dens_mol_liq_comp_coeff_eqn_type}")
def build_parameters(cobj): cobj.cp_mol_ig_comp_coeff_a0 = Var( doc="Parameter a0 for ideal gas molar heat capacity", units=None) set_param_from_config(cobj, param="cp_mol_ig_comp_coeff", index="a0") cobj.cp_mol_ig_comp_coeff_a1 = Var( doc="Parameter a1 for ideal gas molar heat capacity", units=pyunits.K**-1) set_param_from_config(cobj, param="cp_mol_ig_comp_coeff", index="a1") cobj.cp_mol_ig_comp_coeff_a2 = Var( doc="Parameter a2 for ideal gas molar heat capacity", units=pyunits.K**-2) set_param_from_config(cobj, param="cp_mol_ig_comp_coeff", index="a2") cobj.cp_mol_ig_comp_coeff_a3 = Var( doc="Parameter a3 for ideal gas molar heat capacity", units=pyunits.K**-3) set_param_from_config(cobj, param="cp_mol_ig_comp_coeff", index="a3") cobj.cp_mol_ig_comp_coeff_a4 = Var( doc="Parameter a4 for ideal gas molar heat capacity", units=pyunits.K**-4) set_param_from_config(cobj, param="cp_mol_ig_comp_coeff", index="a4")
def build(self): super().build() # If the component_list does not exist, add reference to new Component # The IF is mostly for backwards compatability, to allow for old-style # property packages where the component_list already exists but we # need to add new Component objects if not self.config._component_list_exists: if not self.config._electrolyte: self._add_to_component_list() else: self._add_to_electrolyte_component_list() base_units = self.parent_block().get_metadata().default_units der_units = self.parent_block().get_metadata().derived_units p_units = (base_units["mass"] / base_units["length"] / base_units["time"]**2) # Create Param for molecular weight if provided param_dict = {"mw": base_units["mass"] / base_units["amount"]} for p, u in param_dict.items(): if p in self.config.parameter_data: self.add_component(p, Param(mutable=True, units=u)) set_param_from_config(self, p) # Create Vars for common parameters var_dict = { "dens_mol_crit": der_units["density_mole"], "omega": pyunits.dimensionless, "pressure_crit": p_units, "temperature_crit": base_units["temperature"] } for p, u in var_dict.items(): if p in self.config.parameter_data: self.add_component(p, Var(units=u)) set_param_from_config(self, p)
def build_parameters(cobj): cobj.pressure_sat_comp_coeff_1 = Var( doc="Coefficient 1 for calculating Psat", units=pyunits.dimensionless) set_param_from_config(cobj, param="pressure_sat_comp_coeff", index="1") cobj.pressure_sat_comp_coeff_2 = Var( doc="Coefficient 2 for calculating Psat", units=pyunits.K) set_param_from_config(cobj, param="pressure_sat_comp_coeff", index="2") cobj.pressure_sat_comp_coeff_3 = Var( doc="Coefficient 3 for calculating Psat", units=pyunits.dimensionless) set_param_from_config(cobj, param="pressure_sat_comp_coeff", index="3") cobj.pressure_sat_comp_coeff_4 = Var( doc="Coefficient 4 for calculating Psat", units=pyunits.K**-2) set_param_from_config(cobj, param="pressure_sat_comp_coeff", index="4")