LinkData.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_LINK_DATA_HPP
#define OPENSWMM_ENGINE_LINK_DATA_HPP
 
#include <vector>
#include <cstdint>
#include <string>
#include <algorithm>
 
namespace openswmm {
 
// ============================================================================
// Link type enumerations
// ============================================================================
 
enum class LinkType : int8_t {
    CONDUIT = 0,
    PUMP    = 1,
    ORIFICE = 2,
    WEIR    = 3,
    OUTLET  = 4
};
 
enum class XsectShape : int16_t {
    CIRCULAR         = 0,
    FILLED_CIRCULAR  = 1,
    RECT_CLOSED      = 2,
    RECT_OPEN        = 3,
    TRAPEZOIDAL      = 4,
    TRIANGULAR       = 5,
    PARABOLIC        = 6,
    POWER            = 7,
    MODBASKETHANDLE  = 8,
    EGGSHAPED        = 9,
    HORSESHOE        = 10,
    GOTHIC           = 11,
    CATENARY         = 12,
    SEMIELLIPTICAL   = 13,
    BASKETHANDLE     = 14,
    SEMICIRCULAR     = 15,
    RECT_TRIANG      = 16,  
    RECT_ROUND       = 17,  
    HORIZ_ELLIPSE    = 18,  
    VERT_ELLIPSE     = 19,  
    ARCH             = 20,  
    IRREGULAR        = 21,  
    CUSTOM           = 22,  
    FORCE_MAIN       = 23,  
    STREET_XSECT     = 24,  
    DUMMY            = 25   
};
 
enum class FlowClass : int8_t {
    DRY        = 0,
    UP_DRY     = 1,
    DN_DRY     = 2,
    SUBCRITICAL = 3,
    SUPERCRITICAL = 4,
    UP_CRITICAL = 5,
    DN_CRITICAL = 6
};
 
// ============================================================================
// LinkData — SoA layout
// ============================================================================
 
struct LinkData {
 
    // -----------------------------------------------------------------------
    // Static connectivity — set at parse time
    // -----------------------------------------------------------------------
 
    std::vector<LinkType>   type;
 
    std::vector<int>        node1;
 
    std::vector<int>        node2;
 
    std::vector<double>     offset1;
 
    std::vector<double>     offset2;
 
    std::vector<double>     q0;
 
    std::vector<double>     q_limit;
 
    // -----------------------------------------------------------------------
    // Conduit-specific properties (valid when type[i] == CONDUIT)
    // -----------------------------------------------------------------------
 
    std::vector<XsectShape> xsect_shape;
 
    std::vector<double>     xsect_y_full;
 
    std::vector<double>     xsect_a_full;
 
    std::vector<double>     xsect_w_max;
 
    std::vector<int>        xsect_curve;
 
    std::vector<double>     roughness;
 
    std::vector<double>     length;
 
    std::vector<double>     slope;
 
    std::vector<double>     mod_length;
 
    std::vector<int>        barrels;
 
    std::vector<double>     beta;
 
    std::vector<double>     rough_factor;
 
    std::vector<double>     q_full;
 
    std::vector<double>     xsect_r_full;
 
    std::vector<double>     xsect_s_full;
 
    std::vector<double>     xsect_s_max;
 
    std::vector<double>     q_max;
 
    std::vector<double>     xsect_y_bot;
 
    std::vector<double>     xsect_a_bot;
 
    std::vector<double>     xsect_s_bot;
 
    std::vector<double>     xsect_r_bot;
 
    std::vector<double>     xsect_yw_max;
 
    std::vector<int>        xsect_batch_shape;
 
    std::vector<double>     setting;
 
    std::vector<double>     target_setting;
 
    std::vector<double>     time_last_set;
 
    std::vector<int>        direction;
 
    // -----------------------------------------------------------------------
    // Pump-specific properties (valid when type[i] == PUMP)
    // -----------------------------------------------------------------------
 
    std::vector<int>        pump_curve;
 
    std::vector<bool>       pump_init_state;
 
