dc/dc3/_subcatch_data_8hpp_source.html

// 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_SUBCATCH_DATA_HPP

#define OPENSWMM_ENGINE_SUBCATCH_DATA_HPP


#include <vector>

#include <string>

#include <cstdint>

#include <algorithm>

#include <limits>


namespace openswmm {


// ============================================================================

// SubcatchData — SoA layout

// ============================================================================


struct SubcatchData {


    // -----------------------------------------------------------------------

    // Static properties — set at parse time

    // -----------------------------------------------------------------------


    std::vector<int> outlet_node;


    std::vector<int> outlet_subcatch;


    std::vector<std::string> outlet_name;


    std::vector<std::string> snowpack_name;


    std::vector<std::string> gage_name;


    std::vector<int> gage;


    std::vector<double> area;


    std::vector<double> width;


    std::vector<double> slope;


    std::vector<double> curb_length;


    std::vector<double> rain_scale_factor;


    std::vector<double> snow_scale_factor;


    std::vector<double> frac_imperv;


    std::vector<double> frac_imperv_no_store;


    std::vector<double> pct_zero;


    std::vector<double> n_imperv;


    std::vector<double> n_perv;


    std::vector<double> ds_imperv;


    std::vector<double> ds_perv;


    // -----------------------------------------------------------------------

    // Inter-subarea routing (from [SUBAREAS] section)

    // -----------------------------------------------------------------------


    std::vector<int> subarea_routing;


    std::vector<double> pct_routed;


    // -----------------------------------------------------------------------

    // Infiltration parameters (per subcatchment)

    // -----------------------------------------------------------------------


    std::vector<int> infil_model;


    std::vector<double> infil_p1;

    std::vector<double> infil_p2;

    std::vector<double> infil_p3;

    std::vector<double> infil_p4;

    std::vector<double> infil_p5;


    // -----------------------------------------------------------------------

    // State variables — updated each timestep

    // -----------------------------------------------------------------------


    std::vector<double> runoff;


    std::vector<double> rainfall;


    std::vector<double> evap_loss;


    std::vector<double> infil_loss;


    std::vector<double> ponded_depth;


    std::vector<double> old_ponded_depth;


    std::vector<double> washoff_vout1;


    std::vector<double> gw_flow;


    std::vector<double> snow_depth;


    std::vector<double> lid_drain_flow;


    // -----------------------------------------------------------------------

    // Previous-step state

    // -----------------------------------------------------------------------


    std::vector<double> old_runoff;


    std::vector<double> old_gw_flow;


    std::vector<double> old_snow_depth;


    std::vector<double> old_lid_drain_flow;


    // -----------------------------------------------------------------------

    // Runon coupling — subcatch-to-subcatch routing

    // -----------------------------------------------------------------------


    std::vector<double> runon_inflow;


    std::vector<double> old_runon_inflow;


    std::vector<double> runon_rate;


    std::vector<double> outfall_runon_vol;


    // -----------------------------------------------------------------------

    // Groundwater surface water head coupling

    // -----------------------------------------------------------------------


    std::vector<double> gw_sw_head;


    std::vector<double> gw_node_avail_flow;


    std::vector<double> gw_max_infil_vol;


    // -----------------------------------------------------------------------

    // Quality washoff output

    // -----------------------------------------------------------------------


    std::vector<double> washoff_load;


    // -----------------------------------------------------------------------

    // Per-subcatch quality state — flat 2D: [subcatch * n_pollutants + pollutant]

    // -----------------------------------------------------------------------


    std::vector<double> conc;


    std::vector<double> conc_old;


    std::vector<double> ponded_qual;


    std::vector<double> runon_qual_rate;

    std::vector<double> lid_drain_runon_qual;


    std::vector<double> subarea_runoff_rate;


    std::vector<double> init_loading;


    int conc_n_pollutants = 0;


    // -----------------------------------------------------------------------

    // Per-object INP comment

    // -----------------------------------------------------------------------


    std::vector<std::string> comments;


    std::vector<std::string> tags;


    // -----------------------------------------------------------------------

    // Report flag — per-object output filter

    // -----------------------------------------------------------------------


    std::vector<char> rpt_flag;


    // -----------------------------------------------------------------------

    // Cumulative statistics

    // -----------------------------------------------------------------------


    std::vector<double> stat_precip_vol;

    std::vector<double> stat_runon_vol;

    std::vector<double> stat_gw_time;

    std::vector<double> stat_evap_vol;

    std::vector<double> stat_infil_vol;

    std::vector<double> stat_imperv_vol;

    std::vector<double> stat_perv_vol;


    std::vector<double> stat_runoff_vol;


    std::vector<double> stat_max_runoff;


    // Gap #63: Per-subcatch groundwater statistics (accumulated each GW step)

    std::vector<double> stat_gw_infil_vol;

    std::vector<double> stat_gw_upper_evap_vol;

    std::vector<double> stat_gw_lower_evap_vol;

    std::vector<double> stat_gw_deep_perc_vol;

    std::vector<double> stat_gw_flow_vol;

    std::vector<double> stat_gw_max_flow;

    std::vector<double> stat_gw_sum_theta;

    std::vector<double> stat_gw_sum_depth;

    std::vector<double> stat_gw_final_theta;

    std::vector<double> stat_gw_final_depth;

    std::vector<long> stat_gw_steps;


    // -----------------------------------------------------------------------

    // Groundwater parameters (from [GROUNDWATER] section)

    // -----------------------------------------------------------------------


    std::vector<int> gw_aquifer;


    std::vector<int> gw_node;


    std::vector<double> gw_surf_elev;


    std::vector<double> gw_a1;


    std::vector<double> gw_b1;


    std::vector<double> gw_a2;


    std::vector<double> gw_b2;


    std::vector<double> gw_a3;


    std::vector<double> gw_tw;


    std::vector<double> gw_hstar;


    std::vector<double> gw_bot_elev;


    std::vector<double> gw_wt_elev;


    std::vector<double> gw_upper_moist;


    // -----------------------------------------------------------------------

    // Snowpack assignment (index into SnowpackStore, -1 = none)

    // -----------------------------------------------------------------------


    std::vector<int> snowpack;


    std::vector<double> snow_net_imperv;


    std::vector<double> snow_net_perv;


    std::vector<double> snow_melt_imperv;


    std::vector<double> snow_melt_perv;


    std::vector<double> snow_melt_age_imperv;


    std::vector<double> snow_melt_age_perv;


    std::vector<double> total_lid_area_ft2;


    std::vector<double> lid_return_to_perv_cfs;


    std::vector<double> lid_drain_runon_cfs;


    // -----------------------------------------------------------------------

    // Cumulative pollutant washoff loads — flat 2D: [subcatch * n_pollutants + pollutant]

    // -----------------------------------------------------------------------


