TensorMechanicsPlasticMohrCoulombMulti.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "TensorMechanicsPlasticModel.h"
#include "TensorMechanicsHardeningModel.h"
 
class TensorMechanicsPlasticMohrCoulombMulti;
 
template <>
InputParameters validParams<TensorMechanicsPlasticMohrCoulombMulti>();
 
class TensorMechanicsPlasticMohrCoulombMulti : public TensorMechanicsPlasticModel
{
public:
  static InputParameters validParams();
 
  TensorMechanicsPlasticMohrCoulombMulti(const InputParameters & parameters);
 
  virtual unsigned int numberSurfaces() const override;
 
  virtual void
  yieldFunctionV(const RankTwoTensor & stress, Real intnl, std::vector<Real> & f) const override;
 
  virtual void dyieldFunction_dstressV(const RankTwoTensor & stress,
                                       Real intnl,
                                       std::vector<RankTwoTensor> & df_dstress) const override;
 
  virtual void dyieldFunction_dintnlV(const RankTwoTensor & stress,
                                      Real intnl,
                                      std::vector<Real> & df_dintnl) const override;
 
  virtual void flowPotentialV(const RankTwoTensor & stress,
                              Real intnl,
                              std::vector<RankTwoTensor> & r) const override;
 
  virtual void dflowPotential_dstressV(const RankTwoTensor & stress,
                                       Real intnl,
                                       std::vector<RankFourTensor> & dr_dstress) const override;
 
  virtual void dflowPotential_dintnlV(const RankTwoTensor & stress,
                                      Real intnl,
                                      std::vector<RankTwoTensor> & dr_dintnl) const override;
 
  virtual void activeConstraints(const std::vector<Real> & f,
                                 const RankTwoTensor & stress,
                                 Real intnl,
                                 const RankFourTensor & Eijkl,
                                 std::vector<bool> & act,
                                 RankTwoTensor & returned_stress) const override;
 
  virtual std::string modelName() const override;
 
  virtual bool useCustomReturnMap() const override;
 
  virtual bool returnMap(const RankTwoTensor & trial_stress,
                         Real intnl_old,
                         const RankFourTensor & E_ijkl,
                         Real ep_plastic_tolerance,
                         RankTwoTensor & returned_stress,
                         Real & returned_intnl,
                         std::vector<Real> & dpm,
                         RankTwoTensor & delta_dp,
                         std::vector<Real> & yf,
                         bool & trial_stress_inadmissible) const override;
 
protected:
  virtual Real cohesion(const Real internal_param) const;
 
  virtual Real dcohesion(const Real internal_param) const;
 
  virtual Real phi(const Real internal_param) const;
 
  virtual Real dphi(const Real internal_param) const;
 
  virtual Real psi(const Real internal_param) const;
 
  virtual Real dpsi(const Real internal_param) const;
 
private:
  const TensorMechanicsHardeningModel & _cohesion;
 
  const TensorMechanicsHardeningModel & _phi;
 
  const TensorMechanicsHardeningModel & _psi;
 
  const unsigned int _max_iters;
 
  const Real _shift;
 
  const bool _use_custom_returnMap;
 
  void yieldFunctionEigvals(
      Real e0, Real e1, Real e2, Real sinphi, Real cohcos, std::vector<Real> & f) const;
 
  void df_dsig(const RankTwoTensor & stress, Real sin_angle, std::vector<RankTwoTensor> & df) const;
 
  void perturbStress(const RankTwoTensor & stress,
                     std::vector<Real> & eigvals,
                     std::vector<RankTwoTensor> & deigvals) const;
 
  bool KuhnTuckerOK(const std::vector<Real> & yf,
                    const std::vector<Real> & dpm,
                    Real ep_plastic_tolerance) const;
 
  bool doReturnMap(const RankTwoTensor & trial_stress,
                   Real intnl_old,
                   const RankFourTensor & E_ijkl,
                   Real ep_plastic_tolerance,
                   RankTwoTensor & returned_stress,
                   Real & returned_intnl,
                   std::vector<Real> & dpm,
                   RankTwoTensor & delta_dp,
                   std::vector<Real> & yf,
                   bool & trial_stress_inadmissible) const;
 
  bool returnTip(const std::vector<Real> & eigvals,
                 const std::vector<RealVectorValue> & n,
                 std::vector<Real> & dpm,
                 RankTwoTensor & returned_stress,
                 Real intnl_old,
                 Real & sinphi,
                 Real & cohcos,
                 Real initial_guess,
                 bool & nr_converged,
                 Real ep_plastic_tolerance,
                 std::vector<Real> & yf) const;
 
  bool returnPlane(const std::vector<Real> & eigvals,
                   const std::vector<RealVectorValue> & n,
                   std::vector<Real> & dpm,
                   RankTwoTensor & returned_stress,
                   Real intnl_old,
                   Real & sinphi,
                   Real & cohcos,
                   Real initial_guess,
                   bool & nr_converged,
                   Real ep_plastic_tolerance,
                   std::vector<Real> & yf) const;
 
  bool returnEdge000101(const std::vector<Real> & eigvals,
                        const std::vector<RealVectorValue> & n,
                        std::vector<Real> & dpm,
                        RankTwoTensor & returned_stress,
                        Real intnl_old,
                        Real & sinphi,
                        Real & cohcos,
                        Real initial_guess,
                        Real mag_E,
                        bool & nr_converged,
                        Real ep_plastic_tolerance,
                        std::vector<Real> & yf) const;
 
  bool returnEdge010100(const std::vector<Real> & eigvals,
                        const std::vector<RealVectorValue> & n,
                        std::vector<Real> & dpm,
                        RankTwoTensor & returned_stress,
                        Real intnl_old,
                        Real & sinphi,
                        Real & cohcos,
                        Real initial_guess,
                        Real mag_E,
                        bool & nr_converged,
                        Real ep_plastic_tolerance,
                        std::vector<Real> & yf) const;
 
  enum return_type
  {
    tip110100 = 0,
    tip010101 = 1,
    edge010100 = 2,
    edge000101 = 3,
    plane000100 = 4
  };
};