ahuora-builder 0.1.0__py3-none-any.whl

ahuora_builder/methods/expression_parsing.py

@@ -0,0 +1,105 @@
+from typing import Any
+from pyomo.environ import Expression
+from pyomo.core.base.units_container import units as pyomo_units, _PyomoUnit
+from sympy import Symbol
+from sympy.parsing.sympy_parser import parse_expr
+from pyomo.core.expr.sympy_tools import sympy2pyomo_expression, PyomoSympyBimap
+from pyomo.core.base.indexed_component import IndexedComponent
+from ahuora_builder.properties_manager import PropertiesManager
+from .slice_manipulation import is_scalar_reference
+class ExpressionParsingError(Exception):
+    """Custom exception for errors during expression parsing."""
+    pass
+
+# add extra units to pyomo's units library
+# could probably make this on-demand
+ureg = pyomo_units._pint_registry
+ureg.define("dollar = [currency]")
+
+
+def handle_special_chars(expr: str) -> str:
+    # replace special characters so they can be parsed
+    expr = expr.replace("^", "**")
+    expr = expr.replace("$", "dollar")
+
+    return expr
+
+
+def get_property_from_id(fs, property_id,time_index):
+    # returns a pyomo var from a property id
+    properties_map : PropertiesManager = fs.properties_map
+    pyomo_object: IndexedComponent = properties_map.get_component(property_id)
+    
+    if pyomo_object is None:
+        raise ValueError(f"Symbol with id {id} not found in model")
+    # check if this is a time-indexed var, and if so get the value at the given time index
+    if is_scalar_reference(pyomo_object):
+        # reference with index None
+        return pyomo_object[None]
+    elif pyomo_object.index_set() == fs.time:
+        return pyomo_object[time_index]
+    else:
+        raise NotImplementedError("Only 0D and 1D time-indexed properties are supported in expressions")
+
+
+def evaluate_symbol(fs, symbol: str,time_index) -> Any:
+    if symbol.lower() == "time" or symbol.lower() == "t":
+        return float(time_index)
+    if symbol.startswith("id_"):
+        # get the property from flowsheet properties_map
+        id = int(symbol[3:])
+        return get_property_from_id(fs, id,time_index)
+    else:
+        # assume its a unit, eg. "m" or "kg"
+        # get the unit from pint, pyomo's units library
+        ureg = pyomo_units._pint_registry
+        pint_unit = getattr(ureg, symbol)
+        pyomo_unit = _PyomoUnit(pint_unit, ureg)
+        # We want people to write expressions such as (10 * W + 5 * kW). Pyomo doesn't natively support this,
+        # so we can always convert to base units.
+        if symbol == "delta_degC" or symbol == "delta_degF":
+            # special case, because degC is not a base unit
+            return 1 * pyomo_unit
+            #return _PyomoUnit(ureg.delta_degC)
+        elif symbol == "degC" or symbol == "degF":
+            # throw an error (we do not support this, as it is unclear what to do)
+            # https://pyomo.readthedocs.io/en/6.8.1/explanation/modeling/units.html
+            raise ValueError(f"Use relative temperature units (delta_degC, delta_degF) or absolute temperature units (K, degF). Cannot use {symbol} as addition and multiplication is inconsistent on non-absolute units")
+        scale_factor, base_units = ureg.get_base_units(pint_unit, check_nonmult=True) # TODO: handle degC etc.
+        base_pyomo_unit = _PyomoUnit(base_units, ureg)
+        return pyomo_units.convert( 1 * pyomo_unit, to_units=base_pyomo_unit)
+
+
+class PyomoSympyMap(PyomoSympyBimap):
+
+    def __init__(self, model,time_index):
+        self.model = model
+        self.time_index = time_index
+
+    def getPyomoSymbol(self, sympy_object: Symbol, default=None):
+        if not isinstance(sympy_object, Symbol):
+            return None  # It's not in pyomo, e.g a number or something
+        return evaluate_symbol(self.model, sympy_object.name, self.time_index)
+
+    def getSympySymbol(self, pyomo_object, default=None):
+        raise NotImplementedError(
+            "getSympySymbol not implemented, because it shouldn't be needed"
+        )
+        # we don't care, it only needs to go one way
+
+    def sympyVars(self):
+        raise NotImplementedError(
+            "sympyVars not implemented, because it shouldn't be needed"
+        )
+
+
+def parse_expression(expression, model,time_index) -> Expression:
+    # use the bimap to get the correct pyomo object for each symbol
+    bimap = PyomoSympyMap(model,time_index)
+    try:
+        expression = handle_special_chars(expression)
+        sympy_expr = parse_expr(expression)
+        pyomo_expr = sympy2pyomo_expression(sympy_expr, bimap)
+    except Exception as e:
+        raise ExpressionParsingError(f"{expression}: error: {e}")
+    return pyomo_expr

