NodeData.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2026 Caleb Buahin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#ifndef OPENSWMM_ENGINE_NODE_DATA_HPP
#define OPENSWMM_ENGINE_NODE_DATA_HPP
 
#include <vector>
#include <cstdint>
#include <string>
#include <algorithm>
 
namespace openswmm {
 
// ============================================================================
// Node type enumeration
// ============================================================================

enum class NodeType : int8_t {
    JUNCTION = 0,
    OUTFALL  = 1,
    DIVIDER  = 2,
    STORAGE  = 3
};

enum class OutfallType : int8_t {
    FREE      = 0,
    NORMAL    = 1,
    FIXED     = 2,
    TIDAL     = 3,
    TIMESERIES = 4
};

enum class DividerType : int8_t {
    CUTOFF         = 0,
    OVERFLOW_DIV   = 1,  
    TABULAR        = 2,
    WEIR           = 3
};

enum class StorageShape : int8_t {
    TABULAR     = 0,  
    FUNCTIONAL  = 1,  
    CYLINDRICAL = 2,  
    CONICAL     = 3,  
    PARABOLOID  = 4,  
    PYRAMIDAL   = 5   
};
 
// ============================================================================
// NodeData — SoA layout
// ============================================================================

struct NodeData {
 
    // -----------------------------------------------------------------------
    // Static properties — set at parse time
    // -----------------------------------------------------------------------

    std::vector<NodeType>   type;

    std::vector<double>     invert_elev;

    std::vector<double>     full_depth;

    std::vector<double>     init_depth;

    std::vector<double>     sur_depth;

    std::vector<double>     ponded_area;

    std::vector<uint8_t>    is_virtual;

    std::vector<uint8_t>    is_inlet;

    std::vector<double>     rim_depth;
 
    // -----------------------------------------------------------------------
    // Node subtype properties (storage / outfall / divider)
    // -----------------------------------------------------------------------
    // Relational node refactor (Phase 4): the wide per-node storage_* / outfall_*
    // / divider_* / exfil_* arrays that used to live here have been REMOVED. They
    // now live in the dense relational side-tables (StorageData / OutfallData /
    // DividerData in NodeSubtypes.hpp), sized to the count of each subtype and
    // joined to base nodes by node_idx — the memory win of the refactor. Only the
    // base `type[i]` discriminator remains on NodeData. See
    // docs/relational/RELATIONAL_NODE_REFACTOR_PLAN.md.
 
    // -----------------------------------------------------------------------
    // State variables — updated each timestep
    // -----------------------------------------------------------------------

    std::vector<double>     depth;

    std::vector<double>     head;

    std::vector<double>     volume;

    std::vector<double>     lat_flow;

    std::vector<double>     user_lat_flow;
 
    // -----------------------------------------------------------------------
    // Decomposed lateral inflow sources
    // Each source process writes to its own buffer.
    // assembleLateralInflows() sums them all into lat_flow.
    // -----------------------------------------------------------------------

    std::vector<double>     runoff_inflow;

    std::vector<double>     gw_inflow;

    std::vector<double>     ext_inflow;

    std::vector<double>     dwf_inflow;

    std::vector<double>     rdii_inflow;

    std::vector<double>     iface_inflow;

    std::vector<double>     coupling_inflow;

    std::vector<double>     coupling_volume;

    std::vector<double>     coupling_queue;

    std::vector<double>     coupling_qual_queue;
    std::vector<double>     coupling_qual_inflow;

    std::vector<double>     coupling_age_vol_queue;
    std::vector<double>     coupling_temp_vol_queue;
    std::vector<double>     coupling_age_vol_inflow;
    std::vector<double>     coupling_temp_vol_inflow;
    bool coupling_tuple_age  = false;  
    bool coupling_tuple_temp = false;
 
    // -----------------------------------------------------------------------
    // Quality mass inflow assembly arrays
    // assembleQualityInflows() writes these; mixAtNodes() reads them.
    // -----------------------------------------------------------------------

    std::vector<double>     qual_mass_in;

    std::vector<double>     qual_vol_in;

    std::vector<double>     iface_qual_mass;

    std::vector<double>     ext_qual_mass;

