EnvironmentFacade.h

#pragma once
 
#include <marenv/Environment.h>
#include <marenv/WaterVelocity.h>
#include <marenv/current/CurrentField.h>
#include <marenv/seafloor/BathymetryField.h>
#include <marenv/seafloor/FlatSeafloor.h>
#include <marenv/wake/JetField.h>
#include <marenv/wake/WakeField.h>
#include <marenv/wake/WakeRegistry.h>
#include <marenv/wave/NullWaveField.h>
#include <marenv/wave/WaveEnergySpectrum.h>
#include <marenv/wave/WaveFactory.h>
#include <marenv/wave/WaveField.h>
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <span>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace marenv
{
struct WakedFlow
{
    double ambient[3]; 
    double waked[3]; 
    double deficit; 
    int numSources; 
    int numJets = 0; 
};
 
class EnvironmentFacade : public Environment
{
public:
    EnvironmentFacade()
        : m_waves(std::make_shared<wave::NullWaveField>())
        , m_depths(std::make_shared<seafloor::FlatSeafloor>())
    {
    }
    ~EnvironmentFacade() override = default;
 
    // Environment's setter and getter functions
    void SetWaves(std::shared_ptr<wave::WaveField> wave);
 
    void SetWaves(const wave::WaveEnergySpectrum::SpectrumParameters& params,
        wave::WaveTheory waveTheory,
        int numWaves,
        uint32_t seed);
    void SetBathymetry(std::shared_ptr<seafloor::BathymetryField> bathymetry);
    std::shared_ptr<wave::WaveField> GetWaves();
 
    double MaxWaveElevation() const;
    std::shared_ptr<seafloor::BathymetryField> GetBathymetry();
 
    void AddCurrentField(const std::string& id, std::shared_ptr<current::CurrentField> field);
 
    void RemoveCurrentField(const std::string& id);
 
    bool HasCurrentField(const std::string& id) const;
 
    std::shared_ptr<current::CurrentField> GetCurrentField(const std::string& id) const;
 
    void AddWakeField(const std::string& id, std::shared_ptr<wake::WakeField> field);
 
    void RemoveWakeField(const std::string& id);
 
    bool HasWakeField(const std::string& id) const;
 
    std::shared_ptr<wake::WakeField> GetWakeField(const std::string& id) const;
 
    void AddJetField(const std::string& id, std::shared_ptr<wake::JetField> field);
 
    std::shared_ptr<wake::JetField> GetJetField(const std::string& id) const;
 
    std::vector<std::string> GetWakeFieldIds() const;
 
    std::vector<std::string> GetJetFieldIds() const;
 
    std::vector<std::string> GetCurrentFieldIds() const;
 
    // Accessor functions
 
    Status GetSubmergence(double time, const double pos[3], double& submergence) override;
 
    Status GetSurfaceElevation(double time, const double pos[2], double& elevationOut) override;
 
    Status GetSurfaceUnitNormal(double time, const double pos[2], double* unitNormalOut) override;
    Status GetParticleVelocity(double time, const double pos[3], double* velOut) override;
 
    Status GetParticleAcceleration(double time, const double pos[3], double* accOut) override;
 
    Status GetDynamicPressure(double time, const double pos[3], double& pressureOut) override;
 
    Status GetTotalPressure(double time, const double pos[3], double& pressureOut) override;
 
    Status GetSeaDepth(const double pos[2], double& depthOut) override;
 
    Status ComputeRayIntersection(const double origin[3], const double direction[3], double& distanceOut, double maxSearchDistance = 100, double startSearchDistance = -1, double stepSize = 1.0, double convergenceTolerance = 0.01) override;
    Status GetCurrentVelocity(double time, const double pos[3], double* velOut) override;
 
    Status GetDensity(double time, const double pos[3], double& density) override;
    Status PointEnvironmentQuery(double time, const double pos[3], EnvironmentQuery& queryResult) override;
 
    Status GetWaterVelocity(double time, const double pos[3], WaterVelocityTerms terms, double velOut[3]) const;
 
    Status GetWaterVelocity(double time, const double pos[3], const WaterVelocityParts& parts, double velOut[3]) const;
 
    Status GetWaterVelocity(double time, const double pos[3], const WaterVelocityParts& parts, const wake::HeldWakes& held, std::size_t point, double velOut[3]) const;
 
    void GetWaterVelocities(double time, std::span<const std::array<double, 3>> positions, const WaterVelocityParts& parts, std::span<std::array<double, 3>> velocities, std::span<Status> statuses) const;
 
    Status GetWaterVelocity(double time, const double pos[3], const WaterVelocityParts& parts, const wake::WakeQuery& query, const wake::HeldWakes* held, std::size_t point, double velOut[3], WakedFlow* detail = nullptr) const;
 
    Status GetWakedFlow(double time, const double pos[3], WakedFlow& out) const;
 
    Status GetWakedFlow(double time, const double pos[3], const wake::WakeQuery& query, WakedFlow& out) const;
 
    wake::WakeSelection SelectWakes(const wake::WakeQueryRegion& region, const wake::WakeQuery& query = {}) const;
 
    wake::HeldWakes HoldWakes(std::span<const std::array<double, 3>> positions, double T, const wake::WakeQuery& query = {}, double cutoff = 0.0, const wake::OwnTagsAt& ownTags = {}) const;
 
    std::uint64_t GetWakeRevision() const;
 
    bool WakesStaticFrom(double t) const;
 
protected:
 
    std::shared_ptr<wave::WaveField> m_waves;
    wave::WaveField& Waves() const;
 
    std::unordered_map<std::string, std::shared_ptr<current::CurrentField>> m_currentFields;
 
    std::shared_ptr<seafloor::BathymetryField> m_depths;
 
    wake::WakeRegistry m_wakes;
    Status ComputeTotalCurrent(double time, const double pos[3], double vel[3]) const;
 
private:
    Status SumAtPoint(double time, const double pos[3], const WaterVelocityParts& parts, const wake::WakeComposition* wake, double velOut[3], WakedFlow* detail) const;
 
    Status SumLiveAtPoint(double time, const double pos[3], const WaterVelocityParts& parts, const wake::WakeQuery& query, double velOut[3], WakedFlow* detail) const;
};
 
// Inline: the adapters and a receiver's per-evaluation call reach the live or held path without a call of their own (bench section held).
inline Status EnvironmentFacade::GetWaterVelocity(const double time, const double pos[3], const WaterVelocityParts& parts, const wake::WakeQuery& query, const wake::HeldWakes* held, const std::size_t point, double velOut[3], WakedFlow* detail) const
{
    const bool withWake = parts.wakes || parts.jets;
    if (withWake && held)
        return SumAtPoint(time, pos, parts, &held->At(point, time), velOut, detail); // a reference: no copy per evaluation (fhsim_environment ENV-0100)
    if (!withWake)
        return SumAtPoint(time, pos, parts, nullptr, velOut, detail);
    return SumLiveAtPoint(time, pos, parts, query, velOut, detail);
}
 
} // namespace marenv