    std::vector<double> total_load;


    int total_load_n_pollutants = 0;


    void resize_total_load(int n_sc, int n_poll) {

        total_load_n_pollutants = n_poll;

        total_load.assign(static_cast<std::size_t>(n_sc) * static_cast<std::size_t>(n_poll), 0.0);

    }


    // -----------------------------------------------------------------------

    // Land-use coverage — flat 2D: [subcatch * n_landuses + landuse]

    // -----------------------------------------------------------------------


    std::vector<double> coverage;


    int coverage_n_landuses = 0;


    std::vector<double> sweep_last_swept;

    std::vector<unsigned char> sweep_now;

    std::vector<double> sweep_last_date;


    void resize_coverage(int n_sc, int n_lu) {

        coverage_n_landuses = n_lu;

        auto sz = static_cast<std::size_t>(n_sc) * static_cast<std::size_t>(n_lu);

        coverage.assign(sz, 0.0);

        sweep_last_swept.assign(sz, 0.0);

    }


    // -----------------------------------------------------------------------

    // Capacity management

    // -----------------------------------------------------------------------


    int count() const noexcept { return static_cast<int>(area.size()); }


    void resize(int n) {

        const auto un = static_cast<std::size_t>(n);


        outlet_node.assign(un, -1);

        outlet_subcatch.assign(un, -1);

        outlet_name.resize(un);

        snowpack_name.resize(un);

        gage_name.resize(un);

        gage.assign(un, -1);

        area.assign(un, 0.0);

        width.assign(un, 0.0);

        slope.assign(un, 0.0);

        curb_length.assign(un, 0.0);

        rain_scale_factor.assign(un, 1.0);

        snow_scale_factor.assign(un, 1.0);

        frac_imperv.assign(un, 0.0);

        frac_imperv_no_store.assign(un, 0.0);

        pct_zero.assign(un, 0.0);

        subarea_runoff_rate.assign(un, 0.0);

        n_imperv.assign(un, 0.013);

        n_perv.assign(un, 0.1);

        ds_imperv.assign(un, 0.0);

        ds_perv.assign(un, 0.0);

        subarea_routing.assign(un, 0); // TO_OUTLET

        pct_routed.assign(un, 0.0);


        infil_model.assign(un, 0);

        infil_p1.assign(un, 0.0);

        infil_p2.assign(un, 0.0);

        infil_p3.assign(un, 0.0);

        infil_p4.assign(un, 0.0);

        infil_p5.assign(un, 0.0);


        runoff.assign(un, 0.0);

        rainfall.assign(un, 0.0);

        evap_loss.assign(un, 0.0);

        infil_loss.assign(un, 0.0);

        ponded_depth.assign(un, 0.0);

        old_ponded_depth.assign(un, 0.0);

        washoff_vout1.assign(un, 0.0);

        gw_flow.assign(un, 0.0);

        snow_depth.assign(un, 0.0);

        lid_drain_flow.assign(un, 0.0);

        old_runoff.assign(un, 0.0);

        old_gw_flow.assign(un, 0.0);

        old_snow_depth.assign(un, 0.0);

        old_lid_drain_flow.assign(un, 0.0);

        runon_inflow.assign(un, 0.0);

        old_runon_inflow.assign(un, 0.0);

        runon_rate.assign(un, 0.0);

        outfall_runon_vol.assign(un, 0.0);

        gw_sw_head.assign(un, 0.0);

        gw_node_avail_flow.assign(un, 0.0);

        gw_max_infil_vol.assign(un, std::numeric_limits<double>::max());


        comments.assign(un, std::string{});

        tags.assign(un, std::string{});


        rpt_flag.assign(un, 0);


        stat_precip_vol.assign(un, 0.0);

        stat_gw_time.assign(un, 0.0);

        stat_runon_vol.assign(un, 0.0);

        stat_evap_vol.assign(un, 0.0);

        stat_infil_vol.assign(un, 0.0);

        stat_imperv_vol.assign(un, 0.0);

        stat_perv_vol.assign(un, 0.0);

        stat_runoff_vol.assign(un, 0.0);

        stat_max_runoff.assign(un, 0.0);

        stat_gw_infil_vol.assign(un, 0.0);

        stat_gw_upper_evap_vol.assign(un, 0.0);

        stat_gw_lower_evap_vol.assign(un, 0.0);

        stat_gw_deep_perc_vol.assign(un, 0.0);

        stat_gw_flow_vol.assign(un, 0.0);

        stat_gw_max_flow.assign(un, 0.0);

        stat_gw_sum_theta.assign(un, 0.0);

        stat_gw_sum_depth.assign(un, 0.0);

        stat_gw_final_theta.assign(un, 0.0);

        stat_gw_final_depth.assign(un, 0.0);

        stat_gw_steps.assign(un, 0L);


        gw_aquifer.assign(un, -1);

        gw_node.assign(un, -1);

        gw_surf_elev.assign(un, 0.0);

        gw_a1.assign(un, 0.0);

        gw_b1.assign(un, 0.0);

        gw_a2.assign(un, 0.0);

        gw_b2.assign(un, 0.0);

        gw_a3.assign(un, 0.0);

        gw_tw.assign(un, 0.0);

        gw_hstar.assign(un, -1.0e10); // constants::MISSING

        gw_bot_elev.assign(un, -1.0e10);

        gw_wt_elev.assign(un, -1.0e10);

        gw_upper_moist.assign(un, -1.0e10);

        snowpack.assign(un, -1);

        snow_net_imperv.assign(un, -1.0);

        snow_net_perv.assign(un, -1.0);

        snow_melt_imperv.assign(un, -1.0);

        snow_melt_perv.assign(un, -1.0);

        snow_melt_age_imperv.assign(un, -1.0);

        snow_melt_age_perv.assign(un, -1.0);

        total_lid_area_ft2.assign(un, 0.0);

        lid_return_to_perv_cfs.assign(un, 0.0);

        lid_drain_runon_cfs.assign(un, 0.0);

    }


