InfraData.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_INFRA_DATA_HPP
#define OPENSWMM_ENGINE_INFRA_DATA_HPP
 
#include <vector>
#include <string>
 
namespace openswmm {
 
// ============================================================================
// Transect definitions (from [TRANSECTS] section)
// ============================================================================
 
struct TransectStore {
    int count() const { return static_cast<int>(names.size()); }
 
    std::vector<std::string> names;
    std::vector<std::string> comments; 
    std::vector<double> n_left;
    std::vector<double> n_right;
    std::vector<double> n_channel;
    std::vector<double> x_left_bank;
    std::vector<double> x_right_bank;
    std::vector<double> x_left_encroachment;
    std::vector<double> x_right_encroachment;
    std::vector<double> x_factor;
    std::vector<double> y_factor;
    std::vector<double>
        length_factor; 
    std::vector<std::vector<double>> stations;
    std::vector<std::vector<double>> elevations;
};
 
// ============================================================================
// Street definitions (from [STREETS] section)
// ============================================================================
 
struct StreetStore {
    int count() const { return static_cast<int>(names.size()); }
 
    std::vector<std::string> names;
    std::vector<double> t_crown;
    std::vector<double> h_curb;
    std::vector<double> sx; 
    std::vector<double> n_road;
    std::vector<double> gutter_depres;
    std::vector<double> gutter_width;
    std::vector<int> sides;
    std::vector<double> back_width;
    std::vector<double> back_slope;
    std::vector<double> back_n;
};
 
// ============================================================================
// Inlet definitions (from [INLETS] section)
// ============================================================================

struct InletStore {
    int count() const { return static_cast<int>(names.size()); }
 
    std::vector<std::string> names;
    std::vector<std::string> inlet_type; 
    std::vector<double> length;          
    std::vector<double> width;           
    std::vector<std::string>
        grate_type; 
    std::vector<double> open_area;    
    std::vector<double> splash_veloc; 
    std::vector<double> curb_length;  
    std::vector<double> curb_height;  
    std::vector<int>
        curb_throat; 
    std::vector<std::string> curve_id; 
    std::vector<int> curve_index; 
    std::vector<int>
        curve_kind; 
    std::vector<std::string> comments; 

    int add_row(const std::string& name, const std::string& type) {
        names.push_back(name);
        inlet_type.push_back(type);
        length.push_back(0.0);
        width.push_back(0.0);
        grate_type.push_back("");
        open_area.push_back(0.0);
        splash_veloc.push_back(0.0);
        curb_length.push_back(0.0);
        curb_height.push_back(0.0);
        curb_throat.push_back(2);
        curve_id.push_back("");
        curve_index.push_back(-1);
        curve_kind.push_back(0);
        comments.push_back("");
        return count() - 1;
    }

    void erase_row(int idx) {
        auto u = static_cast<std::size_t>(idx);
        names.erase(names.begin() + static_cast<std::ptrdiff_t>(u));
        inlet_type.erase(inlet_type.begin() + static_cast<std::ptrdiff_t>(u));
        length.erase(length.begin() + static_cast<std::ptrdiff_t>(u));
        width.erase(width.begin() + static_cast<std::ptrdiff_t>(u));
        grate_type.erase(grate_type.begin() + static_cast<std::ptrdiff_t>(u));
        open_area.erase(open_area.begin() + static_cast<std::ptrdiff_t>(u));
        splash_veloc.erase(splash_veloc.begin() + static_cast<std::ptrdiff_t>(u));
        curb_length.erase(curb_length.begin() + static_cast<std::ptrdiff_t>(u));
        curb_height.erase(curb_height.begin() + static_cast<std::ptrdiff_t>(u));
        curb_throat.erase(curb_throat.begin() + static_cast<std::ptrdiff_t>(u));
        curve_id.erase(curve_id.begin() + static_cast<std::ptrdiff_t>(u));
        curve_index.erase(curve_index.begin() + static_cast<std::ptrdiff_t>(u));
        curve_kind.erase(curve_kind.begin() + static_cast<std::ptrdiff_t>(u));
        comments.erase(comments.begin() + static_cast<std::ptrdiff_t>(u));
    }
};
 
// ============================================================================
// Inlet usage (from [INLET_USAGE] section)
// ============================================================================

struct InletUsageStore {
    int count() const { return static_cast<int>(design_index.size()); }
 
    std::vector<int> link_index;     
    std::vector<int> node_host;      
    std::vector<int> design_index;   
    std::vector<int> node_index;     
    std::vector<int> num_inlets;     
    std::vector<int> placement;      
    std::vector<double> clog_factor; 
    std::vector<double> flow_limit;  
    std::vector<double> local_depress; 
    std::vector<double> local_width;   
    std::vector<int>
        street_index; 
    std::vector<std::string> pending_design_name;
    std::vector<std::string> pending_capture_name;

    int add_row(int link_idx, int node_host_idx, int design_idx, int capture_node_idx) {
        link_index.push_back(link_idx);
        node_host.push_back(node_host_idx);
        design_index.push_back(design_idx);
        node_index.push_back(capture_node_idx);
        num_inlets.push_back(1);
        placement.push_back(0);
        clog_factor.push_back(1.0);
        flow_limit.push_back(0.0);
        local_depress.push_back(0.0);
        local_width.push_back(0.0);
        street_index.push_back(-1);
        pending_design_name.emplace_back();
        pending_capture_name.emplace_back();
        return count() - 1;
    }

    void erase_row(int idx) {
        auto e = [idx](auto& v) {
            if (static_cast<std::size_t>(idx) < v.size())
                v.erase(v.begin() + static_cast<std::ptrdiff_t>(idx));
        };
        e(link_index);
        e(node_host);
        e(design_index);
        e(node_index);
        e(num_inlets);
        e(placement);
        e(clog_factor);
        e(flow_limit);
        e(local_depress);
        e(local_width);
        e(street_index);
        e(pending_design_name);
        e(pending_capture_name);
        e(stat_capture_vol);
        e(stat_bypass_vol);
        e(stat_backflow_vol);
        e(stat_peak_flow);
    }

    int find_by_link(int link_idx) const {
        for (int i = 0; i < count(); ++i)
            if (link_index[static_cast<std::size_t>(i)] == link_idx)
                return i;
        return -1;
    }

    int find_by_node_host(int node_idx) const {
        for (int i = 0; i < count(); ++i)
            if (node_host[static_cast<std::size_t>(i)] == node_idx)
                return i;
        return -1;
    }
 
    // Stats (populated by InletSolver::gatherStats() before reporting)
    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_stats(int n) {
        auto un = static_cast<std::size_t>(n);
        stat_capture_vol.assign(un, 0.0);
        stat_bypass_vol.assign(un, 0.0);
        stat_backflow_vol.assign(un, 0.0);
        stat_peak_flow.assign(un, 0.0);
    }
};
 
// ============================================================================
// Control rule text (from [CONTROLS] section)
// ============================================================================
 
struct ControlRuleStore {
    int count() const { return static_cast<int>(rule_text.size()); }

    std::vector<std::string> rule_text;
};
 
} // namespace openswmm
 
#endif // OPENSWMM_ENGINE_INFRA_DATA_HPP