SubcatchData.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_SUBCATCH_DATA_HPP
#define OPENSWMM_ENGINE_SUBCATCH_DATA_HPP
 
#include <vector>
#include <string>
#include <cstdint>
 
namespace openswmm {
 
// ============================================================================
// SubcatchData — SoA layout
// ============================================================================
 
struct SubcatchData {
 
    // -----------------------------------------------------------------------
    // Static properties — set at parse time
    // -----------------------------------------------------------------------
 
    std::vector<int>    outlet_node;
 
    std::vector<int>    outlet_subcatch;
 
    std::vector<std::string> outlet_name;
 
    std::vector<int>    gage;
 
    std::vector<double> area;
 
    std::vector<double> width;
 
    std::vector<double> slope;
 
    std::vector<double> curb_length;
 
    std::vector<double> frac_imperv;
 
    std::vector<double> frac_imperv_no_store;
 
    std::vector<double> n_imperv;
 
    std::vector<double> n_perv;
 
    std::vector<double> ds_imperv;
 
    std::vector<double> ds_perv;
 
    // -----------------------------------------------------------------------
    // Inter-subarea routing (from [SUBAREAS] section)
    // -----------------------------------------------------------------------
 
    std::vector<int>    subarea_routing;
 
    std::vector<double> pct_routed;
 
    // -----------------------------------------------------------------------
    // Infiltration parameters (per subcatchment)
    // -----------------------------------------------------------------------
 
    std::vector<int>    infil_model;
 
    std::vector<double> infil_p1;
    std::vector<double> infil_p2;
    std::vector<double> infil_p3;
    std::vector<double> infil_p4;
    std::vector<double> infil_p5;
 
    // -----------------------------------------------------------------------
    // State variables — updated each timestep
    // -----------------------------------------------------------------------
 
    std::vector<double> runoff;
 
    std::vector<double> rainfall;
 
    std::vector<double> evap_loss;
 
    std::vector<double> infil_loss;
 
    std::vector<double> ponded_depth;
 
    std::vector<double> gw_flow;
 
    // -----------------------------------------------------------------------
    // Previous-step state
    // -----------------------------------------------------------------------
 
    std::vector<double> old_runoff;
 
    // -----------------------------------------------------------------------
    // Cumulative statistics
    // -----------------------------------------------------------------------
 
    std::vector<double> stat_precip_vol;
    std::vector<double> stat_evap_vol;     
    std::vector<double> stat_infil_vol;    
    std::vector<double> stat_imperv_vol;   
    std::vector<double> stat_perv_vol;     
 
    std::vector<double> stat_runoff_vol;
 
    std::vector<double> stat_max_runoff;
 
    // -----------------------------------------------------------------------
    // Groundwater parameters (from [GROUNDWATER] section)
    // -----------------------------------------------------------------------
 
    std::vector<int>    gw_aquifer;
 
    std::vector<int>    gw_node;
 
    std::vector<double> gw_surf_elev;
 
    std::vector<double> gw_a1;
 
    std::vector<double> gw_b1;
 
    std::vector<double> gw_a2;
 
    std::vector<double> gw_b2;
 
    std::vector<double> gw_a3;
 
    std::vector<double> gw_tw;
 
    std::vector<double> gw_hstar;
 
    // -----------------------------------------------------------------------
    // Snowpack assignment (index into SnowpackStore, -1 = none)
    // -----------------------------------------------------------------------
 
    std::vector<int>    snowpack;
 
    // -----------------------------------------------------------------------
    // Cumulative pollutant washoff loads — flat 2D: [subcatch * n_pollutants + pollutant]
    // -----------------------------------------------------------------------
 
    std::vector<double> total_load;
 
    int total_load_n_pollutants = 0;
 
    void resize_total_load(int n_sc, int n_poll) {
        total_load_n_pollutants = n_poll;
        total_load.assign(
            static_cast<std::size_t>(n_sc) * static_cast<std::size_t>(n_poll), 0.0);
    }
 
    // -----------------------------------------------------------------------
    // Land-use coverage — flat 2D: [subcatch * n_landuses + landuse]
    // -----------------------------------------------------------------------
 
    std::vector<double> coverage;
 
    int coverage_n_landuses = 0;
 
    void resize_coverage(int n_sc, int n_lu) {
        coverage_n_landuses = n_lu;
        coverage.assign(
            static_cast<std::size_t>(n_sc) * static_cast<std::size_t>(n_lu),
            0.0);
    }
 
    // -----------------------------------------------------------------------
    // Capacity management
    // -----------------------------------------------------------------------
 
    int count() const noexcept { return static_cast<int>(area.size()); }
 
    void resize(int n) {
        const auto un = static_cast<std::size_t>(n);
 
        outlet_node.assign(un, -1);
        outlet_subcatch.assign(un, -1);
        outlet_name.resize(un);
        gage.assign(un, -1);
        area.assign(un, 0.0);
        width.assign(un, 0.0);
        slope.assign(un, 0.0);
        curb_length.assign(un, 0.0);
        frac_imperv.assign(un, 0.0);
        frac_imperv_no_store.assign(un, 0.0);
        n_imperv.assign(un, 0.013);
        n_perv.assign(un, 0.1);
        ds_imperv.assign(un, 0.0);
        ds_perv.assign(un, 0.0);
        subarea_routing.assign(un, 0);  // TO_OUTLET
        pct_routed.assign(un, 0.0);
 
        infil_model.assign(un, 0);
        infil_p1.assign(un, 0.0);
        infil_p2.assign(un, 0.0);
        infil_p3.assign(un, 0.0);
        infil_p4.assign(un, 0.0);
        infil_p5.assign(un, 0.0);
 
        runoff.assign(un, 0.0);
        rainfall.assign(un, 0.0);
        evap_loss.assign(un, 0.0);
        infil_loss.assign(un, 0.0);
        ponded_depth.assign(un, 0.0);
        gw_flow.assign(un, 0.0);
        old_runoff.assign(un, 0.0);
 
        stat_precip_vol.assign(un, 0.0);
        stat_evap_vol.assign(un, 0.0);
        stat_infil_vol.assign(un, 0.0);
        stat_imperv_vol.assign(un, 0.0);
        stat_perv_vol.assign(un, 0.0);
        stat_runoff_vol.assign(un, 0.0);
        stat_max_runoff.assign(un, 0.0);
 
        gw_aquifer.assign(un, -1);
        gw_node.assign(un, -1);
        gw_surf_elev.assign(un, 0.0);
        gw_a1.assign(un, 0.0);
        gw_b1.assign(un, 0.0);
        gw_a2.assign(un, 0.0);
        gw_b2.assign(un, 0.0);
        gw_a3.assign(un, 0.0);
        gw_tw.assign(un, 0.0);
        gw_hstar.assign(un, 0.0);
        snowpack.assign(un, -1);
    }
 
    void save_state() noexcept {
        old_runoff = runoff;
    }
 
    void reset_state() noexcept {
        std::fill(runoff.begin(),       runoff.end(),       0.0);
        std::fill(rainfall.begin(),     rainfall.end(),     0.0);
        std::fill(evap_loss.begin(),    evap_loss.end(),    0.0);
        std::fill(infil_loss.begin(),   infil_loss.end(),   0.0);
        std::fill(ponded_depth.begin(), ponded_depth.end(), 0.0);
        std::fill(old_runoff.begin(),   old_runoff.end(),   0.0);
    }
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_SUBCATCH_DATA_HPP */