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<double> storage_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<uint8_t> aquifer2d_bed;

    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_qual_load_old;
    std::vector<double> lid_drain_qual_vol_old;
    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;

    std::vector<double> rpt_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_storage_max_volume; 
    std::vector<double> stat_storage_max_volume_date; 

    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);
        storage_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_qual_load_old.clear();
        lid_drain_qual_vol_old.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);
        rpt_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_storage_max_volume_date.assign(un, 0.0);
        stat_storage_max_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(storage_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_qual_vol_old.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(rpt_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_storage_max_volume_date, 0.0);
        g(stat_storage_max_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(storage_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(rpt_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_storage_max_volume_date);
        r(stat_storage_max_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(storage_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(rpt_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_storage_max_volume_date);
        e(stat_storage_max_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();
        storage_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();
        rpt_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 {
        save_hyd_state();
        save_lat_qual_state();
    }

    void save_hyd_state() noexcept {
        std::copy(depth.begin(), depth.end(), old_depth.begin());
        std::copy(volume.begin(), volume.end(), old_volume.begin());
        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];
        }
    }

    void save_lat_qual_state() noexcept {
        std::copy(lat_flow.begin(), lat_flow.end(), old_lat_flow.begin());
        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 */