ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/custom/custom_turbine.py

@@ -0,0 +1,132 @@
+# 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 idaes.models.unit_models.pressure_changer import (
+    TurbineData,
+)
+from idaes.core.util.exceptions import PropertyNotSupportedError, InitializationError
+
+
+# Import Python libraries
+
+
+# Import Pyomo libraries
+from pyomo.environ import (
+    Block,
+    value,
+    Var,
+    Expression,
+    Constraint,
+    Reference,
+    check_optimal_termination,
+    Reals,
+)
+from pyomo.common.config import ConfigBlock, ConfigValue, In, Bool
+from idaes.core.solvers import get_solver
+from .thermal_utility_systems.willans_turbine import TurbineBaseData
+from .inverted import add_inverted, initialise_inverted
+
+
+# When using this file the name "CustomCompressor" is what is imported
+@declare_process_block_class("CustomTurbine")
+class CustomTurbineData(TurbineBaseData):
+    """
+    Zero order Load model
+    """
+
+    # CONFIG are options for the unit model, this simple model only has the mandatory config options
+    CONFIG = TurbineBaseData.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_electrical[t] *  -1
+            )
+        
+        # Add inverted deltaP property
+        add_inverted(self, "deltaP")
+    
+    def initialize_build(self, *args, **kwargs):
+        initialise_inverted(self, "deltaP")
+
+        super().initialize_build(*args, **kwargs)

ahuora_builder/custom/custom_valve.py

