WakeGroupCaster.h

#pragma once
 
#include <fhsim/ISimObjectLogger.h>
#include <fhsim_environment/WakeCaster.h>
#include <fhsim_environment/WakeSourceSet.h>
#include <limits>
#include <memory>
#include <string>
#include <vector>
 
namespace environment
{
class EnvironmentProvider;
} // namespace environment
 
namespace environment::wake::detail
{
 
class WakeGroupCaster final : public IndexedWakeCastingObject
{
public:
   WakeGroupCaster(std::string name, const SourceSetWakeSettings& settings, ISimObjectLogger& logger);
   ~WakeGroupCaster() override;
 
   void Register(EnvironmentProvider& environment);
 
   int Join(const std::string& member, double rho);
 
   void Attach(int member, const WakeCastingObject& body, double T);
 
   void Update(double T, const double* X);
 
   marenv::wake::WakeQuery Query() const;
   const WakeCaster* Caster() const { return m_caster.get(); }
   const std::string& Name() const { return m_name; }
   const SourceSetWakeSettings& Settings() const { return m_settings; }
 
   int NumBodies() const override { return static_cast<int>(m_members.size()); }
   WakeCastState Body(const double* X, int body) const override { return m_bodies[body]->Reference(X); }
   double BodyRadius(int body) const override { return m_bodies[body]->Radius(); }
   SourceLoad BodyLoad(const double* X, int body, const double bodyVel[3], const double waterVel[3]) const override { return m_bodies[body]->BodyLoad(X, bodyVel, waterVel); }
 
private:
   void LogNoMembers(double T);
   void LogMembersWithoutABody(double T);
   std::string MembersWithoutABody() const;
 
   std::string                           m_name;                                                                 
   SourceSetWakeSettings                 m_settings;                                                             
   ISimObjectLogger&                     m_logger;                                                               
   EnvironmentProvider*                  m_environment = nullptr;                                                
   std::unique_ptr<WakeCaster>           m_caster;                                                               
   double                                m_rho = 0.0;                                                            
   std::vector<std::string>              m_members;                                                              
   std::vector<const WakeCastingObject*> m_bodies;                                                               
   double                                m_completeAt                = std::numeric_limits<double>::quiet_NaN(); 
   double                                m_lastUpdate                = std::numeric_limits<double>::quiet_NaN(); 
   double                                m_firstUpdate               = std::numeric_limits<double>::quiet_NaN(); 
   bool                                  m_noMembersLogged           = false;                                    
   bool                                  m_membersWithoutABodyLogged = false;                                    
};
 
} // namespace environment::wake::detail