OpenPinch 0.8.2__tar.gz → 0.8.3__tar.gz

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_exchanger_networks/README.md

@@ -21,7 +21,7 @@ Heat exchanger network (HEN) synthesis, fixed-structure duty optimisation and co
   - [targeting](./targeting/README.md): method orchestration and topology helpers.
 
 ## Invariants
-- Runtime options must be a dict or `None` and must not contain `HENS_` keys; persistent controls are loaded with the problem [context.py:normalise_runtime_options].
+- Runtime options reaching this package must be a dict or `None` and must not contain `HENS_` keys; persistent controls are loaded with the problem. The `problem.design` accessors move `HENS_` keys from a call's `options` into that call's configuration before this check, so users may pass them there [context.py:normalise_runtime_options].
 - Open-HENS and PDM reject `initial_networks`; `method=None` runs tier 0 and `OpenHENS` runs tier 1 [service.py:heat_exchanger_network_synthesis_service].
 - The call-local quality tier of the OpenHENS entry points must be an integer from 0 to 5; the standalone method services use the configured tier [service.py:_validate_quality_tier].
 - An accepted design is ranked, selected and verified; verification failures raise `RuntimeError` [context.py:finalise_design_result].
@@ -33,7 +33,7 @@ Heat exchanger network (HEN) synthesis, fixed-structure duty optimisation and co
 ## Side Effects
 - `finalise_design_result` assigns `problem._results` with the design attached [context.py:finalise_design_result].
 - `ensure_target_results` runs direct heat integration through `problem.target` when no matching targets are cached [context.py:ensure_target_results].
-- Synthesis runs solver models in a `ProcessPoolExecutor` through `LocalSynthesisExecutor` when more than one worker is available; duty optimisation solves serially in-process through `FixedStructureDutyExecutor`. Both launch external solver executables via GEKKO/Pyomo [execution/executor.py:LocalSynthesisExecutor, duty_optimisation.py:FixedStructureDutyExecutor].
+- Synthesis runs solver models in a `ProcessPoolExecutor` through `LocalSynthesisExecutor` when more than one worker is available and the main script has a main guard (or the start method is fork); duty optimisation solves serially in-process through `FixedStructureDutyExecutor`. Both launch external solver executables via GEKKO/Pyomo [execution/executor.py:LocalSynthesisExecutor, duty_optimisation.py:FixedStructureDutyExecutor].
 - Controllability and indexing are pure.
 
 ## Verification

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_exchanger_networks/execution/README.md

@@ -31,7 +31,7 @@ Resolves synthesis settings from a prepared problem, plans the quality-tier path
 - The fake executor requires successful parents for downstream tasks [fake_executor.py:FakeSynthesisExecutor.execute].
 
 ## Side Effects
-- Spawns solver worker processes through `ProcessPoolExecutor`, falling back to serial when the pool raises `NotImplementedError` [executor.py:_process_pool, LocalSynthesisExecutor._map].
+- Spawns solver worker processes through `ProcessPoolExecutor`, falling back to serial when the pool raises `NotImplementedError`. The default pool raises it, after logging a warning, when the start method is not fork and the `__main__` script has no main guard, so it reads and parses that script [executor.py:_process_pool, LocalSynthesisExecutor._map] [../../../optimisation/execution.py:_main_module_reruns_in_workers].
 - Emits progress events [executor.py:LocalSynthesisExecutor._report_progress].
 - Mutates its own bookkeeping (`executed_tasks`, `stage_order`, `problems_by_task_id`, `best_objective`) [executor.py:LocalSynthesisExecutor].
 - Emits a `RuntimeWarning` when the Couenne fallback is taken [fallbacks.py:_warn_couenne_fallback].

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_exchanger_networks/execution/executor.py

@@ -12,6 +12,7 @@ from ....contracts.synthesis.task import (
 )
 from ....domain.enums import HeatExchangerNetworkDesignMethod
 from ....domain.progress import emit as emit_progress
+from ....optimisation.execution import _main_module_reruns_in_workers
 from ...parallelism import supported_workers
 from ..errors import WorkflowContractError
 from ..models.problem import InternalHeatExchangerNetworkProblem
@@ -23,7 +24,13 @@ logger = logging.getLogger(__name__)
 
 def _process_pool(max_workers: int) -> ProcessPoolExecutor:
     """Create solver workers with the interpreter's default process context."""
-
+    if _main_module_reruns_in_workers():
+        logger.warning(
+            "Solving HEN tasks serially: the main script has no main guard, "
+            "so every worker process would rerun it. Put the script's entry "
+            'code under `if __name__ == "__main__":` to use worker processes.'
+        )
+        raise NotImplementedError("the main script has no main guard")
     return ProcessPoolExecutor(max_workers=max_workers)
 
 

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_pumps/README.md

