예제 #1
0
    def frame(self):
        m = ConcreteModel()

        # Create a dummy parameter block
        m.params = Block()

        # Add necessary parameters to parameter block
        m.params.config = ConfigBlock()
        m.params.config.declare("state_bounds", ConfigValue(default={}))

        m.params.phase_list = Set(initialize=["a", "b"], ordered=True)
        m.params.component_list = Set(initialize=[1, 2, 3], ordered=True)

        # Create a dummy state block
        m.props = Block([1])
        m.props[1].config = ConfigBlock()
        m.props[1].config.declare("defined_state", ConfigValue(default=False))
        add_object_reference(m.props[1], "_params", m.params)

        # Add necessary variables that would be built by other methods
        m.props[1].dens_mol_phase = Var(m.params.phase_list, initialize=1)
        m.props[1].enth_mol_phase = Var(m.params.phase_list, initialize=1)

        define_state(m.props[1])

        return m
예제 #2
0
    def frame2(self):
        m = Block(concrete=True)

        m.params = Block()

        m.params.config = ConfigBlock()

        m.params.config.declare("inherent_reactions", ConfigBlock(
            implicit=True, implicit_domain=rxn_config))

        add_object_reference(m, "state_ref", m)

        m.conc_mol_phase_comp = Var()
        m.act_phase_comp = Var()
        m.molality_phase_comp = Var()
        m.mole_frac_phase_comp = Var()
        m.mass_frac_phase_comp = Var()
        m.pressure_phase_comp = Var()

        m.log_conc_mol_phase_comp = Var()
        m.log_act_phase_comp = Var()
        m.log_molality_phase_comp = Var()
        m.log_mole_frac_phase_comp = Var()
        m.log_mass_frac_phase_comp = Var()
        m.log_pressure_phase_comp = Var()

        return m
예제 #3
0
def frame():
    m = ConcreteModel()

    # Create a dummy parameter block
    m.params = Block()

    m.params.config = ConfigBlock(implicit=True)
    m.params.config.parameter_data = {"relative_permittivity_liq_comp": 101}

    m.meta_object = PropertyClassMetadata()
    m.meta_object.default_units["temperature"] = pyunits.K
    m.meta_object.default_units["mass"] = pyunits.kg
    m.meta_object.default_units["length"] = pyunits.m
    m.meta_object.default_units["time"] = pyunits.s
    m.meta_object.default_units["amount"] = pyunits.mol

    def get_metadata(self):
        return m.meta_object

    m.get_metadata = types.MethodType(get_metadata, m)
    m.params.get_metadata = types.MethodType(get_metadata, m.params)

    # Add necessary parameters to parameter block
    m.params.temperature_ref = Var(initialize=298.15, units=pyunits.K)
    m.params.pressure_ref = Var(initialize=1e5, units=pyunits.Pa)

    # Create a dummy state block
    m.props = Block([1])
    add_object_reference(m.props[1], "params", m.params)

    m.props[1].temperature = Var(initialize=500, units=pyunits.K)
    m.props[1].pressure = Var(initialize=101325, units=pyunits.Pa)

    return m
예제 #4
0
def frame():
    m = ConcreteModel()

    # Create a dummy parameter block
    m.params = Block()

    # Add necessary parameters to parameter block
    m.params.temperature_ref = Var(initialize=298.15)
    m.params.pressure_ref = Var(initialize=1e5)

    m.params.pressure_sat_comp_coeff = Var(["H2O"], ["A", "B", "C"])
    m.params.cp_mol_ig_comp_coeff = Var(
            ["H2O"], ["A", "B", "C", "D", "E", "F", "G", "H"])

    m.params.pressure_sat_comp_coeff["H2O", "A"].value = 8.55959  # +5 for unit conversion
    m.params.pressure_sat_comp_coeff["H2O", "B"].value = 643.748
    m.params.pressure_sat_comp_coeff["H2O", "C"].value = -198.043

    m.params.cp_mol_ig_comp_coeff["H2O", "A"].value = 30.09200
    m.params.cp_mol_ig_comp_coeff["H2O", "B"].value = 6.832514
    m.params.cp_mol_ig_comp_coeff["H2O", "C"].value = 6.793435
    m.params.cp_mol_ig_comp_coeff["H2O", "D"].value = -2.534480
    m.params.cp_mol_ig_comp_coeff["H2O", "E"].value = 0.082139
    m.params.cp_mol_ig_comp_coeff["H2O", "F"].value = -250.8810
    m.params.cp_mol_ig_comp_coeff["H2O", "G"].value = 223.3967
    m.params.cp_mol_ig_comp_coeff["H2O", "H"].value = -241.8264

    # Create a dummy state block
    m.props = Block([1])
    add_object_reference(m.props[1], "_params", m.params)

    m.props[1].temperature = Var(initialize=500)
    m.props[1].pressure = Var(initialize=101325)

    return m
