point_rigid_contact_condition.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_POINT_RIGID_CONTACT_CONDITION_H_INCLUDED )
#define  KRATOS_POINT_RIGID_CONTACT_CONDITION_H_INCLUDED
 
// System includes
 
// External includes
#include "boost/smart_ptr.hpp"
 
// Project includes
#include "includes/define.h"
#include "includes/serializer.h"
#include "includes/condition.h"
#include "includes/ublas_interface.h"
#include "includes/variables.h"
 
#include "custom_bounding/spatial_bounding_box.hpp"
#include "custom_friction/friction_law.hpp"
 
namespace Kratos
{
 
 
class KRATOS_API(CONTACT_MECHANICS_APPLICATION) PointRigidContactCondition
    : public Condition
{
public:
 
 
    //typedef BoundedVector<double, 3>                PointType;
    typedef array_1d<double, 3>                           PointType;
    typedef GlobalPointersVector<Node >       NodeWeakPtrVectorType;
    typedef GlobalPointersVector<Element>     ElementWeakPtrVectorType;
    typedef GlobalPointersVector<Condition> ConditionWeakPtrVectorType;
    // Counted pointer of PointRigidContactCondition
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( PointRigidContactCondition );
 
protected:
 
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_RHS_VECTOR );
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_LHS_MATRIX );
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_RHS_VECTOR_WITH_COMPONENTS );
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_LHS_MATRIX_WITH_COMPONENTS );
 
 
    typedef struct
    {
        PointType Normal;        //normal direction
        PointType Tangent;       //tangent direction
 
    } SurfaceVector;
 
    typedef struct
    {
        double Normal;        //normal component
        double Tangent;       //tangent component
 
    } SurfaceScalar;
 
    struct ConditionVariables
    {
      Flags           Options;               //calculation options
 
      //Geometrical gaps:
      SurfaceScalar   Gap;                   //normal and tangential gap
      double          ContributoryFactor;    //distance to neighbour points
 
      //Friction:
      bool            Slip;                  //slip = true / stick = false
      PointType       RelativeDisplacement;  //relative point displacement
      double          FrictionCoefficient;   //total friction coeffitient mu
      double          DeltaTime;             //time step
 
      SurfaceScalar   Penalty;               //Penalty Parameter normal and tangent
 
      //Geometric variables
      SurfaceVector   Surface;               //normal and tangent vector to the surface
 
      // Elasto-plastic constitutive matrix (axisym and PS) (Normal and Tangent stiffness)
      SurfaceScalar   TangentMatrix;
 
      //Contact stress
      Vector ContactStressVector;
 
      //for axisymmetric use only
      double  CurrentRadius;
      double  ReferenceRadius;
 
      //for rigid body
      Matrix  SkewSymDistance;     //compute the skewsymmmetric tensor of the distance
 
      void Initialize()
      {
    Gap.Normal  = 0;
    Gap.Tangent = 0;
 
    ContributoryFactor = 0;
 
    RelativeDisplacement.resize(3);
    noalias(RelativeDisplacement) = ZeroVector(3);
 
    Slip = false;
    DeltaTime = 0;
    FrictionCoefficient = 0;
    Penalty.Normal  = 0;
    Penalty.Tangent = 0;
 
    Surface.Normal.resize(3);
    noalias(Surface.Normal) = ZeroVector(3);
    Surface.Tangent.resize(3);
    noalias(Surface.Tangent) = ZeroVector(3);
 
    SkewSymDistance.resize(3,3,false);
    noalias(SkewSymDistance) =  ZeroMatrix(3,3);
 
    TangentMatrix.Normal = 0;
    TangentMatrix.Tangent = 0;
 
    CurrentRadius = 0;
    ReferenceRadius = 0;
      }
 
    };
 
 
    struct LocalSystemComponents
    {
    private:
 
      //for calculation local system with compacted LHS and RHS
      MatrixType *mpLeftHandSideMatrix;
      VectorType *mpRightHandSideVector;
 
      //for calculation local system with LHS and RHS components
      std::vector<MatrixType> *mpLeftHandSideMatrices;
      std::vector<VectorType> *mpRightHandSideVectors;
 
      //LHS variable components
      const std::vector< Variable< MatrixType > > *mpLeftHandSideVariables;
 
      //RHS variable components
      const std::vector< Variable< VectorType > > *mpRightHandSideVariables;
 
 
    public:
 
      //calculation flags
      Flags  CalculationFlags;
 
      void SetLeftHandSideMatrix( MatrixType& rLeftHandSideMatrix ) { mpLeftHandSideMatrix = &rLeftHandSideMatrix; };
      void SetLeftHandSideMatrices( std::vector<MatrixType>& rLeftHandSideMatrices ) { mpLeftHandSideMatrices = &rLeftHandSideMatrices; };
      void SetLeftHandSideVariables(const std::vector< Variable< MatrixType > >& rLeftHandSideVariables ) { mpLeftHandSideVariables = &rLeftHandSideVariables; };
 
      void SetRightHandSideVector( VectorType& rRightHandSideVector ) { mpRightHandSideVector = &rRightHandSideVector; };
      void SetRightHandSideVectors( std::vector<VectorType>& rRightHandSideVectors ) { mpRightHandSideVectors = &rRightHandSideVectors; };
      void SetRightHandSideVariables(const std::vector< Variable< VectorType > >& rRightHandSideVariables ) { mpRightHandSideVariables = &rRightHandSideVariables; };
 
 
      MatrixType& GetLeftHandSideMatrix() { return *mpLeftHandSideMatrix; };
      std::vector<MatrixType>& GetLeftHandSideMatrices() { return *mpLeftHandSideMatrices; };
      const std::vector< Variable< MatrixType > >& GetLeftHandSideVariables() { return *mpLeftHandSideVariables; };
 
      VectorType& GetRightHandSideVector() { return *mpRightHandSideVector; };
      std::vector<VectorType>& GetRightHandSideVectors() { return *mpRightHandSideVectors; };
      const std::vector< Variable< VectorType > >& GetRightHandSideVariables() { return *mpRightHandSideVariables; };
 
    };
 
 
