hyper_elastic_model.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosConstitutiveModelsApplication $
//   Created by:          $Author:                JMCarbonell $
//   Last modified by:    $Co-Author:                         $
//   Date:                $Date:                   April 2017 $
//   Revision:            $Revision:                      0.0 $
//
//
 
#if !defined(KRATOS_HYPER_ELASTIC_MODEL_H_INCLUDED )
#define  KRATOS_HYPER_ELASTIC_MODEL_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "custom_models/constitutive_model.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
  class KRATOS_API(CONSTITUTIVE_MODELS_APPLICATION) HyperElasticModel : public ConstitutiveModel
  {
  protected:
 
 
    struct StrainInvariants
    {
      double I1;
      double I2;
      double I3;
 
      double J;
      double J_13;
 
    };
 
 
    struct HyperElasticFactors
    {
      double Alpha1;  //1st derivative I1
      double Alpha2;  //1st derivative I2
      double Alpha3;  //1st derivative I3
      double Alpha4;  //1st derivative J
 
      double Beta1;   //2nd derivative I1
      double Beta2;   //2nd derivative I2
      double Beta3;   //2nd derivative I3
      double Beta4;   //2nd derivative J
 
      // the implementation of the crossed derivatives have to be added for a more general form (usually they are zero)
      // double Gamma21;  //2nd derivative ddW/dI2dI1
      // double Gamma31;  //2nd derivative ddW/dI3dI1
      // double Gamma12;  //2nd derivative ddW/dI1dI2
      // double Gamma32;  //2nd derivative ddW/dI3dI2
      // double Gamma13;  //2nd derivative ddW/dI1dI3
      // double Gamma23;  //2nd derivative ddW/dI2dI3
 
    };
 
    struct StrainEigenData
    {
       array_1d<double,3> Values;
       MatrixType        Vectors;
    };
 
 
    struct StrainData
    {
 
      StrainInvariants Invariants;
      StrainEigenData  Eigen;
 
      MatrixType       Matrix; //left(b) or right(C) cauchy green
      MatrixType       InverseMatrix; //insverse right(C) cauchy green
 
    };
 
 
    struct HyperElasticModelData
    {
    private:
 
      Flags*               mpState;
      const ModelDataType* mpModelData;
 
    public:
 
      HyperElasticFactors    Factors;
      StrainData              Strain;
 
      //Set Data Pointers
      void SetState           (Flags& rState)                    {mpState = &rState;};
      void SetModelData       (const ModelDataType&  rModelData) {mpModelData = &rModelData;};
 
      //Get Data Pointers
      const ModelDataType&    GetModelData                () const {return *mpModelData;};
      const MaterialDataType& GetMaterialParameters       () const {return mpModelData->GetMaterialParameters();};
 
      //Get non const Data
      Flags& State                                        () {return *mpState;};
 
      //Get const Data
      const Flags&  GetState                              () const {return *mpState;};
 
 
    };
 
 
  public:
 
    typedef HyperElasticModelData        HyperElasticDataType;
 
    KRATOS_CLASS_POINTER_DEFINITION( HyperElasticModel );
 
 
    HyperElasticModel();
 
    HyperElasticModel(HyperElasticModel const& rOther);
 
    HyperElasticModel& operator=(HyperElasticModel const& rOther);
 
    ConstitutiveModel::Pointer Clone() const override;
 
 
    ~HyperElasticModel() override;
 
 
 
 
 
    void InitializeModel(ModelDataType& rValues) override;
 
    void FinalizeModel(ModelDataType& rValues) override;
 
 
    void CalculateStrainEnergy(ModelDataType& rValues, double& rDensityFunction) override;
 
 
    void CalculateStressTensor(ModelDataType& rValues, MatrixType& rStressMatrix) override;
 
    void CalculateIsochoricStressTensor(ModelDataType& rValues, MatrixType& rStressMatrix) override;
 
    void CalculateVolumetricStressTensor(ModelDataType& rValues, MatrixType& rStressMatrix) override;
 
 
    void CalculateConstitutiveTensor(ModelDataType& rValues, Matrix& rConstitutiveMatrix) override;
 
    void CalculateIsochoricConstitutiveTensor(ModelDataType& rValues, Matrix& rConstitutiveMatrix) override;
 
    void CalculateVolumetricConstitutiveTensor(ModelDataType& rValues, Matrix& rConstitutiveMatrix) override;
 
 
    void CalculateStressAndConstitutiveTensors(ModelDataType& rValues, MatrixType& rStressMatrix, Matrix& rConstitutiveMatrix) override;
 
    void CalculateIsochoricStressAndConstitutiveTensors(ModelDataType& rValues, MatrixType& rStressMatrix, Matrix& rConstitutiveMatrix) override;
 
    void CalculateVolumetricStressAndConstitutiveTensors(ModelDataType& rValues, MatrixType& rStressMatrix, Matrix& rConstitutiveMatrix) override;
 
 
    int Check(const Properties& rProperties, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void SetValue(const Variable<Vector>& rThisVariable, const Vector& rValue,
              const ProcessInfo& rCurrentProcessInfo ) override
    {
      KRATOS_TRY
 
      // A method to compute the initial linear strain from the stress is needed
      //if(rThisVariable == INITIAL_STRESS_VECTOR)
 
      // A method to compute the initial linear strain from the stress is needed
      // if(rThisVariable == INITIAL_STRAIN_VECTOR){
      //   this->mHistoryVector = rValue;
      // }
 
      KRATOS_CATCH(" ")
    }
 
 
    void SetValue(const Variable<Matrix>& rThisVariable, const Matrix& rValue,
              const ProcessInfo& rCurrentProcessInfo ) override
    {
      KRATOS_TRY
 
      // A method to compute the initial linear strain from the stress is needed
      //if(rThisVariable == INITIAL_STRESS_VECTOR)
 
      // A method to compute the initial linear strain from the stress is needed
      // if(rThisVariable == INITIAL_STRAIN_VECTOR){
      //   this->mHistoryVector = rValue;
      // }
 
      KRATOS_CATCH(" ")
    }
 
    void GetDomainVariablesList(std::vector<Variable<double> >& rScalarVariables,
                    std::vector<Variable<array_1d<double,3> > >& rComponentVariables) override
    {
      KRATOS_TRY
 
      rComponentVariables.push_back(DISPLACEMENT);
 
      KRATOS_CATCH(" ")
    }
 
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "HyperElasticModel";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "HyperElasticModel";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "HyperElasticModel Data";
    }
 
 
 
 
 
  protected:
 
    static const MatrixType msIdentityMatrix;
 
 
 
 
 
 
 
    virtual void CalculateAndAddStressTensor(HyperElasticDataType& rVariables, MatrixType& rStressMatrix);
 
    virtual void CalculateAndAddIsochoricStressTensor(HyperElasticDataType& rVariables, MatrixType& rStressMatrix);
 
    virtual void CalculateAndAddVolumetricStressTensor(HyperElasticDataType& rVariables, MatrixType& rStressMatrix);
 
    virtual void CalculateAndAddConstitutiveTensor(HyperElasticDataType& rVariables, Matrix& rConstitutiveMatrix);
 
    virtual void CalculateAndAddIsochoricConstitutiveTensor(HyperElasticDataType& rVariables, Matrix& rConstitutiveMatrix);
 
    virtual void CalculateAndAddVolumetricConstitutiveTensor(HyperElasticDataType& rVariables, Matrix& rConstitutiveMatrix);
 
    virtual double& AddConstitutiveComponent(HyperElasticDataType& rVariables, double &rCabcd,
                         const unsigned int& a, const unsigned int& b,
                         const unsigned int& c, const unsigned int& d);
 
 
    virtual double& AddIsochoricConstitutiveComponent(HyperElasticDataType& rVariables, double &rCabcd,
                              const unsigned int& a, const unsigned int& b,
                              const unsigned int& c, const unsigned int& d);
 
 
    virtual double& AddVolumetricConstitutiveComponent(HyperElasticDataType& rVariables, double &rCabcd,
                               const unsigned int& a, const unsigned int& b,
                               const unsigned int& c, const unsigned int& d);
 
 
    //************// Strain Data
 
 
    virtual void CalculateStrainData(ModelDataType& rValues, HyperElasticDataType& rVariables);
 
    virtual void CalculateInvariants(HyperElasticDataType& rVariables);
 
    virtual void CalculateScalingFactors(HyperElasticDataType& rVariables);
 
    void CalculateStrainInvariants(const MatrixType& rStrainMatrix, double& rI1, double& rI2, double& rI3);
 
 
    //************//W
 
    virtual void CalculateAndAddIsochoricStrainEnergy(HyperElasticDataType& rVariables, double& rIsochoricDensityFunction);
 
    virtual void CalculateAndAddVolumetricStrainEnergy(HyperElasticDataType& rVariables, double& rVolumetricDensityFunction);
 
 
    //************// dW
 
    virtual double& GetVolumetricFunction1stJDerivative(HyperElasticDataType& rVariables, double& rDerivative); //dU/dJ
 
    virtual double& GetVolumetricFunction2ndJDerivative(HyperElasticDataType& rVariables, double& rDerivative); //ddU/dJdJ
 
 
    //************// right cauchy green: C
    MatrixType& GetJRightCauchyGreenDerivative(const StrainData& rStrain, MatrixType& rDerivative); //dJ/dC
 
    double& GetJRightCauchyGreen1stDerivative(const StrainData& rStrain,
                          double& rDerivative,
                          const double& a,
                          const double& b); 
 
    double& GetJRightCauchyGreenSquare1stDerivative(const StrainData& rStrain,
                            double& rDerivative,
                            const double& a,
                            const double& b,
                            const double& c,
                            const double& d); //dJ/dC * dJ/dC
 
    double& GetJRightCauchyGreen2ndDerivative(const StrainData& rStrain,
                          double& rDerivative,
                          const double& a,
                          const double& b,
                          const double& c,
                          const double& d); //ddJ/dCdC
 
    //************// left cauchy green : b
 
    MatrixType& GetJLeftCauchyGreenDerivative(const StrainData& rStrain, MatrixType& rDerivative); //dJ/db
 
    double& GetJLeftCauchyGreen1stDerivative(const StrainData& rStrain,
                         double& rDerivative,
                         const double& a,
                         const double& b); //dJ/db
 
    double& GetJLeftCauchyGreenSquare1stDerivative(const StrainData& rStrain,
                           double& rDerivative,
                           const double& a,
                           const double& b,
                           const double& c,
                           const double& d); //dJ/db * dJ/db
 
    double& GetJLeftCauchyGreen2ndDerivative(const StrainData& rStrain,
                         double& rDerivative,
                         const double& a,
                         const double& b,
                         const double& c,
                         const double& d); //ddJ/dbdb
 
 
 
 
 
 
 
 
 
  private:
 
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
 
    void save(Serializer& rSerializer) const override
    {
      KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, ConstitutiveModel )
    }
 
    void load(Serializer& rSerializer) override
    {
      KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, ConstitutiveModel )
    }
 
 
 
 
 
  }; // Class HyperElasticModel
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_HYPER_ELASTIC_MODEL_H_INCLUDED  defined