예제 #5
0
    def frame(self):
        m = ConcreteModel()

        # Create a dummy parameter block
        m.params = DummyParameterBlock(default={
                "components": {"c1": {}, "c2": {}, "c3": {}},
                "phases": {
                    "p1": {"equation_of_state": dummy_eos},
                    "p2": {"equation_of_state": dummy_eos},
                    "p3": {"equation_of_state": dummy_eos}},
                "state_definition": modules[__name__],
                "pressure_ref": 1e5,
                "temperature_ref": 300,
                "state_bounds": {"flow_mol": (0, 100, 200),
                                 "temperature": (290, 345, 400),
                                 "pressure": (1e5, 3e5, 5e5),
                                 "enth_mol": (0, 500, 1000)},
                "base_units": {"time": pyunits.s,
                               "length": pyunits.m,
                               "mass": pyunits.kg,
                               "amount": pyunits.mol,
                               "temperature": pyunits.K}})

        # Create a dummy state block
        m.props = Block([1])
        m.props[1].config = ConfigBlock()
        m.props[1].config.declare("defined_state", ConfigValue(default=True))
        add_object_reference(m.props[1], "params", m.params)

        # Add necessary variables that would be built by other methods
        m.props[1].enth_mol_phase = Var(m.params.phase_list,
                                        initialize=1,
                                        units=pyunits.J/pyunits.mol)

        return m
예제 #6
0
    def build(self):
        """
        Callable method for Block construction
        """
        super(GasPhaseThermoStateBlockData, self).build()

        # Object reference for molecular weight if needed by CV1D
        # Molecular weights
        add_object_reference(self, "mw_comp", self.config.parameters.mw_comp)
        """List the necessary state variable objects."""
        self.flow_mol = Var(initialize=1.0,
                            domain=Reals,
                            doc='Component molar flowrate [mol/s]')
        self.mole_frac_comp = Var(self._params.component_list,
                                  domain=Reals,
                                  initialize=1 /
                                  len(self._params.component_list),
                                  doc='State component mole fractions [-]')
        self.pressure = Var(initialize=1.01325,
                            domain=Reals,
                            doc='State pressure [bar]')
        self.temperature = Var(initialize=298.15,
                               domain=Reals,
                               doc='State temperature [K]')

        # Create standard constraints
        # Sum mole fractions if not inlet block
        if self.config.defined_state is False:

            def sum_component_eqn(b):
                return 1e2 == 1e2 * sum(b.mole_frac_comp[j]
                                        for j in b._params.component_list)

            self.sum_component_eqn = Constraint(rule=sum_component_eqn)
예제 #7
0
def frame():
    m = ConcreteModel()

    # Create a dummy parameter block
    m.params = Block()
    m.params.config = ConfigBlock()
    m.params.config.declare(
        "equation_of_state",
        ConfigValue(default={
            "Liq": DummyEoS,
            "Vap": DummyEoS
        }))

    m.params.component_list = Set(initialize=["H2O"])
    m.params.phase_list = Set(initialize=["Liq", "Vap"])

    m.params.temperature_crit_comp = Var(["H2O"], initialize=647.3)

    # Create a dummy state block
    m.props = Block([1])
    add_object_reference(m.props[1], "_params", m.params)

    m.props[1].temperature = Var(initialize=300)
    m.props[1].temperature_bubble = Var(initialize=300)
    m.props[1].temperature_dew = Var(initialize=300)

    m.props[1].fug_phase_comp = Var(m.params.phase_list,
                                    m.params.component_list,
                                    initialize=10)

    smooth_VLE.phase_equil(m.props[1])

    return m