public:
 
 
 
    PointRigidContactCondition(){};
 
    PointRigidContactCondition( IndexType NewId, GeometryType::Pointer pGeometry );
 
    PointRigidContactCondition( IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties );
 
 
    PointRigidContactCondition( IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties, SpatialBoundingBox::Pointer pRigidWall );
 
    PointRigidContactCondition( PointRigidContactCondition const& rOther);
 
    virtual ~PointRigidContactCondition();
 
 
 
 
    Condition::Pointer Create(IndexType NewId,
                  NodesArrayType const& ThisNodes,
                  PropertiesType::Pointer pProperties ) const override;
 
 
    Condition::Pointer Clone(IndexType NewId,
                 NodesArrayType const& ThisNodes) 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;
 
 
    //************* GETTING METHODS
 
    void GetDofList(DofsVectorType& rConditionDofList,
            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;
 
 
    //************* COMPUTING  METHODS
 
    void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix,
                  VectorType& rRightHandSideVector,
                  const ProcessInfo& rCurrentProcessInfo ) override;
 
 
    void CalculateLocalSystem(std::vector< MatrixType >& rLeftHandSideMatrices,
                  const std::vector< Variable< MatrixType > >& rLHSVariables,
                  std::vector< VectorType >& rRightHandSideVectors,
                  const std::vector< Variable< VectorType > >& rRHSVariables,
                  const ProcessInfo& rCurrentProcessInfo);
 
    void CalculateRightHandSide(VectorType& rRightHandSideVector,
                const ProcessInfo& rCurrentProcessInfo ) override;
 
 
    void CalculateRightHandSide(std::vector< VectorType >& rRightHandSideVectors,
                const std::vector< Variable< VectorType > >& rRHSVariables,
                const ProcessInfo& rCurrentProcessInfo);
 
    void CalculateMassMatrix(
        MatrixType& rMassMatrix,
        const ProcessInfo& rCurrentProcessInfo ) override;
 
    void CalculateDampingMatrix(
        MatrixType& rDampingMatrix,
        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;
 
 
    void SetRigidWall(SpatialBoundingBox::Pointer pRigidWall);
 
 
 
protected:
 
    IntegrationMethod mThisIntegrationMethod;
 
 
    SpatialBoundingBox::Pointer mpRigidWall;
 
 
    FrictionLaw::Pointer mpFrictionLaw;
 
 
    Vector mContactStressVector;
 
 
    void ClearNodalForces ();
 
 
    virtual void InitializeSystemMatrices(MatrixType& rLeftHandSideMatrix,
                      VectorType& rRightHandSideVector,
                      Flags& rCalculationFlags);
 
    virtual void InitializeConditionVariables(ConditionVariables& rVariables,
                        const ProcessInfo& rCurrentProcessInfo);
 
    virtual void CalculateKinematics(ConditionVariables& rVariables,
                     const ProcessInfo& rCurrentProcessInfo,
                     const double& rPointNumber);
 
    virtual double& CalculateIntegrationWeight(double& rIntegrationWeight);
 
 
    virtual void CalculateConditionSystem(LocalSystemComponents& rLocalSystem,
                      const ProcessInfo& rCurrentProcessInfo);
 
 
    virtual void CalculateAndAddLHS(LocalSystemComponents& rLocalSystem,
                                    ConditionVariables& rVariables,
                                    double& rIntegrationWeight);
 
    virtual void CalculateAndAddRHS(LocalSystemComponents& rLocalSystem,
                                    ConditionVariables& rVariables,
                    double& rIntegrationWeight);
 
 
    virtual void CalculateAndAddKuug(MatrixType& rLeftHandSideMatrix,
                     ConditionVariables& rVariables,
                     double& rIntegrationWeight);
 
 
    virtual void CalculateAndAddContactForces(Vector& rRightHandSideVector,
                          ConditionVariables& rVariables,
                          double& rIntegrationWeight );
 
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
    void save( Serializer& rSerializer ) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, Condition )
      //rSerializer.save("mpRigidWall",mpRigidWall); //rebuild in contact search and in restart
    rSerializer.save("mpFrictionLaw",mpFrictionLaw);
    rSerializer.save("mContactStressVector",mContactStressVector);
    }
 
    void load( Serializer& rSerializer ) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, Condition )
      //rSerializer.load("mpRigidWall",mpRigidWall);
    rSerializer.load("mpFrictionLaw",mpFrictionLaw);
    rSerializer.load("mContactStressVector",mContactStressVector);
    }
 
 
}; // class PointRigidContactCondition.
 
} // namespace Kratos.
 
#endif // KRATOS_POINT_RIGID_CONTACT_CONDITION_H_INCLUDED defined