flextool 4.0.1__tar.gz → 4.0.4__tar.gz

{flextool-4.0.1 → flextool-4.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flextool
-Version: 4.0.1
+Version: 4.0.4
 Summary: IRENA FlexTool is an energy and power systems model for understanding the role of variable power generation in future energy systems.
 Author: IRENA FlexTool contributors
 License: © International Renewable Energy Agency 2018-2022
@@ -39,7 +39,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: polar-high>=3.7.0
-Requires-Dist: highspy<=1.14.0
+Requires-Dist: highspy<=1.14.0,>=1.14.0
 Requires-Dist: polars>=1.40
 Requires-Dist: pandas
 Requires-Dist: spinedb-api

{flextool-4.0.1 → flextool-4.0.4}/flextool/engine_polars/_derived_params.py

@@ -6572,12 +6572,23 @@ def dtttdt_from_source(source: "InputSource",
     # period__branch.csv (workdir-aware) to discover which periods are
     # branches off a non-self anchor.
     branch_anchor: dict[str, str] = {}
+    anchors_with_self: set[str] = set()
     pbf: pl.DataFrame | None = None
     period_col, branch_col = "period", "branch"
     # Path B Cat B: prefer ctx.period_branch (schema [d_anchor, b]).
+    # Null-guard: the accessor casts against the live axis enums, and
+    # the ``d_anchor`` enum vocabulary is empty by contract ("built at
+    # Phase 3 handoff") — under enum activation every anchor value
+    # casts to null, which would poison the anchors_with_self /
+    # branch_anchor classification below (a null==null self-row turns
+    # EVERY period into a "branch").  Only trust the ctx frame when
+    # both columns are fully populated; otherwise fall through to the
+    # provider/workdir CSV (raw Utf8 columns).
     if ctx is not None:
         pb_ctx = ctx.period_branch
-        if pb_ctx.height > 0:
+        if (pb_ctx.height > 0
+                and pb_ctx["d_anchor"].null_count() == 0
+                and pb_ctx["b"].null_count() == 0):
             pbf = pb_ctx
             period_col, branch_col = "d_anchor", "b"
     if pbf is None and workdir is not None:
@@ -6590,13 +6601,52 @@ def dtttdt_from_source(source: "InputSource",
     if pbf is not None and pbf.height > 0:
         pb_rows = list(zip(pbf[period_col].to_list(),
                               pbf[branch_col].to_list()))
-        anchors_with_self: set[str] = set()
         for a, b in pb_rows:
             if a == b:
                 anchors_with_self.add(a)
         for a, b in pb_rows:
             if b != a and a in anchors_with_self:
                 branch_anchor[b] = a
+    # Continuation fan-out: the time-branch map (period -> time_branch,
+    # from solve_branch__time_branch.csv) lets a continuation branch
+    # period wrap to the nearest earlier period of the SAME time-branch
+    # instead of self-wrapping, mirroring ``make_step_jump``.  Ctx-first
+    # (typed accessor), provider/workdir fallback.
+    time_branch_of: dict[str, str] = {}
+    if ctx is not None:
+        sbtb_ctx = ctx.solve_branch_time_branch
+        if sbtb_ctx.height > 0:
+            time_branch_of = dict(zip(sbtb_ctx["d"].to_list(),
+                                        sbtb_ctx["time_branch"].to_list()))
+    if not time_branch_of and workdir is not None:
+        sbtb_path = (Path(workdir) / "solve_data"
+                     / "solve_branch__time_branch.csv")
+        if _provider_has_key(provider, sbtb_path):  # Phase E-j — seed-aware
+            try:
+                sbtb_df = _provider_read(provider, sbtb_path)
+            except Exception:
+                sbtb_df = None
+            if (sbtb_df is not None and sbtb_df.height > 0
+                    and "period" in sbtb_df.columns
+                    and "branch" in sbtb_df.columns):
+                time_branch_of = dict(zip(sbtb_df["period"].to_list(),
+                                            sbtb_df["branch"].to_list()))
+    if branch_anchor and not time_branch_of:
+        # Failure semantics (do NOT fall back to self-wrap): a
+        # period__branch with branch rows but no time-branch map means
+        # the per-solve preprocessing artefacts are inconsistent.  A
+        # silent self-wrap fallback would sever continuation branch
+        # periods from their own branch chain — the exact silent
+        # truncation bug this walk repairs — so raise instead.
+        raise ValueError(
+            "dtttdt_from_source: period__branch declares branch periods "
+            f"({sorted(branch_anchor)}) but solve_branch__time_branch is "
+            "missing or empty — cannot resolve cross-period wrap "
+            "predecessors for branch periods.  The per-solve emitter "
+            "(emit_branch_weights_and_map) writes this frame for every "
+            "solve; its absence indicates an inconsistent workdir/"
+            "Provider state."
+        )
     out_rows: list[tuple[str, str, str, str, str, str]] = []
     len(period_order)
     # Find within-solve predecessor for first-of-period rows.
@@ -6606,19 +6656,36 @@ def dtttdt_from_source(source: "InputSource",
             continue
         # Determine the predecessor period for the j=0 wrap row.
         # Mirrors ``timeline_config.make_step_jump``:
-        #   * branch (non-anchor) period → self-wrap;
+        #   * branch (non-anchor) period → nearest earlier period with
+        #     the SAME time-branch (continuation linkage); self-wrap
+        #     when none exists (the branching period's own fan);
         #   * first anchor period (== first_period_name in flextool's
         #     reversed walk) → wrap to last_period_name (last in
-        #     active_time_list iteration order, == period_order[-1]);
-        #   * non-first anchor period → wrap to the period at
-        #     period_order[pi - 1].
+        #     active_time_list iteration order, == period_order[-1] —
+        #     retained quirk);
+        #   * non-first anchor period → nearest earlier ANCHOR period
+        #     (skips branch periods so a realized continuation period
+        #     wraps to the previous realized period); positional
+        #     ``period_order[pi - 1]`` fallback when there is no
+        #     period__branch data (deterministic path, where
+        #     positional ≡ previous-anchor anyway).
         if period in branch_anchor:
             wrap_period = period
+            tb = time_branch_of.get(period)
+            if tb is not None:
+                for qi in range(pi - 1, -1, -1):
+                    if time_branch_of.get(period_order[qi]) == tb:
+                        wrap_period = period_order[qi]
+                        break
         else:
             if pi == 0:
                 wrap_period = period_order[-1]
             else:
                 wrap_period = period_order[pi - 1]
+                for qi in range(pi - 1, -1, -1):
+                    if period_order[qi] in anchors_with_self:
+                        wrap_period = period_order[qi]
+                        break
         prev_solve_steps = per_period.get(wrap_period) or []
         prev_solve_last_t = prev_solve_steps[-1][0] if prev_solve_steps \
                             else steps[-1][0]

{flextool-4.0.1 → flextool-4.0.4}/flextool/engine_polars/_emit_solve_writers.py

@@ -241,7 +241,10 @@ def derive_years_represented(
                 str(years_to_cover_within_year),
             ))
             for pd_pair in period__branch:
-                if pd_pair[0] in period__years[0] and pd_pair[0] != pd_pair[1]:
+                # Equality, not substring containment (``in``): with
+                # prefix-overlapping period names (p1 / p10), ``in``
+                # would copy p10's year rows to p1's branches.
+                if pd_pair[0] == period__years[0] and pd_pair[0] != pd_pair[1]:
                     rows.append((
                         pd_pair[1], str(year_count), str(year_count),
                         str(years_to_cover_within_year),
@@ -278,7 +281,9 @@ def derive_period_years(
     for period__year in years_represented:
         rows.append((period__year[0], str(year_count)))
         for pd_pair in stochastic_branches:
-            if pd_pair[0] in period__year[0] and pd_pair[0] != pd_pair[1]:
+            # Equality, not substring containment — see
+            # derive_years_represented.
+            if pd_pair[0] == period__year[0] and pd_pair[0] != pd_pair[1]:
                 rows.append((pd_pair[1], str(year_count)))
         year_count += float(period__year[1])
     return _to_utf8_frame(("period", "param"), rows)

{flextool-4.0.1 → flextool-4.0.4}/flextool/engine_polars/_solve_context.py

@@ -192,6 +192,13 @@ class SolveContext:
         ),
         repr=False,
     )
+    _solve_branch_time_branch_loaded: bool = field(default=False, repr=False)
+    _solve_branch_time_branch: pl.DataFrame = field(
+        default_factory=lambda: pl.DataFrame(
+            schema={"d": pl.Utf8, "time_branch": pl.Utf8}
+        ),
+        repr=False,
+    )
 
     # Internal: ad-hoc CSV cache.  Keyed by ``str(path)`` (no syscall).
     # Values are ``None`` when the file is absent so we don't re-stat
@@ -452,6 +459,27 @@ class SolveContext:
             self._solve_branch_weight_loaded = True
         return self._solve_branch_weight
 
+    @property
+    def solve_branch_time_branch(self) -> pl.DataFrame:
+        """``[d, time_branch]`` from ``solve_branch__time_branch.csv``
+        (rename ``period`` → ``d``, ``branch`` → ``time_branch``).
+        Empty when the file is missing.
+
+        Continuation fan-out: ``dtttdt_from_source`` walks this map so
+        a continuation branch period wraps to the nearest earlier
+        period sharing the same time-branch instead of self-wrapping.
+        Columns stay ``Utf8`` — the ``time_branch`` vocabulary (DB
+        branch names like ``rlz`` / ``low``) is not a canonical axis
+        enum, and consumers use the frame as a plain dict.
+        """
+        if not self._solve_branch_time_branch_loaded:
+            self._solve_branch_time_branch = _load_solve_branch_time_branch(
+                self.solve_data_dir / "solve_branch__time_branch.csv",
+                provider=self.provider,
+            )
+            self._solve_branch_time_branch_loaded = True
+        return self._solve_branch_time_branch
+
     # ------------------------------------------------------------------
     # Typed-field convenience accessors
     # ------------------------------------------------------------------
@@ -856,6 +884,32 @@ def _load_period_share(solve_data_dir: Path,
     return empty
 
 
+def _load_solve_branch_time_branch(path: Path,
+                                     *, provider: "object | None" = None,
+                                     ) -> pl.DataFrame:
+    """Load ``solve_branch__time_branch.csv`` as ``[d, time_branch]``.
+
+    Plain ``Utf8`` columns — the time-branch vocabulary is not a
+    canonical axis enum (see :pyattr:`SolveContext.solve_branch_time_branch`).
+    """
+    empty = pl.DataFrame(schema={"d": pl.Utf8, "time_branch": pl.Utf8})
+    df = _read_frame(path, provider=provider,
+                      consumer="SolveContext.solve_branch_time_branch")
+    if df is None:
+        return empty
+    rename = {}
+    if "period" in df.columns:
+        rename["period"] = "d"
+    if "branch" in df.columns:
+        rename["branch"] = "time_branch"
+    df = df.rename(rename)
+    cols = [c for c in ("d", "time_branch") if c in df.columns]
+    if len(cols) < 2:
+        return empty
+    return (df.select(pl.col(c).cast(pl.Utf8) for c in cols)
+              .unique(maintain_order=True))
+
+
 def _load_solve_branch_weight(path: Path,
                                 *, provider: "object | None" = None) -> pl.DataFrame:
     """Load ``solve_branch_weight.csv`` and rename to canonical

{flextool-4.0.1 → flextool-4.0.4}/flextool/engine_polars/_stochastic.py

@@ -30,10 +30,15 @@ Behavioural quirks
   ``branch != period`` AND the realized flag is not ``"yes"``.  Subtle
   three-way condition.
 
-* **Continuation-after-branching**: when a roll's jump exceeds a
-  period length, branches continue into subsequent periods using the
-  same ``period + "_" + branch`` naming.  The naming is "sticky"
-  across periods.
+* **Continuation-after-branching**: every period after the branching
+  period continues the fan.  The realized branch keeps the REAL period
+  name (with its active / realized / fix-storage windows); each
+  non-realized nonzero-weight branch gets a synthetic
+  ``period + "_" + branch`` copy of the period's active time (LP
+  variables, never committed).  The naming is "sticky" across periods.
+  ``period__branch`` mirrors the branching period's metadata rows
+  (``(period, period)`` self-row plus one row per fan member,
+  realized and zero-weight included).
 
 * **Single realized branch per period**: each period must have
   exactly one ``realized: yes`` row (or zero before any branching has
@@ -378,6 +383,17 @@ class StochasticSolver:
         but NOT to ``realized_time_lists`` / ``fix_storage_time_lists``;
         branches are future scenarios that aren't committed.
 
+        After the branching period, the fan extends through every
+        remaining period of the solve: the realized branch keeps the
+        REAL period names (and their realized / fix-storage windows),
+        while each non-realized nonzero-weight branch ``b`` gets one
+        synthetic ``period + "_" + b`` period per continuation period
+        carrying a full copy of that period's active time.
+        ``period__branch`` mirrors the branching period's metadata rows
+        (self-row plus one row per fan member including the realized
+        and zero-weight branches); ``solve_branch__time_branch`` gains
+        rows only for branches that received active time.
+
         IMPORTANT: branches do NOT enter ``invest_periods`` either.
         Per ``audit/a6_b_dim_alternative.md`` (R-O6), ``v_invest`` is
         realized-only — recourse investment is a future capability.
@@ -418,6 +434,10 @@ class StochasticSolver:
 
             branched = False
             branches: list[str] = []
+            # Branches that received active time at the branching period
+            # (nonzero weight, != period, not realized).  Only these are
+            # extended with active time into continuation periods.
+            active_branches: list[str] = []
             branch_start_time_lists[solve] = None
 
             # First step of the solve (used for validation below).
@@ -446,9 +466,14 @@ class StochasticSolver:
                 raise FlexToolConfigError(message)
 
             # Walk periods — at the first branch trigger, fan out into
-            # branches; subsequent periods continue the same branches
-            # (continuation-after-branching at lines 329-340 of the
-            # reference).
+            # branches; subsequent periods continue the same branches.
+            # NB: the reference implementation's continuation block
+            # (flextoolrunner.py:1745-1752) was dead code — it never
+            # wrote active/realized/fix-storage time for continuation
+            # periods, silently truncating the horizon.  This module
+            # intentionally diverges by actually emitting the
+            # continuation timelines (realized branch keeps real period
+            # names; active branches get synthetic copies).
             for period, active_time in active_time_list.items():
                 if not branched:
                     period__branch_lists[solve].append((period, period))
@@ -491,6 +516,7 @@ class StochasticSolver:
                                     and branch != period
                                     and branch__weight__real[2] != "yes"
                                 ):
+                                    active_branches.append(branch)
                                     new_active_time_list[solve_branch] = active_time[0:]
                                     solve_branch__time_branch_lists[solve].append(
                                         (solve_branch, branch)
@@ -506,15 +532,34 @@ class StochasticSolver:
                                     )
                             break
                 else:
-                    # Continuation-after-branching: extend each branch
-                    # into the next period using the same branch-name
-                    # prefix.
+                    # Continuation-after-branching: the realized branch
+                    # keeps the REAL period name; each active branch is
+                    # extended into this period as a synthetic
+                    # '<period>_<branch>' copy.  Append order mirrors
+                    # the branching period: the (period, period)
+                    # self-row first, then fan rows in DB order.  The
+                    # self-row is load-bearing for the branch-weight
+                    # normalization (the realized member of each cohort
+                    # is detected via its (d, d) row) — see
+                    # derive_solve_branch_weight.
+                    period__branch_lists[solve].append((period, period))
+                    new_active_time_list[period] = active_time_list[period]
+                    if period in realized_time_list:
+                        new_realized_time_list[period] = realized_time_list[period]
+                    if period in fix_storage_time_list:
+                        new_fix_storage_time_list[period] = (
+                            fix_storage_time_list[period]
+                        )
                     for branch in branches:
                         solve_branch = period + "_" + branch
                         period__branch_lists[solve].append((period, solve_branch))
-                        solve_branch__time_branch_lists[solve].append(
-                            (solve_branch, branch)
-                        )
+                        if branch in active_branches:
+                            new_active_time_list[solve_branch] = (
+                                active_time_list[period][0:]
+                            )
+                            solve_branch__time_branch_lists[solve].append(
+                                (solve_branch, branch)
+                            )
                         for i in active_time_list[period]:
                             self.state.timeline.stochastic_timesteps[solve].append(
                                 (solve_branch, i.timestep)

{flextool-4.0.1 → flextool-4.0.4}/flextool/engine_polars/_timeline.py

@@ -561,9 +561,18 @@ class TimelineConfig:
                 solve_config.realized_periods[solve]
                 + solve_config.invest_periods[solve]
             )
-            all_periods = {item for tup in all_periods_tuples for item in tup}
-            for period in all_periods:
-                if solve not in solve_config.solve_period_years_represented:
+            # Ordered de-dup (first occurrence) — a set here would make
+            # the seeded row order vary with PYTHONHASHSEED.
+            all_periods = list(
+                dict.fromkeys(
+                    item for tup in all_periods_tuples for item in tup
+                )
+            )
+            # Membership check OUTSIDE the loop: the first append below
+            # inserts the solve key into the defaultdict, so an in-loop
+            # check would stop after seeding a single period.
+            if solve not in solve_config.solve_period_years_represented:
+                for period in all_periods:
                     solve_config.solve_period_years_represented[solve].append(
                         [period, 1.0]
                     )
@@ -1097,14 +1106,29 @@ def make_step_jump(
     """Build a list of step-jump entries for the solver.
 
     Each entry describes the jump from one simulation step to the
-    next, including cross-period jumps.  Stochastic branches use the
-    last-realized-step on a sibling branch as the predecessor.
+    next, including cross-period jumps.
+
+    Cross-period linkage for the first step of a period:
+
+    * **anchor periods** (``(period, period) ∈ period__branch``): the
+      nearest previous ANCHOR key in ``active_time_list`` order (skips
+      branch periods, so a realized continuation period links to the
+      previous realized period).  The solve's FIRST period keeps the
+      cyclic wrap to the last dict key (a branch period in stochastic
+      solves — retained quirk, consumed only by cyclic storage-binding
+      paths).
+    * **branch periods**: the nearest earlier period sharing the same
+      time-branch in ``solve_branch__time_branch_list`` (a continuation
+      branch period continues from the same branch's previous period);
+      when no such period exists (the branching period's own fan) the
+      period self-cycles on its own last step.
     """
     step_lengths: list[tuple] = []
     period_start_pos = 0
     period_counter = -1
-    first_period_name = list(active_time_list)[0]
-    last_period_name = list(active_time_list)[-1]
+    period_names = list(active_time_list)
+    first_period_name = period_names[0]
+    last_period_name = period_names[-1]
     for period, active_time in reversed(active_time_list.items()):
         period_counter -= 1
         period_last = len(active_time)
@@ -1112,7 +1136,18 @@ def make_step_jump(
         if period == first_period_name:
             previous_period_name = last_period_name
         else:
-            previous_period_name = list(active_time_list)[period_counter]
+            previous_period_name = period_names[period_counter]
+            if (period, period) in period__branch:
+                # Anchor period: skip branch periods — link to the
+                # nearest previous key that is itself an anchor.
+                # Deterministic solves (every key an anchor) reduce to
+                # the positional previous; when no earlier anchor
+                # exists the positional previous is kept as fallback.
+                pos = period_names.index(period)
+                for k in range(pos - 1, -1, -1):
+                    if (period_names[k], period_names[k]) in period__branch:
+                        previous_period_name = period_names[k]
+                        break
         for i, step in enumerate(reversed(active_time)):
             j = period_last - i - 1
             if j > 0:
@@ -1146,18 +1181,45 @@ def make_step_jump(
                     )
             else:
                 if (period, period) not in period__branch:
-                    original_period = None
-                    for pb in period__branch:
-                        if pb[1] == period:
-                            original_period = pb[0]
-                    if (
-                        original_period is not None
-                        and (original_period, original_period)
-                        in period__branch
-                        and original_period in active_time_list
+                    # Branch period: find the nearest EARLIER period
+                    # sharing this period's time-branch — the
+                    # continuation linkage (a continuation branch
+                    # period continues from the same branch's previous
+                    # period).  When none exists (the branching
+                    # period's own fan: earlier periods carry only the
+                    # realized time-branch), fall back to the
+                    # self-cycle row on the period's own last step.
+                    time_branch = None
+                    for sb_tb in solve_branch__time_branch_list:
+                        if sb_tb[0] == period:
+                            time_branch = sb_tb[1]
+                    past = False
+                    found = False
+                    previous_period_with_branch = None
+                    for solve_period, _a_t in reversed(
+                        active_time_list.items()
                     ):
+                        if past:
+                            for sb_tb in solve_branch__time_branch_list:
+                                if (
+                                    sb_tb[0] == solve_period
+                                    and sb_tb[1] == time_branch
+                                ):
+                                    previous_period_with_branch = (
+                                        solve_period
+                                    )
+                                    found = True
+                            if found:
+                                break
+                        else:
+                            if solve_period == period:
+                                past = True
+                    if found:
                         jump = (
-                            active_time[j].index - active_time[-1].index
+                            active_time[j].index
+                            - active_time_list[
+                                previous_period_with_branch
+                            ][-1].index
                         )
                         step_lengths.insert(
                             period_start_pos,
@@ -1166,16 +1228,14 @@ def make_step_jump(
                                 step.timestep,
                                 active_time[j - 1].timestep,
                                 active_time[block_last].timestep,
-                                period,
-                                active_time_list[period][-1].timestep,
+                                previous_period_with_branch,
+                                active_time_list[
+                                    previous_period_with_branch
+                                ][-1].timestep,
                                 jump,
                             ),
                         )
-                    elif (
-                        original_period is not None
-                        and (original_period, original_period)
-                        in period__branch
-                    ):
+                    else:
                         jump = (
                             active_time[j].index - active_time[-1].index
                         )
@@ -1191,52 +1251,6 @@ def make_step_jump(
                                 jump,
                             ),
                         )
-                    else:
-                        time_branch = None
-                        for sb_tb in solve_branch__time_branch_list:
-                            if sb_tb[0] == period:
-                                time_branch = sb_tb[1]
-                        past = False
-                        found = False
-                        previous_period_with_branch = None
-                        for solve_period, _a_t in reversed(
-                            active_time_list.items()
-                        ):
-                            if past:
-                                for sb_tb in solve_branch__time_branch_list:
-                                    if (
-                                        sb_tb[0] == solve_period
-                                        and sb_tb[1] == time_branch
-                                    ):
-                                        previous_period_with_branch = (
-                                            solve_period
-                                        )
-                                        found = True
-                                if found:
-                                    break
-                            else:
-                                if solve_period == period:
-                                    past = True
-                        jump = (
-                            active_time[j].index
-                            - active_time_list[
-                                previous_period_with_branch
-                            ][-1].index
-                        )
-                        step_lengths.insert(
-                            period_start_pos,
-                            (
-                                period,
-                                step.timestep,
-                                active_time[j - 1].timestep,
-                                active_time[block_last].timestep,
-                                previous_period_with_branch,
-                                active_time_list[
-                                    previous_period_with_branch
-                                ][-1].timestep,
-                                jump,
-                            ),
-                        )
                 else:
                     jump = (
                         active_time[j].index

{flextool-4.0.1 → flextool-4.0.4}/flextool/process_outputs/calc_storage_vre.py

@@ -126,12 +126,33 @@ def compute_storage_and_vre(par, s, v, r) -> None:
     profile_level_of_vre_node_profile_upper = vre_node_profile_upper.get_level_values('profile')
     vre_processes_in_use = vre_profiles_in_use[profile_level_of_vre_node_profile_upper]
     vre_processes_in_use.columns = vre_node_profile_upper
+    # par.process_availability only carries processes that authored
+    # unit/connection.availability.  A profile-driven VRE process typically
+    # leaves the availability *parameter* at its 1.0 default and is therefore
+    # absent from the frame.  A plain ``.mul`` aligns on the shared 'process'
+    # level and drops those columns to NaN, silently zeroing VRE potential /
+    # curtailment.  The engine applies availability=1.0 to every unauthored
+    # process (model.py: left-join + fill_null(1.0)); reproduce that here by
+    # densifying availability to 1.0 over the VRE process set before the mul.
+    vre_procs = vre_processes_in_use.columns.get_level_values('process').unique()
+    availability_dt = par.process_availability.reindex(columns=vre_procs).fillna(1.0)
     r.potentialVREgen_dt = (
         vre_processes_in_use
-        .mul(par.process_availability)
+        .mul(availability_dt, level='process')
         .mul(r.entity_all_capacity, axis=1, level=0)
         .droplevel(axis=1, level=['profile', 'profile_method'])
     )
+    # A (process, node) flow may carry more than one ``upper_limit`` profile
+    # (e.g. an availability profile plus a scheduling upper bound under a
+    # ``free_schedule`` alternative).  The engine enforces flow ≤ profile ×
+    # capacity for each, so the achievable potential is the tightest (min)
+    # cap; collapsing to the min also keeps curtailment = potential − actual
+    # ≥ 0.  Only rewrite when duplicates exist so single-profile models stay
+    # byte-identical (min-collapse preserves first-seen column order).
+    if r.potentialVREgen_dt.columns.duplicated().any():
+        r.potentialVREgen_dt = (
+            r.potentialVREgen_dt.T.groupby(level=['process', 'node'], sort=False).min().T
+        )
     # potentialVREgen_dt is MW (profile × availability × capacity); multiply
     # by step_duration to get MWh per step before summing to MWh per period.
     r.potentialVREgen_d = (

{flextool-4.0.1 → flextool-4.0.4}/flextool/process_outputs/out_costs.py

@@ -41,8 +41,18 @@ def cost_summaries(par, s, v, r, debug):
     costs_dt['co2'] = r.cost_co2_dt
     costs_dt['other operational'] = r.cost_process_other_operational_cost_dt.sum(axis=1)
     costs_dt['starts'] = r.cost_startup_dt.sum(axis=1)
-    costs_dt['upward slack penalty'] = r.costPenalty_node_state_upDown_dt.xs('up', level='upDown', axis=1).sum(axis=1)
-    costs_dt['downward slack penalty'] = r.costPenalty_node_state_upDown_dt.xs('down', level='upDown', axis=1).sum(axis=1)
+    # With penalty_method=off on every node, v.q_state_up/down have no
+    # columns, so costPenalty_node_state_upDown_dt is empty and the 'up'/
+    # 'down' keys never attach to the upDown level (KeyError on .xs).  Guard
+    # like the reserve slack terms below and the per-entity path (line ~265).
+    try:
+        costs_dt['upward slack penalty'] = r.costPenalty_node_state_upDown_dt.xs('up', level='upDown', axis=1).sum(axis=1)
+    except KeyError:
+        costs_dt['upward slack penalty'] = 0
+    try:
+        costs_dt['downward slack penalty'] = r.costPenalty_node_state_upDown_dt.xs('down', level='upDown', axis=1).sum(axis=1)
+    except KeyError:
+        costs_dt['downward slack penalty'] = 0
     costs_dt['inertia slack penalty'] = r.costPenalty_inertia_dt.sum(axis=1)
     costs_dt['non-synchronous slack penalty'] = r.costPenalty_non_synchronous_dt.sum(axis=1)
     try: