ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/solver.py

@@ -0,0 +1,38 @@
+from typing import Optional
+from pydantic import BaseModel
+from ahuora_builder_types import FlowsheetSchema
+from ahuora_builder_types.flowsheet_schema import SolvedFlowsheetSchema
+from ahuora_builder_types.payloads.solve_request_schema import IdaesSolveRequestPayload
+from .flowsheet_manager import FlowsheetManager
+
+
+class SolveModelResult(BaseModel):
+    input_flowsheet: FlowsheetSchema
+    output_flowsheet: SolvedFlowsheetSchema
+    solve_index: Optional[int] = None
+    scenario_id: Optional[int] = None
+    task_id: int
+    timing: dict
+
+def solve_model(solve_request: IdaesSolveRequestPayload) -> SolveModelResult:
+    """Solves the model and returns the results"""
+    flowsheet = FlowsheetManager(solve_request.flowsheet)
+    #print(solve_request.flowsheet.model_dump_json())
+    flowsheet.load()
+    flowsheet.initialise()
+    flowsheet.report_statistics()
+    if solve_request.perform_diagnostics:
+        flowsheet.diagnose_problems()
+    flowsheet.check_model_valid()
+    flowsheet.solve()
+    flowsheet.optimize()
+    result = flowsheet.serialise()
+
+    return SolveModelResult(
+        input_flowsheet=solve_request.flowsheet,
+        output_flowsheet=result,
+        solve_index=solve_request.solve_index,
+        scenario_id=solve_request.scenario_id,
+        task_id=solve_request.task_id,
+        timing=flowsheet.timing.close()
+    )

ahuora_builder/tear_manager.py

@@ -0,0 +1,98 @@
+from pyomo.environ import value
+from pyomo.network import Arc
+from idaes.core.util.tables import _get_state_from_port
+from pyomo.core.base.expression import ScalarExpression
+from ahuora_builder_types.arc_schema import TearGuessSchema
+from .flowsheet_manager_type import FlowsheetManager
+from ahuora_builder_types import PortId
+from .methods.adapter import fix_var
+
+
+class TearManager:
+    """
+    Manages the tears in the flowsheet
+    """
+
+    def __init__(self, flowsheet_manager: FlowsheetManager):
+        """
+        Create a new tear manager
+        """
+        self._flowsheet_manager = flowsheet_manager
+        self._tears: list[Arc] = []
+
+    def load(self):
+        """
+        Load all the tears (from the recycle unitops)
+        """
+        schema = self._flowsheet_manager.schema
+
+        for arc_schema in schema.arcs:
+            if arc_schema.tear_guess:
+                self.add_tear(arc_schema)
+
+    def add_tear(self, arc_schema):
+        """
+        Add a tear to the flowsheet
+        """
+        portId = arc_schema.destination
+        guess = arc_schema.tear_guess
+
+        port = self._flowsheet_manager.ports.get_port(portId)
+        arc = port.arcs()[0]
+        self._tears.append(arc)
+
+        """
+        During model loading, we add in all the constraints and fix the variables
+        for this port. Since it is a tear, things need to be deactivated/unfixed
+        to ensure 0 degrees of freedom
+
+        If the state block is defined by constraints, we need to solve it to get the
+        correct values for the state variables. Then we deactivate the constraints
+        since we will be fixing the state variables instead (where applicable).
+        """
+        
+        # hardcoding time indexes to [0] for now
+        time_indexes = [0]
+
+        # need to get the correct value for state variables before running
+        # sequential decomposition (since all state variables are fixed
+        # during sequential decomposition).
+        sb = _get_state_from_port(port, time_indexes[0])
+        # deactivate any guesses
+        for key, value in guess.items():
+            var = getattr(sb, key)
+            if value != True:
+                if isinstance(var,ScalarExpression):
+                    pass # we want to solve with constraints
+                else:
+                    # this might give too few dof if we have other constraints. We need to unfix
+                    # this value
+                    var.unfix()
+
+        if len(list(sb.constraints.component_objects())) > 0:
+            # state block is defined by some constraints, so we need to solve it.
+            # initialize the state block, which should put the correct value in
+            # the state variables
+            sb.parent_component().initialize()
+            # deactivate the state block constraints, since we should use the
+            # state variables as guesses (or fix them instead)
+            sb.constraints.deactivate()
+
+        blk = sb.parent_component()
+        for key in sb.define_state_vars():
+            if guess.get(key, False):
+                # deactivate the equality constraint (expanded arcs)
+                expanded_arc = getattr(
+                    self._flowsheet_manager.model.fs, arc._name + "_expanded"
+                )
+                equality_constraint = getattr(expanded_arc, key + "_equality")
+                equality_constraint.deactivate()
+
+                # fix the variable
+                for b in blk.values():
+                    getattr(b, key).fix()
+
+            else:
+                # unfix this variable
+                for b in blk.values():
+                    getattr(b, key).unfix()

