ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/custom/energy/storage.py

@@ -0,0 +1,230 @@
+# Import Pyomo libraries
+from pyomo.environ import (
+    Var,
+    Suffix,
+    units as pyunits,
+)
+from pyomo.common.config import ConfigBlock, ConfigValue, In
+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 pyomo.util.check_units import assert_units_consistent
+from pyomo.environ import value
+
+# Set up logger
+_log = idaeslog.getLogger(__name__)
+
+
+# When using this file the name "Link" is what is imported
+@declare_process_block_class("Storage")
+class StorageData(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
+        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"] = True  
+        self.properties_in = self.config.property_package.state_block_class(
+            self.flowsheet().config.time,
+            doc="Material properties of outlet",
+            **tmp_dict
+        )
+        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 ports - oftentimes users interact with these rather than the state blocks
+        self.add_port(name="inlet", block=self.properties_in)
+        self.add_port(name="outlet", block=self.properties_out)
+
+        # Add variables:
+        self.charging_efficiency = Var(
+            self.flowsheet().config.time,
+            initialize=1.0,
+            doc="Charging Efficiency",
+            )
+        self.capacity = Var(self.flowsheet().config.time,
+            initialize=1.0,
+            units=pyunits.kWh,
+            doc="Capacity of the storage",
+            )
+        self.initial_SOC = Var(self.flowsheet().config.time,
+            initialize=0.4,
+            doc="Initial State of Charge",
+            )
+        self.charging_power_in = Var(self.flowsheet().config.time,
+            initialize=1.0,
+            units=pyunits.W,
+            doc="Power in",
+            )
+        self.charging_power_out = Var(self.flowsheet().config.time,
+            initialize=1.0,
+            units=pyunits.W,
+            doc="Power out",
+            )
+
+        @self.Expression(
+            self.flowsheet().time,
+            doc="updated state of charge",
+        )
+        def updated_SOC(b,t):
+            power_in = self.charging_power_in[t]
+            power_out = self.charging_power_out[t]
+            power_change = (power_in-power_out)/(pyunits.W *1000)
+            capacity_without_unit = self.capacity[t]/pyunits.kWh
+            if t == self.flowsheet().time.first():
+                self.updated_SOC[t] = self.initial_SOC[t] + power_change/capacity_without_unit
+            else:
+                self.updated_SOC[t] = self.updated_SOC[t-1] + power_change/capacity_without_unit
+          
+            return self.updated_SOC[t]
+
+
+
+        @self.Constraint(
+            self.flowsheet().time,
+            doc="Set output power for charging",
+        )
+        
+
+        @self.Constraint(
+            self.flowsheet().time,
+            doc="Set output power for discharging",
+        )
+        def set_power_out_discharge(b,t): 
+            return b.properties_out[t].power == self.charging_power_out[t]
+       
+
+        @self.Constraint(
+            self.flowsheet().time,
+            doc="Set output power for charging",
+        )
+        def set_power_charge(b,t):
+            return self.charging_power_in[t] == self.properties_in[t].power
+
+        
+        # Add a constraint to ensure power_change is within a range
+        @self.Constraint(
+            self.flowsheet().time,
+            doc="Ensure power_change is within a specified range",
+        )
+        def power_change_within_range(b, t):
+            power_in = self.charging_power_in[t]
+            power_out = self.charging_power_out[t]
+            power_in_out = (power_in-power_out)/(pyunits.W *1000)
+           # power_in_out = b.properties_out[t].power / (pyunits.W * 1000)
+            remaining_power = power_in_out + self.initial_SOC[t] * self.capacity[t]
+            return remaining_power <= self.capacity[t]
+        
+        @self.Constraint(
+            self.flowsheet().time,
+            doc="Ensure power_change is within capacity",
+        )
+        def power_change_above_zero(b, t):
+            
+            power_in = self.charging_power_in[t]
+            power_out = self.charging_power_out[t]
+            power_in_out = (power_in-power_out)/(pyunits.W *1000)
+            #power_in_out = b.properties_out[t].power / (pyunits.W * 1000)
+            remaining_power = power_in_out + self.initial_SOC[t] * self.capacity[t]
+            return remaining_power >= 0
+    
+    def calculate_scaling_factors(self):
+        super().calculate_scaling_factors()
+    
+    def initialize(blk, *args, **kwargs):
+
+        for i in blk.properties_in.index_set():
+            if blk.initial_SOC[i].value == 0 and abs(blk.charging_power_out[i].value)> 0 and abs(blk.charging_power_in[i].value) == 0:
+                raise ConfigurationError(
+                    "Warning: There is no power to discharge in the battery."
+                )
+            if blk.charging_power_in[i].value > blk.capacity[i].value:
+                pass
+                #    raise ConfigurationError(
+                #     "Warning: Battery capacity is exceeded!"
+                # )       
+
+    def _get_stream_table_contents(self, time_point=0):
+        pass

ahuora_builder/custom/energy/tests/test_bus.py

@@ -0,0 +1,44 @@
+### Imports
+from pyomo.environ import ConcreteModel, SolverFactory, SolverStatus, TerminationCondition, Block, TransformationFactory, assert_optimal_termination
+from pyomo.network import SequentialDecomposition, Port, Arc
+from pyomo.core.base.units_container import _PyomoUnit, units 
+from idaes.core import FlowsheetBlock
+from idaes.core.util.model_statistics import report_statistics, degrees_of_freedom
+from idaes.core.util.tables import _get_state_from_port
+import idaes.logger as idaeslog
+from property_packages.build_package import build_package
+from idaes.models.unit_models.pressure_changer import Pump
+from idaes.models.unit_models.heater import Heater
+from ..power_property_package import PowerParameterBlock
+from ..bus import Bus
+from pyomo.environ import value
+
+def test_bus():
+    m = ConcreteModel()
+    m.fs = FlowsheetBlock(dynamic=False)
+    m.fs.power_property_package = PowerParameterBlock()
+
+    m.fs.bus = Bus(
+        property_package=m.fs.power_property_package,
+        num_inlets=2,
+        
+        
+        )
+    m.fs.bus.inlet_1.power.fix(100 * units.kW) 
+    m.fs.bus.inlet_2.power.fix(50 * units.kW)
+    
+
+    m.fs.bus.eq_power_balance.pprint()
+
+    #m.fs.bus.display()
+    
+    # Check that the model is fully specified
+    assert degrees_of_freedom(m.fs.bus) == 0 
+
+    # check that it solves correctly
+
+    solver = SolverFactory("ipopt")
+    solver.solve(m)
+    print(*"Post solve power:")
+
+    assert value(m.fs.bus.properties_out[0].power)- 150e3 == 0

ahuora_builder/custom/energy/tests/test_energy_mixer.py

@@ -0,0 +1,46 @@
+### Imports
+from pyomo.environ import ConcreteModel, SolverFactory, SolverStatus, TerminationCondition, Block, TransformationFactory, assert_optimal_termination
+from pyomo.network import SequentialDecomposition, Port, Arc
+from pyomo.core.base.units_container import _PyomoUnit, units 
+from idaes.core import FlowsheetBlock
+from idaes.core.util.model_statistics import report_statistics, degrees_of_freedom
+from idaes.core.util.tables import _get_state_from_port
+import idaes.logger as idaeslog
+from property_packages.build_package import build_package
+from idaes.models.unit_models.pressure_changer import Pump
+from idaes.models.unit_models.heater import Heater
+from ..energy_mixer import EnergyMixer
+from ..power_property_package import PowerParameterBlock
+from pyomo.environ import value
+
+
+def test_energy_mixer():
+    m = ConcreteModel()
+    m.fs = FlowsheetBlock()
+    m.fs.power_property_package = PowerParameterBlock()
+
+    m.fs.mixer = EnergyMixer(
+        property_package=m.fs.power_property_package,
+        num_inlets=3,
+        )
+        
+    
+    
+
+    m.fs.mixer.inlet_1.power.fix(100 * units.kW) 
+    m.fs.mixer.inlet_2.power.fix(1000 * units.W)
+    m.fs.mixer.inlet_3.power.fix(10 * units.kW)
+    m.fs.mixer.efficiency.fix(0.90)
+
+    # Check that the model is fully specified
+    assert degrees_of_freedom(m) == 0 
+
+    # check that it solves correctly
+
+    solver = SolverFactory("ipopt")
+    solver.solve(m)
+    #assert m.fs.mixer.outlet.power[0].value == 111 * units.kW
+    assert abs(m.fs.mixer.outlet.power[0].value - 999e2) < 1e-3
+    
+
+

ahuora_builder/custom/energy/tests/test_mdb.py

@@ -0,0 +1,49 @@
+### Imports
+from pyomo.environ import ConcreteModel, SolverFactory, SolverStatus, TerminationCondition, Block, TransformationFactory, assert_optimal_termination
+from pyomo.network import SequentialDecomposition, Port, Arc
+from pyomo.core.base.units_container import _PyomoUnit, units 
+from idaes.core import FlowsheetBlock
+from idaes.core.util.model_statistics import report_statistics, degrees_of_freedom
+from idaes.core.util.tables import _get_state_from_port
+import idaes.logger as idaeslog
+from property_packages.build_package import build_package
+from idaes.models.unit_models.pressure_changer import Pump
+from idaes.models.unit_models.heater import Heater
+from ..power_property_package import PowerParameterBlock
+from ..bus import Bus
+from ..mainDistributionBoard import MDB
+from pyomo.environ import value
+
+def test_mdb():
+    m = ConcreteModel()
+    m.fs = FlowsheetBlock(dynamic=False)
+    m.fs.power_property_package = PowerParameterBlock()
+    m.fs.mdb = MDB(
+        property_package=m.fs.power_property_package,
+        num_inlets=1,
+        num_outlets=3,
+        )
+    m.fs.mdb.inlet_1.power.fix(10 * units.kW)
+    m.fs.mdb.priorities[0,'outlet_1'].fix(5* units.kW)
+    m.fs.mdb.priorities[0,'outlet_2'].fix(3* units.kW)
+
+    
+    # Check that the model is fully specified
+    assert degrees_of_freedom(m.fs.mdb) == 0 
+
+    # check that it solves correctly
+    solver = SolverFactory("ipopt")
+    solver.solve(m)
+    assert abs(value(m.fs.mdb.outlet_3.power[0])) <= 2.0005e3 
+    
+    #Reduce input power and check that it doesn't give power to the last outlet:
+    m.fs.mdb.inlet_1.power.fix(8 * units.kW)
+    solver = SolverFactory("ipopt")
+    solver.solve(m)
+    assert abs(value(m.fs.mdb.outlet_3.power[0])) <= 0.0005
+
+    #Increase input power and check that it gives all excess power to the last outlet:
+    m.fs.mdb.inlet_1.power.fix(18 * units.kW)
+    solver = SolverFactory("ipopt")
+    solver.solve(m)
+    assert abs(value(m.fs.mdb.outlet_3.power[0])) <= 10.0005e3

ahuora_builder/custom/energy/transformer.py

@@ -0,0 +1,187 @@
+# 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.exceptions import ConfigurationError
+# Set up logger
+_log = idaeslog.getLogger(__name__)
+
+
+
+# When using this file the name "Transformer" is what is imported
+@declare_process_block_class("Transformer")
+class TransformerData(UnitModelBlockData):
+    """
+    Zero order Transformer 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 Transformer 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
+        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 ports - oftentimes users interact with these rather than the state blocks
+        self.add_port(name="inlet", block=self.properties_in)
+        self.add_port(name="outlet", block=self.properties_out)
+
+        # # Add variable for turns_ratio
+        # self.turns_ratio = Var(self.flowsheet().config.time,
+        #     initialize=1.0,
+        #     doc="Turns Ratio of the Transformer",
+        # )
+        # # Add variable for Load Resistance
+        # self.resistance = Var(self.flowsheet().config.time,
+        #     initialize=1.0,
+        #     doc="Load Resistance of the Transformer",
+        # )
+        self.n_capacity = Var(
+            self.flowsheet().config.time,
+            initialize=1.0,
+            units = pyunits.W,
+            doc="N Capacity of the Transformer",
+        )
+        self.voltage = Var(self.flowsheet().config.time,
+            initialize=1.0,
+            units = pyunits.V,
+            doc="Voltage Capacity of the Transformer",
+        )
+        self.efficiency = Var(self.flowsheet().config.time,
+            initialize=1.0,
+            units = pyunits.dimensionless,
+            doc="Efficiency of the Transformer",
+        )
+
+
+        # Add constraints
+        @self.Constraint(
+            self.flowsheet().time,
+            doc = "Power out",
+        )
+        def power_out(b, t):
+            return (
+                self.properties_out[t].power
+                == self.properties_in[t].power * self.efficiency[t]
+            )
+        
+        @self.Constraint(
+            self.flowsheet().time,
+            doc = "Capacity check",
+        )
+        def capacity_check(b,t):
+            return abs(self.properties_in[t].power) <= self.n_capacity[t]
+
+        # @self.Constraint(
+        #     self.flowsheet().time,
+        #     doc="Voltage out",
+        # )
+        # def voltage_out(b, t):
+        #     return (
+        #         b.properties_in[t].voltage * self.turns_ratio[t] == self.properties_out[t].voltage
+        #     )
+        # @self.Constraint(
+        #     self.flowsheet().time,
+        #     doc="Current out",
+        # )
+        # def current_out(b,t):
+        #     return(
+        #         self.properties_out[t].voltage / self.resistance[t] == self.properties_out[t].current
+        #     )
+
+    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 i in blk.properties_in.index_set():
+            if not blk.properties_out[i].power.fixed:
+                blk.properties_out[i].power = blk.properties_in[i].power.value
+            
+            if abs(blk.properties_in[i].power.value) > blk.n_capacity[i].value:
+                 raise ConfigurationError(
+                    "Danger: Input power exceeds transformer capacity. Please either increase capacity or lower input power."
+                )