    std::vector<double>     pump_startup;
 
    std::vector<double>     pump_shutoff;
 
    std::vector<int>        pump_curve_type;
 
    std::vector<std::string> pump_curve_name;
 
    // -----------------------------------------------------------------------
    // Conduit loss coefficients
    // -----------------------------------------------------------------------
 
    std::vector<double>     loss_inlet;
    std::vector<double>     loss_outlet;
    std::vector<double>     loss_avg;
    std::vector<uint8_t>    has_flap_gate;
    std::vector<double>     seep_rate;
 
    std::vector<double>     evap_loss_rate;
 
    std::vector<double>     seep_loss_rate;
 
    std::vector<int>        culvert_code;
 
    std::vector<uint8_t>    normal_flow_limited;
 
    std::vector<uint8_t>    inlet_control;
 
    std::vector<double>     dqdh;
 
    // -----------------------------------------------------------------------
    // Weir / Orifice / Outlet — shared geometric properties
    // -----------------------------------------------------------------------
 
    std::vector<double>     crest_height;
 
    std::vector<double>     cd;
 
    std::vector<double>     param1;
 
    std::vector<double>     param2;
 
    std::vector<double>     orate;
 
    // -----------------------------------------------------------------------
    // State variables — updated each timestep
    // -----------------------------------------------------------------------
 
    std::vector<double>     flow;
 
    std::vector<double>     depth;
 
    std::vector<double>     volume;
 
    std::vector<double>     froude;
 
    std::vector<FlowClass>  flow_class;
 
    std::vector<uint8_t>    is_closed;
 
    std::vector<int8_t>     full_state;
 
    // -----------------------------------------------------------------------
    // Previous-step state
    // -----------------------------------------------------------------------
 
    std::vector<double>     old_flow;
 
    std::vector<double>     old_depth;
 
    std::vector<double>     old_volume;
 
    // -----------------------------------------------------------------------
    // Per-link quality state — flat 2D: [link * n_pollutants + pollutant]
    // -----------------------------------------------------------------------
 
    std::vector<double>     conc;
 
    std::vector<double>     conc_old;
 
    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_vol_flow;
 
    std::vector<double>     stat_max_flow;
 
    std::vector<double>     stat_max_veloc;
 
    std::vector<double>     stat_max_filling;
 
    std::vector<double>     stat_time_surcharged;
 
    static constexpr int N_FLOW_CLASSES = 7;
    std::vector<long> stat_flow_class;
    std::vector<long> stat_norm_ltd;      
    std::vector<long> stat_inlet_ctrl;    
 
    std::vector<double>     stat_max_flow_date;
 
    std::vector<double>     stat_time_full_upstream;
 
    std::vector<double>     stat_time_full_dnstream;
 
    std::vector<double>     stat_time_full_both;
 
    std::vector<double>     stat_time_capacity_limited;
 
    std::vector<double>     stat_total_load;
    int                     stat_n_pollutants = 0;
 
    // -----------------------------------------------------------------------
    // Pump utilization statistics (valid when type[i] == PUMP)
    // -----------------------------------------------------------------------
 
    std::vector<int>        stat_pump_cycles;
 
    std::vector<double>     stat_pump_on_time;
 
    std::vector<double>     stat_pump_volume;
 
    std::vector<double>     stat_pump_energy;
 
    std::vector<bool>       stat_pump_was_on;
 
    std::vector<long>       stat_flow_turns;
 
    std::vector<int>        stat_flow_turn_sign;
 
    std::vector<double>     stat_time_courant_critical;
 
    // -----------------------------------------------------------------------
    // Capacity management
    // -----------------------------------------------------------------------
 
    int count() const noexcept { return static_cast<int>(type.size()); }
 