ahuora_builder/tests/test_generate_python_file/configurations/compressor_generated.py

@@ -0,0 +1,63 @@
+### 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 as pyomo_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 ahuora_builder.custom.custom_compressor import CustomCompressor
+
+
+### Utility Methods
+def units(item: str) -> _PyomoUnit:
+    ureg = pyomo_units._pint_registry
+    pint_unit = getattr(ureg, item)
+    return _PyomoUnit(pint_unit, ureg)
+
+
+### Build Model
+m = ConcreteModel()
+m.fs = FlowsheetBlock(dynamic=False)
+
+# Set up property packages
+m.fs.PP__1 = build_package(
+    "helmholtz",
+    ["h2o"],
+)
+
+# Create unit models
+
+# Compressor-1
+m.fs.Compressor_1 = CustomCompressor(
+    property_package=m.fs.PP__1,
+    power_property_package=m.fs.power_property_package,
+    dynamic=False
+)
+m.fs.Compressor_1.deltaP.fix(50000.0 * units("Pa"))
+m.fs.Compressor_1.efficiency_isentropic.fix(0.9 * units("None"))
+sb = _get_state_from_port(m.fs.Compressor_1.inlet, 0)
+sb.constrain_component(sb.pressure, 101325.0 * units("Pa"))
+sb.constrain_component(sb.enth_mol, 4000.0 * units("J/mol"))
+sb.constrain_component(sb.flow_mol, 100.0 * units("mol/s"))
+sb.constrain_component(sb.mole_frac_comp[('h2o',)], 1.0 * units("None"))
+
+
+### Check Model Status
+report_statistics(m)
+print("Degrees of freedom:", degrees_of_freedom(m))
+
+
+### Initialize Model
+m.fs.Compressor_1.initialize(outlvl=idaeslog.INFO)
+
+
+### Solve
+opt = SolverFactory("ipopt")
+res = opt.solve(m, tee=True)
+assert_optimal_termination(res)
+
+
+### Report
+m.fs.Compressor_1.report()

ahuora_builder/tests/test_generate_python_file/configurations/heat_exchanger_generated.py

@@ -0,0 +1,70 @@
+### 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 as pyomo_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 idaes.models.unit_models.heat_exchanger import delta_temperature_underwood_callback
+from property_packages.build_package import build_package
+from ahuora_builder.custom.custom_heat_exchanger import CustomHeatExchanger
+
+
+### Utility Methods
+def units(item: str) -> _PyomoUnit:
+    ureg = pyomo_units._pint_registry
+    pint_unit = getattr(ureg, item)
+    return _PyomoUnit(pint_unit, ureg)
+
+
+### Build Model
+m = ConcreteModel()
+m.fs = FlowsheetBlock(dynamic=False)
+
+# Set up property packages
+m.fs.PP__1 = build_package(
+    "helmholtz",
+    ["h2o"],
+)
+
+# Create unit models
+
+# heat_exchanger-1
+m.fs.heat_exchanger_1 = CustomHeatExchanger(
+    delta_temperature_callback=delta_temperature_underwood_callback,
+    hot_side={"property_package": m.fs.PP__1,"has_pressure_change": True},
+    cold_side={"property_package": m.fs.PP__1,"has_pressure_change": True},
+    dynamic=False
+)
+m.fs.heat_exchanger_1.overall_heat_transfer_coefficient.fix(100.0 * units("W/(m**2*K)"))
+m.fs.heat_exchanger_1.area.fix(1000.0 * units("m**2"))
+m.fs.heat_exchanger_1.hot_side.deltaP.fix(100.0 * units("Pa"))
+m.fs.heat_exchanger_1.cold_side.deltaP.fix(100.0 * units("Pa"))
+sb = _get_state_from_port(m.fs.heat_exchanger_1.hot_side_inlet, 0)
+sb.constrain_component(sb.pressure, 101325.0 * units("Pa"))
+sb.constrain_component(sb.enth_mol, 40000.0 * units("J/mol"))
+sb.constrain_component(sb.flow_mol, 100.0 * units("mol/s"))
+sb = _get_state_from_port(m.fs.heat_exchanger_1.cold_side_inlet, 0)
+sb.constrain_component(sb.pressure, 101325.0 * units("Pa"))
+sb.constrain_component(sb.enth_mol, 30000.0 * units("J/mol"))
+sb.constrain_component(sb.flow_mol, 100.0 * units("mol/s"))
+
+
+### Check Model Status
+report_statistics(m)
+print("Degrees of freedom:", degrees_of_freedom(m))
+
+
+### Initialize Model
+m.fs.heat_exchanger_1.initialize(outlvl=idaeslog.INFO)
+
+
+### Solve
+opt = SolverFactory("ipopt")
+res = opt.solve(m, tee=True)
+assert_optimal_termination(res)
+
+
+### Report
+m.fs.heat_exchanger_1.report()

