flextool 4.0.0__py3-none-any.whl

flextool/process_outputs/calc_capacity_flows.py

@@ -0,0 +1,107 @@
+import pandas as pd
+
+
+def compute_capacity_and_flows(par, s, v, r) -> None:
+    """Compute capacity, process online state, and flow-related quantities."""
+    step_duration = par.step_duration
+    unitsize = par.entity_unitsize
+
+    # hours_in_realized_period
+    hours_in_realized_period = step_duration.groupby(level='period').sum()
+    hours_in_realized_period = hours_in_realized_period.reindex(s.d_realized_period)
+    r.hours_in_realized_period = hours_in_realized_period
+    r.realized_period_share_of_year = hours_in_realized_period / 8760
+
+    s.nb = s.node_balance.union(s.node_balance_period)
+
+    # entity_all_capacity: read directly from model output (existing + cumulative invest - divest)
+    # The model uses edd_invest set to correctly track which investments apply to which periods,
+    # handling both single-solve and multi-solve scenarios.
+    r.entity_all_capacity = par.entity_all_capacity.copy()
+    # Drop solve level from index — downstream code expects (period,) only.
+    # For rolling scenarios, keep only the last solve per period.
+    if r.entity_all_capacity.index.nlevels > 1:
+        r.entity_all_capacity = r.entity_all_capacity.droplevel('solve')
+        r.entity_all_capacity = r.entity_all_capacity[~r.entity_all_capacity.index.duplicated(keep='last')]
+    r.entity_all_capacity.columns.name = 'process'  # Required for level=0 matching in VRE calculations
+
+    # process_online_dt
+    r.process_online_dt = v.online_linear.add(v.online_integer, fill_value=0)
+
+    # flow_dt: applies unit-size scaling and slope/section transformations
+    s.process_source_sink_alwaysProcess = s.process_method_sources_sinks.droplevel(['method', 'orig_source', 'orig_sink'])
+    s.process_source_sink_alwaysProcess.names = ['process', 'source', 'sink']
+
+    r.flow_dt = pd.DataFrame(
+        index=s.dt_realize_dispatch,
+        columns=s.process_source_sink_alwaysProcess,
+        dtype=float
+    )
+    slope = par.process_slope
+    section = par.process_section
+
+    for row in s.process_method_sources_sinks:
+        p = row[0]
+        method = row[1]
+        orig_source, orig_sink = row[2], row[3]
+        always_source, always_sink = row[4], row[5]
+
+        flow_val = v.flow[[(p, orig_source, orig_sink)]] * unitsize[p]
+
+        # method_2way_1var_off arcs carry a single signed flow
+        # ``v_flow - v_flow_back``: the forward variable ``v_flow >= 0``
+        # plus a non-negative reverse auxiliary ``v_flow_back``.  Subtract
+        # the back auxiliary so the reported flow is the true signed net
+        # (negative = sink->source), matching the engine's nodeBalance.
+        flow_back = getattr(v, "flow_back", None)
+        if (flow_back is not None and not flow_back.empty
+                and (p, orig_source, orig_sink) in flow_back.columns):
+            # ``flow_back`` shares ``v.flow``'s (solve, period, time) row
+            # index, so its column lines up element-wise with ``flow_val``
+            # (which is ``v.flow[[col]] * unitsize``).  Subtract by raw
+            # values to stay agnostic to row-index level differences.
+            back_vals = (flow_back[(p, orig_source, orig_sink)] * unitsize[p]).values
+            flow_val = flow_val.sub(back_vals, axis=0)
+
+        if (method in s.method_1var_per_way and
+                p not in s.process_profile and
+                orig_source == always_source and orig_sink != always_sink):
+            flow_val = flow_val.mul(slope[p], axis=0)
+            if p in s.process_unit:
+                # FlexData only populates
+                # ``p_process_{sink,source}_conversion_flow_coeff`` when a
+                # non-default value is present (default = 1.0).  Use a safe
+                # lookup so direct-method units without explicit coefficients
+                # (the common case) divide by 1.0 instead of raising
+                # KeyError.
+                sink_coef = par.process_sink_conversion_flow_coeff.get(
+                    (p, orig_sink), 1.0,
+                )
+                src_coef = par.process_source_conversion_flow_coeff.get(
+                    (p, orig_source), 1.0,
+                )
+                flow_val /= (sink_coef * src_coef)
+            if (p, 'min_load_efficiency') in s.process__ct_method:
+                flow_val = flow_val.add(r.process_online_dt[p] * section[p] * unitsize[p], axis=0)
+        r.flow_dt[p, always_source, always_sink] = flow_val
+
+    # ramp_dtt
+    current_idx = s.dtt.droplevel('t_previous')
+    previous_idx = s.dtt.droplevel('time')
+    r.ramp_dtt = pd.DataFrame(
+        r.flow_dt.reindex(current_idx).values - r.flow_dt.reindex(previous_idx).values,
+        index=s.dtt,
+        columns=r.flow_dt.columns,
+        dtype=float
+    )
+
+    # flow_d (with step_duration), process_source_flow_d, process_sink_flow_d
+    r.flow_d = r.flow_dt.mul(step_duration, axis=0).groupby('period').sum()
+    r.process_source_flow_d = (
+        r.flow_d.T.groupby(level=['process', 'source']).sum().T
+        .reindex(columns=s.process_source, fill_value=0.0)
+    )
+    r.process_sink_flow_d = (
+        r.flow_d.T.groupby(level=['process', 'sink']).sum().T
+        .reindex(columns=s.process_sink, fill_value=0.0)
+    )

