modified_cam_clay_yield_surface.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_MODIFIED_CAM_CLAY_YIELD_SURFACE_H_INCLUDED )
#define      KRATOS_MODIFIED_CAM_CLAY_YIELD_SURFACE_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_models/plasticity_models/yield_surfaces/yield_surface.hpp"
#include "custom_utilities/stress_invariants_utilities.hpp"
#include "custom_utilities/shape_deviatoric_plane_mcc_utilities.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
  template<class THardeningRule>
  class ModifiedCamClayYieldSurface : public YieldSurface<THardeningRule>
  {
  public:
 
 
    typedef ConstitutiveModelData::MatrixType                          MatrixType;
    typedef ConstitutiveModelData::VectorType                          VectorType;
    typedef ConstitutiveModelData::ModelData                        ModelDataType;
    typedef ConstitutiveModelData::MaterialData                  MaterialDataType;
 
    typedef YieldSurface<THardeningRule>                                 BaseType;
    typedef typename BaseType::Pointer                            BaseTypePointer;
    typedef typename BaseType::PlasticDataType                    PlasticDataType;
 
    KRATOS_CLASS_POINTER_DEFINITION( ModifiedCamClayYieldSurface );
 
 
    ModifiedCamClayYieldSurface() : BaseType() {}
 
    ModifiedCamClayYieldSurface(ModifiedCamClayYieldSurface const& rOther) : BaseType(rOther) {}
 
 
    ModifiedCamClayYieldSurface& operator=(ModifiedCamClayYieldSurface const& rOther)
    {
      BaseType::operator=(rOther);
      return *this;
    }
 
    BaseTypePointer Clone() const override
    {
      return Kratos::make_shared<ModifiedCamClayYieldSurface>(*this);
    }
 
    ~ModifiedCamClayYieldSurface() override {}
 
 
 
 
 
    double& CalculateYieldCondition(const PlasticDataType& rVariables, double & rYieldCondition) override
    {
      KRATOS_TRY
 
      const ModelDataType & rModelData = rVariables.GetModelData();
      const MatrixType    & rStressMatrix = rModelData.GetStressMatrix();
 
      // Material Parameters
      const Properties& rProperties = rModelData.GetProperties();
      const double& rShearM = rProperties[CRITICAL_STATE_LINE];
      //const double & rFriction = rProperties[INTERNAL_FRICTION_ANGLE];
 
 
      // compute something with the hardening rule
      double PreconsolidationStress;
      PreconsolidationStress = this->mHardeningRule.CalculateHardening( rVariables, PreconsolidationStress );
 
 
      double MeanStress, LodeAngle;
      double DeviatoricQ; // == sqrt(3)*J2
 
      // more work is requiered
      StressInvariantsUtilities::CalculateStressInvariants( rStressMatrix, MeanStress, DeviatoricQ, LodeAngle);
      DeviatoricQ *= sqrt(3.0);
 
      rYieldCondition  = pow( DeviatoricQ/rShearM, 2);
      rYieldCondition += (MeanStress * (MeanStress - PreconsolidationStress) );
 
 
      //std::cout << " yield funciton: p " << MeanStress << " q: " << DeviatoricQ << "  pc " << PreconsolidationStress << " yield value " << rYieldCondition << std::endl;
      return rYieldCondition;
 
      KRATOS_CATCH(" ")
    }
 
    //*************************************************************************************
    //*************************************************************************************
    // evaluation of the derivative of the yield surface respect the stresses
    VectorType& CalculateDeltaStressYieldCondition(const PlasticDataType& rVariables, VectorType& rDeltaStressYieldCondition) override
    {
      KRATOS_TRY
 
      const ModelDataType & rModelData = rVariables.GetModelData();
      const MatrixType    & rStressMatrix = rModelData.GetStressMatrix();
 
      // Material Parameters
      const Properties& rProperties = rModelData.GetProperties();
      const double& rShearM = rProperties[CRITICAL_STATE_LINE];
 
      // compute something with the hardening rule
      double PreconsolidationStress;
      PreconsolidationStress = this->mHardeningRule.CalculateHardening( rVariables, PreconsolidationStress );
 
 
      double MeanStress, J2, LodeAngle;
 
      VectorType V1, V2;
      // more work is requiered
      StressInvariantsUtilities::CalculateStressInvariants( rStressMatrix, MeanStress, J2, LodeAngle);
      StressInvariantsUtilities::CalculateDerivativeVectors( rStressMatrix, V1, V2);
 
      rDeltaStressYieldCondition  = ( 2.0*MeanStress - PreconsolidationStress) * V1 + 2.0 * 3.0 * pow( 1.0 / rShearM, 2) * J2 * V2;
 
      return rDeltaStressYieldCondition;
 
      KRATOS_CATCH(" ")
    }
 
 
 
 
 
 
 
 
    std::string Info() const override
    {
      std::stringstream buffer;
      buffer << "ModifiedCamClayYieldSurface" ;
      return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
      rOStream << "ModifiedCamClayYieldSurface";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "ModifiedCamClayYieldSurface 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 ModifiedCamClayYieldSurface
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_MODIFIED_CAM_CLAY_YIELD_SURFACE_H_INCLUDED  defined