WaterAgeData.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_WATER_AGE_DATA_HPP
#define OPENSWMM_ENGINE_DATA_WATER_AGE_DATA_HPP
 
#include <limits>
#include <vector>
 
namespace openswmm {

enum class WaterAgeSource : int {
    RAINFALL        = 0,  
    DWF             = 1,
    GW              = 2,
    RDII            = 3,
    EXTERNAL_INFLOW = 4,
    IFACE           = 5,
    INITIAL_STATE   = 6,  
    COUNT_          = 7
};

struct WaterAgeConfigData {
    bool configured = false;

    double global_age[static_cast<int>(WaterAgeSource::COUNT_)] = {};
 
    // NODE-scope overrides (DWF / EXTERNAL_INFLOW), parallel arrays.
    std::vector<int>    node_over_source;  
    std::vector<int>    node_over_node;    
    std::vector<double> node_over_age;     

    double source_age(WaterAgeSource s, int node) const noexcept {
        for (std::size_t i = 0; i < node_over_source.size(); ++i)
            if (node_over_source[i] == static_cast<int>(s) &&
                node_over_node[i] == node)
                return node_over_age[i];
        return global_age[static_cast<int>(s)];
    }
};

enum class SubArea : int {
    IMPERV0 = 0,  
    IMPERV1 = 1,  
    PERV    = 2,
    COUNT_  = 3
};
 
struct WaterAgeState {
    std::vector<double> node_age_vol_in;  
    std::vector<double> node_age;         
    std::vector<double> link_age;         

    bool legacy_seeded = false;
 
    // --- A3: watershed age -------------------------------------------
    std::vector<double> subarea_age;

    std::vector<double> subarea_vol_prev;

    std::vector<double> subcatch_runoff_age;

    std::vector<double> subcatch_runon_age_vol_in;

    std::vector<double> node_lid_drain_age_vol_in;

    std::vector<double> subcatch_lid_drain_age_cfs;
    std::vector<double> subcatch_outfall_age_vol;

    std::vector<double> node_ext_inflow_age;

    bool hotstart_loaded = false;

    void resize(int n_nodes, int n_links, int n_subcatch) {
        node_age_vol_in.assign(static_cast<std::size_t>(n_nodes), 0.0);
        node_age.assign(static_cast<std::size_t>(n_nodes), 0.0);
        link_age.assign(static_cast<std::size_t>(n_links), 0.0);
        node_lid_drain_age_vol_in.assign(static_cast<std::size_t>(n_nodes), 0.0);
        // Z1: PRESERVE when already sized. InflowSolver::init sizes and
        // fills this at open — BEFORE the first routing step's
        // computeAll — and the loaders' first lazy resize() lands between
        // that write and its first read. A blanket assign here re-NaN'd
        // the array and cost the row exactly one routing step of table-
        // default age (measured: a 4-ULP C5 residue that broke the
        // Z1 equivalence gate). init() re-asserts NaN on every re-init,
        // so a removed row cannot leave a stale age behind.
        if (node_ext_inflow_age.size() != static_cast<std::size_t>(n_nodes))
            node_ext_inflow_age.assign(
                static_cast<std::size_t>(n_nodes),
                std::numeric_limits<double>::quiet_NaN());
        const auto ns3 = static_cast<std::size_t>(n_subcatch) *
                         static_cast<std::size_t>(SubArea::COUNT_);
        subarea_age.assign(ns3, 0.0);
        subarea_vol_prev.assign(ns3, 0.0);
        subcatch_runoff_age.assign(static_cast<std::size_t>(n_subcatch), 0.0);
        subcatch_runon_age_vol_in.assign(
            static_cast<std::size_t>(n_subcatch), 0.0);
        subcatch_lid_drain_age_cfs.assign(
            static_cast<std::size_t>(n_subcatch), 0.0);
        subcatch_outfall_age_vol.assign(
            static_cast<std::size_t>(n_subcatch), 0.0);
        legacy_seeded   = false;
        hotstart_loaded = false;
    }
    void clear() { *this = WaterAgeState{}; }
};
 
}  // namespace openswmm
 
#endif  // OPENSWMM_ENGINE_DATA_WATER_AGE_DATA_HPP