MsxSurfaceData.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_DATA_MSX_SURFACE_DATA_HPP
#define OPENSWMM_ENGINE_DATA_MSX_SURFACE_DATA_HPP
 
#include <cstddef>
#include <string>
#include <vector>
 
namespace openswmm {

struct MsxSurfaceRows {
    struct Buildup {
        std::string landuse, species;
        int func_type = 0; 
        double c1 = 0.0, c2 = 0.0, c3 = 0.0;
        std::string ts_name; 
        int normalizer = 0;  
    };
    struct Washoff {
        std::string landuse, species;
        int func_type = 0; 
        double coeff = 0.0, expon = 0.0, sweep_effic = 0.0, bmp_effic = 0.0;
    };
    struct Loading {
        std::string subcatch, species;
        double value = 0.0; 
    };
    std::vector<Buildup> buildup;
    std::vector<Washoff> washoff;
    std::vector<Loading> loadings;
    bool empty() const noexcept { return buildup.empty() && washoff.empty() && loadings.empty(); }
};

struct MsxSurfaceData {
    MsxSurfaceRows rows; 
 
    int n_landuses = 0;
    int n_species = 0; 
    int n_subcatch = 0;
 
    // ---- parameters [lu * n_species + m] --------------------------------
    std::vector<int> bu_type;                
    std::vector<double> bu_c1, bu_c2, bu_c3; 
    std::vector<int> bu_normalizer;          
    std::vector<double> bu_max_days;         
    std::vector<int> wo_type;                
    std::vector<double> wo_coeff, wo_expon, wo_sweep_effic, wo_bmp_effic;
 
    // ---- initial loading [sc * n_species + m] (mass per unit area) ------
    std::vector<double> init_loading;
 
    // ---- per-species unit factor: concentration-mass → user mass --------
    std::vector<double> mcf; 
 
    // ---- state ----------------------------------------------------------
    std::vector<double> buildup;      
    std::vector<double> washoff_conc; 
    std::vector<double> washoff_conc_old;
    std::vector<double> ponded_qual;
    std::vector<double> runon_qual_rate;
    std::vector<double> c_rain;
    std::vector<bool> snow_only;
    std::vector<double> lid_rmvl;
    std::vector<double> lid_drain_load;
    std::vector<double> lid_drain_load_old;
    std::vector<double> lid_drain_runon_load;
 
    // ---- ledgers per species [m], user mass ---------------------------
    std::vector<double> led_init_buildup;
    std::vector<double> led_buildup;     
    std::vector<double> led_runoff_load; 
    std::vector<double> led_sweeping;
    std::vector<double> led_bmp_removal;
    std::vector<double> led_wet_deposition;   
    std::vector<double> led_infil_loss;       
    std::vector<double> led_reacted;          
    std::vector<double> led_reaction_clamped; 
    std::vector<double> led_ponded_lost;      
    std::vector<double>
        led_subcatch_load; 
 
    bool resolved = false;
    bool active() const noexcept { return resolved && n_species > 0; }

    std::size_t pidx(int lu, int m) const noexcept {
        return static_cast<std::size_t>(lu) * static_cast<std::size_t>(n_species) +
               static_cast<std::size_t>(m);
    }

    std::size_t bu_idx(int sc, int lu, int m) const noexcept {
        return (static_cast<std::size_t>(sc) * static_cast<std::size_t>(n_landuses) +
                static_cast<std::size_t>(lu)) *
                   static_cast<std::size_t>(n_species) +
               static_cast<std::size_t>(m);
    }

    std::size_t sidx(int sc, int m) const noexcept {
        return static_cast<std::size_t>(sc) * static_cast<std::size_t>(n_species) +
               static_cast<std::size_t>(m);
    }

    void resize_params(int nlu, int nm) {
        n_landuses = nlu;
        n_species = nm;
        const auto n = static_cast<std::size_t>(nlu) * static_cast<std::size_t>(nm);
        bu_type.assign(n, 0);
        bu_c1.assign(n, 0.0);
        bu_c2.assign(n, 0.0);
        bu_c3.assign(n, 0.0);
        bu_normalizer.assign(n, 0);
        bu_max_days.assign(n, 0.0);
        wo_type.assign(n, 0);
        wo_coeff.assign(n, 0.0);
        wo_expon.assign(n, 0.0);
        wo_sweep_effic.assign(n, 0.0);
        wo_bmp_effic.assign(n, 0.0);
        mcf.assign(static_cast<std::size_t>(nm), 1.0);
        if (c_rain.size() != static_cast<std::size_t>(nm))
            c_rain.assign(static_cast<std::size_t>(nm), 0.0);
        snow_only.assign(static_cast<std::size_t>(nm), false);
    }

    void resize_state(int nsc) {
        n_subcatch = nsc;
        const auto nm = static_cast<std::size_t>(n_species);
        buildup.assign(static_cast<std::size_t>(nsc) * static_cast<std::size_t>(n_landuses) * nm,
                       0.0);
        washoff_conc.assign(static_cast<std::size_t>(nsc) * nm, 0.0);
        washoff_conc_old.assign(static_cast<std::size_t>(nsc) * nm, 0.0);
        ponded_qual.assign(static_cast<std::size_t>(nsc) * nm, 0.0);
        runon_qual_rate.assign(static_cast<std::size_t>(nsc) * nm, 0.0);
        lid_drain_runon_load.assign(static_cast<std::size_t>(nsc) * nm, 0.0);
        if (init_loading.size() != static_cast<std::size_t>(nsc) * nm)
            init_loading.assign(static_cast<std::size_t>(nsc) * nm, 0.0);
        led_init_buildup.assign(nm, 0.0);
        led_buildup.assign(nm, 0.0);
        led_runoff_load.assign(nm, 0.0);
        led_sweeping.assign(nm, 0.0);
        led_bmp_removal.assign(nm, 0.0);
        led_wet_deposition.assign(nm, 0.0);
        led_infil_loss.assign(nm, 0.0);
        led_ponded_lost.assign(nm, 0.0);
        led_reacted.assign(nm, 0.0);
        led_reaction_clamped.assign(nm, 0.0);
        led_subcatch_load.assign(static_cast<std::size_t>(nsc) * nm, 0.0);
    }
};
 
} // namespace openswmm
 
#endif // OPENSWMM_ENGINE_DATA_MSX_SURFACE_DATA_HPP