NetCableElementTest.h

 
 
#ifndef CNetCableElementTest_H
#define CNetCableElementTest_H
 
 
#include "sfh/math.h"
#include "sfh/linalg.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();
 
    static void * operator new ( size_t size)
    {
#ifdef WIN32
        return _aligned_malloc(size,16);
#elif __APPLE__
        return malloc(size);
#else
        return aligned_alloc(16, size);
#endif
    }
 
    static void operator delete( void *p )
    {       
#ifdef WIN32
        _aligned_free(p);
#else
        free(p);
#endif
    }
 
    NetCableElementTest(const NetCableElementTest* old);
    NetCableElementTest(const NetCableElementTestSpec* spec);
 
    ~NetCableElementTest();
 
    void AddEndForces(const double rhoWater,const sfh::linalg::sse_vec3f  &posa,const sfh::linalg::sse_vec3f &posb,const sfh::linalg::sse_vec3f &vela,const sfh::linalg::sse_vec3f &velb,const sfh::linalg::sse_vec3f &velf, sfh::linalg::sse_vec3f &forceA,sfh::linalg::sse_vec3f &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;
 
    sfh::linalg::sse_vec3f n;
    sfh::linalg::sse_vec3f n2[2];
 
    sfh::linalg::sse_vec3f vel;
    sfh::linalg::sse_vec3f vel_t;
    sfh::linalg::sse_vec3f vel_n;
    sfh::linalg::sse_vec3f vel_n_a;
    sfh::linalg::sse_vec3f vel_n_b;
    
    sfh::linalg::sse_vec3f f_struct;    
    sfh::linalg::sse_vec3f f_drag_a, f_drag_b;
 
    sfh::linalg::sse_vec3f force_sphere_a;
    sfh::linalg::sse_vec3f force_sphere_b;
    sfh::linalg::sse_vec3f 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;
};
 
 
#endif