NetCableElementTest.h

 
 
#ifndef CNetCableElementTest_H
#define CNetCableElementTest_H
 
 
#include <string>
#include <vector>
 
#include "sfh/math.h"
#include "sfh/linalg.h"
#include "NetVec3f.h"
 
#include "NetCableElementTestSpec.h"
#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 NetCableElementTest 
{
public:
    static float m_rhoWater;
    static float m_dragCoeffSphere;     
    static float m_normalDragCoeffDisk; 
    static float m_tangentialFrictionCoeffDisk; 
    static float m_tangentialDragCoeffDisk;
    static float m_tangentialFrictionCoeff;
 
    NetCableElementTest();
 
    NetCableElementTest(const NetCableElementTest* old);
    NetCableElementTest(const NetCableElementTestSpec* spec);
 
    ~NetCableElementTest();
 
    void AddEndForces(const double rhoWater,const NetVec3f  &posa,const NetVec3f &posb,const NetVec3f &vela,const NetVec3f &velb,const NetVec3f &velf, NetVec3f &forceA,NetVec3f &forceB, double angle );
 
    void SetConstants();
 
    void CalcMassAndWeight();
 
    bool Divide(int aiNodes[2], int newNode, int newElementID, NetCableElementTest** sNewCable);
 
    bool CheckAndInitialize();
 
    void DeleteSpheresAndDisks();
 
    void AddSpheres(float* adD, float* adMass, float* adPos, std::vector<std::string> VsSphereMaterial, int num);
    void AddDisks(float* adD, float* adThickness, float* adMass, float* adPos, std::vector<std::string> VsDiskMaterial, int num);
 
#ifdef FH_VISUALIZATION
    void RenderInit(Ogre::Root* ogreRoot);
 
    void RenderUpdate( const double adPosA[3], const double adPosB[3]);
#endif
    int                         m_conn[2];          
    int                         m_numSpheres;           
    float*                      m_sphereD;          
    float*                      m_sphereMass;           
    float*                      m_spherePos;            
    int                         m_numDisks;         
    float*                      m_diskD;                
    float*                      m_diskThickness;        
    float*                      m_diskMass;         
    float*                      m_diskPos;          
    //float                     m_addedWeightInWater;   ///< The weight in water added to the element.
    std::vector<std::string>    m_VsDiskMeshName;       
    std::vector<std::string>    m_VsSphereMeshName;     
 
public:
 
    void AddHydroForcesAppendices(double adForceA[3], double adForceB[3]);
 
    // Constants
 
#ifdef FH_VISUALIZATION
    Ogre::Entity**              m_renderSpheres;
    Ogre::SceneNode**           m_renderNodeSpheres;
    Ogre::Entity**              m_renderDisks;
    Ogre::SceneNode**           m_renderNodeDisks;
    std::string m_materialName;
    int m_cableFaces;
    float m_drawScale;
 
#endif
    std::string m_cableName;
 
    NetVec3f n;
    NetVec3f n2[2];
 
    NetVec3f vel;
    NetVec3f vel_t;
    NetVec3f vel_n;
    NetVec3f vel_n_a;
    NetVec3f vel_n_b;
    
    NetVec3f f_struct;  
    NetVec3f f_drag_a, f_drag_b;
 
    NetVec3f force_sphere_a;
    NetVec3f force_sphere_b;
    NetVec3f force_disk_a,force_disk_b;
 
    int m_iD;
    float m_dL0;
    float m_dD;
    float m_dhyd;
    float m_dE;
    float m_rho;
    float m_normalDragCoeff;
 
    float m_dampingRatio;
//  float ma_dVelAmp;
//  float ma_adVel[3];
//  float ma_adVt[3];
//  float ma_adVn[3];
    float m_massInWater[2];
    float m_weightInWater[2];
    //float m_massInWaterPerMeter[2];
    //float m_weightInWaterPerMeter[2];
    //float ma_adDirection[3];
    float m_dL0Inv;
    //float ma_dVtAmp;
    //float ma_dVnAmp;
    float lengthArray[3];
    float compressionvelArray[3];
    float m_length;
    float m_compressionSpeed;
//  float minLength;
//  float minCompressionVel;
//  float maxLength;
//  float maxCompressionVel;
    float velArray[3];
    float structForceArray[3];
    float ma_dDampingCoeff;
    float m_eA;
    float ma_dNormalDragFactor;
    float ma_dTangentialDragFactor;
    float m_dA;
 
    float m_dragReduction;
    float m_projectedArea;
    float m_normalVelocity;
};
 
// The vector members need 16 byte alignment; C++17 operator new keeps it, no custom allocator is needed.
static_assert(alignof(NetCableElementTest) >= 16);
 
 
 
#endif