rigid_body_element.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosContactMechanicsApplication $
//   Created by:          $Author:              JMCarbonell $
//   Last modified by:    $Co-Author:                       $
//   Date:                $Date:                  July 2016 $
//   Revision:            $Revision:                    0.0 $
//
//
 
#if !defined(KRATOS_RIGID_BODY_ELEMENT_H_INCLUDED )
#define  KRATOS_RIGID_BODY_ELEMENT_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/element.h"
#include "utilities/beam_math_utilities.hpp"
 
 
namespace Kratos
{
 
 
class KRATOS_API(CONTACT_MECHANICS_APPLICATION) RigidBodyElement
    :public Element
{
public:
 
    typedef BeamMathUtils<double>                      BeamMathUtilsType;
    typedef Quaternion<double>                            QuaternionType;
    typedef Node                                             NodeType;
    typedef PointerVectorSet<NodeType, IndexedObject> NodesContainerType;
    typedef GeometryData::SizeType                              SizeType;
    typedef array_1d<double,3>                                 ArrayType;
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( RigidBodyElement );
 
 
protected:
 
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_RHS_VECTOR );
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_LHS_MATRIX );
 
    struct RigidBodyProperties
    {
      double Mass;                            // Mass of the Rigid Body
      Matrix InertiaTensor;                   // Global Inertia Tensor
    };
 
    struct ElementVariables
    {
     private:
 
      //variables including all integration points
      const ProcessInfo* pProcessInfo;
 
     public:
 
      //section properties
      RigidBodyProperties RigidBody;
      ArrayType VolumeForce;
      Matrix DeltaPosition;
 
      void SetProcessInfo(const ProcessInfo& rProcessInfo)
      {
        pProcessInfo=&rProcessInfo;
      }
 
      const ProcessInfo& GetProcessInfo()
      {
        return *pProcessInfo;
      }
 
      void Initialize(const unsigned int& dimension, const ProcessInfo& rProcessInfo)
      {
        noalias(VolumeForce) = ZeroVector(3);
        DeltaPosition.resize(1,dimension,false);
        noalias(DeltaPosition) = ZeroMatrix(1, dimension);
        pProcessInfo=&rProcessInfo;
      }
 
    };
 
 
    struct LocalSystemComponents
    {
    private:
 
      //for calculation local system with compacted LHS and RHS
      MatrixType *mpLeftHandSideMatrix;
      VectorType *mpRightHandSideVector;
 
    public:
 
      //calculation flags
      Flags        CalculationFlags;
 
      void SetLeftHandSideMatrix( MatrixType& rLeftHandSideMatrix ) { mpLeftHandSideMatrix = &rLeftHandSideMatrix; };
 
      void SetRightHandSideVector( VectorType& rRightHandSideVector ) { mpRightHandSideVector = &rRightHandSideVector; };
 
 
      MatrixType& GetLeftHandSideMatrix() { return *mpLeftHandSideMatrix; };
 
      VectorType& GetRightHandSideVector() { return *mpRightHandSideVector; };
 
    };
 
 
