WakeCaster.h

#pragma once
 
#include <algorithm>
#include <fhsim/ISimObjectLogger.h>
#include <fhsim_environment/WakeSchedule.h>
#include <fhsim_environment/WakeSourceSet.h>
#include <marenv/wake/LumpedSource.h>
#include <marenv/wake/WakeField.h>
#include <marenv/wake/WakeRegistry.h> // WakeQuery
#include <marenv/wake/WakeSelection.h>
#include <marenv/wake/WakeTypes.h>
#include <memory>
#include <string>
#include <vector>
 
class ISimObjectCreator;
 
namespace marenv::wake
{
class GriddedWake;
class SourceSetWake;
class WakeBuilder;
} // namespace marenv::wake
 
namespace environment
{
class EnvironmentProvider;
} // namespace environment
 
namespace environment::wake
{
 
namespace detail
{
 
struct RebuildSource;
struct PrivateSources;
 
class WakeCaster
{
public:
   WakeCaster(std::string name, const SourceSetWakeSettings& settings, double rho);
   ~WakeCaster();
 
   void Register(EnvironmentProvider& environment);
 
   void Update(double T, const double* X, const WakeSourceSet& set, ISimObjectLogger& logger);
 
   std::shared_ptr<marenv::wake::WakeField> Field() const;
   std::shared_ptr<marenv::wake::WakeField> PrivateField() const { return m_privateField; }
   marenv::wake::WakeQuery Query() const;
 
   const OwnSourceMap& OwnSources() const { return m_ownSources; }
 
   void ExcludeJet(const marenv::wake::JetField* jet) { m_excludeJet = jet; }
 
   const marenv::wake::LumpedSourceInput& LastLumpedInput() const { return m_lastLumpedInput; }
   const marenv::wake::LumpedSourceResult& LastSource() const { return m_lastLumpedSource; }
   const WakeSchedule& Schedule() const { return m_schedule; }
   double LastRebuildSeconds() const { return m_lastRebuildSeconds; }
   const double* SourceVelocity() const { return m_sourceVelocity; }
   const marenv::wake::WakeFrame& LastFrame() const { return m_lastFrame; }
   const marenv::wake::GridSpec& LastGrid() const { return m_lastGrid; }
   double LastGridCutoff() const { return m_lastGridCutoff; }
 
private:
   bool SkipMalformedSource(double T, const WakeSourceSet& set, ISimObjectLogger& logger);
   bool SkipNonFiniteCarrier(double T, const double* X, const WakeSourceSet& set, ISimObjectLogger& logger);
   void FilterCarrierVelocities(double T, const double* X, const WakeSourceSet& set);
   void SourcePosition(double source[3]) const;
   bool AmbientCurrentAtSource(double T, const double source[3], double current[3]) const;
   void Rebuild(double T, const double* X, const WakeSourceSet& set, bool lookupFailed, ISimObjectLogger& logger);
   std::vector<RebuildSource> CollectSources(double T, const double* X, const WakeSourceSet& set, marenv::wake::HeldWakes& others) const;
   marenv::wake::WakeFrame MakeFrame(double T, const std::vector<RebuildSource>& sources, const std::vector<double>& weights, int numCarriers, double meanRelativeFlow[3]);
   PrivateSources MarchPrivateSources(double T, const double* X, const WakeSourceSet& set, const std::vector<RebuildSource>& sources, const marenv::wake::HeldWakes& others, marenv::wake::WakeBuilder* builder) const;
   std::string PublishPrivate(double T, marenv::wake::SourceSet sources, marenv::wake::WakeBuilder* builder, const double published[3], double blendTime);
   bool CurrentLookupFails(double T, const WakeSourceSet& set, double failedAt[3]) const;
   void PublishWithoutLumpedWake(double T, marenv::wake::SourceSet sources, marenv::wake::WakeBuilder* builder, const double frameOrigin[3]);
   void HoldForFailedLookup(double T, const double* X, const WakeSourceSet& set, const double failedAt[3], ISimObjectLogger& logger);
   void HoldLumpedWakeForFailedLookup(double T, const double failedAt[3], ISimObjectLogger& logger);
   struct BuildChange
   {
      double ratio    = -1.0; 
      double momentum = -1.0; 
      double Measure() const { return std::max(ratio, momentum); }
   };
   BuildChange MeasureChange(const std::vector<double>& ratios) const;
   void PublishLumped(double T, const double published[3], const double frameOrigin[3]);
   std::string LumpedRebuildLine(double T, double flowSpeed) const;
   void LogRebuild(double T, const double* X, const WakeSourceSet& set, int numCast, int numSources, double meanFlowSpeed, const BuildChange& change, const std::string& warning,
         ISimObjectLogger& logger);
   void BuildLumped(const marenv::wake::LumpedSourceInput& input);
   std::string LumpedDescription() const;
 
   std::string                                  m_name;                  
   SourceSetWakeSettings                        m_settings;              
   double                                       m_rho;                   
   marenv::wake::KernelParams                   m_privateKernel;         
   marenv::wake::KernelParams                   m_lumpedKernel;          
   WakeSchedule                                 m_schedule;              
   EnvironmentProvider*                         m_environment = nullptr; 
   std::shared_ptr<marenv::wake::SourceSetWake> m_lumpedField;           
   std::shared_ptr<marenv::wake::WakeField>     m_privateField;          
   std::shared_ptr<marenv::wake::GriddedWake>   m_griddedField;          
   std::shared_ptr<marenv::wake::SourceSetWake> m_directField;           
   const marenv::wake::JetField*                m_excludeJet = nullptr;  
   OwnSourceMap                                 m_ownSources;            
 
   std::vector<double> m_filteredCarrierVel;                  
   double              m_sourceVelocity[3] = {0.0, 0.0, 0.0}; 
   std::vector<double> m_carrierWeights;                      
   std::vector<double> m_carrierPositions;                    
 
   std::string                      m_lastWarning;               
   double                           m_lastRebuildSeconds = 0.0;  
   marenv::wake::WakeFrame          m_lastFrame {};              
   marenv::wake::GridSpec           m_lastGrid {};               
   double                           m_lastGridCutoff = 0.0;      
   std::vector<double>              m_previousRatios;            
   std::vector<double>              m_previousDeficits;          
   double                           m_previousMomentum = 0.0;    
   marenv::wake::LumpedSourceInput  m_lastLumpedInput {};        
   marenv::wake::LumpedSourceResult m_lastLumpedSource {};       
   bool                             m_hasLumped         = false; 
   bool                             m_skippingNonFinite = false; 
   bool                             m_skippingMalformed = false; 
};
 
} // namespace detail
 
} // namespace environment::wake