@@ -18,6 +18,7 @@ a docstring.
 - `build_hpr_accounting`, `calc_hpr_obj`, `relative_feasibility_penalty`, `normalise_hpr_penalty_terms`, `normalise_initial_points`, `initialise_hpr_seed` (`optimisation_adapter.py`): objective, penalty and seed helpers (`initialise_hpr_seed` is public but not in `__all__`).
 - `ProcessComponent`, `ProcessComponentHost` (`components.py`): component base record and the protocol it needs from the problem object.
 - `ProcessMVRComponent`, `create_process_mvr_component`, `replay_process_components`, `restore_process_components` (`process_mvr.py`): direct process MVR component with replacement streams, its factory, its re-solve on a rebuilt zone tree, and its rebuild from saved records.
+- `screen_refrigerants`, `screen_refrigerant`, `resolve_refrigerants`, `RefrigerantScreenThresholds`, `RefrigerantScreenEntry`, `NATURAL_REFRIGERANTS` (`refrigerant_screen.py`): screen candidate fluids as single-stage cycles between evaporating and condensing saturation levels, and resolve a candidate group (`all` CoolProp fluids, `natural`) or a list of names.
 - Subdirectories:
   - [_multiperiod](./_multiperiod/README.md): shared-design preparation, execution and aggregation across periods (documented elsewhere).
   - [_process_mvr](./_process_mvr/README.md): private helpers for process MVR selection, membership, replacement streams and work.
@@ -52,6 +53,11 @@ a docstring.
 - A saved record names each source by its owning zone's path below the root and its stream name, so a name selector that matched several streams saves all of them and a renamed project still resolves; the `options` and `period_id` of the original call only check the call and are not saved. A missing source raises `ValueError`. [process_mvr.py:ProcessMVRComponent._to_record] [process_mvr.py:restore_process_components]
 - `original_streams`, `replacement_streams` and `stage_results_by_period` return deep copies. [process_mvr.py:ProcessMVRComponent]
 
+- A refrigerant screen judges each fluid in this order: condensing within `dt_cont` of the critical point is above critical; evaporating below CoolProp's minimum temperature is below the triple point; then, from saturation properties, a pressure ratio above `max_pressure_ratio`, a suction pressure below `min_suction_pressure` and condensing within `critical_margin` of the critical point; otherwise practical. Fluids without a saturation state carry no pressures or capacity. [refrigerant_screen.py:screen_refrigerant]
+- A screen covers every evaporating and condensing level pair with positive lift, in level order, and raises `ValueError` when none has; within a pair the practical fluids come first, ranked from 1 by descending suction volumetric heating capacity, then the others in candidate order. [refrigerant_screen.py:screen_refrigerants]
+- `RefrigerantScreenThresholds.from_configuration` reads `HPR_DT_CONT`, `HPR_MAX_PRESSURE_RATIO`, `HPR_SCREEN_MIN_SUCTION_PRESSURE` (bar, held in Pa) and `HPR_SCREEN_CRITICAL_MARGIN`. [refrigerant_screen.py:RefrigerantScreenThresholds]
+- Candidate lists are validated by name and mixtures are rejected; `all` is whatever the installed CoolProp lists, so it differs between CoolProp versions. [refrigerant_screen.py:resolve_refrigerants]
+
 ## Side Effects
 - Deep-copies the base target's problem table and mutates the copy with HPR, air and residual columns. [service.py:_compute_single_period_hpr_target] [service.py:_calc_hpr_cascade]
 - Emits progress events for `hpr_targeting` through `domain.progress`. [optimisation_adapter.py:solve_hpr_placement] [optimisation_adapter.py:_CachedHPRScalarObjective]

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_pumps/common/README.md

@@ -11,6 +11,7 @@ multi-stage vapour-compression objective, and residual utility accounting.
 ## Interface
 - `construct_HPRTargetInputs`, `default_refrigeration_to_power_ratio` (`preprocessing.py`): build `HeatPumpTargetInputs` (shifted, simplified background profiles, ambient flags, cost and cycle settings) from a zone's cascades and `Configuration`; default refrigeration electricity ratio.
 - `resolve_hpr_target_load` (`load_selection.py`): requested HPR duty from `config.hpr.load_mode` (`fraction`, `duty`, `period_values`), capped by the available cascade duty in `duty` and `period_values` modes only.
+- `find_hpr_load_kinks`, `HprLoadKinkProfile`, `LoadKinkVertex` (`load_kinks.py`): classify every interior vertex of the heat pump sink (`H_NET_COLD`) or refrigeration source (`H_NET_HOT`) net load profile as step, steepens, flattens or minor, and list the logical load fractions (step and steepens vertices, then 1.0).
 - `HPRoptVectorLayout`, `clip_to_bounds` (`layout.py`): named sections of a flat optimisation vector (`pack`, `unpack`, `build_bounds`) and clipping of seeds into bounds.
 - Duty and temperature encoding (`encoding.py`): `decode_available_fractions`, `encode_available_fractions`, `limit_available_duty`, `allocate_stage_duties`, `require_stage_duty_allocation`, `DutyAllocation`, `StageDutyRequest`, `DutyAllocationRequest` (with `from_state`), and the `map_*_to_*_arr` pairs between optimisation fractions and temperatures, temperature differences or duties.
 - Costing and results (`shared.py`): `HPRCostUnit`, `calc_hpr_capital_cost`, `calc_hpr_machine_capital_costs`, `calc_simulated_hpr_annualized_costs`, `hpr_penalty_cost_scale`, `refrigeration_allowance`, `evaluate_carnot_hpr_result`, `evaluate_vapour_hpr_result`, `post_solve_error`; `limit_parallel_pressure_ratios` raises evaporating temperatures and `limit_cascade_pressure_ratios` raises each lower level (condensing or evaporating) to meet `hpr.max_pressure_ratio`, and both do nothing for TESPy or when no refrigerants are set; constants `EVAPORATING_FLOOR_MARGIN_K`, `NEGLIGIBLE_STAGE_WORK_FRACTION`.