    void resize(int n) {
        const auto un = static_cast<std::size_t>(n);
 
        type.assign(un, LinkType::CONDUIT);
        node1.assign(un, -1);
        node2.assign(un, -1);
        offset1.assign(un, 0.0);
        offset2.assign(un, 0.0);
        q0.assign(un, 0.0);
        q_limit.assign(un, 0.0);
 
        xsect_shape.assign(un, XsectShape::CIRCULAR);
        xsect_y_full.assign(un, 0.0);
        xsect_a_full.assign(un, 0.0);
        xsect_w_max.assign(un, 0.0);
        xsect_curve.assign(un, -1);
        roughness.assign(un, 0.01);
        length.assign(un, 0.0);
        slope.assign(un, 0.0);
        mod_length.assign(un, 0.0);
        barrels.assign(un, 1);
        beta.assign(un, 0.0);
        rough_factor.assign(un, 0.0);
        q_full.assign(un, 0.0);
        xsect_r_full.assign(un, 0.0);
        xsect_s_full.assign(un, 0.0);
        xsect_s_max.assign(un, 0.0);
        q_max.assign(un, 0.0);
        xsect_y_bot.assign(un, 0.0);
        xsect_a_bot.assign(un, 0.0);
        xsect_s_bot.assign(un, 0.0);
        xsect_r_bot.assign(un, 0.0);
        xsect_yw_max.assign(un, 0.0);
        xsect_batch_shape.assign(un, 0);
        setting.assign(un, 1.0);
        target_setting.assign(un, 1.0);
        time_last_set.assign(un, 0.0);
        direction.assign(un, 1);
 
        loss_inlet.assign(un, 0.0);
        loss_outlet.assign(un, 0.0);
        loss_avg.assign(un, 0.0);
        has_flap_gate.assign(un, 0);
        seep_rate.assign(un, 0.0);
        evap_loss_rate.assign(un, 0.0);
        seep_loss_rate.assign(un, 0.0);
        culvert_code.assign(un, 0);
        inlet_control.assign(un, 0);
        dqdh.assign(un, 0.0);
 
        pump_curve.assign(un, -1);
        pump_init_state.assign(un, false);
        pump_startup.assign(un, 0.0);
        pump_shutoff.assign(un, 0.0);
        pump_curve_type.assign(un, -1);
        pump_curve_name.resize(un);
 
        crest_height.assign(un, 0.0);
        cd.assign(un, 0.0);
        param1.assign(un, 0.0);
        param2.assign(un, 0.0);
        orate.assign(un, 0.0);
 
        flow.assign(un, 0.0);
        depth.assign(un, 0.0);
        volume.assign(un, 0.0);
        froude.assign(un, 0.0);
        flow_class.assign(un, FlowClass::DRY);
        is_closed.assign(un, 0);
        full_state.assign(un, 0);
        old_flow.assign(un, 0.0);
        old_depth.assign(un, 0.0);
        old_volume.assign(un, 0.0);
 
        comments.assign(un, std::string{});
        tags.assign(un, std::string{});
 
        rpt_flag.assign(un, 0);
 
        stat_vol_flow.assign(un, 0.0);
        stat_max_flow.assign(un, 0.0);
        stat_max_veloc.assign(un, 0.0);
        stat_max_filling.assign(un, 0.0);
        stat_time_surcharged.assign(un, 0.0);
        stat_flow_class.assign(un * N_FLOW_CLASSES, 0L);
        stat_norm_ltd.assign(un, 0L);
        stat_inlet_ctrl.assign(un, 0L);
        stat_max_flow_date.assign(un, 0.0);
        stat_time_full_upstream.assign(un, 0.0);
        stat_time_full_dnstream.assign(un, 0.0);
        stat_time_full_both.assign(un, 0.0);
        stat_time_capacity_limited.assign(un, 0.0);
        stat_pump_cycles.assign(un, 0);
        stat_pump_on_time.assign(un, 0.0);
        stat_pump_volume.assign(un, 0.0);
        stat_pump_energy.assign(un, 0.0);
        stat_pump_was_on.assign(un, false);
        stat_flow_turns.assign(un, 0L);
        stat_flow_turn_sign.assign(un, 0);
        stat_time_courant_critical.assign(un, 0.0);
        normal_flow_limited.assign(un, 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(type, LinkType::CONDUIT); g(node1, -1); g(node2, -1);
        g(offset1, 0.0); g(offset2, 0.0); g(q0, 0.0); g(q_limit, 0.0);
        g(xsect_shape, XsectShape::CIRCULAR);
        g(xsect_y_full, 0.0); g(xsect_a_full, 0.0); g(xsect_w_max, 0.0);
        g(xsect_curve, -1); g(roughness, 0.013); g(param1, 0.0);
        g(length, 0.0); g(mod_length, 0.0); g(slope, 0.0);
        g(barrels, 1); g(beta, 0.0); g(rough_factor, 0.0);
        g(q_full, 0.0); g(q_max, 0.0);
        g(xsect_r_full, 0.0); g(xsect_s_full, 0.0); g(xsect_s_max, 0.0);
        g(xsect_y_bot, 0.0); g(xsect_a_bot, 0.0);
        g(xsect_s_bot, 0.0); g(xsect_r_bot, 0.0);
        g(xsect_yw_max, 0.0); g(xsect_batch_shape, 0);
        g(setting, 1.0); g(target_setting, 1.0); g(direction, 1);
        g(loss_inlet, 0.0); g(loss_outlet, 0.0); g(loss_avg, 0.0);
        g(has_flap_gate, uint8_t{0}); g(seep_rate, 0.0);
        g(evap_loss_rate, 0.0); g(seep_loss_rate, 0.0);
        g(culvert_code, 0); g(normal_flow_limited, uint8_t{0});
        g(inlet_control, uint8_t{0}); g(dqdh, 0.0);
        g(pump_curve, -1); g(pump_init_state, false);
        g(pump_startup, 0.0); g(pump_shutoff, 0.0);
        g(pump_curve_type, -1);
        pump_curve_name.resize(un);
        g(crest_height, 0.0); g(cd, 0.0); g(param2, 0.0); g(orate, 0.0);
        g(flow, 0.0); g(depth, 0.0); g(volume, 0.0);
        g(froude, 0.0); g(flow_class, FlowClass::DRY); g(is_closed, uint8_t{0});
        g(full_state, int8_t{0});
        g(old_flow, 0.0); g(old_depth, 0.0); g(old_volume, 0.0);
        comments.resize(un, std::string{});
        tags.resize(un, std::string{});
 
        g(rpt_flag, static_cast<char>(0));
        g(stat_vol_flow, 0.0); g(stat_max_flow, 0.0);
        g(stat_max_veloc, 0.0); g(stat_max_filling, 0.0);
        g(stat_time_surcharged, 0.0); g(stat_max_flow_date, 0.0);
        g(stat_time_full_upstream, 0.0); g(stat_time_full_dnstream, 0.0);
        g(stat_time_full_both, 0.0); g(stat_time_capacity_limited, 0.0);
        g(stat_pump_cycles, 0); g(stat_pump_on_time, 0.0);
        g(stat_pump_volume, 0.0); g(stat_pump_energy, 0.0);
        g(stat_pump_was_on, false);
        g(stat_flow_turns, 0L); g(stat_flow_turn_sign, 0);
        g(stat_time_courant_critical, 0.0);
        g(stat_norm_ltd, 0L); g(stat_inlet_ctrl, 0L);
        // stat_flow_class is flat 2D [n * N_FLOW_CLASSES]
        stat_flow_class.resize(un * N_FLOW_CLASSES, 0L);
        // Note: conc, conc_old handled by resize_quality()
        // Note: stat_total_load handled by resize_loads()
    }
 
    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(type); e(node1); e(node2); e(offset1); e(offset2); e(q0); e(q_limit);
 
        e(xsect_shape); e(xsect_y_full); e(xsect_a_full); e(xsect_w_max); e(xsect_curve);
        e(roughness); e(length); e(slope); e(mod_length); e(barrels);
        e(beta); e(rough_factor); e(q_full);
        e(xsect_r_full); e(xsect_s_full); e(xsect_s_max); e(q_max);
        e(xsect_y_bot); e(xsect_a_bot); e(xsect_s_bot); e(xsect_r_bot); e(xsect_yw_max);
        e(xsect_batch_shape); e(setting); e(target_setting); e(direction);
 
        e(pump_curve); e(pump_init_state); e(pump_startup); e(pump_shutoff);
        e(pump_curve_type); e(pump_curve_name);
 
        e(loss_inlet); e(loss_outlet); e(loss_avg); e(has_flap_gate); e(seep_rate);
        e(evap_loss_rate); e(seep_loss_rate); e(culvert_code);
        e(normal_flow_limited); e(inlet_control); e(dqdh);
 
        e(crest_height); e(cd); e(param1); e(param2); e(orate);
 
        e(flow); e(depth); e(volume); e(froude); e(flow_class); e(is_closed); e(full_state);
        e(old_flow); e(old_depth); e(old_volume);
        e(comments); e(tags); e(rpt_flag);
 
        e(stat_vol_flow); e(stat_max_flow); e(stat_max_veloc); e(stat_max_filling);
        e(stat_time_surcharged); e(stat_norm_ltd); e(stat_inlet_ctrl);
        e(stat_max_flow_date); e(stat_time_full_upstream); e(stat_time_full_dnstream);
        e(stat_time_full_both); e(stat_time_capacity_limited);
        e(stat_pump_cycles); e(stat_pump_on_time); e(stat_pump_volume); e(stat_pump_energy);
        e(stat_pump_was_on); e(stat_flow_turns); e(stat_flow_turn_sign);
        e(stat_time_courant_critical);
 
        // Flat 2D: stat_flow_class [link * N_FLOW_CLASSES + class]
        {
            const auto base = ui * static_cast<std::size_t>(N_FLOW_CLASSES);
            const auto end  = base + static_cast<std::size_t>(N_FLOW_CLASSES);
            if (end <= stat_flow_class.size())
                stat_flow_class.erase(stat_flow_class.begin() + static_cast<std::ptrdiff_t>(base),
                                      stat_flow_class.begin() + static_cast<std::ptrdiff_t>(end));
        }
 
        // Flat 2D quality arrays: [link * 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);
        }
 