    std::vector<double>     dwf_qual_mass;

    std::vector<double>     lid_drain_qual_load;

    std::vector<double>     lid_drain_qual_vol;
    std::vector<double>     lid_drain_inflow;
 
    // -----------------------------------------------------------------------
    // Per-node quality state — flat 2D: [node * n_pollutants + pollutant]
    // -----------------------------------------------------------------------

    std::vector<double>     conc;

    std::vector<double>     conc_old;

    std::vector<double>     hrt;

    std::vector<double>     user_conc_mass_flux;

    int                     conc_n_pollutants = 0;

    std::vector<double>     inflow;

    std::vector<double>     outflow;

    std::vector<double>     overflow;

    std::vector<double>     losses;

    std::vector<double>     crown_elev;

    std::vector<int>        degree;

    std::vector<double>     old_net_inflow;

    std::vector<double>     full_volume;
 
    // -----------------------------------------------------------------------
    // Previous-step state (for output interpolation / CFL checks)
    // -----------------------------------------------------------------------

    std::vector<double>     old_depth;

    std::vector<double>     old_volume;

    std::vector<double>     old_lat_flow;

    std::vector<double>     old_inflow;
 
    // -----------------------------------------------------------------------
    // Per-object INP comment
    // -----------------------------------------------------------------------

    std::vector<std::string> comments;

    std::vector<std::string> tags;
 
    // -----------------------------------------------------------------------
    // Report flag — per-object output filter
    // -----------------------------------------------------------------------

    std::vector<char>       rpt_flag;
 
    // -----------------------------------------------------------------------
    // Cumulative statistics
    // -----------------------------------------------------------------------

    std::vector<double>     stat_vol_flooded;

    std::vector<double>     stat_time_flooded;

    std::vector<double>     stat_max_depth;

    std::vector<double>     stat_max_overflow;

    std::vector<double>     stat_max_overflow_date;

    std::vector<double>     stat_sum_depth;

    std::vector<double>     stat_sum_volume;

    std::vector<double>     stat_max_depth_date;

    std::vector<double>     stat_max_rpt_depth;

    std::vector<double>     stat_max_inflow_date;

    std::vector<double>     stat_time_surcharged;

    std::vector<double>     stat_max_surcharge_height;

    std::vector<double>     stat_outfall_avg_flow;

    std::vector<double>     stat_max_lat_inflow;

    std::vector<double>     stat_max_total_inflow;

    std::vector<double>     stat_storage_max_outflow;

    std::vector<double>     stat_lat_inflow_vol;

    std::vector<double>     stat_total_inflow_vol;

    std::vector<double>     stat_total_outflow_vol;

    std::vector<double>     stat_outfall_max_flow;

    std::vector<long>       stat_outfall_periods;

    std::vector<int>        stat_non_converged_count;

    std::vector<double>     stat_time_courant_critical;

    std::vector<double>     stat_total_load;
    int                     stat_n_pollutants = 0;
 
    // -----------------------------------------------------------------------
    // Capacity management
    // -----------------------------------------------------------------------

    int count() const noexcept { return static_cast<int>(type.size()); }

