ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/custom/add_initial_dynamics.py

@@ -0,0 +1,35 @@
+from pyomo.environ import Reference, Var, units
+from pyomo.dae import DerivativeVar
+
+
+def add_initial_dynamics(unit_model):
+    """
+    Adds the reference variables for initial holdup and initial accumulation. 
+    Makes it easier for us to set initial conditions in the frontend, as we can reference them directly.
+    """
+    if unit_model.config.dynamic:
+            # add initial holdup reference
+            unit_model.initial_material_holdup = Reference(unit_model.control_volume.material_holdup[0,:,:])
+            unit_model.initial_energy_holdup = Reference(unit_model.control_volume.energy_holdup[0,:])
+
+            # For some reason we can't do references to the initialaccumulation variables,
+            # Error ( Can only take the derivative of a Varcomponent.)
+            #  so we create them as vars
+            unit_model.initial_material_accumulation = Var(unit_model.config.property_package.phase_list, unit_model.config.property_package.component_list, initialize=0,units=units.mol/units.s)
+            unit_model.initial_energy_accumulation = Var(unit_model.config.property_package.phase_list, initialize=0,units=units.kW)
+
+
+            @unit_model.Constraint(
+                unit_model.config.property_package.phase_list,
+                unit_model.config.property_package.component_list,
+                doc="Initial material accumulation constraint"
+            )
+            def initial_material_accumulation_constraint(b, p, j):
+                return b.initial_material_accumulation[p, j] == b.control_volume.material_accumulation[0, p, j]
+            
+            @unit_model.Constraint(
+                unit_model.config.property_package.phase_list,
+                doc="Initial energy accumulation constraint"
+            )
+            def initial_energy_accumulation_constraint(b, p):
+                return b.initial_energy_accumulation[p] == b.control_volume.energy_accumulation[0, p]

ahuora_builder/custom/custom_compressor.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 (
+
+    CompressorData,
+)
+
+
+
+
+# When using this file the name "CustomCompressor" is what is imported
+@declare_process_block_class("CustomCompressor")
+class CustomCompressorData(CompressorData):
+    """
+    Zero order Load model
+    """
+
+    # CONFIG are options for the unit model, this simple model only has the mandatory config options
+    CONFIG = CompressorData.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_cooler.py

@@ -0,0 +1,33 @@
+from idaes.models.unit_models.heater import HeaterData
+from .inverted import add_inverted, initialise_inverted, enable_inverted, disable_inverted
+from idaes.core import declare_process_block_class
+
+@declare_process_block_class("CustomCooler")
+class CustomCoolerData(HeaterData):
+    """
+    Custom Cooler model that includes inverted deltaP and Heat Added properties.
+    """
+
+    def build(self, *args, **kwargs):
+        super().build(*args, **kwargs)
+
+        # add deltaP_inverted as a property
+        add_inverted(self, "heat_duty")
+        if hasattr(self,"deltaP"):
+            add_inverted(self, "deltaP")
+
+    def initialize_build(
+        self,*args,**kwargs,
+    ):
+        initialise_inverted(self, "heat_duty")
+        disable_inverted(self, "heat_duty")
+
+        if hasattr(self,"deltaP"):
+            initialise_inverted(self, "deltaP")
+            disable_inverted(self, "deltaP")
+
+        super().initialize_build(*args, **kwargs)
+
+        enable_inverted(self, "heat_duty")
+        if hasattr(self,"deltaP"):
+            enable_inverted(self, "deltaP")

ahuora_builder/custom/custom_heat_exchanger.py

