SimulationOptions.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2026 Caleb Buahin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#ifndef OPENSWMM_ENGINE_SIMULATION_OPTIONS_HPP
#define OPENSWMM_ENGINE_SIMULATION_OPTIONS_HPP
 
#include "FilePathPair.hpp"
#include <string>
#include <vector>
#include <unordered_map>
 
#include "../hydraulics/fv/FvOptions.hpp"
#include <cstdint>
#include <cmath>
 
namespace openswmm {
 
// ============================================================================
// Enumerators matching legacy SWMM enums.h
// ============================================================================

enum class FlowUnits : int {
    CFS  = 0,  
    GPM  = 1,  
    MGD  = 2,  
    CMS  = 3,  
    LPS  = 4,  
    MLD  = 5   
};

enum class RoutingModel : int {
    STEADY   = 0,  
    KINWAVE  = 1,  
    DYNWAVE  = 2,  
    FV       = 3   
};

enum class QualitySolverKind : int {
    LEGACY       = 0,  
    EULERIAN_ARD = 1,  
    LAGRANGIAN   = 2   
};

enum class InfiltrationModel : int {
    HORTON        = 0,
    MOD_HORTON    = 1,
    GREEN_AMPT    = 2,
    MOD_GREEN_AMPT = 3,
    CURVE_NUMBER  = 4
};

enum class RunoffModel : int {
    NONE       = 0,
    NL_POND    = 1  
};

enum class NodeContinuity : int {
    EXPLICIT      = 0,  
    SEMI_IMPLICIT = 1   
};
 
// ============================================================================
// SimulationOptions struct
// ============================================================================

struct SimulationOptions {
    // -----------------------------------------------------------------------
    // Time control
    // -----------------------------------------------------------------------

    double start_date = 2453006.0;  // Jan 1, 2004 OADate (days since 12/30/1899) (legacy default)

    double end_date = 0.0;

    double total_duration_ms = -1.0;

    double report_start = 0.0;

    double routing_step = 20.0;

    double min_routing_step = 0.5;

    double dry_step = 3600.0;

    double wet_step = 300.0;

    double report_step = 900.0;

    double dry_days = 0.0;

    double variable_step = 0.75;

    double lengthening_step = 0.0;

    int sweep_start = 1;

    int sweep_end = 365;
 
    // -----------------------------------------------------------------------
    // Flow and routing
    // -----------------------------------------------------------------------

    FlowUnits flow_units = FlowUnits::CFS;

    RoutingModel routing_model = RoutingModel::DYNWAVE;

    QualitySolverKind quality_solver = QualitySolverKind::LEGACY;

    double quality_step = 0.0;

    int max_segments_per_link = 100;

    bool lard_rwpt = false;

    int rwpt_seed = 0;

    bool water_age = false;

    bool outfall_backflow_zero = false;

    bool heat_transport = false;

    double humidity[12] = {50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50};

    int humidity_type = 0;

    int humidity_var = 0;

    std::string humidity_ts_name;

    double water_density = 1000.0;

    double water_specific_heat = 4184.0;

    double wind_func_coeff_a = 1.505e-8;
    double wind_func_coeff_b = 1.6e-8;

    double pressure_ratio = 1.0;

    fv::FvOptions fv;

    InfiltrationModel infiltration = InfiltrationModel::HORTON;

    RunoffModel runoff_model = RunoffModel::NL_POND;
 
    // -----------------------------------------------------------------------
    // Solver settings
    // -----------------------------------------------------------------------

    int max_trials = 8;

    int surcharge_method = 0;

    double tpa_celerity = 100.0;

    double dps_target_celerity = 25.0;

    double dps_alpha = 3.0;

    double dps_decay_time = 0.5;

    int unsteady_friction = 0;

    int report_signed_heads = 0;

    double uf_k3 = 0.015;

    NodeContinuity node_continuity = NodeContinuity::EXPLICIT;

    int virtual_junction_momentum = 0;

    bool anderson_accel = false;

    int normal_flow_ltd = 2;  // BOTH (legacy default)

    int force_main_eqn = 0;

    int inertial_damping = 1;  // PARTIAL (legacy default)

    int link_offsets = 0;  // DEPTH_OFFSET (legacy default)

    double min_slope = 0.0;

    double min_surf_area = 0.0;  // 0 = use MIN_SURFAREA constant

    double head_tol = 0.005;

    double sys_flow_tol = 0.05;

    double lat_flow_tol = 0.05;

    bool skip_steady_state = false;

    bool write_absolute_paths = false;
 
    // -----------------------------------------------------------------------
    // System settings
    // -----------------------------------------------------------------------

    bool quality_routing = false;

    bool allow_ponding = false;

    bool ignore_rainfall = false;

    bool ignore_snow_melt = false;

    bool ignore_groundwater = false;

    bool ignore_rdii = false;

    bool ignore_routing = false;

    bool ignore_quality = false;

    bool ignore_2d = false;
 
    // -----------------------------------------------------------------------
    double rule_step = 0.0;
 
    // Threading
    // -----------------------------------------------------------------------

    int num_threads = 1;
 
    // -----------------------------------------------------------------------
    // New in 6.0.0 — CRS (R06)
    // -----------------------------------------------------------------------

    std::string crs;
 
    // -----------------------------------------------------------------------
    // New in 6.0.0 — Extension options map (R05)
    // -----------------------------------------------------------------------

    std::unordered_map<std::string, std::string> ext_options;
 
    // -----------------------------------------------------------------------
    // Evaporation settings (from [EVAPORATION] section)
    // -----------------------------------------------------------------------

    int evap_type = 0;

    double evap_values[12] = {0,0,0,0,0,0,0,0,0,0,0,0};

    std::string evap_ts_name;

    std::string evap_recovery_pat;

    bool evap_dry_only = false;

    double pan_coeff[12] = {1,1,1,1,1,1,1,1,1,1,1,1};
 
    // -----------------------------------------------------------------------
    // Temperature settings (from [TEMPERATURE] section)
    // -----------------------------------------------------------------------

    int temp_source = 0;

    std::string temp_ts_name;

    FilePathPair temp_file;

    double temp_file_start = 0.0;

    int temp_units = -1;

    int wind_type = 0;

    double wind_speed[12] = {0,0,0,0,0,0,0,0,0,0,0,0};

    double snow_divt = 34.0;

    double snow_ati_wt = 0.5;

    double snow_nrg_ratio = 0.6;

    double snow_lat = 0.0;

    double snow_dtlong = 0.0;

    double snow_elev = 0.0;

    double snow_min_melt = 0.0;

    double snow_max_melt = 0.0;

    double adc_imperv[10] = {1,1,1,1,1,1,1,1,1,1};

    double adc_perv[10] = {1,1,1,1,1,1,1,1,1,1};
 
    // -----------------------------------------------------------------------
    // Report settings (from [REPORT] section)
    // -----------------------------------------------------------------------

    bool rpt_disabled = false;

    int rpt_subcatchments = 1;

    int rpt_nodes = 1;

    int rpt_links = 1;

    bool rpt_input = false;

    bool rpt_continuity = true;

    bool rpt_flowstats = true;

    bool rpt_controls = false;

    bool rpt_averages = false;

    std::vector<std::string> rpt_subcatch_names;

    std::vector<std::string> rpt_node_names;

    std::vector<std::string> rpt_link_names;

    double totalDurationMs() const {
        if (total_duration_ms >= 0.0) return total_duration_ms;
        return std::floor((end_date - start_date) * 86400.0) * 1000.0;
    }
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_SIMULATION_OPTIONS_HPP */