Inlet.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_INLET_HPP
#define OPENSWMM_INLET_HPP
 
#include <vector>
 
namespace openswmm {
 
struct SimulationContext;
struct InletUsageStore;
 
namespace inlet {
 
enum class InletType : int {
    GRATE       = 0,
    CURB        = 1,
    COMBO       = 2,
    SLOTTED     = 3,
    DROP_GRATE  = 4,
    DROP_CURB   = 5,
    CUSTOM      = 6
};
 
enum class GrateType : int {
    P_BAR_50      = 0,
    P_BAR_50x100  = 1,
    P_BAR_30      = 2,
    CURVED_VANE   = 3,
    TILT_BAR_45   = 4,
    TILT_BAR_30   = 5,
    RETICULINE    = 6,
    GENERIC       = 7
};
 
struct InletSoA {
    int count = 0;
    std::vector<int>    link_idx;       
    std::vector<int>    node_idx;       
    std::vector<int>    bypass_node;    
    std::vector<int>    inlet_type;
    std::vector<int>    grate_type;
    std::vector<double> grate_length;   
    std::vector<double> grate_width;    
    std::vector<double> curb_length;    
    std::vector<double> curb_height;    
    std::vector<int>    curb_throat;    
    std::vector<double> slotted_length; 
    std::vector<double> slotted_width;  
    std::vector<double> clog_factor;    
    std::vector<double> opening_ratio;  
    std::vector<int>    num_inlets;     
    std::vector<double> flow_limit;     
    std::vector<double> local_depress;  
    std::vector<double> local_width;    
    std::vector<int>    n_sides;        
 
    // Street geometry (resolved from StreetStore)
    std::vector<double> sx;             
    std::vector<double> gutter_depression; 
    std::vector<double> gutter_width;   
    std::vector<double> road_roughness; 
    std::vector<double> t_crown;        
 
    // Working arrays (per-inlet results)
    std::vector<double> flow_capture;   
 
    // Gap #56: backflow — fraction of capture node overflow that returns to bypass
    std::vector<double> backflow_ratio; 
    std::vector<double> backflow;       
 
    // Gap #68: statistics (accumulated each timestep)
    std::vector<double> stat_capture_vol;   
    std::vector<double> stat_bypass_vol;    
    std::vector<double> stat_backflow_vol;  
    std::vector<double> stat_peak_flow;     
 
    void resize(int n);
};
 
class InletSolver {
public:
    void init(SimulationContext& ctx);
 
    void computeAll(SimulationContext& ctx, double dt);
 
    void adjustQualInflows(SimulationContext& ctx, double dt);
 
    void gatherStats(InletUsageStore& usages) const;
 
private:
    InletSoA soa_;
 
    static double grateCapture(double flow, double velocity, double length,
                                double sx, int grate_type, double open_ratio);
 
    static double curbCapture(double flow, double curb_length,
                               double sx, double sl, double n,
                               double gutter_depress, double gutter_width,
                               double spread);
 
    static double splashOverVelocity(double length, int grate_type);
 
    static double computeFlowSpread(double flow, double qfactor,
                                     double sx, double sw, double a_gutter,
                                     double w_gutter, double t_crown);
 
    static double computeEo(double sr, double ts, double w);
 
    double computeOnGradeCapture(int idx, double flow, double depth) const;
 
    double getInletArea(int ii) const noexcept;
 
    void computeBackflowRatios();
};
 
} // namespace inlet
} // namespace openswmm
 
#endif // OPENSWMM_INLET_HPP