OpenPinch 0.4.2__tar.gz → 0.4.3__tar.gz

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/classes/_problem/_target_accessor.py

@@ -14,6 +14,7 @@ from ...services import (
     indirect_refrigeration_service,
     power_cogeneration_service,
 )
+from ._target_plan import build_targeting_plan
 
 if TYPE_CHECKING:
     from ..pinch_problem import PinchProblem
@@ -34,10 +35,12 @@ class _TargetAccessor:
         runtime_options = dict(options or {})
         if state_id is not None:
             runtime_options["state_id"] = state_id
+        execution_master_zone = self._problem._build_execution_master_zone()
+        plan = build_targeting_plan(execution_master_zone.config)
         return self._problem._run_targeting_for_zone_and_subzones(
-            zone=None,
-            direct_service_func=direct_heat_integration_service,
-            indirect_service_func=indirect_heat_integration_service,
+            zone=execution_master_zone,
+            direct_service_func=plan.composite_direct_service(),
+            indirect_service_func=plan.composite_indirect_service(),
             options=runtime_options,
         )
 
@@ -213,7 +216,6 @@ class _TargetAccessor:
     ) -> BaseTargetModel:
         """Run exergy targeting on the first compatible base target family."""
         runtime_options = dict(options or {})
-        runtime_options["DO_EXERGY_TARGETING"] = True
         if state_id is not None:
             runtime_options["state_id"] = state_id
         return self._problem._execute_exergy_targeting(

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/classes/_problem/_target_dispatch.py

@@ -35,6 +35,12 @@ def _invoke_service(service_func: Callable, zone: Zone, args: dict | None = None
     return service_func(zone, args)
 
 
+def _service_declares_zone_applicability(service_func: Callable, zone: Zone) -> bool:
+    """Return whether a plan-built callback explicitly applies to ``zone``."""
+    zone_applicability = getattr(service_func, "_openpinch_zone_applicability", ())
+    return zone.type in zone_applicability
+
+
 def _invoke_target_handler(
     handler: Callable,
     zone: Zone,
@@ -58,11 +64,11 @@ def _get_unit_operation_targets(
     args: dict | None = None,
 ):
     """Populate a ``Zone`` with detailed unit operation-level pinch targets."""
-    if zone.config.DO_DIRECT_OPERATION_TARGETING:
+    if zone.config.targeting.direct_operation_enabled:
         if len(zone.subzones) > 0:
             for subzone in zone.subzones.values():
                 if subzone.type == ZT.O.value:
-                    if subzone.config.DO_DIRECT_OPERATION_TARGETING:
+                    if subzone.config.targeting.direct_operation_enabled:
                         if callable(direct_service_func):
                             _invoke_service(direct_service_func, subzone, args)
                 else:
@@ -109,9 +115,14 @@ def _get_process_targets(
                     "other process zones and operation zones."
                 )
 
-        if zone.config.DO_INDIRECT_PROCESS_TARGETING:
-            if callable(indirect_service_func):
-                _invoke_service(indirect_service_func, zone, args)
+        if (
+            callable(indirect_service_func)
+            and (
+                zone.config.targeting.indirect_process_enabled
+                or _service_declares_zone_applicability(indirect_service_func, zone)
+            )
+        ):
+            _invoke_service(indirect_service_func, zone, args)
 
     if callable(direct_service_func):
         _invoke_service(direct_service_func, zone, args)

openpinch-0.4.3/OpenPinch/classes/_problem/_target_plan.py

@@ -0,0 +1,211 @@
+"""Targeting selector registry for the default problem targeting entry point."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Literal
+
+from ...lib.enums import TT, ZT
+from ...services import (
+    area_cost_targeting_service,
+    direct_heat_integration_service,
+    direct_heat_pump_service,
+    direct_refrigeration_service,
+    exergy_targeting_service,
+    indirect_heat_integration_service,
+    indirect_heat_pump_service,
+    indirect_refrigeration_service,
+    power_cogeneration_service,
+)
+
+TargetingServiceSlot = Literal["direct", "indirect"]
+
+
+@dataclass(frozen=True)
+class TargetingMethodSpec:
+    """Describe one flat targeting selector and its runtime dispatch service."""
+
+    selector: str
+    service: Callable
+    target_type: str
+    slot: TargetingServiceSlot
+    prerequisites: tuple[str, ...]
+    zone_applicability: tuple[str, ...]
+    execution_order: int
+
+
+@dataclass(frozen=True)
+class TargetingPlan:
+    """Ordered targeting services selected from ``config.targeting``."""
+
+    specs: tuple[TargetingMethodSpec, ...]
+
+    @property
+    def direct_services(self) -> tuple[Callable, ...]:
+        return _unique_services(
+            spec.service for spec in self.specs if spec.slot == "direct"
+        )
+
+    @property
+    def indirect_services(self) -> tuple[Callable, ...]:
+        return _unique_services(
+            spec.service for spec in self.specs if spec.slot == "indirect"
+        )
+
+    def composite_direct_service(self) -> Callable | None:
+        return _compose_services(
+            spec for spec in self.specs if spec.slot == "direct"
+        )
+
+    def composite_indirect_service(self) -> Callable | None:
+        return _compose_services(
+            spec for spec in self.specs if spec.slot == "indirect"
+        )
+
+
+TARGETING_METHOD_SPECS: tuple[TargetingMethodSpec, ...] = (
+    TargetingMethodSpec(
+        selector="TARGETING_DIRECT_SITE_ENABLED",
+        service=direct_heat_integration_service,
+        target_type=TT.DI.value,
+        slot="direct",
+        prerequisites=(),
+        zone_applicability=(ZT.S.value, ZT.P.value),
+        execution_order=10,
+    ),
+    TargetingMethodSpec(
+        selector="TARGETING_DIRECT_OPERATION_ENABLED",
+        service=direct_heat_integration_service,
+        target_type=TT.DI.value,
+        slot="direct",
+        prerequisites=(),
+        zone_applicability=(ZT.O.value,),
+        execution_order=20,
+    ),
+    TargetingMethodSpec(
+        selector="TARGETING_INDIRECT_PROCESS_ENABLED",
+        service=indirect_heat_integration_service,
+        target_type=TT.TS.value,
+        slot="indirect",
+        prerequisites=(TT.DI.value,),
+        zone_applicability=(ZT.S.value, ZT.P.value),
+        execution_order=30,
+    ),
+    TargetingMethodSpec(
+        selector="TARGETING_PROCESS_HP_ENABLED",
+        service=direct_heat_pump_service,
+        target_type=TT.DHP.value,
+        slot="direct",
+        prerequisites=(TT.DI.value,),
+        zone_applicability=(ZT.S.value, ZT.P.value),
+        execution_order=40,
+    ),
+    TargetingMethodSpec(
+        selector="TARGETING_PROCESS_RFRG_ENABLED",
+        service=direct_refrigeration_service,
+        target_type=TT.DR.value,
+        slot="direct",
+        prerequisites=(TT.DI.value,),
+        zone_applicability=(ZT.S.value, ZT.P.value),
+        execution_order=50,
+    ),
+    TargetingMethodSpec(
+        selector="TARGETING_UTILITY_HP_ENABLED",
+        service=indirect_heat_pump_service,
+        target_type=TT.IHP.value,
+        slot="indirect",
+        prerequisites=(TT.TS.value,),
+        zone_applicability=(ZT.S.value, ZT.P.value),
+        execution_order=60,
+    ),
+    TargetingMethodSpec(
+        selector="TARGETING_UTILITY_RFRG_ENABLED",
+        service=indirect_refrigeration_service,
+        target_type=TT.IR.value,
+        slot="indirect",
+        prerequisites=(TT.TS.value,),
+        zone_applicability=(ZT.S.value, ZT.P.value),
+        execution_order=70,
+    ),
+    TargetingMethodSpec(
+        selector="TARGETING_TURBINE_ENABLED",
+        service=power_cogeneration_service,
+        target_type="Cogeneration",
+        slot="direct",
+        prerequisites=(TT.DI.value, TT.TS.value),
+        zone_applicability=(ZT.S.value, ZT.P.value),
+        execution_order=80,
+    ),
+    TargetingMethodSpec(
+        selector="TARGETING_EXERGY_ENABLED",
+        service=exergy_targeting_service,
+        target_type="Exergy Analysis",
+        slot="direct",
+        prerequisites=(TT.DI.value, TT.TS.value),
+        zone_applicability=(ZT.S.value, ZT.P.value),
+        execution_order=90,
+    ),
+    TargetingMethodSpec(
+        selector="TARGETING_AREA_COST_ENABLED",
+        service=area_cost_targeting_service,
+        target_type=TT.DI.value,
+        slot="direct",
+        prerequisites=(TT.DI.value,),
+        zone_applicability=(ZT.S.value, ZT.P.value),
+        execution_order=100,
+    ),
+)
+
+
+def build_targeting_plan(config) -> TargetingPlan:
+    """Build the default service plan from ``Configuration.targeting`` flags."""
+    selected = [
+        spec
+        for spec in TARGETING_METHOD_SPECS
+        if _selector_enabled(config, spec.selector)
+    ]
+    return TargetingPlan(
+        specs=tuple(sorted(selected, key=lambda spec: spec.execution_order))
+    )
+
+
+def _selector_enabled(config, selector: str) -> bool:
+    field_name = selector.removeprefix("TARGETING_").removesuffix("_ENABLED").lower()
+    return bool(getattr(config.targeting, f"{field_name}_enabled", False))
+
+
+def _unique_services(services) -> tuple[Callable, ...]:
+    unique: list[Callable] = []
+    seen: set[int] = set()
+    for service in services:
+        marker = id(service)
+        if marker in seen:
+            continue
+        seen.add(marker)
+        unique.append(service)
+    return tuple(unique)
+
+
+def _compose_services(specs) -> Callable | None:
+    selected = tuple(specs)
+    if not selected:
+        return None
+
+    def _composite(zone, args=None):
+        zone_type = getattr(zone, "type", None)
+        invoked_services: set[int] = set()
+        for spec in selected:
+            if zone_type not in spec.zone_applicability:
+                continue
+            marker = id(spec.service)
+            if marker in invoked_services:
+                continue
+            invoked_services.add(marker)
+            spec.service(zone, args)
+        return zone
+
+    _composite._openpinch_zone_applicability = frozenset(
+        zone_type for spec in selected for zone_type in spec.zone_applicability
+    )
+    return _composite

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/classes/_problem/_validation.py

@@ -9,6 +9,7 @@ from typing import Any, Optional
 import numpy as np
 from pydantic import ValidationError
 
+from ...lib.config_metadata import CONFIG_FIELD_SPECS, input_unit_options_to_map
 from ...lib.enums import ST
 from ...lib.schemas.io import TargetInput
 from ...lib.schemas.workspace import ValidationIssue, ValidationReport
@@ -160,7 +161,9 @@ def semantic_issues(
     """Return semantic validation issues for one validated problem definition."""
     issues: list[ValidationIssue] = []
     options = problem_inputs.options if isinstance(problem_inputs.options, dict) else {}
-    input_unit_config = {"INPUT_UNITS": options.get("INPUT_UNITS", {})}
+    input_unit_config = input_unit_options_to_map(
+        {name: spec.default for name, spec in CONFIG_FIELD_SPECS.items()} | options
+    )
 
     if len(problem_inputs.streams) == 0:
         issues.append(

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/classes/_workspace/views.py

@@ -141,10 +141,12 @@ def configuration_field_metadata() -> list[ConfigurationFieldMetadata]:
                 label=name.replace("_", " ").title(),
                 field_type=field_type,
                 group=spec.group,
+                config_path=list(spec.config_path),
                 support_level=configuration_field_support_level(name),
                 runtime_status=spec.runtime_status,
                 enum_choices=[str(item.value) for item in enum_cls] if enum_cls else [],
                 numeric_min=spec.numeric_min,
+                numeric_max=spec.numeric_max,
                 multiple=multiple,
             )
         )
@@ -298,9 +300,11 @@ def summary_metric_deltas(
                     base_value=base_value,
                     variant_value=variant_value,
                     unit=unit,
-                    delta=numeric_delta(base_value, variant_value)
-                    if units_match
-                    else None,
+                    delta=(
+                        numeric_delta(base_value, variant_value)
+                        if units_match
+                        else None
+                    ),
                 )
             )
     return deltas

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/classes/pinch_problem.py

@@ -576,26 +576,16 @@ class PinchProblem:
         ]
         unit_columns = {col: f"{col} (unit)" for col in columns}
 
-        comparison = pd.DataFrame(
-            [
-                pd.Series(
-                    {
-                        col: base_row.get(col)
-                        for col in [*columns, *unit_columns.values()]
-                    },
-                    name=base_label,
-                ),
-                pd.Series(
-                    {
-                        col: other_row.get(col)
-                        for col in [*columns, *unit_columns.values()]
-                    },
-                    name=other_label,
-                ),
-            ]
-        )
-
-        change_row: dict[str, object] = {}
+        row_columns = [*columns, *unit_columns.values()]
+        base_payload = {
+            "Target": str(base_row["Target"]),
+            **{col: base_row.get(col) for col in row_columns},
+        }
+        other_payload = {
+            "Target": str(other_row["Target"]),
+            **{col: other_row.get(col) for col in row_columns},
+        }
+        change_row: dict[str, object] = {"Target": str(base_row["Target"])}
         for col in columns:
             unit_col = unit_columns[col]
             base_unit = base_row.get(unit_col)
@@ -612,10 +602,15 @@ class PinchProblem:
                 change_row[col] = None
                 change_row[unit_col] = None
 
-        comparison.loc["Change"] = pd.Series(change_row)
-        comparison.insert(0, "Target", str(base_row["Target"]))
-        comparison.loc["Change", "Target"] = str(base_row["Target"])
-        return comparison
+        return pd.DataFrame.from_dict(
+            {
+                base_label: base_payload,
+                other_label: other_payload,
+                "Change": change_row,
+            },
+            orient="index",
+            columns=["Target", *row_columns],
+        )
 
     def _data_preprocessing(self) -> "Zone":
         if isinstance(self._validated_data, TargetInput) and isinstance(

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/classes/zone.py

@@ -31,14 +31,14 @@ class Zone:
         self,
         name: str = "Zone",
         type: str = ZT.P.value,
-        zone_config: Optional[Configuration] = None,
+        config: Optional[Configuration] = None,
         parent_zone: "Zone" = None,
     ):
         """Initialise an empty zone with stream, target, and graph containers."""
         # === Metadata ===
         self._name = name
         self._type = type
-        self._config = zone_config or Configuration()
+        self._config = config or Configuration()
         self._parent_zone = parent_zone
         self._dt_cont_multiplier = (
             parent_zone.dt_cont_multiplier
@@ -56,14 +56,17 @@ class Zone:
             self._weights = parent_zone._weights
         else:
             self._state_ids = (
-                {state_id: idx for idx, state_id in enumerate(self._config.STATE_IDS)}
-                if isinstance(self._config.STATE_IDS, list | tuple)
+                {
+                    state_id: idx
+                    for idx, state_id in enumerate(self._config.problem.state_ids)
+                }
+                if isinstance(self._config.problem.state_ids, list | tuple)
                 else {"0": 0}
             )
             self._num_states = len(self._state_ids)
-            if isinstance(self._config.WEIGHTS, np.ndarray | list):
-                if len(self._config.WEIGHTS) == self._num_states:
-                    self._weights = self._config.WEIGHTS
+            if isinstance(self._config.problem.state_weights, np.ndarray | list):
+                if len(self._config.problem.state_weights) == self._num_states:
+                    self._weights = self._config.problem.state_weights
                 else:
                     self._weights = np.ones(len(self._state_ids), dtype=float)
 

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/data/notebooks/03_carnot_hpr_comparison.ipynb

@@ -34,10 +34,10 @@
     "from OpenPinch.utils import get_scalar_value\n",
     "\n",
     "PROJECT_NAME = \"Chocolate factory\"\n",
-    "LOAD_FRACTION = 1.0\n",
-    "MAX_HP_MULTISTART = 10\n",
-    "N_COND = 3\n",
-    "N_EVAP = 3\n",
+    "LOAD_SHARE = 1.0\n",
+    "MULTISTART_COUNT = 10\n",
+    "CONDENSER_COUNT = 3\n",
+    "EVAPORATOR_COUNT = 3\n",
     "\n",
     "WORKFLOWS = {\n",
     "    \"direct_heat_pump\": {\n",
@@ -79,10 +79,11 @@
     "        case.update_options(\n",
     "            {\n",
     "                \"HPR_TYPE\": cycle.value,\n",
-    "                \"HPR_LOAD_VALUE\": LOAD_FRACTION,\n",
-    "                \"MAX_HP_MULTISTART\": MAX_HP_MULTISTART,\n",
-    "                \"N_COND\": N_COND,\n",
-    "                \"N_EVAP\": N_EVAP,\n",
+    "                \"HPR_LOAD_MODE\": \"fraction\",\n",
+    "                \"HPR_LOAD_FRACTION\": LOAD_SHARE,\n",
+    "                \"HPR_MAX_MULTISTART\": MULTISTART_COUNT,\n",
+    "                \"HPR_N_COND\": CONDENSER_COUNT,\n",
+    "                \"HPR_N_EVAP\": EVAPORATOR_COUNT,\n",
     "            }\n",
     "        )\n",
     "        case_matrix.append(\n",
@@ -339,7 +340,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.14.1"
+   "version": "3.14.2"
   }
  },
  "nbformat": 4,

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/data/notebooks/05_schema_service_and_output_workflows.ipynb

@@ -194,7 +194,7 @@
    "source": [
     "workspace.set_variant_payload(\n",
     "    \"tight_dt\",\n",
-    "    {\"options\": {\"DT_CONT\": 8.0}},\n",
+    "    {\"options\": {\"THERMAL_DT_CONT\": 8.0}},\n",
     "    base=\"baseline\",\n",
     ")\n",
     "\n",
@@ -267,7 +267,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.14.1"
+   "version": "3.14.2"
   }
  },
  "nbformat": 4,

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/data/notebooks/07_vapour_compression_mvr_cascade_hpr.ipynb

@@ -46,7 +46,7 @@
    "metadata": {},
    "source": [
     "## Configure public HPR targeting cases\n",
-    "The VC+MVR backend is selected through the normal `HPR_TYPE` option. `N_COND` and `N_EVAP` define the low-stage vapour-compression placement dimensions; `N_MVR` defines the MVR high-stage count. `MVR_FLUIDS` is independent from the low-stage `REFRIGERANTS` list. The reference case uses `HPRcycle.ParallelCarnot`, the current staged Carnot screening name."
+    "The VC+MVR backend is selected through the normal `HPR_TYPE` option. `HPR_N_COND` and `HPR_N_EVAP` define the low-stage vapour-compression placement dimensions; `HPR_MVR_COUNT` defines the MVR high-stage count. `HPR_MVR_FLUIDS` is independent from the low-stage `HPR_REFRIGERANTS` list. The reference case uses `HPRcycle.ParallelCarnot`, the current staged Carnot screening name."
    ]
   },
   {
@@ -61,29 +61,31 @@
     "carnot_case = workspace.copy_case(\"baseline\", \"reference_parallel_carnot\", activate=False)\n",
     "carnot_options = {\n",
     "        \"HPR_TYPE\": HPRcycle.ParallelCarnot.value,\n",
-    "        \"HPR_LOAD_VALUE\": 0.10,\n",
-    "        \"MAX_HP_MULTISTART\": 5,\n",
-    "        \"N_COND\": 1,\n",
-    "        \"N_EVAP\": 1,\n",
+    "        \"HPR_LOAD_MODE\": \"fraction\",\n",
+    "        \"HPR_LOAD_FRACTION\": 0.10,\n",
+    "        \"HPR_MAX_MULTISTART\": 5,\n",
+    "        \"HPR_N_COND\": 1,\n",
+    "        \"HPR_N_EVAP\": 1,\n",
     "}\n",
     "carnot_case.update_options(carnot_options)\n",
     "\n",
     "vc_mvr_case = workspace.copy_case(\"baseline\", \"vc_mvr_cascade\", activate=False)\n",
     "vc_mvr_options = {\n",
     "        \"HPR_TYPE\": HPRcycle.VapourCompMVR.value,\n",
-    "        \"HPR_LOAD_VALUE\": 0.10,\n",
-    "        \"MAX_HP_MULTISTART\": 1,\n",
-    "        \"N_COND\": 1,\n",
-    "        \"N_EVAP\": 1,\n",
-    "        \"N_MVR\": 1,\n",
-    "        \"REFRIGERANTS\": \"R245FA\",\n",
-    "        \"MVR_FLUIDS\": \"Water\",\n",
-    "        \"ETA_COMP\": 0.75,\n",
-    "        \"ETA_MVR_COMP\": 0.72,\n",
-    "        \"ETA_MOTOR\": 0.95,\n",
-    "        \"DT_HPR_CASCADE_HX\": 5.0,\n",
-    "        \"INITIALISE_SIMULATED_CYCLE\": False,\n",
-    "        \"BB_MINIMISER\": \"rbf_surrogate\",\n",
+    "        \"HPR_LOAD_MODE\": \"fraction\",\n",
+    "        \"HPR_LOAD_FRACTION\": 0.10,\n",
+    "        \"HPR_MAX_MULTISTART\": 1,\n",
+    "        \"HPR_N_COND\": 1,\n",
+    "        \"HPR_N_EVAP\": 1,\n",
+    "        \"HPR_MVR_COUNT\": 1,\n",
+    "        \"HPR_REFRIGERANTS\": [\"R245FA\"],\n",
+    "        \"HPR_MVR_FLUIDS\": [\"Water\"],\n",
+    "        \"HPR_ETA_COMP\": 0.75,\n",
+    "        \"HPR_MVR_ETA_COMP\": 0.72,\n",
+    "        \"HPR_MVR_ETA_MOTOR\": 0.95,\n",
+    "        \"HPR_DT_CASCADE_HX\": 5.0,\n",
+    "        \"HPR_INITIALISE_SIMULATED_CYCLE\": False,\n",
+    "        \"HPR_BB_MINIMISER\": \"rbf_surrogate\",\n",
     "}\n",
     "vc_mvr_case.update_options(vc_mvr_options)\n",
     "\n",
@@ -92,16 +94,16 @@
     "        {\n",
     "            \"case\": \"reference_parallel_carnot\",\n",
     "            \"HPR_TYPE\": carnot_options[\"HPR_TYPE\"],\n",
-    "            \"N_COND\": carnot_options[\"N_COND\"],\n",
-    "            \"N_EVAP\": carnot_options[\"N_EVAP\"],\n",
-    "            \"N_MVR\": None,\n",
+    "            \"HPR_N_COND\": carnot_options[\"HPR_N_COND\"],\n",
+    "            \"HPR_N_EVAP\": carnot_options[\"HPR_N_EVAP\"],\n",
+    "            \"HPR_MVR_COUNT\": None,\n",
     "        },\n",
     "        {\n",
     "            \"case\": \"vc_mvr_cascade\",\n",
     "            \"HPR_TYPE\": vc_mvr_options[\"HPR_TYPE\"],\n",
-    "            \"N_COND\": vc_mvr_options[\"N_COND\"],\n",
-    "            \"N_EVAP\": vc_mvr_options[\"N_EVAP\"],\n",
-    "            \"N_MVR\": vc_mvr_options[\"N_MVR\"],\n",
+    "            \"HPR_N_COND\": vc_mvr_options[\"HPR_N_COND\"],\n",
+    "            \"HPR_N_EVAP\": vc_mvr_options[\"HPR_N_EVAP\"],\n",
+    "            \"HPR_MVR_COUNT\": vc_mvr_options[\"HPR_MVR_COUNT\"],\n",
     "        },\n",
     "    ]\n",
     ")\n"
@@ -113,7 +115,7 @@
    "metadata": {},
    "source": [
     "## Standalone MVR thermodynamics\n",
-    "The MVR model accepts any CoolProp-compatible fluid and defaults to water. The inlet is saturated or superheated vapour at `T_evap`, the outlet is a real compressor discharge at condenser pressure, and the condenser outlet is saturated or subcooled liquid. `ETA_MOTOR` converts shaft work to electrical work."
+    "The MVR model accepts any CoolProp-compatible fluid and defaults to water. The inlet is saturated or superheated vapour at `T_evap`, the outlet is a real compressor discharge at condenser pressure, and the condenser outlet is saturated or subcooled liquid. `HPR_MVR_ETA_MOTOR` converts shaft work to electrical work."
    ]
   },
   {
@@ -327,7 +329,7 @@
     "        rows.append(\n",
     "            {\n",
     "                \"case\": case_name,\n",
-    "                \"HPR_TYPE\": problem.master_zone.config.HPR_TYPE,\n",
+    "                \"HPR_TYPE\": problem.master_zone.config.hpr.type,\n",
     "                \"hpr_success\": getattr(target, \"hpr_success\", None),\n",
     "                \"hpr_work\": get_scalar_value(getattr(target, \"hpr_work\", None)),\n",
     "                \"hpr_cop\": get_scalar_value(getattr(target, \"hpr_cop\", None)),\n",
@@ -376,7 +378,7 @@
    "metadata": {},
    "source": [
     "## Interpretation\n",
-    "Use the deterministic unit-model cells to check thermodynamic accounting and internal heat routing before running a full placement solve. When moving to the public target, start with one VC stage and one MVR stage, keep `MAX_HP_MULTISTART` low while tuning fluids and load fraction, then increase stage counts and multistart effort once the temperature ranges are physically feasible."
+    "Use the deterministic unit-model cells to check thermodynamic accounting and internal heat routing before running a full placement solve. When moving to the public target, start with one VC stage and one MVR stage, keep `MULTISTART_COUNT` low while tuning fluids and load fraction, then increase stage counts and multistart effort once the temperature ranges are physically feasible."
    ]
   }
  ],

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/data/notebooks/08_direct_gas_stream_mvr.ipynb

@@ -48,9 +48,9 @@
     "        ],\n",
     "    },\n",
     "    \"options\": {\n",
-    "        \"TOP_ZONE_NAME\": \"Demo Site\",\n",
-    "        \"TOP_ZONE_IDENTIFIER\": ZT.S.value,\n",
-    "        \"DO_DIRECT_SITE_TARGETING\": True,\n",
+    "        \"PROBLEM_TOP_ZONE_NAME\": \"Demo Site\",\n",
+    "        \"PROBLEM_TOP_ZONE_IDENTIFIER\": ZT.S.value,\n",
+    "        \"TARGETING_DIRECT_SITE_ENABLED\": True,\n",
     "    },\n",
     "    \"streams\": [\n",
     "        {\n",

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/data/notebooks/09_hen_design_service_four_stream.ipynb

@@ -53,9 +53,9 @@
     "        ],\n",
     "    },\n",
     "    \"options\": {\n",
-    "        \"COST_EXP\": 1.0,\n",
-    "        \"FIXED_COST\": 5500.0,\n",
-    "        \"VARIABLE_COST\": 150.0,\n",
+    "        \"COSTING_HX_AREA_EXP\": 1.0,\n",
+    "        \"COSTING_HX_UNIT_COST\": 5500.0,\n",
+    "        \"COSTING_HX_AREA_COEFF\": 150.0,\n",
     "        \"HENS_APPROACH_TEMPERATURES\": [10.0, 14.0, 18.0],\n",
     "        \"HENS_DERIVATIVE_THRESHOLDS\": [0.5],\n",
     "        \"HENS_STAGE_SELECTION\": [3],\n",

{openpinch-0.4.2 → openpinch-0.4.3}/OpenPinch/data/sample_cases/chocolate_factory.json

@@ -1804,15 +1804,19 @@
         }
     ],
     "options": {
-        "DO_PROCESS_HP_TARGETING": true,
-        "DO_UTILITY_HP_TARGETING": true,
+        "TARGETING_PROCESS_HP_ENABLED": true,
+        "TARGETING_UTILITY_HP_ENABLED": true,
         "HPR_TYPE": "Parallel vapour compression cycles",
-        "HPR_LOAD_VALUE": "{\"multiply\": 1} ",
-        "REFRIGERANTS": "R601,R600",
-        "N_COND": 2,
-        "N_EVAP": true,
-        "ETA_COMP": 0.7,
-        "DT_CONT_HP": 4,
-        "DT_HPR_IHX": 20
+        "HPR_LOAD_MODE": "fraction",
+        "HPR_LOAD_FRACTION": 1.0,
+        "HPR_REFRIGERANTS": [
+            "R601",
+            "R600"
+        ],
+        "HPR_N_COND": 2,
+        "HPR_N_EVAP": 1,
+        "HPR_ETA_COMP": 0.7,
+        "HPR_DT_CONT": 4,
+        "HPR_DT_IHX": 20
     }
 }