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/surface/InfilBank.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 setAquiferOwners(std::vector<uint8_t> owners) { aquifer_owners_ = std::move(owners); }
    const std::vector<std::string>& ownershipMessages() const noexcept {
        return ownership_messages_;
    }

    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,
                     surface::InfilBank::Factors factors = {1.0, 1.0});
    void updateRates(const MeshData& mesh, SurfaceStateData& state, double dt,
                     surface::InfilBank::Factors factors, int num_threads);

    surface::InfilBank& bank() noexcept { return bank_; }

    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 bank_.cumulative(); }

    double stepSeconds() const noexcept { return step_seconds_; }

    void reset();
 
private:
    bool resolveImpl(const MeshData&, const SimulationOptions&, std::string&);
    std::vector<uint8_t> aquifer_owners_;
    std::vector<std::string> ownership_messages_;
    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_;
    surface::InfilBank bank_;
};
 
// ============================================================================
// 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