small_strain_umat_3D_law.hpp

Go to the documentation of this file.

// KRATOS___
//     //   ) )
//    //         ___      ___
//   //  ____  //___) ) //   ) )
//  //    / / //       //   / /
// ((____/ / ((____   ((___/ /  MECHANICS
//
//  License:         geo_mechanics_application/license.txt
//
//  Main authors:    Vahid Galavi
//
 
#pragma once
 
// System includes
#include <string>
#include <iostream>
#include "includes/define.h"
 
// Project includes
#include "includes/serializer.h"
#include "includes/constitutive_law.h"
 
// Application includes
#include "geo_mechanics_application_variables.h"
 
namespace Kratos
{
/*
   - structure of UMATs:
   - Function to get stress, stiffness matrix
     void umat(double* STRESS,  double* STATEV,  double** DDSDDE,  double* SSE,     double* SPD,     double* SCD,
               double* RPL,     double* DDSDDT,  double* DRPLDE,   double* DRPLDT,  double* STRAN,   double* DSTRAN,
               double* TIME,    double* DTIME,   double* TEMP,     double* DTEMP,   double* PREDEF,  double* DPRED,
               char* MATERL,    int* NDI,        int* NSHR,        int* NTENS,      int* NSTATV,     double* PROPS,
               int* NPROPS,     double* COORDS,  double** DROT,    double* PNEWDT,  double* CELENT,  double** DFGRD0,
               double** DFGRD1, int* NOEL,       int* NPT,         double* KSLAY,   double* KSPT,    int* KSTEP,
               int* KINC);
 
*/
 
typedef void(*pF_UMATMod) (double* STRESS, double* STATEV, double** DDSDDE, double* SSE, double* SPD, double* SCD,
                          double* rpl, double* ddsddt, double* drplde, double* drpldt, double* stran, double* dstran,
                          double* time, double* dtime, double* temp, double* dtemp, double* predef, double* dpred,
                          char* materl, int* ndi, int* nshr, int* ntens, int* nstatv, const double* props, int* nprops,
                          double* coords, double** drot, double* pnewdt, double* celent, double** dfgrd0,
                          double** dfgrd1, int* noel, int* npt, double* kslay, double* kspt, int* kstep,
                          int* kinc);
 
 
 
 
 
 
 
 
 
   class KRATOS_API(GEO_MECHANICS_APPLICATION) SmallStrainUMAT3DLaw: public ConstitutiveLaw
   {
   public:
      // The process info type definition
      using ProcessInfoType = ProcessInfo;
 
      // The base class ConstitutiveLaw type definition
      using BaseType = ConstitutiveLaw;
 
      using SizeType = std::size_t;
 
      static constexpr SizeType Dimension = N_DIM_3D;
 
      static constexpr SizeType VoigtSize = VOIGT_SIZE_3D;
 
      KRATOS_CLASS_POINTER_DEFINITION( SmallStrainUMAT3DLaw );
 
 
      //@name Life Cycle
 
      SmallStrainUMAT3DLaw() = default;
      ~SmallStrainUMAT3DLaw() override = default;
      SmallStrainUMAT3DLaw(const SmallStrainUMAT3DLaw& rOther);
      SmallStrainUMAT3DLaw& operator=(const SmallStrainUMAT3DLaw& rOther);
      SmallStrainUMAT3DLaw(SmallStrainUMAT3DLaw&&) = delete;
      SmallStrainUMAT3DLaw& operator=(SmallStrainUMAT3DLaw&&) = delete;
 
      ConstitutiveLaw::Pointer Clone() const override;
 
      void GetLawFeatures(Features& rFeatures) override;
 
      SizeType WorkingSpaceDimension() override
      {
         return Dimension;
      }
 
      SizeType GetStrainSize() const override
      {
         return VoigtSize;
      }
 
      StrainMeasure GetStrainMeasure() override
      {
         return StrainMeasure_Infinitesimal;
      }
 
      StressMeasure GetStressMeasure() override
      {
         return StressMeasure_Cauchy;
      }
 
      void CalculateMaterialResponsePK1(ConstitutiveLaw::Parameters & rValues) override;
 
      void CalculateMaterialResponsePK2(ConstitutiveLaw::Parameters & rValues) override;
 
      void CalculateMaterialResponseKirchhoff(ConstitutiveLaw::Parameters & rValues) override;
 
      void CalculateMaterialResponseCauchy(ConstitutiveLaw::Parameters & rValues) override;
 
      void FinalizeMaterialResponseCauchy   (ConstitutiveLaw::Parameters & rValues) override;
      void FinalizeMaterialResponsePK1      (ConstitutiveLaw::Parameters & rValues) override;
      void FinalizeMaterialResponsePK2      (ConstitutiveLaw::Parameters & rValues) override;
      void FinalizeMaterialResponseKirchhoff(ConstitutiveLaw::Parameters & rValues) override;
 
      double& CalculateValue(ConstitutiveLaw::Parameters& rParameterValues,
                             const Variable<double>&      rThisVariable,
                             double&                      rValue) override;
 
      Vector& CalculateValue(ConstitutiveLaw::Parameters& rParameterValues,
                             const Variable<Vector>&      rThisVariable,
                             Vector&                      rValue) override;
 
      Matrix& CalculateValue(ConstitutiveLaw::Parameters& rParameterValues,
                             const Variable<Matrix>&      rThisVariable,
                             Matrix&                      rValue) override;
 