    void grow_to(int n) {

        if (n <= count())

            return;

        const auto un = static_cast<std::size_t>(n);

        auto g = [&](auto& vec, auto def) { vec.resize(un, def); };

        g(outlet_node, -1);

        g(outlet_subcatch, -1);

        outlet_name.resize(un);

        snowpack_name.resize(un);

        gage_name.resize(un);

        g(gage, -1);

        g(area, 0.0);

        g(width, 0.0);

        g(slope, 0.0);

        g(curb_length, 0.0);

        g(rain_scale_factor, 1.0);

        g(snow_scale_factor, 1.0);

        g(frac_imperv, 0.0);

        g(frac_imperv_no_store, 0.0);

        g(pct_zero, 0.0);

        g(subarea_runoff_rate, 0.0);

        g(n_imperv, 0.013);

        g(n_perv, 0.1);

        g(ds_imperv, 0.0);

        g(ds_perv, 0.0);

        g(subarea_routing, 0);

        g(pct_routed, 0.0);

        g(infil_model, 0);

        g(infil_p1, 0.0);

        g(infil_p2, 0.0);

        g(infil_p3, 0.0);

        g(infil_p4, 0.0);

        g(infil_p5, 0.0);

        g(runoff, 0.0);

        g(rainfall, 0.0);

        g(evap_loss, 0.0);

        g(infil_loss, 0.0);

        g(ponded_depth, 0.0);

        g(old_ponded_depth, 0.0);

        g(washoff_vout1, 0.0);

        g(gw_flow, 0.0);

        g(snow_depth, 0.0);

        g(lid_drain_flow, 0.0);

        g(old_runoff, 0.0);

        g(old_gw_flow, 0.0);

        g(old_snow_depth, 0.0);

        g(old_lid_drain_flow, 0.0);

        g(runon_inflow, 0.0);

        g(old_runon_inflow, 0.0);

        g(runon_rate, 0.0);

        g(gw_sw_head, 0.0);

        g(gw_node_avail_flow, 0.0);

        g(gw_max_infil_vol, std::numeric_limits<double>::max());

        g(outfall_runon_vol, 0.0);

        comments.resize(un, std::string{});

        tags.resize(un, std::string{});


        g(rpt_flag, static_cast<char>(0));

        g(stat_precip_vol, 0.0);

        g(stat_gw_time, 0.0);

        g(stat_runon_vol, 0.0);

        g(stat_evap_vol, 0.0);

        g(stat_infil_vol, 0.0);

        g(stat_imperv_vol, 0.0);

        g(stat_perv_vol, 0.0);

        g(stat_runoff_vol, 0.0);

        g(stat_max_runoff, 0.0);

        g(stat_gw_infil_vol, 0.0);

        g(stat_gw_upper_evap_vol, 0.0);

        g(stat_gw_lower_evap_vol, 0.0);

        g(stat_gw_deep_perc_vol, 0.0);

        g(stat_gw_flow_vol, 0.0);

        g(stat_gw_max_flow, 0.0);

        g(stat_gw_sum_theta, 0.0);

        g(stat_gw_sum_depth, 0.0);

        g(stat_gw_final_theta, 0.0);

        g(stat_gw_final_depth, 0.0);

        stat_gw_steps.resize(un, 0L);

        g(gw_aquifer, -1);

        g(gw_node, -1);

        g(gw_surf_elev, 0.0);

        g(gw_a1, 0.0);

        g(gw_b1, 0.0);

        g(gw_a2, 0.0);

        g(gw_b2, 0.0);

        g(gw_a3, 0.0);

        g(gw_tw, 0.0);

        g(gw_hstar, -1.0e10);

        g(gw_bot_elev, -1.0e10);

        g(gw_wt_elev, -1.0e10);

        g(gw_upper_moist, -1.0e10);

        g(snowpack, -1);

        g(snow_net_imperv, -1.0);

        g(snow_net_perv, -1.0);

        g(snow_melt_imperv, -1.0);

        g(snow_melt_perv, -1.0);

        g(snow_melt_age_imperv, -1.0);

        g(snow_melt_age_perv, -1.0);

        g(total_lid_area_ft2, 0.0);

        g(lid_return_to_perv_cfs, 0.0);

        g(lid_drain_runon_cfs, 0.0);

        // Note: conc, conc_old, ponded_qual, washoff_load handled by resize_quality()

        // Note: coverage, total_load handled separately

    }


    void reserve_to(int n) {

        if (n <= 0)

            return;

        const auto un = static_cast<std::size_t>(n);

        if (outlet_node.capacity() >= un)

            return;

        auto r = [&](auto& vec) { vec.reserve(un); };

        r(outlet_node);

        r(outlet_subcatch);

        r(gage);

        r(area);

        r(width);

        r(slope);

        r(curb_length);

        r(rain_scale_factor);

        r(snow_scale_factor);

        r(frac_imperv);

        r(frac_imperv_no_store);

        r(pct_zero);

        r(subarea_runoff_rate);

        r(n_imperv);

        r(n_perv);

        r(ds_imperv);

        r(ds_perv);

        r(subarea_routing);

        r(pct_routed);

        r(infil_model);

        r(infil_p1);

        r(infil_p2);

        r(infil_p3);

        r(infil_p4);

        r(infil_p5);

        r(runoff);

        r(rainfall);

        r(evap_loss);

        r(infil_loss);

        r(ponded_depth);

        r(gw_flow);

        r(snow_depth);

        r(lid_drain_flow);

        r(old_runoff);

        r(old_gw_flow);

        r(old_snow_depth);

        r(old_lid_drain_flow);

        r(runon_inflow);

        r(old_runon_inflow);

        r(runon_rate);

        r(gw_sw_head);

        r(gw_node_avail_flow);

        r(gw_max_infil_vol);

        r(outfall_runon_vol);

        r(rpt_flag);

        r(stat_precip_vol);

        r(stat_gw_time);

        r(stat_runon_vol);

        r(stat_evap_vol);

        r(stat_infil_vol);

        r(stat_imperv_vol);

        r(stat_perv_vol);

        r(stat_runoff_vol);

        r(stat_max_runoff);

        r(stat_gw_infil_vol);

        r(stat_gw_upper_evap_vol);

        r(stat_gw_lower_evap_vol);

        r(stat_gw_deep_perc_vol);

        r(stat_gw_flow_vol);

        r(stat_gw_max_flow);

        r(stat_gw_sum_theta);

        r(stat_gw_sum_depth);

        r(stat_gw_final_theta);

        r(stat_gw_final_depth);

        r(gw_aquifer);

        r(gw_node);

        r(gw_surf_elev);

        r(gw_a1);

        r(gw_b1);

        r(gw_a2);

        r(gw_b2);

        r(gw_a3);

        r(gw_tw);

        r(gw_hstar);

        r(gw_bot_elev);

        r(gw_wt_elev);

        r(gw_upper_moist);

        r(snowpack);

        r(snow_net_imperv);

        r(snow_net_perv);

        r(snow_melt_imperv);

        r(snow_melt_perv);

        r(snow_melt_age_imperv);

        r(snow_melt_age_perv);

        r(total_lid_area_ft2);

        r(lid_return_to_perv_cfs);

        r(lid_drain_runon_cfs);

        r(outlet_name);

        r(gage_name);

        r(comments);

        r(tags);

        r(stat_gw_steps);

    }


