flextool 4.0.0__py3-none-any.whl

flextool/process_outputs/calc_group_flows.py

@@ -0,0 +1,192 @@
+import pandas as pd
+
+from flextool.process_outputs._annualize import annualize_dt_to_d
+
+
+def compute_group_flows(par, s, v, r) -> None:
+    """Compute all group-level flow aggregations (connection and unit flows, inflow, losses).
+
+    v_flow in FlexTool is MW (MWh/h — length-of-time independent).  Period
+    aggregations here multiply by par.step_duration before summing so that
+    `_d` results are MWh (then annualized by dividing by
+    complete_period_share_of_year).  par.node_inflow is already MWh/step
+    (see mod comment at line 2319), so inflow-derived frames sum as-is.
+    """
+    step_duration = par.step_duration
+
+    # --- Group connection flows (uses r.from_conn and r.to_conn from compute_connection_flows) ---
+
+    # Helper: create an empty DataFrame with the expected MultiIndex column structure
+    _empty_gp = pd.DataFrame(columns=pd.MultiIndex(levels=[[], []], codes=[[], []], names=['group', 'process']))
+    _empty_gga = pd.DataFrame(columns=pd.MultiIndex(levels=[[], [], []], codes=[[], [], []], names=['group', 'group_aggregate', 'process']))
+
+    from_conn_set = s.nodeGroupDispatch__process__connection__to_node_Not_in_aggregate.droplevel('connection')
+    if not from_conn_set.empty and not r.from_conn.empty:
+        group_sets = r.from_conn.columns.join(from_conn_set, how='inner')
+        from_conn_selected = r.from_conn[group_sets.droplevel('group')]
+        from_conn_selected.columns = group_sets
+        r.nodeGroupDispatch__from_connection_not_in_aggregate__dt = from_conn_selected
+    else:
+        r.nodeGroupDispatch__from_connection_not_in_aggregate__dt = _empty_gp.copy()
+
+    to_conn_set = s.nodeGroupDispatch__process__node__to_connection_Not_in_aggregate.droplevel('connection')
+    if not to_conn_set.empty and not r.to_conn.empty:
+        group_sets = r.to_conn.columns.join(to_conn_set, how='inner')
+        to_conn_selected = r.to_conn[group_sets.droplevel('group')]
+        to_conn_selected.columns = group_sets
+        r.nodeGroupDispatch__to_connection_not_in_aggregate__dt = to_conn_selected
+    else:
+        r.nodeGroupDispatch__to_connection_not_in_aggregate__dt = _empty_gp.copy()
+
+    r.nodeGroupDispatch__from_connection_not_in_aggregate__d = annualize_dt_to_d(r.nodeGroupDispatch__from_connection_not_in_aggregate__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration) if not r.nodeGroupDispatch__from_connection_not_in_aggregate__dt.empty else _empty_gp.copy()
+    r.nodeGroupDispatch__to_connection_not_in_aggregate__d = annualize_dt_to_d(r.nodeGroupDispatch__to_connection_not_in_aggregate__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration) if not r.nodeGroupDispatch__to_connection_not_in_aggregate__dt.empty else _empty_gp.copy()
+
+    from_conn_agg_set = s.nodeGroupDispatch__processGroup__process__connection__to_node.droplevel('connection')
+    if not from_conn_agg_set.empty and not r.from_conn.empty:
+        group_agg_sets = r.from_conn.columns.join(from_conn_agg_set, how='inner')
+        from_conn_agg_selected = r.from_conn[group_agg_sets.droplevel(['group', 'group_aggregate'])]
+        from_conn_agg_selected.columns = group_agg_sets
+        r.nodeGroupDispatch__from_connection_aggregate__dt = from_conn_agg_selected.T.groupby(level=['group', 'group_aggregate']).sum().T
+    else:
+        r.nodeGroupDispatch__from_connection_aggregate__dt = _empty_gga.copy()
+
+    to_conn_agg_set = s.nodeGroupDispatch__processGroup__process__node__to_connection.droplevel('connection')
+    if not to_conn_agg_set.empty and not r.to_conn.empty:
+        group_agg_sets = to_conn_agg_set.join(r.to_conn.columns)
+        to_conn_agg_selected = r.to_conn[group_agg_sets.droplevel(['group', 'group_aggregate'])]
+        to_conn_agg_selected.columns = group_agg_sets
+        r.nodeGroupDispatch__to_connection_aggregate__dt = to_conn_agg_selected.T.groupby(level=['group', 'group_aggregate']).sum().T
+    else:
+        r.nodeGroupDispatch__to_connection_aggregate__dt = _empty_gga.copy()
+
+    r.nodeGroupDispatch__from_connection_aggregate__d = annualize_dt_to_d(r.nodeGroupDispatch__from_connection_aggregate__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration) if not r.nodeGroupDispatch__from_connection_aggregate__dt.empty else _empty_gga.copy()
+    r.nodeGroupDispatch__to_connection_aggregate__d = annualize_dt_to_d(r.nodeGroupDispatch__to_connection_aggregate__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration) if not r.nodeGroupDispatch__to_connection_aggregate__dt.empty else _empty_gga.copy()
+
+    losses_set = s.nodeGroupDispatch__process_fully_inside
+    if not losses_set.empty and not r.connection_losses_dt.empty:
+        group_losses_sets = r.connection_losses_dt.columns.join(losses_set, how='inner')
+        losses_selected = r.connection_losses_dt[group_losses_sets.droplevel('group')]
+        losses_selected.columns = group_losses_sets
+        r.nodeGroupDispatch_Internal_connection_losses__dt = losses_selected
+        r.nodeGroupDispatch_Internal_connection_losses__d = annualize_dt_to_d(r.nodeGroupDispatch_Internal_connection_losses__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration)
+    else:
+        r.nodeGroupDispatch_Internal_connection_losses__dt = pd.DataFrame()
+        r.nodeGroupDispatch_Internal_connection_losses__d = pd.DataFrame()
+
+    # --- Group unit flows ---
+
+    unit_flows = r.flow_dt[r.flow_dt.columns[r.flow_dt.columns.get_level_values('process').isin(s.process_unit)]]
+
+    unit_to_node = unit_flows[unit_flows.columns[unit_flows.columns.droplevel('source').isin(s.process_sink)]]
+    node_to_unit = unit_flows[unit_flows.columns[unit_flows.columns.droplevel('sink').isin(s.process_source)]]
+
+    unit_to_node.columns = unit_to_node.columns.droplevel('source')
+    node_to_unit.columns = node_to_unit.columns.droplevel('sink')
+
+    unit_to_node.columns.names = ['process', 'node']
+    node_to_unit.columns.names = ['process', 'node']
+
+    unit_to_node_set = s.nodeGroupDispatch__process__unit__to_node_Not_in_aggregate.droplevel('unit')
+    group_sets = unit_to_node.columns.join(unit_to_node_set, how='inner')
+    unit_to_node_selected = unit_to_node[group_sets.droplevel('group')]
+    unit_to_node_selected.columns = group_sets
+    r.nodeGroupDispatch__unit_to_node_not_in_aggregate__dt = unit_to_node_selected
+
+    node_to_unit_set = s.nodeGroupDispatch__process__node__to_unit_Not_in_aggregate.droplevel('unit')
+    group_sets = node_to_unit.columns.join(node_to_unit_set, how='inner')
+    node_to_unit_selected = node_to_unit[group_sets.droplevel('group')]
+    node_to_unit_selected.columns = group_sets
+    r.nodeGroupDispatch__node_to_unit_not_in_aggregate__dt = node_to_unit_selected
+
+    r.nodeGroupDispatch__unit_to_node_not_in_aggregate__d = annualize_dt_to_d(r.nodeGroupDispatch__unit_to_node_not_in_aggregate__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration)
+    r.nodeGroupDispatch__node_to_unit_not_in_aggregate__d = annualize_dt_to_d(r.nodeGroupDispatch__node_to_unit_not_in_aggregate__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration)
+
+    unit_to_group_set = s.nodeGroupDispatch__processGroup__process__unit__to_node.droplevel('unit')
+    group_agg_sets = unit_to_node.columns.join(unit_to_group_set, how='inner')
+    unit_to_group_selected = unit_to_node[group_agg_sets.droplevel(['group', 'group_aggregate'])]
+    unit_to_group_selected.columns = group_agg_sets
+    negatives = (par.entity_unitsize[unit_to_group_selected.columns.get_level_values('process')] < 0).values
+    unit_to_group_selected_negative = unit_to_group_selected[unit_to_group_selected.columns[negatives]]
+    unit_to_group_selected_positive = unit_to_group_selected[unit_to_group_selected.columns[~negatives]]
+    r.nodeGroupDispatch__group_aggregate_Unit_to_group_positive__dt = unit_to_group_selected_positive.T.groupby(level=['group', 'group_aggregate']).sum().T
+    r.nodeGroupDispatch__group_aggregate_Unit_to_group_negative__dt = unit_to_group_selected_negative.T.groupby(level=['group', 'group_aggregate']).sum().T
+
+    group_to_unit_set = s.nodeGroupDispatch__processGroup__process__node__to_unit.droplevel('unit')
+    group_agg_sets = node_to_unit.columns.join(group_to_unit_set, how='inner')
+    group_to_unit_selected = node_to_unit[group_agg_sets.droplevel(['group', 'group_aggregate'])]
+    group_to_unit_selected.columns = group_agg_sets
+    negatives = (par.entity_unitsize[group_to_unit_selected.columns.get_level_values('process')] < 0).values
+    group_to_unit_selected_negative = group_to_unit_selected[group_to_unit_selected.columns[negatives]]
+    group_to_unit_selected_positive = group_to_unit_selected[group_to_unit_selected.columns[~negatives]]
+    r.nodeGroupDispatch__group_aggregate_Group_to_unit_positive__dt = group_to_unit_selected_positive.T.groupby(level=['group', 'group_aggregate']).sum().T
+    r.nodeGroupDispatch__group_aggregate_Group_to_unit_negative__dt = group_to_unit_selected_negative.T.groupby(level=['group', 'group_aggregate']).sum().T
+
+    r.nodeGroupDispatch__group_aggregate_Unit_to_group__dt = r.nodeGroupDispatch__group_aggregate_Unit_to_group_positive__dt.sub(
+        r.nodeGroupDispatch__group_aggregate_Group_to_unit_negative__dt, fill_value=0.0)
+    r.nodeGroupDispatch__group_aggregate_Group_to_unit__dt = r.nodeGroupDispatch__group_aggregate_Group_to_unit_positive__dt.sub(
+        r.nodeGroupDispatch__group_aggregate_Unit_to_group_negative__dt, fill_value=0.0)
+
+    r.nodeGroupDispatch__group_aggregate_Group_to_unit__d = annualize_dt_to_d(r.nodeGroupDispatch__group_aggregate_Group_to_unit__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration)
+    r.nodeGroupDispatch__group_aggregate_Unit_to_group__d = annualize_dt_to_d(r.nodeGroupDispatch__group_aggregate_Unit_to_group__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration)
+
+    losses_set = s.nodeGroupDispatch__process_fully_inside
+    group_losses_sets_node_to_unit = losses_set.join(node_to_unit.columns, how='inner')
+    group_losses_sets_unit_to_node = losses_set.join(unit_to_node.columns, how='inner')
+
+    node_to_unit_filtered = node_to_unit[group_losses_sets_node_to_unit.droplevel('group')]
+    unit_to_node_filtered = unit_to_node[group_losses_sets_unit_to_node.droplevel('group')]
+    node_to_unit_filtered.columns = group_losses_sets_node_to_unit
+    unit_to_node_filtered.columns = group_losses_sets_unit_to_node
+
+    unit_losses_dt = node_to_unit_filtered.sub(unit_to_node_filtered, axis=1, fill_value=0.0)
+    r.nodeGroupDispatch_Internal_unit_losses__dt = unit_losses_dt
+    r.nodeGroupDispatch_Internal_unit_losses__d = annualize_dt_to_d(r.nodeGroupDispatch_Internal_unit_losses__dt, par.timestep_weight, par.complete_period_share_of_year, step_duration)
+
+    # --- Node inflow by group ---
+    dt_dispatch_idx = s.dt_realize_dispatch
+    r_group_inflow = pd.DataFrame(0.0, index=dt_dispatch_idx, columns=s.nodeGroupDispatch, dtype=float)
+    for g in s.nodeGroupDispatch:
+        inflow = pd.Series(0.0, index=dt_dispatch_idx)
+        for n in s.node:
+            if (g, n) in s.group_node and (n, 'no_inflow') not in s.node__inflow_method:
+                if n in par.node_inflow.columns:
+                    inflow = inflow + par.node_inflow[n]
+        r_group_inflow[g] = inflow
+    r.group_node_inflow_dt = r_group_inflow
+
+    r.group_node_inflow_d = (
+        r.group_node_inflow_dt[
+            r.group_node_inflow_dt.index.get_level_values('period').isin(s.d_realized_period)
+        ].groupby(level='period').sum() if not r.group_node_inflow_dt.empty
+        else pd.DataFrame(0.0, index=s.d_realized_period, columns=s.nodeGroupDispatch))
+
+    # --- Storage state losses by group ---
+    r_group_state_losses = pd.DataFrame(0.0, index=dt_dispatch_idx, columns=s.nodeGroupDispatch, dtype=float)
+    for g in s.nodeGroupDispatch:
+        losses = pd.Series(0.0, index=dt_dispatch_idx)
+        for n in s.node_self_discharge:
+            if (g, n) in s.group_node and n in r.self_discharge_loss_dt.columns:
+                losses += r.self_discharge_loss_dt[n].reindex(dt_dispatch_idx, fill_value=0)
+        r_group_state_losses[g] = losses
+    r.group_node_state_losses__dt = r_group_state_losses
+
+    r.group_node_state_losses__d = (
+        r.group_node_state_losses__dt[
+            r.group_node_state_losses__dt.index.get_level_values('period').isin(s.d_realized_period)
+        ].groupby(level='period').sum() if not r.group_node_state_losses__dt.empty
+        else pd.DataFrame(0.0, index=s.d_realized_period, columns=s.nodeGroupDispatch))
+
+    # --- Node slack by group ---
+    r.group_node_up_slack__dt = pd.DataFrame(index=s.dt_realize_dispatch)
+    r.group_node_down_slack__dt = pd.DataFrame(index=s.dt_realize_dispatch)
+    for g in s.nodeGroupDispatch:
+        g_node = s.group_node[s.group_node.get_level_values('node').isin(s.node_balance) & s.group_node.get_level_values('group').isin([g])].get_level_values('node')
+        # Nodes with penalty_method == 'off' carry NO balance-slack variables,
+        # so they have no column in the slack frames.  Intersect (order-
+        # preserving) with the available columns rather than raising
+        # ``KeyError: None of [...] are in the columns`` — a hardened node
+        # simply contributes 0 to the group slack.
+        g_node_up = g_node.intersection(r.upward_node_slack_dt.columns)
+        g_node_down = g_node.intersection(r.downward_node_slack_dt.columns)
+        r.group_node_up_slack__dt[g] = r.upward_node_slack_dt[g_node_up].sum(axis=1)
+        r.group_node_down_slack__dt[g] = r.downward_node_slack_dt[g_node_down].sum(axis=1)

