ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/custom/energy/transformer_property_package.py

@@ -0,0 +1,267 @@
+# Import Pyomo tools
+from pyomo.environ import (
+    Constraint,
+    Var,
+    Param,
+    Expression,
+    Reals,
+    NonNegativeReals,
+    Suffix,
+)
+from pyomo.environ import units as pyunits
+from pyomo.common.config import ConfigBlock, ConfigValue, Bool
+
+# Import IDAES cores
+from idaes.core import (
+    declare_process_block_class,
+    MaterialFlowBasis,
+    PhysicalParameterBlock,
+    StateBlockData,
+    StateBlock,
+    MaterialBalanceType,
+    EnergyBalanceType,
+)
+from idaes.core.base.components import Component
+from idaes.core.base.phases import LiquidPhase
+from idaes.core.util.initialization import (
+    fix_state_vars,
+    revert_state_vars,
+    solve_indexed_blocks,
+)
+from idaes.core.base.process_base import ProcessBlockData
+from idaes.core.base import property_meta
+from idaes.core.util.model_statistics import (
+    degrees_of_freedom,
+    number_unfixed_variables,
+)
+from idaes.core.util.exceptions import PropertyPackageError
+import idaes.core.util.scaling as iscale
+import idaes.logger as idaeslog
+from idaes.core.solvers import get_solver
+
+# Set up logger
+_log = idaeslog.getLogger(__name__)
+
+
+# STEP 2
+
+# When using this file the name "transformerParameterBlock" is what is imported
+@declare_process_block_class("transformerParameterBlock")
+class transformerParameterData(PhysicalParameterBlock):
+    CONFIG = ProcessBlockData.CONFIG()
+    CONFIG.declare(
+            "default_arguments",
+            ConfigBlock(
+                implicit=True, description="Default arguments to use with Property Package"
+            ),
+        )
+
+    def build(self):
+        """
+        Callable method for Block construction.
+        """
+        super(transformerParameterData, self).build()
+
+        self._state_block_class = transformerStateBlock
+
+        # Variables
+        self.current = Var(initialize=0, domain=Reals, units=pyunits.A)
+        self.voltage = Var(initialize=0, domain=Reals, units=pyunits.V)
+
+        # Default scaling values should be provided so that our tools can ensure the model is well-scaled
+        # Generally scaling factors should be such that if it is multiplied by the variable it will range between 0.01 and 100
+        self.set_default_scaling("current", 1e-3)
+        self.set_default_scaling("voltage", 1e-3)
+
+    @classmethod
+    def define_metadata(cls, obj):
+        # see https://github.com/watertap-org/watertap/blob/main/tutorials/creating_a_simple_property_model.ipynb
+        obj.add_properties(
+            {
+                "current": {"method": None},
+                "voltage": {"method": None},
+            }
+        )
+        obj.add_default_units(
+            {
+                "time": pyunits.s,
+                "length": pyunits.m,
+                "mass": pyunits.kg,
+            }
+        )
+    
+    def build_state_block(self, *args, **kwargs):
+        """
+        Methods to construct a StateBlock associated with this
+        PhysicalParameterBlock. This will automatically set the parameters
+        construction argument for the StateBlock.
+
+        Returns:
+            StateBlock
+
+        """
+        # default = kwargs.pop("default", {})
+        initialize = kwargs.pop("initialize", {})
+
+        if initialize == {}:
+            kwargs["parameters"] = self
+        else:
+            for i in initialize.keys():
+                initialize[i]["parameters"] = self
+
+        return self.state_block_class(  # pylint: disable=not-callable
+            *args, **kwargs, initialize=initialize
+        )
+
+    @property
+    def state_block_class(self):
+        if self._state_block_class is not None:
+            return self._state_block_class
+        else:
+            raise AttributeError(
+                "{} has not assigned a StateBlock class to be associated "
+                "with this property package. Please contact the developer of "
+                "the property package.".format(self.name)
+            )
+
+# STEP 3: State Block
+class _transformerStateBlock(StateBlock):
+    def initialize(
+        self,
+        state_args=None,
+        state_vars_fixed=False,
+        hold_state=False,
+        outlvl=idaeslog.NOTSET,
+        solver=None,
+        optarg=None,
+    ):
+        """
+        Initialization routine for property package.
+        Keyword Arguments:
+            state_args : Dictionary with initial guesses for the state vars
+                         chosen. Note that if this method is triggered
+                         through the control volume, and if initial guesses
+                         were not provided at the unit model level, the
+                         control volume passes the inlet values as initial
+                         guess.The keys for the state_args dictionary are:
+
+                         flow_mass_phase_comp : value at which to initialize
+                                               phase component flows
+                         pressure : value at which to initialize pressure
+                         temperature : value at which to initialize temperature
+
+            state_vars_fixed: Flag to denote if state vars have already been
+                              fixed.
+                              - True - states have already been fixed by the
+                                       control volume 1D. Control volume 0D
+                                       does not fix the state vars, so will
+                                       be False if this state block is used
+                                       with 0D blocks.
+                             - False - states have not been fixed. The state
+                                       block will deal with fixing/unfixing.
+            hold_state : flag indicating whether the initialization routine
+                         should unfix any state variables fixed during
+                         initialization (default=False).
+                         - 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
+            outlvl : sets output level of initialization routine (default=idaeslog.NOTSET)
+            solver : Solver object to use during initialization if None is provided
+                     it will use the default solver for IDAES (default = None)
+            optarg : solver options dictionary object (default=None)
+        Returns:
+            If hold_states is True, returns a dict containing flags for
+            which states were fixed during initialization.
+        """
+
+        # Fix state variables
+        flags = fix_state_vars(self, state_args)
+        # Check that dof = 0 when state variables are fixed
+        for k in self.keys():
+            dof = degrees_of_freedom(self[k])
+            if dof != 0:
+                raise PropertyPackageError(
+                    "\nWhile initializing {sb_name}, the degrees of freedom "
+                    "are {dof}, when zero is required. \nInitialization assumes "
+                    "that the state variables should be fixed and that no other "
+                    "variables are fixed. \nIf other properties have a "
+                    "predetermined value, use the calculate_state method "
+                    "before using initialize to determine the values for "
+                    "the state variables and avoid fixing the property variables."
+                    "".format(sb_name=self.name, dof=dof)
+                )
+
+        # If input block, return flags, else release state
+        if state_vars_fixed is False:
+            if hold_state is True:
+                return flags
+            else:
+                self.release_state(flags)
+
+    def release_state(self, flags, outlvl=idaeslog.NOTSET):
+        """
+        Method to release state variables fixed during initialisation.
+
+        Keyword Arguments:
+            flags : dict containing information of which state variables
+                    were fixed during initialization, and should now be
+                    unfixed. This dict is returned by initialize if
+                    hold_state=True.
+            outlvl : sets output level of of logging
+        """
+        if flags is None:
+            return
+        # Unfix state variables
+        for attr in flags:
+            if flags[attr] is True:
+                getattr(self, attr).unfix()
+        return
+        
+# STEP 4: 
+@declare_process_block_class("transformerStateBlock", block_class=_transformerStateBlock)
+class transformerStateBlockData(StateBlockData):
+    def build(self):
+        """Callable method for Block construction."""
+        super(transformerStateBlockData, self).build()
+
+        self.scaling_factor = Suffix(direction=Suffix.EXPORT)
+
+        self.current = Var(
+            initialize=0,
+            domain=Reals,
+            units=pyunits.A,
+            doc="reactive power flow",
+        ) 
+        self.voltage = Var(
+            initialize=0,
+            domain=Reals,
+            units=pyunits.V,
+            doc="voltage",
+        )
+
+    # -----------------------------------------------------------------------------
+
+    def define_state_vars(self):
+        """Define state vars."""
+        return {
+            "current" : self.current,
+            "voltage": self.voltage
+        }
+    
+
+    # -----------------------------------------------------------------------------
+    # Scaling methods
+    def calculate_scaling_factors(self):
+        super().calculate_scaling_factors()
+        # This doesn't do anything, but it's a good example of how to get and set scaling factors in relation to each other.
+        sfc = iscale.get_scaling_factor(self.current)
+        iscale.set_scaling_factor(self.current, sfc)
+        sfv = iscale.get_scaling_factor(self.voltage)
+        iscale.set_scaling_factor(self.voltage, sfv)
+
+
+