@@ -18,6 +19,7 @@ multi-stage vapour-compression objective, and residual utility accounting.
 - Thermodynamic helpers (`shared.py`): `calc_carnot_heat_pump_cop`, `calc_carnot_heat_engine_eta`, `compute_entropic_mean_temperature`, and `satisfies_second_law` (public but not in `__all__`).
 - `_evaluate_multi_vc_objective` (`multi_vc_objective.py`): shared objective for cascade and parallel vapour-compression targeting (parse vector, solve, build streams, account, attach CoolProp record).
 - `value_at_index`, `to_kelvin`, `to_degrees_celsius`, `to_kilopascal` (`units.py`): period-indexed value and unit conversion.
+- Compressor efficiency (`compressor_efficiency.py`): `CompressorConditions` (refrigerant, suction and discharge pressures in kPa, `pressure_ratio`, suction temperature and dew points in degC, suction and saturated vapour densities in kg/m3), `compressor_efficiency_model` (a model name or function to a constant or a function of the conditions), `evaluate_compressor_model`, `CompressorModelError`, and the HeatPumpLab correlations `pareto_front_efficiency`, `wang_cleland_efficiency`, `brendel_efficiency`.
 - `postprocessing.py`: only private functions; `_get_hpr_residual_utility_summary` is the one the service imports, retargeting utilities against the residual cascade after the HPR.
 - Subdirectories: [_shared](./_shared/README.md): private air, stream and plotting helpers behind `shared.py`.
 
@@ -27,6 +29,7 @@ multi-stage vapour-compression objective, and residual utility accounting.
 - A zero target raises `ValueError` for heat pumping [preprocessing.py:_get_reduced_bckgrd_cascade_till_Q_target] and, when the cooling profile exceeds the target, for refrigeration [preprocessing.py:_split_cooling_profile_at_coldest_Q_target].
 - The default refrigeration price ratio is never below the cooling-water ratio. [preprocessing.py:default_refrigeration_to_power_ratio]
 - Stage duties are decoded as fractions in [0, 1] of each stage's available duty, so no stage can request more than it can deliver. [encoding.py:decode_available_fractions]
+- Load kinks walk the sink profile up from the pinch and the source profile down from it, after dropping repeated rows; slopes are `|dT| / d(Q/Q_max)`. A vertex followed by no duty is a step, and the step's top row is not listed again. Otherwise it steepens when `slope_after >= steepening * slope_before` (and `slope_after > 0`), flattens on the mirror condition, and is minor otherwise. `steepening <= 1` and a profile with no duty raise `ValueError`. Duty below `1e-9 * Q_max` and temperature change below `1e-9` K count as zero. [load_kinks.py:find_hpr_load_kinks]
 - `HPRoptVectorLayout` section order is cond, evap, subcool, heat_split, cool_split, ihx, misc, and counts must be non-negative. [layout.py:HPRoptVectorLayout]
 - The load is `Q_max * load_fraction` in `fraction` mode and is capped at the available duty `Q_max` in `duty` and `period_values` modes; an unknown mode, a missing `config` or a missing period key raises `ValueError`. [load_selection.py:resolve_hpr_target_load]
 - Machine capital is `F_inst * C_eq * (Q_cap/MW)^exp * stage factor * temperature factor`, per machine, and zero for a machine with no capacity. [shared.py:calc_hpr_machine_capital_costs]
@@ -36,6 +39,7 @@ multi-stage vapour-compression objective, and residual utility accounting.
 - Ambient air and cooling water are applied through `cascade_with_air` on the condenser and evaporator cascades; cooling water applies on the evaporator side only. Air is left out when `args.ambient_air_enabled` is false (`HPR_AMBIENT_AIR_ENABLED`). [shared.py:_cascade_air_duties]
 - `calc_carnot_heat_pump_cop` and `calc_carnot_heat_engine_eta` take absolute temperatures (K); `satisfies_second_law` takes degC and adds 273.15 internally, and `compute_entropic_mean_temperature` takes degC by default and returns K. [shared.py:calc_carnot_heat_pump_cop] [shared.py:satisfies_second_law]
 - Residual loads below `max(tol, 1e-7 * largest)` are treated as rounding noise and set to zero; duplicate residual temperatures with conflicting values raise `ValueError`. [postprocessing.py:_residual_noise_floor] [postprocessing.py:_deduplicate_residual_profile_rows]