예제 #8
0
    def frame(self):
        m = ConcreteModel()

        m.params = DummyParameterBlock(default={
                "components": {"c1": {}, "c2": {}, "c3": {}},
                "phases": {
                    "a": {"equation_of_state": dummy_eos},
                    "b": {"equation_of_state": dummy_eos}},
                "state_definition": modules[__name__],
                "pressure_ref": 1e5,
                "temperature_ref": 300,
                "state_bounds": {
                    "flow_mol": (0, 0.1, 0.2, pyunits.kmol/pyunits.s),
                    "temperature": (522, 621, 720, pyunits.degR),
                    "pressure": (1, 3, 5, pyunits.bar),
                    "enth_mol": (0, 0.5, 1, pyunits.kJ/pyunits.mol)},
                "base_units": {"time": pyunits.s,
                               "length": pyunits.m,
                               "mass": pyunits.kg,
                               "amount": pyunits.mol,
                               "temperature": pyunits.K}})

        # Create a dummy state block
        m.props = Block([1])
        m.props[1].config = ConfigBlock()
        m.props[1].config.declare("defined_state", ConfigValue(default=False))
        add_object_reference(m.props[1], "params", m.params)

        # Add necessary variables that would be built by other methods
        m.props[1].dens_mol_phase = Var(m.params.phase_list, initialize=1)
        m.props[1].enth_mol_phase = Var(m.params.phase_list, initialize=1)

        define_state(m.props[1])

        return m
예제 #9
0
    def test_mole_frac(self, caplog):
        m = ConcreteModel()
        
        caplog.set_level(
            idaeslog.WARNING,
            logger=("idaes.generic_models.properties.core."))

        m.params = DummyParameterBlock(default={
                "components": {"c1": {}, "c2": {}, "c3": {}},
                "phases": {
                    "p1": {"equation_of_state": dummy_eos}},
                "state_definition": modules[__name__],
                "pressure_ref": 1e5,
                "temperature_ref": 300,
                "base_units": {"time": pyunits.s,
                               "length": pyunits.m,
                               "mass": pyunits.kg,
                               "amount": pyunits.mol,
                               "temperature": pyunits.K},
                "state_bounds": {"mole_frac_comp": (None, None, None)}})

        # Create a dummy state block
        m.props = Block([1])
        m.props[1].config = ConfigBlock()
        m.props[1].config.declare("defined_state", ConfigValue(default=False))
        add_object_reference(m.props[1], "params", m.params)

        with pytest.raises(
                ConfigurationError,
                match="props\[1\] - found unexpected state_bounds key "
                "mole_frac_comp. Please ensure bounds are provided only for "
                "expected state variables and that you have typed the "
                "variable names correctly."):
            define_state(m.props[1])
예제 #10
0
def test_power_law_rate_no_order():
    m = ConcreteModel()

    # # Add a test thermo package for validation
    m.pparams = PhysicalParameterTestBlock()
    m.thermo = m.pparams.build_state_block([1])

    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
            },
            "rate_reactions": {
                "r1": {
                    "stoichiometry": {
                        ("p1", "c1"): -1,
                        ("p1", "c2"): 2
                    },
                    "rate_form": power_law_rate,
                    "concentration_form": ConcentrationForm.moleFraction
                }
            }
        })

    # Create a dummy state block
    m.rxn = Block([1])
    add_object_reference(m.rxn[1], "params", m.rparams)
    add_object_reference(m.rxn[1], "state_ref", m.thermo[1])

    m.rxn[1].k_rxn = Var(["r1"], initialize=1)

    power_law_rate.build_parameters(m.rparams.reaction_r1,
                                    m.rparams.config.rate_reactions["r1"])

    # Check parameter construction
    assert isinstance(m.rparams.reaction_r1.reaction_order, Var)
    assert len(m.rparams.reaction_r1.reaction_order) == 4
    for i, v in m.rparams.reaction_r1.reaction_order.items():
        try:
            stoic = m.rparams.config.rate_reactions.r1.stoichiometry[i]
        except KeyError:
            stoic = 0

        if stoic < 1:
            assert v.value == -stoic
        else:
            assert v.value == 0

    # Check reaction form
    rform = power_law_rate.return_expression(m.rxn[1], m.rparams.reaction_r1,
                                             "r1", 300)

    assert str(rform) == str(m.rxn[1].k_rxn["r1"] *
                             m.thermo[1].mole_frac_phase_comp["p1", "c1"]**
                             m.rparams.reaction_r1.reaction_order["p1", "c1"])
    def build(self):
        """
        Callable method for Block construction
        """
        super(HDAReactionBlockData, self).build()

        # Heat of reaction - no _ref as this is the actual property
        add_object_reference(self, "dh_rxn", self.config.parameters.dh_rxn)
