ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/custom/energy/ac_property_package.py

@@ -0,0 +1,279 @@
+# 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 "acParameterBlock" is what is imported
+@declare_process_block_class("acParameterBlock")
+class acParameterData(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(acParameterData, self).build()
+
+        self._state_block_class = acStateBlock
+
+        # Variables
+        self.active_power = Var(initialize=0, domain=Reals, units=pyunits.W)
+        self.reactive_power = Var(initialize=0, domain=Reals, units=pyunits.W)
+        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("active_power", 1e-3)
+        self.set_default_scaling("reactive_power", 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(
+            {
+                "active_power": {"method": None},
+                "reactive_power": {"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 _acStateBlock(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("acStateBlock", block_class=_acStateBlock)
+class acStateBlockData(StateBlockData):
+    def build(self):
+        """Callable method for Block construction."""
+        super(acStateBlockData, self).build()
+
+        self.scaling_factor = Suffix(direction=Suffix.EXPORT)
+
+        self.active_power = Var(
+            initialize=0,
+            domain=Reals,
+            units=pyunits.W,
+            doc="active power flow",
+        )
+        self.reactive_power = Var(
+            initialize=0,
+            domain=Reals,
+            units=pyunits.W,
+            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 {
+            "active_power": self.active_power,
+            "reactive_power" : self.reactive_power,
+            "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.
+        sfa = iscale.get_scaling_factor(self.active_power)
+        iscale.set_scaling_factor(self.active_power, sfa)
+        sfr = iscale.get_scaling_factor(self.reactive_power)
+        iscale.set_scaling_factor(self.reactive_power, sfr)
+        sfv = iscale.get_scaling_factor(self.active_power)
+        iscale.set_scaling_factor(self.voltage, sfv)
+
+
+

ahuora_builder/custom/energy/battery.py

@@ -0,0 +1,170 @@
+# Import Pyomo libraries
+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 "Solar" is what is imported
+@declare_process_block_class("Solar")
+class SolarData(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 panel",
+        )
+
+        # Add variable for solar irradiation
+        self.irradiation = Var(self.flowsheet().config.time,
+            initialize=1.0, units = pyunits.W/pyunits.m**2,
+            doc="Amount of sunlight hitting the panel",
+        )
+
+        # Add variable for area
+        self.area = Var(
+            initialize=1.0, units = pyunits.m**2,
+            doc="Size of the panel",
+        )
+
+        # Add variable for no. of solar panels
+        self.panel_count = Var(
+            initialize=1.0,
+            doc="Number of solar panels",
+        )
+
+        # Add constraints
+        @self.Constraint(
+            self.flowsheet().time,
+            doc="Power usage",
+        )
+        def eq_power_balance(b, t):
+            return (
+                self.irradiation[t] * self.efficiency * self.area * self.panel_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."
+            )

ahuora_builder/custom/energy/bus.py

@@ -0,0 +1,182 @@
+# Import Pyomo libraries
+from stringprep import in_table_a1
+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 "Bus" is what is imported
+@declare_process_block_class("Bus")
+class BusData(UnitModelBlockData):
+    """
+    Zero order bus 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""",
+        ),
+    )
+    
+    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)
+
+
+        # Defining parameters of state block class
+        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 state blocks for inlet, outlet, and waste
+        # These include the state variables and any other properties on demand
+        num_inlets = self.config.num_inlets
+
+        self.inlet_list = [ "inlet_" + str(i+1) for i in range(num_inlets) ]
+        
+
+        self.inlet_blocks = []
+        for name in self.inlet_list:
+            # add properties_inlet_1, properties_inlet2 etc
+            state_block = self.config.property_package.state_block_class(
+                self.flowsheet().config.time, doc="inlet power", **tmp_dict
+            )
+            self.inlet_blocks.append(state_block)
+            # Dynamic equivalent to self.properties_inlet_1 = stateblock
+            setattr(self,"properties_" + name, state_block)
+            # also add the port
+            self.add_port(name=name,block=state_block)
+
+
+        # Add outlet state 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 outlet port
+        self.add_port(name="outlet", block=self.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 usage",
+        )
+        def eq_power_balance(b, t):
+            return (
+                 sum(
+                    state_block[t].power for state_block in self.inlet_blocks
+                 )
+                  == 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
+        for t in blk.flowsheet().time:
+            power_in = 0
+            for state_block in blk.inlet_blocks:
+                power_in += state_block[t].power.value
+            if not blk.properties_out[t].power.fixed:
+                blk.properties_out[t].power = power_in
+
+    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.
+        """
+        
+        io_dict = {}
+        for inlet_name in self.inlet_list:
+            io_dict[inlet_name] = getattr(self, inlet_name) # get a reference to the port
+        
+        io_dict["Outlet"] = self.outlet
+        return create_stream_table_dataframe(io_dict, time_point=time_point)