    void resize(int n) {
        const auto un = static_cast<std::size_t>(n);
        type.assign(un, NodeType::JUNCTION);
        invert_elev.assign(un, 0.0);
        full_depth.assign(un, 0.0);
        init_depth.assign(un, 0.0);
        sur_depth.assign(un, 0.0);
        ponded_area.assign(un, 0.0);
        is_virtual.assign(un, 0);
        is_inlet.assign(un, 0);
        rim_depth.assign(un, 0.0);
 
        // Subtype config (storage/outfall/divider) lives in NodeSubtypes side-tables.
        depth.assign(un, 0.0);
        head.assign(un, 0.0);
        volume.assign(un, 0.0);
        lat_flow.assign(un, 0.0);
        user_lat_flow.assign(un, 0.0);
        runoff_inflow.assign(un, 0.0);
        gw_inflow.assign(un, 0.0);
        ext_inflow.assign(un, 0.0);
        dwf_inflow.assign(un, 0.0);
        rdii_inflow.assign(un, 0.0);
        iface_inflow.assign(un, 0.0);
        coupling_inflow.assign(un, 0.0);
        coupling_volume.assign(un, 0.0);
        coupling_queue.assign(un, 0.0);
        coupling_age_vol_queue.assign(un, 0.0);
        coupling_temp_vol_queue.assign(un, 0.0);
        coupling_age_vol_inflow.assign(un, 0.0);
        coupling_temp_vol_inflow.assign(un, 0.0);
        qual_mass_in.clear();
        iface_qual_mass.clear();
        coupling_qual_queue.clear();
        coupling_qual_inflow.clear();
        ext_qual_mass.clear();
        dwf_qual_mass.clear();
        qual_vol_in.assign(un, 0.0);
        lid_drain_qual_load.clear();
        lid_drain_qual_vol.assign(un, 0.0);
        lid_drain_inflow.assign(un, 0.0);
        inflow.assign(un, 0.0);
        outflow.assign(un, 0.0);
        overflow.assign(un, 0.0);
        losses.assign(un, 0.0);
        crown_elev.assign(un, 0.0);
        degree.assign(un, 0);
        old_net_inflow.assign(un, 0.0);
        full_volume.assign(un, 0.0);
        old_depth.assign(un, 0.0);
        old_volume.assign(un, 0.0);
        old_lat_flow.assign(un, 0.0);
        old_inflow.assign(un, 0.0);
 
        comments.assign(un, std::string{});
        tags.assign(un, std::string{});
 
        rpt_flag.assign(un, 0);
 
        stat_vol_flooded.assign(un, 0.0);
        stat_time_flooded.assign(un, 0.0);
        stat_max_depth.assign(un, 0.0);
        stat_max_overflow.assign(un, 0.0);
        stat_max_overflow_date.assign(un, 0.0);
        stat_sum_depth.assign(un, 0.0);
        stat_sum_volume.assign(un, 0.0);
        stat_max_depth_date.assign(un, 0.0);
        stat_max_rpt_depth.assign(un, 0.0);
        stat_max_inflow_date.assign(un, 0.0);
        stat_time_surcharged.assign(un, 0.0);
        stat_max_surcharge_height.assign(un, 0.0);
        stat_max_lat_inflow.assign(un, 0.0);
        stat_max_total_inflow.assign(un, 0.0);
        stat_storage_max_outflow.assign(un, 0.0);
        stat_lat_inflow_vol.assign(un, 0.0);
        stat_total_inflow_vol.assign(un, 0.0);
        stat_total_outflow_vol.assign(un, 0.0);
        stat_outfall_avg_flow.assign(un, 0.0);
        stat_outfall_max_flow.assign(un, 0.0);
        stat_outfall_periods.assign(un, 0);
        stat_non_converged_count.assign(un, 0);
        stat_time_courant_critical.assign(un, 0.0);
    }