flextool/process_outputs/calc_connections.py

@@ -0,0 +1,136 @@
+import pandas as pd
+
+from flextool.process_outputs._annualize import annualize_dt_to_d
+
+
+def compute_connection_flows(par, s, v, r) -> None:
+    """Compute connection flow quantities and expose from_conn/to_conn for group aggregations."""
+    step_duration = par.step_duration
+
+    # Identify method_2way_1var connections (single signed flow variable).
+    # These include DC power flow connections (no_losses_no_variable_cost).
+    conn_1var: set[str] = set()
+    for proc, method in s.process_method:
+        if proc in s.process_connection and method == 'method_2way_1var_off':
+            conn_1var.add(proc)
+
+    # Filter to connection processes.
+    # For 2var connections: clip to non-negative (each direction is a separate variable).
+    # For 1var connections: keep sign (positive = left→right, negative = right→left).
+    all_conn_flows = r.flow_dt[
+        r.flow_dt.columns[r.flow_dt.columns.get_level_values('process').isin(s.process_connection)]
+    ]
+    cols_1var = [c for c in all_conn_flows.columns if c[0] in conn_1var]
+    cols_2var = [c for c in all_conn_flows.columns if c[0] not in conn_1var]
+    parts = []
+    if cols_1var:
+        parts.append(all_conn_flows[cols_1var])  # keep sign
+    if cols_2var:
+        parts.append(all_conn_flows[cols_2var].clip(lower=0.0))  # clip
+    if len(parts) > 1:
+        conn_flows = pd.concat(parts, axis=1)
+    elif parts:
+        conn_flows = parts[0]
+    else:
+        # No connections: preserve the 3-level MultiIndex so droplevel() works downstream
+        conn_flows = all_conn_flows  # already empty with correct column names
+
+    # Split into the four directional flows present in one connection.
+    # For 2var: both forward and reverse entries exist in process_source_sink.
+    # For 1var: only one entry exists — left_to_conn and conn_to_right match,
+    #           conn_to_left and right_to_conn are empty. The signed flow value
+    #           naturally gives correct net flow and directional results.
+    conn_to_left = conn_flows[conn_flows.columns[conn_flows.columns.droplevel('source').isin(s.process_source)]]
+    left_to_conn = conn_flows[conn_flows.columns[conn_flows.columns.droplevel('sink').isin(s.process_source)]]
+    conn_to_right = conn_flows[conn_flows.columns[conn_flows.columns.droplevel('source').isin(s.process_sink)]]
+    right_to_conn = conn_flows[conn_flows.columns[conn_flows.columns.droplevel('sink').isin(s.process_sink)]]
+
+    conn_to_left.columns = conn_to_left.columns.droplevel('source')
+    left_to_conn.columns = left_to_conn.columns.droplevel('sink')
+    conn_to_right.columns = conn_to_right.columns.droplevel('source')
+    right_to_conn.columns = right_to_conn.columns.droplevel('sink')
+
+    conn_to_left.columns.names = ['process', 'node']
+    left_to_conn.columns.names = ['process', 'node']
+    conn_to_right.columns.names = ['process', 'node']
+    right_to_conn.columns.names = ['process', 'node']
+
+    r.connection_dt = conn_to_right.droplevel('node', axis=1).sub(
+        conn_to_left.droplevel('node', axis=1), fill_value=0
+    )
+    # Losses = total_out - total_in (negative when energy is lost in connections)
+    r.connection_losses_dt = (
+        conn_to_left.droplevel('node', axis=1)
+        .add(conn_to_right.droplevel('node', axis=1), fill_value=0)
+        .sub(left_to_conn.droplevel('node', axis=1), fill_value=0)
+        .sub(right_to_conn.droplevel('node', axis=1), fill_value=0)
+    )
+    r.connection_to_left_node__dt = conn_to_left.sub(left_to_conn, fill_value=0)
+    r.connection_to_right_node__dt = conn_to_right.sub(right_to_conn, fill_value=0)
+    # v_flow is MW — multiply by step_duration for MWh, then weight each
+    # (d, t) by par.timestep_weight (=1.0 with no/uniform timeset_weights →
+    # byte-identical) before the period sum and annualisation.
+    r.connection_to_left_node__d = annualize_dt_to_d(
+        r.connection_to_left_node__dt, par.timestep_weight,
+        par.complete_period_share_of_year, step_duration,
+    )
+    r.connection_to_right_node__d = annualize_dt_to_d(
+        r.connection_to_right_node__dt, par.timestep_weight,
+        par.complete_period_share_of_year, step_duration,
+    )
+
+    # Expose combined directional flows for use by calc_group_flows
+    r.from_conn = pd.concat([conn_to_left, conn_to_right], axis=1)  # columns: ['process', 'node']
+    r.to_conn = pd.concat([left_to_conn, right_to_conn], axis=1)    # columns: ['process', 'node']
+
+    # connection_d — weight each (d, t) by par.timestep_weight (=1.0 with
+    # no/uniform timeset_weights → byte-identical) here at the period sum;
+    # the cpsoy annualisation is applied downstream in out_ancillary.
+    r_conn_weighted = r.connection_dt.mul(step_duration, axis=0).mul(par.timestep_weight, axis=0)
+    if not r_conn_weighted.empty:
+        r.connection_d = r_conn_weighted[
+            r_conn_weighted.index.get_level_values('period').isin(s.d_realized_period)
+        ].groupby(level='period').sum()
+    else:
+        r.connection_d = pd.DataFrame(
+            index=s.d_realized_period,
+            columns=pd.Index([], name='process'),
+        )
+
+    # connection_losses_d — weight each (d, t) by par.timestep_weight as above
+    # (cpsoy annualisation applied downstream in out_ancillary).
+    r_conn_losses_weighted = r.connection_losses_dt.mul(step_duration, axis=0).mul(par.timestep_weight, axis=0)
+    if not r_conn_losses_weighted.empty:
+        r.connection_losses_d = r_conn_losses_weighted[
+            r_conn_losses_weighted.index.get_level_values('period').isin(s.d_realized_period)
+        ].groupby(level='period').sum()
+    else:
+        r.connection_losses_d = pd.DataFrame(
+            index=s.d_realized_period,
+            columns=pd.Index([], name='process'),
+        )
+
+    # DC power flow: angle differences per connection
+    if not v.angle.empty and not s.connection_dc_power_flow.empty:
+        angle_diff_cols: dict[str, pd.Series] = {}
+        for conn in s.connection_dc_power_flow:
+            # Find source and sink nodes for this connection from process_source_sink
+            pss_for_conn = s.process_source_sink[
+                s.process_source_sink.get_level_values('process') == conn
+            ]
+            if pss_for_conn.empty:
+                continue
+            source_node = pss_for_conn.get_level_values('source')[0]
+            sink_node = pss_for_conn.get_level_values('sink')[0]
+            if source_node in v.angle.columns and sink_node in v.angle.columns:
+                angle_diff_cols[conn] = v.angle[source_node] - v.angle[sink_node]
+        if angle_diff_cols:
+            r.connection_angle_diff_dt = pd.DataFrame(angle_diff_cols)
+            r.connection_angle_diff_dt.columns.name = 'connection'
+        else:
+            r.connection_angle_diff_dt = pd.DataFrame()
+    else:
+        r.connection_angle_diff_dt = pd.DataFrame()
+
+    # Store angle_dt for output (may be empty)
+    r.angle_dt = v.angle