ahuora_builder/methods/load_unit_model.py

@@ -0,0 +1,147 @@
+from typing import Any
+
+from pyomo.network import Port
+from pyomo.environ import value as pyo_value, Var
+from pyomo.core.base.constraint import ScalarConstraint
+from pyomo.core.base.units_container import units
+from idaes.core import UnitModelBlock
+from idaes.core.util.tables import _get_state_from_port
+from idaes.core.util.model_serializer import StoreSpec, from_json
+
+from ahuora_builder.methods.BlockContext import BlockContext
+from .adapter_library import UnitModelConstructor
+from ..flowsheet_manager_type import FlowsheetManager
+from ahuora_builder_types import  UnitModelSchema
+from .adapter import fix_block
+from ahuora_builder.methods.adapter import get_component
+
+def add_unit_model_to_flowsheet(
+    unit_model_def: UnitModelSchema,
+    adapter_constructor: UnitModelConstructor,
+    flowsheet_manager: FlowsheetManager,
+) -> UnitModelBlock: 
+    """
+    Add the unit model to the flowsheet.
+    Args:
+        unit_model_def: The definition of the unit model to be added to the flowsheet.
+        adapter_schema: Methods used to create the model and parse the arguments.
+        flowsheet_manager: Flowsheet manager to interact with the flowsheet.
+    """
+    # Create the model
+    idaes_model: UnitModelBlock =_create_model(unit_model_def, adapter_constructor, flowsheet_manager)
+
+    # Add the model to the flowsheet
+    component_name = f"{unit_model_def.name}_{unit_model_def.id}"
+    flowsheet_manager.model.fs.add_component(component_name, idaes_model)
+
+    # Import initial guesses
+    initial_values = unit_model_def.initial_values
+
+    if initial_values:
+        from_json(idaes_model, initial_values, wts=StoreSpec.value())
+    
+    # Fix properties
+    block_context = BlockContext(flowsheet_manager.model.fs)
+    _fix_properties(idaes_model,unit_model_def, flowsheet_manager,block_context)
+    # Fix ports
+    _fix_ports(idaes_model, unit_model_def, flowsheet_manager,block_context)
+    # Apply degrees of freedom (add constraints for controlled vars)
+    block_context.apply_elimination()
+    return idaes_model
+
+def _create_model(unit_model_def : UnitModelSchema,adapter_constructor: UnitModelConstructor,flowsheet_manager : FlowsheetManager) -> UnitModelBlock:
+    """
+    Create the kwargs for the model constructor from the unit model definition.
+    """
+    arg_parsers = adapter_constructor.arg_parsers
+    args = unit_model_def.args
+
+    kwargs : dict[str, Any] = {}
+    for name in args:
+        if not name in arg_parsers:
+            raise ValueError(
+                f"Argument {name} not found in model schema, available arguments are {[x for x in arg_parsers.keys()]}"
+            )
+    for name in arg_parsers:
+        register = arg_parsers[name]
+        # try to get the argument from the schema passed in
+        # however, in some cases the argument may not be required
+        # i.e when specified by the model adapter itself
+        # e.g methods.constant
+
+        # note that in the future we may have to support passing
+        # optional arguments to the model constructor
+        result = register.run(args.get(name, None),flowsheet_manager)
+        kwargs[name] = result
+
+    idaes_model = adapter_constructor.model_constructor(**kwargs)
+    return idaes_model
+
+def _fix_properties( unit_model: UnitModelBlock, unit_model_def: UnitModelSchema, flowsheet_manager : FlowsheetManager,block_context: BlockContext) -> None:
+        """
+        Fix the properties of the unit model based on the properties in the unit model definition.
+        """
+        # Loop through the properties in the unit model definition to fix the properties in the unit model
+        properties = unit_model_def.properties
+        fix_block(
+            unit_model, properties, flowsheet_manager.model.fs, block_context
+        )
+
+
+def _fix_ports(unit_model: UnitModelBlock, unit_model_def: UnitModelSchema, flowsheet_manager:FlowsheetManager,block_context: BlockContext) -> None:
+        """
+        Fix the ports of the unit model based on the ports in the unit model definition.
+        """
+        # Loop through the ports in the unit model definition to fix the ports in the unit model
+        for port_name, port_schema in unit_model_def.ports.items():
+            # Get the port from the unit model
+            port = get_component(unit_model, port_name)
+            if not isinstance(port, Port):
+                raise ValueError(f"Port {port_name} not found in model")
+            # Register the port, so arcs can connect to it by id
+            flowsheet_manager.ports.register_port(port_schema.id, port)
+            # Set the port parameters
+            sb = _get_state_from_port(port, 0)
+            state_block = sb.parent_component()
+
+            # Prefer time-only properties_in/properties_out if available
+            # decide by port name containing "inlet"/"outlet" and "hot"/"cold"
+            pn = port_name.lower()
+            if "inlet" in pn:
+                if "hot" in pn and hasattr(unit_model, "hot_side") and hasattr(unit_model.hot_side, "properties_in"):
+                    state_block = unit_model.hot_side.properties_in
+                elif "cold" in pn and hasattr(unit_model, "cold_side") and hasattr(unit_model.cold_side, "properties_in"):
+                    state_block = unit_model.cold_side.properties_in
+            elif "outlet" in pn:
+                if "hot" in pn and hasattr(unit_model, "hot_side") and hasattr(unit_model.hot_side, "properties_out"):
+                    state_block = unit_model.hot_side.properties_out
+                elif "cold" in pn and hasattr(unit_model, "cold_side") and hasattr(unit_model.cold_side, "properties_out"):
+                    state_block = unit_model.cold_side.properties_out
+
+            if sb.config.defined_state:
+                """
+                ie. Inlet state.
+
+                The inlet state needs a separate context, because its variables
+                are all fixed during initialization, so applying elimination
+                involving variables outside the inlet state would run into
+                degrees of freedom issues.
+                """
+                inlet_ctx = BlockContext(flowsheet_manager.model.fs)
+                fix_block(
+                    state_block,
+                    port_schema.properties,
+                    flowsheet_manager.model.fs,
+                    inlet_ctx,
+                )
+                inlet_ctx.apply_elimination()
+            else:
+                # The outlet state(s) can use the unit model context.
+                fix_block(
+                    state_block,
+                    port_schema.properties,
+                    flowsheet_manager.model.fs,
+                    block_context,
+                )
+
+    

