displacement_newtonian_fluid_3D_law.hpp

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:        BSD License
//                  Kratos default license: kratos/license.txt
//
//  Main authors:    Contri Alessandro
//
//  References:      This class is based on the file applications/ParticleMechanicsApplication/custom_constitutive/hyperelastic_3D_law.hpp
 
 
#if !defined (KRATOS_DISPLACEMENT_NEWTONIAN_3D_LAW_H_INCLUDED)
#define       KRATOS_DISPLACEMENT_NEWTONIAN_3D_LAW_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/constitutive_law.h"
 
 
namespace Kratos
{
 
class KRATOS_API(PARTICLE_MECHANICS_APPLICATION) DispNewtonianFluid3DLaw
    : public ConstitutiveLaw
{
protected:
 
    struct MaterialResponseVariables
    {
 
    // general material properties
        double Mu; // shear modulus
        double BulkModulus;
 
    // kinematic properties
        double DeterminantF;
        double DeltaTime;
        Matrix DeformationGradientF;  // Deformation Gradient Tensor in 3D
        Matrix Identity;
 
        Matrix DeformationRate; // symmetric part of velocity gradient
    Matrix CauchyGreenMatrix;     // LeftCauchyGreen
        Matrix StressMatrix;
 
        const Vector* mpShapeFunctionsValues;
        const Matrix* mpShapeFunctionsDerivatives;
        const GeometryType* mpElementGeometry;
 
    public:
        void SetShapeFunctionsValues(const Vector& rShapeFunctionsValues)
        {
            mpShapeFunctionsValues = &rShapeFunctionsValues;
        };
 
        void SetElementGeometry(const GeometryType& rElementGeometry)
        {
            mpElementGeometry = &rElementGeometry;
        };
 
        const Vector& GetShapeFunctionsValues() const
        {
            return *mpShapeFunctionsValues;
        };
 
        const GeometryType& GetElementGeometry() const
        {
            return *mpElementGeometry;
        };
    };
 
public:
    typedef ProcessInfo      ProcessInfoType;
    typedef ConstitutiveLaw         BaseType;
    typedef std::size_t             SizeType;
    KRATOS_CLASS_POINTER_DEFINITION( DispNewtonianFluid3DLaw );
 
    DispNewtonianFluid3DLaw();
 
    ConstitutiveLaw::Pointer Clone() const override;
 
    DispNewtonianFluid3DLaw (const DispNewtonianFluid3DLaw& rOther);
 
 
    //DispNewtonianFluid3DLaw& operator=(const DispNewtonianFluid3DLaw& rOther);
 
 
    ~DispNewtonianFluid3DLaw() override;
 
    SizeType WorkingSpaceDimension() override
    {
        return 3;
    };
 
    SizeType GetStrainSize() const override
    {
        return 6;
    };
 
    bool Has(const Variable<double>& rThisVariable) override;
    bool Has(const Variable<Vector>& rThisVariable) override;
    bool Has(const Variable<Matrix>& rThisVariable) override;
 
 
    double& CalculateValue(Parameters& rParameterValues, const Variable<double>& rThisVariable, double& rValue) override;
 
    double& GetValue(const Variable<double>& rThisVariable, double& rValue) override;
    Vector& GetValue(const Variable<Vector>& rThisVariable, Vector& rValue) override;
    Matrix& GetValue(const Variable<Matrix>& rThisVariable, Matrix& rValue) override;
 
    void SetValue(const Variable<double>& rVariable, const double& rValue, const ProcessInfo& rCurrentProcessInfo) override;
    void SetValue(const Variable<Vector>& rVariable, const Vector& rValue, const ProcessInfo& rCurrentProcessInfo) override;
    void SetValue(const Variable<Matrix>& rVariable, const Matrix& rValue, const ProcessInfo& rCurrentProcessInfo) override;
 
    void InitializeMaterial(const Properties& rMaterialProperties,
        const GeometryType& rElementGeometry,
        const Vector& rShapeFunctionsValues) override;
 
    void CalculateMaterialResponseKirchhoff(Parameters& rValues) override;
 
    void CalculateMaterialResponseCauchy(Parameters& rValues) override;
 
 
    void FinalizeMaterialResponseKirchhoff(Parameters& rValues) override;
 
    void FinalizeMaterialResponseCauchy(Parameters& rValues) override;
 
    void GetLawFeatures(Features& rFeatures) override;
 
    int Check(const Properties& rMaterialProperties, const GeometryType& rElementGeometry, const ProcessInfo& rCurrentProcessInfo) const override;
 
    //String Info() const override;
    //void PrintInfo(std::ostream& rOStream) const override;
    //void PrintData(std::ostream& rOStream) const override;
 
protected:
 
 
    Matrix mInverseDeformationGradientF0;
 
    double mDeterminantF0;
 
 
    virtual void CalculateAlmansiStrain( const Matrix & rLeftCauchyGreen,
                                         Vector& rStrainVector );
 
    virtual void CalculateDeformationRate(MaterialResponseVariables& rViscousVariables);
 
    void CalculateStress(MaterialResponseVariables& rViscousVariables, StressMeasure rStressMeasure, Vector& rStressVector);
 
    virtual void CalculateVolumetricStress(const MaterialResponseVariables& rViscousVariables, Vector& rVolStressVector);
 
    virtual void CalculateIsochoricStress(const MaterialResponseVariables& rViscousVariables, StressMeasure rStressMeasure, Vector& rIsoStressVector);
 
 
    virtual void CalculateConstitutiveMatrix ( const MaterialResponseVariables& rViscousVariables,
                                       Matrix& rConstitutiveMatrix);
 
    double& ConstitutiveComponent(double& rCabcd, const MaterialResponseVariables& rViscousVariables,
        const unsigned int& a, const unsigned int& b, const unsigned int& c, const unsigned int& d);
 
    virtual void CalculateVolumetricConstitutiveMatrix(const MaterialResponseVariables& rViscousVariables, Matrix& rConstitutiveMatrix);
 
    double& VolumetricConstitutiveComponent(double& rCabcd, const MaterialResponseVariables& rViscousVariables, const Vector& rFactors, const unsigned int& a,
        const unsigned int& b, const unsigned int& c, const unsigned int& d);
 
 
    virtual void CalculateIsochoricConstitutiveMatrix(const MaterialResponseVariables& rViscousVariables, const Matrix& rIsoStressMatrix, Matrix& rConstitutiveMatrix);
 
    double& IsochoricConstitutiveComponent(double& rCabcd, const MaterialResponseVariables& rViscousVariables, const Matrix& rIsoStressMatrix, const unsigned int& a,
        const unsigned int& b, const unsigned int& c, const unsigned int& d);
 
    virtual double& CalculateVolumetricPressure(const MaterialResponseVariables& rViscousVariables,
        double& rPressure);
 
    virtual Vector& CalculateVolumetricPressureFactors(const MaterialResponseVariables& rViscousVariables, Vector& rFactors);
 
    Matrix& Transform2DTo3D(Matrix& rMatrix);
 
    virtual void UpdateInternalVariables(Parameters& rValues);
 
    void CalculateDeviatoricPart(const Matrix& rMatrix, Matrix& rDevMatrix);
 
    virtual bool CheckParameters(Parameters& rValues);
 
private:
 
 
 
 
 
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, ConstitutiveLaw)
            rSerializer.save("mInverseDeformationGradientF0", mInverseDeformationGradientF0);
        rSerializer.save("mDeterminantF0", mDeterminantF0);
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, ConstitutiveLaw)
            rSerializer.load("mInverseDeformationGradientF0", mInverseDeformationGradientF0);
        rSerializer.load("mDeterminantF0", mDeterminantF0);
    }
 
 
 
}; // Class DispNewtonianFluid3DLaw
}  // namespace Kratos.
#endif // KRATOS_DISPLACEMENT_NEWTONIAN_3D_LAW_H_INCLUDED  defined