WavePropulsionHull.h

#ifndef WavePropulsionHull_H
#define WavePropulsionHull_H
 
#include <array>
#include <string>
 
#include "WaveHull.h"
 
#include <fhsim_environment/BodyFlowInteraction.h>
#include <fhsim_environment/WakeSourceSet.h>
 
class WavePropulsionHull : public WaveHull
{
public:
   WavePropulsionHull(std::string simObjectName, ISimObjectCreator* creator);
 
   void FinalSetup(double T, const double* X, ISimObjectCreator* creator) override;
   void PreOdeFcn(double T, const double* X) override;
 
   const double* ThrustPort(double T, const double* X);
   const double* RudderForcePort(double T, const double* X);
 
   const environment::wake::BodyFlowInteraction& Flow() const { return m_flow; }
 
protected:
   Loads                 ExtraLoads(double T, const double* X, const Dof& velocity) const override;
   std::array<Dof, 6>    ExtraLoadsVelocityJacobian(const Dof& velocity) const override;
   std::array<double, 3> WaterVelocity(double T, const double* X) const override;
   std::array<double, 3> HeldWaterVelocity() const override { return m_heldWater; }
 
private:
   class HullCaster final : public environment::wake::PropelledObject
   {
   public:
      explicit HullCaster(const WavePropulsionHull& hull)
          : m_hull(hull)
      {
      }
      environment::wake::WakeCastState      Reference(double T, const double* X) const override;
      void                                  CurrentLoad(double T, const double* X, const double freeStream[3], const double flowDir[3], double force[3],
                                           double& frontalArea, double rearCentre[3]) const override;
      environment::wake::PropellerJetInput PropellerJet(double T, const double* X) const override;
 
   private:
      const WavePropulsionHull& m_hull;
   };
 
   std::array<double, 3> Centre(const double* X) const;
 
   template<class S>
   struct Actuation
   {
      S thrust;
      S rudderNormalForce;
   };
 
   template<class S>
   Actuation<S> Actuate(double propellerSpeed, double rudderAngle, const S& u, const S& v, const S& r) const;
 
   template<class S>
   std::array<S, 6> LoadsOf(const Actuation<S>& actuation, double rudderAngle) const;
 
   void HoldInputs(double T, const double* X);
 
   ISignalPort* m_inPropellerSpeed = nullptr;
   ISignalPort* m_inRudderAngle    = nullptr;
 
   double m_diameter        = 0.0;
   double m_kt[3]           = {0.0, 0.0, 0.0};
   double m_wakeFraction    = 0.0;
   double m_thrustDeduction = 0.0;
   double m_propellerX      = 0.0;
   double m_propellerZ      = 0.0;
 
   double m_rudderArea       = 0.0;
   double m_liftSlope        = 0.0; 
   double m_rudderX          = 0.0;
   double m_rudderZ          = 0.0;
   double m_hullInteraction  = 0.0;
   double m_hullInteractionX = 0.0; 
   double m_slipstreamFactor = 0.0;
 
   double m_heldPropellerSpeed = 0.0; 
   double m_heldRudderAngle    = 0.0; 
 
   double                m_thrustOut = 0.0;
   std::array<double, 2> m_rudderForceOut {};
 
   HullCaster                             m_caster;           
   environment::wake::BodyFlowInteraction m_flow;             
   std::array<double, 3>                  m_heldWater {};     
};
 
#endif