ahuora_builder/methods/slice_manipulation.py

@@ -0,0 +1,7 @@
+from pyomo.core.base.indexed_component import UnindexedComponent_set, IndexedComponent
+
+
+
+def is_scalar_reference(component: IndexedComponent) -> bool:
+    # The only key in it should be None
+    return list(component) == [None]

ahuora_builder/methods/tests/test_expression_parsing.py

@@ -0,0 +1,15 @@
+from pyomo.environ import ConcreteModel, Var, value, Reference
+from ..expression_parsing import parse_expression
+from ...properties_manager import PropertiesManager
+
+
+def test_parse_expression():
+    m = ConcreteModel()
+    m.x = Var(initialize=2)
+    m.properties_map = PropertiesManager()
+    m.properties_map.add(
+        123, Reference(m.x), "m.x"
+    )
+
+    expr = parse_expression("id_123 + 2", m,1)
+    assert value(expr) == 4

ahuora_builder/methods/units_handler.py

@@ -0,0 +1,129 @@
+from typing import Any, cast, NewType
+from pyomo.environ import value
+from pyomo.core.base.units_container import units, _PyomoUnit
+from pyomo.core.base.var import Var
+from pyomo.core.base.expression import Expression, ExpressionData
+from pyomo.core.expr import ExpressionBase, NPV_ProductExpression
+from pint import UnitRegistry
+
+ValueWithUnits = NewType("ValueWithUnits", NPV_ProductExpression)
+
+
+def _get_pint_unit(unit: str) -> Any:
+    """
+    Get the pint unit object
+    """
+    pint_unit = getattr(units.pint_registry, unit, None)
+    if pint_unit is None:
+        raise AttributeError(f"Unit `{unit}` not found.")
+    return pint_unit
+
+
+def get_unit(unit: str) -> _PyomoUnit:
+    """
+    Get the pint unit object
+    @unit: str unit type
+    @return: unit object
+    """
+    return _PyomoUnit(_get_pint_unit(unit), units.pint_registry)
+
+
+def attach_unit(value: float, unit: str | None) -> ValueWithUnits:
+    """
+    Attach the unit to the value
+    @value: float value
+    @unit: str unit
+    @return: value with unit attached
+    """
+    value, unit = idaes_specific_convert(
+        value, unit
+    )  # make sure the value is in a unit that idaes supports
+    if unit is None:
+        return value
+    pyomo_unit = get_unit(unit)
+    return value * pyomo_unit
+
+
+def check_units_equivalent(unit1: _PyomoUnit, unit2: _PyomoUnit) -> bool:
+    """
+    Check if two units are equivalent
+    """
+    if unit1 is None:
+        unit1 = units.dimensionless
+    if unit2 is None:
+        unit2 = units.dimensionless
+    return (
+        unit1._get_pint_unit().dimensionality
+        == unit2._get_pint_unit().dimensionality
+    )
+
+
+
+def idaes_specific_convert(value: float, unit: str | None) -> tuple[float, str | None]:
+    """
+    Convert the value to a unit that is specific to idaes
+    (ie. idaes only supports K for temperature)
+    @value: float value
+    @unit: str unit
+    @return: tuple:
+        - (float) converted value
+        - (str) new unit
+    """
+    if unit in ["degC", "degR", "degF"]:  # temperature units
+        from_quantity = units.pint_registry.Quantity(value, unit)
+        to_unit = units.pint_registry.K
+        # can probably do the conversion/attachment in one step but haven't figured out how yet
+        converted_value = from_quantity.to(to_unit)  # pint.Quantity object
+        return converted_value.magnitude, "K"
+    if unit in ["percent"]:  # dimensionless units
+        from_quantity = units.pint_registry.Quantity(value, unit)
+        to_unit = units.pint_registry.dimensionless
+        converted_value = from_quantity.to(to_unit)
+        return converted_value.magnitude, None
+    if unit in [None, ""]:
+        return value, None
+    return value, unit
+
+
+def get_attached_unit(
+    var: Var | Expression | ExpressionBase | ExpressionData | float,
+) -> _PyomoUnit | None:
+    """
+    Get the unit of a variable.
+    """
+    if isinstance(var, float):
+        # no attached unit
+        return units.dimensionless
+    if isinstance(var, ExpressionData):
+        var = var.parent_component()
+    if var.is_indexed():
+        # we will get the unit from the first item in the indexed variable
+        var = var[next(iter(var.index_set()))]
+    if isinstance(var, (ExpressionBase, Expression, ExpressionData)):
+        # handle expressions
+        return units.get_units(var)
+    else:
+        # handle variables
+        return var.get_units()
+
+
+def get_attached_unit_str(var: Var | Expression | ExpressionBase) -> str:
+    """
+    Get the unit of a variable as a string.
+    """
+    unit = get_attached_unit(var)
+    return str(unit) if unit is not None else "dimensionless"
+
+
+def get_value(var: Var | Expression | ExpressionBase) -> float | dict:
+    if var.is_indexed():
+        if isinstance(var, Var):
+            # can get values directly
+            return cast(dict, var.get_values())
+        else:
+            data = {}
+            for index in var.index_set():
+                data[index] = value(var[index])
+            return data
+    else:
+        return float(value(var))

