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>
 
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<bool>       outfall_has_flap_gate;
 
    // -----------------------------------------------------------------------
    // 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>     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;
 
    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;
 
    // -----------------------------------------------------------------------
    // 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_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_outfall_max_flow;
 
    std::vector<long>       stat_outfall_periods;
 
    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, false);
 
        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);
        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);
        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);
 
        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_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_outfall_avg_flow.assign(un, 0.0);
        stat_outfall_max_flow.assign(un, 0.0);
        stat_outfall_periods.assign(un, 0);
    }
 
    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 save_state() noexcept {
        old_depth    = depth;
        old_volume   = volume;
        old_lat_flow = lat_flow;
        // 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 reset_state() noexcept {
        const auto n = depth.size();
        std::fill(depth.begin(),    depth.end(),    0.0);
        std::fill(head.begin(),     head.end(),     0.0);
        std::fill(volume.begin(),   volume.end(),   0.0);
        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_depth.begin(),    old_depth.end(),    0.0);
        std::fill(old_volume.begin(),   old_volume.end(),   0.0);
        std::fill(old_lat_flow.begin(), old_lat_flow.end(), 0.0);
        (void)n;
    }
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_NODE_DATA_HPP */