OpenPinch 0.7.4__tar.gz → 0.7.6__tar.gz

{openpinch-0.7.4 → openpinch-0.7.6}/OpenPinch/analysis/heat_pumps/common/shared.py

@@ -25,6 +25,7 @@ from ....contracts.hpr import (
 )
 from ....domain.configuration import tol as _tol
 from ....domain.enums import ProblemTableLabel
+from ....domain.fluids import critical_point
 from ....domain.stream_collection import StreamCollection
 from ....domain.value import Value
 from ..optimisation_adapter import (
@@ -61,6 +62,7 @@ __all__ = [
     "cap_stage_condensing_temperatures",
     "is_negligible_useful_duty",
     "condensing_temperature_search_range",
+    "floor_stage_evaporating_temperatures",
     "calc_simulated_hpr_annualized_costs",
     "hpr_penalty_cost_scale",
     "refrigeration_allowance",
@@ -209,6 +211,12 @@ def calc_hpr_machine_capital_costs(
     return tuple(costs)
 
 
+# A cascade stage doing no more than this fraction of its machine's work has
+# no compressor, so it adds no stage capital (the same fraction as
+# NEGLIGIBLE_USEFUL_DUTY_FRACTION uses for duty).
+NEGLIGIBLE_STAGE_WORK_FRACTION = 1e-3
+
+
 def _single_cost_unit(
     state: HPRParsedState,
     hpr_streams: StreamCollection,
@@ -220,7 +228,9 @@ def _single_cost_unit(
     Each closed stage has its own compressor, so the stage count comes from
     the solved stage works: a cascade with ``n_cond`` condenser and
     ``n_evap`` evaporator levels has ``n_cond + n_evap - 1`` stages, more
-    than its ``n_cond`` condensing temperatures.
+    than its ``n_cond`` condensing temperatures. A stage whose work is at
+    most ``NEGLIGIBLE_STAGE_WORK_FRACTION`` of the machine's work (merged
+    levels, or no duty) has no compressor and is not charged.
     """
     hot = hpr_streams.get_hot_utility_streams()
     Q_cap = (
@@ -229,9 +239,12 @@ def _single_cost_unit(
         else 0.0
     )
     T_cond = np.asarray(state.T_cond, dtype=float).ravel()
+    works = np.abs(np.asarray(work_arr if work_arr is not None else [], dtype=float))
     n_stages = (
-        np.asarray(work_arr, dtype=float).size if work_arr is not None else 0
-    ) or T_cond.size
+        int(np.count_nonzero(works > NEGLIGIBLE_STAGE_WORK_FRACTION * works.sum()))
+        if works.size
+        else T_cond.size
+    )
     return [
         HPRCostUnit(
             Q_cap=Q_cap,
@@ -770,7 +783,7 @@ def condensing_temperature_search_range(
         return t_hot, t_cold
     try:
         refrigerants = list(getattr(args, "refrigerant_ls", None) or ["water"])
-        t_crit = max(float(_coolprop.PropsSI("Tcrit", ref)) for ref in refrigerants)
+        t_crit = max(float(critical_point(ref)[0]) for ref in refrigerants)
     except (ValueError, TypeError):
         return t_hot, t_cold
     ceiling = t_crit - 273.15 - SUBCRITICAL_CONDENSING_MARGIN_K
@@ -814,7 +827,7 @@ def cap_stage_condensing_temperatures(
     for index in range(T_cond.size):
         refrigerant = refrigerants[min(index, len(refrigerants) - 1)]
         try:
-            t_crit = float(_coolprop.PropsSI("Tcrit", refrigerant)) - 273.15
+            t_crit = float(critical_point(refrigerant)[0]) - 273.15
         except (ValueError, TypeError):
             continue
         ceilings[index] = t_crit - SUBCRITICAL_CONDENSING_MARGIN_K
@@ -827,6 +840,44 @@ def cap_stage_condensing_temperatures(
     return capped
 
 
+# Keeps a floored temperature above Tmin through the degC to K round trip.
+EVAPORATING_FLOOR_MARGIN_K = 1e-6
+
+
+def floor_stage_evaporating_temperatures(
+    T_evap: np.ndarray,
+    args: HeatPumpTargetInputs,
+    *,
+    first_stage: int = 0,
+) -> np.ndarray:
+    """Raise each evaporator to its own refrigerant's minimum temperature.
+
+    CoolProp extrapolates saturation below ``Tmin`` without error, so the search
+    range must stop there. Flooring at decode keeps candidates evaluable, where
+    rejecting them would spend a small search budget on failures. Evaporator
+    ``i`` uses ``args.refrigerant_ls[first_stage + i]``; the result is
+    non-increasing (a floored stage lifts the warmer stages with it).
+    """
+    T_evap = np.asarray(T_evap, dtype=float)
+    if getattr(args, "simulation_backend", "coolprop") == "tespy":
+        return T_evap
+    refrigerants = list(getattr(args, "refrigerant_ls", None) or [])
+    if not refrigerants:
+        return T_evap
+    floors = np.full(T_evap.shape, -np.inf)
+    for index in range(T_evap.size):
+        refrigerant = refrigerants[min(first_stage + index, len(refrigerants) - 1)]
+        try:
+            t_min = float(_coolprop.PropsSI("Tmin", refrigerant)) - 273.15
+        except (ValueError, TypeError):
+            continue
+        floors[index] = t_min + EVAPORATING_FLOOR_MARGIN_K
+    floored = np.maximum(T_evap, floors)
+    for index in range(floored.size - 2, -1, -1):
+        floored[index] = max(floored[index], floored[index + 1])
+    return floored
+
+
 def validate_vapour_hp_refrigerant_ls(
     num_stages: int,
     args: HeatPumpTargetInputs,

{openpinch-0.7.4 → openpinch-0.7.6}/OpenPinch/analysis/heat_pumps/cycles/vapour_compression_cycle.py

@@ -13,7 +13,7 @@ from ....domain._stream.linearisation import (
     get_piecewise_data_points,
 )
 from ....domain.configuration import tol
-from ....domain.fluids import build_coolprop_abstract_state
+from ....domain.fluids import build_coolprop_abstract_state, critical_point
 from ....domain.stream_collection import StreamCollection
 
 # Qualities this close to 0 or 1 are saturated liquid or vapour; differences
@@ -93,9 +93,12 @@ class VapourCompressionCycle:
         """Set the working-fluid state object and refresh critical properties."""
         self._state = self._get_fluid_state(value)
         self._solved = False
-        self._p_crit = self._state.keyed_output(CoolProp.iP_critical)
-        self._t_crit = self._state.keyed_output(CoolProp.iT_critical)
-        self._d_crit = self._state.keyed_output(CoolProp.irhomass_critical)
+        if isinstance(value, str):
+            self._t_crit, self._p_crit, self._d_crit = critical_point(value)
+        else:
+            self._p_crit = self._state.keyed_output(CoolProp.iP_critical)
+            self._t_crit = self._state.keyed_output(CoolProp.iT_critical)
+            self._d_crit = self._state.keyed_output(CoolProp.irhomass_critical)
 
     @property
     def cycle_states(self) -> list[dict[str, float]]:
@@ -324,7 +327,7 @@ class VapourCompressionCycle:
         refrigerant: str = None,
     ) -> bool:
         if refrigerant is not None:
-            self.state = self._get_fluid_state(refrigerant)
+            self.state = refrigerant
         if self._state is None:
             raise ValueError("A fluid must be specified before solving the cycle.")
         return True
@@ -413,6 +416,69 @@ class VapourCompressionCycle:
         s.update(CoolProp.PQ_INPUTS, P, Q)
         return s
 
+    def _isobar_points(
+        self,
+        P: float,
+        h_start: float,
+        h_end: float,
+        num: int,
+    ) -> list[list[float]]:
+        """Return ``num`` [h, T] points from ``h_start`` to ``h_end`` on isobar ``P``.
+
+        Pure fluids step in enthalpy. A HEOS mixture's pressure-enthalpy flash
+        costs tens of milliseconds, so a mixture steps in quality inside the
+        two-phase region and in temperature outside it; both give exact points
+        on the same isobar. Segment ends keep their exact enthalpies so that
+        adjacent profile blocks still share their boundary point.
+        """
+        if len(self._get_fluid_state(self._refrigerant).fluid_names()) == 1:
+            return [
+                [h, float(self._compute_state_from_pressure_enthalpy(P=P, h=h).T())]
+                for h in np.linspace(h_start, h_end, num)
+            ]
+
+        h_liquid = self._compute_state_from_pressure_quality(P, 0.0).hmass()
+        h_vapour = self._compute_state_from_pressure_quality(P, 1.0).hmass()
+        start, end = (
+            self._isobar_end_state(P, h, h_liquid, h_vapour) for h in (h_start, h_end)
+        )
+        if all(h_liquid <= h <= h_vapour for h in (h_start, h_end)):
+            states = [
+                self._compute_state_from_pressure_quality(P, Q)
+                for Q in np.linspace(start[2], end[2], num)[1:-1]
+            ]
+        else:
+            states = [
+                self._compute_state_from_pressure_temperature(P, T)
+                for T in np.linspace(start[1], end[1], num)[1:-1]
+            ]
+        interior = [[float(s.hmass()), float(s.T())] for s in states]
+        return [[start[0], start[1]], *interior, [end[0], end[1]]]
+
+    def _isobar_end_state(
+        self,
+        P: float,
+        h: float,
+        h_liquid: float,
+        h_vapour: float,
+    ) -> tuple[float, float, float | None]:
+        """Return (h, T, quality) of a profile segment end on a mixture isobar.
+
+        Saturation ends and solved cycle states are already known; only an end
+        strictly inside the two-phase region needs a flash, for its quality.
+        """
+        if h == h_vapour:
+            return h, float(self._compute_state_from_pressure_quality(P, 1.0).T()), 1.0
+        if h == h_liquid:
+            return h, float(self._compute_state_from_pressure_quality(P, 0.0).T()), 0.0
+        if not h_liquid < h < h_vapour:
+            for point in self._cycle_states:
+                if point and point["P"] == P and point["H"] == h:
+                    return h, point["T"], None
+        state = self._compute_state_from_pressure_enthalpy(P=P, h=h)
+        quality = float(state.Q()) if h_liquid < h < h_vapour else None
+        return h, float(state.T()), quality
+
     def _compute_compressor_outlet_state(
         self, h_in: float, s_in: float, P_out: float
     ) -> CoolProp.AbstractState:
@@ -601,6 +667,13 @@ class VapourCompressionCycle:
             0.0,
         )
 
+        # CoolProp extrapolates saturation below Tmin without error.
+        if self._T_evap < self._state.Tmin():
+            raise ValueError(
+                "Evaporating temperature is below the refrigerant's minimum "
+                "temperature."
+            )
+
         P_lo = self._get_P_sat_from_T(self._T_evap, Q=1.0)
         P_hi = self._get_P_sat_from_T(self._T_cond, Q=0.0)
 
@@ -846,27 +919,23 @@ class VapourCompressionCycle:
             ).hmass()
 
             if H[4] > h_sat_vapor:
-                for h in np.linspace(H[4], max(h_sat_vapor, H[2]), 21):
-                    state = self._compute_state_from_pressure_enthalpy(P=p_high, h=h)
-                    t_h_curve_points.append([h, float(state.T())])
+                t_h_curve_points.extend(
+                    self._isobar_points(p_high, H[4], max(h_sat_vapor, H[2]), 21)
+                )
 
             if H[4] > h_sat_liquid and not (H[2] > h_sat_vapor):
-                for h in np.linspace(
-                    min(h_sat_vapor, H[4]), max(h_sat_liquid, H[2]), 21
+                for point in self._isobar_points(
+                    p_high, min(h_sat_vapor, H[4]), max(h_sat_liquid, H[2]), 21
                 ):
-                    if not _repeats_last_point(t_h_curve_points, h):
-                        state = self._compute_state_from_pressure_enthalpy(
-                            P=p_high, h=h
-                        )
-                        t_h_curve_points.append([h, float(state.T())])
+                    if not _repeats_last_point(t_h_curve_points, point[0]):
+                        t_h_curve_points.append(point)
 
             if H[2] < h_sat_liquid:
-                for h in np.linspace(min(h_sat_liquid, H[4]), H[2], 21):
-                    if not _repeats_last_point(t_h_curve_points, h):
-                        state = self._compute_state_from_pressure_enthalpy(
-                            P=p_high, h=h
-                        )
-                        t_h_curve_points.append([h, float(state.T())])
+                for point in self._isobar_points(
+                    p_high, min(h_sat_liquid, H[4]), H[2], 21
+                ):
+                    if not _repeats_last_point(t_h_curve_points, point[0]):
+                        t_h_curve_points.append(point)
 
         else:
             # Determine supercritical gas cooler profile
@@ -918,23 +987,23 @@ class VapourCompressionCycle:
             h_sat_liquid = self._compute_state_from_pressure_quality(p_low, 0.0).hmass()
 
             if H[3] < h_sat_liquid:
-                for h in np.linspace(H[3], min(h_sat_liquid, H[5]), 21):
-                    state = self._compute_state_from_pressure_enthalpy(P=p_low, h=h)
-                    t_h_curve_points.append([h, float(state.T())])
+                t_h_curve_points.extend(
+                    self._isobar_points(p_low, H[3], min(h_sat_liquid, H[5]), 21)
+                )
 
             if H[3] < h_sat_vapor and not (H[5] < h_sat_liquid):
-                for h in np.linspace(
-                    max(h_sat_liquid, H[3]), min(h_sat_vapor, H[5]), 21
+                for point in self._isobar_points(
+                    p_low, max(h_sat_liquid, H[3]), min(h_sat_vapor, H[5]), 21
                 ):
-                    if not _repeats_last_point(t_h_curve_points, h):
-                        state = self._compute_state_from_pressure_enthalpy(P=p_low, h=h)
-                        t_h_curve_points.append([h, float(state.T())])
+                    if not _repeats_last_point(t_h_curve_points, point[0]):
+                        t_h_curve_points.append(point)
 
             if H[5] > h_sat_vapor:
-                for h in np.linspace(max(h_sat_vapor, H[3]), H[5], 21):
-                    if not _repeats_last_point(t_h_curve_points, h):
-                        state = self._compute_state_from_pressure_enthalpy(P=p_low, h=h)
-                        t_h_curve_points.append([h, float(state.T())])
+                for point in self._isobar_points(
+                    p_low, max(h_sat_vapor, H[3]), H[5], 21
+                ):
+                    if not _repeats_last_point(t_h_curve_points, point[0]):
+                        t_h_curve_points.append(point)
 
         else:
             # Determine supercritical gas heater profile

{openpinch-0.7.4 → openpinch-0.7.6}/OpenPinch/analysis/heat_pumps/targeting/cascade_vapour_compression.py

@@ -34,6 +34,7 @@ from ..common.shared import (
     cap_stage_condensing_temperatures,
     condensing_temperature_search_range,
     evaluate_vapour_hpr_result,
+    floor_stage_evaporating_temperatures,
     validate_vapour_hp_refrigerant_ls,
 )
 from ..cycles.cascade_vapour_compression_cycle import CascadeVapourCompressionCycle
@@ -246,7 +247,12 @@ def _parse_cascade_hp_state_variables(
     T_cond = cap_stage_condensing_temperatures(
         map_x_arr_to_T_arr(x_cond, *condensing_temperature_search_range(args)), args
     )
-    T_evap = map_x_arr_to_T_arr(x_evap, args.T_hot[-1], args.T_hot[0])
+    T_evap = floor_stage_evaporating_temperatures(
+        map_x_arr_to_T_arr(x_evap, args.T_hot[-1], args.T_hot[0]),
+        args,
+        # Process evaporators sit on the coldest stages.
+        first_stage=n_cond - 1,
+    )
     dT_subcool = map_x_arr_to_DT_arr(x_subcool, T_cond, args.T_cold[0])
     Q_heat_available = (
         limit_available_duty(

{openpinch-0.7.4 → openpinch-0.7.6}/OpenPinch/analysis/heat_pumps/targeting/parallel_vapour_compression.py

@@ -28,6 +28,7 @@ from ..common.shared import (
     cap_stage_condensing_temperatures,
     condensing_temperature_search_range,
     evaluate_vapour_hpr_result,
+    floor_stage_evaporating_temperatures,
     validate_vapour_hp_refrigerant_ls,
 )
 from ..cycles.parallel_vapour_compression_cycles import (
@@ -161,7 +162,9 @@ def _parse_parallel_hp_state_temperatures(
     T_cond = cap_stage_condensing_temperatures(
         map_x_arr_to_T_arr(x_cond, *condensing_temperature_search_range(args)), args
     )
-    T_evap = map_x_arr_to_T_arr(x_evap, args.T_hot[-1], args.T_hot[0])
+    T_evap = floor_stage_evaporating_temperatures(
+        map_x_arr_to_T_arr(x_evap, args.T_hot[-1], args.T_hot[0]), args
+    )
     dT_subcool = map_x_arr_to_DT_arr(x_subcool, T_cond, T_evap)
     Q_heat_available = (
         limit_available_duty(

{openpinch-0.7.4 → openpinch-0.7.6}/OpenPinch/analysis/heat_pumps/targeting/vapour_compression_mvr.py

@@ -30,6 +30,7 @@ from ..common.shared import (
     cap_stage_condensing_temperatures,
     condensing_temperature_search_range,
     evaluate_vapour_hpr_result,
+    floor_stage_evaporating_temperatures,
     is_negligible_useful_duty,
     post_solve_error,
     validate_vapour_hp_refrigerant_ls,
@@ -176,10 +177,13 @@ def _parse_vc_mvr_state_variables(
         map_x_arr_to_T_arr(parts["x_cond"], *condensing_temperature_search_range(args)),
         args,
     )
-    T_evap_vc = map_x_arr_to_T_arr(
-        parts["x_evap"],
-        args.T_hot[-1],
-        args.T_hot[0],
+    T_evap_vc = floor_stage_evaporating_temperatures(
+        map_x_arr_to_T_arr(
+            parts["x_evap"],
+            args.T_hot[-1],
+            args.T_hot[0],
+        ),
+        args,
     )
     Q_heat_available = limit_available_duty(
         get_Q_vals_at_T_hpr_from_bckgrd_profile(

{openpinch-0.7.4 → openpinch-0.7.6}/OpenPinch/domain/fluids.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import functools
 import math
 import re
 from typing import Any
@@ -52,6 +53,23 @@ def build_coolprop_abstract_state(value: str | Any):
     return state
 
 
+@functools.cache
+def critical_point(value: str) -> tuple[float, float, float]:
+    """Return a fluid spec's critical temperature (K), pressure (Pa) and density.
+
+    A mixture's critical point is a costly CoolProp solve, so each spec is
+    solved once per process.
+    """
+    import CoolProp
+
+    state = build_coolprop_abstract_state(value)
+    return (
+        state.keyed_output(CoolProp.iT_critical),
+        state.keyed_output(CoolProp.iP_critical),
+        state.keyed_output(CoolProp.irhomass_critical),
+    )
+
+
 def validate_coolprop_fluid_name(value: str) -> None:
     """Validate a CoolProp fluid or mixture name by constructing its state object."""
     try:

{openpinch-0.7.4 → openpinch-0.7.6}/OpenPinch/tutorials/sample_cases/pulp_mill.json

@@ -1656,7 +1656,7 @@
         },
         {
             "zone": "Digestion",
-            "name": "Cooling od Acc.0",
+            "name": "Cooling od Acc-0",
             "t_supply": {
                 "value": 80,
                 "unit": "degC"

{openpinch-0.7.4 → openpinch-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: OpenPinch
-Version: 0.7.4
+Version: 0.7.6
 Summary: An advanced pinch analysis and total site integration toolkit
 Project-URL: Homepage, https://github.com/waikato-ahuora-smart-energy-systems/OpenPinch
 Project-URL: Issues, https://github.com/waikato-ahuora-smart-energy-systems/OpenPinch/issues

{openpinch-0.7.4 → openpinch-0.7.6}/pyproject.toml

@@ -36,7 +36,7 @@ dependencies=[
   "pydantic>=2.12,<3",
   "scipy>=1.16.1,<2",
 ]
-version = "0.7.4"
+version = "0.7.6"
 authors = [
   { name="Tim Walmsley", email="tim.walmsley@waikato.ac.nz" },
 ]