+- `HPR_COMPRESSOR_MODEL` and `HPR_MVR_COMPRESSOR_MODEL` `"constant"` pass `HPR_ETA_COMP` and `HPR_MVR_ETA_COMP` through as floats, so the default cycles are unchanged; only the vapour compression cycle types take a `HPR_COMPRESSOR_MODEL` model, and other types (Brayton passes `eta_comp` to TESPy) keep `HPR_ETA_COMP`; the named models are HeatPumpLab's correlations bounded to [0.4, 1.0] and pickle. [preprocessing.py:construct_HPRTargetInputs] [compressor_efficiency.py:compressor_efficiency_model]
 - `common` imports the parent's `optimisation_adapter` and `performance_maps.targeting` for accounting and backend names. [shared.py] [preprocessing.py]
 
 ## Side Effects
@@ -47,4 +51,4 @@ multi-stage vapour-compression objective, and residual utility accounting.
 
 ## Verification
 - Run: `uv run --no-sync pytest tests/analysis/heat_pumps/test_shared.py tests/analysis/heat_pumps/test_encoding.py tests/analysis/heat_pumps/test_layout.py tests/analysis/heat_pumps/test_preprocessing.py`
-- `postprocessing.py` is covered by `tests/analysis/heat_pumps/test_hpr_residual_regressions.py`; `load_selection.py` by `tests/analysis/heat_pumps/test_targeting.py`. `multi_vc_objective.py` and `units.py` have no direct test; they are exercised through the cascade and parallel vapour-compression tests.
+- `postprocessing.py` is covered by `tests/analysis/heat_pumps/test_hpr_residual_regressions.py`; `load_selection.py` by `tests/analysis/heat_pumps/test_targeting.py`. `load_kinks.py` by `tests/analysis/heat_pumps/test_load_kinks.py`. `multi_vc_objective.py` and `units.py` have no direct test; they are exercised through the cascade and parallel vapour-compression tests.

openpinch-0.8.3/OpenPinch/analysis/heat_pumps/common/compressor_efficiency.py

