BedZoneData.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_BED_ZONE_DATA_HPP
#define OPENSWMM_ENGINE_DATA_BED_ZONE_DATA_HPP
 
#include <cstddef>
#include <vector>
 
namespace openswmm {

struct SedimentConfig {
    bool mesh_ground =
        false; 
    bool ground_source_configured = false; 
    double mesh_porosity = 0.30;
    double thermal_diffusivity = 1.0e-6;

    double solute_diffusivity = 1.0e-9;

    double bed_thickness = 0.20;

    double ground_depth = 2.0;

    double ground_temp = 12.0;

    bool has_ground_temp = false;

    int ground_ts_index = -1;

    double hyporheic_velocity = 0.0;

    double sed_density = 1670.0;

    double sed_specific_heat = 1807.0;

    double initial_temp = 12.0;
    bool has_initial_temp = false;
};

struct BedZoneState {
    std::vector<double> link_temp; 
    std::vector<double> link_conc;
    int n_species = 0;
    bool seeded = false;
 
    // ---- ARD (cell-resolved) bed. The per-link arrays above are the
    //      LEGACY and LARD substrate; under EULERIAN_ARD every CELL gets
    //      its own bed slice, 1:1 — which is exactly the reference's
    //      element mapping (HTSComponent pairs one HTS element with one
    //      channel element) and answers "which cell does the bed under a
    //      400 ft conduit exchange with?" with "its own". The two shapes
    //      coexist because engine choice is per model and this state is
    //      runtime-only (not persisted), so nothing ever has to convert
    //      one into the other.
    std::vector<double> cell_temp; 
    std::vector<double> cell_conc;
    int cell_n_species = 0;
    bool cells_seeded = false;

    void resizeCells(int n_cells, int n_spec, double t_init) {
        const auto nc = static_cast<std::size_t>(n_cells > 0 ? n_cells : 0);
        const auto ns = static_cast<std::size_t>(n_spec > 0 ? n_spec : 0);
        cell_n_species = static_cast<int>(ns);
        cell_temp.assign(nc, t_init);
        cell_conc.assign(ns * nc, 0.0);
        cells_seeded = true;
    }

    void resize(int n_links, int n_spec, double t_init) {
        const auto nl = static_cast<std::size_t>(n_links > 0 ? n_links : 0);
        const auto ns = static_cast<std::size_t>(n_spec > 0 ? n_spec : 0);
        n_species = static_cast<int>(ns);
        link_temp.assign(nl, t_init);
        link_conc.assign(nl * ns, 0.0);
        seeded = false;
    }

    bool sized(int n_links) const noexcept {
        return link_temp.size() == static_cast<std::size_t>(n_links > 0 ? n_links : 0);
    }

    void clear() { *this = BedZoneState{}; }
};
 
} // namespace openswmm
 
#endif // OPENSWMM_ENGINE_DATA_BED_ZONE_DATA_HPP