CIceFloe.h

 
 
#ifndef CIceFloe_H
#define CIceFloe_H
 
#include <string>
#include <Eigen/Eigen>
 
#include "SimObject.h"
#include "CEnvironment.h"
 
namespace ice {
 
typedef Eigen::Matrix<double,6,6>  mat6;
typedef Eigen::Matrix<double,6,1>  vec6;
typedef Eigen::Matrix<double,3,3>  mat3;
typedef Eigen::Matrix<double,3,1>  vec3;
typedef Eigen::Matrix<double,13,1> vec13;
typedef Eigen::Quaternion<double>  quat;
 
class CIceFloe : public SimObject
{
public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    CIceFloe(std::string sSimObjectName, ISimObjectCreator* pCreator);
    virtual void FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const pCreator);
    virtual ~CIceFloe();
 
#ifdef FH_VISUALIZATION
    virtual void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
 
    virtual  void RenderUpdate(const double dT, const double* const adX);
 
    void DrawBody(Ogre::SceneNode* renderNode, Ogre::SceneManager* sceneMgr);
#endif
 
    struct m_PolyplateSpec
    {
    public:
        m_PolyplateSpec();
        m_PolyplateSpec(int nPolyPoints, double* xPoints, double* yPoints, double thickness_, double density_, const string& material);
        ~m_PolyplateSpec();
 
        int numPoints; //#points
        double thickness; //plate thickness
        double xCoords[10]; //polygon x-coords (Anticlockwise)
        double yCoords[10]; //polygon y-coords (Anticlockwise)
        double density; // density
        double mass; // mass
        double volume; //volume
        mat6 inertiaMatrix; //plate inertia
        vec3 centroid;
        string material;
 
        double projectedArea;
        double cubedGRZ;
        double cubedGRY;
        double cubedGRX;
        double cubedGRXY;
        double cubedGRYX;
    };
 
    // ================================================================================================== Contact
    // AABB class ==========================================================================
    class AABB {
    public:
        AABB() {
            minloc(0) = minloc(1) = minloc(2) = std::numeric_limits<double>::max();
            maxloc(0) = maxloc(1) = maxloc(2) = -std::numeric_limits<double>::max();
        }
 
        AABB(const AABB &aabb) {
            minloc = aabb.minloc;
            maxloc = aabb.maxloc;
        }
 
        ~AABB(){}
 
        void add(const vec3 &v) {
            if (v(0) < minloc(0)) minloc(0) = v(0);
            if (v(1) < minloc(1)) minloc(1) = v(1);
            if (v(2) < minloc(2)) minloc(2) = v(2);
            if (v(0) > maxloc(0)) maxloc(0) = v(0);
            if (v(1) > maxloc(1)) maxloc(1) = v(1);
            if (v(2) > maxloc(2)) maxloc(2) = v(2);
        }
 
        void clear() {
            minloc(0) = minloc(1) = minloc(2) = std::numeric_limits<double>::max();
            maxloc(0) = maxloc(1) = maxloc(2) = -std::numeric_limits<double>::max();
        }
 
        int overlap(const AABB &aabb)
        {
            if(maxloc(0) < aabb.minloc(0) || minloc(0) > aabb.maxloc(0)) return 0;
            if(maxloc(1) < aabb.minloc(1) || minloc(1) > aabb.maxloc(1)) return 0;
            if(maxloc(2) < aabb.minloc(2) || minloc(2) > aabb.maxloc(2)) return 0;
 
            return 1;
        }
 
        vec3 minloc, maxloc;
    };
    // AABB class ==========================================================================
 
    // AABB struct =========================================================================
    struct AABBSpec {
        int     numE;               
        int     numT;               
 
        int*    indexE;             
        int*    indexT;             
    };
    // AABB struct =========================================================================
 
    // Object struct =======================================================================
    struct ObjectSpec {
        int     numP;               
        int     numT;               
 
        double* xyzP;               
        int*    indexT;             
        double* normT;
    };
    // Object struct =======================================================================
    // ================================================================================================== Contact
 
 
    virtual void OdeFcn(const double dT, const double* const adX, double* const adXDot, const bool bIsMajorTimeStep);
 
    // r: global
    // q: global
    // dX: bodylocal
    // return: forcelocal
    virtual vec6 GetInternalForces(const vec6& dX, const vec3& r, const quat& q, CEnvironment* environment, double time, const double* states);
 
    // return: bodylocal
    virtual mat6 GetInertiaMatrix(const vec3& r, const quat& q, const double dT, const double* const adX);
 
