NetWakeCaster.h

#pragma once
 
#include "../hydrodynamics/PanelLoadTypes.h"
 
#include <fhsim/ISimObjectLogger.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include <fhsim_environment/WakeCaster.h>
#include <fhsim_environment/WakeSchedule.h>
#include <marenv/EnvironmentFacade.h>
#include <marenv/wake/LumpedSource.h>
#include <marenv/wake/WakeField.h>
#include <marenv/wake/WakeTypes.h>
#include <memory>
#include <string>
 
class ISimObjectCreator;
 
namespace net_wake
{
 
using WakeUpdate = environment::wake::WakeUpdate;
 
using WakeEvaluation = environment::wake::WakeEvaluation;
 
using WakeSettings = environment::wake::SourceSetWakeSettings;
 
inline WakeSettings ReadWakeSettings(ISimObjectCreator* creator)
{
   return environment::wake::ReadSourceSetWakeSettings(creator);
}
 
struct PanelEvaluation
{
   hydrodynamics::PanelLoad<double> load;           
   double                           area     = 0.0; 
   double                           solidity = 0.0; 
};
 
class WakePanelSource
{
public:
   virtual ~WakePanelSource() = default;
 
   virtual int NumNodes() const = 0;
   virtual int NumPanels() const = 0;
   virtual void PanelNodes(int panel, int nodes[3]) const = 0;
   virtual void NodePosition(const double* X, int node, double pos[3]) const = 0;
   virtual void NodeVelocity(const double* X, int node, double vel[3]) const = 0;
   virtual int NumCables() const { return 0; }
   virtual void CableNodes(int /*cable*/, int nodes[2]) const { nodes[0] = nodes[1] = 0; }
 
   virtual PanelEvaluation EvaluatePanel(const double* X, int panel, const double elementVel[3], const double waterVel[3]) const = 0;
 
   virtual void CableHydrodynamicForce(double T, const double* X, double force[3]) const
   {
      force[0] = force[1] = force[2] = 0.0;
   }
};
 
void PanelCentroid(const WakePanelSource& structure, const double* X, int panel, double centroid[3], double (*corners)[3] = nullptr);
 
class PanelSourceSet : public environment::wake::WakeSourceSet
{
public:
   explicit PanelSourceSet(const WakePanelSource& structure)
       : m_structure(structure)
   {
   }
 
   int  NumCarriers() const override { return m_structure.NumNodes(); }
   void CarrierPosition(const double* X, int carrier, double pos[3]) const override { m_structure.NodePosition(X, carrier, pos); }
   void CarrierVelocity(const double* X, int carrier, double vel[3]) const override { m_structure.NodeVelocity(X, carrier, vel); }
   int  NumSources() const override { return m_structure.NumPanels(); }
   int  SourceCarriers(int source, int carriers[3]) const override;
   double SourceArea(const double* X, int source) const override;
   environment::wake::SourceLoad EvaluateSource(const double* X, int source, const double sourceVel[3], const double waterVel[3]) const override;
   std::string DescribeRebuild(double T, const double* X, const marenv::wake::LumpedSourceInput& lumped) const override;
   const char* SourceNoun() const override { return "panels"; }
   const char* ObjectNoun() const override { return "net"; }
   int NumSamplePoints() const override { return m_structure.NumPanels() + m_structure.NumCables(); }
   int SamplePointCarriers(int point, int carriers[3]) const override;
 
private:
   const WakePanelSource& m_structure;
};
 
class NetWakeCaster
{
public:
   NetWakeCaster(std::string name, const WakeSettings& settings, double rho);
   ~NetWakeCaster();
 
   void Register(environment::EnvironmentProvider& environment) { m_caster.Register(environment); }
 
   void Update(double T, const double* X, const WakePanelSource& structure, ISimObjectLogger& logger);
 
   std::shared_ptr<marenv::wake::WakeField> LumpedField() const { return m_caster.LumpedField(); }
   std::shared_ptr<marenv::wake::WakeField> PrivateField() const { return m_caster.PrivateField(); }
   marenv::wake::WakeQuery PanelQuery() const { return m_caster.Query(); }
 
   const marenv::wake::LumpedSourceInput& LastLumpedInput() const { return m_caster.LastLumpedInput(); }
   const marenv::wake::LumpedSourceResult& LastLumpedSource() const { return m_caster.LastLumpedSource(); }
 
   int NumRebuilds() const { return m_caster.Schedule().NumRebuilds(); }
   bool Frozen() const { return m_caster.Schedule().Frozen(); }
   double LastChange() const { return m_caster.Schedule().LastChange(); }
   double LastRebuildSeconds() const { return m_caster.LastRebuildSeconds(); }
   const double* SourceVelocity() const { return m_caster.SourceVelocity(); }
   const marenv::wake::WakeFrame& LastFrame() const { return m_caster.LastFrame(); }
   const marenv::wake::GridSpec& LastGrid() const { return m_caster.LastGrid(); }
   double LastGridCutoff() const { return m_caster.LastGridCutoff(); }
 
private:
   std::string                   m_name;                               
   environment::wake::WakeCaster m_caster;                             
   bool                          m_updateBeforeRegisterLogged = false; 
};
 
} // namespace net_wake