예제 #12
0
def test_add_object_reference():
    m = ConcreteModel()

    m.s = Set(initialize=[1, 2, 3])

    add_object_reference(m, "test_ref", m.s)

    assert hasattr(m, "test_ref")
    assert m.test_ref == m.s
예제 #13
0
def frame():
    m = ConcreteModel()

    # Create a dummy parameter block
    m.params = Block()

    m.params.config = ConfigBlock(implicit=True)
    m.params.config.parameter_data = {
        "cp_mol_ig_comp_coeff": {
            'A': 3.224e1,
            'B': 1.924e-3,
            'C': 1.055e-5,
            'D': -3.596e-9
        },
        "enth_mol_form_vap_comp_ref": -241.83e3,
        "entr_mol_form_vap_comp_ref": 188.84,
        "pressure_sat_comp_coeff": {
            'A': -7.76451,
            'B': 1.45838,
            'C': -2.77580,
            'D': -1.23303
        }
    }
    m.params.config.include_enthalpy_of_formation = True

    # Also need to dummy configblock on the model for the test
    m.config = ConfigBlock(implicit=True)
    m.config.include_enthalpy_of_formation = True

    m.meta_object = PropertyClassMetadata()
    m.meta_object.default_units["temperature"] = pyunits.K
    m.meta_object.default_units["mass"] = pyunits.kg
    m.meta_object.default_units["length"] = pyunits.m
    m.meta_object.default_units["time"] = pyunits.s
    m.meta_object.default_units["amount"] = pyunits.mol

    def get_metadata(self):
        return m.meta_object

    m.get_metadata = types.MethodType(get_metadata, m)
    m.params.get_metadata = types.MethodType(get_metadata, m.params)

    # Add necessary parameters to parameter block
    m.params.temperature_ref = Var(initialize=273.15, units=pyunits.K)
    m.params.pressure_ref = Var(initialize=1e5, units=pyunits.Pa)

    m.params.temperature_crit = Var(initialize=647.3, units=pyunits.K)
    m.params.pressure_crit = Var(initialize=221.2e5, units=pyunits.Pa)

    # Create a dummy state block
    m.props = Block([1])
    add_object_reference(m.props[1], "params", m.params)

    m.props[1].temperature = Var(initialize=298.15, units=pyunits.K)
    m.props[1].pressure = Var(initialize=101325, units=pyunits.Pa)

    return m
예제 #14
0
def frame():
    m = ConcreteModel()

    # Create a dummy parameter block
    m.params = Block()

    m.params.config = ConfigBlock(implicit=True)
    m.params.config.parameter_data = {
        "cp_mol_ig_comp_coeff": {
            'a0': 4.395,
            'a1': -4.186e-3,
            'a2': 1.405e-5,
            'a3': -1.564e-8,
            'a4': 0.632e-11
        },
        "enth_mol_form_vap_comp_ref": -241.81e3,
        "entr_mol_form_vap_comp_ref": 188.84,
        "pressure_sat_comp_coeff": {
            'A': 5.11564,
            'B': 1687.537,
            'C': 230.14
        }
    }
    m.params.config.include_enthalpy_of_formation = True

    # Also need to dummy configblock on the model for the test
    m.config = ConfigBlock(implicit=True)
    m.config.include_enthalpy_of_formation = True

    m.meta_object = PropertyClassMetadata()
    m.meta_object.default_units["temperature"] = pyunits.K
    m.meta_object.default_units["mass"] = pyunits.kg
    m.meta_object.default_units["length"] = pyunits.m
    m.meta_object.default_units["time"] = pyunits.s
    m.meta_object.default_units["amount"] = pyunits.mol

    def get_metadata(self):
        return m.meta_object

    m.get_metadata = types.MethodType(get_metadata, m)
    m.params.get_metadata = types.MethodType(get_metadata, m.params)

    # Add necessary parameters to parameter block
    m.params.temperature_ref = Var(initialize=273.15, units=pyunits.K)
    m.params.pressure_ref = Var(initialize=1e5, units=pyunits.Pa)

    m.params.temperature_crit = Var(initialize=647.15, units=pyunits.K)
    m.params.pressure_crit = Var(initialize=220.64e5, units=pyunits.Pa)

    # Create a dummy state block
    m.props = Block([1])
    add_object_reference(m.props[1], "params", m.params)

    m.props[1].temperature = Var(initialize=298.15, units=pyunits.K)
    m.props[1].pressure = Var(initialize=101325, units=pyunits.Pa)

    return m