ahuora_builder/ml_wizard.py

@@ -0,0 +1,101 @@
+from pydantic import BaseModel
+from ahuora_builder_types.payloads.ml_request_schema import MLTrainRequestPayload, MLTrainingCompletionPayload
+import pandas as pd
+import json
+import numpy as np
+from io import StringIO
+import contextlib
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, r2_score
+from idaes.core.surrogate.pysmo_surrogate import PysmoRBFTrainer, PysmoSurrogate
+
+
+class MLResult(BaseModel):
+    surrogate_model: dict
+    charts: list[dict]
+    metrics: list[dict]
+    test_inputs: dict
+    test_outputs: dict
+    task_id: int
+
+
+def ml_generate(schema: MLTrainRequestPayload) -> MLResult:
+    df = pd.DataFrame(schema.datapoints, columns=schema.columns)
+    train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)
+
+    input_labels = schema.input_labels
+    output_labels = schema.output_labels
+            
+    trainer = PysmoRBFTrainer(
+        input_labels=input_labels, output_labels=output_labels, training_dataframe=train_df)
+    trainer.config.basis_function = 'gaussian'
+
+    # Train surrogate (calls PySMO through IDAES Python wrapper)
+    stream = StringIO()
+    with contextlib.redirect_stdout(stream):
+        rbf_train = trainer.train_surrogate()
+
+
+    # create callable surrogate model
+    rbf_surr = PysmoSurrogate(rbf_train, input_labels,
+                              output_labels, input_bounds=None)
+    f = StringIO()
+    rbf_surr.save(f)
+    content = f.getvalue()
+    json_data = json.loads(content)
+
+    df_evaluate = rbf_surr.evaluate_surrogate(test_df)
+
+    metrics = []
+
+    charts = []
+
+    for output_label in output_labels:
+        charts.append(compute_chart(
+            test_df[output_label], df_evaluate[output_label], output_label))
+        metrics.append({
+            "mean_squared_error": round(mean_squared_error(df_evaluate[output_label], test_df[output_label]), 4),
+            "r2_score": round(r2_score(df_evaluate[output_label], test_df[output_label]), 4),
+        })
+
+    return MLResult(
+        surrogate_model=json_data,
+        charts=charts,
+        metrics=metrics,
+        test_inputs=test_df.to_dict(orient='index'),
+        test_outputs=df_evaluate.to_dict(orient='index'),
+        task_id=schema.task_id
+    )
+
+
+def compute_chart(test_data_df, eval_data_df, output_label):
+    minn = round(np.min([np.min(test_data_df), np.min(eval_data_df)]), 4)
+    maxx = round(np.max([np.max(test_data_df), np.max(eval_data_df)]), 4)
+    qq_plot_data = compute_qq_coordinates(test_data_df, eval_data_df)
+
+    return {
+        "min": minn,
+        "max": maxx,
+        "qq_plot_data": qq_plot_data,
+        "output_label": output_label
+    }
+
+
+def compute_qq_coordinates(test_data, eval_data):
+    """Compute QQ plot coordinates for two datasets."""
+    test_values = test_data.to_numpy().flatten()
+    eval_values = eval_data.to_numpy().flatten()
+
+    # Sort values
+    test_values.sort()
+    eval_values.sort()
+
+    # Generate QQ plot data points
+    quantiles = np.linspace(0, 1, len(test_values))
+    test_quantiles = np.quantile(test_values, quantiles)
+    eval_quantiles = np.quantile(eval_values, quantiles)
+
+    # Prepare JSON response for frontend
+    qq_data = [{"x": round(float(t), 4), "y": round(float(e), 4)}
+               for t, e in zip(test_quantiles, eval_quantiles)]
+    return json.dumps(qq_data)

