geo_truss_element_base.hpp

Go to the documentation of this file.

// KRATOS___
//     //   ) )
//    //         ___      ___
//   //  ____  //___) ) //   ) )
//  //    / / //       //   / /
// ((____/ / ((____   ((___/ /  MECHANICS
//
//  License:         geo_mechanics_application/license.txt
//
//  Main authors:    Klaus B. Sautter,
//                   Vahid Galavi
//
 
#if !defined(KRATOS_GEO_TRUSS_ELEMENT_BASE_H_INCLUDED)
#define KRATOS_GEO_TRUSS_ELEMENT_BASE_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/element.h"
#include "includes/variables.h"
 
namespace Kratos
{
template <unsigned int TDim, unsigned int TNumNodes>
class KRATOS_API(GEO_MECHANICS_APPLICATION) GeoTrussElementBase : public Element
{
protected:
    ConstitutiveLaw::Pointer mpConstitutiveLaw = nullptr;
    static constexpr SizeType NDof             = TDim * TNumNodes;
    static constexpr SizeType DIM              = TDim;
    static constexpr SizeType NUM_NODES        = TNumNodes;
 
public:
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(GeoTrussElementBase);
 
    using BaseType             = Element;
    using GeometryType         = BaseType::GeometryType;
    using NodesArrayType       = BaseType::NodesArrayType;
    using PropertiesType       = BaseType::PropertiesType;
    using IndexType            = BaseType::IndexType;
    using SizeType             = BaseType::SizeType;
    using MatrixType           = BaseType::MatrixType;
    using VectorType           = BaseType::VectorType;
    using EquationIdVectorType = BaseType::EquationIdVectorType;
    using DofsVectorType       = BaseType::DofsVectorType;
    using FullDofMatrixType    = BoundedMatrix<double, TDim * TNumNodes, TDim * TNumNodes>;
    using FullDofVectorType    = BoundedVector<double, TDim * TNumNodes>;
 
    GeoTrussElementBase(){};
    GeoTrussElementBase(IndexType NewId, GeometryType::Pointer pGeometry);
    GeoTrussElementBase(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
    ~GeoTrussElementBase() override;
 
    Element::Pointer Create(IndexType NewId, GeometryType::Pointer pGeom, PropertiesType::Pointer pProperties) const override;
 
    Element::Pointer Create(IndexType NewId,
                            NodesArrayType const& ThisNodes,
                            PropertiesType::Pointer pProperties) const override;
 
    void EquationIdVector(EquationIdVectorType& rResult, const ProcessInfo& rCurrentProcessInfo) const override;
 
    void GetDofList(DofsVectorType& rElementalDofList, const ProcessInfo& rCurrentProcessInfo) const override;
 
    void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
 
    virtual void CreateElementStiffnessMatrix(MatrixType& rLocalStiffnessMatrix,
                                              const ProcessInfo& rCurrentProcessInfo);
 
    void Calculate(const Variable<Matrix>& rVariable, Matrix& rOutput, const ProcessInfo& rCurrentProcessInfo) override;
 
    void Calculate(const Variable<double>& rVariable, double& rOutput, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(const Variable<double>& rVariable,
                                      std::vector<double>& rOutput,
                                      const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(const Variable<array_1d<double, 3>>& rVariable,
                                      std::vector<array_1d<double, 3>>& rOutput,
                                      const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(const Variable<Vector>& rVariable,
                                      std::vector<Vector>& rOutput,
                                      const ProcessInfo& rCurrentProcessInfo) override;
 
    virtual void UpdateInternalForces(FullDofVectorType& rInternalForces, const ProcessInfo& rCurrentProcessInfo);
 
    void CreateTransformationMatrix(BoundedMatrix<double, TDim * TNumNodes, TDim * TNumNodes>& rRotationMatrix);
 
    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 CalculateConsistentMassMatrix(MatrixType& rMassMatrix, const ProcessInfo& rCurrentProcessInfo) const;
 
    void CalculateDampingMatrix(MatrixType& rDampingMatrix, const ProcessInfo& rCurrentProcessInfo) override;
 
    void AddExplicitContribution(const VectorType& rRHSVector,
                                 const Variable<VectorType>& rRHSVariable,
                                 const Variable<double>& rDestinationVariable,
                                 const ProcessInfo& rCurrentProcessInfo) override;
 
    void AddExplicitContribution(const VectorType& rRHSVector,
                                 const Variable<VectorType>& rRHSVariable,
                                 const Variable<array_1d<double, 3>>& rDestinationVariable,
                                 const ProcessInfo& rCurrentProcessInfo) override;
 
    void GetValuesVector(Vector& rValues, int Step = 0) const override;
 
    void GetSecondDerivativesVector(Vector& rValues, int Step = 0) const override;
 
    void GetFirstDerivativesVector(Vector& rValues, int Step = 0) const override;
 
    int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
    double CalculateGreenLagrangeStrain() const;
 
    void CalculateBodyForces(FullDofVectorType& rGlobalBodyForces);
 
    void CalculateGeometricStiffnessMatrix(BoundedMatrix<double, TDim * TNumNodes, TDim * TNumNodes>& rGeometricStiffnessMatrix,
                                           const ProcessInfo& rCurrentProcessInfo);
 
    void CalculateElasticStiffnessMatrix(MatrixType& rElasticStiffnessMatrix, const ProcessInfo& rCurrentProcessInfo);
 
    virtual void WriteTransformationCoordinates(FullDofVectorType& rReferenceCoordinates);
 
    double ReturnTangentModulus1D(const ProcessInfo& rCurrentProcessInfo);
 
    void FinalizeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
private:
    void CalculateLumpedMassVector(VectorType& rMassVector, const ProcessInfo& rCurrentProcessInfo) const override;
 
    friend class Serializer;
    void save(Serializer& rSerializer) const override;
    void load(Serializer& rSerializer) override;
};
 
} // namespace Kratos
 
#endif