BlendedField.h

#pragma once
 
#include <marenv/marenv.h>
#include <marenv/wake/FieldSketch.h>
#include <marenv/wake/JetField.h>
#include <marenv/wake/WakeBlend.h>
#include <marenv/wake/WakeField.h>
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <span>
 
namespace marenv::wake
{
namespace detail
{
template<class S>
const double* ZeroDeficitVelocity(const S& snapshot)
{
    static constexpr double kZero[3] = {0.0, 0.0, 0.0};
    if constexpr (requires { snapshot.sourceVelocity; })
        return snapshot.sourceVelocity;
    else
        return kZero;
}
} // namespace detail
 
struct WakeFieldTraits
{
    using Field   = WakeField; 
    using Value   = WakeSample; 
    using Sum     = WakeBlendSum; 
    using Samples = WakeBlendSamples; 
    using Parts   = WakeSampleParts; 
 
    template<class S>
    static Status ToSample(const Sum& sum, const S& current, Value& out)
    {
        return sum.ToSample(detail::ZeroDeficitVelocity(current), out);
    }
 
    template<class S>
    static void FillParts(Parts& parts, const S& current)
    {
        const double* velocity = detail::ZeroDeficitVelocity(current);
        for (int i = 0; i < 3; ++i)
            parts.zeroDeficitVelocity[i] = velocity[i];
    }
};
 
struct JetFieldTraits
{
    using Field   = JetField; 
    using Value   = JetSample; 
    using Sum     = JetBlendSum; 
    using Samples = JetBlendSamples; 
    using Parts   = JetSampleParts; 
 
    template<class S>
    static Status ToSample(const Sum& sum, const S& /*current*/, Value& out)
    {
        return sum.ToSample(out);
    }
 
    template<class S>
    static void FillParts(Parts& /*parts*/, const S& /*current*/)
    {
    }
};
 
template<class Snapshot, class Traits = WakeFieldTraits>
class BlendedField : public Traits::Field
{
public:
    using Value = typename Traits::Value;
 
    Status Sample(double t, const double pos[3], Value& out) const override { return SampleWith(t, pos, SnapshotSampler {}, out); }
 
    typename Traits::Parts SampleParts(double t, const double pos[3]) const override { return PartsWith(t, pos, SnapshotSampler {}); }
 
    bool MayReach(const WakeQueryRegion& region) const override
    {
        const auto state = m_blend.Load();
        return !state || Blend::MayReach(*state, region);
    }
 
    std::uint64_t Revision() const override { return m_blend.Revision(); }
 
    bool StaticFrom(double t) const override { return m_blend.StaticFrom(t); }
 
    void SampleMany(double t, std::span<const std::array<double, 3>> positions, std::span<Value> out, std::span<Status> status) const override
    {
        const auto state = m_blend.Load();
        for (std::size_t i = 0; i < positions.size(); ++i)
            status[i] = SampleState(state.get(), t, positions[i].data(), SnapshotSampler {}, out[i]);
    }
 
    void Sketch(double t, FieldSketch& out) const override
    {
        if (const auto state = m_blend.Load())
            state->current->Sketch(t, out);
    }
 
protected:
    using Blend = WakeBlend<Snapshot, Value, typename Traits::Sum, typename Traits::Samples>;
 
    template<class Sampler>
    Status SampleWith(double t, const double pos[3], const Sampler& sampler, Value& out) const
    {
        const auto state = m_blend.Load();
        return SampleState(state.get(), t, pos, sampler, out);
    }
 
    template<class Sampler>
    typename Traits::Parts PartsWith(double t, const double pos[3], const Sampler& sampler) const
    {
        const auto state = m_blend.Load();
        typename Traits::Parts parts;
        if (!state || !Blend::Blends(*state, t)) {
            parts.status = SampleState(state.get(), t, pos, sampler, parts.sample);
            return parts;
        }
        parts.blending = true;
        parts.blend    = Blend::Samples(*state, t, pos, sampler);
        Traits::FillParts(parts, *state->current);
        return parts;
    }
 
    Blend m_blend; 
 
private:
    struct SnapshotSampler
    {
        bool operator()(const Snapshot& snapshot, double t, const double* pos, Value& out) const { return snapshot.Sample(t, pos, out); }
    };
 
    template<class Sampler>
    static Status SampleState(const typename Blend::State* state, double t, const double pos[3], const Sampler& sampler, Value& out)
    {
        if (!state) {
            out = Value {};
            return Status::ERROR_NOT_SET;
        }
        return Traits::ToSample(Blend::Evaluate(*state, t, pos, sampler), *state->current, out);
    }
};
} // namespace marenv::wake