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