rigid_body_point_link_condition.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosContactMechanicsApplication $
//   Created by:          $Author:              JMCarbonell $
//   Last modified by:    $Co-Author:                       $
//   Date:                $Date:             September 2018 $
//   Revision:            $Revision:                    0.0 $
//
//
 
#if !defined(KRATOS_RIGID_BODY_POINT_LINK_CONDITION_H_INCLUDED )
#define  KRATOS_RIGID_BODY_POINT_LINK_CONDITION_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/element.h"
#include "includes/condition.h"
#include "utilities/beam_math_utilities.hpp"
 
namespace Kratos
{
 
 
class KRATOS_API(CONTACT_MECHANICS_APPLICATION) RigidBodyPointLinkCondition
    : public Condition
{
 public:
 
 
  typedef Vector                                VectorType;
  typedef Element                              ElementType;
  typedef Node::Pointer                PointPointerType;
  typedef Quaternion<double>                QuaternionType;
  typedef Node::DofsContainerType     DofsContainerType;
  typedef GeometryData::SizeType                  SizeType;
  typedef BeamMathUtils<double>          BeamMathUtilsType;
 
  typedef GlobalPointersVector<Element> ElementWeakPtrVectorType;
  // Counted pointer of RigidBodyPointLinkCondition
  KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( RigidBodyPointLinkCondition );
 
 protected:
 
  KRATOS_DEFINE_LOCAL_FLAG(COMPUTE_RHS_VECTOR);
  KRATOS_DEFINE_LOCAL_FLAG(COMPUTE_LHS_MATRIX);
  typedef struct
  {
    Flags             Options;               //calculation options
 
    SizeType          MasterLinearBlockSize;
    SizeType          MasterAngularBlockSize;
 
    SizeType          SlaveNode;
    SizeType          SlaveLinearBlockSize;
    SizeType          SlaveAngularBlockSize;
 
    std::vector<SizeType> RigidNodes;
    std::vector<SizeType> DeformableNodes;
 
    BoundedMatrix<double,3,3>               SlaveSkewSymDistance;
    std::vector<BoundedMatrix<double,3,3>> RigidSkewSymDistances;
 
    Element*   pSlaveElement;
 
  } GeneralVariables;
 
  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:
 
 
 
  RigidBodyPointLinkCondition( IndexType NewId, GeometryType::Pointer pGeometry );
 
  RigidBodyPointLinkCondition( IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties );
 
  RigidBodyPointLinkCondition( RigidBodyPointLinkCondition const& rOther);
 
  virtual ~RigidBodyPointLinkCondition();
 
 
 
 
  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 InitializeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
  void FinalizeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
  void InitializeSolutionStep(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 CalculateRightHandSide(VectorType& rRightHandSideVector,
                              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 CalculateDampingMatrix(MatrixType& rDampingMatrix,
                              const ProcessInfo& rCurrentProcessInfo) override;
 
  virtual int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
 
 
 protected:
 
  static const std::array<const VariableData,6> mLinearDofs;
  static const std::array<const VariableData,3> mAngularDofs;
 
 
 
  virtual void InitializeSystemMatrices(MatrixType& rLeftHandSideMatrix,
                                        VectorType& rRightHandSideVector,
                                        const SizeType& rSlaveElementSize,
                                        Flags& rCalculationFlags);
  virtual void InitializeGeneralVariables(GeneralVariables& rVariables,
                                          const ProcessInfo& rCurrentProcessInfo);
  virtual void CalculateConditionSystem(LocalSystemComponents& rLocalSystem,
                                        LocalSystemComponents& rLinkedSystem,
                                        Element* rSlaveElement,
                                        const ProcessInfo& rCurrentProcessInfo);
  virtual void CalculateAndAddLHS(LocalSystemComponents& rLocalSystem,
                                  LocalSystemComponents& rLinkedSystem,
                                  GeneralVariables& rVariables);
  virtual void CalculateAndAddRHS(LocalSystemComponents& rLocalSystem,
                                  LocalSystemComponents& rLinkedSystem,
                                  GeneralVariables& rVariables);
  virtual void CalculateAndAddTangent(MatrixType& rLeftHandSideMatrix,
                                      MatrixType& rLinkedLeftHandSideMatrix,
                                      GeneralVariables& rVariables);
  virtual void CalculateAndAddForces(VectorType& rRightHandSideVector,
                                     VectorType& rLinkedRightHandSideVector,
                                     GeneralVariables& rVariables);
 
  virtual void CalculateAndAddTangentBeam(MatrixType& rLeftHandSideMatrix,
                                          MatrixType& rLinkedLeftHandSideMatrix,
                                          GeneralVariables& rVariables);
  virtual void CalculateAndAddForcesBeam(VectorType& rRightHandSideVector,
                                         VectorType& rLinkedRightHandSideVector,
                                         GeneralVariables& rVariables);
 
 
  void AssembleLocalLHS(MatrixType& rLeftHandSideMatrix,
                        const MatrixType& rLocalLeftHandSideMatrix,
                        const SizeType& local_index,
                        const SizeType& dofs_size,
                        const SizeType& master_index);
  void AssembleLocalRHS(VectorType& rRightHandSideVector,
                        const VectorType& rLocalRightHandSideVector,
                        const SizeType& local_index,
                        const SizeType& dofs_size,
                        const SizeType& master_index);
  virtual SizeType GetDofsSize();
 
  void WriteMatrixInRows(std::string MatrixName,
                         const MatrixType& rMatrix);
 
  RigidBodyPointLinkCondition() {};
 
 
 
 
 private:
 
 
 
 
 
 
 
  friend class Serializer;
 
  void save( Serializer& rSerializer ) const override
  {
    KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, Condition )
  }
 
  void load( Serializer& rSerializer ) override
  {
    KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, Condition )
  }
 
 
}; // class RigidBodyPointLinkCondition.
 
} // namespace Kratos.
 
#endif // KRATOS_RIGID_BODY_POINT_LINK_CONDITION_H_INCLUDED defined