    void erase_at(int idx) {

        const auto ui = static_cast<std::size_t>(idx);

        auto e = [&](auto& v) {

            if (ui < v.size())

                v.erase(v.begin() + static_cast<std::ptrdiff_t>(idx));

        };


        e(outlet_node);

        e(outlet_subcatch);

        e(outlet_name);

        e(gage);

        e(area);

        e(width);

        e(slope);

        e(curb_length);

        e(rain_scale_factor);

        e(snow_scale_factor);

        e(frac_imperv);

        e(frac_imperv_no_store);

        e(pct_zero);

        e(subarea_runoff_rate);

        e(n_imperv);

        e(n_perv);

        e(ds_imperv);

        e(ds_perv);

        e(subarea_routing);

        e(pct_routed);


        e(infil_model);

        e(infil_p1);

        e(infil_p2);

        e(infil_p3);

        e(infil_p4);

        e(infil_p5);


        e(runoff);

        e(rainfall);

        e(evap_loss);

        e(infil_loss);

        e(ponded_depth);

        e(gw_flow);

        e(snow_depth);

        e(lid_drain_flow);

        e(old_runoff);

        e(old_gw_flow);

        e(old_snow_depth);

        e(old_lid_drain_flow);

        e(runon_inflow);

        e(old_runon_inflow);

        e(runon_rate);

        e(outfall_runon_vol);

        e(gw_sw_head);

        e(gw_node_avail_flow);

        e(gw_max_infil_vol);

        e(comments);

        e(tags);

        e(rpt_flag);


        e(stat_precip_vol);

        e(stat_gw_time);

        e(stat_runon_vol);

        e(stat_evap_vol);

        e(stat_infil_vol);

        e(stat_imperv_vol);

        e(stat_perv_vol);

        e(stat_runoff_vol);

        e(stat_max_runoff);

        e(stat_gw_infil_vol);

        e(stat_gw_upper_evap_vol);

        e(stat_gw_lower_evap_vol);

        e(stat_gw_deep_perc_vol);

        e(stat_gw_flow_vol);

        e(stat_gw_max_flow);

        e(stat_gw_sum_theta);

        e(stat_gw_sum_depth);

        e(stat_gw_final_theta);

        e(stat_gw_final_depth);

        e(stat_gw_steps);


        e(gw_aquifer);

        e(gw_node);

        e(gw_surf_elev);

        e(gw_a1);

        e(gw_b1);

        e(gw_a2);

        e(gw_b2);

        e(gw_a3);

        e(gw_tw);

        e(gw_hstar);

        e(gw_bot_elev);

        e(gw_wt_elev);

        e(gw_upper_moist);

        e(snowpack);

        e(snow_net_imperv);

        e(snow_net_perv);

        e(snow_melt_imperv);

        e(snow_melt_perv);

        e(snow_melt_age_imperv);

        e(snow_melt_age_perv);

        e(total_lid_area_ft2);

        e(lid_return_to_perv_cfs);

        e(lid_drain_runon_cfs);


        // Flat 2D quality arrays: [sc * np + p]

        if (conc_n_pollutants > 0) {

            const auto np = static_cast<std::size_t>(conc_n_pollutants);

            const auto base = ui * np;

            auto erase2d = [&](auto& v) {

                if (base + np <= v.size())

                    v.erase(v.begin() + static_cast<std::ptrdiff_t>(base),

                            v.begin() + static_cast<std::ptrdiff_t>(base + np));

            };

            erase2d(conc);

            erase2d(conc_old);

            erase2d(init_loading);

            erase2d(ponded_qual);

            erase2d(runon_qual_rate);

            erase2d(lid_drain_runon_qual);

            erase2d(washoff_load);

        }


        // Flat 2D total load: [sc * np + p]

        if (total_load_n_pollutants > 0) {

            const auto np = static_cast<std::size_t>(total_load_n_pollutants);

            const auto base = ui * np;

            if (base + np <= total_load.size())

                total_load.erase(total_load.begin() + static_cast<std::ptrdiff_t>(base),

                                 total_load.begin() + static_cast<std::ptrdiff_t>(base + np));

        }


        // Flat 2D coverage/sweep matrices: [sc * n_lu + lu]

        if (coverage_n_landuses > 0) {

            const auto nlu = static_cast<std::size_t>(coverage_n_landuses);

            const auto base = ui * nlu;

            auto erase2d = [&](auto& v) {

                if (base + nlu <= v.size())

                    v.erase(v.begin() + static_cast<std::ptrdiff_t>(base),

                            v.begin() + static_cast<std::ptrdiff_t>(base + nlu));

            };

            erase2d(coverage);

            erase2d(sweep_last_swept);

        }

    }


    void resize_quality(int n_pollutants) {

        conc_n_pollutants = n_pollutants;

        if (n_pollutants > 0) {

            auto total = static_cast<std::size_t>(count()) * static_cast<std::size_t>(n_pollutants);

            conc.assign(total, 0.0);

            conc_old.assign(total, 0.0);

            init_loading.assign(total, 0.0);

            ponded_qual.assign(total, 0.0);

            runon_qual_rate.assign(total, 0.0);

            lid_drain_runon_qual.assign(total, 0.0);

            washoff_load.assign(total, 0.0);

        }

    }


    void resize_washoff_load(int n_pollutants) {

        if (n_pollutants > 0) {

            washoff_load.assign(

                static_cast<std::size_t>(count()) * static_cast<std::size_t>(n_pollutants), 0.0);

        }

    }


