OpenPinch 0.2.4__tar.gz → 0.2.8__tar.gz

{openpinch-0.2.4 → openpinch-0.2.8}/OpenPinch/classes/_problem/_plot_accessor.py

@@ -53,6 +53,13 @@ _GRAPH_TYPE_ALIASES = {
     "net_load curves": GT.NLP.value,
     "net_load profile": GT.NLP.value,
     "net_load profiles": GT.NLP.value,
+    "nlp_hp": GT.NLP_HP.value,
+    "net load with heat pump": GT.NLP_HP.value,
+    "net load curve with heat pump": GT.NLP_HP.value,
+    "net load curves with heat pump": GT.NLP_HP.value,
+    "net load profile with heat pump": GT.NLP_HP.value,
+    "net load profiles with heat pump": GT.NLP_HP.value,
+    "net_load_with_heat_pump": GT.NLP_HP.value,
     "nlp_x": GT.NLP_X.value,
     "exergy nlp": GT.NLP_X.value,
     "exergetic net load profiles": GT.NLP_X.value,
@@ -362,6 +369,23 @@ class _PlotAccessor:
             return_graph_data=return_graph_data,
         )
 
+    def net_load_profiles_with_heat_pump(
+        self,
+        *,
+        zone_name: Optional[str] = None,
+        index: float = 0,
+        show: bool = False,
+        return_graph_data: bool = False,
+    ):
+        """Return the first matching net load profile (with Heat Pump) or figure."""
+        return self._plot_graph(
+            zone_name=zone_name,
+            graph_type=GT.NLP_HP.value,
+            index=index,
+            show=show,
+            return_graph_data=return_graph_data,
+        )
+
     def exergetic_net_load_profiles(
         self,
         *,

{openpinch-0.2.4 → openpinch-0.2.8}/OpenPinch/classes/_problem/_target_dispatch.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-import inspect
-from functools import lru_cache
 from typing import Callable
 
 from ...lib.enums import ZT
@@ -31,39 +29,12 @@ def run_targeting_for_zone_and_subzones(
 
 
 def _invoke_service(service_func: Callable, zone: Zone, args: dict | None = None):
-    """Call a targeting callback with backward-compatible argument handling."""
+    """Call a targeting callback with runtime options."""
     if not callable(service_func):
         return None
-
-    if args is None or not _service_accepts_args(service_func):
-        return service_func(zone)
-
     return service_func(zone, args)
 
 
-@lru_cache(maxsize=64)
-def _service_accepts_args(service_func: Callable) -> bool:
-    """Return whether a service accepts a second positional ``args`` parameter."""
-    try:
-        signature = inspect.signature(service_func)
-    except TypeError, ValueError:
-        return True
-
-    params = list(signature.parameters.values())
-    if any(param.kind == inspect.Parameter.VAR_POSITIONAL for param in params):
-        return True
-    positional_params = [
-        param
-        for param in params
-        if param.kind
-        in (
-            inspect.Parameter.POSITIONAL_ONLY,
-            inspect.Parameter.POSITIONAL_OR_KEYWORD,
-        )
-    ]
-    return len(positional_params) >= 2
-
-
 def _invoke_target_handler(
     handler: Callable,
     zone: Zone,
@@ -71,13 +42,7 @@ def _invoke_target_handler(
     indirect_service_func: Callable = None,
     args: dict | None = None,
 ):
-    """Call nested target handlers without forcing an ``args`` keyword."""
-    if args is None:
-        return handler(
-            zone,
-            direct_service_func=direct_service_func,
-            indirect_service_func=indirect_service_func,
-        )
+    """Call nested target handlers with runtime options."""
     return handler(
         zone,
         direct_service_func=direct_service_func,

{openpinch-0.2.4 → openpinch-0.2.8}/OpenPinch/classes/pinch_problem.py

@@ -53,7 +53,7 @@ from .stream_collection import StreamCollection
 from .value import Value
 from .zone import Zone
 
-ZoneService = Callable[["Zone"], "Zone"]
+ZoneService = Callable[["Zone", Optional[dict[str, Any]]], "Zone"]
 
 
 class PinchProblem:

{openpinch-0.2.4 → openpinch-0.2.8}/OpenPinch/classes/value.py

@@ -8,7 +8,7 @@ from functools import lru_cache
 from typing import Any
 
 import numpy as np
-from pint import UnitRegistry
+from pint import UnitRegistry, set_application_registry
 from pint.errors import DimensionalityError
 
 ureg = UnitRegistry()
@@ -20,6 +20,7 @@ try:
     ureg.define("NZD = [currency]")
 except Exception:
     pass
+set_application_registry(ureg)
 Q_ = ureg.Quantity  # type: ignore
 
 _SERIALIZED_SCALAR_KEYS = {"value", "unit"}

{openpinch-0.2.4 → openpinch-0.2.8}/OpenPinch/data/notebooks/01_basic_pinch_and_dtcont_sensitivity.ipynb

@@ -26,6 +26,7 @@
    "outputs": [],
    "source": [
     "import pandas as pd\n",
+    "import plotly.express as px\n",
     "\n",
     "from IPython.display import display\n",
     "\n",
@@ -132,7 +133,7 @@
    "metadata": {},
    "source": [
     "## Named `dt_cont` sensitivity with `PinchWorkspace`\n",
-    "Once the single-case picture is clear, `PinchWorkspace` becomes the right tool for named baseline-versus-variant studies. Here the baseline stays intact while two copied cases tighten and widen the active `dt_cont` assumption.\n"
+    "Once the single-case picture is clear, `PinchWorkspace` becomes the right tool for named baseline-versus-variant studies. Here the baseline stays intact while copied cases sweep a wide range of active `dt_cont` assumptions through `set_dt_cont_multiplier(...)`.\n"
    ]
   },
   {
@@ -147,31 +148,32 @@
     "    project_name=\"crude_preheat_train\",\n",
     ")\n",
     "\n",
-    "workspace.copy_case(\"baseline\", \"tight_dt\", activate=False)\n",
-    "workspace.set_dt_cont_multiplier(0.5, case_name=\"tight_dt\")\n",
-    "workspace.copy_case(\"baseline\", \"wide_dt\", activate=False)\n",
-    "workspace.set_dt_cont_multiplier(2.0, case_name=\"wide_dt\")\n",
+    "target_name = \"crude_preheat_train/Direct Integration\"\n",
+    "dt_cont_multipliers = [0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 7.5, 10.0]\n",
     "\n",
     "case_rows = []\n",
-    "for case_name, multiplier in [(\"tight_dt\", 0.5), (\"baseline\", 1.0), (\"wide_dt\", 2.0)]:\n",
-    "    case_problem = workspace.case(case_name)\n",
-    "    case_problem.target()\n",
-    "    site_row = case_problem.summary_frame().loc[\n",
-    "        lambda frame: frame[\"Target\"] == \"crude_preheat_train/Direct Integration\"\n",
-    "    ].iloc[0]\n",
+    "for multiplier in dt_cont_multipliers:\n",
+    "    case_name = \"baseline\" if multiplier == 1.0 else f\"dt_cont_x{str(multiplier).replace('.', '_')}\"\n",
+    "    if case_name != \"baseline\":\n",
+    "        workspace.copy_case(\"baseline\", case_name, activate=False)\n",
+    "        workspace.set_dt_cont_multiplier(multiplier, case_name=case_name)\n",
+    "\n",
+    "    detailed_summary = workspace.summary_frame(case_name=case_name, detailed=True)\n",
+    "    site_row = detailed_summary.loc[detailed_summary[\"Target\"] == target_name].iloc[0]\n",
     "    case_rows.append(\n",
     "        {\n",
     "            \"case\": case_name,\n",
     "            \"dt_cont_multiplier\": multiplier,\n",
-    "            \"Hot Utility Target\": site_row[\"Hot Utility Target\"],\n",
-    "            \"Cold Utility Target\": site_row[\"Cold Utility Target\"],\n",
-    "            \"Heat Recovery\": site_row[\"Heat Recovery\"],\n",
-    "            \"Hot Pinch\": site_row[\"Hot Pinch\"],\n",
-    "            \"Cold Pinch\": site_row[\"Cold Pinch\"],\n",
+    "            \"Hot Utility Target / kW\": site_row[\"Qh (value)\"],\n",
+    "            \"Cold Utility Target / kW\": site_row[\"Qc (value)\"],\n",
+    "            \"Heat Recovery / kW\": site_row[\"Qr (value)\"],\n",
+    "            \"Hot Pinch / degC\": site_row[\"Hot Pinch (value)\"],\n",
+    "            \"Cold Pinch / degC\": site_row[\"Cold Pinch (value)\"],\n",
     "        }\n",
     "    )\n",
     "\n",
-    "pd.DataFrame(case_rows).sort_values(\"dt_cont_multiplier\").reset_index(drop=True)\n"
+    "dt_cont_results = pd.DataFrame(case_rows).sort_values(\"dt_cont_multiplier\").reset_index(drop=True)\n",
+    "dt_cont_results\n"
    ]
   },
   {
@@ -181,15 +183,62 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "selected_dt_cases = [\"dt_cont_x0_25\", \"dt_cont_x0_5\", \"dt_cont_x2_0\", \"dt_cont_x4_0\"]\n",
+    "\n",
     "pd.concat(\n",
     "    [\n",
-    "        workspace.compare_cases(\"baseline\", case_name).loc[[\"Change\"]].assign(case=case_name)\n",
-    "        for case_name in [\"tight_dt\", \"wide_dt\"]\n",
+    "        workspace.compare_cases(\"baseline\", case_name, target_name=target_name)\n",
+    "        .loc[[\"Change\"]]\n",
+    "        .assign(case=case_name)\n",
+    "        for case_name in selected_dt_cases\n",
     "    ],\n",
     "    axis=0,\n",
     ").reset_index(drop=True)\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "dt-cont-plot-md",
+   "metadata": {},
+   "source": [
+    "## Plot the target response\n",
+    "Plotting the targets across the multiplier range makes the tradeoff visible: tighter approach temperatures reduce external utility demand, while wider approach temperatures increase hot and cold utility requirements and reduce recoverable heat.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dt-cont-target-plot",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dt_cont_plot_data = dt_cont_results.melt(\n",
+    "    id_vars=[\"dt_cont_multiplier\"],\n",
+    "    value_vars=[\n",
+    "        \"Hot Utility Target / kW\",\n",
+    "        \"Cold Utility Target / kW\",\n",
+    "        \"Heat Recovery / kW\",\n",
+    "    ],\n",
+    "    var_name=\"Target\",\n",
+    "    value_name=\"Heat Flow / kW\",\n",
+    ")\n",
+    "\n",
+    "fig = px.line(\n",
+    "    dt_cont_plot_data,\n",
+    "    x=\"dt_cont_multiplier\",\n",
+    "    y=\"Heat Flow / kW\",\n",
+    "    color=\"Target\",\n",
+    "    markers=True,\n",
+    "    title=\"Direct-integration targets across dt_cont multipliers\",\n",
+    ")\n",
+    "fig.update_layout(\n",
+    "    xaxis_title=\"dt_cont multiplier\",\n",
+    "    yaxis_title=\"Heat Flow / kW\",\n",
+    "    legend_title_text=\"Target\",\n",
+    ")\n",
+    "fig\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "forward-reference",

{openpinch-0.2.4 → openpinch-0.2.8}/OpenPinch/data/notebooks/02_total_site_targets_and_sugcc.ipynb

@@ -44,6 +44,7 @@
     "baseline = workspace.use_case(\"baseline\")\n",
     "baseline.target()\n",
     "summary = baseline.summary_frame()\n",
+    "detailed_summary = baseline.summary_frame(detailed=True)\n",
     "catalog = baseline.plot.catalog()\n",
     "\n",
     "{\n",
@@ -105,20 +106,20 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "scope_index = scope_rows.set_index(\"Scope\")\n",
+    "scope_index = detailed_summary.set_index(\"Target\")\n",
     "pd.DataFrame(\n",
     "    [\n",
     "        {\n",
     "            \"Comparison\": \"Total Process - Direct\",\n",
-    "            \"Hot Utility Delta\": scope_index.loc[\"Total Process Target\", \"Hot Utility Target\"] - scope_index.loc[\"Direct Integration\", \"Hot Utility Target\"],\n",
-    "            \"Cold Utility Delta\": scope_index.loc[\"Total Process Target\", \"Cold Utility Target\"] - scope_index.loc[\"Direct Integration\", \"Cold Utility Target\"],\n",
-    "            \"Heat Recovery Delta\": scope_index.loc[\"Total Process Target\", \"Heat Recovery\"] - scope_index.loc[\"Direct Integration\", \"Heat Recovery\"],\n",
+    "            \"Hot Utility Delta\": scope_index.loc[\"Site/Total Process Target\", \"Qh (value)\"] - scope_index.loc[\"Site/Direct Integration\", \"Qh (value)\"],\n",
+    "            \"Cold Utility Delta\": scope_index.loc[\"Site/Total Process Target\", \"Qc (value)\"] - scope_index.loc[\"Site/Direct Integration\", \"Qc (value)\"],\n",
+    "            \"Heat Recovery Delta\": scope_index.loc[\"Site/Total Process Target\", \"Qr (value)\"] - scope_index.loc[\"Site/Direct Integration\", \"Qr (value)\"],\n",
     "        },\n",
     "        {\n",
     "            \"Comparison\": \"Total Site - Direct\",\n",
-    "            \"Hot Utility Delta\": scope_index.loc[\"Total Site Target\", \"Hot Utility Target\"] - scope_index.loc[\"Direct Integration\", \"Hot Utility Target\"],\n",
-    "            \"Cold Utility Delta\": scope_index.loc[\"Total Site Target\", \"Cold Utility Target\"] - scope_index.loc[\"Direct Integration\", \"Cold Utility Target\"],\n",
-    "            \"Heat Recovery Delta\": scope_index.loc[\"Total Site Target\", \"Heat Recovery\"] - scope_index.loc[\"Direct Integration\", \"Heat Recovery\"],\n",
+    "            \"Hot Utility Delta\": scope_index.loc[\"Site/Total Site Target\", \"Qh (value)\"] - scope_index.loc[\"Site/Direct Integration\", \"Qh (value)\"],\n",
+    "            \"Cold Utility Delta\": scope_index.loc[\"Site/Total Site Target\", \"Qc (value)\"] - scope_index.loc[\"Site/Direct Integration\", \"Qc (value)\"],\n",
+    "            \"Heat Recovery Delta\": scope_index.loc[\"Site/Total Site Target\", \"Qr (value)\"] - scope_index.loc[\"Site/Direct Integration\", \"Qr (value)\"],\n",
     "        },\n",
     "    ]\n",
     ")\n"
@@ -140,10 +141,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "zone_rows = summary.loc[\n",
-    "    summary[\"Target\"].str.endswith(\"/Direct Integration\") & (summary[\"Target\"] != \"Site/Direct Integration\"),\n",
-    "    [\"Target\", \"Hot Utility Target\", \"Cold Utility Target\", \"Heat Recovery\"],\n",
-    "].copy()\n",
+    "zone_rows = detailed_summary.loc[\n",
+    "    detailed_summary[\"Target\"].str.endswith(\"/Direct Integration\") & (detailed_summary[\"Target\"] != \"Site/Direct Integration\"),\n",
+    "    [\"Target\", \"Qh (value)\", \"Qc (value)\", \"Qr (value)\"],\n",
+    "].rename(\n",
+    "    columns={\n",
+    "        \"Qh (value)\": \"Hot Utility Target\",\n",
+    "        \"Qc (value)\": \"Cold Utility Target\",\n",
+    "        \"Qr (value)\": \"Heat Recovery\",\n",
+    "    }\n",
+    ").copy()\n",
     "zone_rows[\"Zone\"] = zone_rows[\"Target\"].str.replace(\"/Direct Integration\", \"\", regex=False)\n",
     "\n",
     "leader_tables = []\n",
@@ -302,7 +309,7 @@
     "            \"Hot Utility Target\": (cogeneration_target.hot_utility_target),\n",
     "            \"Cold Utility Target\": (cogeneration_target.cold_utility_target),\n",
     "            \"Heat Recovery\": (cogeneration_target.heat_recovery_target),\n",
-    "            \"Power Cogeneration Target\": get_scalar_value.work_target),\n",
+    "            \"Power Cogeneration Target\": get_scalar_value(cogeneration_target.work_target),\n",
     "            \"Turbine Efficiency Target\": (cogeneration_target.turbine_efficiency_target),\n",
     "        },\n",
     "    ]\n",

{openpinch-0.2.4 → openpinch-0.2.8}/OpenPinch/data/notebooks/03_carnot_hpr_comparison.ipynb

@@ -6,7 +6,7 @@
    "metadata": {},
    "source": [
     "# Carnot HPR Comparison\n",
-    "This notebook uses the packaged `chocolate_factory.json` case to compare four advanced workflow families on the public `problem.target.*` and `problem.plot.*` surfaces: direct heat pump, indirect heat pump, direct refrigeration, and indirect refrigeration.\n"
+    "This notebook uses the packaged `chocolate_factory.json` case to compare four advanced workflow families on the public `problem.target.*` and `problem.plot.*` surfaces: direct heat pump, indirect heat pump, direct refrigeration, and indirect refrigeration. It uses the current `HPRcycle.CascadeCarnot` option for broad screening; use `HPRcycle.ParallelCarnot` when you want explicit staged Carnot cycles."
    ]
   },
   {
@@ -15,7 +15,7 @@
    "metadata": {},
    "source": [
     "## Case context\n",
-    "`chocolate_factory.json` is a realistic multi-zone plant case with enough structure to support HPR screening across multiple load fractions. `PinchWorkspace` keeps the study bundle organized, while each named case still behaves like a real `PinchProblem`.\n"
+    "`chocolate_factory.json` is a realistic multi-zone plant case with enough structure to support HPR screening across multiple load fractions. `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."
    ]
   },
   {
@@ -25,9 +25,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from pathlib import Path\n",
-    "from tempfile import TemporaryDirectory\n",
-    "\n",
     "import pandas as pd\n",
     "\n",
     "from IPython.display import display\n",
@@ -41,7 +38,7 @@
     "    \"indirect_heat_pump\": \"Indirect Heat Pump\",\n",
     "    \"direct_refrigeration\": \"Direct Refrigeration\",\n",
     "    \"indirect_refrigeration\": \"Indirect Refrigeration\",\n",
-    "}\n"
+    "}"
    ]
   },
   {
@@ -53,13 +50,15 @@
    "source": [
     "workspace = PinchWorkspace(source=\"chocolate_factory.json\", project_name=\"Site\")\n",
     "load_fractions = [0.25, 0.5, 0.75, 1.0]\n",
+    "screening_cycle = HPRcycle.CascadeCarnot\n",
+    "staged_carnot_cycle = HPRcycle.ParallelCarnot\n",
     "\n",
     "for load_fraction in load_fractions:\n",
     "    load_case_name = f\"load_{int(load_fraction * 100):03d}\"\n",
     "    load_case = workspace.copy_case(\"baseline\", load_case_name, activate=False)\n",
     "    load_case.update_options(\n",
     "        {\n",
-    "            \"HPR_TYPE\": HPRcycle.MultiTempCarnot.value,\n",
+    "            \"HPR_TYPE\": screening_cycle.value,\n",
     "            \"HPR_LOAD_VALUE\": load_fraction,\n",
     "            \"MAX_HP_MULTISTART\": 10,\n",
     "            \"N_COND\": 3,\n",
@@ -75,6 +74,8 @@
     "        )\n",
     "\n",
     "{\n",
+    "    \"screening_cycle\": screening_cycle.value,\n",
+    "    \"staged_carnot_alternative\": staged_carnot_cycle.value,\n",
     "    \"case_count\": len(workspace.list_cases()),\n",
     "    \"example_cases\": workspace.list_cases()[:8],\n",
     "}\n"
@@ -121,10 +122,14 @@
     "direct_hp_target = profile_problem.target.direct_heat_pump()\n",
     "\n",
     "print({\"direct_heat_pump_cop\": direct_hp_target.hpr_cop})\n",
-    "display(profile_problem.plot.net_load_profiles(zone_name=\"Direct Heat Pump\"))\n",
+    "display(\n",
+    "    profile_problem.plot.net_load_profiles_with_heat_pump(\n",
+    "        zone_name=\"Direct Heat Pump\",\n",
+    "    )\n",
+    ")\n",
     "display(\n",
     "    profile_problem.plot.grand_composite_curve_with_heat_pump(\n",
-    "        zone_name=\"Direct Heat Pump\"\n",
+    "        zone_name=\"Direct Heat Pump\",\n",
     "    )\n",
     ")\n"
    ]
@@ -191,22 +196,43 @@
     "    for workflow_name, workflow_label in WORKFLOW_LABELS.items():\n",
     "        case_name = f\"load_{int(load_fraction * 100):03d}__{workflow_name}\"\n",
     "        problem = workspace.case(case_name)\n",
-    "        target = getattr(problem.target, workflow_name)()\n",
-    "        rows.append(\n",
-    "            {\n",
-    "                \"load fraction\": load_fraction,\n",
-    "                \"workflow\": workflow_label,\n",
-    "                \"case\": case_name,\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_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",
-    "            }\n",
-    "        )\n",
+    "        try:\n",
+    "            if workflow_name.startswith(\"indirect\"):\n",
+    "                problem.target()\n",
+    "            target = getattr(problem.target, workflow_name)()\n",
+    "            rows.append(\n",
+    "                {\n",
+    "                    \"load fraction\": load_fraction,\n",
+    "                    \"workflow\": workflow_label,\n",
+    "                    \"case\": case_name,\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_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",
+    "                    \"load fraction\": load_fraction,\n",
+    "                    \"workflow\": workflow_label,\n",
+    "                    \"case\": case_name,\n",
+    "                    \"target\": None,\n",
+    "                    \"Qh\": None,\n",
+    "                    \"Qc\": None,\n",
+    "                    \"Qr\": 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\n"
@@ -232,7 +258,18 @@
     "for workflow_name, workflow_label in WORKFLOW_LABELS.items():\n",
     "    case_name = f\"load_100__{workflow_name}\"\n",
     "    problem = workspace.case(case_name)\n",
-    "    getattr(problem.target, workflow_name)()\n",
+    "    comparison_row = comparison.loc[comparison[\"case\"] == case_name].iloc[0]\n",
+    "    if comparison_row[\"error\"] is not None:\n",
+    "        graph_families.append(\n",
+    "            {\n",
+    "                \"workflow\": workflow_label,\n",
+    "                \"target\": case_name,\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",
@@ -240,42 +277,13 @@
     "            \"target\": case_name,\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)\n"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "bundle-md",
-   "metadata": {},
-   "source": [
-    "## Save and reload the study bundle\n",
-    "This is useful when a multi-case HPR study becomes a reusable engineering artifact rather than a one-off notebook session.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bundle",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "bundle_workspace = TemporaryDirectory()\n",
-    "bundle_path = Path(bundle_workspace.name) / \"chocolate_factory_hpr_workspace.json\"\n",
-    "workspace.save_bundle(bundle_path)\n",
-    "reloaded = PinchWorkspace.load_bundle(bundle_path)\n",
-    "\n",
-    "{\n",
-    "    \"bundle_path\": str(bundle_path),\n",
-    "    \"case_count\": len(reloaded.list_cases()),\n",
-    "    \"sample_heat_pump_cases\": [\n",
-    "        name for name in reloaded.list_cases() if name.endswith(\"__direct_heat_pump\")\n",
-    "    ][:3],\n",
-    "}\n"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "interpretation",

{openpinch-0.2.4 → openpinch-0.2.8}/OpenPinch/data/notebooks/05_schema_service_and_output_workflows.ipynb

@@ -249,15 +249,6 @@
     "    \"reloaded_baseline_status\": reloaded.solve_variant(\"baseline\").status,\n",
     "}\n"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dashboard-md",
-   "metadata": {},
-   "source": [
-    "## Next step: `show_dashboard()`\n",
-    "After a case is solved, `problem.show_dashboard()` is the next step when you want the Streamlit UI. This notebook does not execute it because launching the dashboard is outside the scope of a packaged, output-free teaching asset.\n"
-   ]
   }
  ],
  "metadata": {