flextool/process_outputs/calc_slacks.py

@@ -0,0 +1,103 @@
+import pandas as pd
+
+from flextool.process_outputs._annualize import annualize_dt_to_d
+
+
+def compute_slacks(par, s, v, r) -> None:
+    """Compute slack and reserve quantities.
+
+    Cost-term conventions (must match the LP objective in flextool.mod):
+
+    * **Per-timestep slack terms** (node state, inertia, non-sync, reserve)
+      are cost amounts held across each step.  The mod multiplies them by
+      ``step_duration[d, t] * p_rp_cost_weight[d, t] *
+      p_inflation_factor_operations_yearly[d] /
+      complete_period_share_of_year[d] * pdt_branch_weight[d, t]``.  Here
+      we store the *per-(d, t)* contribution with ``step_duration`` and
+      ``timestep_weight`` already baked in (so it can still be totalled
+      per-step by ``costs__dt.csv``).  The remaining period-level factors
+      (``inflation`` and ``/ period_share``) are applied at
+      ``calc_costs.costPenalty_d`` where ``costPenalty_dt`` is aggregated.
+
+    * **Capacity-margin slack** is a per-period decision (no timestep
+      dimension).  The mod term is
+      ``vq * group_capacity_for_scaling * penalty_capacity_margin * 1000 *
+      p_inflation_factor_operations_yearly``.  No step_duration, no
+      timestep_weight, no period_share division (it is already a per-period
+      quantity).
+    """
+    # Per-step scaling factor for all per-(d, t) cost terms:
+    # step_duration × timestep_weight.  Combined once for readability.
+    step_x_rp = par.step_duration.mul(par.timestep_weight, axis=0)
+
+    r.reserves_dt = v.reserve.mul(par.step_duration, axis=0)
+    # Average MW held over the period: Σ(MW × step_duration) / total period hours.
+    # Reserves are MW capacity held per hour (not consumed energy), so the
+    # meaningful per-period figure is the average MW held across the period.
+    period_hours = par.complete_period_share_of_year * 8760
+    r.reserves_d = r.reserves_dt.groupby('period').sum().div(period_hours, axis=0)
+
+    # upward_node_slack_dt is already MWh per step (q_state_up × capacity × step_duration),
+    # so the period aggregate is a plain groupby-sum; no extra step_duration.
+    # node_capacity_for_scaling / node_penalty_* are complete over
+    # nodeBalance ∪ nodeBalancePeriod (⊇ the q_state nodes) and solve-keyed
+    # (concat-unioned), so direct column
+    # indexing is safe — no missing-column densify needed here.
+    # The annualised ``_d`` reporting series weights each (d, t) by
+    # par.timestep_weight (=1.0 with no/uniform timeset_weights →
+    # byte-identical) before the period sum, matching the cost-weighted
+    # objective.  The ``_not_annualized`` diagnostic sums (used for the raw
+    # Created/Removed slack-event reports) stay unweighted.
+    r.upward_node_slack_dt = v.q_state_up.mul(par.node_capacity_for_scaling[v.q_state_up.columns]).mul(par.step_duration, axis=0)
+    r.upward_node_slack_d_not_annualized = r.upward_node_slack_dt.groupby('period').sum()
+    r.upward_node_slack_d = annualize_dt_to_d(r.upward_node_slack_dt, par.timestep_weight, par.complete_period_share_of_year)
+    r.downward_node_slack_dt = v.q_state_down.mul(par.node_capacity_for_scaling[v.q_state_down.columns]).mul(par.step_duration, axis=0)
+    r.downward_node_slack_d_not_annualized = r.downward_node_slack_dt.groupby('period').sum()
+    r.downward_node_slack_d = annualize_dt_to_d(r.downward_node_slack_dt, par.timestep_weight, par.complete_period_share_of_year)
+    # Node-state slack penalty: apply timestep_weight (step_duration already in _slack_dt).
+    upward_node_penalty = r.upward_node_slack_dt.mul(par.node_penalty_up[v.q_state_up.columns]) \
+                                               .mul(par.timestep_weight, axis=0)
+    downward_node_penalty = r.downward_node_slack_dt.mul(par.node_penalty_down[v.q_state_down.columns]) \
+                                                   .mul(par.timestep_weight, axis=0)
+    r.costPenalty_node_state_upDown_dt = pd.concat([upward_node_penalty, downward_node_penalty], axis=1, keys=['up', 'down'], names=['upDown'])
+    r.costPenalty_node_state_upDown_dt = r.costPenalty_node_state_upDown_dt.reorder_levels([1, 0], axis=1)
+    r.costPenalty_node_state_upDown_d = r.costPenalty_node_state_upDown_dt.groupby(level='period').sum()
+
+    # Inertia penalty: mod uses × step_duration × timestep_weight (objective line ~2380).
+    # Per-step cost = q × inertia_limit × penalty × step_duration × timestep_weight.
+    r.q_inertia_dt = v.q_inertia.mul(par.group_inertia_limit)
+    r.q_inertia_d_not_annualized = r.q_inertia_dt.mul(par.step_duration, axis=0).groupby('period').sum()
+    r.q_inertia_d = annualize_dt_to_d(r.q_inertia_dt, par.timestep_weight, par.complete_period_share_of_year, par.step_duration)
+    r.costPenalty_inertia_dt = r.q_inertia_dt.mul(par.group_penalty_inertia).mul(step_x_rp, axis=0)
+
+    # Non-synchronous penalty: mod uses × step_duration × timestep_weight (objective line ~2382).
+    r.q_non_synchronous_dt = v.q_non_synchronous.mul(par.group_capacity_for_scaling[s.groupNonSync])
+    r.q_non_synchronous_d_not_annualized = r.q_non_synchronous_dt.mul(par.step_duration, axis=0) \
+        .groupby('period').sum()
+    r.q_non_synchronous_d = annualize_dt_to_d(
+        r.q_non_synchronous_dt, par.timestep_weight,
+        par.complete_period_share_of_year, par.step_duration)
+    r.costPenalty_non_synchronous_dt = r.q_non_synchronous_dt \
+        .mul(par.group_penalty_non_synchronous) \
+        .mul(step_x_rp, axis=0)
+
+    # Capacity-margin penalty: per-period event; no step_duration, no rp_weight.
+    # Mod (~line 2414-2417): vq × group_capacity × penalty × 1000 × inflation.
+    # Penalty is expressed per kW in the template; the ×1000 converts to /MW.
+    r.q_capacity_margin_d_not_annualized = v.q_capacity_margin \
+        .mul(par.group_capacity_for_scaling[s.groupCapacityMargin])
+    r.costPenalty_capacity_margin_d = r.q_capacity_margin_d_not_annualized \
+        .mul(par.group_penalty_capacity_margin[s.groupCapacityMargin]) \
+        .mul(1000.0) \
+        .mul(par.inflation_factor_operations_yearly, axis=0) \
+        .sum(axis=1)
+
+    r.q_reserves_dt = v.q_reserve.mul(par.reserve_upDown_group_reservation[v.q_reserve.columns], axis=1)
+    r.q_reserves_d_not_annualized = r.q_reserves_dt.mul(par.step_duration, axis=0).groupby(level='period').sum()
+    r.q_reserves_d = annualize_dt_to_d(r.q_reserves_dt, par.timestep_weight, par.complete_period_share_of_year, par.step_duration)
+    # Reserve slack penalty: step_duration is already here (line below);
+    # add timestep_weight to match mod line ~2388.
+    r.costPenalty_reserve_upDown_dt = v.q_reserve.mul(par.step_duration, axis=0) \
+        .mul(par.timestep_weight, axis=0) \
+        .mul(par.reserve_upDown_group_penalty, axis=1) \
+        .mul(par.reserve_upDown_group_reservation, axis=1)

