boundary_condition.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosSolidMechanicsApplication $
//   Created by:          $Author:            JMCarbonell $
//   Last modified by:    $Co-Author:                     $
//   Date:                $Date:              August 2017 $
//   Revision:            $Revision:                  0.0 $
//
//
 
#if !defined(KRATOS_BOUNDARY_CONDITION_H_INCLUDED)
#define  KRATOS_BOUNDARY_CONDITION_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/checks.h"
#include "includes/condition.h"
#include "custom_utilities/solid_mechanics_math_utilities.hpp"
#include "utilities/beam_math_utilities.hpp"
#include "custom_utilities/element_utilities.hpp"
 
namespace Kratos
{
 
 
class KRATOS_API(SOLID_MECHANICS_APPLICATION) BoundaryCondition
    : public Condition
{
public:
 
 
    typedef Variable<array_1d<double,3>>      VariableVectorType;
    typedef Variable<double>                  VariableScalarType;
 
    typedef GeometryData::SizeType                      SizeType;
 
    // Counted pointer of BoundaryCondition
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( BoundaryCondition );
 
protected:
 
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_RHS_VECTOR );
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_LHS_MATRIX );
 
    struct ConditionVariables
    {
      private:
 
        //variables including all integration points
        const GeometryType::ShapeFunctionsGradientsType* pDN_De;
        const Matrix* pNcontainer;
 
      public:
 
        //for axisymmetric use only
        double  CurrentRadius;
        double  ReferenceRadius;
 
        //general variables
        double  GeometrySize;
        double  Jacobian;
        Vector  N;
        Matrix  DN_De;
        Matrix  DeltaPosition;
 
        //external boundary values
        double  ExternalScalarValue;
        Vector  ExternalVectorValue;
 
        //boundary characteristics
        Vector  Normal;
        Vector  Tangent1;
        Vector  Tangent2;
 
        //variables including all integration points
        GeometryType::JacobiansType j;
        GeometryType::JacobiansType J;
 
        void SetShapeFunctionsGradients(const GeometryType::ShapeFunctionsGradientsType &rDN_De)
        {
            pDN_De=&rDN_De;
        };
 
        void SetShapeFunctions(const Matrix& rNcontainer)
        {
            pNcontainer=&rNcontainer;
        };
 
 
        const GeometryType::ShapeFunctionsGradientsType& GetShapeFunctionsGradients()
        {
            return *pDN_De;
        };
 
        const Matrix& GetShapeFunctions()
        {
            return *pNcontainer;
        };
 
        void Initialize( const unsigned int& dimension,
             const unsigned int& local_dimension,
             const unsigned int& number_of_nodes )
        {
      //doubles
      //radius
      CurrentRadius   = 0;
      ReferenceRadius = 0;
      //jacobians
      GeometrySize = 1;
      Jacobian     = 1;
      //external boundary values
      ExternalScalarValue  = 0;
      ExternalVectorValue.resize(dimension,false);
      noalias(ExternalVectorValue) = ZeroVector(dimension);
      //vectors
      N.resize(number_of_nodes,false);
      Normal.resize(dimension,false);
      Tangent1.resize(dimension,false);
      Tangent2.resize(dimension,false);
      noalias(N) = ZeroVector(number_of_nodes);
      noalias(Normal) = ZeroVector(dimension);
      noalias(Tangent1) = ZeroVector(dimension);
      noalias(Tangent2) = ZeroVector(dimension);
      //matrices
      DN_De.resize(number_of_nodes, local_dimension,false);
      noalias(DN_De) = ZeroMatrix(number_of_nodes, local_dimension);
      DeltaPosition.resize(number_of_nodes, dimension,false);
      noalias(DeltaPosition) = ZeroMatrix(number_of_nodes, dimension);
      //others
      J.resize(1,false);
      j.resize(1,false);
      J[0].resize(dimension,dimension,false);
      j[0].resize(dimension,dimension,false);
      noalias(J[0]) = ZeroMatrix(dimension,dimension);
      noalias(j[0]) = ZeroMatrix(dimension,dimension);
      //pointers
      pDN_De = NULL;
      pNcontainer = NULL;
    }
 
    };
 
    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:
 
 
 
    BoundaryCondition();
 
    BoundaryCondition( IndexType NewId, GeometryType::Pointer pGeometry );
 
    BoundaryCondition( IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties );
 
    BoundaryCondition( BoundaryCondition const& rOther);
 
    ~BoundaryCondition() override;
 
 
 
 
    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;
 
 
    //************* 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 CalculateLeftHandSide(MatrixType& rLeftHandSideMatrix,
                   const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateMassMatrix(MatrixType& rMassMatrix,
                 const ProcessInfo& rCurrentProcessInfo ) override;
 
    void CalculateDampingMatrix(MatrixType& rDampingMatrix,
                const ProcessInfo& rCurrentProcessInfo ) override;
 
 
    void AddExplicitContribution(const VectorType& rRHS,
                     const Variable<VectorType>& rRHSVariable,
                     const Variable<array_1d<double,3> >& rDestinationVariable,
                     const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void CalculateOnIntegrationPoints(const Variable<double>& rVariable,
                      std::vector<double>& rOutput,
                      const ProcessInfo& rCurrentProcessInfo) override;
 
 
 
    //************************************************************************************
    //************************************************************************************
    int Check( const ProcessInfo& rCurrentProcessInfo ) const override;
 
 
protected:
 
    IntegrationMethod mThisIntegrationMethod;
 
 
 
    void InitializeExplicitContributions();
 
 
    virtual bool HasVariableDof(VariableVectorType& rVariable) const;
 
    virtual bool HasVariableDof(VariableScalarType& rVariable) const;
 
 
    virtual unsigned int GetDofsSize() const;
 
    virtual void InitializeSystemMatrices(MatrixType& rLeftHandSideMatrix,
                      VectorType& rRightHandSideVector,
                      Flags& rCalculationFlags);
 
    virtual void InitializeConditionVariables(ConditionVariables& rVariables,
                        const ProcessInfo& rCurrentProcessInfo);
 
    virtual void CalculateKinematics(ConditionVariables& rVariables,
                     const double& rPointNumber);
 
 
    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 CalculateAndAddExternalForces(Vector& rRightHandSideVector,
                           ConditionVariables& rVariables,
                           double& rIntegrationWeight);
 
    virtual double& CalculateAndAddExternalEnergy(double& rEnergy,
                          ConditionVariables& rVariables,
                          double& rIntegrationWeight,
                          const ProcessInfo& rCurrentProcessInfo);
    void GetNodalDeltaMovements(Vector& rValues, const int& rNode);
 
    Vector& GetNodalCurrentValue(const Variable<array_1d<double,3> >&rVariable, Vector& rValue, const unsigned int& rNode);
 
    Vector& GetNodalPreviousValue(const Variable<array_1d<double,3> >&rVariable, Vector& rValue, const unsigned int& rNode);
 
 
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override;
 
    void load(Serializer& rSerializer) override;
 
 
}; // class BoundaryCondition.
 
} // namespace Kratos.
 
#endif // KRATOS_BOUNDARY_CONDITION_H_INCLUDED defined