    void shrink_to_fit() {

        outlet_node.shrink_to_fit();

        outlet_subcatch.shrink_to_fit();

        outlet_name.shrink_to_fit();

        gage.shrink_to_fit();

        area.shrink_to_fit();

        width.shrink_to_fit();

        slope.shrink_to_fit();

        curb_length.shrink_to_fit();

        rain_scale_factor.shrink_to_fit();

        snow_scale_factor.shrink_to_fit();

        frac_imperv.shrink_to_fit();

        frac_imperv_no_store.shrink_to_fit();

        pct_zero.shrink_to_fit();

        subarea_runoff_rate.shrink_to_fit();

        n_imperv.shrink_to_fit();

        n_perv.shrink_to_fit();

        ds_imperv.shrink_to_fit();

        ds_perv.shrink_to_fit();

        subarea_routing.shrink_to_fit();

        pct_routed.shrink_to_fit();


        infil_model.shrink_to_fit();

        infil_p1.shrink_to_fit();

        infil_p2.shrink_to_fit();

        infil_p3.shrink_to_fit();

        infil_p4.shrink_to_fit();

        infil_p5.shrink_to_fit();


        runoff.shrink_to_fit();

        rainfall.shrink_to_fit();

        evap_loss.shrink_to_fit();

        infil_loss.shrink_to_fit();

        ponded_depth.shrink_to_fit();

        gw_flow.shrink_to_fit();

        snow_depth.shrink_to_fit();

        lid_drain_flow.shrink_to_fit();

        old_runoff.shrink_to_fit();

        old_gw_flow.shrink_to_fit();

        old_snow_depth.shrink_to_fit();

        old_lid_drain_flow.shrink_to_fit();

        runon_inflow.shrink_to_fit();

        old_runon_inflow.shrink_to_fit();

        runon_rate.shrink_to_fit();

        outfall_runon_vol.shrink_to_fit();

        gw_sw_head.shrink_to_fit();

        gw_node_avail_flow.shrink_to_fit();

        gw_max_infil_vol.shrink_to_fit();


        comments.shrink_to_fit();

        tags.shrink_to_fit();


        rpt_flag.shrink_to_fit();


        stat_precip_vol.shrink_to_fit();

        stat_gw_time.shrink_to_fit();

        stat_runon_vol.shrink_to_fit();

        stat_evap_vol.shrink_to_fit();

        stat_infil_vol.shrink_to_fit();

        stat_imperv_vol.shrink_to_fit();

        stat_perv_vol.shrink_to_fit();

        stat_runoff_vol.shrink_to_fit();

        stat_max_runoff.shrink_to_fit();


        gw_aquifer.shrink_to_fit();

        gw_node.shrink_to_fit();

        gw_surf_elev.shrink_to_fit();

        gw_a1.shrink_to_fit();

        gw_b1.shrink_to_fit();

        gw_a2.shrink_to_fit();

        gw_b2.shrink_to_fit();

        gw_a3.shrink_to_fit();

        gw_tw.shrink_to_fit();

        gw_hstar.shrink_to_fit();

        gw_bot_elev.shrink_to_fit();

        gw_wt_elev.shrink_to_fit();

        gw_upper_moist.shrink_to_fit();

        snowpack.shrink_to_fit();

        snow_net_imperv.shrink_to_fit();

        snow_net_perv.shrink_to_fit();

        snow_melt_imperv.shrink_to_fit();

        snow_melt_perv.shrink_to_fit();

        snow_melt_age_imperv.shrink_to_fit();

        snow_melt_age_perv.shrink_to_fit();


        conc.shrink_to_fit();

        conc_old.shrink_to_fit();

        ponded_qual.shrink_to_fit();

        runon_qual_rate.shrink_to_fit();

        lid_drain_runon_qual.shrink_to_fit();

        washoff_load.shrink_to_fit();

        total_load.shrink_to_fit();

        coverage.shrink_to_fit();

        sweep_last_swept.shrink_to_fit();

    }


    void save_state() noexcept {

        std::copy(runoff.begin(), runoff.end(), old_runoff.begin());

        std::copy(runon_inflow.begin(), runon_inflow.end(), old_runon_inflow.begin());

        std::copy(conc.begin(), conc.end(), conc_old.begin());

        std::copy(ponded_depth.begin(), ponded_depth.end(), old_ponded_depth.begin());

    }


    void reset_state() noexcept {

        std::fill(runoff.begin(), runoff.end(), 0.0);

        std::fill(rainfall.begin(), rainfall.end(), 0.0);

        std::fill(snow_net_imperv.begin(), snow_net_imperv.end(), -1.0);

        std::fill(snow_net_perv.begin(), snow_net_perv.end(), -1.0);

        std::fill(snow_melt_imperv.begin(), snow_melt_imperv.end(), -1.0);

        std::fill(snow_melt_perv.begin(), snow_melt_perv.end(), -1.0);

        std::fill(snow_melt_age_imperv.begin(), snow_melt_age_imperv.end(), -1.0);

        std::fill(snow_melt_age_perv.begin(), snow_melt_age_perv.end(), -1.0);

        std::fill(evap_loss.begin(), evap_loss.end(), 0.0);

        std::fill(infil_loss.begin(), infil_loss.end(), 0.0);

        std::fill(ponded_depth.begin(), ponded_depth.end(), 0.0);

        std::fill(old_runoff.begin(), old_runoff.end(), 0.0);

        std::fill(old_gw_flow.begin(), old_gw_flow.end(), 0.0);

        std::fill(snow_depth.begin(), snow_depth.end(), 0.0);

        std::fill(old_snow_depth.begin(), old_snow_depth.end(), 0.0);

        std::fill(lid_drain_flow.begin(), lid_drain_flow.end(), 0.0);

        std::fill(old_lid_drain_flow.begin(), old_lid_drain_flow.end(), 0.0);

        std::fill(runon_inflow.begin(), runon_inflow.end(), 0.0);

        std::fill(old_runon_inflow.begin(), old_runon_inflow.end(), 0.0);

        std::fill(runon_rate.begin(), runon_rate.end(), 0.0);

        std::fill(gw_sw_head.begin(), gw_sw_head.end(), 0.0);

        std::fill(gw_node_avail_flow.begin(), gw_node_avail_flow.end(), 0.0);

        std::fill(washoff_load.begin(), washoff_load.end(), 0.0);

        std::fill(conc.begin(), conc.end(), 0.0);

        std::fill(conc_old.begin(), conc_old.end(), 0.0);

    }


};


} /* namespace openswmm */


#endif /* OPENSWMM_ENGINE_SUBCATCH_DATA_HPP */

openswmm
Definition ExchangeLaw.hpp:60

openswmm::SubcatchData
Structure-of-Arrays storage for all subcatchments.
Definition SubcatchData.hpp:57

openswmm::SubcatchData::gage
std::vector< int > gage
Rain gage index for this subcatchment.
Definition SubcatchData.hpp:106

openswmm::SubcatchData::total_lid_area_ft2
std::vector< double > total_lid_area_ft2
Total LID area for this subcatchment (ft²).
Definition SubcatchData.hpp:647

openswmm::SubcatchData::reset_state
void reset_state() noexcept
Clear the subcatchment dynamic arrays visited here.
Definition SubcatchData.hpp:1418

openswmm::SubcatchData::infil_model
std::vector< int > infil_model
Infiltration model: 0=HORTON, 1=MOD_HORTON, 2=GREEN_AMPT, 3=MOD_GREEN_AMPT, 4=CURVE_NUMBER.
Definition SubcatchData.hpp:235

openswmm::SubcatchData::old_snow_depth
std::vector< double > old_snow_depth
Snow depth at the previous runoff evaluation (for interpolation).
Definition SubcatchData.hpp:333

openswmm::SubcatchData::gw_b2
std::vector< double > gw_b2
Groundwater flow exponent B2.
Definition SubcatchData.hpp:548

openswmm::SubcatchData::snow_net_perv
std::vector< double > snow_net_perv
Snow-modified net precipitation for pervious subarea (ft/sec).
Definition SubcatchData.hpp:596

openswmm::SubcatchData::stat_gw_infil_vol
std::vector< double > stat_gw_infil_vol
Cumulative infiltration to GW (ft³)
Definition SubcatchData.hpp:513

