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_GENS_NOVA_MODEL_H_INCLUDED )
#define  KRATOS_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) GensNovaModel : 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( GensNovaModel );
 
 
         GensNovaModel() : BaseType() { mInitialized = false; }
 
         GensNovaModel(GensNovaModel const& rOther) : BaseType(rOther)  {}
 
         GensNovaModel& operator=(GensNovaModel const& rOther)
         {
            BaseType::operator=(rOther);
            return *this;
         }
 
         ConstitutiveModel::Pointer Clone() const override
         {
            return ( GensNovaModel::Pointer(new GensNovaModel(*this)) );
         }
 
         virtual ~GensNovaModel() {}
 
 
 
 
         
 
 
 
 
 
 
         virtual std::string Info() const override
         {
            std::stringstream buffer;
            buffer << "GensNovaModel" ;
            return buffer.str();
         }
 
         virtual void PrintInfo(std::ostream& rOStream) const override
         {
            rOStream << "GensNovaModel";
         }
 
         virtual void PrintData(std::ostream& rOStream) const override
         {
            rOStream << "GensNovaModel Data";
         }
 
 
 
 
 
      protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
      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 GensNovaModel
 
 
 
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_GENS_NOVA_MODEL_H_INCLUDED  defined