        // Flat 2D stat load: [link * np + p]
        if (stat_n_pollutants > 0) {
            const auto np = static_cast<std::size_t>(stat_n_pollutants);
            const auto base = ui * np;
            if (base + np <= stat_total_load.size())
                stat_total_load.erase(
                    stat_total_load.begin() + static_cast<std::ptrdiff_t>(base),
                    stat_total_load.begin() + static_cast<std::ptrdiff_t>(base + np));
        }
    }
 
    void resize_loads(int n_pollutants) {
        stat_n_pollutants = n_pollutants;
        if (n_pollutants > 0) {
            auto total = static_cast<std::size_t>(count()) *
                         static_cast<std::size_t>(n_pollutants);
            stat_total_load.assign(total, 0.0);
        }
    }
 
    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);
        }
    }
 
    void shrink_to_fit() {
        type.shrink_to_fit();
        node1.shrink_to_fit();
        node2.shrink_to_fit();
        offset1.shrink_to_fit();
        offset2.shrink_to_fit();
        q0.shrink_to_fit();
        q_limit.shrink_to_fit();
 
        xsect_shape.shrink_to_fit();
        xsect_y_full.shrink_to_fit();
        xsect_a_full.shrink_to_fit();
        xsect_w_max.shrink_to_fit();
        xsect_curve.shrink_to_fit();
        roughness.shrink_to_fit();
        length.shrink_to_fit();
        slope.shrink_to_fit();
        mod_length.shrink_to_fit();
        barrels.shrink_to_fit();
        beta.shrink_to_fit();
        rough_factor.shrink_to_fit();
        q_full.shrink_to_fit();
        xsect_r_full.shrink_to_fit();
        xsect_s_full.shrink_to_fit();
        xsect_s_max.shrink_to_fit();
        q_max.shrink_to_fit();
        xsect_y_bot.shrink_to_fit();
        xsect_a_bot.shrink_to_fit();
        xsect_s_bot.shrink_to_fit();
        xsect_r_bot.shrink_to_fit();
        xsect_yw_max.shrink_to_fit();
        xsect_batch_shape.shrink_to_fit();
        setting.shrink_to_fit();
        target_setting.shrink_to_fit();
        direction.shrink_to_fit();
 
        loss_inlet.shrink_to_fit();
        loss_outlet.shrink_to_fit();
        loss_avg.shrink_to_fit();
        has_flap_gate.shrink_to_fit();
        seep_rate.shrink_to_fit();
        evap_loss_rate.shrink_to_fit();
        seep_loss_rate.shrink_to_fit();
        culvert_code.shrink_to_fit();
        inlet_control.shrink_to_fit();
        dqdh.shrink_to_fit();
        normal_flow_limited.shrink_to_fit();
 
        pump_curve.shrink_to_fit();
        pump_init_state.shrink_to_fit();
        pump_startup.shrink_to_fit();
        pump_shutoff.shrink_to_fit();
        pump_curve_type.shrink_to_fit();
        pump_curve_name.shrink_to_fit();
 
        crest_height.shrink_to_fit();
        cd.shrink_to_fit();
        param1.shrink_to_fit();
        param2.shrink_to_fit();
        orate.shrink_to_fit();
 
        flow.shrink_to_fit();
        depth.shrink_to_fit();
        volume.shrink_to_fit();
        froude.shrink_to_fit();
        flow_class.shrink_to_fit();
        is_closed.shrink_to_fit();
        old_flow.shrink_to_fit();
        old_depth.shrink_to_fit();
        old_volume.shrink_to_fit();
        conc.shrink_to_fit();
        conc_old.shrink_to_fit();
 
        comments.shrink_to_fit();
        tags.shrink_to_fit();
 
        rpt_flag.shrink_to_fit();
 
        stat_vol_flow.shrink_to_fit();
        stat_max_flow.shrink_to_fit();
        stat_max_veloc.shrink_to_fit();
        stat_max_filling.shrink_to_fit();
        stat_time_surcharged.shrink_to_fit();
        stat_flow_class.shrink_to_fit();
        stat_norm_ltd.shrink_to_fit();
        stat_inlet_ctrl.shrink_to_fit();
        stat_max_flow_date.shrink_to_fit();
        stat_time_full_upstream.shrink_to_fit();
        stat_time_full_dnstream.shrink_to_fit();
        stat_time_full_both.shrink_to_fit();
        stat_time_capacity_limited.shrink_to_fit();
        stat_pump_cycles.shrink_to_fit();
        stat_pump_on_time.shrink_to_fit();
        stat_pump_volume.shrink_to_fit();
        stat_pump_energy.shrink_to_fit();
        stat_pump_was_on.shrink_to_fit();
        stat_total_load.shrink_to_fit();
    }
 
    void save_state() noexcept {
        std::copy(flow.begin(),   flow.end(),   old_flow.begin());
        std::copy(depth.begin(),  depth.end(),  old_depth.begin());
        std::copy(volume.begin(), volume.end(), old_volume.begin());
        std::copy(conc.begin(),   conc.end(),   conc_old.begin());
    }
 
    void reset_state() noexcept {
        std::fill(flow.begin(),  flow.end(),  0.0);
        std::fill(depth.begin(), depth.end(), 0.0);
        std::fill(volume.begin(), volume.end(), 0.0);
        std::fill(froude.begin(), froude.end(), 0.0);
        std::fill(flow_class.begin(), flow_class.end(), FlowClass::DRY);
        std::fill(old_flow.begin(),  old_flow.end(),  0.0);
        std::fill(old_depth.begin(), old_depth.end(), 0.0);
        std::fill(old_volume.begin(), old_volume.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_LINK_DATA_HPP */