@@ -0,0 +1,183 @@
+
+
+# Import Pyomo libraries
+from pyomo.environ import (
+    Block,
+    Var,
+    Param,
+    log,
+    Reference,
+    PositiveReals,
+    ExternalFunction,
+    units as pyunits,
+    check_optimal_termination,
+)
+from pyomo.common.config import ConfigBlock, ConfigValue, In
+
+# Import IDAES cores
+from idaes.core import (
+    declare_process_block_class,
+    UnitModelBlockData,
+)
+
+import idaes.logger as idaeslog
+from idaes.core.util.functions import functions_lib
+from idaes.core.util.tables import create_stream_table_dataframe
+from idaes.models.unit_models.heater import (
+    _make_heater_config_block,
+    _make_heater_control_volume,
+)
+
+from idaes.core.util.misc import add_object_reference
+from idaes.core.util import scaling as iscale
+from idaes.core.solvers import get_solver
+from idaes.core.util.exceptions import ConfigurationError, InitializationError
+from idaes.core.initialization import SingleControlVolumeUnitInitializer
+from idaes.models.unit_models.heat_exchanger import HX0DInitializer, _make_heat_exchanger_config, HeatExchangerData
+from .inverted import add_inverted, initialise_inverted
+_log = idaeslog.getLogger(__name__)
+
+
+@declare_process_block_class("CustomHeatExchanger", doc="Simple 0D heat exchanger model.")
+class CustomHeatExchangerData(HeatExchangerData):
+
+    def build(self,*args,**kwargs) -> None:
+        """
+        Begin building model.
+        """
+        super().build(*args,**kwargs)
+        # Add an inverted DeltaP
+        add_inverted(self.hot_side, "deltaP")
+        add_inverted(self.cold_side, "deltaP")
+
+    def initialize_build(
+        self,
+        state_args_1=None,
+        state_args_2=None,
+        outlvl=idaeslog.NOTSET,
+        solver=None,
+        optarg=None,
+        duty=None,
+    ):
+        """
+        Heat exchanger initialization method.
+
+        Args:
+            state_args_1 : a dict of arguments to be passed to the property
+                initialization for the hot side (see documentation of the specific
+                property package) (default = {}).
+            state_args_2 : a dict of arguments to be passed to the property
+                initialization for the cold side (see documentation of the specific
+                property package) (default = {}).
+            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)
+            duty : an initial guess for the amount of heat transferred. This
+                should be a tuple in the form (value, units), (default
+                = (1000 J/s))
+
+        Returns:
+            None
+
+        """
+        # So, when solving with a correct area, there can be problems
+        # That's because if the area's even slightly too large, it becomes infeasible
+        if not self.area.fixed:
+            self.area.value = self.area.value * 0.8
+
+        initialise_inverted(self.hot_side, "deltaP")
+        initialise_inverted(self.cold_side, "deltaP")
+
+        # Set solver options
+        init_log = idaeslog.getInitLogger(self.name, outlvl, tag="unit")
+        solve_log = idaeslog.getSolveLogger(self.name, outlvl, tag="unit")
+
+        # Create solver
+        opt = get_solver(solver, optarg)
+
+        flags1 = self.hot_side.initialize(
+            outlvl=outlvl, optarg=optarg, solver=solver, state_args=state_args_1
+        )
+
+        init_log.info_high("Initialization Step 1a (hot side) Complete.")
+
+        flags2 = self.cold_side.initialize(
+            outlvl=outlvl, optarg=optarg, solver=solver, state_args=state_args_2
+        )
+        init_log.info_high("Initialization Step 1b (cold side) Complete.")
+        # ---------------------------------------------------------------------
+        # Solve unit without heat transfer equation
+        self.heat_transfer_equation.deactivate()
+        if hasattr( self.cold_side.properties_out[0], "constraints"):
+            self.cold_side.properties_out[0].constraints.deactivate()
+        if hasattr( self.hot_side.properties_out[0], "constraints"):
+            self.hot_side.properties_out[0].constraints.deactivate()
+
+        # Get side 1 and side 2 heat units, and convert duty as needed
+        s1_units = self.hot_side.heat.get_units()
+        s2_units = self.cold_side.heat.get_units()
+
+        # Check to see if heat duty is fixed
+        # WE will assume that if the first point is fixed, it is fixed at all points
+        if not self.cold_side.heat[self.flowsheet().time.first()].fixed:
+            cs_fixed = False
+            if duty is None:
+                # Assume 1000 J/s and check for unitless properties
+                if s1_units is None and s2_units is None:
+                    # Backwards compatibility for unitless properties
+                    s1_duty = -1000
+                    s2_duty = 1000
+                else:
+                    s1_duty = pyunits.convert_value(
+                        -1000, from_units=pyunits.W, to_units=s1_units
+                    )
+                    s2_duty = pyunits.convert_value(
+                        1000, from_units=pyunits.W, to_units=s2_units
+                    )
+            else:
+                # Duty provided with explicit units
+                s1_duty = -pyunits.convert_value(
+                    duty[0], from_units=duty[1], to_units=s1_units
+                )
+                s2_duty = pyunits.convert_value(
+                    duty[0], from_units=duty[1], to_units=s2_units
+                )
+
+            self.cold_side.heat.fix(s2_duty)
+            for i in self.hot_side.heat:
+                self.hot_side.heat[i].value = s1_duty
+        else:
+            cs_fixed = True
+            for i in self.hot_side.heat:
+                self.hot_side.heat[i].set_value(self.cold_side.heat[i])
+        with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
+            res = opt.solve(self, tee=slc.tee)
+        init_log.info_high("Initialization Step 2 {}.".format(idaeslog.condition(res)))
+        if not cs_fixed:
+            self.cold_side.heat.unfix()
+        if hasattr( self.cold_side.properties_out[0], "constraints"):
+            self.cold_side.properties_out[0].constraints.activate()
+        if hasattr( self.hot_side.properties_out[0], "constraints"):
+            self.hot_side.properties_out[0].constraints.activate()
+        self.heat_transfer_equation.activate()
+
+        # ---------------------------------------------------------------------
+        # Solve unit
+        with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
+            res = opt.solve(self, tee=slc.tee)
+        init_log.info_high("Initialization Step 3 {}.".format(idaeslog.condition(res)))
+        # ---------------------------------------------------------------------
+
+        # Release Inlet state
+        self.hot_side.release_state(flags1, outlvl=outlvl)
+        self.cold_side.release_state(flags2, outlvl=outlvl)
+
+        init_log.info("Initialization Completed, {}".format(idaeslog.condition(res)))
+
+        if not check_optimal_termination(res):
+            raise InitializationError(
+                f"{self.name} failed to initialize successfully. Please check "
+                f"the output logs for more information."
+            )