@@ -0,0 +1,300 @@
+#################################################################################
+# 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.
+#################################################################################
+"""
+This provides standard valve models for adiabatic control valves.  Beyond the
+most common valve models, and adiabatic valve model can be added by supplying
+custom callbacks for the pressure-flow relation or valve function.
+"""
+# Changing existing config block attributes
+# pylint: disable=protected-access
+
+__Author__ = "John Eslick"
+
+from enum import Enum
+
+import pyomo.environ as pyo
+from pyomo.common.config import ConfigValue, In
+
+from idaes.core import declare_process_block_class
+from .updated_pressure_changer import (
+    ThermodynamicAssumption,
+    MaterialBalanceType,
+)
+
+from .updated_pressure_changer import PressureChangerData
+
+from idaes.core.util.exceptions import ConfigurationError
+import idaes.logger as idaeslog
+import idaes.core.util.scaling as iscale
+from .inverted import add_inverted, initialise_inverted
+
+_log = idaeslog.getLogger(__name__)
+
+
+class ValveFunctionType(Enum):
+    """
+    Enum of supported valve types.
+    """
+
+    linear = 1
+    quick_opening = 2
+    equal_percentage = 3
+
+
+def linear_cb(valve):
+    """
+    Linear opening valve function callback.
+    """
+
+    @valve.Expression(valve.flowsheet().time)
+    def valve_function(b, t):
+        return b.valve_opening[t]
+
+
+def quick_cb(valve):
+    """
+    Quick opening valve function callback.
+    """
+
+    @valve.Expression(valve.flowsheet().time)
+    def valve_function(b, t):
+        return pyo.sqrt(b.valve_opening[t])
+
+
+def equal_percentage_cb(valve):
+    """
+    Equal percentage valve function callback.
+    """
+    valve.alpha = pyo.Var(initialize=100, doc="Valve function parameter")
+    valve.alpha.fix()
+
+    @valve.Expression(valve.flowsheet().time)
+    def valve_function(b, t):
+        return b.alpha ** (b.valve_opening[t] - 1)
+
+
+def pressure_flow_default_callback(valve):
+    """
+    Add the default pressure flow relation constraint.  This will be used in the
+    valve model, a custom callback is provided.
+    """
+    umeta = (
+        valve.control_volume.config.property_package.get_metadata().get_derived_units
+    )
+
+    valve.Cv = pyo.Var(
+        initialize=0.1,
+        doc="Valve flow coefficient",
+        units=umeta("amount") / umeta("time") / umeta("pressure") ** 0.5,
+    )
+    # valve.Cv.fix()
+
+    valve.flow_var = pyo.Reference(valve.control_volume.properties_in[:].flow_mol)
+    valve.pressure_flow_equation_scale = lambda x: x**2
+
+    @valve.Constraint(valve.flowsheet().time)
+    def pressure_flow_equation(b, t):
+        Po = b.control_volume.properties_out[t].pressure
+        Pi = b.control_volume.properties_in[t].pressure
+        F = b.control_volume.properties_in[t].flow_mol
+        Cv = b.Cv
+        fun = b.valve_function[t]
+        return F**2 == Cv**2 * (Pi - Po) * fun**2
+
+
+@declare_process_block_class("Valve", doc="Adiabatic valves")
+class ValveData(PressureChangerData):
+    """
+    Basic valve model class.
+    """
+
+    # Same settings as the default pressure changer, but force to expander with
+    # isentropic efficiency
+    CONFIG = PressureChangerData.CONFIG()
+    CONFIG.compressor = False
+    CONFIG.get("compressor")._default = False
+    CONFIG.get("compressor")._domain = In([False])
+    CONFIG.material_balance_type = MaterialBalanceType.componentTotal
+    CONFIG.get("material_balance_type")._default = MaterialBalanceType.componentTotal
+    CONFIG.thermodynamic_assumption = ThermodynamicAssumption.adiabatic
+    CONFIG.get("thermodynamic_assumption")._default = ThermodynamicAssumption.adiabatic
+    CONFIG.get("thermodynamic_assumption")._domain = In(
+        [ThermodynamicAssumption.adiabatic]
+    )
+    CONFIG.declare(
+        "valve_function_callback",
+        ConfigValue(
+            default=ValveFunctionType.linear,
+            description="Valve function type or callback for custom",
+            doc="""This takes either an enumerated valve function type in: {
+ValveFunctionType.linear, ValveFunctionType.quick_opening,
+ValveFunctionType.equal_percentage, ValveFunctionType.custom} or a callback
+function that takes a valve model object as an argument and adds a time-indexed
+valve_function expression to it. Any additional required variables, expressions,
+or constraints required can also be added by the callback.""",
+        ),
+    )
+    CONFIG.declare(
+        "pressure_flow_callback",
+        ConfigValue(
+            default=pressure_flow_default_callback,
+            description="Callback function providing the valve_function expression",
+            doc="""This callback function takes a valve model object as an argument
+and adds a time-indexed valve_function expression to it.  Any additional required
+variables, expressions, or constraints required can also be added by the callback.""",
+        ),
+    )
+
+    def build(self):
+        super().build()
+
+        self.valve_opening = pyo.Var(
+            self.flowsheet().time,
+            initialize=1,
+            bounds=(0, 1),
+            doc="Fraction open for valve from 0 to 1",
+        )
+
+
+        #commented out to allow for valve opening to be set by the user
+        #self.valve_opening.fix()
+
+ 
+        
+        # If the valve function callback is set to one of the known enumerated
+        # types, set the callback appropriately.  If not callable and not a known
+        # type raise ConfigurationError.
+        vfcb = self.config.valve_function_callback
+        if not callable(vfcb):
+            if vfcb == ValveFunctionType.linear:
+                self.config.valve_function_callback = linear_cb
+            elif vfcb == ValveFunctionType.quick_opening:
+                self.config.valve_function_callback = quick_cb
+            elif vfcb == ValveFunctionType.equal_percentage:
+                self.config.valve_function_callback = equal_percentage_cb
+            else:
+                raise ConfigurationError("Invalid valve function callback.")
+        self.config.valve_function_callback(self)
+        self.config.pressure_flow_callback(self)
+
+        # add deltaP_inverted as a property
+        add_inverted(self,"deltaP")
+
+    def initialize_build(
+        self,
+        state_args=None,
+        outlvl=idaeslog.NOTSET,
+        solver=None,
+        optarg=None,
+    ):
+        """
+        Initialize the valve based on a deltaP guess.
+
+        Args:
+            state_args (dict): Initial state for property initialization
+            outlvl : sets output level of initialization routine
+            solver (str): Solver to use for initialization
+            optarg (dict): Solver arguments dictionary
+        """
+        initialise_inverted(self,"deltaP")
+
+        for t in self.flowsheet().time:
+            if (
+                self.deltaP[t].fixed or self.deltaP_inverted[t].fixed
+                or self.ratioP[t].fixed
+                or self.outlet.pressure[t].fixed
+            ):
+                continue
+            # Generally for the valve initialization pressure drop won't be
+            # fixed, so if there is no good guess on deltaP try to out one in
+            Pout = self.outlet.pressure[t]
+            Pin = self.inlet.pressure[t]
+            if self.deltaP[t].value is not None:
+                prdp = pyo.value((self.deltaP[t] - Pin) / Pin)
+            else:
+                prdp = -100  # crazy number to say don't use deltaP as guess
+            if pyo.value(Pout / Pin) > 1 or pyo.value(Pout / Pin) < 0.0:
+                if pyo.value(self.ratioP[t]) <= 1 and pyo.value(self.ratioP[t]) >= 0:
+                    Pout.value = pyo.value(Pin * self.ratioP[t])
+                elif prdp <= 1 and prdp >= 0:
+                    Pout.value = pyo.value(prdp * Pin)
+                else:
+                    Pout.value = pyo.value(Pin * 0.95)
+            self.deltaP[t] = pyo.value(Pout - Pin)
+            self.ratioP[t] = pyo.value(Pout / Pin)
+
+        # one bad thing about reusing this is that the log messages aren't
+        # really compatible with being nested inside another initialization
+        super().initialize_build(
+            state_args=state_args, outlvl=outlvl, solver=solver, optarg=optarg
+        )
+
+    def calculate_scaling_factors(self):
+        """
+        Calculate pressure flow constraint scaling from flow variable scale.
+        """
+        # The value of the valve opening and the output of the valve function
+        # expression are between 0 and 1, so the only thing that needs to be
+        # scaled here is the pressure-flow constraint, which can be scaled by
+        # using the flow variable scale.  The flow variable could be defined
+        # in different ways, so the flow variable is determined here from a
+        # "flow_var[t]" reference set in the pressure-flow callback. The flow
+        # term could be in various forms, so an optional
+        # "pressure_flow_equation_scale" function can be defined in the callback
+        # as well.  The pressure-flow function could be flow = f(Pin, Pout), but
+        # it could also be flow**2 = f(Pin, Pout), ... The so
+        # "pressure_flow_equation_scale" provides the form of the LHS side as
+        # a function of the flow variable.
+
+        super().calculate_scaling_factors()
+
+        # Do some error trapping.
+        if not hasattr(self, "pressure_flow_equation"):
+            raise AttributeError(
+                "Pressure-flow callback must define pressure_flow_equation[t]"
+            )
+        # Check for flow term form if none assume flow = f(Pin, Pout)
+        if hasattr(self, "pressure_flow_equation_scale"):
+            ff = self.pressure_flow_equation_scale
+        else:
+            # pylint: disable-next=unnecessary-lambda-assignment
+            ff = lambda x: x
+        # if the "flow_var" is not set raise an exception
+        if not hasattr(self, "flow_var"):
+            raise AttributeError(
+                "Pressure-flow callback must define flow_var[t] reference"
+            )
+
+        # Calculate and set the pressure-flow relation scale.
+        if hasattr(self, "pressure_flow_equation"):
+            for t, c in self.pressure_flow_equation.items():
+                iscale.constraint_scaling_transform(
+                    c,
+                    ff(
+                        iscale.get_scaling_factor(
+                            self.flow_var[t], default=1, warning=True
+                        )
+                    ),
+                )
+
+    def _get_performance_contents(self, time_point=0):
+        pc = super()._get_performance_contents(time_point=time_point)
+
+        pc["vars"]["Opening"] = self.valve_opening[time_point]
+        try:
+            pc["vars"]["Valve Coefficient"] = self.Cv
+        except AttributeError:
+            pass
+        if self.config.valve_function_callback == ValveFunctionType.equal_percentage:
+            pc["vars"]["alpha"] = self.alpha
+        return pc

ahuora_builder/custom/custom_variable.py

@@ -0,0 +1,29 @@
+from idaes.models.control.controller import PIDControllerData, ControllerType, ControllerMVBoundType, ControllerAntiwindupType, smooth_bound, smooth_heaviside
+from pyomo.environ import Var
+from idaes.core import UnitModelBlockData, declare_process_block_class
+from pyomo.common.config import ConfigValue, In, Bool
+import pyomo.environ as pyo
+from idaes.core.util.exceptions import ConfigurationError
+import pyomo.dae as pyodae
+from idaes.core.util import scaling as iscale
+import functools
+
+
+@declare_process_block_class(
+    "CustomVariable",
+    doc="Custom variable model block. You can finally be free!",
+)
+class CustomVariableData(UnitModelBlockData):
+
+    CONFIG = UnitModelBlockData.CONFIG()
+
+    def build(self):
+        """
+        Build the custom variable block
+        """
+        super().build()
+        self.variable = Var(
+            self.flowsheet().time,
+            initialize=0.0,
+            doc="A variable you are free to do whatever you want with",
+        )