beam_point_rigid_contact_condition.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosContactMechanicsApplication $
//   Last modified by:    $Author:              JMCarbonell $
//   Date:                $Date:                  July 2013 $
//   Revision:            $Revision:                    0.0 $
//
//
 
#if !defined(KRATOS_BEAM_POINT_RIGID_CONTACT_CONDITION_H_INCLUDED )
#define  KRATOS_BEAM_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 "utilities/beam_math_utilities.hpp"
 
#include "custom_bounding/spatial_bounding_box.hpp"
 
namespace Kratos
{
 
 
class KRATOS_API(CONTACT_MECHANICS_APPLICATION) BeamPointRigidContactCondition
    : public Condition
{
public:
 
 
    //typedef BoundedVector<double, 3>        PointType;
    typedef array_1d<double, 3>                PointType;
 
    typedef BeamMathUtils<double>      BeamMathUtilsType;
 
    // Counted pointer of BeamPointRigidContactCondition
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( BeamPointRigidContactCondition );
 
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;
 
    typedef struct
    {
      Flags           Options;               //calculation options
 
      //Geometrical gaps:
      SurfaceScalar   Gap;                   //normal and tangential gap
 
      //Friction:
      PointType       RelativeDisplacement;  //relative displacement
      double          FrictionCoefficient;   //total friction coeffitient mu
 
      SurfaceScalar   Penalty;               //Penalty Parameter normal and tangent
 
      //Geometric variables
      SurfaceVector   Surface;               //normal and tangent vector to the surface
 
 
       //for axisymmetric use only
      double  CurrentRadius;
      double  ReferenceRadius;
 
 
    } ConditionVariables;
 
 
    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:
 
 
 
    BeamPointRigidContactCondition( IndexType NewId, GeometryType::Pointer pGeometry );
 
    BeamPointRigidContactCondition( IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties );
 
 
    BeamPointRigidContactCondition( IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties, SpatialBoundingBox::Pointer pRigidWall );
 
    BeamPointRigidContactCondition( BeamPointRigidContactCondition const& rOther);
 
    virtual ~BeamPointRigidContactCondition();
 
 
 
 
    Condition::Pointer Create(IndexType NewId,
                  NodesArrayType const& ThisNodes,
                  PropertiesType::Pointer pProperties ) const;
 
 
    Condition::Pointer Clone(IndexType NewId,
                 NodesArrayType const& ThisNodes) const;
 
 
    //************* STARTING - ENDING  METHODS
 
 
    void InitializeNonLinearIteration(ProcessInfo& rCurrentProcessInfo);
 
 
    void FinalizeNonLinearIteration(ProcessInfo& rCurrentProcessInfo);
 
 
    virtual void InitializeSolutionStep(ProcessInfo& rCurrentProcessInfo);
 
 
    void FinalizeSolutionStep(ProcessInfo& rCurrentProcessInfo);
 
 
    //************* GETTING METHODS
 
    void GetDofList(DofsVectorType& rConditionDofList,
            ProcessInfo& rCurrentProcessInfo );
 
    void EquationIdVector(EquationIdVectorType& rResult,
              ProcessInfo& rCurrentProcessInfo );
 
    void GetValuesVector(Vector& rValues,
             int Step = 0 );
 
    void GetFirstDerivativesVector(Vector& rValues,
                   int Step = 0 );
 
    void GetSecondDerivativesVector(Vector& rValues,
                    int Step = 0 );
 
 
    //************* COMPUTING  METHODS
 
    void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix,
                  VectorType& rRightHandSideVector,
                  ProcessInfo& rCurrentProcessInfo );
 
 
    void CalculateLocalSystem(std::vector< MatrixType >& rLeftHandSideMatrices,
                  const std::vector< Variable< MatrixType > >& rLHSVariables,
                  std::vector< VectorType >& rRightHandSideVectors,
                  const std::vector< Variable< VectorType > >& rRHSVariables,
                  ProcessInfo& rCurrentProcessInfo);
 
    void CalculateRightHandSide(VectorType& rRightHandSideVector,
                ProcessInfo& rCurrentProcessInfo );
 
 
    void CalculateRightHandSide(std::vector< VectorType >& rRightHandSideVectors,
                const std::vector< Variable< VectorType > >& rRHSVariables,
                ProcessInfo& rCurrentProcessInfo);
 
    void CalculateMassMatrix(
        MatrixType& rMassMatrix,
        ProcessInfo& rCurrentProcessInfo );
 
    void CalculateDampingMatrix(
        MatrixType& rDampingMatrix,
        ProcessInfo& rCurrentProcessInfo );
 
 
    virtual void AddExplicitContribution(const VectorType& rRHSVector,
                     const Variable<VectorType>& rRHSVariable,
                     const Variable<array_1d<double,3> >& rDestinationVariable,
                     const ProcessInfo& rCurrentProcessInfo);
 
    //************************************************************************************
    //************************************************************************************
    virtual int Check( const ProcessInfo& rCurrentProcessInfo );
 
 
    void SetRigidWall(SpatialBoundingBox::Pointer pRigidWall);
 
 
 
protected:
    BeamPointRigidContactCondition() {};
 
    IntegrationMethod mThisIntegrationMethod;
 
 
    SpatialBoundingBox::Pointer mpRigidWall;
 
 
 
    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,
                      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;
 
    virtual void save( Serializer& rSerializer ) const
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, Condition )
    }
 
    virtual void load( Serializer& rSerializer )
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, Condition )
    }
 
 
}; // class BeamPointRigidContactCondition.
 
} // namespace Kratos.
 
#endif // KRATOS_BEAM_POINT_RIGID_CONTACT_CONDITION_H_INCLUDED defined