generic_small_strain_femdem_element.hpp

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics FemDem Application
//
//  License:         BSD License
//                     Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//                   Vicente Mataix Ferrandiz
//                   Alejandro Cornejo
 
#pragma once
 
// System includes
 
// External include
 
// Project includes
 
#include "custom_elements/generic_total_lagrangian_femdem_element.h"
#include "custom_utilities/constitutive_law_utilities.h"
 
namespace Kratos
{
 
 
 
 
 
template<unsigned int TDim, unsigned int TyieldSurf>
class KRATOS_API(FEM_TO_DEM_APPLICATION) GenericSmallStrainFemDemElement 
    : public GenericTotalLagrangianFemDemElement<TDim,TyieldSurf> // Derived Element from SolidMechanics
{
public:
 
    typedef ConstitutiveLaw ConstitutiveLawType;
 
    typedef Element ElementType;
 
    typedef GenericTotalLagrangianFemDemElement<TDim,TyieldSurf> BaseType;
 
    typedef Node NodeType;
 
    typedef Properties PropertiesType;
 
    typedef Geometry<NodeType> GeometryType;
 
    typedef Geometry<NodeType>::PointsArrayType NodesArrayType;
 
    typedef Vector VectorType;
 
    typedef Matrix MatrixType;
 
    typedef std::size_t IndexType;
 
    typedef std::size_t SizeType;
 
    typedef std::vector<std::size_t> EquationIdVectorType;
 
    typedef std::vector< Dof<double>::Pointer > DofsVectorType;
 
    typedef PointerVectorSet<Dof<double>, IndexedObject> DofsArrayType;
 
    typedef GeometryData GeometryDataType;
 
    static constexpr SizeType VoigtSize = (TDim == 3) ? 6 : 3;
 
    static constexpr SizeType NumberOfEdges = (TDim == 3) ? 6 : 3;
 
    typedef ConstitutiveLawType::Pointer ConstitutiveLawPointerType;
 
    static constexpr double tolerance = std::numeric_limits<double>::epsilon();
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(GenericSmallStrainFemDemElement);
 
 
    GenericSmallStrainFemDemElement(IndexType NewId, GeometryType::Pointer pGeometry);
    GenericSmallStrainFemDemElement(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
    // GenericSmallStrainFemDemElement(GenericSmallStrainFemDemElement const &rOther);
 
    virtual ~GenericSmallStrainFemDemElement();
 
    GenericSmallStrainFemDemElement(GenericSmallStrainFemDemElement const& rOther)
        : BaseType(rOther)
    {};
 
    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;
 
    Element::Pointer Clone(
        IndexType NewId,
        NodesArrayType const& rThisNodes
        ) const override;
 
    GenericSmallStrainFemDemElement()
    {
    }
 
    void CalculateOnIntegrationPoints(
        const Variable<Vector>& rVariable,
        std::vector<Vector>& rOutput,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void FinalizeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
    void InitializeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateTangentTensor(Matrix& rTangentTensor,const Vector& rStrainVectorGP,const Vector& rStressVectorGP,const Matrix& rElasticMatrix, ConstitutiveLaw::Parameters& rValues);
    void CalculateTangentTensorSecondOrder(Matrix& rTangentTensor,const Vector& rStrainVectorGP,const Vector& rStressVectorGP,const Matrix& rElasticMatrix, ConstitutiveLaw::Parameters& rValues);
 
    void ComputeEquivalentF(Matrix& rF,const Vector& rStrainTensor);
protected:
 
    void CalculateAll(
        MatrixType& rLeftHandSideMatrix,
        VectorType& rRightHandSideVector,
        const ProcessInfo& rCurrentProcessInfo,
        const bool CalculateStiffnessMatrixFlag,
        const bool CalculateResidualVectorFlag
        ) override;
 
    void CalculateKinematicVariables(
        BaseSolidElement::KinematicVariables& rThisKinematicVariables,
        const IndexType PointNumber,
        const GeometryType::IntegrationMethod& rIntegrationMethod) override;
 
    void CalculateB(Matrix& rB, const Matrix& rDN_DX);
    void Calculate2DB(Matrix& rB, const Matrix& rDN_DX);
    void Calculate3DB(Matrix& rB, const Matrix& rDN_DX);
 
    // void ComputeEquivalentF(Matrix& rF, const Vector& rStrainTensor);
 
    void CalculateConstitutiveVariables(
        BaseSolidElement::KinematicVariables& rThisKinematicVariables,
        BaseSolidElement::ConstitutiveVariables& rThisConstitutiveVariables,
        ConstitutiveLaw::Parameters& rValues,
        const IndexType PointNumber,
        const GeometryType::IntegrationPointsArrayType& IntegrationPoints,
        const ConstitutiveLaw::StressMeasure ThisStressMeasure) override;
 
    void SetConstitutiveVariables(
        BaseSolidElement::KinematicVariables& rThisKinematicVariables,
        BaseSolidElement::ConstitutiveVariables& rThisConstitutiveVariables,
        ConstitutiveLaw::Parameters& rValues,
        const IndexType PointNumber,
        const GeometryType::IntegrationPointsArrayType& IntegrationPoints) override;
 
    void GetValuesVector(
        Vector& rValues,
        int Step = 0
        ) const  override;
 
    bool UseElementProvidedStrain() const override;
 
        
 
 
 
 
 
}; // Class GenericSmallStrainFemDemElement
 
template<unsigned int TDim, unsigned int TyieldSurf> constexpr SizeType GenericSmallStrainFemDemElement<TDim, TyieldSurf>::VoigtSize;
template<unsigned int TDim, unsigned int TyieldSurf> constexpr SizeType GenericSmallStrainFemDemElement<TDim, TyieldSurf>::NumberOfEdges;
 
 
} // namespace Kratos.