generic_total_lagrangian_mixtures_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:    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) GenericTotalLagrangianMixturesFemDemElement
    : public GenericTotalLagrangianFemDemElement<TDim,TyieldSurf>
{
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();
 
    typedef array_1d<double, VoigtSize> BoundedVectorType;
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(GenericTotalLagrangianMixturesFemDemElement);
 
 
    GenericTotalLagrangianMixturesFemDemElement(IndexType NewId, GeometryType::Pointer pGeometry);
    GenericTotalLagrangianMixturesFemDemElement(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
    // GenericTotalLagrangianMixturesFemDemElement(GenericTotalLagrangianMixturesFemDemElement const &rOther);
 
    virtual ~GenericTotalLagrangianMixturesFemDemElement();
 
    GenericTotalLagrangianMixturesFemDemElement(GenericTotalLagrangianMixturesFemDemElement 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;
 
    GenericTotalLagrangianMixturesFemDemElement()
    {
    }
 
protected:
 
    Vector IntegrateSmoothedConstitutiveLaw(const std::string &rYieldSurface, ConstitutiveLaw::Parameters &rValues,
                                            const BaseSolidElement::ConstitutiveVariables &rThisConstVars, const BaseSolidElement::KinematicVariables &rKinVariables,
                                            Vector &rStrainVector, double &rDamageElement, bool &rIsDamaging, const double CharacteristicLength,
                                            const bool SaveIntVars) override;
 
    Vector IntegrateStressPlasticity(ConstitutiveLaw::Parameters &rValues,
                                     const Vector &rStrainVector,
                                     Vector& rPlasticStrainVector,
                                     double &rAcumulatedPlasticStrain,
                                     double &rThreshold,
                                     double& rUniaxialStress,
                                     bool &rIsPlastifying);
    void ComputePlasticMultiplier(const double UniaxialStress,
                                  const double Threshold,
                                  double &rPlasticMultiplier,
                                  ConstitutiveLaw::Parameters &rValues);
    void ComputePlasticThreshold(const double AcumulatedPlasticStrain,
                                 double &rThreshold,
                                 ConstitutiveLaw::Parameters &rValues);
 
    void IntegratePerturbedStrain(Vector &rPerturbedStressVector,
                                  const Vector &rPerturbedStrainVector,
                                  const Matrix &rElasticMatrix,
                                  ConstitutiveLaw::Parameters &rValues) override;
 
    void CalculateOnIntegrationPoints(
        const Variable<double> &rVariable,
        std::vector<double> &rOutput,
        const ProcessInfo &rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        const Variable<Vector>& rVariable,
        std::vector<Vector>& rOutput,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        const Variable<Matrix>& rVariable,
        std::vector<Matrix>& rOutput,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    Vector CalculateAveragePlasticStrain()
    {
        Vector average_plastic_strain(VoigtSize);
        noalias(average_plastic_strain) = ZeroVector(VoigtSize);
        for (IndexType i = 0; i < NumberOfEdges; ++i)
            average_plastic_strain += mPlasticStrains[i];
        return average_plastic_strain / NumberOfEdges;
    }
 
    double CalculateAverageAcumulatedPlasticStrain()
    {
        double acumulated_strain = 0.0;
        for (IndexType i = 0; i < NumberOfEdges; ++i)
            acumulated_strain += mAcumulatedPlasticStrains[i];
        return acumulated_strain / NumberOfEdges;
    }
 
 
    void CheckIfEraseElement(
        const ProcessInfo &rCurrentProcessInfo,
        const Properties& rProperties
        ) override
    {
        if (this->mDamage >= 0.98 && this->CalculateAverageAcumulatedPlasticStrain() >= rProperties[MAX_PLASTIC_STRAIN]) {
            this->Set(ACTIVE, false);
            this->mDamage = 0.98;
            // We set a "flag" to generate the DEM
            // rCurrentProcessInfo[GENERATE_DEM] = true;
            this->SetValue(GENERATE_DEM, true);
        }
    }
 
    void CalculateAll(
        MatrixType &rLeftHandSideMatrix,
        VectorType &rRightHandSideVector,
        const ProcessInfo &rCurrentProcessInfo,
        const bool CalculateStiffnessMatrixFlag,
        const bool CalculateResidualVectorFlag) override;
 
    Vector mAcumulatedPlasticStrains;
    Vector mPlasticityThresholds;
    std::vector<Vector> mPlasticStrains;
    double mUniaxialStress = 0.0;
 
 
 
 
 
 
}; // Class GenericTotalLagrangianMixturesFemDemElement
 
template<unsigned int TDim, unsigned int TyieldSurf> constexpr SizeType GenericTotalLagrangianMixturesFemDemElement<TDim, TyieldSurf>::VoigtSize;
template<unsigned int TDim, unsigned int TyieldSurf> constexpr SizeType GenericTotalLagrangianMixturesFemDemElement<TDim, TyieldSurf>::NumberOfEdges;
 
 
} // namespace Kratos.