ahuora_builder/tests/test_generate_python_file/configurations/pump_generated.py

@@ -0,0 +1,84 @@
+### 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 as pyomo_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 ahuora_builder.custom.custom_pump import CustomPump
+from ahuora_builder.custom.custom_heater import DynamicHeater
+
+
+### Utility Methods
+def units(item: str) -> _PyomoUnit:
+    ureg = pyomo_units._pint_registry
+    pint_unit = getattr(ureg, item)
+    return _PyomoUnit(pint_unit, ureg)
+
+def init_unit(unit: Block) -> None:
+    unit.initialize(outlvl=idaeslog.INFO)
+
+
+### Build Model
+m = ConcreteModel()
+m.fs = FlowsheetBlock(dynamic=False)
+
+# Set up property packages
+m.fs.PP__1 = build_package(
+    "helmholtz",
+    ["h2o"],
+)
+
+# Create unit models
+
+# Pump-1
+m.fs.Pump_1 = CustomPump(
+    property_package=m.fs.PP__1,
+    dynamic=False,
+    power_property_package=m.fs.power_property_package
+)
+m.fs.Pump_1.efficiency_pump.fix(0.8 * units("dimensionless"))
+sb = _get_state_from_port(m.fs.Pump_1.inlet, 0)
+sb.constrain_component(sb.pressure, 11000000.0 * units("Pa"))
+sb.constrain_component(sb.enth_mol, 125.0 * units("J/mol"))
+sb.constrain_component(sb.flow_mol, 431.0 * units("mol/s"))
+sb = _get_state_from_port(m.fs.Pump_1.outlet, 0)
+sb.constrain_component(sb.pressure, 22000000.0 * units("Pa"))
+
+# Heater-1
+m.fs.Heater_1 = DynamicHeater(
+    property_package=m.fs.PP__1,
+    has_pressure_change=None,
+    dynamic=None,
+    has_holdup=None
+)
+m.fs.Heater_1.heat_duty.fix(100.0 * units("J/s"))
+
+
+### Connect Unit Models
+m.fs.arc_1 = Arc(source=m.fs.Pump_1.outlet, destination=m.fs.Heater_1.inlet)
+
+
+### Check Model Status
+report_statistics(m)
+print("Degrees of freedom:", degrees_of_freedom(m))
+
+
+### Initialize Model
+TransformationFactory("network.expand_arcs").apply_to(m)
+seq = SequentialDecomposition()
+seq.set_tear_set([])
+seq.run(m, init_unit)
+
+
+### Solve
+opt = SolverFactory("ipopt")
+res = opt.solve(m, tee=True)
+assert_optimal_termination(res)
+
+
+### Report
+m.fs.Pump_1.report()
+m.fs.Heater_1.report()

ahuora_builder/tests/test_generate_python_file/configurations/recycle_generated.py

@@ -0,0 +1,73 @@
+### 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 as pyomo_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 ahuora_builder.custom.custom_compressor import CustomCompressor
+
+
+### Utility Methods
+def units(item: str) -> _PyomoUnit:
+    ureg = pyomo_units._pint_registry
+    pint_unit = getattr(ureg, item)
+    return _PyomoUnit(pint_unit, ureg)
+
+def init_unit(unit: Block) -> None:
+    unit.initialize(outlvl=idaeslog.INFO)
+
+
+### Build Model
+m = ConcreteModel()
+m.fs = FlowsheetBlock(dynamic=False)
+
+# Set up property packages
+m.fs.PP__1 = build_package(
+    "helmholtz",
+    ["h2o"],
+)
+
+# Create unit models
+
+# Compressor-1
+m.fs.Compressor_1 = CustomCompressor(
+    property_package=m.fs.PP__1,
+    power_property_package=m.fs.power_property_package,
+    dynamic=False
+)
+m.fs.Compressor_1.efficiency_isentropic.fix(1.0 * units("dimensionless"))
+sb = _get_state_from_port(m.fs.Compressor_1.inlet, 0)
+sb.constrain_component(sb.flow_mol, 1.0 * units("mol/s"))
+sb.constrain_component(sb.pressure, 105.0 * units("kPa"))
+sb.constrain_component(sb.enth_mol, 10.541 * units("J/mol"))
+sb = _get_state_from_port(m.fs.Compressor_1.outlet, 0)
+sb.constrain_component(sb.pressure, 110.0 * units("kPa"))
+
+
+### Connect Unit Models
+m.fs.arc_1 = Arc(source=m.fs.Compressor_1.outlet, destination=m.fs.Compressor_1.inlet)
+
+
+### Check Model Status
+report_statistics(m)
+print("Degrees of freedom:", degrees_of_freedom(m))
+
+
+### Initialize Model
+TransformationFactory("network.expand_arcs").apply_to(m)
+seq = SequentialDecomposition()
+seq.set_tear_set([])
+seq.run(m, init_unit)
+
+
+### Solve
+opt = SolverFactory("ipopt")
+res = opt.solve(m, tee=True)
+assert_optimal_termination(res)
+
+
+### Report
+m.fs.Compressor_1.report()