    void grow_to(int n) {
        if (n <= count()) return;
        const auto un = static_cast<std::size_t>(n);
        auto g = [&](auto& vec, auto def) { vec.resize(un, def); };
        g(type, NodeType::JUNCTION);
        g(invert_elev, 0.0); g(full_depth, 0.0); g(init_depth, 0.0);
        g(sur_depth, 0.0); g(ponded_area, 0.0);
        g(is_virtual, static_cast<uint8_t>(0));
        g(is_inlet, static_cast<uint8_t>(0));
        g(rim_depth, 0.0);
        // Subtype config (storage/outfall/divider) lives in NodeSubtypes side-tables.
        g(depth, 0.0); g(head, 0.0); g(volume, 0.0);
        g(lat_flow, 0.0); g(user_lat_flow, 0.0);
        g(runoff_inflow, 0.0); g(gw_inflow, 0.0); g(ext_inflow, 0.0);
        g(dwf_inflow, 0.0); g(rdii_inflow, 0.0); g(iface_inflow, 0.0);
        g(coupling_inflow, 0.0); g(coupling_volume, 0.0); g(coupling_queue, 0.0);
        g(coupling_age_vol_queue, 0.0); g(coupling_temp_vol_queue, 0.0);
        g(coupling_age_vol_inflow, 0.0); g(coupling_temp_vol_inflow, 0.0);
        qual_vol_in.resize(un, 0.0);
        lid_drain_qual_vol.resize(un, 0.0);
        lid_drain_inflow.resize(un, 0.0);
        g(inflow, 0.0); g(outflow, 0.0); g(overflow, 0.0);
        g(losses, 0.0); g(crown_elev, 0.0); g(degree, 0);
        g(old_net_inflow, 0.0); g(full_volume, 0.0);
        g(old_depth, 0.0); g(old_volume, 0.0); g(old_lat_flow, 0.0);
        g(old_inflow, 0.0);
        comments.resize(un, std::string{});
        tags.resize(un, std::string{});
 
        g(rpt_flag, static_cast<char>(0));
        g(stat_vol_flooded, 0.0); g(stat_time_flooded, 0.0);
        g(stat_max_depth, 0.0); g(stat_max_overflow, 0.0);
        g(stat_max_overflow_date, 0.0); g(stat_sum_depth, 0.0);
        g(stat_sum_volume, 0.0);
        g(stat_max_depth_date, 0.0); g(stat_max_rpt_depth, 0.0);
        g(stat_max_inflow_date, 0.0); g(stat_time_surcharged, 0.0);
        g(stat_max_surcharge_height, 0.0);
        g(stat_max_lat_inflow, 0.0); g(stat_max_total_inflow, 0.0);
        g(stat_storage_max_outflow, 0.0);
        g(stat_lat_inflow_vol, 0.0); g(stat_total_inflow_vol, 0.0);
        g(stat_total_outflow_vol, 0.0);
        g(stat_outfall_avg_flow, 0.0); g(stat_outfall_max_flow, 0.0);
        g(stat_outfall_periods, 0L);
        g(stat_non_converged_count, 0); g(stat_time_courant_critical, 0.0);
        // Note: qual_mass_in, conc, conc_old, hrt handled by resize_quality()
    }

    void reserve_to(int n) {
        if (n <= 0) return;
        const auto un = static_cast<std::size_t>(n);
        if (type.capacity() >= un) return;
        auto r = [&](auto& vec) { vec.reserve(un); };
        r(type); r(invert_elev); r(full_depth); r(init_depth);
        r(sur_depth); r(ponded_area); r(is_virtual); r(is_inlet); r(rim_depth); r(depth);
        r(head); r(volume); r(lat_flow); r(user_lat_flow);
        r(runoff_inflow); r(gw_inflow); r(ext_inflow); r(dwf_inflow);
        r(rdii_inflow); r(iface_inflow); r(coupling_inflow); r(coupling_volume);
        r(coupling_queue); r(inflow); r(outflow); r(overflow);
        r(coupling_age_vol_queue); r(coupling_temp_vol_queue);
        r(coupling_age_vol_inflow); r(coupling_temp_vol_inflow);
        r(losses); r(crown_elev); r(degree); r(old_net_inflow);
        r(full_volume); r(old_depth); r(old_volume); r(old_lat_flow);
        r(old_inflow); r(rpt_flag); r(stat_vol_flooded); r(stat_time_flooded);
        r(stat_max_depth); r(stat_max_overflow); r(stat_max_overflow_date); r(stat_sum_depth);
        r(stat_sum_volume); r(stat_max_depth_date); r(stat_max_rpt_depth); r(stat_max_inflow_date);
        r(stat_time_surcharged); r(stat_max_surcharge_height); r(stat_max_lat_inflow); r(stat_max_total_inflow);
        r(stat_storage_max_outflow);
        r(stat_lat_inflow_vol); r(stat_total_inflow_vol); r(stat_total_outflow_vol); r(stat_outfall_avg_flow);
        r(stat_outfall_max_flow); r(stat_outfall_periods); r(stat_non_converged_count); r(stat_time_courant_critical);
        r(qual_vol_in); r(lid_drain_qual_vol); r(lid_drain_inflow); r(comments); r(tags);
    }

