GageData.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2026 Caleb Buahin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#ifndef OPENSWMM_ENGINE_GAGE_DATA_HPP
#define OPENSWMM_ENGINE_GAGE_DATA_HPP
 
#include "../core/FilePathPair.hpp"
#include "TableData.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<FilePathPair> file_path;

    std::vector<std::string> ts_name;

    std::vector<std::string> col_name;

    std::vector<std::string> station_id;

    std::vector<int> rain_units;
 
    // -----------------------------------------------------------------------
    // Rainfall-file summary statistics (for the "Rainfall File Summary"
    // report section).  Populated by load_external_rain_files() while it
    // scans the external file; meaningful only when source == FILE_RAIN.
    // -----------------------------------------------------------------------

    std::vector<double> file_first_date;

    std::vector<double> file_last_date;

    std::vector<long> file_periods_precip;

    std::vector<double> file_start_date;

    std::vector<Table> rain_series;

    std::vector<RainFileFormat> file_format;

    std::vector<int> interval_sec;

    std::vector<double> snow_factor;

    std::vector<double> scale_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;

    std::vector<int> st_cur;
    std::vector<int> st_next;
    std::vector<double> st_rain;
    std::vector<uint8_t> st_init;
    std::vector<uint8_t> st_used;
 
    // -----------------------------------------------------------------------
    // 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_interval;

    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{});
        station_id.assign(un, std::string{});
        rain_units.assign(un, 0);
        file_first_date.assign(un, 0.0);
        file_last_date.assign(un, 0.0);
        file_periods_precip.assign(un, 0L);
        file_start_date.assign(un, 0.0);
        rain_series.assign(un, Table{});
        file_format.assign(un, RainFileFormat::UNKNOWN);
        interval_sec.assign(un, 3600);
        snow_factor.assign(un, 1.0);
        scale_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);
        st_cur.assign(un, -2);
        st_next.assign(un, -1);
        st_rain.assign(un, 0.0);
        st_init.assign(un, 0);
        st_used.assign(un, 0);
 
        past_rain.assign(un * MAXPASTRAIN, 0.0);
        past_rain_accum.assign(un, 0.0);
        past_rain_interval.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{});
        station_id.resize(un, std::string{});
        g(rain_units, 0);
        g(file_first_date, 0.0);
        g(file_last_date, 0.0);
        g(file_periods_precip, 0L);
        g(file_start_date, 0.0);
        rain_series.resize(un, Table{});
        g(file_format, RainFileFormat::UNKNOWN);
        g(interval_sec, 3600);
        g(snow_factor, 1.0);
        g(scale_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);
        g(st_cur, -2);
        g(st_next, -1);
        g(st_rain, 0.0);
        g(st_init, static_cast<uint8_t>(0));
        g(st_used, static_cast<uint8_t>(0));
        // 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_interval, 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(scale_factor);
        e(file_start_date);
        e(rainfall);
        e(next_rainfall);
        e(api_rainfall);
        e(next_rain_date);
        e(is_raining);
        e(st_cur);
        e(st_next);
        e(st_rain);
        e(st_init);
        e(st_used);
        e(past_rain_accum);
        e(past_rain_interval);
        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();
        scale_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();
        st_cur.shrink_to_fit();
        st_next.shrink_to_fit();
        st_rain.shrink_to_fit();
        st_init.shrink_to_fit();
        st_used.shrink_to_fit();
 
        past_rain.shrink_to_fit();
        past_rain_accum.shrink_to_fit();
        past_rain_interval.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(st_cur.begin(), st_cur.end(), -2);
        std::fill(st_next.begin(), st_next.end(), -1);
        std::fill(st_rain.begin(), st_rain.end(), 0.0);
        std::fill(st_init.begin(), st_init.end(), static_cast<uint8_t>(0));
        std::fill(st_used.begin(), st_used.end(), static_cast<uint8_t>(0));
        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_interval.begin(), past_rain_interval.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 */