TAPsFEMMesh.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsFEMMesh.hpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (12/15/2009)
UPDATE          (10/27/2010)
******************************************************************************/
#ifndef TAPs_FEM_MESH_HPP
#define TAPs_FEM_MESH_HPP

#include "TAPsFEMElement.hpp"

// REMARK:
//   The sparse (nonsymmetric) matrix is used instead of the sparse sysmtetric matrix, 
//   because it provides more flexibility.
//   Also for nonlinear FEM, the stiffness matrix is no longer symmetric.

#include "../DataStructure/TAPsSparseMatrix_Matrix3x3.hpp"

#define TAPs_SIM_DYNAMIC_SYSTEM

#ifdef  TAPs_SIM_DYNAMIC_SYSTEM
#endif//TAPs_SIM_DYNAMIC_SYSTEM

#define TAPs_ADD_INTERACTIONS

#ifdef  TAPs_ADD_INTERACTIONS
    #include "../Physics/TAPsForces.hpp"
#endif//TAPs_ADD_INTERACTIONS

#include "../Support/TAPsTransformationSupport.hpp"

BEGIN_NAMESPACE_TAPs__FEM
//=============================================================================
template <typename T>
class Mesh {
//=============================================================================
public:
    // Member Functions -------------------------------------------------------
    friend std::ostream & operator<< ( std::ostream &output, Mesh<T> const &obj )
    {
        output << obj.StrInfo();
        return output;
    }
    //-------------------------------------------------------------------------
    Mesh ();
    //Mesh ( Mesh<T> const &orig );
    virtual ~Mesh ();
    //-------------------------------------------------------------------------
    virtual std::string StrInfo () const = 0;
    //-------------------------------------------------------------------------
    //Mesh<T> & operator= ( Mesh<T> const &orig ) = 0;

    //-------------------------------------------------------------------------
    // Operations

    std::vector< Vector3<T> > & RetListOfDeformedMeshNodes ()   { return m_vDeformedMeshNodes; }

    std::vector< Vector3<T> > & RetListOfUndeformedMeshNodes () { return m_vUndeformedMeshNodes; }

    //inline virtual void ResetToDeformedState () = 0;

    inline virtual void ResetToUndeformedState () = 0;

    virtual void SetSizeOfStiffnessMatrix ();

    virtual void AssembleStiffnessMatrix () = 0;

    virtual void UpdateStrainDisplacementMatrix () = 0;

    //-------------------------------------------------------------------------
    // Get/Set

    SparseMatrix_Matrix3x3<T> const & StiffnessMatrix () const { return Mstiff; }

    inline unsigned int GetNumOfNodes () const;

    inline virtual Vector3<T> const & ForceAtNode ( unsigned int node ) const;
    inline Vector3<T> & ForceAtNode ( unsigned int node );

    inline virtual Vector3<T> const & FilterAtNode ( unsigned int node ) const;
    inline Vector3<T> & FilterAtNode ( unsigned int node );

    inline Vector3<T> const & OrigPositionOfNode ( unsigned int node ) const;
    inline Vector3<T> & OrigPositionOfNode ( unsigned int node );

    inline Vector3<T> const & CurrPositionOfNode ( unsigned int node ) const;
    inline Vector3<T> & CurrPositionOfNode ( unsigned int node );

    inline void SetTransformationSupportPointer ( TransformationSupport<T> * pTrx ) { m_pTrx = pTrx; }
    inline TransformationSupport<T> const & RefToTransformationSupport () const { return *m_pTrx; }
    inline TransformationSupport<T> &       RefToTransformationSupport ()       { return *m_pTrx; }

    //---------------------------------------------------------------
    // Prescribed Displacements

    inline void FixNode ( unsigned int node, bool b );

    inline void FixNode ( unsigned int node );

    inline void UnfixNode ( unsigned int node );

    inline void ToggleFixUnfixOfNode ( unsigned int node );

    inline bool IsFixedNode ( unsigned int node );

    inline void SetFixedDisplacementOfNode ( unsigned int node, Vector3<T> const & u );
    inline void SetFixedDisplacementOfNode ( unsigned int node, T x, T y, T z );


#ifdef  TAPs_SIM_DYNAMIC_SYSTEM