    void erase_at(int idx) {
        const auto ui = static_cast<std::size_t>(idx);
        auto e = [&](auto& v) { if (ui < v.size()) v.erase(v.begin() + static_cast<std::ptrdiff_t>(idx)); };
 
        e(type); e(invert_elev); e(full_depth); e(init_depth); e(sur_depth); e(ponded_area);
        e(is_virtual); e(is_inlet); e(rim_depth);
 
        // Subtype config (storage/outfall/divider) lives in NodeSubtypes side-tables;
        // its rows are erased/renumbered by NodeSubtypes::erase_node (called by the
        // node-delete path), not here.
        e(depth); e(head); e(volume);
        e(lat_flow); e(user_lat_flow);
        e(runoff_inflow); e(gw_inflow); e(ext_inflow); e(dwf_inflow);
        e(rdii_inflow); e(iface_inflow);
        e(coupling_inflow); e(coupling_volume); e(coupling_queue);
        e(coupling_age_vol_queue); e(coupling_temp_vol_queue);
        e(coupling_age_vol_inflow); e(coupling_temp_vol_inflow);
        e(qual_vol_in); e(lid_drain_qual_vol); e(lid_drain_inflow);
        e(inflow); e(outflow); e(overflow); e(losses);
        e(crown_elev); e(degree); e(old_net_inflow); e(full_volume);
        e(old_depth); e(old_volume); e(old_lat_flow); e(old_inflow);
        e(comments); e(tags); e(rpt_flag);
 
        e(stat_vol_flooded); e(stat_time_flooded); e(stat_max_depth); e(stat_max_overflow);
        e(stat_max_overflow_date); e(stat_sum_depth); e(stat_sum_volume); e(stat_max_depth_date);
        e(stat_max_rpt_depth); e(stat_max_inflow_date); e(stat_time_surcharged);
        e(stat_max_surcharge_height); e(stat_outfall_avg_flow); e(stat_max_lat_inflow);
        e(stat_max_total_inflow); e(stat_storage_max_outflow);
        e(stat_lat_inflow_vol); e(stat_total_inflow_vol);
        e(stat_total_outflow_vol); e(stat_outfall_max_flow); e(stat_outfall_periods);
        e(stat_non_converged_count); e(stat_time_courant_critical);
 
        // Flat 2D quality arrays: [node * np + p] → erase the stride for idx
        if (conc_n_pollutants > 0) {
            const auto np = static_cast<std::size_t>(conc_n_pollutants);
            const auto base = ui * np;
            auto erase2d = [&](auto& v) {
                if (base + np <= v.size())
                    v.erase(v.begin() + static_cast<std::ptrdiff_t>(base),
                            v.begin() + static_cast<std::ptrdiff_t>(base + np));
            };
            erase2d(conc); erase2d(conc_old);
            erase2d(qual_mass_in); erase2d(iface_qual_mass);
            erase2d(coupling_qual_queue); erase2d(coupling_qual_inflow);
            erase2d(ext_qual_mass);
            erase2d(dwf_qual_mass);
            erase2d(lid_drain_qual_load); erase2d(user_conc_mass_flux);
            if (ui < hrt.size()) hrt.erase(hrt.begin() + static_cast<std::ptrdiff_t>(idx));
        }
 
        // Flat 2D stat load: [node * np + p]
        if (stat_n_pollutants > 0) {
            const auto np = static_cast<std::size_t>(stat_n_pollutants);
            const auto base = ui * np;
            if (base + np <= stat_total_load.size())
                stat_total_load.erase(
                    stat_total_load.begin() + static_cast<std::ptrdiff_t>(base),
                    stat_total_load.begin() + static_cast<std::ptrdiff_t>(base + np));
        }
    }

    void resize_loads(int n_pollutants) {
        stat_n_pollutants = n_pollutants;
        if (n_pollutants > 0) {
            auto total = static_cast<std::size_t>(count()) *
                         static_cast<std::size_t>(n_pollutants);
            stat_total_load.assign(total, 0.0);
        }
    }

