ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/custom/custom_pressure_changer.py

@@ -0,0 +1,34 @@
+from idaes.models.unit_models.pressure_changer import PressureChangerData
+from .inverted import add_inverted, initialise_inverted
+from idaes.core import declare_process_block_class
+
+@declare_process_block_class("CustomPressureChanger")
+class CustomPressureChangerData(PressureChangerData):
+    """
+    Custom Pressure Changer model that includes inverted deltaP property.
+    """
+
+    def build(self, *args, **kwargs):
+        """
+        Build method for the CustomPressureChangerData class.
+        This method initializes the control volume and sets up the model.
+        """
+        super().build(*args, **kwargs)
+
+        # add deltaP_inverted as a property
+        add_inverted(self, "deltaP")
+
+    def initialize_build(
+        self,*args,**kwargs,
+    ):
+        """
+        Initialization method for the CustomPressureChangerData class.
+
+        Args:
+            state_args (dict): Arguments to be passed to the state block
+            solver (str): Solver to use for initialization
+            optarg (dict): Solver arguments dictionary
+        """
+        initialise_inverted(self, "deltaP")
+
+        super().initialize_build(*args, **kwargs)

ahuora_builder/custom/custom_pump.py

@@ -0,0 +1,107 @@
+# Import Pyomo libraries
+from pyomo.environ import (
+    Var,
+    Suffix,
+    units as pyunits,
+)
+from pyomo.common.config import ConfigBlock, ConfigValue, In
+from idaes.core.util.tables import create_stream_table_dataframe
+from idaes.core.util.exceptions import ConfigurationError
+# Import IDAES cores
+from idaes.core import (
+    declare_process_block_class,
+    UnitModelBlockData,
+    useDefault,
+)
+from idaes.core.util.config import is_physical_parameter_block
+import idaes.core.util.scaling as iscale
+import idaes.logger as idaeslog
+
+from ..custom.updated_pressure_changer import (
+
+    PumpData,
+)
+
+
+
+
+# When using this file the name "CustomCompressor" is what is imported
+@declare_process_block_class("CustomPump")
+class CustomPumpData(PumpData):
+    """
+    Zero order Load model
+    """
+
+    # CONFIG are options for the unit model, this simple model only has the mandatory config options
+    CONFIG = PumpData.CONFIG()
+
+    CONFIG.declare(
+        "power_property_package",
+        ConfigValue(
+            default=useDefault,
+            domain=is_physical_parameter_block,
+            description="Property package to use for power",
+            doc="""Power Property parameter object used to define power calculations,
+    **default** - useDefault.
+    **Valid values:** {
+    **useDefault** - use default package from parent model or flowsheet,
+    **PhysicalParameterObject** - a PhysicalParameterBlock object.}""",
+        ),
+    )
+    CONFIG.declare(
+        "power_property_package_args",
+        ConfigBlock(
+            implicit=True,
+            description="Arguments to use for constructing power property packages",
+            doc="""A ConfigBlock with arguments to be passed to a property block(s)
+    and used when constructing these,
+    **default** - None. 
+    **Valid values:** {
+    see property package for documentation.}""",
+        ),
+    )
+
+    def build(self):
+        # build always starts by calling super().build()
+        # This triggers a lot of boilerplate in the background for you
+        super().build()
+
+        # This creates blank scaling factors, which are populated later
+        self.scaling_factor = Suffix(direction=Suffix.EXPORT)
+
+
+        # Add state blocks for inlet, outlet, and waste
+        # These include the state variables and any other properties on demand
+ 
+        tmp_dict = dict(**self.config.property_package_args)
+        tmp_dict["parameters"] = self.config.property_package
+        tmp_dict["defined_state"] = True  # inlet block is an inlet
+       # Add inlet block
+        # self.properties_in = self.config.property_package.state_block_class(
+        #     self.flowsheet().config.time, doc="Material properties of inlet", **tmp_dict
+        # )
+
+
+        # Add outlet and waste block
+        tmp_dict["defined_state"] = False  # outlet and waste block is not an inlet
+        self.power_properties_out = self.config.power_property_package.state_block_class(
+            self.flowsheet().config.time,
+            doc="Material properties of outlet",
+            **tmp_dict
+        )
+
+        # Add ports - oftentimes users interact with these rather than the state blocks
+        self.add_port(name="power_outlet", block=self.power_properties_out)
+
+        # Add constraints
+        # Usually unit models use a control volume to do the mass, energy, and momentum
+        # balances, however, they will be explicitly written out in this example
+        @self.Constraint(
+            self.flowsheet().time,
+            doc="Power out",
+        )
+        def eq_power_out(b, t):
+            return (
+                self.power_properties_out[t].power == self.work_mechanical[t] * -1
+            )
+    