ahuora_builder/tests/test_generate_python_file/test_generate_python_file.py

@@ -0,0 +1,108 @@
+from idaes.models.unit_models import Compressor, Heater
+from idaes.models.unit_models.heat_exchanger import delta_temperature_underwood_callback
+
+from ahuora_builder_types import FlowsheetSchema
+from ...generate_python_file import generate_python_code, PythonFileGenerator
+
+GENERATE_TESTS = False
+
+def test_generate_is_false():
+    assert GENERATE_TESTS is False, "test_generate_python_file.py:  GENERATE_TESTS should be False to avoid overriding test_solved.json files during tests."
+
+
+def test_import():
+    generator = PythonFileGenerator({})
+    heater_name, heater_import = generator.resolve_import(Heater)
+    assert heater_name == "Heater"
+    assert heater_import == "from idaes.models.unit_models.heater import Heater"
+    compressor_name, compressor_import = generator.resolve_import(Compressor)
+    assert compressor_name == "Compressor"
+    assert compressor_import == "from idaes.models.unit_models.pressure_changer import Compressor"
+    delta_t_name, delta_t_import = generator.resolve_import(delta_temperature_underwood_callback)
+    assert delta_t_name == "delta_temperature_underwood_callback"
+    assert delta_t_import == "from idaes.models.unit_models.heat_exchanger import delta_temperature_underwood_callback"
+
+
+def test_names():
+    # names need to be converted to valid python variable names
+    generator = PythonFileGenerator({})
+    def check_name(name: str, expected: str):
+        # starts with m.fs.
+        assert generator.get_name(name) == f"m.fs.{expected}"
+    check_name("Pump-1", "Pump_1")
+    check_name("Heater-1", "Heater_1")
+    check_name("heat_exchanger-1", "heat_exchanger_1")
+    check_name("name with spaces", "name_with_spaces")
+    check_name("name-with-dashes", "name_with_dashes")
+    check_name("name_with_underscores", "name_with_underscores")
+    check_name("name_with_123_numbers", "name_with_123_numbers")
+    check_name("123_numbers_at_start", "_123_numbers_at_start")
+    check_name("name_with_!@#$%^&*()_special_characters", "name_with__special_characters")
+    check_name("", "_unnamed_unit")
+    check_name(" ", "_unnamed_unit")
+    check_name("1", "_1")
+    check_name(",", "_unnamed_unit")
+    
+
+def run_generate(input_file: str, expected_file: str) -> None:
+    import os
+    import json
+
+    with open(os.path.join(os.path.dirname(__file__), input_file), "r") as f:
+        flowsheet = json.load(f)
+        flowsheet = FlowsheetSchema.model_validate(flowsheet)
+    
+    result = generate_python_code(flowsheet)
+
+    # # write result to a file for debugging - or to regenerate expected files
+    if GENERATE_TESTS:
+        with open(os.path.join(os.path.dirname(__file__), expected_file), "w") as f:
+            f.write(result)
+
+
+    # split result line by line to compare each line
+    lines = result.split("\n")
+
+    with open(os.path.join(os.path.dirname(__file__), expected_file), "r") as f:
+        expected_lines = f.readlines()
+    
+    # compare each line of the result with the expected file
+    i = 0
+    while len(lines) > 0 and len(expected_lines) > 0:
+        # skip empty lines
+        while len(lines) > 0 and lines[0].strip() == "":
+            lines.pop(0)
+        while len(expected_lines) > 0 and expected_lines[0].strip() == "":
+            i += 1
+            expected_lines.pop(0)
+        if len(lines) == 0:
+            assert len(expected_lines) == 0, f"Expected '{expected_lines[0]}'"
+            break
+        if len(expected_lines) == 0:
+            assert len(lines) == 0, f"Got '{lines[0]}'"
+            break
+        # compare lines
+        i += 1
+        line = lines.pop(0).strip()
+        expected_line = expected_lines.pop(0).strip()
+        assert line == expected_line, f"Line {str(i)}: Expected '{expected_line}', got '{line}'"
+
+
+def test_compressor():
+    # basic test
+    run_generate("../test_solver/configurations/compressor.json", "configurations/compressor_generated.py")
+
+
+def test_heat_exchanger():
+    # tests a few more features (constants, dictionaries)
+    run_generate("../test_solver/configurations/heat_exchanger.json", "configurations/heat_exchanger_generated.py")
+
+
+def test_pump_and_heater():
+    # tests connected components
+    run_generate("../test_solver/configurations/pump.json", "configurations/pump_generated.py")
+
+
+def test_recycle():
+    # tests tears
+    run_generate("../test_solver/configurations/recycle.json", "configurations/recycle_generated.py")