ahuora_builder/custom/energy/transmissionLine.py

@@ -0,0 +1,228 @@
+# Import Pyomo libraries
+from stringprep import in_table_a1
+from pyomo import environ
+from pyomo.environ import (
+    Constraint,
+    Set,
+    Var,
+    Suffix,
+    units as pyunits,
+    atan
+)
+from pyomo.environ import Reals
+from pyomo.common.config import ConfigBlock, ConfigValue, In
+from pyomo.contrib.fbbt import interval
+from idaes.core.util.model_statistics import degrees_of_freedom
+# Import IDAES cores
+from idaes.core import (
+    declare_process_block_class,
+    UnitModelBlockData,
+    useDefault,
+    MaterialBalanceType,
+    MaterialFlowBasis,
+)
+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 import separator
+from idaes.core.util.tables import create_stream_table_dataframe
+from idaes.core.util.exceptions import ConfigurationError, BurntToast, PropertyNotSupportedError
+
+from idaes.models.unit_models import separator
+#Import enum
+from enum import Enum
+
+# Set up logger
+_log = idaeslog.getLogger(__name__)
+
+import math
+# Enumerate options for balances
+class SplittingType(Enum):
+    """
+    Enum of supported material split types.
+    """
+
+    totalFlow = 1
+    phaseFlow = 2
+    componentFlow = 3
+    phaseComponentFlow = 4
+
+
+
+# When using this file the name "transmissionLine" is what is imported
+@declare_process_block_class("transmissionLine")
+class transmissionLineData(UnitModelBlockData):
+    """
+    Zero order transmission line model
+    """
+
+    # CONFIG are options for the unit model, this simple model only has the mandatory config options
+    CONFIG = ConfigBlock()
+
+    CONFIG.declare(
+        "dynamic",
+        ConfigValue(
+            domain=In([False]),
+            default=False,
+            description="Dynamic model flag - must be False",
+            doc="""Indicates whether this model will be dynamic or not,
+    **default** = False. The Bus unit does not support dynamic
+    behavior, thus this must be False.""",
+        ),
+    )
+    CONFIG.declare(
+        "has_holdup",
+        ConfigValue(
+            default=False,
+            domain=In([False]),
+            description="Holdup construction flag - must be False",
+            doc="""Indicates whether holdup terms should be constructed or not.
+    **default** - False. The Bus unit does not have defined volume, thus
+    this must be False.""",
+        ),
+    )
+    CONFIG.declare(
+        "property_package",
+        ConfigValue(
+            default=useDefault,
+            domain=is_physical_parameter_block,
+            description="Property package to use for control volume",
+            doc="""Property parameter object used to define property calculations,
+    **default** - useDefault.
+    **Valid values:** {
+    **useDefault** - use default package from parent model or flowsheet,
+    **PhysicalParameterObject** - a PhysicalParameterBlock object.}""",
+        ),
+    )
+    CONFIG.declare(
+        "property_package_args",
+        ConfigBlock(
+            implicit=True,
+            description="Arguments to use for constructing 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.}""",
+        ),
+    )
+    CONFIG.declare(
+        "num_inlets",
+        ConfigValue(
+            default=False,
+            domain=int,
+            description="Number of inlets to add",
+            doc="Number of inlets to add",
+        ),
+    )
+    CONFIG.declare(
+        "num_outlets",
+        ConfigValue(
+            default=False,
+            domain=int,
+            description="Number of outlets to add",
+            doc="Number of outlets to add",
+        ),
+    )
+    CONFIG.declare(
+        "material_balance_type",
+        ConfigValue(
+            default=MaterialBalanceType.useDefault,
+            domain=In(MaterialBalanceType),
+            description="Material balance construction flag",
+            doc="""Indicates what type of mass balance should be constructed,
+            **default** - MaterialBalanceType.useDefault.
+            **Valid values:** {
+            **MaterialBalanceType.useDefault - refer to property package for default
+            balance type
+            **MaterialBalanceType.none** - exclude material balances,
+            **MaterialBalanceType.componentPhase** - use phase component balances,
+            **MaterialBalanceType.componentTotal** - use total component balances,
+            **MaterialBalanceType.elementTotal** - use total element balances,
+            **MaterialBalanceType.total** - use total material balance.}""",
+        ),
+    )
+
+
+    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)
+
+        tmp_dict = dict(**self.config.property_package_args)
+        tmp_dict["parameters"] = self.config.property_package
+
+                # Add state blocks for inlet, outlet, and waste
+        # These include the state variables and any other properties on demand
+        # Add inlet block
+        # 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
+        # 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.properties_out = self.config.property_package.state_block_class(
+            self.flowsheet().config.time,
+            doc="Material properties of outlet",
+            **tmp_dict
+        )
+         # Add second outlet block
+        tmp_dict["defined_state"] = False 
+        self.properties_out2 = self.config.property_package.state_block_class(
+            self.flowsheet().config.time, doc="Material properties of inlet", **tmp_dict
+        )
+
+        # Add ports - oftentimes users interact with these rather than the state blocks
+        # self.add_port(name="inlet_1", block=self.properties_in)
+        # self.add_port(name="inlet_2", block=self.properties_in2)
+        self.add_port(name="outlet_1", block=self.properties_out)
+        self.add_port(name="outlet_2", block=self.properties_out2)       
+       
+        self.power_transfer = Var(self.flowsheet().config.time,
+            initialize=1.0,
+            doc="Power transferred between busses",
+            units = pyunits.W
+
+        )
+
+        # Add constraints:
+        @self.Constraint(
+            self.flowsheet().time,
+            doc = "Power balance"
+        )
+        def eq_power_balance(b,t):
+            return self.properties_out2[t].power == self.power_transfer[t]
+        
+        @self.Constraint(
+            self.flowsheet().time,
+            doc = "Power calculation"
+        )
+        def eq_power_calc(b,t):
+            return self.properties_out[t].power == self.power_transfer[t] * -1
+
+
+                
+    def calculate_scaling_factors(self):
+        super().calculate_scaling_factors()
+    
+    def initialize(blk, *args, **kwargs):
+       for i in blk.properties_out.index_set():
+            if not blk.properties_out[i].power.fixed:
+                blk.properties_out[i].power = blk.power_transfer[i].value   
+
+
+    def _get_stream_table_contents(self, time_point=0):
+        """
+        Assume unit has standard configuration of 1 inlet and 1 outlet.
+
+        Developers should overload this as appropriate.
+        """
+       
+
+   

