SolverOptions2D.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_2D_SOLVER_OPTIONS_HPP
#define OPENSWMM_ENGINE_2D_SOLVER_OPTIONS_HPP
 
#include <cstdint>
#include <string>
 
namespace openswmm::twoD {

enum class LinearSolverType : int8_t {
    GMRES    = 0,   
    BICGSTAB = 1,   
    TFQMR    = 2    
};

enum class PreconditionerType : int8_t {
    NONE   = 0,     
    JACOBI = 1,     
    ILU    = 2,     
    AMG    = 3      
};

enum class IntegratorType : int8_t {
    CVODE  = 0,     
    ARKODE = 1      
};

enum class MomentumType : int8_t {
    DW       = 0,   
    INERTIAL = 1    
};

enum class RainfallMode : int8_t {
    NATURAL_NEIGHBOUR = 0,  
    SYSTEM            = 1,  
    NONE              = 2   
};

struct SolverOptions2D {
    double max_timestep      = 10.0;    
    double min_timestep      = 0.001;   
    double rel_tolerance     = 1.0e-4;  
    double abs_tolerance     = 1.0e-6;  
    double dry_depth         = 0.001;   
    double limiter_epsilon   = 1.0e-6;  
    double flux_dh_eps       = 0.004;   
    double coupling_cd       = 0.65;    
    int    max_krylov_dim    = 30;      
    int    coupling_interval = 0;       
    double coupling_window   = -1.0;
    int    max_cvode_steps   = 500;     

    bool   active_set        = false;
    int    active_set_halo   = 2;
    bool   report_2d         = true;    
 
    // Time integrator. Default CVODE (validated path); ARKODE selects the
    // ARKStep IMEX solver. Parsed from [2D_OPTIONS] INTEGRATOR; env
    // OPENSWMM_2D_INTEGRATOR overrides at solver-construction time.
    IntegratorType     integrator      = IntegratorType::CVODE;
 
    // Surface-momentum closure. Default DW (diffusive wave). INERTIAL selects the
    // local-inertial scheme (per-edge q), honored only by ArkodeSurfaceSolver.
    // Parsed from [2D_OPTIONS] MOMENTUM; env OPENSWMM_2D_MOMENTUM overrides.
    MomentumType       momentum        = MomentumType::DW;
 
    // Rainfall→mesh mapping. Default NATURAL_NEIGHBOUR (spatial interpolation
    // across all located gages); SYSTEM applies the uniform all-gage mean.
    // Parsed from [2D_OPTIONS] RAINFALL_MODE; env OPENSWMM_2D_RAINFALL_MODE
    // (natural|system) overrides.
    RainfallMode       rainfall_mode   = RainfallMode::NATURAL_NEIGHBOUR;
 
    LinearSolverType   linear_solver   = LinearSolverType::GMRES;
    // Default to AMG (hypre BoomerAMG): the only preconditioner with
    // near-mesh-independent Krylov counts on the elliptic diffusive-wave
    // operator, so it is the right default at every scale (and essential past
    // ~100k cells). The value is unconditional here (keeping one struct layout
    // across all TUs); a build WITHOUT hypre resolves AMG → JACOBI at solver
    // initialize with a one-line notice, so the portable base build still runs.
    // See docs/2D_KNOWN_STIFFNESS_ISSUE.md.
    PreconditionerType preconditioner  = PreconditionerType::AMG;

    std::string mesh_file;

    std::string output_file;
 
    // -----------------------------------------------------------------------
    // Unit-system coupling factors — NOT parsed from input. Computed once in
    // SurfaceRouter2D::initialize() from the project FLOW_UNITS.
    //
    // The 2D solver runs internally in SI (metres, m², m³, m³/s, g=9.80665).
    // The 1D SWMM engine ALWAYS computes internally in FEET (g=32.2, PHI=1.486)
    // — for EVERY project, US or SI: its reader converts metric inputs to feet
    // on load and only converts back at the display/output boundary. So these
    // coupling factors are ALWAYS the feet⇄metres conversion, independent of
    // FLOW_UNITS. SurfaceRouter2D::initialize() overwrites the 1.0 defaults
    // with the real ft⇄m factors; the defaults only stand when 2D is inactive
    // (no coupling occurs). The MESH scaling factor is separate and IS driven
    // by FLOW_UNITS (the mesh is authored in project units) — see initialize().
    // -----------------------------------------------------------------------
    double len_1d_to_2d  = 1.0;  
    double len_2d_to_1d  = 1.0;  
    double vol_1d_to_2d  = 1.0;  
    double flow_1d_to_2d = 1.0;  
    double flow_2d_to_1d = 1.0;  

    int num_threads = 1;

    bool mesh_units_si = false;

    bool mesh_scaled_to_si = false;

    bool pending_rows_drained = false;
};
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_ENGINE_2D_SOLVER_OPTIONS_HPP