RDII.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_RDII_HPP
#define OPENSWMM_RDII_HPP
 
#include <array>
#include <vector>
#include <string>
#include <unordered_map>
 
namespace openswmm {
 
struct SimulationContext;
 
namespace rdii {
 
struct UnitHydParams {
    double r[12][3]     = {};  
    double tPeak[12][3] = {};  
    double tBase[12][3] = {};  
    double iaMax[12][3] = {};  
    double iaRecov[12][3] = {};
    double iaInit[12][3] = {}; 
};

struct ExpDecayParams {
    bool   active    = false;
    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 UHResponseData {
    std::vector<double> past_rain;      
    std::vector<int>    past_month;     
    int    period      = 0;             
    int    max_periods = 0;             
    int    has_past_rain = 0;           
    double ia_used     = 0.0;           
    long   dry_seconds = 0;             
 
    void allocate(int n) {
        max_periods = n;
        past_rain.assign(static_cast<std::size_t>(n), 0.0);
        past_month.assign(static_cast<std::size_t>(n), 0);
        period = 0;
        has_past_rain = 0;
        ia_used = 0.0;
        dry_seconds = static_cast<long>(n) * 300 + 1; // start dry
    }
};

double getRecoveryRate(const ExpDecayParams& dp, double T_celsius);

double updateIA_exp(const UnitHydParams& uh, UHResponseData& rd,
                    const ExpDecayParams& dp, int month, int response,
                    double rainDepth, double dt_sec,
                    const SimulationContext& ctx);
 
struct RDIIGroupSoA {
    int count = 0;
    std::vector<int>    node_idx;       
    std::vector<int>    uh_idx;         
    std::vector<int>    gage_idx;       
    std::vector<double> area;           

    std::vector<UHResponseData> uh_data;
 
    std::vector<int>    rain_interval;  
    std::vector<double> time_accum;     
    std::vector<double> rain_at_start;  
 
    void resize(int n);
};
 
class RDIISolver {
public:
    void init(SimulationContext& ctx);

    int addUnitHydParams(const std::string& name, const UnitHydParams& params);

    int findUnitHyd(const std::string& name) const;

    const std::unordered_map<std::string, int>& uhNameIndex() const { return uh_name_to_idx_; }

    void computeAll(SimulationContext& ctx, int month, double dt);

    void applyRdiiInflows(SimulationContext& ctx) const;
 
    std::vector<UnitHydParams> uh_params;

    std::vector<std::array<ExpDecayParams, 3>> decay_params;

    const std::vector<double>& nodeFlows() const { return node_rdii_flow_; }

    std::vector<int> rdiiNodeList() const;

    static int getRainInterval(const UnitHydParams& uh, double wet_step);

    static int getMaxPeriods(const UnitHydParams& uh, int response, int rainInterval);
 
private:
    RDIIGroupSoA groups_;
    std::unordered_map<std::string, int> uh_name_to_idx_;
    std::vector<double> node_rdii_flow_;  

    double uhOrdinate(const UnitHydParams& uh, int month, int response, double t) const;

    void validateExpDecay(SimulationContext& ctx) const;
};
 
} // namespace rdii
} // namespace openswmm
 
#endif // OPENSWMM_RDII_HPP