CNetCableElementTest.h

 
 
#ifndef CNetCableElementTest_H
#define CNetCableElementTest_H
 
 
#include "sfh/math.h"
#include "sfh/linalg.h"
 
#include "CNetCableElementTestSpec.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 CNetCableElementTest 
{
public:
    static float m_dRhoWater;
    static float m_dDragCoeffSphere;        
    static float m_dNormalDragCoeffDisk;    
    static float m_dTangentialFrictionCoeffDisk;    
    static float m_dTangentialDragCoeffDisk;
    static float m_dTangentialFrictionCoeff;
 
    CNetCableElementTest();
 
    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
    }
 
    CNetCableElementTest(const CNetCableElementTest* pOld);
    CNetCableElementTest(const CNetCableElementTestSpec* pSpec);
 
    ~CNetCableElementTest();
 
    void AddEndForces(const double dRhoWater,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 iNewNode, int iNewElementID, CNetCableElementTest** pSNewCable);
 
    bool CheckAndInitialize();
 
    void DeleteSpheresAndDisks();
 
    void AddSpheres(float* adD, float* adMass, float* adPos, std::vector<std::string> VsSphereMaterial, int iNum);
    void AddDisks(float* adD, float* adThickness, float* adMass, float* adPos, std::vector<std::string> VsDiskMaterial, int iNum);
 
#ifdef FH_VISUALIZATION
    void RenderInit(Ogre::Root* pOgreRoot);
 
    void RenderUpdate( const double adPosA[3], const double adPosB[3]);
#endif
    int                         m_conn[2];          
    int                         m_iNumSpheres;          
    float*                      m_adSphereD;            
    float*                      m_adSphereMass;         
    float*                      m_adSpherePos;          
    int                         m_iNumDisks;            
    float*                      m_adDiskD;              
    float*                      m_adDiskThickness;      
    float*                      m_adDiskMass;           
    float*                      m_adDiskPos;            
    //float                     m_dAddedWeightInWater;  ///< 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_aRenderSpheres;
    Ogre::SceneNode**           m_aRenderNodeSpheres;
    Ogre::Entity**              m_aRenderDisks;
    Ogre::SceneNode**           m_aRenderNodeDisks;
    std::string m_sMaterialName;
    int m_iCableFaces;
    float m_dDrawScale;
 
#endif
    std::string m_sCableName;
 
    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_iID;
    float m_dL0;
    float m_dD;
    float m_dDhyd;
    float m_dE;
    float m_dRho;
    float m_dNormalDragCoeff;
 
    float m_dDampingRatio;
//  float ma_dVelAmp;
//  float ma_adVel[3];
//  float ma_adVt[3];
//  float ma_adVn[3];
    float m_adMassInWater[2];
    float m_adWeightInWater[2];
    //float m_adMassInWaterPerMeter[2];
    //float m_adWeightInWaterPerMeter[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_dEA;
    float ma_dNormalDragFactor;
    float ma_dTangentialDragFactor;
    float m_dA;
 
    float m_dragReduction;
    float m_projectedArea;
    float m_normalVelocity;
};
 
 
#endif