simo_J2_thermo_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_SIMO_J2_THERMO_PLASTICITY_MODEL_H_INCLUDED )
#define  KRATOS_SIMO_J2_THERMO_PLASTICITY_MODEL_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_models/plasticity_models/non_linear_associative_plasticity_model.hpp"
#include "custom_models/plasticity_models/yield_surfaces/mises_huber_thermal_yield_surface.hpp"
#include "custom_models/plasticity_models/hardening_rules/simo_exponential_thermal_hardening_rule.hpp"
#include "custom_models/elasticity_models/incompressible_neo_hookean_model.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
  class KRATOS_API(CONSTITUTIVE_MODELS_APPLICATION) SimoJ2ThermoPlasticityModel : public NonLinearAssociativePlasticityModel<IncompressibleNeoHookeanModel, MisesHuberThermalYieldSurface<SimoExponentialThermalHardeningRule> >
  {
  public:
 
 
    //elasticity model
    typedef IncompressibleNeoHookeanModel                   ElasticityModelType;
    typedef ElasticityModelType::Pointer                 ElasticityModelPointer;
 
    //yield surface
    typedef SimoExponentialThermalHardeningRule               HardeningRuleType;
    typedef MisesHuberThermalYieldSurface<HardeningRuleType>   YieldSurfaceType;
    typedef YieldSurfaceType::Pointer                       YieldSurfacePointer;
 
    //base type
    typedef NonLinearAssociativePlasticityModel<ElasticityModelType,YieldSurfaceType>  BaseType;
 
    //common types
    typedef BaseType::Pointer                         BaseTypePointer;
    typedef BaseType::SizeType                               SizeType;
    typedef BaseType::VoigtIndexType                   VoigtIndexType;
    typedef BaseType::MatrixType                           MatrixType;
    typedef BaseType::ModelDataType                     ModelDataType;
    typedef BaseType::MaterialDataType               MaterialDataType;
    typedef BaseType::PlasticDataType                 PlasticDataType;
    typedef BaseType::InternalVariablesType     InternalVariablesType;
 
 
    KRATOS_CLASS_POINTER_DEFINITION( SimoJ2ThermoPlasticityModel );
 
 
    SimoJ2ThermoPlasticityModel() : BaseType() {}
 
    SimoJ2ThermoPlasticityModel(SimoJ2ThermoPlasticityModel const& rOther) : BaseType(rOther) {}
 
    SimoJ2ThermoPlasticityModel& operator=(SimoJ2ThermoPlasticityModel const& rOther)
    {
      BaseType::operator=(rOther);
      return *this;
    }
 
    ConstitutiveModel::Pointer Clone() const override
    {
      return Kratos::make_shared<SimoJ2ThermoPlasticityModel>(*this);
    }
 
    ~SimoJ2ThermoPlasticityModel() override {}
 
 
 
 
 
 
 
    void GetDomainVariablesList(std::vector<Variable<double> >& rScalarVariables,
                    std::vector<Variable<array_1d<double,3> > >& rComponentVariables) override
    {
      KRATOS_TRY
 
      PlasticityModel::GetDomainVariablesList(rScalarVariables, rComponentVariables);
 
      rScalarVariables.push_back(TEMPERATURE);
 
      KRATOS_CATCH(" ")
    }
 
    bool Has(const Variable<double>& rThisVariable) override
    {
      if(rThisVariable == PLASTIC_STRAIN || rThisVariable == DELTA_PLASTIC_STRAIN )
    return true;
 
      if(rThisVariable == PLASTIC_DISSIPATION || rThisVariable == DELTA_PLASTIC_DISSIPATION )
    return true;
 
      return false;
    }
 
 
    double& GetValue(const Variable<double>& rThisVariable, double& rValue) override
    {
 
      rValue=0;
 
      if (rThisVariable==PLASTIC_STRAIN)
    {
      rValue = this->mInternal.Variables[0];
    }
 
 
      if (rThisVariable==DELTA_PLASTIC_STRAIN)
    {
      rValue = this->mInternal.Variables[0]-mPreviousInternal.Variables[0];
    }
 
      if (rThisVariable==PLASTIC_DISSIPATION)
    {
      rValue = this->mThermalVariables.PlasticDissipation;
    }
 
 
      if (rThisVariable==DELTA_PLASTIC_DISSIPATION)
    {
      rValue = this->mThermalVariables.DeltaPlasticDissipation;
    }
 
      return rValue;
    }
 
 
 
 
    std::string Info() const override
    {
      std::stringstream buffer;
      buffer << "SimoJ2ThermoPlasticityModel" ;
      return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
      rOStream << "SimoJ2ThermoPlasticityModel";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "SimoJ2ThermoPlasticityModel Data";
    }
 
 
 
 
  protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  private:
 
 
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
      KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, BaseType )
    }
 
    void load(Serializer& rSerializer) override
    {
      KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, BaseType )
    }
 
 
 
 
  }; // Class SimoJ2ThermoPlasticityModel
 
 
 
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_SIMO_J2_THERMO_PLASTICITY_MODEL_H_INCLUDED  defined