particle_hardening_law.hpp

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:        BSD License
//                      Kratos default license: kratos/license.txt
//
//  Main authors:    Bodhinanda Chandra
//
//  References:      This class is adapted from applications/SolidMechanicsApplication/custom_constitutive/custom_hardening_laws/hardening_law.hpp
 
 
#if !defined(KRATOS_MPM_HARDENING_LAW_H_INCLUDED)
#define      KRATOS_MPM_HARDENING_LAW_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/properties.h"
#include "input_output/logger.h"
 
 
namespace Kratos
{
 
 
 
 
 
 
 
class KRATOS_API(PARTICLE_MECHANICS_APPLICATION) ParticleHardeningLaw
{
public:
 
    struct Parameters
    {
    private:
 
          double        mRateFactor;
 
          const double* mpDeltaTime;
 
    public:
 
          //Set Parameters
          void SetRateFactor  (double rRateFactor)         { mRateFactor = rRateFactor;     };
          void SetDeltaTime   (const double& rDeltaTime)   { mpDeltaTime = &rDeltaTime;     };
 
          //Get Parameters
          const double& GetRateFactor  () const { return  mRateFactor;   };
          const double& GetDeltaTime   () const { return *mpDeltaTime;   };
 
          void print() const
          {
            KRATOS_INFO("ParticleHardeningLaw.Parameters") << " RateFactor " << mRateFactor  << std::endl;
            KRATOS_INFO("ParticleHardeningLaw.Parameters") << " DeltaTime  " << *mpDeltaTime << std::endl;
          }
 
    };
 
 
    typedef const Properties*   PropertiesPointer;
 
 
    KRATOS_CLASS_POINTER_DEFINITION( ParticleHardeningLaw );
 
 
    ParticleHardeningLaw(){};
 
    ParticleHardeningLaw(ParticleHardeningLaw const& rOther)
    {};
 
    ParticleHardeningLaw& operator=(ParticleHardeningLaw const& rOther)
    {
      return *this;
    };
 
    virtual ~ParticleHardeningLaw() {};
 
 
 
    virtual ParticleHardeningLaw::Pointer Clone() const
    {
      return Kratos::make_shared<ParticleHardeningLaw>(*this);
    }
 
 
    /*
    * @brief This function return the hardening constant at given hardening parameters
    * @param[in/out] rHardening Hardening value
    * @param[in] rValues Hardening parameters
    * @param[in] rAlpha Hardening parameters
    * @param[in] rBeta Hardening parameters
    * @param[in] rThisVariable Identifier variables
    * @return Value of Hardening
    */
    virtual double& CalculateHardening(double &rHardening, const Parameters& rValues, const Properties& rProperties){ return rHardening; };
 
    virtual double& CalculateHardening(double &rHardening, const double& rAlpha, const double& rBeta, const Properties& rProperties) {return rHardening; };
 
    virtual double& CalculateHardening(double &rHardening, const double& rAlpha, const Variable<double>& rThisVariable, const Properties& rProperties) {return rHardening;};
 
 
 
 
 
 
 
 
 
 
protected:
 
 
 
    PropertiesPointer mpProperties;
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
    // A private default constructor necessary for serialization
 
    virtual void save(Serializer& rSerializer) const
    {
    };
 
    virtual void load(Serializer& rSerializer)
    {
    };
 
 
 
 
 
}; // Class ParticleHardeningLaw
 
 
 
 
 
 
// /// input stream function
// inline std::istream& operator >> (std::istream& rIStream,
//                                   ParticleHardeningLaw& rThis);
 
// /// output stream function
// inline std::ostream& operator << (std::ostream& rOStream,
//                                   const ParticleHardeningLaw& rThis)
// {
//     rThis.PrintInfo(rOStream);
//     rOStream << std::endl;
//     rThis.PrintData(rOStream);
 
//     return rOStream;
// }
 
 
}  // namespace Kratos.
 
#endif // KRATOS_MPM_HARDENING_LAW_H_INCLUDED  defined