openswmm::SubcatchData::snowpack_name
std::vector< std::string > snowpack_name
Snow pack name string for deferred resolution.
Definition SubcatchData.hpp:91

openswmm::SubcatchData::stat_runon_vol
std::vector< double > stat_runon_vol
Cumulative received runon volume (ft3).
Definition SubcatchData.hpp:493

openswmm::SubcatchData::total_load_n_pollutants
int total_load_n_pollutants
Number of pollutants in total_load matrix.
Definition SubcatchData.hpp:679

openswmm::SubcatchData::outfall_runon_vol
std::vector< double > outfall_runon_vol
Gap #28: accumulated outfall-routed volume (ft³) between runoff steps.
Definition SubcatchData.hpp:360

openswmm::SubcatchData::stat_precip_vol
std::vector< double > stat_precip_vol
Total precipitation volume (project volume units).
Definition SubcatchData.hpp:492

openswmm::SubcatchData::gw_surf_elev
std::vector< double > gw_surf_elev
Surface elevation for groundwater calculations.
Definition SubcatchData.hpp:536

openswmm::SubcatchData::gw_sw_head
std::vector< double > gw_sw_head
Surface water head at GW receiving node (project length units).
Definition SubcatchData.hpp:368

openswmm::SubcatchData::init_loading
std::vector< double > init_loading
The [LOADINGS] initial surface buildup, mass per unit AREA.
Definition SubcatchData.hpp:452

openswmm::SubcatchData::resize_quality
void resize_quality(int n_pollutants)
Set the pollutant stride and replace positive-sized quality arrays.
Definition SubcatchData.hpp:1268

openswmm::SubcatchData::slope
std::vector< double > slope
Average slope of catchment (fraction).
Definition SubcatchData.hpp:124

openswmm::SubcatchData::infil_p1
std::vector< double > infil_p1
Infiltration param 1: f0 (Horton), suction (GA), CN (CN).
Definition SubcatchData.hpp:238

openswmm::SubcatchData::old_gw_flow
std::vector< double > old_gw_flow
GW flow at the previous runoff evaluation (for interpolation).
Definition SubcatchData.hpp:330

openswmm::SubcatchData::snowpack
std::vector< int > snowpack
Snowpack index for this subcatchment (-1 = none).
Definition SubcatchData.hpp:578

openswmm::SubcatchData::gage_name
std::vector< std::string > gage_name
Rain gage name string for deferred resolution.
Definition SubcatchData.hpp:100

openswmm::SubcatchData::gw_tw
std::vector< double > gw_tw
[GROUNDWATER] Dsw: fixed surface-water depth (project length units, 0 = live node depth).
Definition SubcatchData.hpp:554

openswmm::SubcatchData::old_ponded_depth
std::vector< double > old_ponded_depth
Ponded depth at the START of the runoff step (project length).
Definition SubcatchData.hpp:291

openswmm::SubcatchData::evap_loss
std::vector< double > evap_loss
Current evaporation loss rate (project length/time units).
Definition SubcatchData.hpp:268

openswmm::SubcatchData::gw_wt_elev
std::vector< double > gw_wt_elev
[GROUNDWATER] Wgw: initial water-table elevation override; MISSING = the aquifer's.
Definition SubcatchData.hpp:568

openswmm::SubcatchData::old_runoff
std::vector< double > old_runoff
Runoff at the previous timestep.
Definition SubcatchData.hpp:327

openswmm::SubcatchData::gw_node_avail_flow
std::vector< double > gw_node_avail_flow
Available node flow for GW negative flow limit (cfs/ft2).
Definition SubcatchData.hpp:371

openswmm::SubcatchData::stat_infil_vol
std::vector< double > stat_infil_vol
Cumulative infiltration volume (ft3)
Definition SubcatchData.hpp:496

openswmm::SubcatchData::gw_flow
std::vector< double > gw_flow
Groundwater outflow rate (project flow units).
Definition SubcatchData.hpp:308

openswmm::SubcatchData::stat_evap_vol
std::vector< double > stat_evap_vol
Cumulative evaporation volume (ft3)
Definition SubcatchData.hpp:495

openswmm::SubcatchData::lid_drain_flow
std::vector< double > lid_drain_flow
Total LID drain outflow (cfs) over the current runoff step.
Definition SubcatchData.hpp:320

openswmm::SubcatchData::stat_gw_sum_theta
std::vector< double > stat_gw_sum_theta
Time integral of upper-zone theta (seconds)
Definition SubcatchData.hpp:519

openswmm::SubcatchData::sweep_now
std::vector< unsigned char > sweep_now
Definition SubcatchData.hpp:718

openswmm::SubcatchData::snow_melt_imperv
std::vector< double > snow_melt_imperv
The MELT-ONLY part of snow_net_imperv (ft/sec).
Definition SubcatchData.hpp:617

openswmm::SubcatchData::stat_perv_vol
std::vector< double > stat_perv_vol
Cumulative pervious runoff volume (ft3)
Definition SubcatchData.hpp:498

openswmm::SubcatchData::snow_scale_factor
std::vector< double > snow_scale_factor
Subcatchment-level snowfall scale factor (default 1.0 = no scaling).
Definition SubcatchData.hpp:156

openswmm::SubcatchData::reserve_to
void reserve_to(int n)
Reserve capacity for n subcatchments without changing count().
Definition SubcatchData.hpp:1001

openswmm::SubcatchData::area
std::vector< double > area
Subcatchment area (project area units).
Definition SubcatchData.hpp:112

openswmm::SubcatchData::gw_a3
std::vector< double > gw_a3
Groundwater flow coefficient A3.
Definition SubcatchData.hpp:551

openswmm::SubcatchData::old_lid_drain_flow
std::vector< double > old_lid_drain_flow
LID drain outflow at the previous runoff evaluation (for interpolation).
Definition SubcatchData.hpp:336

openswmm::SubcatchData::outlet_subcatch
std::vector< int > outlet_subcatch
Index of the subcatch that receives overflow (-1 if none).
Definition SubcatchData.hpp:75

openswmm::SubcatchData::gw_hstar
std::vector< double > gw_hstar
[GROUNDWATER] Egwt: threshold groundwater table elevation (project length units) below which no later...
Definition SubcatchData.hpp:562

openswmm::SubcatchData::coverage_n_landuses
int coverage_n_landuses
Number of landuses stored in the coverage and sweep matrices.
Definition SubcatchData.hpp:707

