yield_surface.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_YIELD_SURFACE_H_INCLUDED )
#define  KRATOS_YIELD_SURFACE_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_models/plasticity_models/hardening_rules/hardening_rule.hpp"
#include "custom_utilities/constitutive_model_utilities.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
  template<class THardeningRule>
  class YieldSurface
  {
  public:
 
 
    typedef ConstitutiveModelData::MatrixType                          MatrixType;
    typedef ConstitutiveModelData::VectorType                          VectorType;
    typedef ConstitutiveModelData::ModelData                        ModelDataType;
    typedef ConstitutiveModelData::MaterialData                  MaterialDataType;
 
    typedef THardeningRule                                       HardeningRuleType;
    typedef typename THardeningRule::PlasticDataType               PlasticDataType;
    typedef typename THardeningRule::InternalVariablesType   InternalVariablesType;
 
    KRATOS_CLASS_POINTER_DEFINITION( YieldSurface );
 
 
    YieldSurface() {}
 
    YieldSurface(YieldSurface const& rOther) : mHardeningRule(rOther.mHardeningRule) {}
 
    YieldSurface& operator=(YieldSurface const& rOther)
    {
      mHardeningRule = rOther.mHardeningRule;
      return *this;
    }
 
    virtual typename YieldSurface::Pointer Clone() const
    {
      return Kratos::make_shared<YieldSurface>(*this);
    }
 
    virtual ~YieldSurface() {}
 
 
 
 
 
    virtual double& CalculateYieldCondition(const PlasticDataType& rVariables, double & rYieldCondition)
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the YieldSurface base class ... illegal operation" << std::endl;
 
      return rYieldCondition;
 
      KRATOS_CATCH(" ")
    }
 
    virtual double& CalculateDeltaYieldCondition(const PlasticDataType& rVariables, double & rDeltaYieldCondition)
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the YieldSurface base class ... illegal operation" << std::endl;
 
      return rDeltaYieldCondition;
 
      KRATOS_CATCH(" ")
    }
 
 
    virtual VectorType& CalculateDeltaStressYieldCondition(const PlasticDataType& rVariables, VectorType& rDeltaStressYieldCondition)
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the YieldSurface base class ... illegal operation" << std::endl;
 
      return rDeltaStressYieldCondition;
 
      KRATOS_CATCH(" ")
    }
 
 
    virtual double& CalculateStateFunction(const PlasticDataType& rVariables, double & rStateFunction)
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the YieldSurface base class ... illegal operation" << std::endl;
 
      return rStateFunction;
 
      KRATOS_CATCH(" ")
    }
 
    virtual double& CalculateDeltaStateFunction(const PlasticDataType& rVariables, double & rDeltaStateFunction)
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the YieldSurface base class ... illegal operation" << std::endl;
 
      return rDeltaStateFunction;
 
      KRATOS_CATCH(" ")
    }
 
    virtual double& CalculatePlasticDissipation(const PlasticDataType& rVariables, double & rPlasticDissipation)
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the YieldSurface base class ... illegal operation" << std::endl;
 
      return rPlasticDissipation;
 
      KRATOS_CATCH(" ")
    }
 
    virtual double& CalculateDeltaPlasticDissipation(const PlasticDataType& rVariables, double & rDeltaPlasticDissipation)
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the YieldSurface base class ... illegal operation" << std::endl;
 
      return rDeltaPlasticDissipation;
 
      KRATOS_CATCH(" ")
    }
 
    virtual double& CalculateImplexPlasticDissipation(const PlasticDataType& rVariables, double & rPlasticDissipation)
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the YieldSurface base class ... illegal operation" << std::endl;
 
      return rPlasticDissipation;
 
      KRATOS_CATCH(" ")
    }
 
    virtual double& CalculateImplexDeltaPlasticDissipation(const PlasticDataType& rVariables, double & rDeltaPlasticDissipation)
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the YieldSurface base class ... illegal operation" << std::endl;
 
      return rDeltaPlasticDissipation;
 
      KRATOS_CATCH(" ")
    }
 
 
 
    HardeningRuleType& GetHardeningRule() { return mHardeningRule; };
 
 
 
 
 
    virtual std::string Info() const
    {
      std::stringstream buffer;
      buffer << "YieldSurface" ;
      return buffer.str();
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
      rOStream << "YieldSurface";
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
      rOStream << "YieldSurface Data";
    }
 
 
 
 
 
  protected:
 
 
 
    HardeningRuleType mHardeningRule;
 
 
 
 
 
 
 
 
 
 
 
 
  private:
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
 
    virtual void save(Serializer& rSerializer) const
    {
      rSerializer.save("mHardeningRule", mHardeningRule);
    }
 
    virtual void load(Serializer& rSerializer)
    {
      rSerializer.load("mHardeningRule", mHardeningRule);
    }
 
 
 
 
 
  }; // Class YieldSurface
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_YIELD_SURFACE_H_INCLUDED  defined