hypo_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 2018 $
//   Revision:            $Revision:                      0.0 $
//
//
 
#if !defined(KRATOS_HYPO_ELASTIC_MODEL_H_INCLUDED )
#define  KRATOS_HYPO_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) HypoElasticModel : public ConstitutiveModel
  {
  protected:
 
    struct ElasticModelData
    {
    private:
 
      Flags*               mpState;
      const ModelDataType* mpModelData;
 
    public:
 
      BoundedMatrix<double,6,6> ConstitutiveTensor;
      MatrixType                StrainMatrix;
 
      //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 ElasticModelData              ElasticDataType;
 
 
    KRATOS_CLASS_POINTER_DEFINITION( HypoElasticModel );
 
 
    HypoElasticModel();
 
    HypoElasticModel(HypoElasticModel const& rOther);
 
    ConstitutiveModel::Pointer Clone() const override;
 
    HypoElasticModel& operator=(HypoElasticModel const& rOther);
 
    ~HypoElasticModel() 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(VELOCITY);
 
      KRATOS_CATCH(" ")
    }
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "HypoElasticModel";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "HypoElasticModel";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "HypoElasticModel Data";
    }
 
 
 
 
 
  protected:
 
 
 
 
 
 
 
    void AddHistoricalStress(ModelDataType& rValues, MatrixType& rStressMatrix);
 
    virtual void CalculateAndAddStressTensor(ElasticDataType& rVariables, VectorType& rStrainVector, VectorType& rStressVector);
 
    virtual void CalculateAndAddIsochoricStressTensor(ElasticDataType& rVariables, VectorType& rStrainVector, VectorType& rStressVector);
 
    virtual void CalculateAndAddVolumetricStressTensor(ElasticDataType& rVariables, VectorType& rStrainVector, VectorType& rStressVector);
 
    virtual void CalculateAndAddConstitutiveTensor(ElasticDataType& rVariables, Matrix& rConstitutiveMatrix);
 
    virtual void CalculateAndAddConstitutiveTensor(ElasticDataType& rVariables);
 
    virtual void CalculateAndAddIsochoricConstitutiveTensor(ElasticDataType& rVariables, Matrix& rConstitutiveMatrix);
 
    virtual void CalculateAndAddIsochoricConstitutiveTensor(ElasticDataType& rVariables);
 
 
    virtual void CalculateAndAddVolumetricConstitutiveTensor(ElasticDataType& rVariables, Matrix& rConstitutiveMatrix);
 
    virtual void CalculateAndAddVolumetricConstitutiveTensor(ElasticDataType& rVariables);
 
    //************//
 
    void InitializeElasticData(ModelDataType& rValues, ElasticDataType& rVariables);
 
    virtual void CalculateAndAddIsochoricStrainEnergy(ElasticDataType& rVariables, double& rIsochoricDensityFunction);
 
    virtual void CalculateAndAddVolumetricStrainEnergy(ElasticDataType& rVariables, double& rIsochoricDensityFunction);
 
 
 
 
 
 
 
 
 
  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 HypoElasticModel
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_HYPO_ELASTIC_MODEL_H_INCLUDED  defined