ahuora_builder/port_manager.py

@@ -0,0 +1,20 @@
+from pyomo.network import Port
+from ahuora_builder_types import PortId
+
+
+class PortManager:
+    
+    def __init__(self) -> None:
+        self._map: dict[PortId, Port] = {}
+    
+
+    def register_port(self, id: PortId, port: Port) -> None:
+        """Registers a port with the port map, so that arcs can connect to it by id"""
+        self._map[id] =  port
+    
+    
+    def get_port(self, id: PortId) -> Port:
+        try:
+            return self._map[id]
+        except KeyError:
+            raise KeyError(f"Port with id `{id}` not found")

ahuora_builder/properties_manager.py

@@ -0,0 +1,44 @@
+from ahuora_builder_types.id_types import PropertyValueId
+from pyomo.core.base.indexed_component import IndexedComponent
+class PropertyComponent:
+    def __init__(self, name: str, component : IndexedComponent, unknown_units=False):
+        """
+        Args:
+        - name (str): The name of the property component (for debugging purposes)
+        - component (Component): The Pyomo component; i.e., Expression, Var
+        - unknown_units (bool): If units are unknown, idaes_factory will do some
+            additional processing to determine the unit category.
+        - corresponding_constraint (Constraint | Var | None): The component
+            (Var or Constraint) that was fixed or activated to set the value of
+            this property. Given an id in the properties dictionary, this field
+            can be used to unfix or deactivate the corresponding constraint.
+            Defaults to None (allowed for properties that are not fixed).
+        """
+        self.name: str = name
+        self.component: IndexedComponent = component
+        self.unknown_units = unknown_units
+        self.corresponding_constraint = None # TODO: Type
+
+
+class PropertiesManager:
+    def __init__(self):
+        self.properties : dict[PropertyValueId,PropertyComponent] = {}
+
+    def add(self, id: PropertyValueId, indexed_component: IndexedComponent, name : str, unknown_units=False)-> IndexedComponent:
+        self.properties[id] = PropertyComponent(name, indexed_component, unknown_units)
+    
+    def get(self, id: PropertyValueId):
+        return self.properties[id]
+    
+    def get_component(self, id: PropertyValueId):
+        return self.get(id).component
+    
+    def get_constraint(self, id: PropertyValueId):
+        return self.get(id).corresponding_constraint
+    
+    def add_constraint(self, id: PropertyValueId, constraint):
+        # assumes the property has already been added
+        self.get(id).corresponding_constraint = constraint
+    
+    def items(self):
+        return self.properties.items()

