LinkData.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_LINK_DATA_HPP
#define OPENSWMM_ENGINE_LINK_DATA_HPP
 
#include <vector>
#include <cstdint>
 
namespace openswmm {
 
// ============================================================================
// Link type enumerations
// ============================================================================
 
enum class LinkType : int8_t {
    CONDUIT = 0,
    PUMP    = 1,
    ORIFICE = 2,
    WEIR    = 3,
    OUTLET  = 4
};
 
enum class XsectShape : int16_t {
    CIRCULAR         = 0,
    FILLED_CIRCULAR  = 1,
    RECT_CLOSED      = 2,
    RECT_OPEN        = 3,
    TRAPEZOIDAL      = 4,
    TRIANGULAR       = 5,
    PARABOLIC        = 6,
    POWER            = 7,
    MODBASKETHANDLE  = 8,
    EGGSHAPED        = 9,
    HORSESHOE        = 10,
    GOTHIC           = 11,
    CATENARY         = 12,
    SEMIELLIPTICAL   = 13,
    BASKETHANDLE     = 14,
    SEMICIRCULAR     = 15,
    RECT_TRIANG      = 16,  
    RECT_ROUND       = 17,  
    IRREGULAR        = 18,  
    CUSTOM           = 19,  
    FORCE_MAIN       = 20,  
    STREET_XSECT     = 21,  
    DUMMY            = 22   
};
 
enum class FlowClass : int8_t {
    DRY        = 0,
    UP_DRY     = 1,
    DN_DRY     = 2,
    SUBCRITICAL = 3,
    SUPERCRITICAL = 4,
    UP_CRITICAL = 5,
    DN_CRITICAL = 6
};
 
// ============================================================================
// LinkData — SoA layout
// ============================================================================
 
struct LinkData {
 
    // -----------------------------------------------------------------------
    // Static connectivity — set at parse time
    // -----------------------------------------------------------------------
 
    std::vector<LinkType>   type;
 
    std::vector<int>        node1;
 
    std::vector<int>        node2;
 
    std::vector<double>     offset1;
 
    std::vector<double>     offset2;
 
    std::vector<double>     q0;
 
    std::vector<double>     q_limit;
 
    // -----------------------------------------------------------------------
    // Conduit-specific properties (valid when type[i] == CONDUIT)
    // -----------------------------------------------------------------------
 
    std::vector<XsectShape> xsect_shape;
 
    std::vector<double>     xsect_y_full;
 
    std::vector<double>     xsect_a_full;
 
    std::vector<double>     xsect_w_max;
 
    std::vector<int>        xsect_curve;
 
    std::vector<double>     roughness;
 
    std::vector<double>     length;
 
    std::vector<double>     slope;
 
    std::vector<double>     mod_length;
 
    std::vector<int>        barrels;
 
    std::vector<double>     beta;
 
    std::vector<double>     rough_factor;
 
    std::vector<double>     q_full;
 
    std::vector<double>     xsect_r_full;
 
    std::vector<double>     xsect_s_full;
 
    std::vector<double>     xsect_s_max;
 
    std::vector<double>     q_max;
 
    std::vector<double>     xsect_y_bot;
 
    std::vector<double>     xsect_a_bot;
 
    std::vector<double>     xsect_s_bot;
 
    std::vector<double>     xsect_r_bot;
 
    std::vector<double>     xsect_yw_max;
 
    std::vector<double>     setting;
 
    std::vector<double>     target_setting;
 
    std::vector<int>        direction;
 
    // -----------------------------------------------------------------------
    // Pump-specific properties (valid when type[i] == PUMP)
    // -----------------------------------------------------------------------
 
    std::vector<int>        pump_curve;
 
    std::vector<bool>       pump_init_state;
 
    // -----------------------------------------------------------------------
    // Conduit loss coefficients
    // -----------------------------------------------------------------------
 
    std::vector<double>     loss_inlet;
    std::vector<double>     loss_outlet;
    std::vector<double>     loss_avg;
    std::vector<bool>       has_flap_gate;
    std::vector<double>     seep_rate;
 
    std::vector<int>        culvert_code;
 
    std::vector<bool>       normal_flow_limited;
 
    std::vector<bool>       inlet_control;
 
    std::vector<double>     dqdh;
 
    // -----------------------------------------------------------------------
    // Weir / Orifice / Outlet — shared geometric properties
    // -----------------------------------------------------------------------
 
    std::vector<double>     crest_height;
 
    std::vector<double>     cd;
 
    std::vector<double>     param2;
 
    std::vector<double>     orate;
 
    // -----------------------------------------------------------------------
    // State variables — updated each timestep
    // -----------------------------------------------------------------------
 