ahuora_builder/custom/energy/wind.py

@@ -0,0 +1,206 @@
+# Import Pyomo libraries
+from ast import Expression
+from cmath import pi
+from pyomo.environ import (
+    Var,
+    Suffix,
+    units as pyunits,
+)
+from pyomo.common.config import ConfigBlock, ConfigValue, In
+
+# 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.core.util.tables import create_stream_table_dataframe
+
+from idaes.core.util.exceptions import ConfigurationError
+
+# Set up logger
+_log = idaeslog.getLogger(__name__)
+
+
+# When using this file the name "Wind" is what is imported
+@declare_process_block_class("Wind")
+class WindData(UnitModelBlockData):
+    """
+    Zero order Link model
+    """
+
+    # CONFIG are options for the unit model, this simple model only has the mandatory config options
+    CONFIG = ConfigBlock()
+
+    CONFIG.declare(
+        "dynamic",
+        ConfigValue(
+            domain=In([False]),
+            default=False,
+            description="Dynamic model flag - must be False",
+            doc="""Indicates whether this model will be dynamic or not,
+    **default** = False. The Bus unit does not support dynamic
+    behavior, thus this must be False.""",
+        ),
+    )
+    CONFIG.declare(
+        "has_holdup",
+        ConfigValue(
+            default=False,
+            domain=In([False]),
+            description="Holdup construction flag - must be False",
+            doc="""Indicates whether holdup terms should be constructed or not.
+    **default** - False. The Bus unit does not have defined volume, thus
+    this must be False.""",
+        ),
+    )
+    CONFIG.declare(
+        "property_package",
+        ConfigValue(
+            default=useDefault,
+            domain=is_physical_parameter_block,
+            description="Property package to use for control volume",
+            doc="""Property parameter object used to define property calculations,
+    **default** - useDefault.
+    **Valid values:** {
+    **useDefault** - use default package from parent model or flowsheet,
+    **PhysicalParameterObject** - a PhysicalParameterBlock object.}""",
+        ),
+    )
+    CONFIG.declare(
+        "property_package_args",
+        ConfigBlock(
+            implicit=True,
+            description="Arguments to use for constructing 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
+        # Add inlet block
+        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 outlet
+        tmp_dict["defined_state"] = False  # outlet is not an inlet
+        self.properties_out = self.config.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="outlet", block=self.properties_out)
+
+        # Add variable for efficiency
+        self.efficiency = Var(
+            initialize=1.0,
+            doc="Efficiency of the turbine",
+        )
+
+        # Add variable for Windspeed
+        self.windspeed = Var(self.flowsheet().config.time,
+            initialize=1.0, units = pyunits.m/pyunits.s,
+            doc="Speed of wind hitting the turbines",
+        )
+
+        # Add variable for Pressure
+        self.pressure = Var(self.flowsheet().config.time,
+            initialize=1.0, units = pyunits.Pa,
+            doc="Air pressure",
+        )
+
+        # Add variable for Temperature
+        self.air_temp = Var(self.flowsheet().config.time,
+            initialize=1.0, units = pyunits.degK,
+            doc="Air Temperature",
+        )
+
+        # Add variable for Humidity
+        self.humidity = Var(self.flowsheet().config.time,
+            initialize=1.0,
+            doc="Air humidity",
+        )
+
+        # Add variable for rotor diameter
+        self.rotor_diameter = Var(
+            initialize=1.0, units = pyunits.m,
+            doc="Rotor Diameter",
+        )
+
+        # Add variable for no. of turbines
+        self.turbine_count = Var(
+            initialize=1.0,
+            doc="Number of turbines",
+        )
+
+        # Simple expressions
+        self.radius = self.rotor_diameter / 2
+        self.area = pi * self.radius**2
+        self.Cp= 0.579  # Power coefficient, typically between 0.4 and 0.6 for wind turbines
+
+        
+        # Expression indexed by time
+        @self.Expression(
+            self.flowsheet().time
+        )
+        def density(b,t):
+            return(
+               (self.pressure[t]/(287.05 * self.air_temp[t])) * (1-0.378*(self.humidity[t]))
+            )    
+
+
+        # Add constraints
+        @self.Constraint(
+            self.flowsheet().time,
+            doc="Power usage",
+        )
+        def eq_power_balance(b, t):
+            return (
+               0.5 * self.density[t] * self.area * self.windspeed[t]**3 * self.Cp * self.efficiency * self.turbine_count == b.properties_out[t].power
+            )
+
+
+    def calculate_scaling_factors(self):
+        super().calculate_scaling_factors()
+    
+    def initialize(blk, *args, **kwargs):
+        # Just propagate the power from inlet to outlet, good simple method of initialization
+       pass
+
+    def _get_stream_table_contents(self, time_point=0):
+        """
+        Assume unit has standard configuration of 1 inlet and 1 outlet.
+
+        Developers should overload this as appropriate.
+        """
+        try:
+            return create_stream_table_dataframe(
+                {"Outlet": self.outlet}, time_point=time_point
+            )
+        except AttributeError:
+            raise ConfigurationError(
+                f"Unit model {self.name} does not have the standard Port "
+                f"names (inlet and outlet). Please contact the unit model "
+                f"developer to develop a unit specific stream table."
+            )