예제 #15
0
def frame():
    m = ConcreteModel()

    # Create a dummy parameter block
    m.params = Block()

    m.params.config = ConfigBlock(implicit=True)
    m.params.config.parameter_data = {
        "cp_mol_ig_comp_coeff": {
            'A': 7.701,
            'B': 4.595e-4,
            'C': 2.521e-6,
            'D': -0.859e-9
        },
        "enth_mol_form_vap_comp_ref": (-57.797e3, pyunits.cal / pyunits.mol),
        "entr_mol_form_vap_comp_ref":
        (45.13, pyunits.cal / pyunits.mol / pyunits.K),
        "pressure_sat_comp_coeff": {
            'A': 18.3036,
            'B': 3816.44,
            'C': -46.13
        }
    }
    m.params.config.include_enthalpy_of_formation = True

    # Also need to dummy configblock on the model for the test
    m.config = ConfigBlock(implicit=True)
    m.config.include_enthalpy_of_formation = True

    m.meta_object = PropertyClassMetadata()
    m.meta_object.default_units["temperature"] = pyunits.K
    m.meta_object.default_units["mass"] = pyunits.kg
    m.meta_object.default_units["length"] = pyunits.m
    m.meta_object.default_units["time"] = pyunits.s
    m.meta_object.default_units["amount"] = pyunits.mol

    def get_metadata(self):
        return m.meta_object

    m.get_metadata = types.MethodType(get_metadata, m)
    m.params.get_metadata = types.MethodType(get_metadata, m.params)

    # Add necessary parameters to parameter block
    m.params.temperature_ref = Var(initialize=273.15, units=pyunits.K)
    m.params.pressure_ref = Var(initialize=1e5, units=pyunits.Pa)

    m.params.temperature_crit = Var(initialize=647.3, units=pyunits.K)
    m.params.pressure_crit = Var(initialize=217.6e5, units=pyunits.Pa)

    # Create a dummy state block
    m.props = Block([1])
    add_object_reference(m.props[1], "params", m.params)

    m.props[1].temperature = Var(initialize=298.15, units=pyunits.K)
    m.props[1].pressure = Var(initialize=101325, units=pyunits.Pa)

    return m
예제 #16
0
    def build(self):
        """
        Callable method for Block construction
        """
        super().build()

        # Create references to state vars
        # Concentration
        add_object_reference(self, "conc_mass_comp_ref",
                             self.state_ref.conc_mass_comp)
예제 #17
0
def frame():
    m = ConcreteModel()

    # Create a dummy parameter block
    m.params = Block()

    m.params.config = ConfigBlock(implicit=True)
    m.params.config.parameter_data = {
        "dens_mol_liq_comp_coeff":
        (55.2046332734557, pyunits.kmol / pyunits.m**3),
        "cp_mol_liq_comp_coeff":
        (75704.2953333398, pyunits.J / pyunits.kmol / pyunits.K),
        "enth_mol_form_liq_comp_ref": (-285.83, pyunits.kJ / pyunits.mol),
        "entr_mol_form_liq_comp_ref":
        (69.95, pyunits.J / pyunits.K / pyunits.mol),
        "cp_mol_ig_comp_coeff":
        (29114.850, pyunits.J / pyunits.kmol / pyunits.K),
        "enth_mol_form_ig_comp_ref": (0.0, pyunits.kJ / pyunits.mol),
        "entr_mol_form_ig_comp_ref": (0.0,
                                      pyunits.J / pyunits.K / pyunits.mol),
        "dens_mol_sol_comp_coeff": (100, pyunits.kmol / pyunits.m**3),
        "cp_mol_sol_comp_coeff": (100000,
                                  pyunits.J / pyunits.kmol / pyunits.K),
        "enth_mol_form_sol_comp_ref": (-300, pyunits.kJ / pyunits.mol),
        "entr_mol_form_sol_comp_ref": (50, pyunits.J / pyunits.K / pyunits.mol)
    }
    m.params.config.include_enthalpy_of_formation = True

    # Also need to dummy configblock on the model for the test
    m.config = ConfigBlock(implicit=True)
    m.config.include_enthalpy_of_formation = True

    m.meta_object = PropertyClassMetadata()
    m.meta_object.default_units["temperature"] = pyunits.K
    m.meta_object.default_units["mass"] = pyunits.kg
    m.meta_object.default_units["length"] = pyunits.m
    m.meta_object.default_units["time"] = pyunits.s
    m.meta_object.default_units["amount"] = pyunits.mol

    def get_metadata(self):
        return m.meta_object

    m.get_metadata = types.MethodType(get_metadata, m)
    m.params.get_metadata = types.MethodType(get_metadata, m.params)

    # Add necessary parameters to parameter block
    m.params.temperature_ref = Var(initialize=300, units=pyunits.K)

    # Create a dummy state block
    m.props = Block([1])
    add_object_reference(m.props[1], "params", m.params)

    m.props[1].temperature = Var(initialize=300, units=pyunits.K)

    return m
