NodeData.hpp

Go to the documentation of this file.

 
#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;
 
    // -----------------------------------------------------------------------
    // 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;
 
    // -----------------------------------------------------------------------
    // 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>     lid_drain_qual_load;

    std::vector<double>     lid_drain_qual_vol;
 
    // -----------------------------------------------------------------------
    // 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_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);
 
        // 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);
        qual_mass_in.clear();
        iface_qual_mass.clear();
        qual_vol_in.assign(un, 0.0);
        lid_drain_qual_load.clear();
        lid_drain_qual_vol.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_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);
        // 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);
        qual_vol_in.resize(un, 0.0);
        lid_drain_qual_vol.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_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 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);
 
        // 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(qual_vol_in); e(lid_drain_qual_vol);
        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_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(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);
            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();
 
        // 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();
        qual_mass_in.shrink_to_fit();
        iface_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_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 are NOT cleared by clearInflowSources
        // (coupling_volume is the carry-across-steps field — its end-of-step value
        // 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);
        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(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 */