    inline T GetTimeStep () const;
    inline void SetTimeStep ( T timestep );

    inline Vector3<T> const & MassOfNode ( unsigned int node ) const;
    inline Vector3<T> & MassOfNode ( unsigned int node );

    inline Vector3<T> const & CurrentVelocityOfNode ( unsigned int node ) const;
    inline Vector3<T> & CurrentVelocityOfNode ( unsigned int node );
    inline Vector3<T> const & NextVelocityOfNode ( unsigned int node ) const;
    inline Vector3<T> & NextVelocityOfNode ( unsigned int node );

    inline T GetDampingMass () const;
    inline void SetDampingMass ( T d );

    inline T GetDampingStiffness () const;
    inline void SetDampingStiffness ( T d );

    inline void ResetCurrentVelocities ();

#endif//TAPs_SIM_DYNAMIC_SYSTEM


    // Virtual Fns ------------------------------

    inline virtual unsigned int GetNumOfElements () const = 0;

    inline virtual Element<T> const &   RefToElement ( unsigned int i ) const = 0;
    inline virtual Element<T> &         RefToElement ( unsigned int i ) = 0;

    //-------------------------------------------------------------------------
    // Simulation

    virtual void AllocateDataForSimulation ( T mass = 1 );

    unsigned char GetIterationLimit () const    { return m_iIterationLimit; }
    void SetIterationLimit ( unsigned char limit ) { m_iIterationLimit = limit; }

    T GetErrorThreshold () const    { return m_tErrorThreshold; }
    void SetErrorThreshold ( T error ) { m_tErrorThreshold = error; }

    void ClearAllNodeForces ();

    //-------------------------------------------------------------------------
    // Checking

    virtual std::string CheckVolumeOfEachElement () = 0;

    //-------------------------------------------------------------------------

    virtual void AdvanceSimulationStatic ();

    virtual void AdvanceSimulationStatic_woFixedDisplacementNodes ();

#ifdef  TAPs_SIM_DYNAMIC_SYSTEM

    virtual void AdvanceSimulationDynamic ();

    virtual void AdvanceSimulationDynamic_woFixedDisplacementNodes ();

#endif//TAPs_SIM_DYNAMIC_SYSTEM

protected:
    void MPCGSolver (
        SparseMatrix_Matrix3x3<T> const &A,     
        std::vector< Vector3<T> > const &x,     
        std::vector< Vector3<T> > const &b,     
        std::vector< Vector3<T> > &x_out,       
        std::vector< Vector3<T> > const &ft,    
        std::vector< Vector3<T> > const &P,     
        int iterationLimit = 100,               
        T errorThreshold = 1E-10                
    );

    // Data Members -----------------------------------------------------------

//=============================================================================
protected:
    // Member Functions -------------------------------------------------------

    // Simulation -------------------------------
    inline void UpdateDisplacementVector ();
    inline void UpdateDisplacementVector_wFixedDisplacementNodes ();
    inline void UpdateDeformedMeshNodes ();

    inline void UpdateFixedDisplacements ();

    // Data Members -----------------------------------------------------------

    // Stiffness matrix is always square.
    SparseMatrix_Matrix3x3<T>   Mstiff;     
    SparseMatrix_Matrix3x3<T>   Mstiff_2;   

    // Mesh nodes determines the size of the stiffness matrix.
    std::vector< Vector3<T> >   m_vDeformedMeshNodes;       
    std::vector< Vector3<T> >   m_vUndeformedMeshNodes;     

    // Simulation -------------------------------

    // For prescribed fixed displacements.
    // The size of these data have to be the same as the size of the stiffness matrix.
    std::vector< bool >         m_FixedNodes;           
    std::vector< Vector3<T> >   m_FixedDisplacements;   

    // These data are for SparseMatrix_Matrix3x3<T>::MPCGSolver function.
    // The size of these data have to be the same as the size of the stiffness matrix
    std::vector< Vector3<T> >   m_Filters;  
    std::vector< Vector3<T> >   m_Forces;   
    std::vector< Vector3<T> >   m_u;        
    std::vector< Vector3<T> >   m_u_out;    
    std::vector< Vector3<T> >   m_Precond;  

