OpenPyTEA 3.1.0__tar.gz → 3.2.0__tar.gz

{openpytea-3.1.0/src/OpenPyTEA.egg-info → openpytea-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenPyTEA
-Version: 3.1.0
+Version: 3.2.0
 Summary: OpenPyTEA: An open-source Python toolkit for techno-economic assessment of process plants with economic sensitivity and uncertainty evaluation
 Maintainer-email: "Panji B. Tamarona" <P.B.Tamarona@tudelft.nl>
 License-Expression: MIT

{openpytea-3.1.0 → openpytea-3.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "OpenPyTEA"
-version = "3.1.0"
+version = "3.2.0"
 description = "OpenPyTEA: An open-source Python toolkit for techno-economic assessment of process plants with economic sensitivity and uncertainty evaluation"
 readme = "README.md"
 license = "MIT"

{openpytea-3.1.0 → openpytea-3.2.0/src/OpenPyTEA.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenPyTEA
-Version: 3.1.0
+Version: 3.2.0
 Summary: OpenPyTEA: An open-source Python toolkit for techno-economic assessment of process plants with economic sensitivity and uncertainty evaluation
 Maintainer-email: "Panji B. Tamarona" <P.B.Tamarona@tudelft.nl>
 License-Expression: MIT

{openpytea-3.1.0 → openpytea-3.2.0}/src/openpytea/io.py

@@ -5,7 +5,7 @@ from importlib.metadata import version
 
 import matplotlib.pyplot as plt
 
-from openpytea.equipment import Equipment
+from openpytea.equipment import Equipment, CompositeEquipment
 from openpytea.plant import Plant
 from openpytea.analysis import (
     direct_costs_data,
@@ -76,6 +76,11 @@ def load_equipment_config(filepath):
           material (falls back to 'Carbon steel'), target_year=2024
         - Optional keys: 'type', 'material', 'num_units', 'purchased_cost',
           'cost_year', 'cost_func', 'target_year'
+        - An entry with a 'components' list (of equipment entries, nesting
+          allowed) builds a CompositeEquipment; it requires 'name' and
+          'process_type' and accepts 'category' (default 'Composite'),
+          'type', 'installation', 'purchased_cost', 'cost_year',
+          'target_year' and 'num_units' (default 1)
     """
     data = _read_json(filepath)
     return _build_equipment_list(data)
@@ -99,45 +104,87 @@ def _build_equipment_list(data):
             "'equipment' must be a list of equipment entries."
         )
 
-    equipment_list = []
+    return [
+        _build_equipment(entry, f"#{i}")
+        for i, entry in enumerate(data["equipment"], start=1)
+    ]
 
-    for i, entry in enumerate(data["equipment"], start=1):
-        if not isinstance(entry, dict):
-            raise ValueError(
-                f"Equipment entry #{i} must be a dictionary."
-            )
 
-        required = ["name", "process_type", "category"]
-        missing = [k for k in required if k not in entry]
+# Installation-factor overrides accepted by Equipment and CompositeEquipment
+_FACTOR_KEYS = (
+    "erection_factor", "piping_factor", "instrumentation_factor",
+    "electrical_factor", "civil_factor", "structural_factor",
+    "lagging_factor", "material_factor",
+)
+
+
+def _build_equipment(entry, label, target_year=2024):
+    """
+    Build one Equipment, or a CompositeEquipment when the entry has a
+    'components' list (built recursively; components without their own
+    'target_year' inherit the composite's).
+    """
+    if not isinstance(entry, dict):
+        raise ValueError(f"Equipment entry {label} must be a dictionary.")
+
+    target_year = entry.get("target_year", target_year)
+    factors = {k: entry[k] for k in _FACTOR_KEYS if k in entry}
+
+    if "components" in entry:
+        missing = [k for k in ("name", "process_type") if k not in entry]
         if missing:
             raise ValueError(
-                f"Equipment entry #{i} is missing required keys: {missing}"
+                f"Equipment entry {label} is missing required keys: {missing}"
             )
-
-        if "purchased_cost" not in entry and "param" not in entry:
+        if not isinstance(entry["components"], list):
             raise ValueError(
-                f"Equipment entry #{i} must define either 'param' "
-                f"or 'purchased_cost'."
+                f"'components' of equipment entry {label} must be a list."
             )
-
-        # ponytail: copies keys by hand; Equipment(**{'param': 0.0, **entry})
-        eq = Equipment(
+        return CompositeEquipment(
             name=entry["name"],
-            param=entry.get("param", 0.0),
             process_type=entry["process_type"],
-            category=entry["category"],
+            components=[
+                _build_equipment(sub, f"{label}.{j}", target_year)
+                for j, sub in enumerate(entry["components"], start=1)
+            ],
+            category=entry.get("category", "Composite"),
             type=entry.get("type"),
-            material=entry.get("material"),
-            num_units=entry.get("num_units"),
+            installation=entry.get("installation", "component"),
             purchased_cost=entry.get("purchased_cost"),
             cost_year=entry.get("cost_year"),
-            cost_func=entry.get("cost_func"),
-            target_year=entry.get("target_year", 2024),
+            target_year=target_year,
+            num_units=entry.get("num_units", 1),
+            **factors,
         )
 
-        equipment_list.append(eq)
+    required = ["name", "process_type", "category"]
+    missing = [k for k in required if k not in entry]
+    if missing:
+        raise ValueError(
+            f"Equipment entry {label} is missing required keys: {missing}"
+        )
 
-    return equipment_list
+    if "purchased_cost" not in entry and "param" not in entry:
+        raise ValueError(
+            f"Equipment entry {label} must define either 'param' "
+            f"or 'purchased_cost'."
+        )
+
+    # ponytail: copies keys by hand; Equipment(**{'param': 0.0, **entry})
+    return Equipment(
+        name=entry["name"],
+        param=entry.get("param", 0.0),
+        process_type=entry["process_type"],
+        category=entry["category"],
+        type=entry.get("type"),
+        material=entry.get("material"),
+        num_units=entry.get("num_units"),
+        purchased_cost=entry.get("purchased_cost"),
+        cost_year=entry.get("cost_year"),
+        cost_func=entry.get("cost_func"),
+        target_year=target_year,
+        **factors,
+    )
 
 
 def load_plant_config(filepath, equipment_list):
@@ -555,6 +602,10 @@ def run_openpytea(config_path, output_dir=None):
     return _run_analyses(equipment_list, plant, config, output_dir)
 
 
+# Analyses whose function takes an ``additional_capex`` argument
+_ADDITIONAL_CAPEX_ANALYSES = {"fixed_capital", "tornado", "monte_carlo"}
+
+
 def _run_analyses(equipment_list, plant, analysis_cfg, output_dir):
     """
     Run the configured analyses for a loaded plant/equipment pair and
@@ -602,7 +653,10 @@ def _run_analyses(equipment_list, plant, analysis_cfg, output_dir):
     if save_json or save_plots:
         output_dir.mkdir(parents=True, exist_ok=True)
 
-    plant.calculate_all()
+    # One switch so the exported plant results and the analyses agree on
+    # whether additional capex counts; an analysis' own args still win
+    additional_capex = analysis_block.get("additional_capex", False)
+    plant.calculate_all(additional_capex=additional_capex)
 
     results = {}
 
@@ -621,15 +675,20 @@ def _run_analyses(equipment_list, plant, analysis_cfg, output_dir):
         cfg = analysis_block.get(key, {})
         if cfg.get("run"):
             args = cfg.get("args", {})
+            if key in _ADDITIONAL_CAPEX_ANALYSES:
+                args = {"additional_capex": additional_capex, **args}
             results[key] = func(plant, **args)
 
     sens_cfg = analysis_block.get("sensitivity", {})
+    sens_plot_args = {}
     if sens_cfg.get("run", False):
         results["sensitivity"] = {}
         for i, case in enumerate(sens_cfg.get("cases", []), start=1):
             name = case.get("name", f"case_{i}")
-            args = case.get("args", {})
+            args = {"additional_capex": additional_capex,
+                    **case.get("args", {})}
             results["sensitivity"][name] = sensitivity_data(plant, **args)
+            sens_plot_args[name] = case.get("plot_args", {})
 
     if save_json:
         export_equipment_results(
@@ -667,13 +726,18 @@ def _run_analyses(equipment_list, plant, analysis_cfg, output_dir):
             ("cash_flow", plot_cash_flow),
         ):
             if key in results:
-                _save(plot_fn(results[key], show=False)[0], key)
+                plot_args = analysis_block[key].get("plot_args", {})
+                _save(plot_fn(results[key], show=False, **plot_args)[0], key)
 
         for name, data in results.get("sensitivity", {}).items():
-            _save(plot_sensitivity(data, show=False)[0], f"sensitivity_{name}")
+            plot_args = sens_plot_args.get(name, {})
+            _save(plot_sensitivity(data, show=False, **plot_args)[0],
+                  f"sensitivity_{name}")
 
         if "tornado" in results:
-            _save(plot_tornado(results["tornado"], show=False)[0], "tornado")
+            plot_args = analysis_block["tornado"].get("plot_args", {})
+            _save(plot_tornado(results["tornado"], show=False, **plot_args)[0],
+                  "tornado")
 
         if "monte_carlo" in results:
             mc_results = results["monte_carlo"]
@@ -704,17 +768,24 @@ def _run_analyses(equipment_list, plant, analysis_cfg, output_dir):
                     mc_results,
                     metric=metric_name,
                     show=False,
+                    **mc_cfg.get("plot_args", {}),
                 )
                 _save(fig, f"monte_carlo_{metric_name.lower()}")
 
-            if mc_cfg.get("plot_inputs", False):
-                fig_process, _, fig_economic, _ = plot_monte_carlo_inputs(
-                    mc_results, show=False
+            inputs_cfg = mc_cfg.get("plot_inputs", False)
+            if inputs_cfg:
+                # true, or a dict of plot_monte_carlo_inputs kwargs
+                plot_args = inputs_cfg if isinstance(inputs_cfg, dict) else {}
+                out = plot_monte_carlo_inputs(
+                    mc_results, show=False, **plot_args
+                )
+                category = plot_args.get("category", "both")
+                groups = (
+                    ("process", "economic") if category == "both"
+                    else (category,)
                 )
-                for group_name, fig in (
-                    ("process", fig_process),
-                    ("economic", fig_economic),
-                ):
+                # out is (fig, axes) per group, flattened
+                for group_name, fig in zip(groups, out[::2]):
                     if fig is None:
                         continue  # no inputs sampled for this group
                     _save(fig, f"monte_carlo_inputs_{group_name}")

{openpytea-3.1.0 → openpytea-3.2.0}/tests/test_composite_equipment.py

@@ -218,3 +218,33 @@ def test_composite_in_plant_and_direct_costs_data(psa):
     expanded = direct_costs_data(plant, expand_composites=True)["components"][0]
     assert set(expanded) == {"PSA / Vessel", "PSA / Adsorbent", "Pump"}
     assert sum(expanded.values()) == pytest.approx(sum(lumped.values()))
+
+
+def test_json_builds_nested_composite(psa):
+    from openpytea.io import _build_equipment_list
+
+    def part(name, cost, process_type, category, **kw):
+        return {"name": name, "purchased_cost": cost, "cost_year": 2024,
+                "process_type": process_type, "category": category, **kw}
+
+    entry = {
+        "name": "Train", "process_type": "Fluids", "num_units": 2,
+        "components": [
+            {"name": "PSA", "process_type": "Fluids",
+             "category": "Adsorption", "type": "PSA",
+             "components": [
+                 part("Vessel", 10_000, "Fluids", "Pressure vessels",
+                      num_units=4),
+                 part("Adsorbent", 5_000, "Solids",
+                      "Packings & adsorbents"),
+             ]},
+        ],
+    }
+    (train,) = _build_equipment_list({"equipment": [entry]})
+
+    assert isinstance(train, CompositeEquipment)
+    assert train.category == "Composite"
+    built_psa = train.components[0]
+    assert isinstance(built_psa, CompositeEquipment)
+    assert built_psa.direct_cost == pytest.approx(psa.direct_cost)
+    assert train.direct_cost == pytest.approx(2 * psa.direct_cost)

{openpytea-3.1.0 → openpytea-3.2.0}/tests/test_run_tea.py

@@ -1,4 +1,6 @@
 import json
+
+import pytest
 from openpytea import run_tea, run_openpytea
 
 
@@ -286,3 +288,48 @@ def test_run_tea_python_api_honors_config_directory(tmp_path):
     )
 
     assert (config_dir / "Test Plant_analysis_results.json").exists()
+
+
+def test_run_openpytea_passes_factors_capex_and_plot_args(tmp_path):
+    equipment = _equipment_data()
+    equipment["equipment"][1]["piping_factor"] = 0.0
+    plant = _plant_data()
+    plant["plant"]["additional_capex_years"] = [5]
+    plant["plant"]["additional_capex_cost"] = [50_000]
+    analysis = {
+        "analysis": {
+            "additional_capex": True,
+            "fixed_capital": {"run": True, "plot_args": {"figsize": [2, 2]}},
+            "monte_carlo": {
+                "run": True,
+                "args": {"num_samples": 100, "batch_size": 20},
+                "metric": ["LCOP"],
+                "plot_args": {"bins": 5},
+                "plot_inputs": {"category": "economic"},
+            },
+        },
+        "output": {"save_json": True, "save_plots": True},
+    }
+    config_path = tmp_path / "config.json"
+    config_path.write_text(
+        json.dumps({**equipment, **plant, **analysis}), encoding="utf-8"
+    )
+    out = tmp_path / "results"
+    run_openpytea(config_path=config_path, output_dir=out)
+
+    eq = json.loads((out / "Test Plant_equipment_results.json").read_text())
+    pump = eq["equipment"][1]
+    reactor = eq["equipment"][0]
+    # Same purchased cost and process type, only the pump drops piping
+    assert pump["direct_cost"] / pump["purchased_cost"] < (
+        reactor["direct_cost"] / reactor["purchased_cost"]
+    )
+
+    from openpytea.io import _build_equipment_list, _build_plant
+    expected = _build_plant(plant, _build_equipment_list(equipment))
+    expected.calculate_all(additional_capex=True)
+    plant_res = json.loads((out / "Test Plant_plant_results.json").read_text())
+    assert plant_res["metrics"]["roi"] == pytest.approx(expected.roi)
+
+    assert (out / "Test Plant_monte_carlo_inputs_economic.png").exists()
+    assert not (out / "Test Plant_monte_carlo_inputs_process.png").exists()