openswmm::SubcatchData::comments
std::vector< std::string > comments
Object comment from the INP file (';'-prefixed lines immediately above this subcatchment's data row),...
Definition SubcatchData.hpp:466

openswmm::SubcatchData::stat_gw_upper_evap_vol
std::vector< double > stat_gw_upper_evap_vol
Cumulative upper zone evap (ft³)
Definition SubcatchData.hpp:514

openswmm::SubcatchData::old_runon_inflow
std::vector< double > old_runon_inflow
Previous-step runon inflow (for interpolation).
Definition SubcatchData.hpp:347

openswmm::SubcatchData::stat_runoff_vol
std::vector< double > stat_runoff_vol
Total runoff volume (project volume units).
Definition SubcatchData.hpp:504

openswmm::SubcatchData::n_imperv
std::vector< double > n_imperv
Manning's n for impervious area.
Definition SubcatchData.hpp:189

openswmm::SubcatchData::lid_drain_runon_cfs
std::vector< double > lid_drain_runon_cfs
LID drain flow routed to a target subcatchment (CFS).
Definition SubcatchData.hpp:666

openswmm::SubcatchData::n_perv
std::vector< double > n_perv
Manning's n for pervious area.
Definition SubcatchData.hpp:195

openswmm::SubcatchData::infil_p4
std::vector< double > infil_p4
Infiltration param 4: dry time (Horton), 0 (GA/CN).
Definition SubcatchData.hpp:244

openswmm::SubcatchData::resize_coverage
void resize_coverage(int n_sc, int n_lu)
Resize the coverage and sweep matrices.
Definition SubcatchData.hpp:730

openswmm::SubcatchData::lid_return_to_perv_cfs
std::vector< double > lid_return_to_perv_cfs
LID surface return flow to pervious area (CFS).
Definition SubcatchData.hpp:656

openswmm::SubcatchData::tags
std::vector< std::string > tags
Per-object tag from the INP [TAGS] section.
Definition SubcatchData.hpp:474

openswmm::SubcatchData::runon_qual_rate
std::vector< double > runon_qual_rate
Incoming run-on pollutant mass RATE per (subcatch, pollutant), mg/sec.
Definition SubcatchData.hpp:421

openswmm::SubcatchData::runon_inflow
std::vector< double > runon_inflow
Runoff inflow from upstream subcatchments (project flow units).
Definition SubcatchData.hpp:344

openswmm::SubcatchData::runon_rate
std::vector< double > runon_rate
Legacy Subcatch.runon: the run-on as a depth rate (ft/s).
Definition SubcatchData.hpp:355

openswmm::SubcatchData::rain_scale_factor
std::vector< double > rain_scale_factor
Subcatchment-level rainfall scale factor (default 1.0 = no scaling).
Definition SubcatchData.hpp:142

openswmm::SubcatchData::stat_gw_final_theta
std::vector< double > stat_gw_final_theta
Upper-zone theta at last GW step.
Definition SubcatchData.hpp:521

openswmm::SubcatchData::gw_a2
std::vector< double > gw_a2
Groundwater flow coefficient A2.
Definition SubcatchData.hpp:545

openswmm::SubcatchData::stat_gw_lower_evap_vol
std::vector< double > stat_gw_lower_evap_vol
Cumulative lower zone evap (ft³)
Definition SubcatchData.hpp:515

openswmm::SubcatchData::conc_n_pollutants
int conc_n_pollutants
Number of pollutants in the quality arrays.
Definition SubcatchData.hpp:455

openswmm::SubcatchData::outlet_name
std::vector< std::string > outlet_name
Outlet name string for deferred resolution.
Definition SubcatchData.hpp:82

openswmm::SubcatchData::stat_gw_deep_perc_vol
std::vector< double > stat_gw_deep_perc_vol
Cumulative deep percolation (ft³)
Definition SubcatchData.hpp:516

openswmm::SubcatchData::snow_melt_age_imperv
std::vector< double > snow_melt_age_imperv
S2b — WATER AGE of the meltwater in snow_melt_imperv (sec).
Definition SubcatchData.hpp:635

openswmm::SubcatchData::stat_imperv_vol
std::vector< double > stat_imperv_vol
Cumulative impervious runoff volume (ft3)
Definition SubcatchData.hpp:497

openswmm::SubcatchData::ponded_qual
std::vector< double > ponded_qual
Ponded surface water quality mass per (subcatch, pollutant).
Definition SubcatchData.hpp:409

openswmm::SubcatchData::pct_routed
std::vector< double > pct_routed
Fraction of runoff routed between subareas (0–1).
Definition SubcatchData.hpp:228

openswmm::SubcatchData::infil_p2
std::vector< double > infil_p2
Infiltration param 2: fmin (Horton), conductivity (GA), unused (CN).
Definition SubcatchData.hpp:240

openswmm::SubcatchData::snow_melt_age_perv
std::vector< double > snow_melt_age_perv
S2b — water age of the meltwater in snow_melt_perv (sec). See above.
Definition SubcatchData.hpp:638

openswmm::SubcatchData::sweep_last_date
std::vector< double > sweep_last_date
Definition SubcatchData.hpp:723

openswmm::SubcatchData::stat_gw_max_flow
std::vector< double > stat_gw_max_flow
Peak lateral GW outflow (CFS)
Definition SubcatchData.hpp:518

openswmm::SubcatchData::gw_a1
std::vector< double > gw_a1
Groundwater flow coefficient A1.
Definition SubcatchData.hpp:539

openswmm::SubcatchData::resize
void resize(int n)
Replace the base subcatchment store with a requested row count.
Definition SubcatchData.hpp:760

openswmm::SubcatchData::stat_gw_final_depth
std::vector< double > stat_gw_final_depth
Water table elevation at last GW step (ft)
Definition SubcatchData.hpp:522

openswmm::SubcatchData::snow_net_imperv
std::vector< double > snow_net_imperv
Snow-modified net precipitation for impervious subareas (ft/sec).
Definition SubcatchData.hpp:587

openswmm::SubcatchData::ds_perv
std::vector< double > ds_perv
Depression storage depth for pervious area (project length units).
Definition SubcatchData.hpp:207

openswmm::SubcatchData::width
std::vector< double > width
Width of overland flow path (project length units).
Definition SubcatchData.hpp:118

openswmm::SubcatchData::infil_loss
std::vector< double > infil_loss
Current infiltration loss rate (project length/time units).
Definition SubcatchData.hpp:274

openswmm::SubcatchData::lid_drain_runon_qual
std::vector< double > lid_drain_runon_qual
Definition SubcatchData.hpp:426

openswmm::SubcatchData::frac_imperv_no_store
std::vector< double > frac_imperv_no_store
Fraction of impervious area with no depression storage (0–1).
Definition SubcatchData.hpp:168

openswmm::SubcatchData::gw_upper_moist
std::vector< double > gw_upper_moist
[GROUNDWATER] Umc: initial upper-zone moisture override; MISSING = the aquifer's.
Definition SubcatchData.hpp:571

openswmm::SubcatchData::conc_old
std::vector< double > conc_old
Previous-step quality in subcatchment runoff.
Definition SubcatchData.hpp:401

openswmm::SubcatchData::count
int count() const noexcept
Count subcatchment rows from the area column.
Definition SubcatchData.hpp:746

openswmm::SubcatchData::erase_at
void erase_at(int idx)
Erase one subcatchment row from the columns visited by this helper.
Definition SubcatchData.hpp:1113

openswmm::SubcatchData::gw_max_infil_vol
std::vector< double > gw_max_infil_vol
Gap #40: max infiltration volume (ft) upper GW zone can accept next step.
Definition SubcatchData.hpp:379

openswmm::SubcatchData::resize_total_load
void resize_total_load(int n_sc, int n_poll)
Replace cumulative subcatchment pollutant-load storage.
Definition SubcatchData.hpp:691

openswmm::SubcatchData::rpt_flag
std::vector< char > rpt_flag
Whether this subcatchment is included in report/output (0=no, 1=yes).
Definition SubcatchData.hpp:482

openswmm::SubcatchData::washoff_vout1
std::vector< double > washoff_vout1
This runoff step's PRE-LID outflow volume, ft³ (legacy vOut1).
Definition SubcatchData.hpp:302

openswmm::SubcatchData::gw_aquifer
std::vector< int > gw_aquifer
Aquifer index for this subcatchment (-1 = none).
Definition SubcatchData.hpp:530

openswmm::SubcatchData::outlet_node
std::vector< int > outlet_node
Index of the drain-to node or subcatchment.
Definition SubcatchData.hpp:69

openswmm::SubcatchData::grow_to
void grow_to(int n)
Extend base subcatchment columns while preserving existing prefixes.
Definition SubcatchData.hpp:875

openswmm::SubcatchData::gw_bot_elev
std::vector< double > gw_bot_elev
[GROUNDWATER] Ebot: aquifer bottom elevation override; MISSING = the aquifer's.
Definition SubcatchData.hpp:565

openswmm::SubcatchData::runoff
std::vector< double > runoff
Current total runoff flow rate (project flow units).
Definition SubcatchData.hpp:256

openswmm::SubcatchData::shrink_to_fit
void shrink_to_fit()
Release excess vector capacity accumulated during parsing.
Definition SubcatchData.hpp:1300

openswmm::SubcatchData::coverage
std::vector< double > coverage
Coverage fraction per (subcatchment x landuse).
Definition SubcatchData.hpp:704

openswmm::SubcatchData::snow_depth
std::vector< double > snow_depth
Area-weighted snow pack SWE depth (ft), end of runoff step.
Definition SubcatchData.hpp:314

openswmm::SubcatchData::stat_max_runoff
std::vector< double > stat_max_runoff
Maximum reported runoff rate (project flow units).
Definition SubcatchData.hpp:510

openswmm::SubcatchData::infil_p5
std::vector< double > infil_p5
Infiltration param 5: max infil (Horton), 0 (GA/CN).
Definition SubcatchData.hpp:246

openswmm::SubcatchData::stat_gw_steps
std::vector< long > stat_gw_steps
Step count for GW averages.
Definition SubcatchData.hpp:523

openswmm::SubcatchData::stat_gw_time
std::vector< double > stat_gw_time
Elapsed groundwater time (seconds).
Definition SubcatchData.hpp:494

openswmm::SubcatchData::rainfall
std::vector< double > rainfall
Current total rainfall depth rate (project length/time units).
Definition SubcatchData.hpp:262

openswmm::SubcatchData::washoff_load
std::vector< double > washoff_load
Washoff mass rate per (subcatch, pollutant) (mass/sec).
Definition SubcatchData.hpp:387

openswmm::SubcatchData::ponded_depth
std::vector< double > ponded_depth
Current total ponded depth over subcatchment (project length units).
Definition SubcatchData.hpp:280

openswmm::SubcatchData::save_state
void save_state() noexcept
Snapshot runoff-step discharge, run-on, concentration and ponded depth.
Definition SubcatchData.hpp:1403

openswmm::SubcatchData::snow_melt_perv
std::vector< double > snow_melt_perv
The melt-only part of snow_net_perv (ft/sec). See above.
Definition SubcatchData.hpp:620

openswmm::SubcatchData::frac_imperv
std::vector< double > frac_imperv
Fraction of area that is impervious (0–1).
Definition SubcatchData.hpp:162

openswmm::SubcatchData::gw_node
std::vector< int > gw_node
Receiving node index for groundwater flow (-1 = none).
Definition SubcatchData.hpp:533

openswmm::SubcatchData::gw_b1
std::vector< double > gw_b1
Groundwater flow exponent B1.
Definition SubcatchData.hpp:542

openswmm::SubcatchData::infil_p3
std::vector< double > infil_p3
Infiltration param 3: decay (Horton), initial deficit (GA), drying time (CN).
Definition SubcatchData.hpp:242

openswmm::SubcatchData::sweep_last_swept
std::vector< double > sweep_last_swept
Gap #34: days since last swept per (subcatch x landuse).
Definition SubcatchData.hpp:714

openswmm::SubcatchData::total_load
std::vector< double > total_load
Total washoff load per (subcatchment x pollutant) (mass units).
Definition SubcatchData.hpp:676

openswmm::SubcatchData::ds_imperv
std::vector< double > ds_imperv
Depression storage depth for impervious area (project length units).
Definition SubcatchData.hpp:201

openswmm::SubcatchData::subarea_routing
std::vector< int > subarea_routing
Inter-subarea routing mode.
Definition SubcatchData.hpp:220

openswmm::SubcatchData::resize_washoff_load
void resize_washoff_load(int n_pollutants)
Zero the washoff-load matrix for a positive pollutant count.
Definition SubcatchData.hpp:1290

openswmm::SubcatchData::stat_gw_sum_depth
std::vector< double > stat_gw_sum_depth
Time integral of water table elevation (ft-seconds)
Definition SubcatchData.hpp:520

openswmm::SubcatchData::stat_gw_flow_vol
std::vector< double > stat_gw_flow_vol
Cumulative lateral GW outflow (ft³)
Definition SubcatchData.hpp:517

openswmm::SubcatchData::subarea_runoff_rate
std::vector< double > subarea_runoff_rate
Area-averaged subarea runoff RATE, ft/sec — legacy's subcatch_getRunoff return value (runoff / area).
Definition SubcatchData.hpp:438

openswmm::SubcatchData::conc
std::vector< double > conc
Current quality concentration in subcatchment runoff.
Definition SubcatchData.hpp:398

openswmm::SubcatchData::pct_zero
std::vector< double > pct_zero
The AUTHORED [SUBAREAS] PctZero column, in percent.
Definition SubcatchData.hpp:183

openswmm::SubcatchData::curb_length
std::vector< double > curb_length
Total curb length (project length units).
Definition SubcatchData.hpp:130