JetField.h

#pragma once
 
#include <marenv/marenv.h>
#include <marenv/wake/WakeField.h> // WakeQueryRegion
#include <marenv/wake/WakeSampleParts.h> // BlendWeight
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <span>
 
namespace marenv::wake
{
struct JetSample
{
    double velocity[3]; 
};
 
struct JetBlendSum
{
    bool inside        = false; 
    double velocity[3] = {0.0, 0.0, 0.0}; 
 
    void Add(double share, const JetSample& sample)
    {
        inside = true;
        for (int i = 0; i < 3; ++i)
            velocity[i] += share * sample.velocity[i];
    }
 
    void Add(double share, const JetBlendSum& part)
    {
        inside = true;
        for (int i = 0; i < 3; ++i)
            velocity[i] += share * part.velocity[i];
    }
 
    Status ToSample(JetSample& out) const
    {
        for (int i = 0; i < 3; ++i)
            out.velocity[i] = inside ? velocity[i] : 0.0;
        return inside ? Status::OK : Status::ERROR_NOT_SET;
    }
};
 
struct JetBlendSamples
{
    bool currentInside = false; 
    JetSample current {}; 
    JetBlendSum previous {}; 
    double start = 0.0; 
    double time  = 0.0; 
 
    JetBlendSum At(double t) const
    {
        JetBlendSum sum;
        const double weight = BlendWeight(t, start, time);
        if (weight > 0.0 && currentInside)
            sum.Add(weight, current);
        if (weight < 1.0 && previous.inside)
            sum.Add(1.0 - weight, previous);
        return sum;
    }
};
 
struct JetSampleParts
{
    bool blending = false; 
    Status status = Status::ERROR_NOT_SET; 
    JetSample sample {}; 
    JetBlendSamples blend {}; 
 
    Status At(double t, JetSample& out) const
    {
        if (!blending) {
            out = sample;
            return status;
        }
        return blend.At(t).ToSample(out);
    }
};
 
struct JetSourceInput
{
    double pos[3]; 
    double shaftDir[3]; 
    double propellerDiameter; 
    double effectiveThrust; 
    double advanceSpeed; 
    double rho; 
};
 
class JetField : private marenv::NoCopyNoMove
{
public:
    virtual ~JetField() = default;
 
    virtual Status Sample(double t, const double pos[3], JetSample& out) const = 0;
 
    virtual JetSampleParts SampleParts(double t, const double pos[3]) const
    {
        JetSampleParts parts;
        parts.status = Sample(t, pos, parts.sample);
        return parts;
    }
 
    virtual bool MayReach(const WakeQueryRegion& region) const
    {
        (void)region;
        return true;
    }
 
    virtual std::uint64_t Revision() const { return 0; }
 
    virtual bool StaticFrom(double t) const
    {
        (void)t;
        return false;
    }
 
    virtual void SampleMany(double t, std::span<const std::array<double, 3>> positions, std::span<JetSample> out, std::span<Status> status) const
    {
        for (std::size_t i = 0; i < positions.size(); ++i)
            status[i] = Sample(t, positions[i].data(), out[i]);
    }
 
    virtual void Sketch(double t, FieldSketch& out) const
    {
        (void)t;
        (void)out;
    }
 
protected:
    JetField() = default;
};
} // namespace marenv::wake