ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/custom/hda_reaction.py

@@ -0,0 +1,182 @@
+#################################################################################
+# The Institute for the Design of Advanced Energy Systems Integrated Platform
+# Framework (IDAES IP) was produced under the DOE Institute for the
+# Design of Advanced Energy Systems (IDAES), and is copyright (c) 2018-2022
+# by the software owners: The Regents of the University of California, through
+# Lawrence Berkeley National Laboratory,  National Technology & Engineering
+# Solutions of Sandia, LLC, Carnegie Mellon University, West Virginia University
+# Research Corporation, et al.  All rights reserved.
+#
+# Please see the files COPYRIGHT.md and LICENSE.md for full copyright and
+# license information.
+#################################################################################
+"""
+Property package for the hydrodealkylation of toluene to form benzene
+"""
+
+# Import Python libraries
+import logging
+
+# Import Pyomo libraries
+from pyomo.environ import Constraint, exp, Set, Var, Param, units as pyunits
+
+# Import IDAES cores
+from idaes.core import (
+    declare_process_block_class,
+    MaterialFlowBasis,
+    ReactionParameterBlock,
+    ReactionBlockDataBase,
+    ReactionBlockBase,
+)
+from idaes.core.util.constants import Constants as const
+from idaes.core.util.misc import add_object_reference
+
+# Set up logger
+_log = logging.getLogger(__name__)
+
+
+@declare_process_block_class("HDAReactionParameterBlock")
+class HDAReactionParameterData(ReactionParameterBlock):
+    """
+    Property Parameter Block Class
+    Contains parameters and indexing sets associated with properties for
+    superheated steam.
+    """
+
+    def build(self):
+        """
+        Callable method for Block construction.
+        """
+        super(HDAReactionParameterData, self).build()
+
+        self._reaction_block_class = HDAReactionBlock
+
+        # List of valid phases in property package
+        self.phase_list = Set(initialize=["Vap"])
+
+        # Component list - a list of component identifiers
+        self.component_list = Set(
+            initialize=["benzene", "toluene", "hydrogen", "methane"]
+        )
+
+        # Reaction Index
+        self.rate_reaction_idx = Set(initialize=["R1"])
+
+        # Reaction Stoichiometry
+        self.rate_reaction_stoichiometry = {
+            ("R1", "Vap", "benzene"): 1,
+            ("R1", "Vap", "toluene"): -1,
+            ("R1", "Vap", "hydrogen"): -1,
+            ("R1", "Vap", "methane"): 1,
+            ("R1", "Liq", "benzene"): 0,
+            ("R1", "Liq", "toluene"): 0,
+            ("R1", "Liq", "hydrogen"): 0,
+            ("R1", "Liq", "methane"): 0,
+        }
+
+        # Arrhenius Constant
+        self.arrhenius = Var(
+            initialize=6.3e10,
+            units=pyunits.mol * pyunits.m**-3 * pyunits.s**-1 * pyunits.Pa**-1,
+            doc="Arrhenius pre-exponential factor",
+        )
+        self.arrhenius.fix()
+
+        # Activation Energy
+        self.energy_activation = Var(
+            initialize=217.6e3, units=pyunits.J / pyunits.mol, doc="Activation energy"
+        )
+        self.energy_activation.fix()
+
+        # Heat of Reaction
+        dh_rxn_dict = {"R1": -1.08e5}
+        self.dh_rxn = Param(
+            self.rate_reaction_idx,
+            initialize=dh_rxn_dict,
+            units=pyunits.J / pyunits.mol,
+            doc="Heat of reaction",
+        )
+
+    @classmethod
+    def define_metadata(cls, obj):
+        obj.add_properties(
+            {
+                "k_rxn": {"method": None, "units": "m^3/mol.s"},
+                "reaction_rate": {"method": None, "units": "mol/m^3.s"},
+            }
+        )
+        obj.add_default_units(
+            {
+                "time": pyunits.s,
+                "length": pyunits.m,
+                "mass": pyunits.kg,
+                "amount": pyunits.mol,
+                "temperature": pyunits.K,
+            }
+        )
+
+
+class ReactionBlock(ReactionBlockBase):
+    """
+    This Class contains methods which should be applied to Reaction Blocks as a
+    whole, rather than individual elements of indexed Reaction Blocks.
+    """
+
+    def initialize(blk, outlvl=0, **kwargs):
+        """
+        Initialization routine for reaction package.
+        Keyword Arguments:
+            outlvl : sets output level of initialization routine
+                     * 0 = no output (default)
+                     * 1 = report after each step
+        Returns:
+            None
+        """
+        if outlvl > 0:
+            _log.info("{} Initialization Complete.".format(blk.name))
+
+
+@declare_process_block_class("HDAReactionBlock", block_class=ReactionBlock)
+class HDAReactionBlockData(ReactionBlockDataBase):
+    """
+    An example reaction package for saponification of ethyl acetate
+    """
+
+    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)
+
+        self.k_rxn = Var(
+            initialize=0.2,
+            units=pyunits.mol * pyunits.m**-3 * pyunits.s**-1 * pyunits.Pa**-1,
+        )
+
+        self.reaction_rate = Var(
+            self.params.rate_reaction_idx,
+            initialize=1,
+            units=pyunits.mol / pyunits.m**3 / pyunits.s,
+        )
+
+        self.arrhenus_equation = Constraint(
+            expr=self.k_rxn
+            == self.params.arrhenius
+            * exp(
+                -self.params.energy_activation
+                / (const.gas_constant * self.state_ref.temperature)
+            )
+        )
+
+        self.rate_expression = Constraint(
+            expr=self.reaction_rate["R1"]
+            == self.k_rxn
+            * self.state_ref.pressure
+            * self.state_ref.mole_frac_phase_comp["Vap", "toluene"]
+        )
+
+    def get_reaction_rate_basis(b):
+        return MaterialFlowBasis.molar

