GageData.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_GAGE_DATA_HPP
#define OPENSWMM_ENGINE_GAGE_DATA_HPP
 
#include <vector>
#include <string>
#include <cstdint>
 
namespace openswmm {
 
// ============================================================================
// Rain source enumeration
// ============================================================================
 
enum class RainSource : int8_t {
    TIMESERIES = 0,  
    FILE_RAIN  = 1   
};
 
enum class RainFileFormat : int8_t {
    UNKNOWN  = -1,
    NWS_15   = 0,   
    NWS_HOURLY = 1, 
    DSI_3240 = 2,   
    DSI_3260 = 3,   
    HLY_PRCP = 4,   
    STAN_PRCP = 5,  
    USER_CSV = 6    
};
 
// ============================================================================
// GageData — SoA layout
// ============================================================================
 
struct GageData {
 
    // -----------------------------------------------------------------------
    // Static properties — set at parse time
    // -----------------------------------------------------------------------
 
    std::vector<int>            rain_type;
 
    std::vector<RainSource>     source;
 
    std::vector<int>            ts_index;
 
    std::vector<std::string>    file_path;
 
    std::vector<std::string>    ts_name;
 
    std::vector<std::string>    col_name;
 
    std::vector<RainFileFormat> file_format;
 
    std::vector<int>            interval_sec;
 
    std::vector<double>         snow_factor;
 
    // -----------------------------------------------------------------------
    // State variables — updated each timestep
    // -----------------------------------------------------------------------
 
    std::vector<double>         rainfall;
 
    std::vector<double>         next_rainfall;
 
    std::vector<double>         api_rainfall;
 
    std::vector<double>         next_rain_date;
 
    std::vector<bool>           is_raining;
 
    // -----------------------------------------------------------------------
    // Past-rain history (for control rules — GAGE_RAIN_PAST)
    // -----------------------------------------------------------------------
 
    static constexpr int MAXPASTRAIN = 48; 
 
    std::vector<double>         past_rain;
 
    std::vector<double>         past_rain_accum;
 
    std::vector<double>         past_rain_time;
 
    std::vector<double>         cumul_rain_accum;
 
    std::vector<std::string>    comments;
 
    std::vector<int>            co_gage_index;
 
    // -----------------------------------------------------------------------
    // Capacity management
    // -----------------------------------------------------------------------
 
    int count() const noexcept { return static_cast<int>(source.size()); }
 
    void resize(int n) {
        const auto un = static_cast<std::size_t>(n);
 
        rain_type.assign(un, 0);
        source.assign(un, RainSource::TIMESERIES);
        ts_index.assign(un, -1);
        ts_name.assign(un, std::string{});
        file_path.assign(un, std::string{});
        col_name.assign(un, std::string{});
        file_format.assign(un, RainFileFormat::UNKNOWN);
        interval_sec.assign(un, 3600);
        snow_factor.assign(un, 1.0);
 
        rainfall.assign(un, 0.0);
        next_rainfall.assign(un, 0.0);
        api_rainfall.assign(un, -1.0);  // -1.0 means no API override
        next_rain_date.assign(un, 0.0);
        is_raining.assign(un, false);
 
        past_rain.assign(un * MAXPASTRAIN, 0.0);
        past_rain_accum.assign(un, 0.0);
        past_rain_time.assign(un, 0.0);
        cumul_rain_accum.assign(un, 0.0);
        co_gage_index.assign(un, -1);
        comments.assign(un, std::string{});
    }
 
    void grow_to(int n) {
        if (n <= count()) return;
        const auto un = static_cast<std::size_t>(n);
        auto g = [&](auto& v, auto def) { v.resize(un, def); };
        g(rain_type, 0); g(source, RainSource::TIMESERIES); g(ts_index, -1);
        ts_name.resize(un, std::string{});
        file_path.resize(un, std::string{});
        col_name.resize(un, std::string{});
        g(file_format, RainFileFormat::UNKNOWN); g(interval_sec, 3600); g(snow_factor, 1.0);
        g(rainfall, 0.0); g(next_rainfall, 0.0);
        g(api_rainfall, -1.0); g(next_rain_date, 0.0); g(is_raining, false);
        // Flat 2D: [gage * MAXPASTRAIN + hour]
        past_rain.resize(un * static_cast<std::size_t>(MAXPASTRAIN), 0.0);
        g(past_rain_accum, 0.0); g(past_rain_time, 0.0); g(cumul_rain_accum, 0.0);
        g(co_gage_index, -1);
        comments.resize(un, std::string{});
    }
 
    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(rain_type); e(source); e(ts_index); e(ts_name);
        e(file_path); e(col_name); e(file_format); e(interval_sec); e(snow_factor);
        e(rainfall); e(next_rainfall); e(api_rainfall); e(next_rain_date); e(is_raining);
        e(past_rain_accum); e(past_rain_time); e(cumul_rain_accum); e(co_gage_index);
        e(comments);
 
        // Flat 2D past_rain: [gage * MAXPASTRAIN + hour]
        const auto base = ui * static_cast<std::size_t>(MAXPASTRAIN);
        const auto end  = base + static_cast<std::size_t>(MAXPASTRAIN);
        if (end <= past_rain.size())
            past_rain.erase(past_rain.begin() + static_cast<std::ptrdiff_t>(base),
                            past_rain.begin() + static_cast<std::ptrdiff_t>(end));
    }
 
    void shrink_to_fit() {
        rain_type.shrink_to_fit();
        source.shrink_to_fit();
        ts_index.shrink_to_fit();
        ts_name.shrink_to_fit();
        file_path.shrink_to_fit();
        col_name.shrink_to_fit();
        file_format.shrink_to_fit();
        interval_sec.shrink_to_fit();
        snow_factor.shrink_to_fit();
 
        rainfall.shrink_to_fit();
        next_rainfall.shrink_to_fit();
        api_rainfall.shrink_to_fit();
        next_rain_date.shrink_to_fit();
        is_raining.shrink_to_fit();
 
        past_rain.shrink_to_fit();
        past_rain_accum.shrink_to_fit();
        past_rain_time.shrink_to_fit();
        cumul_rain_accum.shrink_to_fit();
        co_gage_index.shrink_to_fit();
        comments.shrink_to_fit();
    }
 
    void reset_state() noexcept {
        std::fill(rainfall.begin(),      rainfall.end(),      0.0);
        std::fill(next_rainfall.begin(), next_rainfall.end(), 0.0);
        std::fill(api_rainfall.begin(),  api_rainfall.end(),  -1.0); // -1 = no override
        std::fill(is_raining.begin(),    is_raining.end(),    false);
        std::fill(past_rain.begin(),     past_rain.end(),     0.0);
        std::fill(past_rain_accum.begin(), past_rain_accum.end(), 0.0);
        std::fill(past_rain_time.begin(),  past_rain_time.end(),  0.0);
        std::fill(cumul_rain_accum.begin(), cumul_rain_accum.end(), 0.0);
        // co_gage_index is static (set at parse time), not reset between runs
    }
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_GAGE_DATA_HPP */