ahuora_builder/tests/test_solver/configurations/BT_PR.json

@@ -0,0 +1,59 @@
+{
+    "id": 0,
+    "name": "BT_PR test",
+    "description": "Peng-Robinson test with Benzene and Toluene",
+    "dynamic": false,
+    "property_packages": [
+        {
+            "id": 1,
+            "compounds":["benzene", "toluene"],
+            "type":"peng-robinson",
+            "phases":["Vap", "Liq"]
+        }
+    ],
+    "unit_models": [
+        {
+            "id": 9,
+            "type": "heater",
+            "name": "Heater-1",
+            "args": {
+                "property_package": 1
+            },
+            "properties": {
+                "heat_duty": { "data": [  { "id": 1, "value": 200000 } ], "unit": "W" }
+            },
+            "ports": {
+                "inlet": {
+                    "id": 1,
+                    "properties": {
+                        "flow_mol": { "data": [  { "id": 2, "value": 431 } ], "unit": "mol/s" },
+                        "mole_frac_comp": {
+                            "data": [ 
+                                 {
+                                    "discrete_indexes":["benzene"],
+                                        "id": 3,
+                                        "value": 0.8
+                                    },
+                                     {
+                                        "discrete_indexes":["toluene"],
+                                        "id": 4,
+                                        "value": 0.2
+                                    }
+                                
+                            ],
+                            "unit": null
+                        },
+                        "pressure": { "data": [  { "id": 5, "value": 101325 } ], "unit": "Pa" },
+                        "temperature": { "data": [  { "id": 6, "value": 303.2 } ], "unit": "K" }
+                    }
+                },
+                "outlet": {
+                    "id": 4,
+                    "properties": {}
+                }
+            }
+        }
+    ],
+    "arcs": [
+    ]
+}

ahuora_builder/tests/test_solver/configurations/BT_PR_solved.json

@@ -0,0 +1,59 @@
+{
+    "id": 0,
+    "properties": [
+        {
+            "id": 1,
+            "name": "fs.Heater-1_9.control_volume.heat[0.0]",
+            "value": [
+                200000.0
+            ],
+            "unit": "kg*m**2/s**3",
+            "unknown_units": false
+        },
+        {
+            "id": 2,
+            "name": "fs.Heater-1_9.control_volume.properties_in[0.0].flow_mol",
+            "value": [
+                431.0
+            ],
+            "unit": "mol/s",
+            "unknown_units": false
+        },
+        {
+            "id": 3,
+            "name": "fs.Heater-1_9.control_volume.properties_in[0.0].mole_frac_comp[benzene]",
+            "value": [
+                0.8
+            ],
+            "unit": "dimensionless",
+            "unknown_units": false
+        },
+        {
+            "id": 4,
+            "name": "fs.Heater-1_9.control_volume.properties_in[0.0].mole_frac_comp[toluene]",
+            "value": [
+                0.2
+            ],
+            "unit": "dimensionless",
+            "unknown_units": false
+        },
+        {
+            "id": 5,
+            "name": "fs.Heater-1_9.control_volume.properties_in[0.0].pressure",
+            "value": [
+                101325.0
+            ],
+            "unit": "kg/m/s**2",
+            "unknown_units": false
+        },
+        {
+            "id": 6,
+            "name": "fs.Heater-1_9.control_volume.properties_in[0.0].temperature",
+            "value": [
+                303.2
+            ],
+            "unit": "K",
+            "unknown_units": false
+        }
+    ]
+}