    unsigned char   m_iIterationLimit;  
    T               m_tErrorThreshold;  

//===================================================================
// For dynamic system
#ifdef  TAPs_SIM_DYNAMIC_SYSTEM
//-------------------------------------------------------------------
    T                           m_tTimeStep;            
    std::vector< Vector3<T> >   m_vNodeMass;            
    std::vector< Vector3<T> >   m_vNodeVelocities[2];   
    unsigned char               m_currVelIdx;           
    unsigned char               m_nextVelIdx;           

    T   m_tNodeDamping_Alpha;   
    T   m_tNodeDamping_Beta;    

    SparseMatrix_Matrix3x3<T>   m_A;    
    std::vector< Vector3<T> >   m_b;    

    inline void UpdateAandB ( SparseMatrix_Matrix3x3<T> & Mstiff );
//-------------------------------------------------------------------
#endif//TAPs_SIM_DYNAMIC_SYSTEM
//===================================================================


//=============================================================================
private:
    // Member Functions -------------------------------------------------------

    // For MPCGSolver
    std::vector< Vector3<T> > v;    
    std::vector< Vector3<T> > Pinv; 
    std::vector< Vector3<T> > r;    
    std::vector< Vector3<T> > s;    
    std::vector< Vector3<T> > c;    
    std::vector< Vector3<T> > q;    

    /*
    // DEBUG
    void Print ( std::vector< Vector3<T> > const & v ) {
        std::cout << "V:\n";
        for ( unsigned int i = 0; i < v.size(); ++i ) {
            std::cout << "\t" << v[i] << "\n";
        }
        std::cout << "\n";
    }
    //*/

    // Data Members -----------------------------------------------------------
//=============================================================================


//=============================================================================
// For interactions
#ifdef  TAPs_ADD_INTERACTIONS
//-----------------------------------------------------------------------------
public:
    // Member Functions ---------------------------------------------

    inline virtual void AddPointForce ( PointForce<T> * const ptrPtForce );
    inline virtual void AddPointForceInLocalCoordinates ( PointForce<T> * const ptrPtForce );

    inline virtual void RemovePointForce ( PointForce<T> * const ptrPtForce );

    inline virtual void AddCDForce ( PointForce<T> * const ptrCDForce );
    inline virtual void AddCDForceInLocalCoordinates ( PointForce<T> * const ptrCDForce );

    inline virtual void RemoveCDForce ( PointForce<T> * const ptrCDForce );

    inline virtual void AddConnectionForce ( PointForce<T> * const ptrConnectionForce );
    inline virtual void AddConnectionForceInLocalCoordinates ( PointForce<T> * const ptrConnectionForce );

    inline virtual void RemoveConnectionForce ( PointForce<T> * const ptrConnectionForce );

    void ClearAllPointLoads ();

    void ClearAllCDLoads ();

    void ClearAllConnectionLoads ();

    void ClearAllAppliedLoads ();

    // Data Members -------------------------------------------------

protected:
    // Member Functions ---------------------------------------------

    // Data Members -------------------------------------------------
    ForceListsPtr<T>    m_ForceLists;   

    inline virtual void ApplyAllLoads ();

    inline virtual void ApplyPointLoad ( PointForce<T> const * const ptrPtForce ) = 0;

    TransformationSupport<T> *  m_pTrx; 

private:
    // Member Functions ---------------------------------------------
    // Data Members -------------------------------------------------
//-----------------------------------------------------------------------------
#endif//TAPs_ADD_INTERACTIONS
//=============================================================================


#if defined(__gl_h_) || defined(__GL_H__)
public:
    void DrawFixedNodes ();

    virtual void Draw () = 0;

    virtual void DrawUndeformedMesh () = 0;

    virtual void DrawDeformedMesh () = 0;

    #ifdef  TAPs_ADD_INTERACTIONS

        virtual void DrawInteractionForces () = 0;
    #endif//TAPs_ADD_INTERACTIONS
#endif

//=============================================================================
}; // END CLASS Mesh
//=============================================================================
END_NAMESPACE_TAPs__FEM
//-----------------------------------------------------------------------------
#include "TAPsFEMMesh.cpp"

// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
//  #include "TAPsFEMMesh.cpp"
//#endif
//-----------------------------------------------------------------------------
#endif
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----