@@ -0,0 +1,136 @@
+"""Compressor isentropic efficiency models for vapour compression HPR cycles.
+
+The correlations follow HeatPumpLab (Apache-2.0,
+https://github.com/waikato-ahuora-smart-energy-systems/HeatPumpLab,
+``HeatPumpLab.components.compressor``).
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+from dataclasses import dataclass
+
+# Pareto front of design compressor efficiency against pressure ratio (HeatPumpLab,
+# October 2026): eta(PR) = eta_1 - a ln(PR)^b - d / (1 + exp(-(ln(PR) - L0) / w)),
+# a lower envelope of the best published shaft-basis isentropic efficiency for
+# 1 <= PR <= 20.
+_PARETO_FRONT_COEFFS = (0.8695, 0.025392, 1.476, 0.29915, 2.9599, 0.2)
+
+
+def pareto_front_efficiency(pressure_ratio: float) -> float:
+    """Return the shaft-basis isentropic efficiency on the Pareto front."""
+    log_pr = math.log(max(float(pressure_ratio), 1.0))
+    eta_1, a, b, d, L0, w = _PARETO_FRONT_COEFFS
+    return eta_1 - a * log_pr**b - d / (1.0 + math.exp(-(log_pr - L0) / w))
+
+
+def wang_cleland_efficiency(pressure_ratio: float) -> float:
+    """Return the shaft-basis isentropic efficiency of Wang and Cleland (2018).
+
+    The overall efficiency polynomial is divided by a motor efficiency of 0.96.
+    """
+    pr = float(pressure_ratio)
+    return (0.65 + 0.015 * pr - 0.0015 * pr**2) / 0.96
+
+
+def brendel_efficiency(pressure_ratio: float, suction_pressure: float) -> float:
+    """Return the isentropic efficiency of Brendel et al.; pressure in kPa.
+
+    The correlation takes the suction pressure in MPa; without compression
+    (pressure ratio at most 1) it returns 0.4.
+    """
+    pr = float(pressure_ratio)
+    if pr <= 1.0:
+        return 0.4
+    P_mpa = float(suction_pressure) / 1000.0
+    return 0.66981 - 0.6 / (pr - 0.01466) ** (8.38 * P_mpa) - 0.00102 * pr**1.8
+
+
+@dataclass(frozen=True)
+class CompressorConditions:
+    """Operating point handed to a compressor efficiency model.
+
+    Pressures are in kPa, temperatures in degC and densities in kg/m3. The dew
+    points are those of the refrigerant at the suction and discharge pressures,
+    the basis of manufacturer maps in evaporating and condensing temperature.
+    """
+
+    refrigerant: str
+    P_suction: float
+    P_discharge: float
+    T_suction: float
+    T_evap_dew: float
+    T_cond_dew: float
+    rho_suction: float
+    rho_evap_dew: float
+    rho_cond_dew: float
+
+    @property
+    def pressure_ratio(self) -> float:
+        """Discharge over suction pressure."""
+        return self.P_discharge / self.P_suction
+
+
+CompressorEfficiencyFunction = Callable[[CompressorConditions], float]
+
+# HeatPumpLab bounds every correlation to this range.
+_CORRELATION_BOUNDS = (0.4, 1.0)
+
+
+@dataclass(frozen=True)
+class _Correlation:
+    """A built-in correlation by name; a plain class so it pickles."""
+
+    name: str
+
+    def __call__(self, conditions: CompressorConditions) -> float:
+        pr = conditions.pressure_ratio
+        if self.name == "pareto_front":
+            eta = pareto_front_efficiency(pr)
+        elif self.name == "wang_cleland":
+            eta = wang_cleland_efficiency(pr)
+        else:
+            eta = brendel_efficiency(pr, conditions.P_suction)
+        lo, hi = _CORRELATION_BOUNDS
+        return min(max(eta, lo), hi)
+
+
+def compressor_efficiency_model(
+    model: str | CompressorEfficiencyFunction, eta_constant: float
+) -> float | CompressorEfficiencyFunction:
+    """Return a constant efficiency or a function of ``CompressorConditions``.
+
+    ``"constant"`` gives ``eta_constant``; a built-in name gives its bounded
+    correlation; a function is returned as given.
+    """
+    if callable(model):
+        return model
+    if model == "constant":
+        return float(eta_constant)
+    return _Correlation(model)
+
+
+class CompressorModelError(RuntimeError):
+    """A compressor model returned an unusable efficiency."""
+
+
+def evaluate_compressor_model(
+    model: CompressorEfficiencyFunction, conditions: CompressorConditions
+) -> float:
+    """Return the model's isentropic efficiency, which must lie in (0, 1].
+
+    A ``ValueError`` raised by the model marks the operating point infeasible
+    for the targeting search; an efficiency out of range raises
+    ``CompressorModelError``, which stops it.
+    """
+    eta = float(model(conditions))
+    if not 0.0 < eta <= 1.0:
+        name = getattr(model, "name", None) or getattr(
+            model, "__name__", type(model).__name__
+        )
+        raise CompressorModelError(
+            f"Compressor model {name} returned an isentropic efficiency of {eta}; "
+            "it must lie in (0, 1]."
+        )
+    return eta

openpinch-0.8.3/OpenPinch/analysis/heat_pumps/common/load_kinks.py

@@ -0,0 +1,127 @@
+"""Logical heat pump and refrigeration loads from net load profile kinks."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from ....contracts.hpr_load_kinks import LOGICAL_LOAD_KINDS, HprLoadKinkKind
+
+__all__ = ["HprLoadKinkProfile", "LoadKinkVertex", "find_hpr_load_kinks"]
+
+# Duty below this fraction of the profile's total, or a temperature change
+# below this many kelvin, is treated as zero.
+_DUTY_RELATIVE_TOLERANCE = 1e-9
+_TEMPERATURE_TOLERANCE = 1e-9
+
+
+@dataclass(frozen=True)
+class LoadKinkVertex:
+    """One interior vertex in canonical units (kW, shifted degC, K)."""
+
+    load_fraction: float
+    duty: float
+    temperature: float
+    slope_before: float
+    slope_after: float | None
+    kind: HprLoadKinkKind
+
+
+@dataclass(frozen=True)
+class HprLoadKinkProfile:
+    """Every interior vertex of one net load profile and its logical loads."""
+
+    maximum_duty: float
+    vertices: tuple[LoadKinkVertex, ...]
+    logical_load_fractions: tuple[float, ...]
+
+
+def find_hpr_load_kinks(
+    T_vals: np.ndarray,
+    H_net_cold: np.ndarray,
+    H_net_hot: np.ndarray,
+    *,
+    is_refrigeration: bool = False,
+    steepening: float = 2.0,
+) -> HprLoadKinkProfile:
+    """Classify the vertices of the sink (or source) net load profile.
+
+    Rows run from the hottest temperature down, as in a problem table. A heat
+    pump walks the sink profile up from the pinch; refrigeration walks the
+    source profile down from it. The slope is the temperature change per unit
+    load fraction. A vertex is a logical load when the profile steps (changes
+    temperature with no duty) or its slope after is at least ``steepening``
+    times its slope before. The full load, 1.0, is always a logical load.
+    """
+    if not steepening > 1.0:
+        raise ValueError("steepening must be greater than 1.")
+    temperatures = np.asarray(T_vals, dtype=float)
+    if is_refrigeration:
+        duties = np.abs(np.asarray(H_net_hot, dtype=float))
+    else:
+        duties = np.abs(np.asarray(H_net_cold, dtype=float))[::-1]
+        temperatures = temperatures[::-1]
+    maximum_duty = float(np.nanmax(duties, initial=0.0))
+    if not 0.0 < maximum_duty < np.inf:
+        profile = "refrigeration source" if is_refrigeration else "heat pump sink"
+        raise ValueError(f"The net load profile has no {profile} duty.")
+    duty_tolerance = _DUTY_RELATIVE_TOLERANCE * maximum_duty
+
+    start = int(np.flatnonzero(duties <= duty_tolerance)[-1])
+    end = int(np.flatnonzero(duties >= maximum_duty - duty_tolerance)[0])
+    points = [(duties[start], temperatures[start])]
+    for duty, temperature in zip(
+        duties[start + 1 : end + 1], temperatures[start + 1 : end + 1]
+    ):
+        last_duty, last_temperature = points[-1]
+        if (
+            duty - last_duty > duty_tolerance
+            or abs(temperature - last_temperature) > _TEMPERATURE_TOLERANCE
+        ):
+            points.append((duty, temperature))
+
+    vertices = []
+    for before, vertex, after in zip(points, points[1:], points[2:]):
+        if vertex[0] - before[0] <= duty_tolerance:
+            # The top of a step is the same load as its foot.
+            continue
+        slope_before = _slope(before, vertex, maximum_duty)
+        slope_after = (
+            None
+            if after[0] - vertex[0] <= duty_tolerance
+            else _slope(vertex, after, maximum_duty)
+        )
+        vertices.append(
+            LoadKinkVertex(
+                load_fraction=float(vertex[0] / maximum_duty),
+                duty=float(vertex[0]),
+                temperature=float(vertex[1]),
+                slope_before=slope_before,
+                slope_after=slope_after,
+                kind=_kind(slope_before, slope_after, steepening),
+            )
+        )
+    logical = tuple(v.load_fraction for v in vertices if v.kind in LOGICAL_LOAD_KINDS)
+    return HprLoadKinkProfile(
+        maximum_duty=maximum_duty,
+        vertices=tuple(vertices),
+        logical_load_fractions=logical + (1.0,),
+    )
+
+
+def _slope(start, end, maximum_duty: float) -> float:
+    """Temperature change per unit load fraction between two points."""
+    return float(abs(end[1] - start[1]) / ((end[0] - start[0]) / maximum_duty))
+
+
+def _kind(
+    slope_before: float, slope_after: float | None, steepening: float
+) -> HprLoadKinkKind:
+    if slope_after is None:
+        return HprLoadKinkKind.STEP
+    if slope_after > 0.0 and slope_after >= steepening * slope_before:
+        return HprLoadKinkKind.STEEPENS
+    if slope_before > 0.0 and slope_before >= steepening * slope_after:
+        return HprLoadKinkKind.FLATTENS
+    return HprLoadKinkKind.MINOR

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_pumps/common/preprocessing.py

