OpenPinch 0.2.8__tar.gz → 0.2.9__tar.gz

{openpinch-0.2.8 → openpinch-0.2.9}/OpenPinch/classes/pinch_workspace.py

@@ -339,14 +339,14 @@ class PinchWorkspace:
 
     def copy_case(
         self,
-        source_name: str,
-        new_name: str,
         *,
+        source_name: str = "baseline",
+        new_name: str = "new",
         activate: bool = False,
     ) -> PinchProblem:
         """Clone one existing case into a new named case."""
-        payload = self.get_case_payload(source_name, canonical=True)
-        return self.load(payload, case_name=new_name, activate=activate)
+        data_source = self.get_case_payload(source_name, canonical=True)
+        return self.load(data_source, case_name=new_name, activate=activate)
 
     def get_case_payload(
         self,

openpinch-0.2.9/OpenPinch/data/notebooks/03_carnot_hpr_comparison.ipynb

@@ -0,0 +1,347 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "title",
+   "metadata": {},
+   "source": [
+    "# Carnot HPR Comparison\n",
+    "This notebook uses the packaged `chocolate_factory.json` case to compare direct versus indirect heat-pump placement and `HPRcycle.CascadeCarnot` versus `HPRcycle.ParallelCarnot` screening. The optimisation is the expensive step, so the notebook creates four named cases, solves each once, and reuses the solved targets for tables and plots."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "context",
+   "metadata": {},
+   "source": [
+    "## Case context\n",
+    "`chocolate_factory.json` is a realistic multi-zone plant case with enough structure to support HPR screening. `PinchWorkspace` keeps the study bundle organized, while each named case still behaves like a real `PinchProblem`. The Carnot backends use base duty scales plus bounded split fractions internally, so trial optimiser points are clipped to process availability before cycle work is evaluated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "from IPython.display import display\n",
+    "\n",
+    "from OpenPinch import PinchWorkspace\n",
+    "from OpenPinch.lib.enums import HPRcycle\n",
+    "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",
+    "\n",
+    "WORKFLOWS = {\n",
+    "    \"direct_heat_pump\": {\n",
+    "        \"label\": \"Direct Heat Pump\",\n",
+    "        \"target_name\": f\"{PROJECT_NAME}/Direct Heat Pump\",\n",
+    "        \"requires_base_target\": False,\n",
+    "    },\n",
+    "    \"indirect_heat_pump\": {\n",
+    "        \"label\": \"Indirect Heat Pump\",\n",
+    "        \"target_name\": f\"{PROJECT_NAME}/Indirect Heat Pump\",\n",
+    "        \"requires_base_target\": True,\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "CYCLE_OPTIONS = {\n",
+    "    \"CascadeCarnot\": HPRcycle.CascadeCarnot,\n",
+    "    \"ParallelCarnot\": HPRcycle.ParallelCarnot,\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "workspace = PinchWorkspace(source=\"chocolate_factory.json\", project_name=PROJECT_NAME)\n",
+    "\n",
+    "case_matrix = []\n",
+    "for cycle_key, cycle in CYCLE_OPTIONS.items():\n",
+    "    for workflow_name, workflow in WORKFLOWS.items():\n",
+    "        case_name = f\"{cycle_key}__{workflow_name}\"\n",
+    "        case = workspace.copy_case(\n",
+    "            source_name=\"baseline\",\n",
+    "            new_name=case_name,\n",
+    "            activate=False,\n",
+    "        )\n",
+    "        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",
+    "            }\n",
+    "        )\n",
+    "        case_matrix.append(\n",
+    "            {\n",
+    "                \"case\": case_name,\n",
+    "                \"cycle\": cycle_key,\n",
+    "                \"cycle option\": cycle.value,\n",
+    "                \"workflow\": workflow_name,\n",
+    "                \"placement\": workflow[\"label\"],\n",
+    "                \"target name\": workflow[\"target_name\"],\n",
+    "            }\n",
+    "        )\n",
+    "\n",
+    "pd.DataFrame(case_matrix)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "solve-one-md",
+   "metadata": {},
+   "source": [
+    "## Solve the four comparison cases once\n",
+    "Each row below is one optimiser run. Keep this cell as the single place where the notebook calls `problem.target.direct_heat_pump()` or `problem.target.indirect_heat_pump()`; later cells reuse `SOLVED_TARGETS` and the cached `comparison` frame."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "solve-one",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SOLVED_TARGETS = {}\n",
+    "rows = []\n",
+    "\n",
+    "for spec in case_matrix:\n",
+    "    problem = workspace.case(spec[\"case\"])\n",
+    "    workflow = WORKFLOWS[spec[\"workflow\"]]\n",
+    "    try:\n",
+    "        if workflow[\"requires_base_target\"]:\n",
+    "            problem.target()\n",
+    "        target = getattr(problem.target, spec[\"workflow\"])()\n",
+    "        SOLVED_TARGETS[spec[\"case\"]] = target\n",
+    "        rows.append(\n",
+    "            {\n",
+    "                \"cycle\": spec[\"cycle\"],\n",
+    "                \"placement\": spec[\"placement\"],\n",
+    "                \"case\": spec[\"case\"],\n",
+    "                \"target\": target.name,\n",
+    "                \"Qh\": get_scalar_value(getattr(target, \"Qh\", None)),\n",
+    "                \"Qc\": get_scalar_value(getattr(target, \"Qc\", None)),\n",
+    "                \"Qr\": get_scalar_value(getattr(target, \"Qr\", None)),\n",
+    "                \"hpr_utility_total\": get_scalar_value(\n",
+    "                    getattr(target, \"hpr_utility_total\", None)\n",
+    "                ),\n",
+    "                \"hpr_external_utility\": get_scalar_value(\n",
+    "                    getattr(target, \"hpr_external_utility\", None)\n",
+    "                ),\n",
+    "                \"hpr_work\": get_scalar_value(getattr(target, \"hpr_work\", None)),\n",
+    "                \"hpr_cop\": get_scalar_value(getattr(target, \"hpr_cop\", None)),\n",
+    "                \"hpr_success\": getattr(target, \"hpr_success\", None),\n",
+    "                \"graph_count\": len(problem.plot.catalog()),\n",
+    "                \"error\": None,\n",
+    "            }\n",
+    "        )\n",
+    "    except Exception as exc:\n",
+    "        rows.append(\n",
+    "            {\n",
+    "                \"cycle\": spec[\"cycle\"],\n",
+    "                \"placement\": spec[\"placement\"],\n",
+    "                \"case\": spec[\"case\"],\n",
+    "                \"target\": None,\n",
+    "                \"Qh\": None,\n",
+    "                \"Qc\": None,\n",
+    "                \"Qr\": None,\n",
+    "                \"hpr_utility_total\": None,\n",
+    "                \"hpr_external_utility\": None,\n",
+    "                \"hpr_work\": None,\n",
+    "                \"hpr_cop\": None,\n",
+    "                \"hpr_success\": False,\n",
+    "                \"graph_count\": len(problem.plot.catalog()),\n",
+    "                \"error\": f\"{type(exc).__name__}: {exc}\",\n",
+    "            }\n",
+    "        )\n",
+    "\n",
+    "comparison = pd.DataFrame(rows)\n",
+    "comparison"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "plot-md",
+   "metadata": {},
+   "source": [
+    "## Direct versus indirect, Cascade versus Parallel\n",
+    "The tables below reuse `comparison`; they do not trigger additional optimisation calls."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "plot-one",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "display(\n",
+    "    comparison.sort_values([\"placement\", \"cycle\"])[\n",
+    "        [\n",
+    "            \"placement\",\n",
+    "            \"cycle\",\n",
+    "            \"Qh\",\n",
+    "            \"Qc\",\n",
+    "            \"Qr\",\n",
+    "            \"hpr_work\",\n",
+    "            \"hpr_cop\",\n",
+    "            \"hpr_success\",\n",
+    "            \"error\",\n",
+    "        ]\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "for metric in [\"Qh\", \"Qc\", \"Qr\", \"hpr_work\", \"hpr_cop\"]:\n",
+    "    print(metric)\n",
+    "    display(comparison.pivot(index=\"placement\", columns=\"cycle\", values=metric))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "direct-comparison-md",
+   "metadata": {},
+   "source": [
+    "## Inspect one solved HPR-aware plot set\n",
+    "Pick one of the four solved cases and use the standard public plot accessors. This cell reads the solved target and graph catalog from the previous optimisation cell."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "direct-comparison",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SELECTED_CASE = \"CascadeCarnot__direct_heat_pump\"\n",
+    "selected_problem = workspace.case(SELECTED_CASE)\n",
+    "selected_target = SOLVED_TARGETS[SELECTED_CASE]\n",
+    "selected_zone_name = comparison.loc[comparison[\"case\"] == SELECTED_CASE, \"placement\"].iloc[0]\n",
+    "\n",
+    "print(\n",
+    "    {\n",
+    "        \"case\": SELECTED_CASE,\n",
+    "        \"target\": selected_target.name,\n",
+    "        \"hpr_cop\": get_scalar_value(selected_target.hpr_cop),\n",
+    "    }\n",
+    ")\n",
+    "display(selected_problem.plot.net_load_profiles_with_heat_pump(zone_name=selected_zone_name))\n",
+    "display(selected_problem.plot.grand_composite_curve_with_heat_pump(zone_name=selected_zone_name))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "workflow-md",
+   "metadata": {},
+   "source": [
+    "## Which graph families appear after each solved workflow?\n",
+    "Use `plot.catalog()` together with the comparison table to see which graph families become available after each target is solved. This stays on the stable graph catalog instead of depending on lower-level cycle internals."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "workflow-table",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph_families = []\n",
+    "for spec in case_matrix:\n",
+    "    problem = workspace.case(spec[\"case\"])\n",
+    "    comparison_row = comparison.loc[comparison[\"case\"] == spec[\"case\"]].iloc[0]\n",
+    "    if comparison_row[\"error\"] is not None:\n",
+    "        graph_families.append(\n",
+    "            {\n",
+    "                \"placement\": spec[\"placement\"],\n",
+    "                \"cycle\": spec[\"cycle\"],\n",
+    "                \"case\": spec[\"case\"],\n",
+    "                \"graph families\": None,\n",
+    "                \"graph count\": comparison_row[\"graph_count\"],\n",
+    "                \"status\": comparison_row[\"error\"],\n",
+    "            }\n",
+    "        )\n",
+    "        continue\n",
+    "    catalog = problem.plot.catalog()\n",
+    "    graph_families.append(\n",
+    "        {\n",
+    "            \"placement\": spec[\"placement\"],\n",
+    "            \"cycle\": spec[\"cycle\"],\n",
+    "            \"case\": spec[\"case\"],\n",
+    "            \"graph families\": \", \".join(sorted(catalog[\"Graph Type\"].unique())),\n",
+    "            \"graph count\": len(catalog),\n",
+    "            \"status\": \"ok\",\n",
+    "        }\n",
+    "    )\n",
+    "\n",
+    "pd.DataFrame(graph_families)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "catalog-md",
+   "metadata": {},
+   "source": [
+    "## Optional case-to-case deltas\n",
+    "`compare_cases()` is useful when the two cases contain the same target name. The example below compares the two direct heat-pump cycle choices without running another optimisation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "catalog-table",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "workspace.compare_cases(\n",
+    "    \"CascadeCarnot__direct_heat_pump\",\n",
+    "    \"ParallelCarnot__direct_heat_pump\",\n",
+    "    target_name=WORKFLOWS[\"direct_heat_pump\"][\"target_name\"],\n",
+    "    base_label=\"CascadeCarnot direct\",\n",
+    "    other_label=\"ParallelCarnot direct\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "interpretation",
+   "metadata": {},
+   "source": [
+    "## Interpretation\n",
+    "A useful HPR option improves the utility picture while keeping the cycle work and COP operationally plausible. In this workflow, `PinchWorkspace` keeps the four named study cases, the comparison frame shows placement and cycle effects side by side, and the standard plot accessors show how each solved HPR target changes the net-load and GCC views."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "openpinch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{openpinch-0.2.8 → openpinch-0.2.9}/OpenPinch/lib/config.py

@@ -109,6 +109,29 @@ class Configuration:
             )
         return value
 
+    @staticmethod
+    def _normalise_config_list(values, *, uppercase: bool = False) -> list[str]:
+        """Return stripped, non-empty string values from a config list option."""
+        normalised = [str(value).strip() for value in values if str(value).strip()]
+        if uppercase:
+            return [value.upper() for value in normalised]
+        return normalised
+
+    @property
+    def hpr_refrigerants(self) -> list[str]:
+        """Return HPR refrigerant names normalised for thermodynamic backends."""
+        return self._normalise_config_list(self.REFRIGERANTS, uppercase=True)
+
+    @property
+    def hpr_mvr_fluids(self) -> list[str]:
+        """Return MVR fluid names normalised for thermodynamic backends."""
+        return self._normalise_config_list(self.MVR_FLUIDS) or ["Water"]
+
+    @property
+    def effective_eta_ii_he_carnot(self) -> float:
+        """Return the usable Carnot heat-engine efficiency for HPR targeting."""
+        return float(self.ETA_II_HE_CARNOT) if self.ALLOW_INTEGRATED_EXPANDER else 0.0
+
 
 Configuration.__annotations__ = {
     name: spec.annotation for name, spec in CONFIG_FIELD_SPECS.items()

{openpinch-0.2.8 → openpinch-0.2.9}/OpenPinch/lib/config_metadata.py

@@ -29,27 +29,13 @@ class ConfigurationOptionStatus:
     runtime_status: str
 
 
+# fmt: off
 CONFIG_FIELD_SPECS: dict[str, ConfigurationFieldSpec] = {
     "TOP_ZONE_NAME": ConfigurationFieldSpec(str, "Site", "general"),
-    "TOP_ZONE_IDENTIFIER": ConfigurationFieldSpec(
-        str,
-        ZT.S.value,
-        "general",
-        enum_cls=ZT,
-    ),
+    "TOP_ZONE_IDENTIFIER": ConfigurationFieldSpec(str, ZT.S.value, "general", enum_cls=ZT),
     "DT_CONT": ConfigurationFieldSpec(float, 5, "general", numeric_min=0.0),
-    "DT_PHASE_CHANGE": ConfigurationFieldSpec(
-        float,
-        0.01,
-        "general",
-        numeric_min=0.0,
-    ),
-    "DT_ASSISTED_HT": ConfigurationFieldSpec(
-        float,
-        10.0,
-        "general",
-        numeric_min=0.0,
-    ),
+    "DT_PHASE_CHANGE": ConfigurationFieldSpec(float, 0.01, "general", numeric_min=0.0),
+    "DT_ASSISTED_HT": ConfigurationFieldSpec(float, 10.0, "general", numeric_min=0.0),
     "HTC": ConfigurationFieldSpec(float, 1.0, "general", numeric_min=0.0),
     "T_ENV": ConfigurationFieldSpec(float, 15, "general"),
     "DT_ENV_CONT": ConfigurationFieldSpec(float, 10, "general", numeric_min=0.0),
@@ -59,17 +45,9 @@ CONFIG_FIELD_SPECS: dict[str, ConfigurationFieldSpec] = {
     "STATE_IDS": ConfigurationFieldSpec(List[str], ["0"], "general"),
     "INPUT_UNITS": ConfigurationFieldSpec(dict[str, str], {}, "general"),
     "OUTPUT_UNITS": ConfigurationFieldSpec(dict[str, str], {}, "general"),
-    "DO_DIRECT_OPERATION_TARGETING": ConfigurationFieldSpec(
-        bool,
-        False,
-        "targeting",
-    ),
+    "DO_DIRECT_OPERATION_TARGETING": ConfigurationFieldSpec(bool, False, "targeting"),
     "DO_DIRECT_SITE_TARGETING": ConfigurationFieldSpec(bool, True, "targeting"),
-    "DO_INDIRECT_PROCESS_TARGETING": ConfigurationFieldSpec(
-        bool,
-        False,
-        "targeting",
-    ),
+    "DO_INDIRECT_PROCESS_TARGETING": ConfigurationFieldSpec(bool, False, "targeting"),
     "DO_BALANCED_CC": ConfigurationFieldSpec(bool, True, "targeting"),
     "DO_AREA_TARGETING": ConfigurationFieldSpec(bool, False, "targeting"),
     "DO_PROCESS_HP_TARGETING": ConfigurationFieldSpec(bool, False, "targeting"),
@@ -77,44 +55,19 @@ CONFIG_FIELD_SPECS: dict[str, ConfigurationFieldSpec] = {
     "DO_UTILITY_HP_TARGETING": ConfigurationFieldSpec(bool, False, "targeting"),
     "DO_UTILITY_RFRG_TARGETING": ConfigurationFieldSpec(bool, False, "targeting"),
     "DO_TURBINE_TARGETING": ConfigurationFieldSpec(bool, False, "targeting"),
-    "DO_EXERGY_TARGETING": ConfigurationFieldSpec(
-        bool,
-        False,
-        "targeting",
-        runtime_status="experimental",
-    ),
+    "DO_EXERGY_TARGETING": ConfigurationFieldSpec(bool, False, "targeting", runtime_status="experimental"),
     "DO_VERTICAL_GCC": ConfigurationFieldSpec(bool, False, "targeting"),
     "DO_ASSITED_HT": ConfigurationFieldSpec(bool, False, "targeting"),
     "DO_TURBINE_WORK": ConfigurationFieldSpec(bool, False, "targeting"),
-    "HPR_TYPE": ConfigurationFieldSpec(
-        str,
-        HPRcycle.CascadeCarnot.value,
-        "hpr",
-        enum_cls=HPRcycle,
-    ),
+    "HPR_TYPE": ConfigurationFieldSpec(str, HPRcycle.CascadeCarnot.value, "hpr", enum_cls=HPRcycle),
     "HPR_LOAD_VALUE": ConfigurationFieldSpec(float | str | dict, 1.0, "hpr"),
     "HPR_LOAD_VALUE_TYPE": ConfigurationFieldSpec(str, "fraction", "hpr"),
     "REFRIGERANTS": ConfigurationFieldSpec(List[str], ["water", "ammonia"], "hpr"),
     "MVR_FLUIDS": ConfigurationFieldSpec(List[str], ["Water"], "hpr"),
     "DO_REFRIGERANT_SORT": ConfigurationFieldSpec(bool, True, "hpr"),
-    "PRICE_RATIO_HEAT_TO_ELE": ConfigurationFieldSpec(
-        float,
-        1.0,
-        "hpr",
-        numeric_min=0.0,
-    ),
-    "PRICE_RATIO_COLD_TO_ELE": ConfigurationFieldSpec(
-        float,
-        1.0,
-        "hpr",
-        numeric_min=0.0,
-    ),
-    "MAX_HP_MULTISTART": ConfigurationFieldSpec(
-        int,
-        10,
-        "hpr",
-        numeric_min=0.0,
-    ),
+    "PRICE_RATIO_HEAT_TO_ELE": ConfigurationFieldSpec(float, 1.0, "hpr", numeric_min=0.0),
+    "PRICE_RATIO_COLD_TO_ELE": ConfigurationFieldSpec(float, 1.0, "hpr", numeric_min=0.0),
+    "MAX_HP_MULTISTART": ConfigurationFieldSpec(int, 10, "hpr", numeric_min=0.0),
     "N_COND": ConfigurationFieldSpec(int, 3, "hpr", numeric_min=0.0),
     "N_EVAP": ConfigurationFieldSpec(int, 2, "hpr", numeric_min=0.0),
     "N_MVR": ConfigurationFieldSpec(int, 1, "hpr", numeric_min=1.0),
@@ -122,80 +75,39 @@ CONFIG_FIELD_SPECS: dict[str, ConfigurationFieldSpec] = {
     "ETA_MVR_COMP": ConfigurationFieldSpec(float, 0.7, "hpr", numeric_min=0.0),
     "ETA_EXP": ConfigurationFieldSpec(float, 0.7, "hpr", numeric_min=0.0),
     "ETA_MOTOR": ConfigurationFieldSpec(float, 0.95, "hpr", numeric_min=0.0),
-    "ETA_II_HPR_CARNOT": ConfigurationFieldSpec(
-        float,
-        0.5,
-        "hpr",
-        numeric_min=0.0,
-    ),
-    "ETA_II_HE_CARNOT": ConfigurationFieldSpec(
-        float,
-        0.5,
-        "hpr",
-        numeric_min=0.0,
-    ),
+    "ETA_II_HPR_CARNOT": ConfigurationFieldSpec(float, 0.5, "hpr", numeric_min=0.0),
+    "ETA_II_HE_CARNOT": ConfigurationFieldSpec(float, 0.5, "hpr", numeric_min=0.0),
     "DT_CONT_HP": ConfigurationFieldSpec(float, 0.0, "hpr", numeric_min=0.0),
     "DT_HPR_IHX": ConfigurationFieldSpec(float, 0.0, "hpr", numeric_min=0.0),
-    "DT_HPR_CASCADE_HX": ConfigurationFieldSpec(
-        float,
-        0.0,
-        "hpr",
-        numeric_min=0.0,
-    ),
-    "BB_MINIMISER": ConfigurationFieldSpec(
-        str,
-        BB_Minimiser.CMAES.value,
-        "hpr",
-        enum_cls=BB_Minimiser,
-    ),
+    "DT_HPR_CASCADE_HX": ConfigurationFieldSpec(float, 0.0, "hpr", numeric_min=0.0),
+    "ETA_PENALTY": ConfigurationFieldSpec(float, 0.001, "hpr", numeric_min=0.0),
+    "RHO_PENALTY": ConfigurationFieldSpec(float, 10.0, "hpr", numeric_min=0.0),
+    "BB_MINIMISER": ConfigurationFieldSpec(str, BB_Minimiser.CMAES.value, "hpr", enum_cls=BB_Minimiser),
     "INITIALISE_SIMULATED_CYCLE": ConfigurationFieldSpec(bool, True, "hpr"),
     "ALLOW_INTEGRATED_EXPANDER": ConfigurationFieldSpec(bool, False, "hpr"),
+    "HPR_COMP_FIXED_COST": ConfigurationFieldSpec(float, 0, "hpr", numeric_min=0.0),
+    "HPR_COMP_VARIABLE_COST": ConfigurationFieldSpec(float, 10000, "hpr", numeric_min=0.0),
+    "HPR_COMP_COST_EXP": ConfigurationFieldSpec(float, 1.0, "hpr", numeric_min=0.0),
+    "HPR_HX_FIXED_COST": ConfigurationFieldSpec(float, 0, "hpr", numeric_min=0.0),
+    "HPR_HX_VARIABLE_COST": ConfigurationFieldSpec(float, 10000, "hpr", numeric_min=0.0),
+    "HPR_HX_COST_EXP": ConfigurationFieldSpec(float, 1.0, "hpr", numeric_min=0.0),
     "ELE_PRICE": ConfigurationFieldSpec(float, 200, "costing", numeric_min=0.0),
-    "UTILITY_PRICE": ConfigurationFieldSpec(
-        float,
-        100,
-        "costing",
-        numeric_min=0.0,
-    ),
-    "ANNUAL_OP_TIME": ConfigurationFieldSpec(
-        float,
-        8300,
-        "costing",
-        numeric_min=0.0,
-    ),
+    "UTILITY_PRICE": ConfigurationFieldSpec(float, 100, "costing", numeric_min=0.0),
+    "ANNUAL_OP_TIME": ConfigurationFieldSpec(float, 8300, "costing", numeric_min=0.0),
     "FIXED_COST": ConfigurationFieldSpec(float, 0, "costing", numeric_min=0.0),
-    "VARIABLE_COST": ConfigurationFieldSpec(
-        float,
-        10000,
-        "costing",
-        numeric_min=0.0,
-    ),
+    "VARIABLE_COST": ConfigurationFieldSpec(float, 10000, "costing", numeric_min=0.0),
     "COST_EXP": ConfigurationFieldSpec(float, 0.6, "costing", numeric_min=0.0),
-    "DISCOUNT_RATE": ConfigurationFieldSpec(
-        float,
-        0.07,
-        "costing",
-        numeric_min=0.0,
-    ),
+    "DISCOUNT_RATE": ConfigurationFieldSpec(float, 0.07, "costing", numeric_min=0.0),
     "SERV_LIFE": ConfigurationFieldSpec(float, 20, "costing", numeric_min=0.0),
     "TURB_T_IN": ConfigurationFieldSpec(float, 450, "turbine"),
     "TURB_P_IN": ConfigurationFieldSpec(float, 90, "turbine", numeric_min=0.0),
     "MIN_EFF": ConfigurationFieldSpec(float, 0.1, "turbine", numeric_min=0.0),
-    "LOAD_FRACTION": ConfigurationFieldSpec(
-        float,
-        1,
-        "turbine",
-        numeric_min=0.0,
-    ),
+    "LOAD_FRACTION": ConfigurationFieldSpec(float, 1, "turbine", numeric_min=0.0),
     "ETA_MECH": ConfigurationFieldSpec(float, 1, "turbine", numeric_min=0.0),
-    "TURB_MODEL": ConfigurationFieldSpec(
-        str,
-        TurbineModel.MEDINA_FLORES.value,
-        "turbine",
-        enum_cls=TurbineModel,
-    ),
+    "TURB_MODEL": ConfigurationFieldSpec(str, TurbineModel.MEDINA_FLORES.value, "turbine", enum_cls=TurbineModel),
     "IS_HIGH_P_COND_FLASH": ConfigurationFieldSpec(bool, False, "turbine"),
 }
+# fmt: on
 
 CONFIG_ENUMS: dict[str, type[Enum]] = {
     name: spec.enum_cls