예제 #18
0
def model():
    m = ConcreteModel()

    # # Add a test thermo package for validation
    m.pparams = PhysicalParameterTestBlock()
    m.thermo = m.pparams.build_state_block([1])

    # Create a dummy reaction parameter block
    m.rparams = Block()

    m.rparams.config = ConfigBlock(implicit=True)

    m.rparams.config.property_package = m.pparams
    m.rparams.config.reaction_basis = MaterialFlowBasis.molar
    m.rparams.config.rate_reactions = ConfigBlock(implicit=True)
    m.rparams.config.rate_reactions.r1 = ConfigBlock(implicit=True)
    m.rparams.config.rate_reactions.r1 = {
        "stoichiometry": {
            ("p1", "c1"): -1,
            ("p1", "c2"): 2
        },
        "parameter_data": {}
    }
    m.rparams.config.equilibrium_reactions = ConfigBlock(implicit=True)
    m.rparams.config.equilibrium_reactions.e1 = ConfigBlock(implicit=True)
    m.rparams.config.equilibrium_reactions.e1 = {
        "stoichiometry": {
            ("p1", "c1"): -1,
            ("p1", "c2"): 2
        },
        "parameter_data": {}
    }

    m.rparams.reaction_r1 = Block()
    m.rparams.reaction_e1 = Block()

    m.meta_object = PropertyClassMetadata()
    m.meta_object.default_units["temperature"] = pyunits.K
    m.meta_object.default_units["mass"] = pyunits.kg
    m.meta_object.default_units["length"] = pyunits.m
    m.meta_object.default_units["time"] = pyunits.s
    m.meta_object.default_units["amount"] = pyunits.mol

    def get_metadata(self):
        return m.meta_object

    m.rparams.get_metadata = types.MethodType(get_metadata, m.rparams)

    # Create a dummy state block
    m.rxn = Block([1])
    add_object_reference(m.rxn[1], "params", m.rparams)
    add_object_reference(m.rxn[1], "state_ref", m.thermo[1])

    return m
예제 #19
0
def frame():
    m = ConcreteModel()

    # Create a dummy parameter block
    m.params = Block()

    m.params.config = ConfigBlock(implicit=True)
    m.params.config.parameter_data = {
        "dens_mol_liq_comp_coeff": {
            'eqn_type': 1,
            '1': 5.459,
            '2': 0.30542,
            '3': 647.13,
            '4': 0.081
        },
        "cp_mol_liq_comp_coeff": {
            '1': 2.7637e+05,
            '2': -2.0901e+03,
            '3': 8.1250e+00,
            '4': -1.4116e-2,
            '5': 9.3701e-06
        },
        "enth_mol_form_liq_comp_ref": -285.83e3,
        "entr_mol_form_liq_comp_ref": 69.95
    }
    m.params.config.include_enthalpy_of_formation = True

    # Also need to dummy configblock on the model for the test
    m.config = ConfigBlock(implicit=True)
    m.config.include_enthalpy_of_formation = True

    m.meta_object = PropertyClassMetadata()
    m.meta_object.default_units["temperature"] = pyunits.K
    m.meta_object.default_units["mass"] = pyunits.kg
    m.meta_object.default_units["length"] = pyunits.m
    m.meta_object.default_units["time"] = pyunits.s
    m.meta_object.default_units["amount"] = pyunits.mol

    def get_metadata(self):
        return m.meta_object

    m.get_metadata = types.MethodType(get_metadata, m)
    m.params.get_metadata = types.MethodType(get_metadata, m.params)

    # Add necessary parameters to parameter block
    m.params.temperature_ref = Var(initialize=273.16, units=pyunits.K)

    # Create a dummy state block
    m.props = Block([1])
    add_object_reference(m.props[1], "params", m.params)

    m.props[1].temperature = Var(initialize=273.16, units=pyunits.K)

    return m