    void resize_quality(int n_pollutants) {
        conc_n_pollutants = n_pollutants;
        if (n_pollutants > 0) {
            auto total = static_cast<std::size_t>(count()) *
                         static_cast<std::size_t>(n_pollutants);
            conc.assign(total, 0.0);
            conc_old.assign(total, 0.0);
            hrt.assign(static_cast<std::size_t>(count()), 0.0);
            user_conc_mass_flux.assign(total, 0.0);
            qual_mass_in.assign(total, 0.0);
            iface_qual_mass.assign(total, 0.0);
            coupling_qual_queue.assign(total, 0.0);
            coupling_qual_inflow.assign(total, 0.0);
            ext_qual_mass.assign(total, 0.0);
            dwf_qual_mass.assign(total, 0.0);
            lid_drain_qual_load.assign(total, 0.0);
        }
    }

    void shrink_to_fit() {
        type.shrink_to_fit();
        invert_elev.shrink_to_fit();
        full_depth.shrink_to_fit();
        init_depth.shrink_to_fit();
        sur_depth.shrink_to_fit();
        ponded_area.shrink_to_fit();
        is_virtual.shrink_to_fit();
        is_inlet.shrink_to_fit();
        rim_depth.shrink_to_fit();
 
        // Subtype config (storage/outfall/divider) lives in NodeSubtypes side-tables.
        depth.shrink_to_fit();
        head.shrink_to_fit();
        volume.shrink_to_fit();
        lat_flow.shrink_to_fit();
        user_lat_flow.shrink_to_fit();
        runoff_inflow.shrink_to_fit();
        gw_inflow.shrink_to_fit();
        ext_inflow.shrink_to_fit();
        dwf_inflow.shrink_to_fit();
        rdii_inflow.shrink_to_fit();
        iface_inflow.shrink_to_fit();
        coupling_inflow.shrink_to_fit();
        coupling_volume.shrink_to_fit();
        coupling_queue.shrink_to_fit();
        coupling_age_vol_queue.shrink_to_fit(); coupling_temp_vol_queue.shrink_to_fit();
        coupling_age_vol_inflow.shrink_to_fit(); coupling_temp_vol_inflow.shrink_to_fit();
        qual_mass_in.shrink_to_fit();
        iface_qual_mass.shrink_to_fit();
        coupling_qual_queue.shrink_to_fit();
        coupling_qual_inflow.shrink_to_fit();
        ext_qual_mass.shrink_to_fit();
        dwf_qual_mass.shrink_to_fit();
        qual_vol_in.shrink_to_fit();
        conc.shrink_to_fit();
        conc_old.shrink_to_fit();
        user_conc_mass_flux.shrink_to_fit();
        inflow.shrink_to_fit();
        outflow.shrink_to_fit();
        overflow.shrink_to_fit();
        losses.shrink_to_fit();
        crown_elev.shrink_to_fit();
        degree.shrink_to_fit();
        old_net_inflow.shrink_to_fit();
        full_volume.shrink_to_fit();
        old_depth.shrink_to_fit();
        old_volume.shrink_to_fit();
        old_lat_flow.shrink_to_fit();
        old_inflow.shrink_to_fit();
 
        comments.shrink_to_fit();
        tags.shrink_to_fit();
 
        rpt_flag.shrink_to_fit();
 
        stat_vol_flooded.shrink_to_fit();
        stat_time_flooded.shrink_to_fit();
        stat_max_depth.shrink_to_fit();
        stat_max_overflow.shrink_to_fit();
        stat_max_overflow_date.shrink_to_fit();
        stat_sum_depth.shrink_to_fit();
        stat_max_depth_date.shrink_to_fit();
        stat_max_rpt_depth.shrink_to_fit();
        stat_max_inflow_date.shrink_to_fit();
        stat_time_surcharged.shrink_to_fit();
        stat_max_surcharge_height.shrink_to_fit();
        stat_max_lat_inflow.shrink_to_fit();
        stat_max_total_inflow.shrink_to_fit();
        stat_storage_max_outflow.shrink_to_fit();
        stat_lat_inflow_vol.shrink_to_fit();
        stat_total_inflow_vol.shrink_to_fit();
        stat_total_outflow_vol.shrink_to_fit();
        stat_outfall_avg_flow.shrink_to_fit();
        stat_outfall_max_flow.shrink_to_fit();
        stat_outfall_periods.shrink_to_fit();
        stat_total_load.shrink_to_fit();
    }

