Runoff.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_RUNOFF_HPP
#define OPENSWMM_RUNOFF_HPP
 
#include "../data/SubcatchData.hpp"
#include "Infiltration.hpp"
#include <vector>
 
namespace openswmm {
 
struct SimulationContext;
 
namespace runoff {
 
// ============================================================================
// Constants
// ============================================================================
 
constexpr double MEXP = 5.0 / 3.0;       
constexpr double ODETOL = 0.0001;         
constexpr double PHI = 1.486;             
 
// ============================================================================
// Per-subcatchment subarea state (SoA for vectorization)
// ============================================================================
 
struct RunoffSoA {
    int n_subcatch = 0;
 
    // Per-subcatchment properties (set at init)
    std::vector<double> area;          
    std::vector<double> width;         
    std::vector<double> slope;         
    std::vector<double> imperv_pct;    
    std::vector<double> imperv0_pct;   
 
    // Per-subarea SoA: alpha = runoff coefficient
    std::vector<double> alpha_imperv;  
    std::vector<double> alpha_perv;    
 
    // Per-subarea SoA: depression storage (ft)
    std::vector<double> ds_imperv;     
    std::vector<double> ds_perv;       
 
    // Per-subarea SoA: Manning's n
    std::vector<double> n_imperv;      
    std::vector<double> n_perv;        
 
    // Per-subarea SoA: ponded depth (state, updated each step)
    std::vector<double> depth_imperv0; 
    std::vector<double> depth_imperv1; 
    std::vector<double> depth_perv;    
 
    // Per-subarea SoA: previous-step runoff rates (ft/sec, area-averaged)
    // Used for inter-subarea routing (legacy subcatch_getRunon)
    std::vector<double> old_runoff_imperv0; 
    std::vector<double> old_runoff_imperv1; 
    std::vector<double> old_runoff_perv;    
 
    // Per-subcatchment: computed runoff (output)
    std::vector<double> runoff;        
    std::vector<double> evap_loss;     
    std::vector<double> infil_loss;    
 
    void resize(int n);
    void computeAlpha();
};
 
// ============================================================================
// Runoff solver
// ============================================================================
 
class RunoffSolver {
public:
    void init(SimulationContext& ctx);
    void execute(SimulationContext& ctx, double dt, double evap_rate = 0.0,
                 double infil_factor = 1.0, double recovery_factor = 1.0);
 
    const RunoffSoA& soa() const { return soa_; }
 
private:
    RunoffSoA soa_;
 
    // Infiltration state (one per subcatchment)
    InfilModel infil_model_ = InfilModel::HORTON;
    std::vector<HortonState>    horton_states_;
    std::vector<GreenAmptState> grnampt_states_;
    std::vector<CurveNumState>  curvenum_states_;
 
    // Working buffers (reused each step, sized to n_subcatch)
    std::vector<double> precip_;
    std::vector<double> evap_rate_;
    std::vector<double> infil_rate_;
 
    static void updatePondedDepth(double& depth, double inflow, double alpha,
                                  double dStore, double dt);
 
    static double getRunoffRate(double depth, double dStore, double alpha);
};
 
} // namespace runoff
} // namespace openswmm
 
#endif // OPENSWMM_RUNOFF_HPP