예제 #20
0
    def build(self):
        """
        Callable method for Block construction
        """
        super(SolidPhaseThermoStateBlockData, self).build()

        # Object reference for molecular weight if needed by CV1D
        # Molecular weights
        add_object_reference(self, "mw_comp", self.config.parameters.mw_comp)

        self._make_state_vars()
예제 #21
0
    def build(self):
        """
        General build method for StateBlockDatas.

        Args:
            None

        Returns:
            None
        """
        super(StateBlockData, self).build()
        add_object_reference(self, "_params", self.config.parameters)
예제 #22
0
def frame():
    m = ConcreteModel()

    # Create a dummy parameter block
    m.params = Block()

    m.params.config = ConfigBlock(implicit=True)
    m.params.config.parameter_data = {
        "cp_mol_ig_comp_coeff": {
            'A': 30.09200,  # parameters for water
            'B': 6.832514,
            'C': 6.793435,
            'D': -2.534480,
            'E': 0.082139,
            'F': -250.8810,
            'G': 223.3967,
            'H': -241.8264
        },
        "pressure_sat_comp_coeff": {
            'A': 3.55959,  # units bar, K
            'B': 643.748,
            'C': -198.043
        }
    }
    m.params.config.include_enthalpy_of_formation = True

    m.meta_object = PropertyClassMetadata()
    m.meta_object.default_units["temperature"] = pyunits.K
    m.meta_object.default_units["mass"] = pyunits.kg
    m.meta_object.default_units["length"] = pyunits.m
    m.meta_object.default_units["time"] = pyunits.s
    m.meta_object.default_units["amount"] = pyunits.mol

    def get_metadata(self):
        return m.meta_object

    m.get_metadata = types.MethodType(get_metadata, m)
    m.params.get_metadata = types.MethodType(get_metadata, m.params)

    # Add necessary parameters to parameter block
    m.params.temperature_ref = Var(initialize=298.15, units=pyunits.K)
    m.params.pressure_ref = Var(initialize=1e5, units=pyunits.Pa)

    # Create a dummy state block
    m.props = Block([1])
    add_object_reference(m.props[1], "params", m.params)

    m.props[1].temperature = Var(initialize=500, units=pyunits.K)
    m.props[1].pressure = Var(initialize=101325, units=pyunits.Pa)

    return m
예제 #23
0
    def set_geometry(self):
        """
        Define the geometry of the unit as necessary, and link to control
        volume

        Args:
            None

        Returns:
            None
        """
        # For this case, just create a reference to control volume
        if self.config.has_holdup is True:
            add_object_reference(self, "volume", self.control_volume.volume)
예제 #24
0
    def model(self):
        m = ConcreteModel()

        m.frame = ZeroOrderCosting()

        # Dummy a unit model to use with _get_tech_parameters
        m.dummy_unit = Block(concrete=True)
        m.dummy_unit.config = ConfigBlock()
        m.dummy_unit.config.declare("flowsheet_costing_block", ConfigValue())
        m.dummy_unit.config.flowsheet_costing_block = m.frame
        add_object_reference(m.dummy_unit, "unit_model", m.dummy_unit)
        m.dummy_unit._tech_type = "test_tech"

        return m
예제 #25
0
    def build(self):
        """
        General build method for PropertyBlockDatas. Inheriting models should
        call super().build.

        Args:
            None

        Returns:
            None
        """
        super(ReactionBlockDataBase, self).build()
        add_object_reference(self, "_params", self.config.parameters)

        self._validate_state_block()
예제 #26
0
    def build(self):
        """
        General build method for StateBlockDatas.

        Args:
            None

        Returns:
            None
        """
        super(StateBlockData, self).build()
        add_object_reference(self, "_params", self.config.parameters)

        # TODO: Deprecate this at some point
        # Backwards compatability check for old-style property packages
        self._params._validate_parameter_block()
