LidLayerSpeciesData.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_LIDLAYERSPECIESDATA_HPP
#define OPENSWMM_ENGINE_DATA_LIDLAYERSPECIESDATA_HPP
 
#include <cstddef>
#include <vector>
 
namespace openswmm {

enum class LidLayer : int {
    SURFACE  = 0,
    PAVEMENT = 1,
    SOIL     = 2,
    STORAGE  = 3,
    COUNT_   = 4
};

enum class LidSpecies : int {
    AGE         = 0,
    TEMPERATURE = 1,
    COUNT_      = 2
};

struct LidLayerSpeciesState {
    int n_units   = 0;
    int n_species = 0;

    std::vector<int> group_offset;

    std::vector<double> value;

    std::vector<double> vol_prev;

    std::vector<double> drain_value;

    std::vector<double> inflow_value;
 
    static constexpr int kLayerCount = static_cast<int>(LidLayer::COUNT_);
 
    bool active() const noexcept { return n_units > 0 && n_species > 0; }
 
    std::size_t layer_index(int unit, LidLayer layer, int species) const noexcept {
        return (static_cast<std::size_t>(unit) * kLayerCount +
                static_cast<std::size_t>(layer)) *
                   static_cast<std::size_t>(n_species) +
               static_cast<std::size_t>(species);
    }

    void resize(int units, int species, const std::vector<int>& offsets) {
        n_units   = units;
        n_species = species;
        group_offset = offsets;
        const auto n_layers = static_cast<std::size_t>(units) *
                              static_cast<std::size_t>(kLayerCount);
        value.assign(n_layers * static_cast<std::size_t>(species), 0.0);
        vol_prev.assign(n_layers, 0.0);
        drain_value.assign(static_cast<std::size_t>(units) *
                               static_cast<std::size_t>(species), 0.0);
        inflow_value.assign(static_cast<std::size_t>(units) *
                                static_cast<std::size_t>(species), 0.0);
    }

    void ensureSized(int units, int species, const std::vector<int>& offsets) {
        const auto want = static_cast<std::size_t>(units) *
                          static_cast<std::size_t>(kLayerCount) *
                          static_cast<std::size_t>(species);
        if (n_units == units && n_species == species && value.size() == want)
            return;
        resize(units, species, offsets);
    }
 
    void clear() { *this = LidLayerSpeciesState{}; }
};
 
}  // namespace openswmm
 
#endif  // OPENSWMM_ENGINE_DATA_LIDLAYERSPECIESDATA_HPP