InflowData.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_INFLOW_DATA_HPP
#define OPENSWMM_ENGINE_INFLOW_DATA_HPP
 
#include <vector>
#include <string>
 
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> 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) {
        node_idx.push_back(ni); 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);
        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> 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) {
        node_idx.push_back(ni); 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);
        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> uh_name;     
    std::vector<double>      sewer_area;  
 
    void add(int ni, const std::string& uh, double area) {
        node_idx.push_back(ni); 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);
        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; 
};
 
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);
    }
};
 
} // namespace openswmm
 
#endif // OPENSWMM_ENGINE_INFLOW_DATA_HPP