flextool/process_outputs/calc_costs.py

@@ -0,0 +1,260 @@
+import pandas as pd
+
+from flextool.process_outputs._annualize import annualize_dt_to_d
+
+
+def _agg_period_or_empty(df: pd.DataFrame, realized_periods, period_level: str = 'period') -> pd.DataFrame:
+    """Group-by period sum, or an all-zeros frame when df is empty."""
+    if df.empty:
+        cols = df.columns if hasattr(df, 'columns') else []
+        return pd.DataFrame(0.0, index=realized_periods, columns=cols)
+    return df[df.index.get_level_values(period_level).isin(realized_periods)].groupby(period_level).sum()
+
+
+def compute_costs(par, s, v, r) -> None:
+    """Compute all cost quantities (depends on r.costPenalty_* from compute_slacks).
+
+    Per-timestep cost terms must carry the same step-level scaling set as
+    the LP objective in flextool.mod: ``step_duration * p_rp_cost_weight``.
+    Period-level scaling (``p_inflation_factor_operations_yearly /
+    complete_period_share_of_year``) is applied when aggregating *_dt →
+    *_d below.
+    """
+    # --- Commodity costs ---
+    # In-memory ``commodity_node`` is derived from the FlexData flow_*
+    # frames (covers every (c, n) referenced by an arc, regardless of
+    # whether a price was authored).  ``par.commodity_price`` only
+    # carries columns for commodities with a populated ``p_commodity_price``
+    # entry — so intersect here to avoid KeyError when an arc references
+    # a price-less commodity (e.g. coal_chp where coal has only a
+    # co2_content row).  Legacy behaviour: cost contribution is 0.
+    available_commodities = pd.Index(par.commodity_price.columns).unique()
+    commodity_node = s.commodity_node[
+        s.commodity_node.get_level_values('commodity').isin(available_commodities)
+    ]
+    flow_from_commodity_node = r.flow_dt[r.flow_dt.columns[r.flow_dt.columns.get_level_values(level=1).isin(commodity_node.get_level_values(level=1))]]
+    flow_to_commodity_node = r.flow_dt[r.flow_dt.columns[r.flow_dt.columns.get_level_values(level=2).isin(commodity_node.get_level_values(level=1))]]
+
+    # Per-step scaling factor: step_duration × timestep_weight.  Used by all
+    # per-(d, t) cost terms below to match the objective in flextool.mod.
+    step_x_rp = par.step_duration.mul(par.timestep_weight, axis=0)
+
+    commodity_price = par.commodity_price[commodity_node.get_level_values('commodity').unique()]
+    commodity_price.columns = commodity_price.columns.join(commodity_node)
+    flow_from_commodity_node.columns.names = ['process', 'node', 'sink']
+    flow_from_commodity_node.columns = flow_from_commodity_node.columns.join(commodity_price.columns)
+    flow_from_commodity = flow_from_commodity_node.T.groupby('commodity').sum().T
+    r.cost_commodity_dt = flow_from_commodity.mul(commodity_price).mul(step_x_rp, axis=0)
+    flow_to_commodity_node.columns.names = ['process', 'source', 'node']
+    flow_to_commodity_node.columns = flow_to_commodity_node.columns.join(commodity_price.columns)
+    flow_to_commodity = flow_to_commodity_node.T.groupby('commodity').sum().T
+    r.sales_commodity_dt = flow_to_commodity.mul(commodity_price).mul(step_x_rp, axis=0)
+
+    r.cost_commodity_d = r.cost_commodity_dt.groupby('period').sum()
+    r.sales_commodity_d = r.sales_commodity_dt.groupby('period').sum()
+
+    # --- Per-process commodity (fuel) buy & sales (additive output layer) ---
+    # Attribute fuel cost to the consuming process.  Same dt-price, step_x_rp
+    # scaling and sign convention as the per-commodity totals above; only the
+    # collapse axis differs (process, not commodity).  Build a price frame
+    # whose columns mirror the flow's full column MultiIndex (price selected
+    # by each column's commodity level), then a plain element-wise mul — a
+    # level= broadcast raises NotImplementedError on the non-unique commodity
+    # key.  Summing these over 'process' reproduces r.cost_commodity_dt /
+    # r.sales_commodity_dt exactly (reconciliation invariant).
+    _price_by_commodity = commodity_price.droplevel('node', axis=1)
+    _price_by_commodity = _price_by_commodity.loc[:, ~_price_by_commodity.columns.duplicated()]
+
+    def _per_process_commodity_cost(flow_frame):
+        pf = _price_by_commodity.reindex(
+            columns=flow_frame.columns.get_level_values('commodity'))
+        pf.columns = flow_frame.columns
+        return flow_frame.mul(step_x_rp, axis=0).mul(pf).T.groupby('process').sum().T
+
+    r.cost_commodity_process_dt = _per_process_commodity_cost(flow_from_commodity_node)
+    r.sales_commodity_process_dt = _per_process_commodity_cost(flow_to_commodity_node)
+
+    # --- CO2 emissions ---
+    flow_outof_cols = r.flow_dt.columns.copy()
+    flow_outof_cols.names = ['process', 'node', 'sink']
+    flow_outof_cols = s.process__commodity__node_co2.join(flow_outof_cols)
+    flow_outof_cols = flow_outof_cols[~flow_outof_cols.get_level_values('sink').isna()]
+
+    flow_into_cols = r.flow_dt.columns.copy()
+    flow_into_cols.names = ['process', 'source', 'node']
+    flow_into_cols = s.process__commodity__node_co2.join(flow_into_cols)
+    flow_into_cols = flow_into_cols[~flow_into_cols.get_level_values('source').isna()]
+    flow_into_cols = flow_into_cols.reorder_levels(order=['process', 'commodity', 'source', 'node'])
+
+    flow_outof_node = r.flow_dt[flow_outof_cols.droplevel('commodity')]
+    flow_outof_node.columns.names = ['process', 'node', 'sink']
+    flow_outof_node.columns = flow_outof_node.columns.join(flow_outof_cols)
+
+    flow_into_node = r.flow_dt[flow_into_cols.droplevel('commodity')]
+    flow_into_node.columns.names = ['process', 'source', 'node']
+    flow_into_node.columns = flow_into_node.columns.join(flow_into_cols)
+
+    flow_into_node_grouped = flow_into_node.T.groupby(level=[0, 2, 3]).sum().T
+    flow_outof_node_grouped = flow_outof_node.T.groupby(level=[0, 1, 3]).sum().T
+
+    net_flow = flow_outof_node_grouped.sub(flow_into_node_grouped, fill_value=0)
+    # Emissions are physical MWh, so only step_duration applies here (no
+    # timestep_weight).  timestep_weight is added downstream on the monetary
+    # group_cost_co2_dt to match the objective's CO2-price term
+    # (flextool.mod ~line 2312-2336).
+    net_flow_with_duration = net_flow.mul(par.step_duration, axis=0)
+    r.process_emissions_co2_dt = net_flow_with_duration.mul(par.commodity_co2_content, axis=1, level='commodity')
+
+    cols_df = r.process_emissions_co2_dt.columns.to_frame(index=False)
+    cols_df['type'] = 'unit'
+    cols_df.loc[cols_df['process'].isin(s.process_connection), 'type'] = 'connection'
+    r.process_emissions_co2_dt.columns = pd.MultiIndex.from_frame(
+        cols_df[['type', 'process', 'commodity', 'node']]
+    )
+
+    # Reported annual emissions (tonnes) must match the already-weighted CO2
+    # cap and CO2 cost: weight each (d, t) by par.timestep_weight (=1.0 with
+    # no/uniform timeset_weights → byte-identical) before the period sum.
+    # process_emissions_co2_dt carries step_duration but NOT timestep_weight
+    # (see net_flow_with_duration above), so this is the only weight applied.
+    r.process_emissions_co2_d = annualize_dt_to_d(r.process_emissions_co2_dt, par.timestep_weight, par.complete_period_share_of_year)
+
+    r.emissions_co2_d = r.process_emissions_co2_d.sum(axis=1)
+    r.emissions_co2_dt = r.process_emissions_co2_dt.sum(axis=1)
+
+    # Group CO2
+    s.group_node_co2 = s.group_node[s.group_node.get_level_values('group').isin(s.group_co2_limit.union(s.group_co2_price))]
+    group_process_co2_columns = r.process_emissions_co2_dt.columns.join(s.group_node_co2)
+    r.group_process_emissions_co2_dt = pd.DataFrame(index=r.process_emissions_co2_dt.index, columns=group_process_co2_columns)
+    for col in group_process_co2_columns:
+        r.group_process_emissions_co2_dt[col] = r.process_emissions_co2_dt[col[:4]]
+    r.group_co2_dt = r.group_process_emissions_co2_dt.T.groupby('group').sum().T
+    # Reported annual group emissions (tonnes): weight each (d, t) by
+    # par.timestep_weight (=1.0 with no/uniform timeset_weights →
+    # byte-identical) before the period sum so it matches the CO2 cap/cost.
+    # group_co2_dt derives from process_emissions_co2_dt (step_duration only,
+    # no timestep_weight), so this is the only weight applied.
+    r.group_co2_d = annualize_dt_to_d(r.group_co2_dt, par.timestep_weight, par.complete_period_share_of_year)
+    # Monetary CO2 cost = emissions × price.  Emissions already carry
+    # step_duration; add timestep_weight to match the objective's CO2-price
+    # term (flextool.mod ~line 2312-2336 where it has
+    # step_duration × timestep_weight).  Per-period cost_co2 is then
+    # aggregated from the rp-weighted cost_dt directly (instead of
+    # multiplying the annualized physical emissions by price, which would
+    # drop the per-step rp weighting).
+    r.group_cost_co2_dt = r.group_co2_dt.mul(par.group_co2_price).mul(par.timestep_weight, axis=0)
+    r.group_cost_co2_d = r.group_cost_co2_dt.groupby('period').sum()
+    r.cost_co2_dt = r.group_cost_co2_dt.sum(axis=1)
+    r.cost_co2_d = r.group_cost_co2_d.sum(axis=1)
+
+    # --- Per-process CO2 cost (additive output layer) ---
+    # group_process_emissions_co2_dt replicates per-process emissions once per
+    # priced group the process's node belongs to.  Multiply by the dt group
+    # price (column-aligned to the 'group' level) and timestep_weight, then
+    # groupby('process').sum() — this SUMS the per-group charges over every
+    # priced group the process touches, matching the LP objective and
+    # calc_costs.py:104-127.  Summing over 'process' reproduces r.cost_co2_dt.
+    _co2_cols = r.group_process_emissions_co2_dt.columns
+    _co2_price = par.group_co2_price.reindex(columns=_co2_cols.get_level_values('group'))
+    _co2_price.columns = _co2_cols
+    r.cost_process_co2_dt = (
+        r.group_process_emissions_co2_dt
+        .mul(_co2_price)
+        .mul(par.timestep_weight, axis=0)
+        .T.groupby('process').sum().T
+    )
+
+    # --- Operational costs ---
+    # Mod objective (~line 2347-2376): flow × unitsize × varCost ×
+    # step_duration × timestep_weight × inflation / period_share ×
+    # pdt_branch_weight.
+    #
+    # The mod splits the ``other_operational_cost`` contribution into
+    # three sums keyed by ``pssdt_varCost_noEff``,
+    # ``pssdt_varCost_eff_unit_source``/``_sink``, and
+    # ``_eff_connection``.  For ``min_load_efficiency`` processes the
+    # source-side sum also contains a ``section × online × unitsize``
+    # term (flextool.mod line 2358-2364).  In Python this term is
+    # folded into ``r.flow_dt`` on the source-side (p, source, p)
+    # tuple by ``calc_capacity_flows.compute_capacity_and_flows``
+    # (line 58-59): ``flow_val.add(online × section × unitsize)`` when
+    # the process uses ``min_load_efficiency``.  Multiplying that
+    # pre-aggregated source-side flow by the per-(p, source, sink)
+    # varCost here therefore reproduces both the slope and the section
+    # contributions in a single matmul, matching the objective.  See
+    # ``test_cost_aggregation_semantics.TestMinLoadEfficiencySectionTerm``
+    # for the regression guard.
+    relevant_flows = r.flow_dt.loc[:, r.flow_dt.columns.intersection(par.process_source_sink_varCost.columns)]
+    cost_flows = relevant_flows.mul(step_x_rp, axis=0).mul(par.process_source_sink_varCost, axis=1)
+    r.cost_process_other_operational_cost_dt = cost_flows.T.groupby(level=0).sum().T.reindex(columns=s.process, fill_value=0.0)
+
+    # --- Startup costs ---
+    # Mod objective (~line 2337-2346): v_startup × startup_cost × unitsize
+    # × timestep_weight × inflation / period_share × pdt_branch_weight.
+    # No step_duration: startup is a per-event (not per-hour) cost.
+    r.process_startup_dt = v.startup_linear.add(v.startup_integer, fill_value=0)
+    r.cost_startup_dt = pd.DataFrame(0.0, index=r.process_startup_dt.index, columns=s.process_online, dtype=float)
+    valid_processes = s.process_online.intersection(r.process_startup_dt.columns).intersection(par.process_startup_cost.columns)
+    if len(valid_processes) > 0:
+        cost = r.process_startup_dt[valid_processes].mul(par.entity_unitsize[valid_processes], axis=1)
+        periods = cost.index.get_level_values('period')
+        period_costs = par.process_startup_cost.loc[periods, valid_processes]
+        period_costs.index = cost.index
+        r.cost_startup_dt[valid_processes] = cost.mul(period_costs).mul(par.timestep_weight, axis=0)
+
+    # --- Investment costs ---
+    r.cost_entity_invest_d = v.invest.mul(par.entity_unitsize[v.invest.columns]).mul(par.entity_annual_discounted)
+    r.cost_entity_divest_d = -v.divest.mul(par.entity_unitsize[v.divest.columns]).mul(par.entity_annual_divest_discounted)
+    # Use p_entity_all_existing (= pre_existing + carry-forward from earlier
+    # solves − divested) to match the mod objective term at
+    # flextool.mod:2395-2398.  Differs from par.entity_pre_existing only for
+    # rolling / nested solves where prior-solve v_invest has aged into
+    # current-solve existing capacity.
+    r.cost_entity_fixed_pre_existing = (par.entity_all_existing * par.entity_fixed_cost).mul(par.inflation_factor_operations_yearly, axis=0)
+    # entity_lifetime_fixed_cost* are densified over _entity_universe and
+    # solve-keyed (concat-unioned), so they cover every v.invest/v.divest
+    # column — direct indexing is safe.
+    r.cost_entity_fixed_invested = (v.invest.mul(par.entity_unitsize[v.invest.columns] * par.entity_lifetime_fixed_cost[v.invest.columns]))
+    r.cost_entity_fixed_divested = -(v.divest.mul(par.entity_unitsize[v.divest.columns] * par.entity_lifetime_fixed_cost_divest[v.divest.columns]))
+
+    # --- Aggregate operational costs (depends on r.costPenalty_* from compute_slacks) ---
+    r.costOper_dt = (r.cost_commodity_dt.sum(axis=1) -
+                     r.sales_commodity_dt.sum(axis=1) +
+                     r.cost_process_other_operational_cost_dt.sum(axis=1) +
+                     r.cost_startup_dt.sum(axis=1) +
+                     r.cost_co2_dt
+                     )
+    r.costPenalty_dt = (r.costPenalty_node_state_upDown_dt.sum(axis=1) +
+                        r.costPenalty_inertia_dt.sum(axis=1) +
+                        r.costPenalty_non_synchronous_dt.sum(axis=1) +
+                        r.costPenalty_reserve_upDown_dt.sum(axis=1))
+
+    r.cost_process_other_operational_cost_d = r.cost_process_other_operational_cost_dt.groupby('period').sum()
+    r.cost_variable_d = r.cost_process_other_operational_cost_d.sum(axis=1)
+
+    r.cost_startup_d = _agg_period_or_empty(r.cost_startup_dt, s.d_realized_period)
+    r.costPenalty_inertia_d = _agg_period_or_empty(r.costPenalty_inertia_dt, s.d_realized_period)
+    r.costPenalty_non_synchronous_d = _agg_period_or_empty(r.costPenalty_non_synchronous_dt, s.d_realized_period)
+    r.costPenalty_reserve_upDown_d = _agg_period_or_empty(r.costPenalty_reserve_upDown_dt, s.d_realized_period)
+
+    r.costOper_d = r.costOper_dt.groupby('period').sum() \
+                                .mul(par.inflation_factor_operations_yearly, axis=0) \
+                                .div(par.complete_period_share_of_year, axis=0)
+    r.costPenalty_d = r.costPenalty_dt.groupby('period').sum() \
+                                .mul(par.inflation_factor_operations_yearly, axis=0) \
+                                .div(par.complete_period_share_of_year, axis=0)
+    r.costPenalty_d = r.costPenalty_d.add(r.costPenalty_capacity_margin_d, fill_value=0)
+    r.costOper_and_penalty_d = r.costOper_d.add(r.costPenalty_d, fill_value=0)
+
+    r.costInvestUnit_d = r.cost_entity_invest_d[[e for e in s.process_unit if e in r.cost_entity_invest_d.columns]].sum(axis=1)
+    r.costDivestUnit_d = r.cost_entity_divest_d[[e for e in s.process_unit if e in r.cost_entity_divest_d.columns]].sum(axis=1)
+    r.costInvestConnection_d = r.cost_entity_invest_d[[e for e in s.process_connection if e in r.cost_entity_invest_d.columns]].sum(axis=1)
+    r.costDivestConnection_d = r.cost_entity_divest_d[[e for e in s.process_connection if e in r.cost_entity_divest_d.columns]].sum(axis=1)
+    r.costInvestState_d = r.cost_entity_invest_d[[e for e in s.node_state if e in r.cost_entity_invest_d.columns]].sum(axis=1)
+    r.costDivestState_d = r.cost_entity_divest_d[[e for e in s.node_state if e in r.cost_entity_divest_d.columns]].sum(axis=1)
+
+    r.costInvest_d = r.costInvestUnit_d + r.costInvestConnection_d + r.costInvestState_d
+    r.costDivest_d = r.costDivestUnit_d + r.costDivestConnection_d + r.costDivestState_d
+    r.costFixedPreExisting_d = r.cost_entity_fixed_pre_existing.sum(axis=1)
+    r.costFixedInvested_d = r.cost_entity_fixed_invested.sum(axis=1)
+    r.costFixedDivested_d = r.cost_entity_fixed_divested.sum(axis=1)