Infil2D.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_2D_INFIL2D_HPP
#define OPENSWMM_2D_INFIL2D_HPP
 
#include <cstdint>
#include <string>
#include <vector>
 
#include "../../hydrology/Infiltration.hpp"
 
namespace openswmm { struct SimulationOptions; }
 
namespace openswmm::twoD {
 
struct MeshData;
struct SurfaceStateData;
 
// ============================================================================
// Value types
// ============================================================================

enum class Infil2DDest : int {
    LOST             = 0,  
    SUBCATCH_AQUIFER = 1,  
    AQUIFER_2D       = 2   
};

inline constexpr int kInfil2DMaxParams = 5;

struct Infil2DRow {
    bool        has_method = false;
    InfilModel  method     = InfilModel::HORTON;
    double      p[kInfil2DMaxParams] = {0.0, 0.0, 0.0, 0.0, 0.0};
    Infil2DDest dest       = Infil2DDest::LOST;
    bool        dest_explicit = false;
};

struct Infil2DDefault {
    std::string tag;
    Infil2DRow  row;
};

struct Infil2DOverride {
    int        tri = -1;   
    Infil2DRow row;
};

struct Infil2DOptions {
    double infil_step = 0.0;
};

enum class Infil2DProvenance : std::uint8_t {
    NONE     = 0,  
    STAR     = 1,  
    TAG      = 2,  
    OVERRIDE = 3   
};
 
// ============================================================================
// Infil2D — per-cell infiltration state and driver
// ============================================================================

class Infil2D {
public:
    // --- configuration (populated by the section handlers) -----------------
    std::vector<Infil2DDefault>&        defaults()        noexcept { return defaults_; }
    const std::vector<Infil2DDefault>&  defaults()  const noexcept { return defaults_; }
    std::vector<Infil2DOverride>&       overrides()       noexcept { return overrides_; }
    const std::vector<Infil2DOverride>& overrides() const noexcept { return overrides_; }
    Infil2DOptions&                     options()         noexcept { return options_; }
    const Infil2DOptions&               options()   const noexcept { return options_; }

    bool resolve(const MeshData& mesh, const SimulationOptions& opts,
                 std::string& err);

    void setAquifer2DAvailable(bool on) noexcept { aquifer_2d_available_ = on; }
    bool aquifer2DAvailable() const noexcept { return aquifer_2d_available_; }

    void updateRates(const MeshData& mesh, SurfaceStateData& state, double dt);

    bool active() const noexcept { return active_; }

    void deactivate() noexcept { active_ = false; }

    const std::vector<Infil2DRow>& resolvedRows() const noexcept { return resolved_; }

    const std::vector<Infil2DProvenance>& provenance() const noexcept { return prov_; }

    const std::vector<double>& cumulative() const noexcept { return cum_depth_; }

    double stepSeconds() const noexcept { return step_seconds_; }

    void reset();
 
private:
    std::vector<Infil2DDefault>  defaults_;
    std::vector<Infil2DOverride> overrides_;
    Infil2DOptions               options_;
 
    bool   active_        = false;
    double step_seconds_  = 0.0;
    bool   aquifer_2d_available_ = false;
 
    // Per-triangle resolved state (empty when !active_).
    std::vector<Infil2DRow>        resolved_;
    std::vector<Infil2DProvenance> prov_;
    std::vector<double>            cum_depth_;   
 
    // Kernel state, one entry per triangle (allocated only for the methods in
    // use; indexed by triangle so lookups stay branch-free).
    std::vector<infil::HortonState>    horton_;
    std::vector<infil::GreenAmptState> grnampt_;
    std::vector<infil::CurveNumState>  curvenum_;
};
 
// ============================================================================
// Free helpers
// ============================================================================

bool parseInfil2DMethod(const std::string& token, InfilModel& method,
                        bool& has_method);

const char* infil2DMethodToken(const Infil2DRow& row);

bool parseInfil2DDest(const std::string& token, Infil2DDest& dest);

const char* infil2DDestToken(Infil2DDest dest);

int infil2DParamCount(InfilModel method);
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_2D_INFIL2D_HPP