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