mpm_updated_lagrangian_UP.hpp

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:        BSD License
//                  Kratos default license: kratos/license.txt
//
//  Main authors:    Ilaria Iaconeta
//
 
 
#if !defined(KRATOS_UPDATED_LAGRANGIAN_UP_H_INCLUDED )
#define  KRATOS_UPDATED_LAGRANGIAN_UP_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_elements/mpm_updated_lagrangian.hpp"
 
namespace Kratos
{
 
 
class MPMUpdatedLagrangianUP
    : public MPMUpdatedLagrangian
{
public:
 
    typedef ConstitutiveLaw ConstitutiveLawType;
    typedef ConstitutiveLawType::Pointer ConstitutiveLawPointerType;
    typedef ConstitutiveLawType::StressMeasure StressMeasureType;
    typedef GeometryData::IntegrationMethod IntegrationMethod;
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( MPMUpdatedLagrangianUP );
 
 
 
 
public:
 
 
 
    MPMUpdatedLagrangianUP();
 
 
    MPMUpdatedLagrangianUP(IndexType NewId, GeometryType::Pointer pGeometry);
 
    MPMUpdatedLagrangianUP(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
    MPMUpdatedLagrangianUP(MPMUpdatedLagrangianUP const& rOther);
 
    ~MPMUpdatedLagrangianUP() override;
 
 
    MPMUpdatedLagrangianUP& operator=(MPMUpdatedLagrangianUP const& rOther);
 
 
    Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes, PropertiesType::Pointer pProperties) const override;
 
    Element::Pointer Create(IndexType NewId, GeometryType::Pointer pGeom, PropertiesType::Pointer pProperties) const override;
 
    Element::Pointer Clone(IndexType NewId, NodesArrayType const& ThisNodes) const override;
 
 
    //************* GETTING METHODS
 
    void GetDofList(DofsVectorType& rElementalDofList, 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;
 
    //************* STARTING - ENDING  METHODS
 
    void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
 
    void InitializeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
 
    //************* COMPUTING  METHODS
 
    void CalculateMassMatrix(MatrixType& rMassMatrix,
                             const ProcessInfo& rCurrentProcessInfo) override;
 
 
    //************************************************************************************
    //************************************************************************************
    int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
 
 
    void CalculateOnIntegrationPoints(const Variable<double>& rVariable,
        std::vector<double>& rValues,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void SetValuesOnIntegrationPoints(
        const Variable<double>& rVariable,
        const std::vector<double>& rValues,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "MPM Element #" << Id();
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "MPM Element #" << Id();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        GetGeometry().PrintData(rOStream);
    }
 
protected:
 
    SizeType GetNumberOfDofs() override {
        return GetGeometry().WorkingSpaceDimension() + 1;
    }
 
    //virtual void CalculateElementalSystem(LocalSystemComponents& rLocalSystem,
    //ProcessInfo& rCurrentProcessInfo);
    void FinalizeStepVariables(GeneralVariables & rVariables, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateAndAddLHS(MatrixType& rLeftHandSideMatrix,
                            GeneralVariables& rVariables,
                            const double& rIntegrationWeight,
                            const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateAndAddRHS(VectorType& rRightHandSideVector,
                            GeneralVariables& rVariables,
                            Vector& rVolumeForce,
                            const double& rIntegrationWeight,
                            const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void CalculateAndAddKuum(MatrixType& rLeftHandSideMatrix,
                             GeneralVariables& rVariables,
                             const double& rIntegrationWeight) override;
 
    void CalculateAndAddKuugUP(MatrixType& rLeftHandSideMatrix,
                               GeneralVariables& rVariables,
                               const double& rIntegrationWeight);
 
    virtual void CalculateAndAddKup (MatrixType& rK,
                                     GeneralVariables & rVariables,
                                     const double& rIntegrationWeight
                                    );
 
    virtual void CalculateAndAddKpu(MatrixType& rK,
                                    GeneralVariables & rVariables,
                                    const double& rIntegrationWeight
                                   );
 
    virtual void CalculateAndAddKpp(MatrixType& rK,
                                    GeneralVariables & rVariables,
                                    const double& rIntegrationWeight
                                   );
 
    virtual void CalculateAndAddKppStab(MatrixType& rK,
                                        GeneralVariables & rVariables,
                                        const double& rIntegrationWeight
                                       );
    void CalculateAndAddExternalForces(VectorType& rRightHandSideVector,
                                       GeneralVariables& rVariables,
                                       Vector& rVolumeForce,
                                       const double& rIntegrationWeight) override;
 
    void CalculateAndAddInternalForces(VectorType& rRightHandSideVector,
                                       GeneralVariables & rVariables,
                                       const double& rIntegrationWeight) override;
 
    virtual void CalculateAndAddPressureForces(VectorType& rRightHandSideVector,
            GeneralVariables & rVariables,
            const double& rIntegrationWeight
                                              );
 
    virtual void CalculateAndAddStabilizedPressure(VectorType& rRightHandSideVector,
            GeneralVariables & rVariables,
            const double& rIntegrationWeight
                                                  );
 
    void CalculateKinematics(GeneralVariables& rVariables, const ProcessInfo& rCurrentProcessInfo) override;
 
    void InitializeGeneralVariables(GeneralVariables & rVariables, const ProcessInfo& rCurrentProcessInfo) override;
    void UpdateGaussPoint(GeneralVariables & rVariables, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    virtual double& CalculatePUCoefficient(double& rCoefficient, GeneralVariables & rVariables);
 
    virtual double& CalculatePUDeltaCoefficient(double& rCoefficient, GeneralVariables & rVariables);
 
    void GetHistoricalVariables( GeneralVariables& rVariables) override;
 
    using MPMUpdatedLagrangian::CalculateDeformationMatrix;
    void CalculateDeformationMatrix(Matrix& rB,
                                    Matrix& rF,
                                    Matrix& rDN_DX);
 
    double& CalculateVolumeChange(double& rVolumeChange, GeneralVariables& rVariables) override;
 
 
private:
 
 
    double m_mp_pressure;
 
 
 
 
 
 
    friend class Serializer;
 
    // A private default constructor necessary for serialization
 
    void save(Serializer& rSerializer) const override;
 
    void load(Serializer& rSerializer) override;
 
 
 
}; // Class MPMUpdatedLagrangian
 
 
} // namespace Kratos.
#endif // KRATOS_UPDATED_LAGRANGIAN_H_INCLUDED  defined