    std::vector<double>     flow;
 
    std::vector<double>     depth;
 
    std::vector<double>     volume;
 
    std::vector<double>     froude;
 
    std::vector<FlowClass>  flow_class;
 
    std::vector<bool>       is_closed;
 
    // -----------------------------------------------------------------------
    // Previous-step state
    // -----------------------------------------------------------------------
 
    std::vector<double>     old_flow;
 
    std::vector<double>     old_depth;
 
    std::vector<double>     old_volume;
 
    // -----------------------------------------------------------------------
    // Cumulative statistics
    // -----------------------------------------------------------------------
 
    std::vector<double>     stat_vol_flow;
 
    std::vector<double>     stat_max_flow;
 
    std::vector<double>     stat_max_veloc;
 
    std::vector<double>     stat_max_filling;
 
    std::vector<double>     stat_time_surcharged;
 
    static constexpr int N_FLOW_CLASSES = 7;
    std::vector<long> stat_flow_class;
    std::vector<long> stat_norm_ltd;      
    std::vector<long> stat_inlet_ctrl;    
 
    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, LinkType::CONDUIT);
        node1.assign(un, -1);
        node2.assign(un, -1);
        offset1.assign(un, 0.0);
        offset2.assign(un, 0.0);
        q0.assign(un, 0.0);
        q_limit.assign(un, 0.0);
 
        xsect_shape.assign(un, XsectShape::CIRCULAR);
        xsect_y_full.assign(un, 0.0);
        xsect_a_full.assign(un, 0.0);
        xsect_w_max.assign(un, 0.0);
        xsect_curve.assign(un, -1);
        roughness.assign(un, 0.01);
        length.assign(un, 0.0);
        slope.assign(un, 0.0);
        mod_length.assign(un, 0.0);
        barrels.assign(un, 1);
        beta.assign(un, 0.0);
        rough_factor.assign(un, 0.0);
        q_full.assign(un, 0.0);
        xsect_r_full.assign(un, 0.0);
        xsect_s_full.assign(un, 0.0);
        xsect_s_max.assign(un, 0.0);
        q_max.assign(un, 0.0);
        xsect_y_bot.assign(un, 0.0);
        xsect_a_bot.assign(un, 0.0);
        xsect_s_bot.assign(un, 0.0);
        xsect_r_bot.assign(un, 0.0);
        xsect_yw_max.assign(un, 0.0);
        setting.assign(un, 1.0);
        target_setting.assign(un, 1.0);
        direction.assign(un, 1);
 
        loss_inlet.assign(un, 0.0);
        loss_outlet.assign(un, 0.0);
        loss_avg.assign(un, 0.0);
        has_flap_gate.assign(un, false);
        seep_rate.assign(un, 0.0);
        culvert_code.assign(un, 0);
        inlet_control.assign(un, false);
        dqdh.assign(un, 0.0);
 
        pump_curve.assign(un, -1);
        pump_init_state.assign(un, false);
 
        crest_height.assign(un, 0.0);
        cd.assign(un, 0.0);
        param2.assign(un, 0.0);
        orate.assign(un, 0.0);
 
        flow.assign(un, 0.0);
        depth.assign(un, 0.0);
        volume.assign(un, 0.0);
        froude.assign(un, 0.0);
        flow_class.assign(un, FlowClass::DRY);
        is_closed.assign(un, false);
        old_flow.assign(un, 0.0);
        old_depth.assign(un, 0.0);
        old_volume.assign(un, 0.0);
 
        stat_vol_flow.assign(un, 0.0);
        stat_max_flow.assign(un, 0.0);
        stat_max_veloc.assign(un, 0.0);
        stat_max_filling.assign(un, 0.0);
        stat_time_surcharged.assign(un, 0.0);
        stat_flow_class.assign(un * N_FLOW_CLASSES, 0L);
        stat_norm_ltd.assign(un, 0L);
        stat_inlet_ctrl.assign(un, 0L);
        normal_flow_limited.assign(un, false);
    }
 
    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_flow  = flow;
        old_depth = depth;
        old_volume = volume;
    }
 
    void reset_state() noexcept {
        std::fill(flow.begin(),  flow.end(),  0.0);
        std::fill(depth.begin(), depth.end(), 0.0);
        std::fill(volume.begin(), volume.end(), 0.0);
        std::fill(froude.begin(), froude.end(), 0.0);
        std::fill(flow_class.begin(), flow_class.end(), FlowClass::DRY);
        std::fill(old_flow.begin(),  old_flow.end(),  0.0);
        std::fill(old_depth.begin(), old_depth.end(), 0.0);
        std::fill(old_volume.begin(), old_volume.end(), 0.0);
    }
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_LINK_DATA_HPP */