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
};
 
// ============================================================================
// 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;
 
    // -----------------------------------------------------------------------
    // Outfall-specific properties (valid when type[i] == OUTFALL)
    // -----------------------------------------------------------------------
 
    std::vector<OutfallType> outfall_type;
 
    std::vector<double>     outfall_param;
 
    std::vector<uint8_t>    outfall_has_flap_gate;
 
    std::vector<int>        outfall_route_to;
 
    std::vector<int>        outfall_link_idx;
 
    std::vector<double>     outfall_link_offset;
 
    std::vector<double>     outfall_2d_head;
 
    // -----------------------------------------------------------------------
    // Storage-specific properties (valid when type[i] == STORAGE)
    // -----------------------------------------------------------------------
 
    std::vector<int>        storage_curve;
 
    std::vector<std::string> storage_curve_name;
 
    std::vector<double>     storage_a;
    std::vector<double>     storage_b;
    std::vector<double>     storage_c;
 
    std::vector<double>     storage_seep_rate;
 
    std::vector<double>     storage_evap_frac;
 
    std::vector<double>     storage_evap_loss;
 
    std::vector<double>     storage_exfil_loss;
 
    std::vector<double>     exfil_suction;
    std::vector<double>     exfil_ksat;
    std::vector<double>     exfil_imd;
 
    // -----------------------------------------------------------------------
    // Divider-specific properties (valid when type[i] == DIVIDER)
    // -----------------------------------------------------------------------
 
    std::vector<DividerType> divider_type;
 
    std::vector<double>     divider_cutoff;
 
    std::vector<double>     divider_cd;
 
    std::vector<double>     divider_max_depth;
 
    std::vector<int>        divider_curve;
 
    std::vector<int>        divider_link;
 
    std::vector<std::string> divider_link_name;
 
    std::vector<std::string> divider_curve_name;
 
    // -----------------------------------------------------------------------
    // 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;
 
    // -----------------------------------------------------------------------
    // 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>     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;
 
    // -----------------------------------------------------------------------
    // 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_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);
 
        outfall_type.assign(un, OutfallType::FREE);
        outfall_param.assign(un, 0.0);
        outfall_has_flap_gate.assign(un, 0);
        outfall_route_to.assign(un, -1);
        outfall_link_idx.assign(un, -1);
        outfall_link_offset.assign(un, 0.0);
        outfall_2d_head.assign(un, -1.0e30);
 
        storage_curve.assign(un, -1);
        storage_curve_name.resize(un);
        storage_a.assign(un, 0.0);
        storage_b.assign(un, 0.0);
        storage_c.assign(un, 0.0);
        storage_seep_rate.assign(un, 0.0);
        storage_evap_frac.assign(un, 0.0);
        storage_evap_loss.assign(un, 0.0);
        storage_exfil_loss.assign(un, 0.0);
        exfil_suction.assign(un, 0.0);
        exfil_ksat.assign(un, 0.0);
        exfil_imd.assign(un, 0.0);
 
        divider_type.assign(un, DividerType::CUTOFF);
        divider_cutoff.assign(un, 0.0);
        divider_cd.assign(un, 0.0);
        divider_max_depth.assign(un, 0.0);
        divider_curve.assign(un, -1);
        divider_link.assign(un, -1);
        divider_link_name.resize(un);
        divider_curve_name.resize(un);
 
        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);
        qual_mass_in.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);
 
        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_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);
        g(outfall_type, OutfallType::FREE); g(outfall_param, 0.0);
        g(outfall_has_flap_gate, uint8_t{0}); g(outfall_route_to, -1);
        g(outfall_link_idx, -1); g(outfall_link_offset, 0.0);
        g(outfall_2d_head, -1.0e30);
        g(storage_curve, -1); storage_curve_name.resize(un);
        g(storage_a, 0.0); g(storage_b, 0.0); g(storage_c, 0.0);
        g(storage_seep_rate, 0.0); g(storage_evap_frac, 0.0);
        g(storage_evap_loss, 0.0); g(storage_exfil_loss, 0.0);
        g(exfil_suction, 0.0); g(exfil_ksat, 0.0); g(exfil_imd, 0.0);
        g(divider_type, DividerType::CUTOFF); g(divider_cutoff, 0.0);
        g(divider_cd, 0.0); g(divider_max_depth, 0.0);
        g(divider_curve, -1); g(divider_link, -1);
        divider_link_name.resize(un); divider_curve_name.resize(un);
        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);
        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);
        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_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);
 
        e(outfall_type); e(outfall_param); e(outfall_has_flap_gate);
        e(outfall_route_to); e(outfall_link_idx); e(outfall_link_offset);
        e(outfall_2d_head);
 
        e(storage_curve); e(storage_curve_name);
        e(storage_a); e(storage_b); e(storage_c);
        e(storage_seep_rate); e(storage_evap_frac); e(storage_evap_loss); e(storage_exfil_loss);
        e(exfil_suction); e(exfil_ksat); e(exfil_imd);
 
        e(divider_type); e(divider_cutoff); e(divider_cd); e(divider_max_depth);
        e(divider_curve); e(divider_link); e(divider_link_name); e(divider_curve_name);
 
        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(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(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_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(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);
            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();
 
        outfall_type.shrink_to_fit();
        outfall_param.shrink_to_fit();
        outfall_has_flap_gate.shrink_to_fit();
        outfall_route_to.shrink_to_fit();
        outfall_link_idx.shrink_to_fit();
        outfall_link_offset.shrink_to_fit();
        outfall_2d_head.shrink_to_fit();
 
        storage_curve.shrink_to_fit();
        storage_curve_name.shrink_to_fit();
        storage_a.shrink_to_fit();
        storage_b.shrink_to_fit();
        storage_c.shrink_to_fit();
        storage_seep_rate.shrink_to_fit();
        storage_evap_frac.shrink_to_fit();
        storage_evap_loss.shrink_to_fit();
        storage_exfil_loss.shrink_to_fit();
        exfil_suction.shrink_to_fit();
        exfil_ksat.shrink_to_fit();
        exfil_imd.shrink_to_fit();
 
        divider_type.shrink_to_fit();
        divider_cutoff.shrink_to_fit();
        divider_cd.shrink_to_fit();
        divider_max_depth.shrink_to_fit();
        divider_curve.shrink_to_fit();
        divider_link.shrink_to_fit();
        divider_link_name.shrink_to_fit();
        divider_curve_name.shrink_to_fit();
 
        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();
        qual_mass_in.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();
 
        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());
        // 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);
        // coupling_inflow is NOT cleared by clearInflowSources (its end-of-
        // step value must persist into the next step's assembly), so zero it
        // explicitly on cold start.
        std::fill(coupling_inflow.begin(), coupling_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(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 */