CBarge.h

#ifndef CBarge_H
#define CBarge_H
 
#include <string>
#include <Eigen/Eigen>
 
#include "SimObject.h"
#include "CEnvironment.h"
#include <CIntegratorOptions.h>
#include "Subroutines.h"
 
 
namespace barge {
#define sys_size 22
 
class CBarge : public SimObject
{
public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    CBarge(std::string sSimObjectName, ISimObjectCreator* pCreator);
    virtual void FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const pCreator);
    virtual void InitialConditionSetup(const double T, const double *const currentIC, double* updatedIC, ISimObjectCreator* creator);
    virtual ~CBarge();
 
#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, const int& pi);
#endif
 
    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 int& pi, const vec6& dX, const vec3& r, const quat& ql2g, const quat& qg2l, double time, const double* const states);
 
    // return: bodylocal
    virtual mat6 GetInertiaMatrix(const int& pi, const vec3& r, const quat& q, const double dT, const double* const adX);
 
    // all global coords
    virtual vec13 GetSecondDerivative(const int& pi, const vec3& r, const quat& ql2g, const quat& qg2l, const vec3& v, const vec3& w, const vec6& externalForces, const double time, const double* const states);
 
    // bodylocal coords
    static vec6 GetCoriolisForce(const vec6& dX, const mat6& Inertia);
 
 
    // Connections =============================================================================
    virtual vec6 CalConnectForce(const vec3& r, const vec6& dX, const quat& ql2g, const quat& qg2l, const double dT, const double* const adX);
    // Connections =============================================================================
 
    // Wave overtopping ========================================================================
    virtual vec6 CalcHydroforcesBarge(const int& pi, const vec6& dX, const vec3& r, const quat& ql2g, const quat& qg2l, double time, const double* const states);
    virtual vec6 FroudeKriloffBarge(const int& pi, const vec6& dX, const vec3& r, const quat& ql2g, const quat& qg2l, double time, const double* const states);
    virtual vec6 DiffractionBarge(const int& pi, const vec6& dX, const vec3& r, const quat& ql2g, const quat& qg2l, double time, const double* const states);
 
    virtual vec6 CalWaveOverToppingBarge(const int& pi, const vec6& dX, const vec3& r, const quat& ql2g, const quat& qg2l, double time, const double* const states);
    // Wave overtopping ========================================================================
 
protected:
 
    // Input ports.
 
    // Output ports.
    virtual const double* BargeState(const double dT, const double* const adX);
    virtual const double* ConnectForce(const double dT, const double* const adX);
    virtual const double* RadiationDamping(const double dT, const double* const adX);
    virtual const double* FirstOrderWave(const double dT, const double* const adX);
 
    // States
    int         m_IStatePos;                
    int         m_IStateRot;                
    int         m_IStateQuater;             
    int         m_IStateLocalVel;           
    int         m_IStateOmega;              
 
    // Parameters
    int             m_numFloe;              
    vec3**          m_BargeV;               
    vec3**          m_xyzBargeV;            
 
    mat6*           m_AddedMass;            
    mat6*           m_DampMatrix;           
 
    Particle        m_Particle[1];          
    PolyplateSpec   m_PolyPlate[1];         
 
    double          m_BargeDensity;         
    double          m_wDragCoeff[2];        
    double          m_BargeSpeed[3];        
    CEnvironment*   m_Environment;          
    double          m_BargeState[22];       
    double          m_StepSize;             
   double         m_PrevTime;          
 
 
    // Connections =============================================================================
    int         m_ConnectNum;               
    int         m_ConnectPA;                
    double*     m_ConnectLoc;               
    double*     m_ConnectPos;               
    double*     m_ConnectVel;               
    virtual const double* ConnectPos(const double dT, const double* const adX, int iConnect);
    virtual const double* ConnectVel(const double dT, const double* const adX, int iConnect);
    ISignalPort ** m_ConnectForce;
 
    double      m_StructConnectForce[8];    
    // Connections =============================================================================
 
    // State-space implementation ==============================================================
    int         m_StateSpace;
    int         m_IStateSSpace;             
    int         m_ModeNum;
    int         m_StateNum;
 
    Eigen::Matrix<double, sys_size, sys_size>*  m_SSpaceA;
    Eigen::Matrix<double, sys_size,1>*  m_SSpaceB;
    Eigen::Matrix<double,1, sys_size>*  m_SSpaceC;
    Eigen::Matrix<double,1,1>*  m_SSpaceD;
    double*                     m_SSpaceSDot;
 
    virtual vec6 CalStateSpaceStructure(const int& pi, const double dT, const double* const adX, const vec6& VS);
    // State-space implementation ==============================================================
 
    // Wave components =========================================================================
    int                     m_WNum;
    std::vector<double>     m_WaveF;
    std::vector<double>     m_WaveA;
    std::vector<double>     m_WaveP;
    std::vector<double>     m_WaveD;
    std::vector<double>     m_WaveN;
 
    double*                 m_DiffA;
    double*                 m_DiffP;
    // Wave components =========================================================================
 
    // Barge dimensions ========================================================================
    double      m_BargeL;                   
    double      m_BargeB;                   
    double      m_BargeD;                   
    double      m_BargeH;                   
    double      m_BargeCOG[3];              
    double      m_BargeZG[2];               
    double      m_BargeRST[6];              
    mat6        m_BargeMass;                
    // Barge dimensions ========================================================================
 
    // Wave overtopping ========================================================================
    vec3        m_TAcc;
    vec3        m_RAcc;
    int         m_wTop;
    double      m_wTopHmin;
    double      m_wTopCFL;
    int         m_wTopN;
    double      m_wTopL;
    double      m_dx;
    int         m_wodwriteoutput;
    std::ofstream m_wodoutputfile1;
    std::ofstream m_wodoutputfile2;
    bool        m_isMajorTimeStep;
 
    // Shallow water grid and state variables:
    std::valarray<double> m_x;
    //std::valarray<double> m_h;
    std::valarray<double> m_u;
    std::valarray<double> m_q1;
    std::valarray<double> m_q2;
    //double*       m_x;
    //double*       m_h;
    //double*       m_u;
    //double*       m_q1;
    //double*       m_q2;
 
    // Wave overtopping ========================================================================
 
    // Output buffer
    double m_radiationForce[6];
    double m_firstOrderWave[6];
 
    // Test
    int             m_tNum;
    int             m_oNum;
    double          m_test[50];         
 
#ifdef FH_VISUALIZATION
    string                      m_Material;                 
    Ogre::SceneNode**           m_RenderNodes;              
    Ogre::SceneManager*         m_SceneMgr;
    vector<Ogre::ManualObject*> m_Manual;
#endif
 
};
 
};
#endif