WaveHull.h

#ifndef WaveHull_H
#define WaveHull_H
 
#include <array>
#include <fhsim/simobject/SimObject.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include <string>
#include <vector>
 
class WaveHull : public SimObject
{
public:
   using Dof = std::array<double, 3>;
   using Loads = std::array<double, 6>;
 
   WaveHull(std::string simObjectName, ISimObjectCreator* creator);
 
   void FinalSetup(double T, const double* X, ISimObjectCreator* creator) override;
 
   void OdeFcn(double T, const double* X, double* XDot) const override;
 
   bool HasJacobians() const override { return true; }
   void OdeJacobian(double T, const double* X, double* J, int nStates) override;
   int  GetJacobianSparsity(int /*nStates*/, int* /*rowPtr*/, int* /*colIdx*/) override { return -1; }
 
#ifdef FH_VISUALIZATION
   void RenderInit(Ogre::Root* ogreRoot, ISimObjectCreator* creator) override;
   void RenderUpdate(double T, const double* X) override;
#endif
 
   Dof RawWaveLoads(double T, const double* pose) const;
 
   const double* MotionPort(double T, const double* X);
   const double* MotionRatePort(double T, const double* X);
   const double* ExcitationPort(double T, const double* X);
   const double* VelocityPort(double T, const double* X);
   const double* PositionPort(double T, const double* X);
   const double* RotationPort(double T, const double* X);
 
protected:
   virtual Loads ExtraLoads(double /*T*/, const double* /*X*/, const Dof& /*velocity*/) const { return {}; }
 
   virtual std::array<Dof, 6> ExtraLoadsVelocityJacobian(const Dof& /*velocity*/) const { return {}; }
 
   virtual std::array<double, 3> WaterVelocity(double /*T*/, const double* /*X*/) const { return {0.0, 0.0, 0.0}; }
 
   virtual std::array<double, 3> HeldWaterVelocity() const { return {0.0, 0.0, 0.0}; }
 
   static Dof InBodyFrame(const std::array<double, 3>& water, double psi);
 
   Dof VelocityThroughWater(double T, const double* X) const;
 
   Dof HullDamping(const Dof& velocity) const;
 
   double Length() const { return m_length; }
   double Breadth() const { return m_breadth; }
   double Lcf() const { return m_lcf; }
   double Draught() const { return m_draught; }
   double Rho() const { return m_rho; }
   int    MotionIndex() const { return m_indexMotion; }
   int    RateIndex() const { return m_indexRate; }
   int    PoseIndex() const { return m_indexPose; }
   int    VelocityIndex() const { return m_indexVelocity; }
 
private:
   struct SamplePoint
   {
      double x;
      double y;
   };
 
   void   BuildFootprint(double length, double breadth, double lcf, int sampleLevel);
   double RotationalStiffness(ISimObjectCreator* creator, const std::string& gmName, const std::string& periodName,
         double mass, double inertia) const;
 
   Dof VerticalAccelerations(const double* motion, const double* rate, const Dof& load) const;
   Dof HorizontalAccelerations(const double* velocity, const Dof& load) const;
 
 
   environment::EnvironmentProvider* m_environment = nullptr;
 
   int m_indexMotion     = 0;
   int m_indexRate       = 0;
   int m_indexExcitation = 0;
   int m_indexPose       = 0;
   int m_indexVelocity   = 0;
 
   double m_rho                  = 0.0;
   double m_waterplaneArea       = 0.0;
   double m_filterTime           = 0.0;
   double m_rollQuadraticDamping = 0.0;
 
   Dof    m_inertia {};   
   Dof    m_stiffness {}; 
   Dof    m_damping {};   
   double m_a35 = 0.0;
   double m_b35 = 0.0;
   double m_c35 = 0.0;
 
   double m_mass = 0.0;
   double m_a11  = 0.0;
   double m_a22  = 0.0;
   Dof    m_horizontalInertia {};          
   Dof    m_horizontalLinearDamping {};    
   Dof    m_horizontalQuadraticDamping {}; 
 
   std::vector<SamplePoint> m_samples;
   double                   m_sampleWeight = 0.0; 
 
   std::array<double, 3> m_positionOut {}; 
   std::array<double, 3> m_rotationOut {}; 
 
   double m_length  = 0.0;
   double m_breadth = 0.0;
   double m_lcf     = 0.0;
   double m_draught = 0.0; 
 
#ifdef FH_VISUALIZATION
   Ogre::SceneNode* m_renderNode = nullptr;
#endif
};
 
#endif