InflowData.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_INFLOW_DATA_HPP
#define OPENSWMM_ENGINE_INFLOW_DATA_HPP
 
#include <vector>
#include <string>
#include <string_view>
 
#include "../core/StringCase.hpp"
 
namespace openswmm {
 
// ============================================================================
// External inflow definitions (from [INFLOWS] section)
// ============================================================================
 
struct ExtInflowData {
    int count() const { return static_cast<int>(node_idx.size()); }
 
    std::vector<int>         node_idx;       
    std::vector<std::string> node_name;      
    std::vector<std::string> constituent;    
    std::vector<std::string> ts_name;        
    std::vector<std::string> inflow_type;    
    std::vector<double>      m_factor;       
    std::vector<double>      s_factor;       
    std::vector<double>      baseline;       
    std::vector<std::string> pattern_name;   
 
    void add(int ni, const std::string& cons, const std::string& ts,
             const std::string& type, double mf, double sf, double base,
             const std::string& pat, const std::string& name = {}) {
        node_idx.push_back(ni); node_name.push_back(name);
        constituent.push_back(cons);
        ts_name.push_back(ts); inflow_type.push_back(type);
        m_factor.push_back(mf); s_factor.push_back(sf);
        baseline.push_back(base); pattern_name.push_back(pat);
    }

    void erase(int idx) {
        if (idx < 0 || idx >= count()) return;
        const auto u = static_cast<std::size_t>(idx);
        node_idx.erase(node_idx.begin() + u);
        node_name.erase(node_name.begin() + u);
        constituent.erase(constituent.begin() + u);
        ts_name.erase(ts_name.begin() + u);
        inflow_type.erase(inflow_type.begin() + u);
        m_factor.erase(m_factor.begin() + u);
        s_factor.erase(s_factor.begin() + u);
        baseline.erase(baseline.begin() + u);
        pattern_name.erase(pattern_name.begin() + u);
    }
};
 
// ============================================================================
// Dry weather flow definitions (from [DWF] section)
// ============================================================================
 
struct DwfData {
    int count() const { return static_cast<int>(node_idx.size()); }
 
    std::vector<int>         node_idx;       
    std::vector<std::string> node_name;      
    std::vector<std::string> constituent;    
    std::vector<double>      avg_value;      
    std::vector<std::string> pat1;           
    std::vector<std::string> pat2;           
    std::vector<std::string> pat3;           
    std::vector<std::string> pat4;           
 
    void add(int ni, const std::string& cons, double avg,
             const std::string& p1, const std::string& p2,
             const std::string& p3, const std::string& p4,
             const std::string& name = {}) {
        node_idx.push_back(ni); node_name.push_back(name);
        constituent.push_back(cons);
        avg_value.push_back(avg);
        pat1.push_back(p1); pat2.push_back(p2);
        pat3.push_back(p3); pat4.push_back(p4);
    }
 
    void erase(int idx) {
        if (idx < 0 || idx >= count()) return;
        const auto u = static_cast<std::size_t>(idx);
        node_idx.erase(node_idx.begin() + u);
        node_name.erase(node_name.begin() + u);
        constituent.erase(constituent.begin() + u);
        avg_value.erase(avg_value.begin() + u);
        pat1.erase(pat1.begin() + u);
        pat2.erase(pat2.begin() + u);
        pat3.erase(pat3.begin() + u);
        pat4.erase(pat4.begin() + u);
    }
};
 
// ============================================================================
// RDII assignments (from [RDII] section)
// ============================================================================
 
struct RDIIAssignData {
    int count() const { return static_cast<int>(node_idx.size()); }
 
    std::vector<int>         node_idx;    
    std::vector<std::string> node_name;   
    std::vector<std::string> uh_name;     
    std::vector<double>      sewer_area;  
 
    void add(int ni, const std::string& uh, double area,
             const std::string& name = {}) {
        node_idx.push_back(ni); node_name.push_back(name);
        uh_name.push_back(uh);
        sewer_area.push_back(area);
    }
 
    void erase(int idx) {
        if (idx < 0 || idx >= count()) return;
        const auto u = static_cast<std::size_t>(idx);
        node_idx.erase(node_idx.begin() + u);
        node_name.erase(node_name.begin() + u);
        uh_name.erase(uh_name.begin() + u);
        sewer_area.erase(sewer_area.begin() + u);
    }
};
 
// ============================================================================
// Unit Hydrograph data (from [HYDROGRAPHS] section)
// ============================================================================
 
struct UnitHydEntry {
    std::string name;       
    std::string gage_name;  
    int month;              
    int response;           
    double r;               
    double t;               
    double k;               
    double dmax;            
    double drecov;          
    double dinit;           
};
 
struct UnitHydData {
    int count() const { return static_cast<int>(entries.size()); }
 
    std::vector<UnitHydEntry> entries;

    std::vector<std::string> gage_assignments; 
    std::vector<std::string> gage_names;       
 
    void add_gage(const std::string& uh_name, const std::string& gage) {
        gage_assignments.push_back(uh_name);
        gage_names.push_back(gage);
    }
 
    void add(const UnitHydEntry& e) { entries.push_back(e); }
};
 
// ============================================================================
// RDII exponential-decay parameters (from [RDII_DECAY] section)
// ============================================================================
//
// One row per (UH group, response). Granularity is per-response, NOT per-month
// — the whole point of the exponential model is that seasonal variation in
// IA recovery emerges from temperature dynamics, not from a monthly lookup.
//
// A UH group with no row here uses the legacy linear IA recovery for every
// response. A group with one row falls back to linear for the two unspecified
// responses, so adoption is incremental.
//
// @see docs/RDII_ExpDecay_Implementation.md
 
struct RDIIDecayEntry {
    std::string uh_name;    
    int    response  = -1;  
    double k_dep     = 0.0; 
    double k_0       = 0.0; 
    double k_T       = 0.0; 
    double T_ref     = 10.0;
    double theta_rec = 0.0; 
    double T_freeze  = 0.0; 
 
    // Optional degree-day snow model (SNOW keyword + 2 extra columns).
    // When on, precipitation at T <= snow_T accumulates as SWE (no liquid
    // input); at T > snow_T, melt = min(SWE, snow_ddf*(T - snow_T)*dt_days)
    // is added to rainfall before the IA update (rain-on-snow adds).
    bool   snow_on   = false; 
    double snow_T    = 1.0;   
    double snow_ddf  = 0.0;   
};
 
struct RDIIDecayData {
    int count() const { return static_cast<int>(entries.size()); }
 
    std::vector<RDIIDecayEntry> entries;
 
    void add(const RDIIDecayEntry& e) { entries.push_back(e); }
};
 
// ============================================================================
// Time patterns (from [PATTERNS] section)
// ============================================================================
 
struct PatternData {
    int count() const { return static_cast<int>(names.size()); }
 
    std::vector<std::string> names;           
    std::vector<int>         types;           
    std::vector<std::vector<double>> factors; 
 
    void add(const std::string& name, int type, const std::vector<double>& facs) {
        names.push_back(name); types.push_back(type);
        factors.push_back(facs);
    }

    int find(std::string_view name) const noexcept {
        for (int i = 0; i < count(); ++i)
            if (ieq(names[static_cast<std::size_t>(i)], name)) return i;
        return -1;
    }
};
 
} // namespace openswmm
 
#endif // OPENSWMM_ENGINE_INFLOW_DATA_HPP