constitutive_law.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                     Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//                   Janosch Stascheit
//                   Nelson Maireni Lafontaine
//                   Josep Maria Carbonell
//
 
 
#if !defined(KRATOS_CONSTITUTIVE_LAW )
#define  KRATOS_CONSTITUTIVE_LAW
 
/* System includes */
 
/* External includes */
 
/* Project includes */
#include "includes/define.h"
#include "includes/serializer.h"
#include "includes/variables.h"
#include "includes/node.h"
#include "includes/properties.h"
#include "geometries/geometry.h"
#include "utilities/math_utils.h"
#include "includes/process_info.h"
#include "includes/ublas_interface.h"
#include "includes/kratos_parameters.h"
#include "containers/data_value_container.h"
#include "containers/flags.h"
#include "includes/initial_state.h"
 
 
namespace Kratos
{
 
class KRATOS_API(KRATOS_CORE) ConstitutiveLaw : public Flags
{
public:
 
 
   enum StrainMeasure
   {
        StrainMeasure_Infinitesimal,   //strain measure small displacements
        StrainMeasure_GreenLagrange,   //strain measure reference configuration
        StrainMeasure_Almansi,         //strain measure current configuration
 
        // True strain:
        StrainMeasure_Hencky_Material, //strain measure reference configuration
        StrainMeasure_Hencky_Spatial,  //strain measure current   configuration
 
        // Deformation measures:
        StrainMeasure_Deformation_Gradient, //material deformation gradient as a strain measure
        StrainMeasure_Right_CauchyGreen,    //right cauchy-green tensor as a strain measure
        StrainMeasure_Left_CauchyGreen,     //left  cauchy-green tensor as a strain measure
        StrainMeasure_Velocity_Gradient     //spatial velocity gradient as a strain measure
    };
 
    enum StressMeasure
    {
        StressMeasure_PK1,            //stress related to reference configuration non-symmetric
        StressMeasure_PK2,            //stress related to reference configuration
        StressMeasure_Kirchhoff,      //stress related to current   configuration
        StressMeasure_Cauchy          //stress related to current   configuration
    };
 
 
    typedef ProcessInfo ProcessInfoType;
    typedef std::size_t SizeType;
    typedef Geometry<Node > GeometryType;
 
    typedef Vector StrainVectorType;
    typedef Vector StressVectorType;
    typedef Matrix VoigtSizeMatrixType;           // Constitutive Matrix
    typedef Matrix DeformationGradientMatrixType; // Def. gradient tensor
 
    KRATOS_CLASS_POINTER_DEFINITION(ConstitutiveLaw);
 
