plasticity_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_PLASTICITY_MODEL_H_INCLUDED )
#define  KRATOS_PLASTICITY_MODEL_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_models/constitutive_model.hpp"
#include "custom_models/plasticity_models/yield_surfaces/yield_surface.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
  template<class TElasticityModel, class TYieldSurface>
  class PlasticityModel : public ConstitutiveModel
  {
  public:
 
 
    //elasticity model
    typedef TElasticityModel                                   ElasticityModelType;
 
    //yield surface
    typedef TYieldSurface                                         YieldSurfaceType;
 
    //common types
    typedef ConstitutiveModelData::SizeType                               SizeType;
    typedef ConstitutiveModelData::VoigtIndexType                   VoigtIndexType;
    typedef ConstitutiveModelData::MatrixType                           MatrixType;
    typedef ConstitutiveModelData::VectorType                           VectorType;
    typedef ConstitutiveModelData::ModelData                         ModelDataType;
    typedef typename TYieldSurface::PlasticDataType                PlasticDataType;
    typedef typename TYieldSurface::InternalVariablesType    InternalVariablesType;
 
    KRATOS_CLASS_POINTER_DEFINITION( PlasticityModel );
 
 
    PlasticityModel() : ConstitutiveModel() {}
 
    PlasticityModel(PlasticityModel const& rOther) : ConstitutiveModel(rOther), mElasticityModel(rOther.mElasticityModel), mYieldSurface(rOther.mYieldSurface) {}
 
    PlasticityModel& operator=(PlasticityModel const& rOther)
    {
      ConstitutiveModel::operator=(rOther);
      mElasticityModel = rOther.mElasticityModel;
      mYieldSurface    = rOther.mYieldSurface;
      return *this;
    }
 
    ConstitutiveModel::Pointer Clone() const override
    {
      return Kratos::make_shared<PlasticityModel>(*this);
    }
 
    ~PlasticityModel() override {}
 
 
 
 
 
    void InitializeMaterial(const Properties& rProperties) override
    {
      KRATOS_TRY
 
      mElasticityModel.InitializeMaterial(rProperties);
 
      KRATOS_CATCH(" ")
    }
 
    void InitializeModel(ModelDataType& rValues) override
    {
      KRATOS_TRY
 
      mElasticityModel.InitializeModel(rValues);
 
      KRATOS_CATCH(" ")
    }
 
    void FinalizeModel(ModelDataType& rValues) override
    {
      KRATOS_TRY
 
      mElasticityModel.FinalizeModel(rValues);
 
      KRATOS_CATCH(" ")
    }
 
 
    void CalculateStressTensor(ModelDataType& rValues, MatrixType& rStressMatrix) override
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the PlasticityModel base class ... illegal operation" << std::endl;
 
      KRATOS_CATCH(" ")
    }
 
    void CalculateIsochoricStressTensor(ModelDataType& rValues, MatrixType& rStressMatrix) override
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the PlasticityModel base class ... illegal operation" << std::endl;
 
      KRATOS_CATCH(" ")
    }
 
    void CalculateVolumetricStressTensor(ModelDataType& rValues, MatrixType& rStressMatrix) override
    {
      KRATOS_TRY
 
      mElasticityModel.CalculateVolumetricStressTensor(rValues,rStressMatrix);
 
      KRATOS_CATCH(" ")
    }
 
 
    void CalculateConstitutiveTensor(ModelDataType& rValues, Matrix& rConstitutiveMatrix) override
    {
      KRATOS_ERROR << "calling PlasticityModel base class " << std::endl;
    }
 
    void CalculateIsochoricConstitutiveTensor(ModelDataType& rValues, Matrix& rConstitutiveMatrix) override
    {
      KRATOS_ERROR << "calling PlasticityModel base class " << std::endl;
    }
 
    void CalculateVolumetricConstitutiveTensor(ModelDataType& rValues, Matrix& rConstitutiveMatrix) override
    {
      KRATOS_TRY
 
      mElasticityModel.CalculateVolumetricConstitutiveTensor(rValues,rConstitutiveMatrix);
 
      KRATOS_CATCH(" ")
    }
 
 
    void CalculateStressAndConstitutiveTensors(ModelDataType& rValues, MatrixType& rStressMatrix, Matrix& rConstitutiveMatrix) override
    {
      KRATOS_ERROR << "calling PlasticityModel base class " << std::endl;
    }
 
    void CalculateIsochoricStressAndConstitutiveTensors(ModelDataType& rValues, MatrixType& rStressMatrix, Matrix& rConstitutiveMatrix) override
    {
      KRATOS_ERROR << "calling PlasticityModel base class " << std::endl;
    }
 
    void CalculateVolumetricStressAndConstitutiveTensors(ModelDataType& rValues, MatrixType& rStressMatrix, Matrix& rConstitutiveMatrix) override
    {
      KRATOS_ERROR << "calling PlasticityModel base class " << std::endl;
    }
 
 
    int Check(const Properties& rProperties, const ProcessInfo& rCurrentProcessInfo) override
    {
      KRATOS_TRY
 
      // if(YOUNG_MODULUS.Key() == 0 || rProperties[YOUNG_MODULUS]<= 0.00)
      //    KRATOS_ERROR << "YOUNG_MODULUS has Key zero or invalid value" << std::endl;
 
      // const double& nu = rProperties[POISSON_RATIO];
      // const bool check = bool( (nu >0.499 && nu<0.501 ) || (nu < -0.999 && nu > -1.01 ) );
 
      // if(POISSON_RATIO.Key() == 0 || check==true)
      //    KRATOS_ERROR << "POISSON_RATIO has Key zero invalid value" << std::endl;
 
 
      if(DENSITY.Key() == 0 || rProperties[DENSITY]<0.00)
         KRATOS_ERROR << "DENSITY has Key zero or invalid value" << std::endl;
 
      mElasticityModel.Check(rProperties, rCurrentProcessInfo);
 
      return 0;
 
      KRATOS_CATCH(" ")
    }
 
 
    void GetDomainVariablesList(std::vector<Variable<double> >& rScalarVariables,
                    std::vector<Variable<array_1d<double,3> > >& rComponentVariables) override
    {
      KRATOS_TRY
 
      mElasticityModel.GetDomainVariablesList(rScalarVariables, rComponentVariables);
 
      KRATOS_CATCH(" ")
    }
 
 
    bool Has(const Variable<double>& rThisVariable) override {return false;}
 
    void SetValue(const Variable<double>& rVariable,
              const double& rValue,
              const ProcessInfo& rCurrentProcessInfo) override {}
    double& GetValue(const Variable<double>& rThisVariable, double& rValue) override { rValue=0; return rValue;}
 
 
 
    ElasticityModelType& GetElasticityModel() {return mElasticityModel;};
 
 
 
 
    std::string Info() const override
    {
      std::stringstream buffer;
      buffer << "PlasticityModel" ;
      return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
      rOStream << "PlasticityModel";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "PlasticityModel Data";
    }
 
 
 
 
  protected:
 
 
 
    ElasticityModelType   mElasticityModel;
    YieldSurfaceType         mYieldSurface;
 
 
 
 
    //set internal variables for output print
 
    virtual void SetInternalVariables(ModelDataType& rValues, PlasticDataType& rVariables)
    {
      KRATOS_TRY
 
      KRATOS_CATCH(" ")
    }
 
 
 
 
 
 
 
 
  private:
 
 
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
      KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, ConstitutiveModel )
 
      rSerializer.save("mElasticityModel",mElasticityModel);
      rSerializer.save("mYieldSurface",mYieldSurface);
    }
 
    void load(Serializer& rSerializer) override
    {
      KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, ConstitutiveModel )
 
      rSerializer.load("mElasticityModel",mElasticityModel);
      rSerializer.load("mYieldSurface",mYieldSurface);
    }
 
 
 
 
  }; // Class PlasticityModel
 
 
 
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_PLASTICITY_MODEL_H_INCLUDED  defined