CableElBasics.h

 
 
#ifndef CCableElBasics_H
#define CCableElBasics_H
 
// Includes
#include <fhsim_environment/hydrodynamics/CylinderHydro.h>
#include <fhsim_environment/hydrodynamics/WetCylinderLaw.h>
 
#include <assert.h>
#include <fhsim/Exceptions.h>
#include <string>
 
#ifdef FH_VISUALIZATION
#   undef ATTACH_SPHERE
// #define SIMPLE_LINE_RENDERING
#   pragma warning(push)
#   pragma warning(disable : 4251)
#   include <Ogre.h>
#   pragma warning(pop)
#   include "sfh/ogre/CDynamicLines.h"
#endif
 
// kMaxCompressionSpeedSaturation, kMinLengthSaturation and kMaxLengthSaturation: CalcFoundation bounds
// the stored length (the drag uses it too) and compression speed with them.
#include "cable/subroutines/CableAxialLaw.h"
 
// Class definition
 
class CableElBasics
{
public:
   CableElBasics();
 
   ~CableElBasics();
 
   virtual void AddEndForces(
         const double adPosA[3],
         const double adVelA[3],
         const double adPosB[3],
         const double adVelB[3],
         const double adFluidVel[3],
         const double rhoWater,
         double       adForceA[3],
         double       adForceB[3]);
 
   virtual void SetConstants();
 
   virtual void CalcMassAndWeight();
 
   virtual bool CheckAndInitialize();
 
   double GetDampingCoeff() const { return ma_dDampingCoeff; }
 
   virtual void UpdateLength(double newLength);
 
   double GetLength();
#ifdef FH_VISUALIZATION
   virtual void RenderInit(Ogre::Root* ogreRoot);
 
   virtual void RenderUpdate(const double adPosA[3], const double adPosB[3]);
 
   const double* const GetDirection() { return ma_adDirection; }
#endif
   unsigned long m_iD;                      
   std::string   m_cableName;               
   double        m_dL0;                     
   double        m_dD;                      
   double        m_dE;                      
   double        m_rho;                     
   double        m_addedWeightInWater;      
   double        m_tangentialFrictionCoeff; 
   double        m_normalDragCoeff;         
   double        m_rhoWater;                
   double        m_rhoWaterFull = 1025.0;   
   double        m_rhoAir = 1.2;            
 
   void SetSurfaceElevation(double etaA, double etaB)
   {
      m_surfaceElevation[0] = etaA;
      m_surfaceElevation[1] = etaB;
   }
 
   virtual double SurfaceHalfSize() const { return 0.5 * m_dD; }
 
   void SetWaveAcceleration(const double acceleration[3])
   {
      for (int k = 0; k < 3; k++)
         m_waveAcceleration[k] = acceleration[k];
   }
 
 
   double InertiaShare() const;
 
   void WaveExcitationPositionJacobian(const double posA[3], const double posB[3], const double acceleration[3], double dF_dpB[9]) const;
 
   void DragVelocityJacobian(
         const double posA[3], const double posB[3],
         const double velA[3], const double velB[3],
         const double vFluid[3], double rhoWater,
         double dFA_dvA[9], double dFA_dvB[9],
         double dFB_dvA[9], double dFB_dvB[9]) const;
 
   void DragPositionJacobian(
         const double posA[3], const double posB[3],
         const double velA[3], const double velB[3],
         const double vFluid[3], double rhoWater,
         double dFA_dpA[9], double dFA_dpB[9],
         double dFB_dpA[9], double dFB_dpB[9]) const;
 
   double BlendedFluidDensity(const double posA[3], const double posB[3]) const;
   double        m_minLength;               
   double        m_maxTension;              
   double        m_dampingRatio;            
 
   // Calculated properties.
   double m_eA;                       
   double m_dA;                       
   double m_weightInWater[2];         
   double m_massInWater[2];           
   double m_weightInWaterPerMeter[2]; 
   double m_massInWaterPerMeter[2];   
#ifdef FH_VISUALIZATION
   std::string    m_materialName; 
   unsigned short m_cableFaces;   
   double         m_drawScale;    
#endif
protected:
   virtual bool AppendagesNearTheSurface() { return false; }
 
   double m_surfaceElevation[2] = {0.0, 0.0}; 
   double m_submergence[2]      = {1e10, 1e10}; 
   double m_axisVertical        = 0.0;          
   double m_wetFraction         = 1.0;          
   double m_waveAcceleration[3] = {0.0, 0.0, 0.0}; 
 
   double WetFractionAt(const double posA[3], const double posB[3], double submergence[2], double& axisVertical) const;
 
   void AddWaveExcitationCable(double adForceA[3], double adForceB[3]) const;
 
   void CalcFoundation(const double adPosA[3],
         const double               adVelA[3],
         const double               adPosB[3],
         const double               adVelB[3],
         const double               adFluidVel[3],
         const double               rhoWater);
 
   virtual void AddStructuralForces(double adForceA[3], double adForceB[3]) = 0;
 
   void AddGravityBuoyancy(double adForceA[3], double adForceB[3], const double adPosA[3], const double adPosB[3]);
 
   void AddHydroForcesCable(double adForceA[3], double adForceB[3]);
 
 
   // For computational efficiency.
   double ma_adDirection[3];        
   double ma_dDampingCoeff;         
   double ma_adVel[3];              
   double ma_dVelAmp;               
   double ma_adVt[3];               
   double ma_dVtAmp;                
   double ma_adVn[3];               
   double ma_dVnAmp;                
   double ma_adVn_A[3];             
   double ma_adVn_B[3];             
   double ma_dVnAmp_A;              
   double ma_dVnAmp_B;              
   double ma_adVt_A[3];             
   double ma_adVt_B[3];             
   double ma_dVtAmp_A;              
   double ma_dVtAmp_B;              
   double ma_dLength;               
   double ma_dCompressionSpeed;     
 
#ifdef FH_VISUALIZATION
   Ogre::Root*         m_ogreRoot;      
   Ogre::SceneManager* m_sceneMgr;      
   Ogre::Entity*       m_renderElement; 
   Ogre::SceneNode*    m_renderNode;    
   CDynamicLines*      m_lines;         
   Ogre::ManualObject* m_cableRenderObj;
   double              m_drawDiam; 
#   ifdef ATTACH_SPHERE
   Ogre::Entity*    m_renderSphere;
   Ogre::SceneNode* m_renderNodeSphere;
#   endif
 
#endif
};
 
 
#endif