ahuora_builder/property_package_manager.py

@@ -0,0 +1,78 @@
+from idaes.core.base.property_base import PhysicalParameterBlock
+from idaes.core import FlowsheetBlock
+from property_packages.build_package import build_package
+
+from ahuora_builder_types.flowsheet_schema import PropertyPackageType
+from .flowsheet_manager_type import FlowsheetManager
+from ahuora_builder_types import PropertyPackageId
+
+
+def create_property_package(
+    property_package_schema: PropertyPackageType, flowsheet: FlowsheetBlock
+) -> PhysicalParameterBlock:
+    """
+    Create a property package from a schema
+    """
+    compounds = property_package_schema.compounds
+    type = property_package_schema.type
+    phases = property_package_schema.phases
+
+    property_package = build_package(type, compounds)
+    property_package_id = property_package_schema.id if property_package_schema.id != -1 else "default"
+
+    flowsheet.add_component(f"PP_{property_package_id}", property_package)
+    return property_package
+
+
+class PropertyPackageManager:
+    """
+    Manages the property packages for a flowsheet
+    """
+
+    def __init__(self, flowsheet_manager: FlowsheetManager) -> None:
+        """
+        Create a new property package manager
+        """
+        self._flowsheet_manager = flowsheet_manager
+        self._property_packages: dict[PropertyPackageId, PhysicalParameterBlock] = {}
+
+    def load(self) -> None:
+        """
+        Load the property packages from the flowsheet definition
+        """
+        schema = self._flowsheet_manager.schema
+        property_packages_schema = schema.property_packages
+        for property_package_schema in property_packages_schema:
+            id = property_package_schema.id
+            if id in self._property_packages:
+                raise Exception(f"Property package with id {id} already exists")
+
+            property_package = create_property_package(
+                property_package_schema, self._flowsheet_manager.model.fs
+            )
+            self._property_packages[id] = property_package
+
+    def get(self, id: PropertyPackageId) -> PhysicalParameterBlock:
+        """
+        Get a property package by id
+        """
+        # For backwards compatibility with other tests, use id -1 as helmholtz
+        fs = self._flowsheet_manager.model.fs
+
+        if id == -1:
+            if not hasattr(fs, "PP_default"):
+                create_property_package(
+                    PropertyPackageType(
+                        id=-1,
+                        type="helmholtz",
+                        compounds=["h2o"],
+                        phases=["Liq"]
+                    ),
+                    fs,
+                )
+            return fs.PP_default
+        else:
+            # get the property package by id
+            if id not in self._property_packages:
+                raise Exception(f"Property package with id {id} does not exist")
+            return self._property_packages[id]