TrawlDoorBase.h

#pragma once
 
#include "sfh/sim/kinematics.h"
 
#include <fhsim/simobject/SimObject.h>
#include <fhsim_environment/BodyFlowInteraction.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include <fhsim_environment/WakeSourceSet.h>
#include <fhsim_environment/hydrodynamics/PlateGeometry.h>
#include <math.h>
#include <string>
 
 
#ifdef FH_VISUALIZATION
#   include "OgreParticleSystem.h"
#   ifdef USE_BILLBOARD_LABELS
#      include "sfh/ogre/CMovableText.h"
#   endif
#endif
 
// #define TD_AR 1.45
// #define TD_C_X 0.11
// #define TD_C_Z 0.22
// #define TD_OUT_OF_BOUND_COEFF {0.2, 1.2, 0.4, 1.0, 1.0, 1.0}
 
class TrawlDoorBase : public SimObject
{
public:
   TrawlDoorBase(std::string simObjectName, ISimObjectCreator* creator);
 
   virtual void OdeFcn(const double dT, const double* const adX, double* const adXDot) const override;
 
   bool HasJacobians() const override;
   void OdeJacobian(double T, const double* X, double* J, int nStates) override;
   int  GetJacobianSparsity(int nStates, int* rowPtr, int* colIdx) override;
 
   void PreOdeFcn(double T, const double* X, IStateUpdater* updater) override;
 
 
#ifdef FH_VISUALIZATION
   virtual void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
 
   virtual void RenderUpdate(const double dT, const double* const adX);
#endif
 
protected:
   virtual void TD_HydroForces(const double relVel[], double* alpha, double* beta, double* pU, double forceSS[]) const;
   // virtual void TD_AngularDamping(double rho, double TD_ARea, const double relVel[], double angDamp[]);
   virtual void TD_HydroForces_SS(double TD_Area, double rho, const double relVel[], double alpha, double beta, double U, double* coeffSS, double* forceSS) const;
   virtual void TD_HydroCoeff_SS(double alpha, double beta, double coeffSS[]) const;
   virtual void TD_vel2HydroAng(const double relVel[], double* alpha, double* beta, double* pU) const;
   void         HydroForceAt(const double* X, const double relVel_n[3], double force_n[3]) const;
   void         AddQuaternionKinematicsJacobian(const double* quater, const double* omega, double* J, int nStates, int quaterIndex, int omegaIndex) const;
   void         OutOfBoundRotationalDamping(double T, const double* X, double damping[3]);
   virtual void AddExternalForces(double dT, const double* const adX);
   virtual void AddInternalForces();
   virtual void AddHydroForces();
   virtual void AddInflowDependentForces(double dT, const double* const adX) { }
   virtual void AddDampingForces();
   virtual void AddBottomForces() { };
   virtual void CalcDerivatives(double dT, double* const adXDot, const double* const adX);
   virtual void CalcFoundation(const double dT, const double* const adX, double* const adXDot);
   virtual void AddExternalForce(const double adPos_d[3], const double adForceExternal_n[3]);
   virtual void CalcOutput(const double dT, const double* const adX);
   void         CalcOutputCommon(const double dT, const double* const adX) const;
   void         FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const creator);
   // Geometry and properties
   bool   m_isPort; 
   double m_cOG[3]; 
   double m_area;   
   double m_height;
   double m_length;
   double m_aR;
   double m_curvature;
   double m_mass; 
   double m_massInverse[6][6];
   double m_rigidInertia[6]; 
   double m_addedMass[6];    
   double m_mdCornerPos_body[4][3];
   double m_rhoDoor; 
 
   // Hydrodynamic forces
   double m_outOfBoundCoeff[6];
   double m_hydrodynamicCorrections[6];
 
   // Fastening points
   double m_warpPos_d[3]; 
   double m_lBPos_d[3];   
   double m_uBPos_d[3];   
 
   // External
   double              m_rhoWater;      
   double              m_force_warp[3]; 
   double              m_force_LB[3];   
   double              m_force_UB[3];   
   double              m_waterVel_n[3]; 
   ICommonComputation* m_commonCalc;    
 
   class DoorCaster final : public environment::wake::WakeCastingObject
   {
   public:
      explicit DoorCaster(const TrawlDoorBase& door)
          : m_door(door)
      {
      }
 
      environment::wake::WakeCastState Reference(const double* X) const override;
      void CurrentLoad(const double* X, const double freeStream[3], const double flowDir[3], double force[3], double& frontalArea,
            double rearCentre[3]) const override;
      double Radius() const override;
      environment::wake::SourceLoad BodyLoad(const double* X, const double bodyVel[3], const double waterVel[3]) const override;
 
   private:
      void PlateAxes(const double* X, double normal[3], double chordAxis[3]) const;
      environment::plate_geometry::Plate Plate() const;
 
      const TrawlDoorBase& m_door;
   };
 
   environment::EnvironmentProvider*      m_environment = nullptr; 
   DoorCaster                             m_caster;                
   environment::wake::BodyFlowInteraction m_flow;                  
   double                                 m_time = 0.0;            
 
   // Input ports
   ISignalPort* m_inWarp_F; 
   ISignalPort* m_inLB_F;   
   ISignalPort* m_inUB_F;   
 
   // Output ports
   const double* OutPos1(const double dT, const double* const adX);
   const double* OutPos3(const double dT, const double* const adX);
   const double* OutPos2(const double dT, const double* const adX);
   const double* OutVel1(const double dT, const double* const adX);
   const double* OutVel3(const double dT, const double* const adX);
   const double* OutVel2(const double dT, const double* const adX);
 
   double m_outPos1[3];
   double m_outPos3[3];
   double m_outPos2[3];
   double m_outVel1[3];
   double m_outVel3[3];
   double m_outVel2[3];
 
   unsigned long m_IStatePos;        
   unsigned long m_IStateQuater;     
   unsigned long m_IStateLocalVel;   
   unsigned long m_IStateOmega;      
   unsigned long m_IStateHydroForce; 
 
   // For computational efficiency
   double ma_adSumForces[6];
   double ma_dAlpha;
   double ma_dBeta;
   double ma_dU;
 
   double m_outAlpha;
 
   const double* ma_adXPos_n;
   const double* ma_adXQuater;
   const double* ma_adXVel_d;
   const double* ma_adXOmega;
 
   double ma_mdR[3][3];
   double ma_adXVel_n[3];
   double ma_adHydroForceSS[6];
   double ma_adRelVel_d[6];
   double ma_adWaterVel_d[3];
 
#ifdef FH_VISUALIZATION
   void                   BottomContactRenderInit();
   void                   RenderBottomContact(double depth, double m_cornerPos_ned[4][3], double m_submergence[4]);
   Ogre::ParticleSystem*  m_particleSystem;
   Ogre::SceneNode*       m_particleNode;
   Ogre::ParticleEmitter* m_particleEmitter;
   Ogre::Vector3          m_visualizationScale;
 
   std::string         m_meshName; 
   double              m_visScale;
   double              m_lengthScale;
   double              m_heightScale;
   double              m_curvatureScale;
   Ogre::Entity*       m_renderEntity;
   Ogre::SceneNode*    m_renderNode;
   Ogre::Quaternion    m_InitOrientation;
   Ogre::SceneManager* m_sceneMgr;
 
#   ifdef USE_BILLBOARD_LABELS
   Ogre::SceneNode*    m_BBRenderNode;
   Ogre::CMovableText* m_BBTxt;
   double              m_bBTxtSize;
#   endif
#endif
};