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<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;
 
    // -----------------------------------------------------------------------
    // 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{});
        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);
        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);
 
        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{});
        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);
        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);
        // 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(scale_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();
        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();
 
        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 */