ahuora_builder/custom/custom_separator.py

@@ -0,0 +1,371 @@
+from idaes.models.unit_models.separator import SeparatorData, SplittingType
+
+from functools import partial
+from pandas import DataFrame
+
+from pyomo.environ import (
+    Block,
+    check_optimal_termination,
+    Constraint,
+    Param,
+    Reals,
+    Reference,
+    Set,
+    Var,
+    value,
+)
+from pyomo.network import Port
+from pyomo.common.config import ConfigBlock, ConfigValue, In, ListOf, Bool
+
+from idaes.core import (
+    declare_process_block_class,
+    UnitModelBlockData,
+    useDefault,
+    MaterialBalanceType,
+    MomentumBalanceType,
+    MaterialFlowBasis,
+    VarLikeExpression,
+)
+from idaes.core.util.config import (
+    is_physical_parameter_block,
+    is_state_block,
+)
+from idaes.core.util.exceptions import (
+    BurntToast,
+    ConfigurationError,
+    PropertyNotSupportedError,
+    InitializationError,
+)
+from idaes.core.solvers import get_solver
+from idaes.core.util.tables import create_stream_table_dataframe
+from idaes.core.util.model_statistics import degrees_of_freedom
+import idaes.logger as idaeslog
+import idaes.core.util.scaling as iscale
+from idaes.core.util.units_of_measurement import report_quantity
+from idaes.core.initialization import ModularInitializerBase
+
+
+# This only changes a couple of lines in the original SeparatorData class, to not fix state variables by default.
+# The state block initialisation already does this if needed, so we can just set their value.
+# This is because if the state block has extra constraints, such as for flow_mass, then fixing flow_mol will over-define the system.
+# It might be worth making this a pr to idaes.
+
+@declare_process_block_class("CustomSeparator")
+class CustomSeparatorData(SeparatorData):
+
+    def initialize_build(
+        blk, outlvl=idaeslog.NOTSET, optarg=None, solver=None, hold_state=False
+    ):
+        """
+        Initialization routine for separator
+
+        Keyword Arguments:
+            outlvl : sets output level of initialization routine
+            optarg : solver options dictionary object (default=None, use
+                     default solver options)
+            solver : str indicating which solver to use during
+                     initialization (default = None, use default solver)
+            hold_state : flag indicating whether the initialization routine
+                     should unfix any state variables fixed during
+                     initialization, **default** - False. **Valid values:**
+                     **True** - states variables are not unfixed, and a dict of
+                     returned containing flags for which states were fixed
+                     during initialization, **False** - state variables are
+                     unfixed after initialization by calling the release_state
+                     method.
+
+        Returns:
+            If hold_states is True, returns a dict containing flags for which
+            states were fixed during initialization.
+        """
+        init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit")
+        solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit")
+
+        # Create solver
+        opt = get_solver(solver, optarg)
+
+        # Initialize mixed state block
+        if blk.config.mixed_state_block is not None:
+            mblock = blk.config.mixed_state_block
+        else:
+            mblock = blk.mixed_state
+        flags = mblock.initialize(
+            outlvl=outlvl,
+            optarg=optarg,
+            solver=solver,
+            hold_state=True,
+        )
+
+        # Solve for split fractions only
+        component_status = {}
+        for c in blk.component_objects((Block, Constraint)):
+            for i in c:
+                if not c[i].local_name == "sum_split_frac":
+                    # Record current status of components to restore later
+                    component_status[c[i]] = c[i].active
+                    c[i].deactivate()
+
+        if degrees_of_freedom(blk) != 0:
+            with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
+                res = opt.solve(blk, tee=slc.tee)
+                init_log.info(
+                    "Initialization Step 1 Complete: {}".format(idaeslog.condition(res))
+                )
+
+        for c, s in component_status.items():
+            if s:
+                c.activate()
+
+        if blk.config.ideal_separation:
+            # If using ideal splitting, initialization should be complete
+            return flags
+
+        # Initialize outlet StateBlocks
+        outlet_list = blk.create_outlet_list()
+
+        # Premises for initializing outlet states:
+        # 1. Intensive states remain unchanged - this is either a valid premise
+        # or the actual state is impossible to calculate without solving the
+        # full separator model.
+        # 2. Extensive states are use split fractions if index matches, or
+        # average of split fractions for outlet otherwise
+        for o in outlet_list:
+            # Get corresponding outlet StateBlock
+            o_block = getattr(blk, o + "_state")
+
+            # Create dict to store fixed status of state variables
+            o_flags = {}
+            for t in blk.flowsheet().time:
+
+                # Calculate values for state variables
+                s_vars = o_block[t].define_state_vars()
+                for v in s_vars:
+                    for k in s_vars[v]:
+                        # Record whether variable was fixed or not
+                        o_flags[t, v, k] = s_vars[v][k].fixed
+
+                        # If fixed, use current value
+                        # otherwise calculate guess from mixed state and fix
+                        if not s_vars[v][k].fixed:
+                            m_var = getattr(mblock[t], s_vars[v].local_name)
+                            if "flow" in v:
+                                # If a "flow" variable, is extensive
+                                # Apply split fraction
+                                if blk.config.split_basis == SplittingType.totalFlow:
+                                    # All flows split by outlet
+                                    s_vars[v][k].set_value(
+                                        value(m_var[k] * blk.split_fraction[(t, o)])
+                                    )
+                                elif "_phase_comp" in v:
+                                    # Need to match indices, but use split frac
+                                    if (
+                                        blk.config.split_basis
+                                        == SplittingType.phaseComponentFlow
+                                    ):
+                                        s_vars[v][k].set_value(
+                                            value(
+                                                m_var[k]
+                                                * blk.split_fraction[(t, o) + (k,)]
+                                            )
+                                        )
+                                    elif (
+                                        blk.config.split_basis
+                                        == SplittingType.phaseFlow
+                                    ):
+                                        s_vars[v][k].set_value(
+                                            value(
+                                                m_var[k]
+                                                * blk.split_fraction[(t, o) + (k[0],)]
+                                            )
+                                        )
+                                    elif (
+                                        blk.config.split_basis
+                                        == SplittingType.componentFlow
+                                    ):
+                                        s_vars[v][k].set_value(
+                                            value(
+                                                m_var[k]
+                                                * blk.split_fraction[(t, o) + (k[1],)]
+                                            )
+                                        )
+                                    else:
+                                        raise BurntToast(
+                                            "{} encountered unrecognised "
+                                            "SplittingType. This should not "
+                                            "occur - please send this bug to "
+                                            "the IDAES developers.".format(blk.name)
+                                        )
+                                elif "_phase" in v:
+                                    if (
+                                        blk.config.split_basis
+                                        == SplittingType.phaseComponentFlow
+                                    ):
+                                        # Need average split fraction
+                                        avg_split = value(
+                                            sum(
+                                                blk.split_fraction[t, o, k, j]
+                                                for j in mblock.component_list
+                                            )
+                                            / len(mblock.component_list)
+                                        )
+                                        s_vars[v][k].set_value(value(m_var[k] * avg_split))
+                                    elif (
+                                        blk.config.split_basis
+                                        == SplittingType.phaseFlow
+                                    ):
+                                        s_vars[v][k].set_value(
+                                            value(
+                                                m_var[k]
+                                                * blk.split_fraction[(t, o) + (k,)]
+                                            )
+                                        )
+                                    elif (
+                                        blk.config.split_basis
+                                        == SplittingType.componentFlow
+                                    ):
+                                        # Need average split fraction
+                                        avg_split = value(
+                                            sum(
+                                                blk.split_fraction[t, o, j]
+                                                for j in mblock.component_list
+                                            )
+                                            / len(mblock.component_list)
+                                        )
+                                        s_vars[v][k].set_value(value(m_var[k] * avg_split))
+                                    else:
+                                        raise BurntToast(
+                                            "{} encountered unrecognised "
+                                            "SplittingType. This should not "
+                                            "occur - please send this bug to "
+                                            "the IDAES developers.".format(blk.name)
+                                        )
+                                elif "_comp" in v:
+                                    if (
+                                        blk.config.split_basis
+                                        == SplittingType.phaseComponentFlow
+                                    ):
+                                        # Need average split fraction
+                                        avg_split = value(
+                                            sum(
+                                                blk.split_fraction[t, o, p, k]
+                                                for p in mblock.phase_list
+                                            )
+                                            / len(mblock.phase_list)
+                                        )
+                                        s_vars[v][k].set_value(value(m_var[k] * avg_split))
+                                    elif (
+                                        blk.config.split_basis
+                                        == SplittingType.phaseFlow
+                                    ):
+                                        # Need average split fraction
+                                        avg_split = value(
+                                            sum(
+                                                blk.split_fraction[t, o, p]
+                                                for p in mblock.phase_list
+                                            )
+                                            / len(mblock.phase_list)
+                                        )
+                                        s_vars[v][k].set_value(value(m_var[k] * avg_split))
+                                    elif (
+                                        blk.config.split_basis
+                                        == SplittingType.componentFlow
+                                    ):
+                                        s_vars[v][k].set_value(
+                                            value(
+                                                m_var[k]
+                                                * blk.split_fraction[(t, o) + (k,)]
+                                            )
+                                        )
+                                    else:
+                                        raise BurntToast(
+                                            "{} encountered unrecognised "
+                                            "SplittingType. This should not "
+                                            "occur - please send this bug to "
+                                            "the IDAES developers.".format(blk.name)
+                                        )
+                                else:
+                                    # Assume unindexed extensive state
+                                    # Need average split
+                                    if (
+                                        blk.config.split_basis
+                                        == SplittingType.phaseComponentFlow
+                                    ):
+                                        # Need average split fraction
+                                        avg_split = value(
+                                            sum(
+                                                blk.split_fraction[t, o, p, j]
+                                                for (p, j) in mblock.phase_component_set
+                                            )
+                                            / len(mblock.phase_component_set)
+                                        )
+                                    elif (
+                                        blk.config.split_basis
+                                        == SplittingType.phaseFlow
+                                    ):
+                                        # Need average split fraction
+                                        avg_split = value(
+                                            sum(
+                                                blk.split_fraction[t, o, p]
+                                                for p in mblock.phase_list
+                                            )
+                                            / len(mblock.phase_list)
+                                        )
+                                    elif (
+                                        blk.config.split_basis
+                                        == SplittingType.componentFlow
+                                    ):
+                                        # Need average split fraction
+                                        avg_split = value(
+                                            sum(
+                                                blk.split_fraction[t, o, j]
+                                                for j in mblock.component_list
+                                            )
+                                            / len(mblock.component_list)
+                                        )
+                                    else:
+                                        raise BurntToast(
+                                            "{} encountered unrecognised "
+                                            "SplittingType. This should not "
+                                            "occur - please send this bug to "
+                                            "the IDAES developers.".format(blk.name)
+                                        )
+                                    s_vars[v][k].set_value(value(m_var[k] * avg_split))
+                            else:
+                                # Otherwise intensive, equate to mixed stream
+                                s_vars[v][k].set_value(m_var[k].value)
+
+            # Call initialization routine for outlet StateBlock
+            o_block.initialize(
+                outlvl=outlvl,
+                optarg=optarg,
+                solver=solver,
+                hold_state=False,
+            )
+
+            # Revert fixed status of variables to what they were before
+            for t in blk.flowsheet().time:
+                s_vars = o_block[t].define_state_vars()
+                for v in s_vars:
+                    for k in s_vars[v]:
+                        s_vars[v][k].fixed = o_flags[t, v, k]
+
+        if blk.config.mixed_state_block is None:
+            with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
+                res = opt.solve(blk, tee=slc.tee)
+
+            if not check_optimal_termination(res):
+                raise InitializationError(
+                    f"{blk.name} failed to initialize successfully. Please "
+                    f"check the output logs for more information."
+                )
+
+            init_log.info(
+                "Initialization Step 2 Complete: {}".format(idaeslog.condition(res))
+            )
+        else:
+            init_log.info("Initialization Complete.")
+
+        if hold_state is True:
+            return flags
+        else:
+            blk.release_state(flags, outlvl=outlvl)