@@ -8,11 +8,22 @@ from ....analysis.graphs.composite import clean_composite_curve
 from ....analysis.numerics import delta_vals, linear_interpolation
 from ....contracts.hpr import HeatPumpTargetInputs, HPRSearchBudget
 from ....domain.configuration import Configuration, tol
-from ....domain.enums import ProblemTableLabel
+from ....domain.enums import HeatPumpAndRefrigerationCycle, ProblemTableLabel
 from ....domain.problem_table import ProblemTable
 from ....domain.stream import Stream
 from ....domain.stream_collection import StreamCollection
 from ..performance_maps.targeting import normalize_hpr_simulation_backend
+from .compressor_efficiency import compressor_efficiency_model
+
+# Cycles whose CoolProp models apply a compressor efficiency model; Brayton
+# passes eta_comp to TESPy, which needs a number.
+_VAPOUR_CYCLES = frozenset(
+    {
+        HeatPumpAndRefrigerationCycle.CascadeVapourComp.value,
+        HeatPumpAndRefrigerationCycle.ParallelVapourComp.value,
+        HeatPumpAndRefrigerationCycle.VapourCompMVR.value,
+    }
+)
 
 __all__ = [
     "construct_HPRTargetInputs",
@@ -106,9 +117,15 @@ def construct_HPRTargetInputs(
         refrigerant_ls=hpr.normalised_refrigerants,
         mvr_fluid_ls=hpr.normalised_mvr_fluids,
         do_refrigerant_sort=hpr.refrigerant_sort_enabled,
-        eta_comp=hpr.eta_comp,
-        eta_mvr_comp=hpr.mvr_eta_comp,
-        eta_motor=hpr.mvr_eta_motor,
+        eta_comp=compressor_efficiency_model(
+            hpr.compressor_model if hpr.type in _VAPOUR_CYCLES else "constant",
+            hpr.eta_comp,
+        ),
+        eta_mvr_comp=compressor_efficiency_model(
+            hpr.mvr_compressor_model, hpr.mvr_eta_comp
+        ),
+        eta_motor=hpr.eta_motor,
+        eta_mvr_motor=hpr.mvr_eta_motor,
         eta_exp=hpr.eta_exp,
         eta_ii_hpr_carnot=hpr.eta_ii_carnot,
         eta_ii_he_carnot=hpr.effective_eta_ii_he_carnot,

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_pumps/cycles/README.md

@@ -15,7 +15,9 @@ in `../common`. `__init__.py` has only a docstring.
 - `CascadeVapourCompressionCycle` (`cascade_vapour_compression_cycle.py`): stages coupled through cascade exchangers; `solve` takes condenser and evaporator temperature arrays and a `DutyAllocationRequest`. Stages are ordered hottest first and heat always passes up the cascade. A heat pump solves from the top stage down and the coldest stage takes the remaining cooling; a refrigerator solves from the coldest stage up and the top stage rejects the remaining heat.
 - `ParallelVapourCompressionCycles` (`parallel_vapour_compression_cycles.py`): independent subcycles solved side by side.
 - `MechanicalVapourRecompressionCycle` (`mechanical_vapour_recompression_cycle.py`): open MVR stage with liquid-injection desuperheating, solved by `solve_from_source_heat` or `solve_from_mass_flow`; `process_heat_components` gives desuperheat, latent and subcool heat.
-- `VapourCompressionMvrCascade` (`vapour_compression_mvr_cascade.py`): vapour-compression stages feeding a serial MVR train; `MAX_MVR_STAGE_LIFT` limits stage lift.
+- `VapourCompressionMvrCascade` (`vapour_compression_mvr_cascade.py`): vapour-compression stages feeding a serial MVR train; `MAX_MVR_STAGE_LIFT` limits stage lift; `eta_comp` gives the efficiency applied in each subcycle, vapour compression stages first.
+- Compressor efficiency: `eta_comp` (vapour compression) and `eta_mvr_comp` (MVR) take a constant or a function of `CompressorConditions` (`../common/compressor_efficiency.py`), evaluated at each compressor's suction and discharge state; the cycles' `eta_comp` and `eta_mvr_comp` properties report the efficiency applied in the last solve.
+- Motor efficiency: `VapourCompressionCycle.solve`, `ParallelVapourCompressionCycles.solve` and `CascadeVapourCompressionCycle.solve` take `eta_motor` (default 1.0, in (0, 1]); `VapourCompressionMvrCascade.solve` takes `eta_vc_motor` for its vapour compression stages and `eta_motor` for its MVR stages. `work`, `w_net` and the COPs are electrical (shaft work divided by `eta_motor`); duties are unchanged. [vapour_compression_cycle.py:VapourCompressionCycle]
 - `CascadeCarnotCycle`, `ParallelCarnotCycles` (`carnot_cycles.py`): Carnot-family heat pump, heat engine and heat recovery stages with second-law efficiency factors.
 - `SimpleBraytonHeatPumpCycle` (`brayton_heat_pump.py`): TESPy Brayton model (experimental, no `__all__`); `solve`, `get_hp_th_profiles`, `get_hp_hot_and_cold_streams`, `build_stream_collection`.
 - `_MultiVapourCompressionCycleBase` (`_multi_cycle_base.py`): private base aggregating duties, temperatures and COPs over `subcycles`; `__all__` is empty.
@@ -26,6 +28,7 @@ in `../common`. `__init__.py` has only a docstring.
 - Cycle temperatures are given in degC, held internally in K, and reported in degC after solving; for the CoolProp vapour cycles, state points hold `H`, `S`, `P`, `T` in SI units (the Brayton cycle uses its own state keys). [vapour_compression_cycle.py:VapourCompressionCycle.solve] [vapour_compression_cycle.py:VapourCompressionCycle._save_cycle_state]
 - A single cycle has `STATECOUNT = 6` states; the MVR cycle has 4. [vapour_compression_cycle.py:VapourCompressionCycle] [mechanical_vapour_recompression_cycle.py:MechanicalVapourRecompressionCycle]
 - `solve` raises `ValueError` for an evaporating temperature below the refrigerant's `Tmin`, an evaporator pressure above the condenser pressure, or a condenser with no enthalpy drop. [vapour_compression_cycle.py:VapourCompressionCycle.solve]
+- A compressor efficiency function outside (0, 1] raises `CompressorModelError`, not `ValueError`, so the targeting search does not read it as an infeasible point; a `ValueError` from the function itself propagates as one. With a constant efficiency no compressor conditions are computed. [vapour_compression_cycle.py:VapourCompressionCycle._compute_compressor_outlet_state]
 - A stage passing heat up gives the hottest of its condenser heat to the cascade exchanger and the coldest to its process duty. Subcooled liquid cannot heat the evaporator above, so subcooling heat must all fit in the process duty: `solve` raises the condenser outlet to that limit, without a penalty, and a stage with no process duty does not subcool. The internal heat exchanger's limit then follows the subcooling applied. [vapour_compression_cycle.py:VapourCompressionCycle._coldest_outlet_serving_cascade_heat] [vapour_compression_cycle.py:VapourCompressionCycle.solve]
 - A cycle is marked solved only when work is finite and non-negative. [vapour_compression_cycle.py:VapourCompressionCycle.solve]
 - Excess subcooling and missing IHX superheat are returned as penalties scaled by mass flow, not as exceptions. [vapour_compression_cycle.py:VapourCompressionCycle.solve]

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_pumps/cycles/cascade_vapour_compression_cycle.py

@@ -309,6 +309,7 @@ class CascadeVapourCompressionCycle(_MultiVapourCompressionCycleBase):
         dT_superheat: np.ndarray = 0.0,
         dT_subcool: np.ndarray = 0.0,
         eta_comp: float = 0.7,
+        eta_motor: float = 1.0,
         refrigerant: List[str] | str = "water",
         dT_ihx_gas_side: np.ndarray | float = 10.0,
         Q_heat: np.ndarray = None,
@@ -334,6 +335,8 @@ class CascadeVapourCompressionCycle(_MultiVapourCompressionCycleBase):
             Degree of subcooling after the condenser, heat delivered to the process [K].
         eta_comp : float, optional
             Isentropic efficiency of the compressor [-].
+        eta_motor : float, optional
+            Efficiency of each compressor motor [-].
         refrigerant : List[str], optional
             Cycle refrigerant; supports multi-component fluids.
         dT_ihx_gas_side : np.ndarray | float, optional
@@ -451,6 +454,7 @@ class CascadeVapourCompressionCycle(_MultiVapourCompressionCycleBase):
                 dT_superheat=dT_superheat_all[i],
                 dT_subcool=dT_subcool_all[i],
                 eta_comp=eta_comp,
+                eta_motor=eta_motor,
                 refrigerant=refrigerant_all[i],
                 dT_ihx_gas_side=ihx_gas_dt_all[i],
                 Q_heat=Q_heat_all[i],

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_pumps/cycles/mechanical_vapour_recompression_cycle.py

@@ -87,7 +87,9 @@ class MechanicalVapourRecompressionCycle(VapourCompressionCycle):
 
     @property
     def eta_mvr_comp(self) -> float:
-        """MVR compressor isentropic efficiency."""
+        """MVR compressor isentropic efficiency, as applied when it is a model."""
+        if callable(self._eta_mvr_comp):
+            return self._eta_comp_applied
         return self._eta_mvr_comp
 
     @property
@@ -359,7 +361,9 @@ class MechanicalVapourRecompressionCycle(VapourCompressionCycle):
         self._cycle_states = self._new_cycle_states()
         self._penalty = np.asarray([], dtype=float)
         self._refrigerant = fluid
-        self._eta_mvr_comp = float(eta_mvr_comp)
+        self._eta_mvr_comp = (
+            eta_mvr_comp if callable(eta_mvr_comp) else float(eta_mvr_comp)
+        )
         self._eta_motor = float(eta_motor)
         self._m_dot = 0.0
         self._m_dot_source = 0.0
@@ -385,7 +389,9 @@ class MechanicalVapourRecompressionCycle(VapourCompressionCycle):
         if self._dT_subcool < 0.0:
             self._max_work *= 1e3
             return None
-        if self._eta_mvr_comp <= 0.0 or self._eta_motor <= 0.0:
+        if self._eta_motor <= 0.0 or (
+            not callable(self._eta_mvr_comp) and self._eta_mvr_comp <= 0.0
+        ):
             self._max_work *= 1e3
             return None
         if self._T_cond <= self._T_evap:
@@ -485,6 +491,7 @@ class MechanicalVapourRecompressionCycle(VapourCompressionCycle):
                     h_in=state0.hmass(),
                     s_in=state0.smass(),
                     P_out=P_hi,
+                    suction=state0,
                 )
             finally:
                 self._eta_comp = old_eta

{openpinch-0.8.2 → openpinch-0.8.3}/OpenPinch/analysis/heat_pumps/cycles/parallel_vapour_compression_cycles.py

@@ -202,6 +202,7 @@ class ParallelVapourCompressionCycles(_MultiVapourCompressionCycleBase):
         dT_superheat: np.ndarray = 0.0,
         dT_subcool: np.ndarray = 0.0,
         eta_comp: float = 0.7,
+        eta_motor: float = 1.0,
         refrigerant: List[str] | str = "water",
         dT_ihx_gas_side: np.ndarray | float = 10.0,
         Q_heat: np.ndarray | float | None = None,
@@ -226,6 +227,8 @@ class ParallelVapourCompressionCycles(_MultiVapourCompressionCycleBase):
             Degree of subcooling after the condenser [K].
         eta_comp : float, optional
             Isentropic efficiency of the compressor [-].
+        eta_motor : float, optional
+            Efficiency of each compressor motor [-].
         refrigerant : List[str] | str, optional
             Cycle refrigerants; one per heat pump or a scalar value.
         dT_ihx_gas_side : np.ndarray | float, optional
@@ -243,7 +246,7 @@ class ParallelVapourCompressionCycles(_MultiVapourCompressionCycleBase):
         Returns
         -------
         float
-            Total compressor power requirement for the solved operating point [W].
+            Total compressor electrical power for the solved operating point [W].
         """
         self._solved = False
         self._subcycles = []
@@ -285,6 +288,7 @@ class ParallelVapourCompressionCycles(_MultiVapourCompressionCycleBase):
                 dT_superheat=dT_superheat_all[i],
                 dT_subcool=dT_subcool_all[i],
                 eta_comp=eta_comp,
+                eta_motor=eta_motor,
                 refrigerant=refrigerant_all[i],
                 dT_ihx_gas_side=ihx_gas_dt_all[i],
                 Q_heat=Q_heat_all[i],