    void save_state() noexcept {
        std::copy(depth.begin(),    depth.end(),    old_depth.begin());
        std::copy(volume.begin(),   volume.end(),   old_volume.begin());
        std::copy(lat_flow.begin(), lat_flow.end(), old_lat_flow.begin());
        // Legacy node_setOldHydState (node.c:294): oldFlowInflow = inflow
        std::copy(inflow.begin(),   inflow.end(),   old_inflow.begin());
        // Save net inflow for trapezoidal averaging in next step
        for (std::size_t i = 0; i < inflow.size(); ++i) {
            old_net_inflow[i] = inflow[i] - outflow[i];
        }
        std::copy(conc.begin(), conc.end(), conc_old.begin());
    }

    void reset_state() noexcept {
        const auto n = depth.size();
        // Apply initial depths from input (matching legacy node_initState)
        for (std::size_t i = 0; i < n; ++i) {
            depth[i]     = init_depth[i];
            old_depth[i] = init_depth[i];
            head[i]      = invert_elev[i] + init_depth[i];
        }
        // Volumes must be computed from init_depth by caller (needs table data)
        std::fill(volume.begin(),   volume.end(),   0.0);
        std::fill(old_volume.begin(), old_volume.end(), 0.0);
        // Zero flows
        std::fill(lat_flow.begin(), lat_flow.end(), 0.0);
        std::fill(inflow.begin(),   inflow.end(),   0.0);
        std::fill(outflow.begin(),  outflow.end(),  0.0);
        std::fill(overflow.begin(), overflow.end(), 0.0);
        std::fill(losses.begin(),   losses.end(),   0.0);
        std::fill(old_net_inflow.begin(), old_net_inflow.end(), 0.0);
        std::fill(old_lat_flow.begin(), old_lat_flow.end(), 0.0);
        std::fill(old_inflow.begin(), old_inflow.end(), 0.0);
        // coupling_inflow / coupling_volume / coupling_queue are NOT cleared by
        // clearInflowSources (coupling_volume and coupling_queue are the
        // carry-across-steps fields — their end-of-step values must persist into
        // the next step's assembly), so zero them explicitly on cold start.
        std::fill(coupling_inflow.begin(), coupling_inflow.end(), 0.0);
        std::fill(coupling_volume.begin(), coupling_volume.end(), 0.0);
        std::fill(coupling_queue.begin(), coupling_queue.end(), 0.0);
        std::fill(coupling_qual_queue.begin(), coupling_qual_queue.end(), 0.0);
        std::fill(coupling_qual_inflow.begin(), coupling_qual_inflow.end(), 0.0);
        std::fill(coupling_age_vol_queue.begin(),  coupling_age_vol_queue.end(),  0.0);
        std::fill(coupling_temp_vol_queue.begin(), coupling_temp_vol_queue.end(), 0.0);
        std::fill(coupling_age_vol_inflow.begin(),  coupling_age_vol_inflow.end(),  0.0);
        std::fill(coupling_temp_vol_inflow.begin(), coupling_temp_vol_inflow.end(), 0.0);
        clearInflowSources();
        std::fill(conc.begin(), conc.end(), 0.0);
        std::fill(conc_old.begin(), conc_old.end(), 0.0);
        (void)n;
    }

    void clearInflowSources() noexcept {
        // runoff_inflow and gw_inflow: zeroed in stepRunoff() Phase 2
        std::fill(ext_inflow.begin(),    ext_inflow.end(),    0.0);
        std::fill(dwf_inflow.begin(),    dwf_inflow.end(),    0.0);
        std::fill(rdii_inflow.begin(),   rdii_inflow.end(),   0.0);
        std::fill(iface_inflow.begin(),  iface_inflow.end(),  0.0);
        std::fill(iface_qual_mass.begin(), iface_qual_mass.end(), 0.0);
        std::fill(ext_qual_mass.begin(),   ext_qual_mass.end(),   0.0);
        std::fill(dwf_qual_mass.begin(),   dwf_qual_mass.end(),   0.0);
        std::fill(qual_mass_in.begin(),  qual_mass_in.end(),  0.0);
        std::fill(qual_vol_in.begin(),   qual_vol_in.end(),   0.0);
    }
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_NODE_DATA_HPP */