ahuora_builder/custom/custom_heat_exchanger_1d.py

@@ -0,0 +1,258 @@
+from pyomo.environ import Var, Constraint, Reference, units as pyunits
+from pyomo.common.numeric_types import value
+from pyomo.opt.results.solver import check_optimal_termination
+from idaes.core import declare_process_block_class
+from idaes.core.util import scaling as iscale
+from idaes.models.unit_models.heat_exchanger_1D import HeatExchanger1DData, HX1DInitializer
+from idaes.models.unit_models.heat_exchanger import HeatExchangerFlowPattern
+from idaes.core.solvers import get_solver
+from idaes.core.util.exceptions import InitializationError
+import idaes.logger as idaeslog
+
+class CustomHX1DInitializer(HX1DInitializer):
+    """
+    Use our custom control-volume initialize (no source port-member fixing).
+    """
+    def initialize_control_volume(self, cv, state_args=None):
+        return initialize(
+            cv,
+            state_args=state_args,
+            outlvl=self.get_output_level(),
+        )
+
+@declare_process_block_class(
+    "CustomHeatExchanger1D",
+    doc="1D Heat Exchanger with overall U tied to local heat_transfer_coefficient.",
+)
+class CustomHeatExchanger1DData(HeatExchanger1DData):
+    # Use our initializer so both sides use the custom CV initialize
+    default_initializer = CustomHX1DInitializer
+
+    CONFIG = HeatExchanger1DData.CONFIG()
+
+    def build(self):
+        super().build()
+        # Ends of the tube along the length axis (start and end positions)
+        x_first = self.hot_side.length_domain.first()
+        x_last = self.hot_side.length_domain.last()
+
+        # Hot side: inlet at start, outlet at end
+        x_hot_in, x_hot_out = x_first, x_last
+
+        # Cold side: depends on flow pattern
+        if self.config.flow_type == HeatExchangerFlowPattern.cocurrent:
+            x_cold_in, x_cold_out = x_first, x_last
+        else:
+            x_cold_in, x_cold_out = x_last, x_first
+
+        # Time-only inlet/outlet views of the boundary states (no extra vars/cons)
+        self.hot_side.properties_in = Reference(self.hot_side.properties[:, x_hot_in])
+        self.hot_side.properties_out = Reference(self.hot_side.properties[:, x_hot_out])
+        self.cold_side.properties_in = Reference(self.cold_side.properties[:, x_cold_in])
+        self.cold_side.properties_out = Reference(self.cold_side.properties[:, x_cold_out])
+
+        # Overall U
+        self.overall_heat_transfer_coefficient = Var(
+            self.flowsheet().time,
+            initialize=500.0,
+            bounds=(1.0, 1e5),
+            units=pyunits.W / pyunits.m**2 / pyunits.K,
+            doc="Overall (constant along length) heat transfer coefficient U.",
+        )
+
+        @self.Constraint(self.flowsheet().time, self.hot_side.length_domain)
+        def overall_heat_transfer_coefficient_def(b, t, x):
+            return b.overall_heat_transfer_coefficient[t] == b.heat_transfer_coefficient[t, x]
+
+        iscale.set_scaling_factor(self.overall_heat_transfer_coefficient, 1e-3)
+
+    def initialize_build(
+        self,
+        hot_side_state_args=None,
+        cold_side_state_args=None,
+        outlvl=idaeslog.NOTSET,
+        solver=None,
+        optarg=None,
+        duty=None,
+    ):
+        init_log = idaeslog.getInitLogger(self.name, outlvl, tag="unit")
+        solve_log = idaeslog.getSolveLogger(self.name, outlvl, tag="unit")
+        opt = get_solver(solver, optarg)
+
+        # Sync length values
+        if self.length.fixed:
+            self.cold_side.length.set_value(self.length)
+        elif self.cold_side.length.fixed:
+            self.length.set_value(self.cold_side.length)
+
+        # Initialize control volumes with length fixed
+        Lfix = self.hot_side.length.fixed
+        self.hot_side.length.fix()
+        flags_hot_side = initialize(
+            self.hot_side,
+            outlvl=outlvl,
+            optarg=optarg,
+            solver=solver,
+            state_args=hot_side_state_args,
+        )
+        if not Lfix:
+            self.hot_side.length.unfix()
+
+        Lfix = self.cold_side.length.fixed
+        self.cold_side.length.fix()
+        # Use our custom CV initialize here as well
+        flags_cold_side = initialize(
+            self.cold_side,
+            outlvl=outlvl,
+            optarg=optarg,
+            solver=solver,
+            state_args=cold_side_state_args,
+        )
+        if not Lfix:
+            self.cold_side.length.unfix()
+
+        init_log.info_high("Initialization Step 1 Complete.")
+
+        # Fixed-duty solve
+        hot_units = self.hot_side.config.property_package.get_metadata().get_derived_units
+        cold_units = self.cold_side.config.property_package.get_metadata().get_derived_units
+        t0 = self.flowsheet().time.first()
+
+        # Use inlet indices for each side
+        x_hot_in = self.hot_side.length_domain.first()
+        x_cold_in = self.cold_side.length_domain.first() if self.config.flow_type == HeatExchangerFlowPattern.cocurrent else self.cold_side.length_domain.last()
+
+        if duty is None:
+            duty = value(
+                0.25
+                * self.heat_transfer_coefficient[t0, x_hot_in]
+                * self.area
+                * (
+                    self.hot_side.properties[t0, x_hot_in].temperature
+                    - pyunits.convert(
+                        self.cold_side.properties[t0, x_cold_in].temperature,
+                        to_units=hot_units("temperature"),
+                    )
+                )
+            )
+        else:
+            duty = pyunits.convert_value(duty[0], from_units=duty[1], to_units=hot_units("power"))
+
+        duty_per_length = value(duty / self.length)
+
+        # Fix heat duties
+        for v in self.hot_side.heat.values():
+            v.fix(-duty_per_length)
+        for v in self.cold_side.heat.values():
+            v.fix(pyunits.convert_value(duty_per_length, to_units=cold_units("power")/cold_units("length"), from_units=hot_units("power")/hot_units("length")))
+
+        # Deactivate heat duty constraints and solve
+        self.heat_transfer_eq.deactivate()
+        self.heat_conservation.deactivate()
+        with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
+            res = opt.solve(self, tee=slc.tee)
+        init_log.info_high("Initialization Step 2 {}.".format(idaeslog.condition(res)))
+
+        # Unfix heat duties and re-activate constraints
+        for v in self.hot_side.heat.values():
+            v.unfix()
+        for v in self.cold_side.heat.values():
+            v.unfix()
+        self.heat_transfer_eq.activate()
+        self.heat_conservation.activate()
+        with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
+            res = opt.solve(self, tee=slc.tee)
+        init_log.info_high("Initialization Step 3 {}.".format(idaeslog.condition(res)))
+
+        release_state(self.hot_side, flags_hot_side)
+        release_state(self.cold_side, flags_cold_side)
+
+        if res is not None and not check_optimal_termination(res):
+            raise InitializationError(f"{self.name} failed to initialize successfully. See logs.")
+
+        init_log.info("Initialization Complete.")
+
+
+def initialize(
+        blk,
+        state_args=None,
+        outlvl=idaeslog.NOTSET,
+        optarg=None,
+        solver=None,
+        hold_state=True,
+    ):
+        """
+        Initialization routine for 1D control volume.
+
+        Keyword Arguments:
+            state_args: a dict of arguments to be passed to the property
+                package(s) to provide an initial state for initialization
+                (see documentation of the specific property package) (default = {}).
+            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)
+            hold_state: flag indicating whether the initialization routine
+                should unfix any state variables fixed during initialization,
+                (default = True). **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 else the release state is
+            triggered.
+        """
+        if optarg is None:
+            optarg = {}
+
+        # Get inlet state if not provided
+        init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="control_volume")
+
+        # Provide guesses if none
+        if state_args is None:
+            blk.estimate_states(always_estimate=True)
+
+
+        if state_args is None:
+            # If no initial guesses provided, estimate values for states
+            blk.estimate_states(always_estimate=True)
+
+        # Initialize state blocks
+        flags = blk.properties.initialize(
+            state_args=state_args,
+            outlvl=outlvl,
+            optarg=optarg,
+            solver=solver,
+            hold_state=True,
+        )
+
+        try:
+            # TODO: setting state_vars_fixed may not work for heterogeneous
+            # systems where a second control volume is involved, as we cannot
+            # assume those state vars are also fixed. For now, heterogeneous
+            # reactions should ignore the state_vars_fixed argument and always
+            # check their state_vars.
+            blk.reactions.initialize(
+                outlvl=outlvl,
+                optarg=optarg,
+                solver=solver,
+                state_vars_fixed=True,
+            )
+        except AttributeError:
+            pass
+
+        init_log.info("Initialization Complete")
+
+        # Unfix state variables except for source block
+        blk.properties.release_state(flags)
+
+        return {}
+
+def release_state(blk, flags, outlvl=idaeslog.NOTSET):
+    # No-op: nothing was fixed at the CV level in our custom initialize
+    return

