friction_law.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosContactMechanicsApplication $
//   Created by:          $Author:              JMCarbonell $
//   Last modified by:    $Co-Author:                       $
//   Date:                $Date:                  July 2016 $
//   Revision:            $Revision:                    0.0 $
//
//
 
#if !defined(KRATOS_FRICTION_LAW_H_INCLUDED)
#define KRATOS_FRICTION_LAW_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/properties.h"
#include "containers/flags.h"
#include "custom_utilities/contact_properties_extensions.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
class KRATOS_API(CONTACT_MECHANICS_APPLICATION) FrictionLaw
{
public:
 
 
  struct FrictionLawVariables {
 
    double FrictionCoefficient;
    double Alpha;
    double Area;
 
    double TangentPenalty;
 
    double PlasticSlipOld;
    double PlasticSlip;
    double Adhesion;
 
    bool Implex;
 
    FrictionLawVariables() {Implex = false; Area = 1.0;}
 
    void Initialize(const double & rTangentPenalty, double PS, double & rArea, bool rImplex = false )
    {
      PlasticSlipOld = PS;
      PlasticSlip = PS;
      Area = rArea;
      TangentPenalty = rTangentPenalty / Area;
      Implex = rImplex;
    };
 
  };
 
  KRATOS_CLASS_POINTER_DEFINITION(FrictionLaw);
 
 
  FrictionLaw()
  {
    mPlasticSlip = 0.0;
    mPlasticSlipNew = 0.0;
    mDeltaPlasticSlip = 0.0;
  };
 
  FrictionLaw(FrictionLaw const& rOther)
      :mPlasticSlip(rOther.mPlasticSlip)
      ,mPlasticSlipNew(rOther.mPlasticSlipNew)
      ,mDeltaPlasticSlip(rOther.mDeltaPlasticSlip)
  {};
 
  virtual ~FrictionLaw(){};
 
  virtual FrictionLaw::Pointer Clone() const
  {
    return Kratos::make_shared<FrictionLaw>(*this);
  };
 
 
 
 
 
 
  void InitializeSolutionStep();
 
  void FinalizeSolutionStep();
 
  // perform similar to a return mapping
  bool EvaluateFrictionLaw( double& rTangentForce, const double& rNormalForce, FrictionLawVariables& rTangentVariables);
 
  void EvaluateConstitutiveComponents( double& rNormalModulus, double & rTangentModulus, const double& rTangentForce, const double& rEffectiveNormalForce, FrictionLawVariables& rTangentVariables);
 
  double GetPlasticSlip() { return mPlasticSlip; };
 
 
 
 
 
 
  virtual std::string Info() const
  {
    std::stringstream buffer;
    buffer << "FrictionLaw";
    return buffer.str();
  }
 
  virtual void PrintInfo(std::ostream& rOStream) const
  {
    rOStream << "FrictionLaw";
  }
 
  virtual void PrintData(std::ostream& rOStream) const
  {
    rOStream << "FrictionLaw Data";
  }
 
 
 
 
protected:
 
 
 
 
 
 
 
  // Evaluate Hardening
  virtual double EvaluateHardening( const double& rNormalStress, const double& rPlasticSlip, FrictionLawVariables& rTangentVariables) { return 0; };
 
  // Evaluate Contact Yield Surface
  virtual double EvaluateContactYield( const double& rTangentStress, const double& rNormalStress, const double& rPlasticSlip, FrictionLawVariables& rTangentVariables ) { return 0; };
 
  // Evaluate Contact Yield Surface Stress Derivative
  virtual void EvaluateYieldDerivativeRespectStress( double& rdF_dt, double & rdF_dp, const double& rTangentStress, const double& rNormalStress, const double& Gamma, FrictionLawVariables&  rTangentVariables ) {};
 
 
 
 
 
 
 
 
 
private:
 
 
 
  double mPlasticSlip;
  double mPlasticSlipNew;
  double mDeltaPlasticSlip;
 
 
 
 
 
  friend class Serializer;
 
  virtual void save( Serializer& rSerializer ) const
  {
    rSerializer.save("mPlasticSlip",mPlasticSlip);
    rSerializer.save("mPlasticSlipNew",mPlasticSlipNew);
    rSerializer.save("mDeltaPlasticSlip",mDeltaPlasticSlip);
  }
 
  virtual void load( Serializer& rSerializer )
  {
    rSerializer.load("mPlasticSlip",mPlasticSlip);
    rSerializer.load("mPlasticSlipNew",mPlasticSlipNew);
    rSerializer.load("mDeltaPlasticSlip",mDeltaPlasticSlip);
  }
 
 
 
 
 
 
  //FrictionLaw& operator=(FrictionLaw const& rOther);
 
 
public:
 
  DECLARE_HAS_THIS_TYPE_PROPERTIES
  DECLARE_ADD_THIS_TYPE_TO_PROPERTIES
  DECLARE_GET_THIS_TYPE_FROM_PROPERTIES
 
}; // Class FrictionLaw
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  FrictionLaw& rThis)
{
  return rIStream;
}
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const FrictionLaw& rThis)
{
  return rOStream << rThis.Info();
}
 
 
} // namespace Kratos
 
#endif // KRATOS_FRICTION_LAW_H_INCLUDED defined