NetCableElement.h

 
 
#ifndef CNetCableElement_H
#define CNetCableElement_H
 
// Includes
// #include <string>
 
// #include <fhsim/FhSimMgr.h>
#include "NetCableElementSpec.h"
#include "cable/subroutines/CableElDynStiff.h"
 
#include <cmath>
#ifdef FH_VISUALIZATION
#   pragma warning(push)
#   pragma warning(disable : 4251)
#   include <Ogre.h>
#   pragma warning(pop)
 
#   include "sfh/ogre/CDynamicLines.h"
// #include "MeshGenerators.h"
#endif
 
// Class definition
class NetCableElement : public CableElDynStiff
{
public:
   NetCableElement();
 
   NetCableElement(const NetCableElement* old);
   NetCableElement(const NetCableElementSpec* spec);
 
   ~NetCableElement();
 
   // Calculates the end forces on the cable element.
   void AddEndForces(
         double       deltaT,
         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],
         bool         isScreen = false);
 
   void SetConstants();
 
   void CalcMassAndWeight();
 
   bool Divide(int aiNodes[2], int newNode, int newElementID, NetCableElement** sNewCable);
 
   bool CheckAndInitialize();
 
   void DeleteSpheresAndDisks();
 
   void AddSpheres(double* adD, double* adMass, double* adPos, std::vector<std::string> VsSphereMaterial, unsigned int num);
   void AddDisks(double* adD, double* adThickness, double* adMass, double* adPos, std::vector<std::string> VsDiskMaterial, unsigned int num);
 
   double GetStrainEnergy(double deltaT, const double adPosA[3], const double adVelA[3], const double adPosB[3], const double adVelB[3], const double adFluidVel[3], const double rhoWater);
 
   void StrainEnergyGradient(const double adPosA[3], const double adPosB[3], double gradA[3], double gradB[3]) const;
 
   double GetEffectiveStiffness() const { return m_eFactor * m_eA; }
 
   double GetMeanTensionForce() const { return (1 - m_eFactor) * m_meanTension; }
 
   double GetEffectiveDamping() const { return ma_dDampingCoeff * std::sqrt(m_eFactor); }
 
   double GetTangentialDragFactor() const { return ma_dTangentialDragFactor; }
 
   double GetNormalDragFactor() const { return ma_dNormalDragFactor; }
 
#ifdef FH_VISUALIZATION
   void RenderInit(Ogre::Root* ogreRoot);
 
   void RenderUpdate(const double adPosA[3], const double adPosB[3]);
#endif
   double                   m_nodeOffset;         
   int                      m_fromNodes[2];       
   int                      m_conn[2];            
   double                   m_refineFactor;       
   unsigned int             m_numSpheres;         
   double*                  m_sphereD;            
   double*                  m_sphereMass;         
   double*                  m_spherePos;          
   unsigned int             m_numDisks;           
   double*                  m_diskD;              
   double*                  m_diskThickness;      
   double*                  m_diskMass;           
   double*                  m_diskPos;            
   double                   m_addedWeightInWater; 
   std::vector<std::string> m_VsDiskMeshName;     
   std::vector<std::string> m_VsSphereMeshName;   
 
    double SurfaceHalfSize() const override;
 
 
protected:
    bool AppendagesNearTheSurface() override;
    double SphereWetFraction(unsigned int i) const;
    double DiskWetFraction(unsigned int i) const;
    void AddWaveExcitation(double adForceA[3], double adForceB[3]) const;
 
    bool   m_appendagesWereNearTheSurface = false;           
 
   void AddHydroForcesAppendices(double adForceA[3], double adForceB[3]);
 
   // Constants
   double m_dragCoeffSphere;             
   double m_normalDragCoeffDisk;         
 
#ifdef FH_VISUALIZATION
   Ogre::Entity**    m_renderSpheres;
   Ogre::SceneNode** m_renderNodeSpheres;
   Ogre::Entity**    m_renderDisks;
   Ogre::SceneNode** m_renderNodeDisks;
#endif
};
 
 
#endif