v2_gens_nova_model.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosConstitutiveModelsApplication $
//   Created by:          $Author:                  LMonforte $
//   Last modified by:    $Co-Author:                MCiantia $
//   Date:                $Date:                    July 2018 $
//   Revision:            $Revision:                      0.0 $
//
//
 
#if !defined(KRATOS_V2_GENS_NOVA_MODEL_H_INCLUDED )
#define  KRATOS_V2_GENS_NOVA_MODEL_H_INCLUDED
 
// System includes
 
// External includes
#include <iostream>
#include <fstream>
 
// Project includes
#include "custom_models/plasticity_models/structured_soil_model.hpp"
#include "custom_models/plasticity_models/hardening_rules/gens_nova_hardening_rule.hpp"
#include "custom_models/plasticity_models/yield_surfaces/gens_nova_yield_surface.hpp"
#include "custom_models/elasticity_models/borja_model.hpp"
#include "custom_models/elasticity_models/tamagnini_model.hpp"
 
 
 
//***** the hardening law associated to this Model has ... variables
// 0. Plastic multiplier
// 1. Plastic Volumetric deformation
// 2. Plastic Deviatoric deformation
// 3. ps (mechanical)
// 4. pt (ageing)
// 5. pcSTAR = ps + (1+k) p_t
// 6. Plastic Volumetric deformation Absolut Value
// 7. NonLocal Plastic Vol Def
// 8. NonLocal Plastic Dev Def
// 9. NonLocal Plastic Vol Def ABS
// ... (the number now is then..., xD)
 
namespace Kratos
{
 
 
 
 
 
 
 
   class KRATOS_API(CONSTITUTIVE_MODELS_APPLICATION) V2GensNovaModel : public StructuredSoilModel<TamagniniModel, GensNovaYieldSurface<GensNovaHardeningRule> >
   {
      public:
 
 
         //elasticity model
         //typedef BorjaModel                                     ElasticityModelType;
         typedef TamagniniModel                                     ElasticityModelType;
         typedef ElasticityModelType::Pointer                ElasticityModelPointer;
 
         //yield surface
         typedef GensNovaHardeningRule                             HardeningRuleType;
         typedef GensNovaYieldSurface<HardeningRuleType>    YieldSurfaceType;
         typedef YieldSurfaceType::Pointer                      YieldSurfacePointer;
 
         //base type
         typedef StructuredSoilModel<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( V2GensNovaModel );
 
 
         V2GensNovaModel() : BaseType() { mInitialized = false; }
 
         V2GensNovaModel(V2GensNovaModel const& rOther) : BaseType(rOther)  {}
 
         V2GensNovaModel& operator=(V2GensNovaModel const& rOther)
         {
            BaseType::operator=(rOther);
            return *this;
         }
 
         ConstitutiveModel::Pointer Clone() const override
         {
            return ( V2GensNovaModel::Pointer(new V2GensNovaModel(*this)) );
         }
 
         virtual ~V2GensNovaModel() {}
 
 
 
 
 
 
 
 
 
 
 
         virtual std::string Info() const override
         {
            std::stringstream buffer;
            buffer << "V2GensNovaModel" ;
            return buffer.str();
         }
 
         virtual void PrintInfo(std::ostream& rOStream) const override
         {
            rOStream << "V2GensNovaModel";
         }
 
         virtual void PrintData(std::ostream& rOStream) const override
         {
            rOStream << "V2GensNovaModel Data";
         }
 
 
 
 
 
      protected:
 
 
 
 
 
 
            // Calculate Stress and constitutive tensor
            void CalculateStressAndConstitutiveTensors(ModelDataType& rValues, MatrixType& rStressMatrix, Matrix& rConstitutiveMatrix) override
            {
               KRATOS_TRY
 
               // integrate "analytically" ps and pt from plastic variables. Then update the internal variables.
 
               PlasticDataType Variables;
               this->InitializeVariables( rValues, Variables);
 
               const ModelDataType & rModelData = Variables.GetModelData();
               const Properties & rMaterialProperties = rModelData.GetProperties();
 
               const double & rPs0 = rMaterialProperties[PS];
               const double & rPt0 = rMaterialProperties[PT];
               const double & rChis = rMaterialProperties[CHIS];
               const double & rChit = rMaterialProperties[CHIT];
               const double & rhos = rMaterialProperties[RHOS];
               const double & rhot = rMaterialProperties[RHOT];
               const double & k = rMaterialProperties[KSIM];
 
               const double & rPlasticVolDef = Variables.Internal.Variables[1]; 
               const double & rPlasticDevDef = Variables.Internal.Variables[2];
               const double & rPlasticVolDefAbs = Variables.Internal.Variables[6];
 
               double sq2_3 = sqrt(2.0/3.0);
 
               double ps;
               ps = rPlasticVolDef + sq2_3 * rChis * rPlasticDevDef; 
               ps = (-rPs0) * std::exp( -rhos*ps);
 
               double pt;
               pt = rPlasticVolDefAbs + sq2_3 * rChit * rPlasticDevDef; 
               pt = (-rPt0) * std::exp( rhot*pt);
 
               double pm;
               pm = ps + (1.0+k)*pt;
 
 
               mInternal.Variables[3] = ps;
               mInternal.Variables[4] = pt;
               mInternal.Variables[5] = pm;
 
               StructuredSoilModel::CalculateStressAndConstitutiveTensors( rValues, rStressMatrix, rConstitutiveMatrix);
 
               KRATOS_CATCH("")
            }
 
 
 
 
 
 
 
      private:
 
 
 
 
 
 
 
 
 
 
 
 
         friend class Serializer;
 
         virtual void save(Serializer& rSerializer) const override
         {
            KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, BaseType )
         }
 
         virtual void load(Serializer& rSerializer) override
         {
            KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, BaseType )
         }
 
 
 
 
   }; // Class V2GensNovaModel
 
 
 
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_V2_GENS_NOVA_MODEL_H_INCLUDED  defined