TensorMechanicsPlasticTensileMulti.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 TensorMechanicsPlasticTensileMulti;
 
template <>
InputParameters validParams<TensorMechanicsPlasticTensileMulti>();
 
class TensorMechanicsPlasticTensileMulti : public TensorMechanicsPlasticModel
{
public:
  static InputParameters validParams();
 
  TensorMechanicsPlasticTensileMulti(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 useCustomCTO() 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;
 
  virtual RankFourTensor
  consistentTangentOperator(const RankTwoTensor & trial_stress,
                            Real intnl_old,
                            const RankTwoTensor & stress,
                            Real intnl,
                            const RankFourTensor & E_ijkl,
                            const std::vector<Real> & cumulative_pm) const override;
 
protected:
  virtual Real tensile_strength(const Real internal_param) const;
 
  virtual Real dtensile_strength(const Real internal_param) const;
 
private:
  const TensorMechanicsHardeningModel & _strength;
 
  const unsigned int _max_iters;
 
  const Real _shift;
 
  const bool _use_custom_returnMap;
 
  const bool _use_custom_cto;
 
  Real dot(const std::vector<Real> & a, const std::vector<Real> & b) const;
 
  Real triple(const std::vector<Real> & a,
              const std::vector<Real> & b,
              const std::vector<Real> & c) const;
 
  bool returnTip(const std::vector<Real> & eigvals,
                 const std::vector<RealVectorValue> & n,
                 std::vector<Real> & dpm,
                 RankTwoTensor & returned_stress,
                 Real intnl_old,
                 Real initial_guess) const;
 
  bool returnEdge(const std::vector<Real> & eigvals,
                  const std::vector<RealVectorValue> & n,
                  std::vector<Real> & dpm,
                  RankTwoTensor & returned_stress,
                  Real intnl_old,
                  Real initial_guess) const;
 
  bool returnPlane(const std::vector<Real> & eigvals,
                   const std::vector<RealVectorValue> & n,
                   std::vector<Real> & dpm,
                   RankTwoTensor & returned_stress,
                   Real intnl_old,
                   Real initial_guess) const;
 
  bool KuhnTuckerOK(const RankTwoTensor & returned_diagonal_stress,
                    const std::vector<Real> & dpm,
                    Real str,
                    Real ep_plastic_tolerance) const;
 
  virtual 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;
 
  enum return_type
  {
    tip = 0,
    edge = 1,
    plane = 2
  };
};