      using ConstitutiveLaw::CalculateValue;
 
 
      // @brief This function provides the place to perform checks on the completeness of the input.
      // @details It is designed to be called only once (or anyway, not often) typically at the beginning
      //          of the calculations, so to verify that nothing is missing from the input or that
      //          no common error is found.
      int Check(const Properties& rMaterialProperties,
                const GeometryType& rElementGeometry,
                const ProcessInfo& rCurrentProcessInfo) const override;
 
      void InitializeMaterial(const Properties& rMaterialProperties,
                              const GeometryType& rElementGeometry,
                              const Vector& rShapeFunctionsValues) override;
 
 
      void InitializeMaterialResponseCauchy   (ConstitutiveLaw::Parameters& rValues) override;
      void InitializeMaterialResponsePK1      (ConstitutiveLaw::Parameters& rValues) override;
      void InitializeMaterialResponsePK2      (ConstitutiveLaw::Parameters& rValues) override;
      void InitializeMaterialResponseKirchhoff(ConstitutiveLaw::Parameters& rValues) override;
 
      virtual void CalculateCauchyGreenStrain(ConstitutiveLaw::Parameters& rValues, Vector& rStrainVector);
 
     void ResetMaterial(const Properties& rMaterialProperties,
                        const GeometryType& rElementGeometry,
                        const Vector& rShapeFunctionsValues) override;
 
    using ConstitutiveLaw::GetValue;
    double& GetValue( const Variable<double> &rThisVariable, double &rValue ) override;
    int& GetValue( const Variable<int> &rThisVariable, int &rValue ) override;
    Vector& GetValue( const Variable<Vector> &rThisVariable, Vector &rValue ) override;
 
    using ConstitutiveLaw::SetValue;
    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;
 
 
 
      std::string Info() const override
      {
         return "SmallStrainUMAT3DLaw";
      }
 
      void PrintInfo(std::ostream& rOStream) const override
      {
         rOStream << Info();
      }
 
      void PrintData(std::ostream& rOStream) const override
      {
         rOStream << "SmallStrainUMAT3DLaw Data";
      }
 
 
 
   protected:
      array_1d<double, VOIGT_SIZE_3D> mStressVector;
      array_1d<double, VOIGT_SIZE_3D> mStressVectorFinalized;
 
      array_1d<double, VOIGT_SIZE_3D> mDeltaStrainVector;
      array_1d<double, VOIGT_SIZE_3D> mStrainVectorFinalized;
 
      double mMatrixD[VOIGT_SIZE_3D][VOIGT_SIZE_3D];
 
 
 
 
      virtual void UpdateInternalDeltaStrainVector(ConstitutiveLaw::Parameters &rValues);
      virtual void UpdateInternalStrainVectorFinalized(ConstitutiveLaw::Parameters &rValues);
      virtual void SetExternalStressVector(Vector& rStressVector);
      virtual void SetInternalStressVector(const Vector& rStressVector);
      virtual void SetInternalStrainVector(const Vector& rStrainVector);
      virtual void CopyConstitutiveMatrix(ConstitutiveLaw::Parameters &rValues, Matrix& rConstitutiveMatrix);
 
 
      void CalculateConstitutiveMatrix(ConstitutiveLaw::Parameters &rValues, Matrix& rConstitutiveMatrix);
      void CalculateStress(ConstitutiveLaw::Parameters &rValues, Vector& rStressVector);
 
      int GetStateVariableIndex(const Variable<double>& rThisVariable);
 
 
 
 
 
 
   private:
 
 
      pF_UMATMod          pUserMod;
 
      bool mIsModelInitialized = false;
      bool mIsUMATLoaded = false;
 
      std::vector<int> mProjectDirectory;
 
      Vector mStateVariables;
      Vector mStateVariablesFinalized;
 
 
 
 
 
 
 
      // to load UMAT and functions
      bool loadUMAT(const Properties& rMaterialProperties);
      bool loadUMATWindows(const Properties& rMaterialProperties);
      bool loadUMATLinux(const Properties& rMaterialProperties);
 
      // Set number of MaterialParameters
      void CallUMAT( ConstitutiveLaw::Parameters &rValues);
 
      // Set state variables to the initial values
      void ResetStateVariables(const Properties& rMaterialProperties);
 
 
      friend class Serializer;
 
      void save(Serializer& rSerializer) const override
      {
         KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, ConstitutiveLaw)
         rSerializer.save("InitializedModel",           mIsModelInitialized);
         rSerializer.save("StressVectorFinalized",      mStressVectorFinalized);
         rSerializer.save("StrainVectorFinalized",      mStrainVectorFinalized);
         rSerializer.save("StateVariablesFinalized",    mStateVariablesFinalized);
      }
 
      void load(Serializer& rSerializer) override
      {
         KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, ConstitutiveLaw)
         rSerializer.load("InitializedModel",           mIsModelInitialized);
         rSerializer.load("StressVectorFinalized",      mStressVectorFinalized);
         rSerializer.load("StrainVectorFinalized",      mStrainVectorFinalized);
         rSerializer.load("StateVariablesFinalized",    mStateVariablesFinalized);
      }
 
 
 
 
 
   }; // Class SmallStrainUMAT3DLaw
 
 
 
 
 
 
 
}