    KRATOS_DEFINE_LOCAL_FLAG( USE_ELEMENT_PROVIDED_STRAIN );
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_STRESS );
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_CONSTITUTIVE_TENSOR );
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_STRAIN_ENERGY );
 
    KRATOS_DEFINE_LOCAL_FLAG( ISOCHORIC_TENSOR_ONLY );
    KRATOS_DEFINE_LOCAL_FLAG( VOLUMETRIC_TENSOR_ONLY );
 
    KRATOS_DEFINE_LOCAL_FLAG( MECHANICAL_RESPONSE_ONLY );
    KRATOS_DEFINE_LOCAL_FLAG( THERMAL_RESPONSE_ONLY );
 
    KRATOS_DEFINE_LOCAL_FLAG( INCREMENTAL_STRAIN_MEASURE );
 
 
    KRATOS_DEFINE_LOCAL_FLAG( INITIALIZE_MATERIAL_RESPONSE );
    KRATOS_DEFINE_LOCAL_FLAG( FINALIZE_MATERIAL_RESPONSE );
 
 
    KRATOS_DEFINE_LOCAL_FLAG( FINITE_STRAINS );
    KRATOS_DEFINE_LOCAL_FLAG( INFINITESIMAL_STRAINS );
 
    KRATOS_DEFINE_LOCAL_FLAG( THREE_DIMENSIONAL_LAW );
    KRATOS_DEFINE_LOCAL_FLAG( PLANE_STRAIN_LAW );
    KRATOS_DEFINE_LOCAL_FLAG( PLANE_STRESS_LAW );
    KRATOS_DEFINE_LOCAL_FLAG( AXISYMMETRIC_LAW );
 
    KRATOS_DEFINE_LOCAL_FLAG( U_P_LAW );
 
    KRATOS_DEFINE_LOCAL_FLAG( ISOTROPIC );
    KRATOS_DEFINE_LOCAL_FLAG( ANISOTROPIC );
 
 
    struct Features
    {
 
      KRATOS_CLASS_POINTER_DEFINITION(Features);
 
      Flags                mOptions;
      SizeType             mStrainSize;
      SizeType             mSpaceDimension;
      std::vector< StrainMeasure > mStrainMeasures;
 
      Features()
      {
      }
 
      ~Features()
      {
      }
 
      // Set variables
      void SetOptions        (const Flags&  rOptions)        {mOptions=rOptions;};
      void SetStrainSize     (const SizeType StrainSize)     {mStrainSize=StrainSize;};
      void SetSpaceDimension (const SizeType SpaceDimension) {mSpaceDimension=SpaceDimension;};
      void SetStrainMeasure  (const StrainMeasure Measure)   {mStrainMeasures.push_back(Measure);};
 
      void SetStrainMeasures (const std::vector<StrainMeasure> MeasuresVector) {mStrainMeasures = MeasuresVector;};
 
      // Get variables
      const Flags& GetOptions () {return mOptions;};
 
      const SizeType& GetStrainSize()     {return mStrainSize;};
      const SizeType& GetSpaceDimension() {return mSpaceDimension;};
      std::vector<StrainMeasure>& GetStrainMeasures() {return mStrainMeasures;};
    };
 
 
 
    struct Parameters
    {
        KRATOS_CLASS_POINTER_DEFINITION(Parameters);
 
    private:
 
      /*** NOTE: Member Pointers are used only to point to a certain variable, no "new" or "malloc" can be used for this Parameters ***/
 
      Flags                                 mOptions;
      double                                mDeterminantF;
 
      StrainVectorType*                    mpStrainVector;
      StressVectorType*                    mpStressVector;
 
      const Vector*                        mpShapeFunctionsValues;
      const Matrix*                        mpShapeFunctionsDerivatives;
 
      const DeformationGradientMatrixType* mpDeformationGradientF;
      VoigtSizeMatrixType*                 mpConstitutiveMatrix;
 
      const ProcessInfo*                   mpCurrentProcessInfo;
      const Properties*                    mpMaterialProperties;
      const GeometryType*                  mpElementGeometry;
 
    public:
 
 
      Parameters ()
      {
          //Initialize pointers to NULL
          mDeterminantF=0;
          mpStrainVector=NULL;
          mpStressVector=NULL;
          mpShapeFunctionsValues=NULL;
          mpShapeFunctionsDerivatives=NULL;
          mpDeformationGradientF=NULL;
          mpConstitutiveMatrix=NULL;
          mpCurrentProcessInfo=NULL;
          mpMaterialProperties=NULL;
          mpElementGeometry=NULL;
      };
 
 
      Parameters (
          const GeometryType& rElementGeometry,
          const Properties& rMaterialProperties,
          const ProcessInfo& rCurrentProcessInfo)
      :mpCurrentProcessInfo(&rCurrentProcessInfo)
      ,mpMaterialProperties(&rMaterialProperties)
      ,mpElementGeometry(&rElementGeometry)
      {
          //Initialize pointers to NULL
          mDeterminantF=0;
          mpStrainVector=NULL;
          mpStressVector=NULL;
          mpShapeFunctionsValues=NULL;
          mpShapeFunctionsDerivatives=NULL;
          mpDeformationGradientF=NULL;
          mpConstitutiveMatrix=NULL;
      };
 
      Parameters (const Parameters & rNewParameters)
        :mOptions(rNewParameters.mOptions)
        ,mDeterminantF(rNewParameters.mDeterminantF)
        ,mpStrainVector(rNewParameters.mpStrainVector)
        ,mpStressVector(rNewParameters.mpStressVector)
        ,mpShapeFunctionsValues(rNewParameters.mpShapeFunctionsValues)
        ,mpShapeFunctionsDerivatives(rNewParameters.mpShapeFunctionsDerivatives)
        ,mpDeformationGradientF(rNewParameters.mpDeformationGradientF)
        ,mpConstitutiveMatrix(rNewParameters.mpConstitutiveMatrix)
        ,mpCurrentProcessInfo(rNewParameters.mpCurrentProcessInfo)
        ,mpMaterialProperties(rNewParameters.mpMaterialProperties)
        ,mpElementGeometry(rNewParameters.mpElementGeometry)
      {
      };
 
      ~Parameters()
      {
      }
 
      bool CheckAllParameters ()
      {
        if(CheckMechanicalVariables() &&  CheckShapeFunctions() && CheckInfoMaterialGeometry ())
            return 1;
        else
            return 0;
      }
 
 
      bool CheckShapeFunctions ()
      {
        if(!mpShapeFunctionsValues)
            KRATOS_ERROR << "ShapeFunctionsValues NOT SET" << std::endl;
 
        if(!mpShapeFunctionsDerivatives)
            KRATOS_ERROR << "ShapeFunctionsDerivatives NOT SET" << std::endl;
 
        return 1;
      }
 
      bool CheckInfoMaterialGeometry ()
      {
        if(!mpCurrentProcessInfo)
            KRATOS_ERROR << "CurrentProcessInfo NOT SET" << std::endl;
 
        if(!mpMaterialProperties)
            KRATOS_ERROR << "MaterialProperties NOT SET" << std::endl;
 
        if(!mpElementGeometry)
            KRATOS_ERROR << "ElementGeometry NOT SET" << std::endl;
 
        return 1;
      }
 
 
      bool CheckMechanicalVariables ()
      {
          if(mDeterminantF<=0)
            KRATOS_ERROR << "DeterminantF NOT SET, value <= 0" << std::endl;
 
          if(!mpDeformationGradientF)
            KRATOS_ERROR << "DeformationGradientF NOT SET" << std::endl;
 
          if(!mpStrainVector)
            KRATOS_ERROR << "StrainVector NOT SET" << std::endl;
 
          if(!mpStressVector)
            KRATOS_ERROR << "StressVector NOT SET" << std::endl;
 
          if(!mpConstitutiveMatrix)
            KRATOS_ERROR << "ConstitutiveMatrix NOT SET" << std::endl;
 
          return 1;
      }
 
 
      void Set                             (Flags ThisFlag)                           {mOptions.Set(ThisFlag);};
      void Reset                           (Flags ThisFlag)                           {mOptions.Reset(ThisFlag);};
 
      void SetOptions                      (const Flags&  rOptions)                   {mOptions=rOptions;};
      void SetDeterminantF                 (const double DeterminantF)                {mDeterminantF=DeterminantF;};
      //void SetDeterminantF                 (const double& rDeterminantF)              {mDeterminantF=&rDeterminantF;};
 
      void SetShapeFunctionsValues         (const Vector& rShapeFunctionsValues)      {mpShapeFunctionsValues=&rShapeFunctionsValues;};
      void SetShapeFunctionsDerivatives    (const Matrix& rShapeFunctionsDerivatives) {mpShapeFunctionsDerivatives=&rShapeFunctionsDerivatives;};
 
      void SetDeformationGradientF         (const DeformationGradientMatrixType& rDeformationGradientF)      {mpDeformationGradientF=&rDeformationGradientF;};
 
      void SetStrainVector                 (StrainVectorType& rStrainVector)                       {mpStrainVector=&rStrainVector;};
      void SetStressVector                 (StressVectorType& rStressVector)                       {mpStressVector=&rStressVector;};
      void SetConstitutiveMatrix           (VoigtSizeMatrixType& rConstitutiveMatrix)              {mpConstitutiveMatrix =&rConstitutiveMatrix;};
 
      void SetProcessInfo                  (const ProcessInfo& rProcessInfo)          {mpCurrentProcessInfo =&rProcessInfo;};
      void SetMaterialProperties           (const Properties&  rMaterialProperties)   {mpMaterialProperties =&rMaterialProperties;};
      void SetElementGeometry              (const GeometryType& rElementGeometry)     {mpElementGeometry =&rElementGeometry;};
 
      Flags& GetOptions () {return mOptions;};
 
      const double& GetDeterminantF()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetDeterminantF()) << "DeterminantF is not set!" << std::endl;
          return mDeterminantF;
      }
      const Vector& GetShapeFunctionsValues()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetShapeFunctionsValues()) << "ShapeFunctionsValues is not set!" << std::endl;
          return *mpShapeFunctionsValues;
      }
      const Matrix& GetShapeFunctionsDerivatives()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetShapeFunctionsDerivatives()) << "ShapeFunctionsDerivatives is not set!" << std::endl;
          return *mpShapeFunctionsDerivatives;
      }
      const DeformationGradientMatrixType& GetDeformationGradientF()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetDeformationGradientF()) << "DeformationGradientF is not set!" << std::endl;
          return *mpDeformationGradientF;
      }
 
      StrainVectorType& GetStrainVector()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetStrainVector()) << "StrainVector is not set!" << std::endl;
          return *mpStrainVector;
      }
      StressVectorType& GetStressVector()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetStressVector()) << "StressVector is not set!" << std::endl;
          return *mpStressVector;
      }
 
      VoigtSizeMatrixType& GetConstitutiveMatrix()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetConstitutiveMatrix()) << "ConstitutiveMatrix is not set!" << std::endl;
          return *mpConstitutiveMatrix;
      }
 
      const ProcessInfo& GetProcessInfo()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetProcessInfo()) << "ProcessInfo is not set!" << std::endl;
          return *mpCurrentProcessInfo;
      }
      const Properties& GetMaterialProperties()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetMaterialProperties()) << "MaterialProperties is not set!" << std::endl;
          return *mpMaterialProperties;
      }
      const GeometryType& GetElementGeometry()
      {
          KRATOS_DEBUG_ERROR_IF_NOT(IsSetElementGeometry()) << "ElementGeometry is not set!" << std::endl;
          return *mpElementGeometry;
      }
 
      double& GetDeterminantF                                (double & rDeterminantF) {rDeterminantF=mDeterminantF; return rDeterminantF;};
      StrainVectorType& GetStrainVector                      (StrainVectorType & rStrainVector) {rStrainVector=*mpStrainVector; return rStrainVector;};
      DeformationGradientMatrixType& GetDeformationGradientF (DeformationGradientMatrixType & rDeformationGradientF)  {rDeformationGradientF=*mpDeformationGradientF;   return rDeformationGradientF;};
      StressVectorType& GetStressVector                      (StressVectorType & rStressVector) {rStressVector=*mpStressVector; return rStressVector;};
      VoigtSizeMatrixType& GetConstitutiveMatrix             (VoigtSizeMatrixType & rConstitutiveMatrix) {rConstitutiveMatrix=*mpConstitutiveMatrix; return rConstitutiveMatrix;};
 
      bool IsSetDeterminantF              () {return (mDeterminantF > 0.0);};
      bool IsSetShapeFunctionsValues      () {return (mpShapeFunctionsValues != NULL);};
      bool IsSetShapeFunctionsDerivatives () {return (mpShapeFunctionsDerivatives != NULL);};
      bool IsSetDeformationGradientF      () {return (mpDeformationGradientF != NULL);};
 
      bool IsSetStrainVector              () {return (mpStrainVector != NULL);};
      bool IsSetStressVector              () {return (mpStressVector != NULL);};
 
      bool IsSetConstitutiveMatrix        () {return (mpConstitutiveMatrix != NULL);};
 
      bool IsSetProcessInfo               () {return (mpCurrentProcessInfo != NULL);};
      bool IsSetMaterialProperties        () {return (mpMaterialProperties != NULL);};
      bool IsSetElementGeometry           () {return (mpElementGeometry != NULL);};
 
    };// struct Parameters end
 
    ConstitutiveLaw();
 
    ~ConstitutiveLaw() override{};
 
    virtual ConstitutiveLaw::Pointer Clone() const;
 
    virtual Pointer Create(Kratos::Parameters NewParameters) const;
 
    virtual Pointer Create(
        Kratos::Parameters NewParameters,
        const Properties& rProperties
        ) const;
 
    virtual SizeType WorkingSpaceDimension();
 
    virtual SizeType GetStrainSize() const;
 
    void SetInitialState(InitialState::Pointer pInitialState)
    {
        mpInitialState = pInitialState;
    }
 
    InitialState::Pointer pGetInitialState()
    {
        return mpInitialState;
    }
 
    InitialState& GetInitialState()
    {
        return *mpInitialState;
    }
 
    bool HasInitialState() const
    {
        return mpInitialState != nullptr;
    }
 
    template<typename TVectorType>
    void AddInitialStressVectorContribution(TVectorType& rStressVector)
    {
        if (this->HasInitialState()) {
            const auto& r_initial_state = GetInitialState();
            noalias(rStressVector) += r_initial_state.GetInitialStressVector();
        }
    }
 
    template<typename TVectorType>
    void AddInitialStrainVectorContribution(TVectorType& rStrainVector)
    {
        if (this->HasInitialState()) {
            const auto& r_initial_state = GetInitialState();
            noalias(rStrainVector) -= r_initial_state.GetInitialStrainVector();
        }
    }
 
    template<typename TMatrixType>
    void AddInitialDeformationGradientMatrixContribution(TMatrixType& rF)
    {
        if (this->HasInitialState()) {
            const auto& r_initial_state = GetInitialState();
            rF = prod(r_initial_state.GetInitialDeformationGradientMatrix(), rF);
        }
    }
 
    virtual bool Has(const Variable<bool>& rThisVariable);
 
    virtual bool Has(const Variable<int>& rThisVariable);
 
    virtual bool Has(const Variable<double>& rThisVariable);
 
    virtual bool Has(const Variable<Vector>& rThisVariable);
 
    virtual bool Has(const Variable<Matrix>& rThisVariable);
 
    virtual bool Has(const Variable<array_1d<double, 3 > >& rThisVariable);
 
    virtual bool Has(const Variable<array_1d<double, 6 > >& rThisVariable);
 
    virtual bool& GetValue(const Variable<bool>& rThisVariable, bool& rValue);
 
    virtual int& GetValue(const Variable<int>& rThisVariable, int& rValue);
 
    virtual double& GetValue(const Variable<double>& rThisVariable, double& rValue);
 
    virtual Vector& GetValue(const Variable<Vector>& rThisVariable, Vector& rValue);
 
    virtual Matrix& GetValue(const Variable<Matrix>& rThisVariable, Matrix& rValue);
 
    virtual array_1d<double, 3 > & GetValue(const Variable<array_1d<double, 3 > >& rThisVariable,
                                            array_1d<double, 3 > & rValue);
 
    virtual array_1d<double, 6 > & GetValue(const Variable<array_1d<double, 6 > >& rThisVariable,
                                            array_1d<double, 6 > & rValue);
 
    virtual void SetValue(const Variable<bool>& rVariable,
                          const bool& Value,
                          const ProcessInfo& rCurrentProcessInfo);
 
    virtual void SetValue(const Variable<int>& rVariable,
                          const int& Value,
                          const ProcessInfo& rCurrentProcessInfo);
 
    virtual void SetValue(const Variable<double>& rVariable,
                          const double& rValue,
                          const ProcessInfo& rCurrentProcessInfo);
 
    virtual void SetValue(const Variable<Vector >& rVariable,
                          const Vector& rValue,
              const ProcessInfo& rCurrentProcessInfo);
 
    virtual void SetValue(const Variable<Matrix >& rVariable,
                          const Matrix& rValue,
              const ProcessInfo& rCurrentProcessInfo);
 
    virtual void SetValue(const Variable<array_1d<double, 3 > >& rVariable,
                          const array_1d<double, 3 > & rValue,
                          const ProcessInfo& rCurrentProcessInfo);
 
    virtual void SetValue(const Variable<array_1d<double, 6 > >& rVariable,
                          const array_1d<double, 6 > & rValue,
                          const ProcessInfo& rCurrentProcessInfo);
 
    virtual bool& CalculateValue(Parameters& rParameterValues, const Variable<bool>& rThisVariable, bool& rValue);
 
    virtual int& CalculateValue(Parameters& rParameterValues, const Variable<int>& rThisVariable, int& rValue);
 
    virtual double& CalculateValue(Parameters& rParameterValues, const Variable<double>& rThisVariable, double& rValue);
 
    virtual Vector& CalculateValue(Parameters& rParameterValues, const Variable<Vector>& rThisVariable, Vector& rValue);
 
    virtual Matrix& CalculateValue(Parameters& rParameterValues, const Variable<Matrix>& rThisVariable, Matrix& rValue);
 
    virtual array_1d<double, 3 > & CalculateValue(Parameters& rParameterValues, const Variable<array_1d<double, 3 > >& rVariable,
                          array_1d<double, 3 > & rValue);
 
    virtual array_1d<double, 6 > & CalculateValue(Parameters& rParameterValues, const Variable<array_1d<double, 6 > >& rVariable,
                          array_1d<double, 6 > & rValue);
 
    virtual void CalculateDerivative(
        Parameters& rParameterValues,
        const Variable<double>& rFunctionVariable,
        const Variable<double>& rDerivativeVariable,
        double& rOutput);
 
    virtual void CalculateDerivative(
        Parameters& rParameterValues,
        const Variable<Vector>& rFunctionVariable,
        const Variable<double>& rDerivativeVariable,
        Vector& rOutput);
 
    virtual void CalculateDerivative(
        Parameters& rParameterValues,
        const Variable<Matrix>& rFunctionVariable,
        const Variable<double>& rDerivativeVariable,
        Matrix& rOutput);
 
    virtual void CalculateDerivative(
        Parameters& rParameterValues,
        const Variable<array_1d<double, 3>>& rFunctionVariable,
        const Variable<double>& rDerivativeVariable,
        array_1d<double, 3>& rOutput);
 
 
    virtual bool ValidateInput(const Properties& rMaterialProperties);
 
 
    virtual StrainMeasure GetStrainMeasure();
 
    virtual StressMeasure GetStressMeasure();
 
    virtual bool IsIncremental();
 
    virtual void InitializeMaterial(const Properties& rMaterialProperties,
                                    const GeometryType& rElementGeometry,
                                    const Vector& rShapeFunctionsValues);
 
    KRATOS_DEPRECATED_MESSAGE("Please do not use this method - Use InitializeMaterialResponse instead\"")
    virtual void InitializeSolutionStep(const Properties& rMaterialProperties,
                                        const GeometryType& rElementGeometry, //this is just to give the array of nodes
                                        const Vector& rShapeFunctionsValues,
                                        const ProcessInfo& rCurrentProcessInfo);
 
    KRATOS_DEPRECATED_MESSAGE("Please do not use this method - Use FinalizeMaterialResponse instead\"")
    virtual void FinalizeSolutionStep(const Properties& rMaterialProperties,
                                      const GeometryType& rElementGeometry,
                                      const Vector& rShapeFunctionsValues,
                                      const ProcessInfo& rCurrentProcessInfo);
 
 
 
    KRATOS_DEPRECATED_MESSAGE("Please do not use this method - There is no equivalent for this\"")
    virtual void InitializeNonLinearIteration(const Properties& rMaterialProperties,
                          const GeometryType& rElementGeometry,
                          const Vector& rShapeFunctionsValues,
                          const ProcessInfo& rCurrentProcessInfo);
 
 
 
    KRATOS_DEPRECATED_MESSAGE("Please do not use this method - There is no equivalent for this\"")
    virtual void FinalizeNonLinearIteration(const Properties& rMaterialProperties,
                        const GeometryType& rElementGeometry,
                        const Vector& rShapeFunctionsValues,
                        const ProcessInfo& rCurrentProcessInfo);
 
 
 
    void CalculateMaterialResponse (Parameters& rValues,const StressMeasure& rStressMeasure);
 
 
 
    virtual void CalculateMaterialResponsePK1 (Parameters& rValues);
 
 
    virtual void CalculateMaterialResponsePK2 (Parameters& rValues);
 
 
    virtual void CalculateMaterialResponseKirchhoff (Parameters& rValues);
 
 
    virtual void CalculateMaterialResponseCauchy (Parameters& rValues);
 
    virtual bool RequiresInitializeMaterialResponse()
    {
        return true;
    }
 
    virtual void CalculateStressResponse (Parameters& rValues, Vector& rInternalVariables);
 
    void InitializeMaterialResponse (Parameters& rValues,const StressMeasure& rStressMeasure);
 
    virtual void InitializeMaterialResponsePK1 (Parameters& rValues);
 
    virtual void InitializeMaterialResponsePK2 (Parameters& rValues);
 
    virtual void InitializeMaterialResponseKirchhoff (Parameters& rValues);
 
    virtual void InitializeMaterialResponseCauchy (Parameters& rValues);
 
    virtual bool RequiresFinalizeMaterialResponse()
    {
        return true;
    }
 
    void FinalizeMaterialResponse (Parameters& rValues,const StressMeasure& rStressMeasure);
 
 
    virtual void FinalizeMaterialResponsePK1 (Parameters& rValues);
 
    virtual void FinalizeMaterialResponsePK2 (Parameters& rValues);
 
    virtual void FinalizeMaterialResponseKirchhoff (Parameters& rValues);
 
    virtual void FinalizeMaterialResponseCauchy (Parameters& rValues);
 
 
 
 
    virtual void ResetMaterial(const Properties& rMaterialProperties,
                               const GeometryType& rElementGeometry,
                               const Vector& rShapeFunctionsValues);
 
 
    virtual Vector& TransformStrains (Vector& rStrainVector,
                     const Matrix &rF,
                     StrainMeasure rStrainInitial,
                     StrainMeasure rStrainFinal);
 
    virtual Matrix& TransformStresses (Matrix& rStressMatrix,
                       const Matrix &rF,
                       const double &rdetF,
                       StressMeasure rStressInitial,
                       StressMeasure rStressFinal);
 
 
    virtual Vector& TransformStresses (Vector& rStressVector,
                       const Matrix &rF,
                       const double &rdetF,
                       StressMeasure rStressInitial,
                       StressMeasure rStressFinal);
 
 
 
    Vector& TransformPK1Stresses (Vector& rStressVector,
                  const Matrix &rF,
                  const double &rdetF,
                  StressMeasure rStressFinal);
 
    Vector& TransformPK2Stresses (Vector& rStressVector,
                  const Matrix &rF,
                  const double &rdetF,
                  StressMeasure rStressFinal);
 
    Vector& TransformKirchhoffStresses (Vector& rStressVector,
                    const Matrix &rF,
                    const double &rdetF,
                    StressMeasure rStressFinal);
 
    Vector& TransformCauchyStresses (Vector& rStressVector,
                     const Matrix &rF,
                     const double &rdetF,
                     StressMeasure rStressFinal);
 
 
 
    void PullBackConstitutiveMatrix ( Matrix& rConstitutiveMatrix,
                      const Matrix & rF );
 
 
    void PushForwardConstitutiveMatrix ( Matrix& rConstitutiveMatrix,
                     const Matrix & rF );
 
 
    virtual void GetLawFeatures(Features& rFeatures);
 
 
    virtual int Check(const Properties& rMaterialProperties,
                      const GeometryType& rElementGeometry,
                      const ProcessInfo& rCurrentProcessInfo) const;
 
 
    // VM
 
    virtual void CalculateCauchyStresses(Vector& Cauchy_StressVector,
                                         const Matrix& F,
                                         const Vector& PK2_StressVector,
                                         const Vector& GreenLagrangeStrainVector);
 
 
    inline static bool HasSameType(const ConstitutiveLaw& rLHS, const ConstitutiveLaw& rRHS) {
        return (typeid(rLHS) == typeid(rRHS));
    }
 
    inline static bool HasSameType(const ConstitutiveLaw* rLHS, const ConstitutiveLaw* rRHS) {
        return ConstitutiveLaw::HasSameType(*rLHS, *rRHS);
    }
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "ConstitutiveLaw";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "ConstitutiveLaw";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "ConstitutiveLaw has no data";
    }
 
 
 