예제 #27
0
 def build(self):
     """
     Building model
     Args:
         None
     Returns:
         None
     """
     # Call UnitModel.build to setup dynamics
     super(HeaterData, self).build()
     # Add Control Volume
     _make_heater_control_volume(self, "control_volume", self.config)
     # Add Ports
     self.add_inlet_port()
     self.add_outlet_port()
     # Add a convienient reference to heat duty.
     add_object_reference(self, "heat_duty", self.control_volume.heat)
예제 #28
0
    def test_mole_frac(self, caplog):
        m = ConcreteModel()

        caplog.set_level(idaeslog.WARNING,
                         logger=("idaes.generic_models.properties.core."))

        m.params = DummyParameterBlock(
            default={
                "components": {
                    "c1": {},
                    "c2": {},
                    "c3": {}
                },
                "phases": {
                    "p1": {
                        "equation_of_state": dummy_eos
                    }
                },
                "state_definition": modules[__name__],
                "pressure_ref": 1e5,
                "temperature_ref": 300,
                "base_units": {
                    "time": pyunits.s,
                    "length": pyunits.m,
                    "mass": pyunits.kg,
                    "amount": pyunits.mol,
                    "temperature": pyunits.K
                },
                "state_bounds": {
                    "mole_frac_comp": (None, None, None)
                }
            })

        # Create a dummy state block
        m.props = Block([1])
        m.props[1].config = ConfigBlock()
        m.props[1].config.declare("defined_state", ConfigValue(default=False))
        add_object_reference(m.props[1], "params", m.params)
        m.props[1].enth_mol_phase = {"p1": 1}

        define_state(m.props[1])

        assert ("props[1] - found state_bounds argument for mole_frac_comp."
                " Mole fraction bounds are set automatically and "
                "this argument will be ignored." in caplog.text)
예제 #29
0
    def build(self):
        """
        Begin building model (pre-DAE transformation).
        Args:
            None
        Returns:
            None
        """
        # Call UnitModel.build to setup dynamics
        super(StoichiometricReactorData, self).build()

        # Build Control Volume
        self.control_volume = ControlVolume0DBlock(
            default={
                "dynamic": self.config.dynamic,
                "property_package": self.config.property_package,
                "property_package_args": self.config.property_package_args,
                "reaction_package": self.config.reaction_package,
                "reaction_package_args": self.config.reaction_package_args
            })

        self.control_volume.add_state_blocks(has_phase_equilibrium=False)

        self.control_volume.add_reaction_blocks(has_equilibrium=False)

        self.control_volume.add_material_balances(
            balance_type=self.config.material_balance_type,
            has_rate_reactions=True)

        self.control_volume.add_energy_balances(
            balance_type=self.config.energy_balance_type,
            has_heat_transfer=self.config.has_heat_transfer,
            has_heat_of_reaction=self.config.has_heat_of_reaction)

        self.control_volume.add_momentum_balances(
            balance_type=self.config.momentum_balance_type,
            has_pressure_change=self.config.has_pressure_change)

        # Add Ports
        self.add_inlet_port()
        self.add_outlet_port()

        # Add performance equations
        add_object_reference(self, "rate_reaction_idx_ref",
                             self.config.reaction_package.rate_reaction_idx)
        add_object_reference(self, "rate_reaction_extent",
                             self.control_volume.rate_reaction_extent)

        # Set references to balance terms at unit level
        if (self.config.has_heat_transfer is True
                and self.config.energy_balance_type != 'none'):
            add_object_reference(self, "heat_duty", self.control_volume.heat)
        if (self.config.has_pressure_change is True
                and self.config.momentum_balance_type != 'none'):
            add_object_reference(self, "deltaP", self.control_volume.deltaP)
예제 #30
0
    def frame(self):
        m = ConcreteModel()

        # Create a dummy parameter block
        m.params = Block()

        # Add necessary parameters to parameter block
        m.params.config = ConfigBlock()
        m.params.config.declare("dummy_option", ConfigValue(default=None))

        # Create a dummy state block
        m.props = Block([1])
        m.props[1].config = ConfigBlock()
        add_object_reference(m.props[1], "_params", m.params)

        m.props[1].dummy_response = "foo"

        return m