ahuora_builder/custom/heat_exchanger_1d_wrapper.py

@@ -0,0 +1,31 @@
+from .custom_heat_exchanger_1d import CustomHeatExchanger1D
+from idaes.models.unit_models.heat_exchanger import HeatExchangerFlowPattern
+
+# Map frontend string values to IDAES enums
+FLOW_TYPE_MAP = {
+    "countercurrent": HeatExchangerFlowPattern.countercurrent,
+    "cocurrent": HeatExchangerFlowPattern.cocurrent,
+}
+
+def HeatExchanger1DWrapper(**kwargs):
+    """
+    Wrapper for CustomHeatExchanger1D that handles string-to-enum conversion
+    and provides default values for required parameters, defaulting to collocation.
+    """
+    # Convert flow_type string to enum
+    flow_type = kwargs.pop('flow_type', None)
+    if flow_type is None:
+        flow_type = "countercurrent"
+    
+    if isinstance(flow_type, str):
+        if flow_type.lower() in FLOW_TYPE_MAP:
+            flow_type_enum = FLOW_TYPE_MAP[flow_type.lower()]
+        else:
+            raise ValueError(f"Unknown flow_type: {flow_type}. Must be one of: {list(FLOW_TYPE_MAP.keys())}")
+    else:
+        flow_type_enum = flow_type
+    
+    kwargs['flow_type'] = flow_type_enum
+    
+    # Return the heat exchanger with fixed parameters
+    return CustomHeatExchanger1D(**kwargs)

ahuora_builder/custom/integration_block.py

@@ -0,0 +1,106 @@
+#################################################################################
+# The Institute for the Design of Advanced Energy Systems Integrated Platform
+# Framework (IDAES IP) was produced under the DOE Institute for the
+# Design of Advanced Energy Systems (IDAES).
+#
+# Copyright (c) 2018-2024 by the software owners: The Regents of the
+# University of California, through Lawrence Berkeley National Laboratory,
+# National Technology & Engineering Solutions of Sandia, LLC, Carnegie Mellon
+# University, West Virginia University Research Corporation, et al.
+# All rights reserved.  Please see the files COPYRIGHT.md and LICENSE.md
+# for full copyright and license information.
+#################################################################################
+"""
+Base class for unit models
+"""
+
+from pyomo.environ import check_optimal_termination
+from pyomo.common.config import ConfigValue
+from pyomo.network import Port
+
+from idaes.core.base.process_base import (
+    declare_process_block_class,
+    ProcessBlockData,
+    useDefault,
+)
+from idaes.core.base.property_base import StateBlock
+from idaes.core.base.control_volume_base import (
+    ControlVolumeBlockData,
+    FlowDirection,
+    MaterialBalanceType,
+)
+from idaes.core.util.exceptions import (
+    BurntToast,
+    ConfigurationError,
+    BalanceTypeNotSupportedError,
+    InitializationError,
+)
+from idaes.core.util.tables import create_stream_table_dataframe
+import idaes.logger as idaeslog
+from idaes.core.solvers import get_solver
+from idaes.core.util.config import DefaultBool
+from idaes.core.initialization import SingleControlVolumeUnitInitializer
+from pyomo.environ import Var, units, Expression
+from pyomo.dae import Integral
+
+
+# Set up logger
+_log = idaeslog.getLogger(__name__)
+
+
+@declare_process_block_class("IntegrationBlock")
+class IntegrationBlockData(ProcessBlockData):
+    """
+    This block has no inlets or outlets, but one value that you can get the integral for.
+    """
+
+    # Create Class ConfigBlock
+    CONFIG = ProcessBlockData.CONFIG()
+    CONFIG.declare(
+        "dynamic",
+        ConfigValue(
+            default=useDefault,
+            domain=DefaultBool,
+            description="Dynamic model flag",
+            doc="""Indicates whether this model will be dynamic or not,
+**default** = useDefault.
+**Valid values:** {
+**useDefault** - get flag from parent (default = False),
+**True** - set as a dynamic model,
+**False** - set as a steady-state model.}""",
+        ),
+    )
+
+    def build(self):
+        """
+        
+        """
+        super(IntegrationBlockData, self).build()
+
+        self.variable = Var(
+            self.flowsheet().time
+        )
+
+        #self.time = self.flowsheet().time
+
+        
+        
+        def _integral(m):
+            time_steps = sorted(self.flowsheet().time)
+            value = m.variable
+            return sum([
+                # Trapezium rule
+                # average the value at the current and next time step, then multiply by the time difference
+                0.5 * (value[time_steps[i]] + value[time_steps[i+1]]) * (time_steps[i+1] - time_steps[i]) 
+                for i in range(len(time_steps)-1)
+            ])
+        
+        self.integral = Expression(
+            rule=_integral
+        )
+        
+        
+        # if self.config.dynamic:
+        #     # create a variable to hold the normal value, and one to hold the integral value
+        # else:
+