ahuora_builder/custom/custom_heater.py

@@ -0,0 +1,41 @@
+from idaes.core import declare_process_block_class
+from idaes.models.unit_models.heater import HeaterData
+from .add_initial_dynamics import add_initial_dynamics
+from .inverted import add_inverted, initialise_inverted, disable_inverted, enable_inverted
+
+@declare_process_block_class("DynamicHeater")
+class DynamicHeaterData(HeaterData):
+    """
+    Dynamic Heater unit model class.
+    This extends the Heater class to include reference variables for initial holdup and initial accumulation. 
+    Which makes it easier for us to set initial conditions in the frontend.
+    """
+
+    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)
+
+        if hasattr(self,"deltaP"):
+            # else has_pressure_change is false
+            add_inverted(self, "deltaP")
+
+        add_initial_dynamics(self)
+    
+    def initialize_build(
+        self,*args,**kwargs,
+    ):
+        """
+        Initialize method for the DynamicHeaterData class.
+        This method initializes the control volume and sets up the model.
+        """
+        if hasattr(self,"deltaP"):
+            initialise_inverted(self, "deltaP")
+            disable_inverted(self, "deltaP")
+
+        super().initialize_build(*args, **kwargs)
+
+        if hasattr(self,"deltaP"):
+            enable_inverted(self, "deltaP")