flextool/process_outputs/calc_storage_vre.py

@@ -0,0 +1,160 @@
+import pandas as pd
+
+from flextool.process_outputs._annualize import annualize_dt_to_d
+
+
+def compute_storage_and_vre(par, s, v, r) -> None:
+    """Compute storage state changes, self-discharge, node inflow, VRE potential, and storage usage."""
+    step_duration = par.step_duration
+    unitsize = par.entity_unitsize
+
+    # node_state_change_dt (four storage binding methods)
+    current_idx = s.dtt.droplevel('t_previous')
+    prev_period_idx = (
+        s.dtttdt
+        .droplevel(['time', 't_previous_within_timeset', 'd_previous', 't_previous_within_solve'])
+        .set_names(['period', 'time'])
+    )
+    prev_timeset_idx = (
+        s.dtttdt
+        .droplevel(['time', 't_previous', 'd_previous', 't_previous_within_solve'])
+        .set_names(['period', 'time'])
+    )
+    prev_forward_only_idx = (
+        s.dtttdt
+        .droplevel(['period', 'time', 't_previous', 't_previous_within_timeset'])
+        .set_names(['period', 'time'])
+    )
+    exclude_idx = s.period__time_first[
+        s.period__time_first.get_level_values('period').isin(s.period_first_of_solve)
+    ]
+
+    r_state_change = pd.DataFrame(0.0, index=s.dt_realize_dispatch, columns=s.node_state, dtype=float)
+    for n in s.node_state:
+        if n not in v.state.columns:
+            continue
+
+        state_change = pd.Series(0.0, index=current_idx)
+        # ``v.state[n]`` is keyed by every (period, time) that appears in
+        # any sub-solve's parquet (after the drop_levels dedup), whereas
+        # ``current_idx`` is filtered to ``dt_realize_dispatch``.  Align
+        # v_current to current_idx so the arithmetic below has the same
+        # shape as ``mask`` — otherwise pandas raises
+        # "Array conditional must be same shape as self" on rolling /
+        # nested-multi-invest scenarios.
+        v_current = pd.Series(v.state[n].squeeze().reindex(current_idx).values, index=current_idx)
+        v_prev_period = pd.Series(v.state[n].squeeze().reindex(prev_period_idx).values, index=current_idx)
+        v_prev_timeblock = pd.Series(v.state[n].squeeze().reindex(prev_timeset_idx).values, index=current_idx)
+        v_forward = pd.Series(v.state[n].squeeze().reindex(prev_forward_only_idx).values, index=current_idx)
+
+        # After the single-valued migration (v54), each node appears in
+        # ``s.node__storage_binding_method`` with exactly one method string,
+        # so at most one of these branches fires per node.  Pre-v54 DBs
+        # with array-valued methods were rejected at ingestion
+        # (spinedb_backend/_backend.py).  The four if-blocks are left as
+        # independent membership checks for readability; their additive
+        # form is functionally equivalent to a switch under single-valued
+        # semantics.
+        if (n, 'bind_forward_only') in s.node__storage_binding_method:
+            mask = ~current_idx.isin(exclude_idx)
+            state_change += ((v_current - v_forward) * unitsize[n]).where(mask, 0)
+
+        if (n, 'bind_within_solve') in s.node__storage_binding_method:
+            state_change += (v_current - v_forward) * unitsize[n]
+
+        if (n, 'bind_within_period') in s.node__storage_binding_method:
+            state_change += (v_current - v_prev_period) * unitsize[n]
+
+        if (n, 'bind_within_timeblock') in s.node__storage_binding_method:
+            state_change += (v_current - v_prev_timeblock) * unitsize[n]
+
+        r_state_change[n] = state_change
+
+    r.node_state_change_dt = r_state_change
+    r.node_state_change_d = r.node_state_change_dt.groupby(level='period').sum()
+
+    # self_discharge_loss
+    # par.node_self_discharge_loss broadcasts the authored
+    # ``state_self_discharge`` param across every node that carries it,
+    # including supply-curve / commodity nodes that have no ``v_state``
+    # LP variable.  Self-discharge is only meaningful on storage nodes,
+    # so restrict to the intersection with ``v.state.columns`` before
+    # multiplying — otherwise pandas raises ``KeyError: None of [...] are
+    # in the [columns]`` on real scenarios with non-storage authored
+    # values.
+    #
+    # In rolling / multi-solve scenarios ``par.node_self_discharge_loss``
+    # is built from the last sub-solve's ``flex_data.dt`` only, whereas
+    # ``v.state`` is concatenated across every sub-solve's parquet.
+    # Their (period, time) row indices then differ, and pandas raises
+    # ``TypeError: Join on level between two MultiIndex objects is
+    # ambiguous`` on the broadcast-multiply.  The underlying
+    # ``p_state_self_discharge`` is dimensioned ``(n,)`` (one constant
+    # value per node — see ``read_parameters.py``), so collapse the
+    # per-(d, t) repeats to a per-node Series before broadcasting; the
+    # mul then aligns the Series's ``node`` axis against
+    # ``v.state.columns`` regardless of row index.
+    loss_cols = par.node_self_discharge_loss.columns.intersection(
+        v.state.columns
+    )
+    if len(loss_cols) > 0:
+        per_node_loss = par.node_self_discharge_loss[loss_cols].iloc[0]
+        r.self_discharge_loss_dt = (
+            v.state[loss_cols]
+            .mul(per_node_loss, axis='columns')
+            .mul(unitsize[loss_cols], axis='columns', level=0)
+        )
+    else:
+        r.self_discharge_loss_dt = pd.DataFrame(
+            0.0, index=v.state.index, columns=[],
+        )
+    r.self_discharge_loss_d = r.self_discharge_loss_dt.mul(step_duration, axis=0).groupby('period').sum()
+
+    # node_inflow_d — weight each (d, t) by par.timestep_weight (=1.0 with
+    # no/uniform timeset_weights → byte-identical) before the period sum,
+    # matching the cost-weighted annualisation.  par.node_inflow is already
+    # MWh/step, so no step_duration.
+    r.node_inflow_d = annualize_dt_to_d(par.node_inflow, par.timestep_weight, par.complete_period_share_of_year)
+
+    # potentialVREgen
+    vre_with_sink = s.process_VRE[s.process_VRE.isin(s.process_sink)]
+    vre_node_profile = vre_with_sink.join(s.process__node__profile__profile_method)
+    vre_node_profile_upper = vre_node_profile[
+        vre_node_profile.get_level_values('profile_method').isin(['upper_limit'])
+    ]
+    vre_profiles_in_use = par.profile[vre_node_profile_upper.get_level_values('profile').unique()]
+    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
+    r.potentialVREgen_dt = (
+        vre_processes_in_use
+        .mul(par.process_availability)
+        .mul(r.entity_all_capacity, axis=1, level=0)
+        .droplevel(axis=1, level=['profile', 'profile_method'])
+    )
+    # 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 = (
+        r.potentialVREgen_dt.mul(step_duration, axis=0).groupby('period').sum()
+    )
+
+    # storage_usage_dt (for nested model storage fixing)
+    dt_fix_idx = s.dt_fix_storage_timesteps
+    r_storage_usage = {}
+    for n in s.node:
+        if (n, 'fix_usage') in s.node__storage_nested_fix_method:
+            usage = pd.Series(0.0, index=dt_fix_idx)
+            for col in r.flow_dt.columns:
+                p, source, sink = col
+                if source == n:
+                    usage += (r.flow_dt[col].reindex(dt_fix_idx, fill_value=0) *
+                              par.step_duration.reindex(dt_fix_idx, fill_value=0))
+                if sink == n:
+                    usage -= (r.flow_dt[col].reindex(dt_fix_idx, fill_value=0) *
+                              par.step_duration.reindex(dt_fix_idx, fill_value=0))
+            r_storage_usage[n] = usage
+    r.storage_usage_dt = (
+        pd.DataFrame(r_storage_usage, dtype=float)
+        if r_storage_usage
+        else pd.DataFrame(0.0, index=dt_fix_idx, columns=[])
+    )