hyperelastic_3D_law.hpp

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:        BSD License
//                  Kratos default license: kratos/license.txt
//
//  Main authors:    Bodhinanda Chandra
//
//  References:      This class is adapted from applications/SolidMechanicsApplication/custom_constitutive/hyperelastic_3D_law.hpp
 
 
#if !defined (KRATOS_HYPERELASTIC_3D_LAW_H_INCLUDED)
#define       KRATOS_HYPERELASTIC_3D_LAW_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/constitutive_law.h"
 
namespace Kratos
{
class KRATOS_API(PARTICLE_MECHANICS_APPLICATION) HyperElastic3DLaw
    : public ConstitutiveLaw
{
protected:
 
 
    struct MaterialResponseVariables
    {
        // general material properties
        double LameMu;
        double LameLambda;
 
        // general thermal properties
        double ThermalExpansionCoefficient;
        double ReferenceTemperature;
 
        // kinematic properties
        double DeterminantF;
        double traceCG;               // LeftCauchyGreen or RightCauchyGreen
        Matrix CauchyGreenMatrix;     // LeftCauchyGreen or InverseRightCauchyGreen
        Matrix DeformationGradientF;  // Deformation Gradient Tensor in 3D
        Matrix Identity;
 
        //element properties
        const Vector*        mpShapeFunctionsValues;
        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( HyperElastic3DLaw );
 
    HyperElastic3DLaw();
 
    ConstitutiveLaw::Pointer Clone() const override;
 
    HyperElastic3DLaw (const HyperElastic3DLaw& rOther);
 
 
    //HyperElastic3DLaw& operator=(const HyperElastic3DLaw& rOther);
 
 
    ~HyperElastic3DLaw() 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>& rThisVariable,
                   const Vector& rValue,
                   const ProcessInfo& rCurrentProcessInfo ) override;
    void SetValue( const Variable<Matrix>& rThisVariable,
                   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;
 
    double mStrainEnergy;
 
 
 
    virtual void CalculateGreenLagrangeStrain( const Matrix & rRightCauchyGreen,
            Vector& rStrainVector );
 
 
    virtual void CalculateAlmansiStrain( const Matrix & rLeftCauchyGreen,
                                         Vector& rStrainVector );
 
    virtual double& CalculateDomainTemperature (const MaterialResponseVariables & rElasticVariables,
                        double & rTemperature);
 
    void CalculateStress( const MaterialResponseVariables& rElasticVariables,
                          StressMeasure rStressMeasure,
                          Vector& rStressVector);
 
    virtual void CalculateVolumetricStress( const MaterialResponseVariables & rElasticVariables,
                                            Vector& rVolStressVector );
 
    virtual void CalculateIsochoricStress( const MaterialResponseVariables & rElasticVariables,
                                           StressMeasure rStressMeasure,
                       Vector& rIsoStressVector);
 
 
    virtual void CalculateConstitutiveMatrix (const MaterialResponseVariables& rElasticVariables,
                          Matrix& rConstitutiveMatrix);
 
 
    double& ConstitutiveComponent( double & rCabcd,
                                   const MaterialResponseVariables& rElasticVariables,
                                   const unsigned int& a, const unsigned int& b,
                                   const unsigned int& c, const unsigned int& d);
 
 
    virtual void CalculateVolumetricConstitutiveMatrix (const MaterialResponseVariables& rElasticVariables,
                            Matrix& rConstitutiveMatrix);
 
 
    double& VolumetricConstitutiveComponent( double & rCabcd,
                         const MaterialResponseVariables& rElasticVariables,
                         const Vector& rFactors,
                         const unsigned int& a, const unsigned int& b,
                         const unsigned int& c, const unsigned int& d);
 
 
    virtual void CalculateIsochoricConstitutiveMatrix (const MaterialResponseVariables& rElasticVariables,
                               const Matrix & rIsoStressMatrix,
                               Matrix& rConstitutiveMatrix);
 
 
    double& IsochoricConstitutiveComponent( double & rCabcd,
                                            const MaterialResponseVariables& rElasticVariables,
                                            const Matrix & rIsoStressMatrix,
                                            const unsigned int& a, const unsigned int& b,
                                            const unsigned int& c, const unsigned int& d);
 
 
    virtual double& CalculateVolumetricFactor (const MaterialResponseVariables & rElasticVariables,
                           double & rFactor);
 
 
    virtual double& CalculateVolumetricPressure (const MaterialResponseVariables & rElasticVariables,
                         double & rPressure);
 
 
    virtual Vector&  CalculateVolumetricPressureFactors (const MaterialResponseVariables & rElasticVariables,
                             Vector & rFactors);
 
 
    Matrix& Transform2DTo3D (Matrix& rMatrix);
 
 
    virtual void UpdateInternalVariables (Parameters & rValues);
 
    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);
        rSerializer.save("mStrainEnergy",mStrainEnergy);
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, ConstitutiveLaw )
        rSerializer.load("mInverseDeformationGradientF0",mInverseDeformationGradientF0);
        rSerializer.load("mDeterminantF0",mDeterminantF0);
        rSerializer.load("mStrainEnergy",mStrainEnergy);
    }
 
 
 
}; // Class HyperElastic3DLaw
}  // namespace Kratos.
#endif // KRATOS_HYPERELASTIC_3D_LAW_H_INCLUDED  defined