ahuora_builder/custom/custom_tank.py

@@ -0,0 +1,133 @@
+from idaes.core import declare_process_block_class, MaterialBalanceType
+from .water_tank_with_units import WaterTankData
+from .add_initial_dynamics import add_initial_dynamics
+from pyomo.environ import Reference, Var
+from pyomo.dae import DerivativeVar
+from pyomo.environ import units as pyunit
+from .inverted import add_inverted, initialise_inverted
+
+
+def CustomTank(*args, **kwargs):
+    # In dynamics mode, we need to use the default material balance type of componentPhase.
+    # This does balances for liquid and vapor phases separately. This is needed becasue 
+    # accumulation terms are phase specific.
+    # However, in steady-state, this is not necessary, because we don't have accumulation terms.
+    # So this would make the system over-defined, as the state block defines the phase equilibrium already.
+    is_dynamic = kwargs.get("dynamic")
+    if is_dynamic:
+        kwargs["material_balance_type"] = MaterialBalanceType.componentPhase
+    else:
+        kwargs["material_balance_type"] = MaterialBalanceType.componentTotal
+    
+    return DynamicTank(*args, **kwargs)
+        
+
+@declare_process_block_class("DynamicTank")
+class DynamicTankData(WaterTankData):
+    """
+    Water tank model with dynamic capabilities.
+    Some extra properties are added to IDAES's tank model to allow for easier specification of initial conditions.
+    """
+
+    def build(self, *args, **kwargs):
+        """
+        Build method for the DynamicHeaterData class.
+        This method initializes the control volume and sets up the model.
+        """
+
+        super().build(*args, **kwargs)
+
+        self.flow_rate_out = Reference(self.outlet.flow_mol)
+
+        # add deltaP_inverted as a property
+        add_inverted(self,"heat_duty")
+
+        # Because it's hard to specify the initial conditions directly,
+        # Create a state block for the initial conditions.
+
+        if not self.config.dynamic:
+            return # There is no need to add these extra properties.        
+
+        self.initial_block = self.config.property_package.build_state_block(
+            [0],
+            defined_state=True,
+        )
+
+        if len(self.config.property_package.component_list) > 1:
+
+            # We are assuming that the composition does not change at the initial time step. In theory it could, but
+            # we can worry about that later.
+            @self.Constraint(
+                self.config.property_package.component_list,
+                doc="Initial composition constraint",
+            )
+            def initial_composition_constraint(b, j):
+                return (
+                    b.initial_block[0].mole_frac_comp[j]
+                    == b.control_volume.properties_in[0].mole_frac_comp[j]
+                )
+
+        # The initial temperature, pressure, and flow amount is set by the user.
+        self.initial_pressure = Var(initialize=101325, units=pyunit.Pa)
+        @self.Constraint(doc="Initial pressure constraint")
+        def initial_pressure_constraint(b):
+            return b.initial_block[0].pressure == b.initial_pressure
+
+        self.initial_holdup = Var(initialize=300, units=pyunit.mol)
+        @self.Constraint(doc="Initial flow constraint")
+        def initial_holdup_mol_constraint(b):
+            return (
+                b.initial_block[0].flow_mol * pyunit.s == b.initial_holdup
+            )  # cancel out the seconds as we are using it for holdup not accumulation.
+        
+
+        self.initial_level = Var(initialize=300, units=pyunit.m)
+        @self.Constraint(doc="Initial level constraint")
+        def initial_level_constraint(b):
+            return b.initial_holdup == b.tank_cross_sect_area * b.initial_level * b.initial_block[0].dens_mol
+
+        self.initial_temperature = Var(initialize=300, units=pyunit.K)
+        @self.Constraint(doc="Initial temperature constraint")
+        def initial_temperature_constraint(b):
+            return b.initial_block[0].temperature == b.initial_temperature
+
+        # The temperature, pressure and flow are used to calculate the other properties.
+        @self.Constraint(
+            self.config.property_package.phase_list,
+            self.config.property_package.component_list,
+            doc="Defining accumulation",
+        )
+        def initial_material_conditions_constraint(b, p, j):
+            return (
+                b.initial_block[0].flow_mol
+                * b.initial_block[0].mole_frac_phase_comp[p, j]
+                + b.control_volume.material_accumulation[0, p, j]
+                == b.control_volume.material_holdup[0, p, j]
+            )
+
+        @self.Constraint(
+            self.config.property_package.phase_list, doc="Defining accumulation"
+        )
+        def initial_energy_conditions_constraint(b, p):
+            return (
+                b.initial_block[0].flow_mol
+                * b.initial_block[0].phase_frac[p]
+                * b.initial_block[0].enth_mol_phase[p]
+                + b.control_volume.energy_accumulation[0, p]
+                == b.control_volume.energy_holdup[0, p]
+            )
+        
+        
+
+    def initialize(self, *args, **kwargs):
+        """
+        Initialization method for the DynamicTankData class.
+        This method initializes the control volume and sets up the model.
+        """
+        # Copy initial conditions from inverted properties
+        initialise_inverted(self,"heat_duty")
+
+        if self.config.dynamic:
+            self.initial_block.initialize()
+        
+        super().initialize(*args, **kwargs)