cam_clay_model.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_CAM_CLAY_MODEL_H_INCLUDED )
#define  KRATOS_CAM_CLAY_MODEL_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_models/plasticity_models/non_associative_plasticity_model.hpp"
#include "custom_models/plasticity_models/hardening_rules/cam_clay_hardening_rule.hpp"
#include "custom_models/plasticity_models/yield_surfaces/modified_cam_clay_yield_surface.hpp"
#include "custom_models/elasticity_models/borja_model.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
   class KRATOS_API(CONSTITUTIVE_MODELS_APPLICATION) CamClayModel : public NonAssociativePlasticityModel<BorjaModel, ModifiedCamClayYieldSurface<CamClayHardeningRule> >
   {
      public:
 
 
         //elasticity model
         typedef BorjaModel                                     ElasticityModelType;
         typedef ElasticityModelType::Pointer                ElasticityModelPointer;
 
         //yield surface
         typedef CamClayHardeningRule                             HardeningRuleType;
         typedef ModifiedCamClayYieldSurface<HardeningRuleType>    YieldSurfaceType;
         typedef YieldSurfaceType::Pointer                      YieldSurfacePointer;
 
         //base type
         typedef NonAssociativePlasticityModel<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( CamClayModel );
 
 
         CamClayModel() : BaseType() {}
 
         CamClayModel(CamClayModel const& rOther) : BaseType(rOther) {}
 
         CamClayModel& operator=(CamClayModel const& rOther)
         {
            BaseType::operator=(rOther);
            return *this;
         }
 
         ConstitutiveModel::Pointer Clone() const override
         {
            return Kratos::make_shared<CamClayModel>(*this);
         }
 
         ~CamClayModel() override {}
 
 
 
 
 
         int Check(const Properties& rProperties, const ProcessInfo& rCurrentProcessInfo) override
         {
            KRATOS_TRY
 
            //LMV: to be implemented. but should not enter in the base one
 
            return 0;
 
            KRATOS_CATCH("")
         }
 
 
         bool Has(const Variable<double>& rThisVariable) override
         {
            if(rThisVariable == PLASTIC_STRAIN || rThisVariable == DELTA_PLASTIC_STRAIN )
               return true;
 
            return false;
         }
 
         void SetValue(const Variable<double>& rVariable,
               const double& rValue,
               const ProcessInfo& rCurrentProcessInfo) override 
         {
            KRATOS_TRY
 
            if ( rVariable == NONLOCAL_PLASTIC_VOL_DEF) {
               mInternal.Variables[4] = rValue;
            }
 
            KRATOS_CATCH("")
         }
 
         double& GetValue(const Variable<double>& rThisVariable, double& rValue) override
         {
 
            rValue=0;
 
            if (rThisVariable==PLASTIC_STRAIN)
            {
               rValue = this->mInternal.Variables[0];
            }
            else if (rThisVariable==DELTA_PLASTIC_STRAIN)
            {
               rValue = this->mInternal.Variables[0]-mPreviousInternal.Variables[0];
            }
            else if (rThisVariable==PRE_CONSOLIDATION_STRESS)
            {
               rValue = this->mInternal.Variables[3];
            }
            else {
               rValue = NonAssociativePlasticityModel::GetValue( rThisVariable, rValue);
            }
            return rValue;
         }
 
 
 
 
         std::string Info() const override
         {
            std::stringstream buffer;
            buffer << "CamClayModel" ;
            return buffer.str();
         }
 
         void PrintInfo(std::ostream& rOStream) const override
         {
            rOStream << "CamClayModel";
         }
 
         void PrintData(std::ostream& rOStream) const override
         {
            rOStream << "CamClayModel 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 CamClayModel
 
 
 
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_CAM_CLAY_MODEL_H_INCLUDED  defined