    // all global coords
    virtual vec13 GetSecondDerivative(const vec3& r, const quat& q, const vec3& v, const vec3 w, const vec6& externalForces, CEnvironment* environment, double time, const double* states);
 
    // bodylocal coords
    static vec6 GetCoriolisForce(const vec6& dX, const mat6& Inertia);
 
    virtual vec6 CalcHydroforcesPolyplate(const vec6& dX, const vec3& r, const quat& q, CEnvironment* environment, double time, const double* states);
 
    virtual vec6 CalContactForce(const vec3& r, const quat& q, const double dT, const double* const adX);
 
    //================================================================================================== Contact
    virtual int rayTri(const vec3 &V1, const vec3 &V2, const vec3 &V3, const vec3 &O, const vec3 &D, double &out);
    //================================================================================================== Contact
 
    //================================================================================================== WAMIT
    virtual double GaussianFun(double &x, double &muix, double &sigmax, double &y, double &muiy, double &sigmay);
    virtual double PolyVal(int* &polyxy, double* &gassxy, double* &par, double &parx, double &pary);
    //================================================================================================== WAMIT
 
protected:
 
    // Input ports.
    ISignalPort*    m_pInMoment;        
    ISignalPort*    m_pInForce;         
 
    // Output ports.
    virtual const double* Position(const double dT, const double* const adX);
    virtual const double* Velocity(const double dT, const double* const adX);
    virtual const double* Quater(const double dT, const double* const adX);
    virtual const double* LocalVel(const double dT, const double* const adX);
    virtual const double* AngVel(const double dT, const double* const adX);
    virtual const double* ContactForce(const double dT, const double* const adX);
 
    virtual const double* Test(const double dT, const double* const adX);
 
    // States
    int         m_IStatePos;            
    int         m_IStateQuater;         
    int         m_IStateLocalVel;       
    int         m_IStateOmega;          
 
    // Parameters
    m_PolyplateSpec m_spec0;            
    double          m_adVelGlobal[3];   
    double          m_dragxy;           
    double          m_dragz;            
    CEnvironment*   m_Environment;      
    double          m_ContactForce[3];  
    mat6            m_DampMatrix;       
    mat6            m_AddedMass;        
    double          m_A33;
    quat            m_qc;               
    vec6            m_Acc;              
    double          m_rA33;
    int             m_dCylinder;
    int             m_dPressure;
 
    // Mesh
    int             m_tmesh;                
    int             m_wmesh;
    int             m_hmesh;
    double          m_dmesh;
    double          m_hdmesh;
 
    // Contact
    int             m_contact;
    double          m_psize;
    double          m_hsize;
    double          m_ikns;
    double          m_iknv;
    double          m_ikts;
    double          m_imui;
    double          m_icst;
    double          m_carea;
 
    //================================================================================================== Contact
    ObjectSpec      m_objectA;
    vec3            m_locA;
 
    ObjectSpec      m_objectB;
    double*         m_objectBP0;
 
    int             m_ABNumA;
    AABBSpec*       m_ABSpecA;
    AABB            m_BOXA;
    AABB*           m_BOXAI;
 
    int             m_ABNumB;
    AABBSpec*       m_ABSpecB;
    AABB            m_BOXB;
    AABB*           m_BOXBI;
 
    int             m_itsNum;
    double          m_itsPoints[1000][3];
 
    double          m_ictr;
    //================================================================================================== Contact
 
    struct m_SurfaceSpec
    {
    public:
        m_SurfaceSpec();
        ~m_SurfaceSpec();
 
        double xos;
        double yos;
        double areas;
        double width;
        double hsize;
        mat3 trp_s;
        mat3 trs_p;
 
        double aream;
        int mts;
        int mws;
        double mt0;
        double mw0;
        double mtl;
        double mwl;
 
        double h_aream;
        int h_mts;
        int h_mws;
        double h_mtl;
        double h_mwl;
 
        double dsp;
        double xcnr[2];
        double ycnr[2];
    } m_surface[12];
 
    // Test
    double          m_test[100];            
 
#ifdef FH_VISUALIZATION
    string                      m_Material;                 
    vector<Ogre::SceneNode*>    m_RenderNodes;              
    Ogre::SceneManager*         m_SceneMgr;
    vector<Ogre::ManualObject*> m_Manual;
 
    Ogre::SceneNode*        m_RenderNode;
#endif
 
    static mat6 ReorientInertiaTranslateRotate(const mat6& Inertia, const vec6& orientation);
    static mat3 MakeDyadic(const vec3& vector);
    static mat3 GetRotation(const vec3& angle);
    static mat6 GetRotation6(const vec3& angle);
};
 
};
#endif