hencky_hyper_elastic_model.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosConstitutiveModelsApplication $
//   Created by:          $Author:                  LMonforte $
//   Last modified by:    $Co-Author:                         $
//   Date:                $Date:                   April 2017 $
//   Revision:            $Revision:                      0.0 $
//
//
 
#if !defined(KRATOS_HENCKY_HYPER_ELASTIC_MODEL_H_INCLUDED )
#define  KRATOS_HENCKY_HYPER_ELASTIC_MODEL_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_models/elasticity_models/hyper_elastic_model.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
   class KRATOS_API(CONSTITUTIVE_MODELS_APPLICATION) HenckyHyperElasticModel : public HyperElasticModel
   {
      public:
 
 
         KRATOS_CLASS_POINTER_DEFINITION( HenckyHyperElasticModel );
 
 
         HenckyHyperElasticModel(): HyperElasticModel() {};
 
         HenckyHyperElasticModel(HenckyHyperElasticModel const& rOther) : HyperElasticModel( rOther) {};
 
         HenckyHyperElasticModel& operator=(HenckyHyperElasticModel const& rOther)
         {
            HyperElasticModel::operator=(rOther);
            return *this;
         };
 
         ConstitutiveModel::Pointer Clone() const override
         {
            return ( HenckyHyperElasticModel::Pointer( new HenckyHyperElasticModel(*this)) );
         };
 
 
         ~HenckyHyperElasticModel() override {};
 
 
 
 
 
         void InitializeModel(ModelDataType& rValues) override
         {
            KRATOS_TRY
 
            HyperElasticModel::InitializeModel(rValues);
 
            // Compute trial strain
            //deformation gradient
            const MatrixType& rDeltaDeformationMatrix  = rValues.GetDeltaDeformationMatrix();
 
            //historical strain matrix
            rValues.StrainMatrix = ConstitutiveModelUtilities::VectorToSymmetricTensor(this->mHistoryVector,rValues.StrainMatrix);
            rValues.StrainMatrix = prod( rDeltaDeformationMatrix, rValues.StrainMatrix);
            rValues.StrainMatrix = prod( rValues.StrainMatrix, trans(rDeltaDeformationMatrix));
 
            KRATOS_CATCH("")
 
         };
 
 
 
 
 
 
         std::string Info() const override
         {
            std::stringstream buffer;
            buffer << "HenckyHyperElasticModel";
            return buffer.str();
         }
 
         void PrintInfo(std::ostream& rOStream) const override
         {
            rOStream << "HenckyHyperElasticModel";
         }
 
         void PrintData(std::ostream& rOStream) const override
         {
            rOStream << "HenckyHyperElasticModel Data";
         }
 
 
 
 
 
      protected:
 
 
 
 
 
 
 
         void CalculateStrainData(ModelDataType& rValues, HyperElasticDataType& rVariables) override
         {
            KRATOS_TRY
 
            rVariables.SetModelData(rValues);
            rVariables.SetState(rValues.State);
 
            const StressMeasureType& rStressMeasure  = rValues.GetStressMeasure();
 
            if( rStressMeasure == ConstitutiveModelData::StressMeasureType::StressMeasure_PK2 ){ //mStrainMatrix = RightCauchyGreen (C=FT*F)  C^-1=(FT*F)^-1=F^-1*FT^-1
 
               KRATOS_ERROR << "calling HenckyHyperelastic based method with PK2 stress. not implemented" << std::endl;
 
            }
            else if( rStressMeasure == ConstitutiveModelData::StressMeasureType::StressMeasure_Kirchhoff ){ //mStrainMatrix = LeftCauchyGreen (b=F*FT)
 
               //set working strain measure
               rValues.SetStrainMeasure(ConstitutiveModelData::StrainMeasureType::CauchyGreen_Left);
 
               MatrixType EigenVectors;
               MatrixType EigenValues;
               EigenVectors.clear();
               EigenValues.clear();
 
         MathUtils<double>::GaussSeidelEigenSystem<MatrixType, MatrixType>(rValues.StrainMatrix, EigenVectors, EigenValues);
 
               rVariables.Strain.Matrix.clear();
               for (unsigned int i = 0; i < 3; i++)
                  rVariables.Strain.Matrix(i,i) =  std::log(EigenValues(i,i)) / 2.0;
 
         rVariables.Strain.Matrix = prod(rVariables.Strain.Matrix, trans(EigenVectors));
         rVariables.Strain.Matrix = prod(EigenVectors, rVariables.Strain.Matrix);
 
               rValues.State.Set(ConstitutiveModelData::STRAIN_COMPUTED);
 
            }
            else{
               KRATOS_ERROR << "calling initialize HyperElasticModel .. StressMeasure required is inconsistent"  << std::endl;
            }
 
 
            KRATOS_CATCH("")
         };
 
 
 
 
 
 
 
 
      private:
 
 
 
 
 
 
 
 
 
 
 
         friend class Serializer;
 
 
         void save(Serializer& rSerializer) const override
         {
            KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, HyperElasticModel )
         }
 
         void load(Serializer& rSerializer) override
         {
            KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, HyperElasticModel )
         }
 
 
 
 
 
   }; // Class BorjaModel
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_HENCKY_HYPER_ELASTIC_MODEL_H_INCLUDED  defined