protected:
 
    static const unsigned int msIndexVoigt3D6C [6][2];
    static const unsigned int msIndexVoigt2D4C [4][2];
    static const unsigned int msIndexVoigt2D3C [3][2];
 
    void ContraVariantPushForward( Matrix& rMatrix,
                   const Matrix& rF );
 
    void ContraVariantPullBack( Matrix& rMatrix,
                const Matrix& rF );
 
 
    void CoVariantPushForward( Matrix& rMatrix,
                   const Matrix& rF );
 
 
    void CoVariantPullBack( Matrix& rMatrix,
                const Matrix& rF );
 
 
    void ConstitutiveMatrixTransformation ( Matrix& rConstitutiveMatrix,
                        const Matrix& rOriginalConstitutiveMatrix,
                        const Matrix & rF );
 
 
    double& TransformConstitutiveComponent(double & rCabcd,
                       const Matrix & rConstitutiveMatrix,
                       const Matrix & rF,
                       const unsigned int& a, const unsigned int& b,
                       const unsigned int& c, const unsigned int& d);
 
    double& GetConstitutiveComponent(double & rCabcd,
                     const Matrix& rConstitutiveMatrix,
                     const unsigned int& a, const unsigned int& b,
                     const unsigned int& c, const unsigned int& d);
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    InitialState::Pointer mpInitialState = nullptr;
 
 
 
 
 
 
 
    friend class Serializer;
 
 
    void save(Serializer& rSerializer) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, Flags );
        rSerializer.save("InitialState",mpInitialState);
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, Flags );
        rSerializer.load("InitialState",mpInitialState);
    }
 
 
 
 
 
 
}; /* Class ConstitutiveLaw */
 
 
inline std::istream & operator >>(std::istream& rIStream,
                                  ConstitutiveLaw& rThis);
 
 
inline std::ostream & operator <<(std::ostream& rOStream,
                                  const ConstitutiveLaw& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << " : " << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<ConstitutiveLaw >;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents< Variable<ConstitutiveLaw::Pointer> >;
 
void KRATOS_API(KRATOS_CORE) AddKratosComponent(std::string const& Name, ConstitutiveLaw const& ThisComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(std::string const& Name, Variable<ConstitutiveLaw::Pointer> const& ThisComponent);
 
#undef  KRATOS_EXPORT_MACRO
#define KRATOS_EXPORT_MACRO KRATOS_API
 
KRATOS_DEFINE_VARIABLE(ConstitutiveLaw::Pointer, CONSTITUTIVE_LAW)
 
#undef  KRATOS_EXPORT_MACRO
#define KRATOS_EXPORT_MACRO KRATOS_NO_EXPORT
 
 
} /* namespace Kratos.*/
#endif /* KRATOS_CONSTITUTIVE_LAW  defined */