CRFShell.h

 
 
#ifndef CRFShell_H
#define CRFShell_H
 
#include <string>
#include <Eigen/Eigen>
 
#include "SimObject.h"
//#include <CIntegratorOptions.h>
#include "CEnvironment.h"
 
#ifdef FH_VISUALIZATION
#include "sfh/ogre/C3DLine.h"
#endif
 
namespace membrane {
 
/*
typedef Eigen::Matrix<double,6,6>  mat66;
typedef Eigen::Matrix<double,6,1>  vect6;
typedef Eigen::Matrix<double,3,3>  mat33;
typedef Eigen::Matrix<double,3,6>  mat36;
typedef Eigen::Matrix<double,6,3>  mat63;
typedef Eigen::Matrix<double,3,1>  vect3;
*/
 
class CRFShell : public SimObject
{
public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    CRFShell(std::string sSimObjectName, ISimObjectCreator* pCreator);
    virtual void FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const pCreator);
    virtual ~CRFShell();
 
#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
 
        virtual void OdeFcn(const double dT, const double* const adX, double* const adXDot, const bool bIsMajorTimeStep);
 
    virtual int HHTAlpha(const double dT, const double* const adX, const double TS, const double TI, const double Alpha, const int SubTS);
    virtual void FEPlot(const double dT, const double* const adX);
 
protected:
    ISignalPort*    m_pInForce_B;       
    int             m_TopConnectNum;
    int*            m_TopConnectNode;
    ISignalPort**   m_TopInPos;
    ISignalPort**   m_TopInVel;
    int             m_BotConnectNum;
    int*            m_BotConnectNode;
    ISignalPort**   m_BotInForce;
    ISignalPort*    m_BotInForceM;      
    int             m_BotNode;          
 
    virtual const double* VolumeCL(const double dT, const double* const adX);
    virtual const double* DragCOE(const double dT, const double* const adX);
    virtual const double* StressMX(const double dT, const double* const adX);
 
    double*     m_TopOutForce;
    virtual const double* TopOutForce(const double dT, const double* const adX, int iTop);
    double*     m_BotOutPos;
    double*     m_BotOutVel;
    virtual const double* BotOutPos(const double dT, const double* const adX, int iBot);
    virtual const double* BotOutVel(const double dT, const double* const adX, int iBot);
    double      m_BotOutPosM[3];
    double      m_BotOutVelM[3];
    virtual const double* BotOutPosM(const double dT, const double* const adX);
    virtual const double* BotOutVelM(const double dT, const double* const adX);
 
    int         m_IStatePos;            
    int         m_IStateVel;            
    int         m_IStateVol;            
 
    CEnvironment*   m_Environment;      
 
    int             m_Nodes;            
    int             m_Triangles;        
    double          m_MeshSize;         
 
    double          m_Loc[3];           
    double          m_Dim[4];           
    string          m_Shape;            
    double          m_Filling[2];       
    double          m_dPress[10];       
    double          m_rPress[2];        
 
    double          m_AddM;             
    double*         m_B2G;              
    double          m_Damp[2];          
    double          m_Drag;             
    double          m_StrDamp[2];       
 
    double          m_Thickness;        
    double          m_Density;          
    double          m_Youngs;           
    double          m_Poissons;         
    double          m_Yield;            
    double          m_CArea;            
    double          m_Volume[8];        
    double          m_Mass;             
    double          m_MStrain[6];       
    double          m_MStress[9];       
 
    double          m_Indt;             
 
    Eigen::Matrix<double,3,3>           m_D;                
 
    bool            m_Bending;          
    int*            m_TI;               
    int*            m_TPI;              
    double*         m_NodeM;            
    double*         m_NodeMR;           
    double*         m_NodeB;            
    double*         m_NodeB2;           
    double*         m_TC;               
    double*         m_TPC;              
    double*         m_TArea;            
    Eigen::Matrix<double,3,1>*          m_N;                
    Eigen::Matrix<double,3,6>*          m_B;                
    Eigen::Matrix<double,6,3>*          m_Bt;               
    Eigen::Matrix<double,6,6>*          m_K;                
    Eigen::Matrix<double,6,6>*          m_PK;               
    Eigen::Matrix<double,3,1>*          m_Strain;           
    Eigen::Matrix<double,3,1>*          m_Stress;           
    double*                             m_VMS;              
    double*                             m_VMSB;             
    double*                             m_RAngle;           
    //Eigen::Matrix<double,6,6>*        m_KA;               /// Mass matrix of the triangles.
    Eigen::Matrix<double,3,3>*          m_RG2L;             
    Eigen::Matrix<double,3,3>*          m_RL2G;             
    Eigen::Matrix<double,3,1>*          m_OL;               
    Eigen::Matrix<double,3,3>           m_PD;               
    Eigen::Matrix<double,3,6>*          m_PB;               
    int                                 m_IC;               
    int                                 m_BC;               
 
    double                              m_BendR;            
    double                              m_VolR[3];          
    int                                 m_ItM;              
    std::string                         m_OutFolder;        
 
    //CIntegratorOptions*           m_Integrator;       /// Pointer to the integration method
    int             m_Iteration;                            
    double          m_RelTol;                               
    //double            m_TS;                                      /// Integration time step.
   //double         m_PrevTime;                      ///< Previous time
   struct time_info {
      double step_size;           
      double previous_time = 0.0; 
      double current_time = 0.0;  
      double prev_plot_time = 0.0;
   } m_time_info;
    double          m_Alpha;                                   
    double          m_Beta;                                 
    double          m_Gamma;                                   
    double*         m_NodeP0;                               
    double*         m_NodeP;                                   
    double*         m_NodeV0;                               
    double*         m_NodeV;                                   
    double*         m_NodeA0;                               
    double*         m_NodeA;                                   
    double*         m_NodeF0;                               
    double*         m_NodeF;                                   
    double*         m_NodeD;                                   
    double          m_TS_s;                                 
    double*         m_NodeP_s;                              
    double*         m_NodeV_s;                              
    double*         m_NodeA_s;                              
    double*         m_NodeF_s;                              
    int             m_TPlot;                                   
 
    double          m_EOpenA;                               
    double          m_Omg[2];                               
    double          m_OmgDot;                               
    double          m_Vol;                                  
    double          m_VolDot;                               
 
    double          m_NetEK[2];                             
 
    int             m_TNlgeom;                              
    Eigen::Matrix<double,6,1>*          m_FiNlgeom;         
    Eigen::Matrix<double,6,1>*          m_FoNlgeom;         
 
#ifdef FH_VISUALIZATION
    string                      m_Material;                 
    vector<Ogre::SceneNode*>    m_RenderNodes;              
    Ogre::SceneManager*         m_SceneMgr;
    vector<Ogre::ManualObject*> m_Manual;
 
    int                         m_RenderType;
    C3DLine*                    m_3DLine;
    double                      m_Color[4];
    bool                        m_RenderStress;
#endif
 
};
 
};
#endif