ahuora_builder/custom/inverted.py

@@ -0,0 +1,81 @@
+from pyomo.environ import Var, Constraint, units as pyunits, Block, Reference
+
+def add_inverted(block: Block,component_name: str):
+    """
+    Adds inverted variables and constraints to a block with variable component_name.
+    e.g if component_name is 'deltaP', adds deltaP_inverted variable, so we can do 
+    pressure drop instead of pressure increase.
+    """
+    inverted_component_name = f"{component_name}_inverted"
+
+    component = getattr(block, component_name)
+
+    inverted_component = Var(
+        component.index_set(),
+        # Explanation for units:
+        # Reference() turns a var/expression into a indexed object, even if it's scalar.
+        # next() gets the first item from the indexed object
+        # This is a way of getting around the fact that an indexed component
+        # will only have its units defined at the individual index level.
+        units=next(Reference(component).values()).get_units(),
+    )
+
+    block.add_component(inverted_component_name, inverted_component)
+
+    def _inverted_rule(b, *indexes):
+        return inverted_component[indexes] == -component[indexes]
+
+    constraint = Constraint(
+        component.index_set(),
+        rule=_inverted_rule,
+        doc=f"Inverted {component_name} Constraint",
+    )
+    block.add_component(f"{inverted_component_name}_constraint", constraint)
+
+def initialise_inverted(block: Block, component_name: str):
+    """
+    Initialises the inverted deltaP variables to match the deltaP variable values,
+    or vice versa (depending on which is fixed).
+
+    This is generalised so you can pass any component name.
+    """
+    inverted_component_name = f"{component_name}_inverted"
+    component = getattr(block, component_name)
+    inverted_component = getattr(block, inverted_component_name)
+
+    for indexes in component.index_set():
+        if component[indexes].fixed:
+            # we can savely assume that the inverted variable is not
+            # fixed, otherwise this would be an overconstrained model.
+            inverted_component[indexes].value = -component[indexes].value
+        elif inverted_component[indexes].fixed:
+            component[indexes].value = -inverted_component[indexes].value
+        else:
+            # neither variable is fixed,
+            # so let's just leave them as is.
+            # Hopefully the solver can figure it out.
+            pass
+
+def disable_inverted(block: Block, component_name: str) -> bool:
+    """
+    Disables the inverted variables and constraints for a given component.
+    Returns True if the inverted variable was fixed, false otherwise.
+    """
+    inverted_component_name = f"{component_name}_inverted"
+    constraint_name = f"{inverted_component_name}_constraint"
+
+    inverted_constraint = getattr(block, constraint_name)
+
+    inverted_constraint.deactivate()
+
+
+def enable_inverted(block: Block, component_name: str):
+    """
+    Enables the inverted variables and constraints for a given component.
+    """
+    inverted_component_name = f"{component_name}_inverted"
+    constraint_name = f"{inverted_component_name}_constraint"
+
+    inverted_constraint = getattr(block, constraint_name)
+
+    inverted_constraint.activate()

ahuora_builder/custom/performance_curves.py

@@ -0,0 +1 @@
+ 

ahuora_builder/custom/reactions/hda_stoich.py

@@ -0,0 +1,10 @@
+from idaes.core import declare_process_block_class
+from idaes.models.unit_models.stoichiometric_reactor import StoichiometricReactorData
+from pyomo.environ import Var, Reference
+
+@declare_process_block_class("HDAStoichiometricReactor")
+class HDAStoichiometricReactorData(StoichiometricReactorData):
+    def build(self,*args, **kwargs):
+        super().build(*args, **kwargs)
+        # reaction id in https://github.com/IDAES/examples/blob/50065c4cc4de96a8dc1cad833101df2d96574ac4/idaes_examples/mod/hda/hda_reaction.py#L4
+        self.hda_extent = Reference(self.rate_reaction_extent[:,"R1"])