public:
 
 
    RigidBodyElement() {};
 
    RigidBodyElement(IndexType NewId, GeometryType::Pointer pGeometry);
 
    RigidBodyElement(IndexType NewId, GeometryType::Pointer pGeometry,  PropertiesType::Pointer pProperties);
 
    RigidBodyElement(IndexType NewId, GeometryType::Pointer pGeometry,  PropertiesType::Pointer pProperties, NodesContainerType::Pointer pNodes);
 
    RigidBodyElement(RigidBodyElement const& rOther);
 
    virtual ~RigidBodyElement();
 
 
 
 
    Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes,  PropertiesType::Pointer pProperties) const override;
 
    Element::Pointer Clone(IndexType NewId, NodesArrayType const& ThisNodes) const override;
 
 
 
    //************* GETTING METHODS
 
 
    void GetDofList(DofsVectorType& rElementalDofList, const ProcessInfo& rCurrentProcessInfo) const override;
 
    void EquationIdVector(EquationIdVectorType& rResult, const ProcessInfo& rCurrentProcessInfo) const override;
 
    void GetValuesVector(Vector& rValues, int Step = 0) const override;
 
    void GetFirstDerivativesVector(Vector& rValues, int Step = 0) const override;
 
    void GetSecondDerivativesVector(Vector& rValues, int Step = 0) const override;
 
 
    //************* STARTING - ENDING  METHODS
 
    void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
 
    void InitializeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
    void InitializeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
    void FinalizeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void FinalizeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
    //************* COMPUTING  METHODS
 
    void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix, VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateRightHandSide(VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void CalculateLeftHandSide(MatrixType& rLeftHandSideMatrix, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void CalculateSecondDerivativesContributions(MatrixType& rLeftHandSideMatrix,
                        VectorType& rRightHandSideVector,
                        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateSecondDerivativesLHS(MatrixType& rLeftHandSideMatrix,
                       const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void CalculateSecondDerivativesRHS(VectorType& rRightHandSideVector,
                       const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateMassMatrix(MatrixType& rMassMatrix, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void AddExplicitContribution(const VectorType& rRHSVector, const Variable<VectorType>& rRHSVariable, const Variable<array_1d<double,3> >& rDestinationVariable, const ProcessInfo& rCurrentProcessInfo) override;
 
    int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "Rigid Body Element #" << Id();
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "Rigid Body Element #" << Id();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      GetGeometry().PrintData(rOStream);
    }
 
protected:
 
 
    QuaternionType  mInitialLocalQuaternion;
 
    NodesContainerType::Pointer     mpNodes;
 
 
 
 
 
    void CalculateDynamicSystem(LocalSystemComponents& rLocalSystem,
                                const ProcessInfo& rCurrentProcessInfo);
 
    virtual void InitializeSystemMatrices(MatrixType& rLeftHandSideMatrix,
                                          VectorType& rRightHandSideVector,
                                          Flags& rCalculationFlags);
 
    ArrayType& MapToInitialLocalFrame(ArrayType& rVariable);
 
 
    void CalculateRigidBodyProperties(RigidBodyProperties & rRigidBody);
 
 
    virtual void CalculateAndAddLHS(MatrixType& rLeftHandSideMatrix,
                                    ElementVariables& rVariables);
 
    virtual void CalculateAndAddRHS(VectorType& rRightHandSideVector,
                                    ElementVariables& rVariables);
 
    virtual void CalculateAndAddExternalForces(VectorType& rRightHandSideVector,
                           ElementVariables& rVariables);
 
    virtual void CalculateAndAddInertiaLHS(MatrixType& rLeftHandSideMatrix,
                       ElementVariables& rVariables);
 
    virtual void CalculateAndAddInertiaRHS(VectorType& rRightHandSideVector,
                       ElementVariables& rVariables);
 
 
    virtual void GetTimeIntegrationParameters(double& rP0,double& rP1,double& rP2,
                                              const ProcessInfo& rCurrentProcessInfo);
 
    virtual ArrayType& CalculateVolumeForce(ArrayType& rVolumeForce);
 
 
    virtual void CalculateRotationLinearPartTensor(ArrayType& rRotationVector, Matrix& rRotationTensor);
 
 
    virtual void UpdateRigidBodyNodes(const ProcessInfo& rCurrentProcessInfo);
 
    virtual SizeType GetDofsSize() const;
 
    virtual void MapLocalToGlobalSystem(LocalSystemComponents& rLocalSystem);
 
 
private:
 
    friend class Serializer;
 
    virtual void save(Serializer& rSerializer) const override;
 
    virtual void load(Serializer& rSerializer) override;
 
 
 
}; // Class RigidBodyElement
 
} // namespace Kratos.
#endif //  KRATOS_RIGID_BODY_ELEMENT_H_INCLUDED defined