TensorMechanicsPlasticDruckerPragerHyperbolic Class Reference

Rate-independent non-associative Drucker Prager with hardening/softening. More...

#include <TensorMechanicsPlasticDruckerPragerHyperbolic.h>

Inheritance diagram for TensorMechanicsPlasticDruckerPragerHyperbolic:

Public Types
enum	FrictionDilation { friction = 0, dilation = 1 }
	bbb (friction) and bbb_flow (dilation) are computed using the same function, onlyB, and this parameter tells that function whether to compute bbb or bbb_flow More...

Public Member Functions
	TensorMechanicsPlasticDruckerPragerHyperbolic (const InputParameters &parameters)
virtual std::string	modelName () const override
virtual bool	useCustomReturnMap () const override
	Returns false. You will want to override this in your derived class if you write a custom returnMap function. More...
virtual bool	useCustomCTO () const override
	Returns false. You will want to override this in your derived class if you write a custom consistent tangent operator function. More...
void	bothAB (Real intnl, Real &aaa, Real &bbb) const
	Calculates aaa and bbb as a function of the internal parameter intnl. More...
void	dbothAB (Real intnl, Real &daaa, Real &dbbb) const
	Calculates d(aaa)/d(intnl) and d(bbb)/d(intnl) as a function of the internal parameter intnl. More...
void	onlyB (Real intnl, int fd, Real &bbb) const
	Calculate bbb or bbb_flow. More...
void	donlyB (Real intnl, int fd, Real &dbbb) const
	Calculate d(bbb)/d(intnl) or d(bbb_flow)/d(intnl) More...
void	initialize ()
void	execute ()
void	finalize ()
virtual unsigned int	numberSurfaces () const
	The number of yield surfaces for this plasticity model. More...
virtual void	yieldFunctionV (const RankTwoTensor &stress, Real intnl, std::vector< Real > &f) const
	Calculates the yield functions. More...
virtual void	dyieldFunction_dstressV (const RankTwoTensor &stress, Real intnl, std::vector< RankTwoTensor > &df_dstress) const
	The derivative of yield functions with respect to stress. More...
virtual void	dyieldFunction_dintnlV (const RankTwoTensor &stress, Real intnl, std::vector< Real > &df_dintnl) const
	The derivative of yield functions with respect to the internal parameter. More...
virtual void	flowPotentialV (const RankTwoTensor &stress, Real intnl, std::vector< RankTwoTensor > &r) const
	The flow potentials. More...
virtual void	dflowPotential_dstressV (const RankTwoTensor &stress, Real intnl, std::vector< RankFourTensor > &dr_dstress) const
	The derivative of the flow potential with respect to stress. More...
virtual void	dflowPotential_dintnlV (const RankTwoTensor &stress, Real intnl, std::vector< RankTwoTensor > &dr_dintnl) const
	The derivative of the flow potential with respect to the internal parameter. More...
virtual void	hardPotentialV (const RankTwoTensor &stress, Real intnl, std::vector< Real > &h) const
	The hardening potential. More...
virtual void	dhardPotential_dstressV (const RankTwoTensor &stress, Real intnl, std::vector< RankTwoTensor > &dh_dstress) const
	The derivative of the hardening potential with respect to stress. More...
virtual void	dhardPotential_dintnlV (const RankTwoTensor &stress, Real intnl, std::vector< Real > &dh_dintnl) const
	The derivative of the hardening potential with respect to the internal parameter. More...
virtual void	activeConstraints (const std::vector< Real > &f, const RankTwoTensor &stress, Real intnl, const RankFourTensor &Eijkl, std::vector< bool > &act, RankTwoTensor &returned_stress) const
	The active yield surfaces, given a vector of yield functions. More...
bool	KuhnTuckerSingleSurface (Real yf, Real dpm, Real dpm_tol) const
	Returns true if the Kuhn-Tucker conditions for the single surface are satisfied. More...

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const Real	_f_tol
	Tolerance on yield function. More...
const Real	_ic_tol
	Tolerance on internal constraint. More...

Protected Member Functions
Real	yieldFunction (const RankTwoTensor &stress, Real intnl) const override
	The following functions are what you should override when building single-plasticity models. More...
RankFourTensor	dflowPotential_dstress (const RankTwoTensor &stress, Real intnl) const override
	The derivative of the flow potential with respect to stress. More...
virtual RankTwoTensor	df_dsig (const RankTwoTensor &stress, Real bbb) const override
	Function that's used in dyieldFunction_dstress and flowPotential. More...
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
	Performs a custom return-map. More...
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
	Calculates a custom consistent tangent operator. More...
virtual RankTwoTensor	dyieldFunction_dstress (const RankTwoTensor &stress, Real intnl) const override
	The derivative of yield function with respect to stress. More...
virtual Real	dyieldFunction_dintnl (const RankTwoTensor &stress, Real intnl) const override
	The derivative of yield function with respect to the internal parameter. More...
virtual RankTwoTensor	flowPotential (const RankTwoTensor &stress, Real intnl) const override
	The flow potential. More...
virtual RankTwoTensor	dflowPotential_dintnl (const RankTwoTensor &stress, Real intnl) const override
	The derivative of the flow potential with respect to the internal parameter. More...
virtual Real	hardPotential (const RankTwoTensor &stress, Real intnl) const
	The hardening potential. More...
virtual RankTwoTensor	dhardPotential_dstress (const RankTwoTensor &stress, Real intnl) const
	The derivative of the hardening potential with respect to stress. More...
virtual Real	dhardPotential_dintnl (const RankTwoTensor &stress, Real intnl) const
	The derivative of the hardening potential with respect to the internal parameter. More...

Protected Attributes
const TensorMechanicsHardeningModel &	_mc_cohesion
	Hardening model for cohesion. More...
const TensorMechanicsHardeningModel &	_mc_phi
	Hardening model for tan(phi) More...
const TensorMechanicsHardeningModel &	_mc_psi
	Hardening model for tan(psi) More...
const MooseEnum	_mc_interpolation_scheme
	The parameters aaa and bbb are chosen to closely match the Mohr-Coulomb yield surface. More...
const bool	_zero_cohesion_hardening
	True if there is no hardening of cohesion. More...
const bool	_zero_phi_hardening
	True if there is no hardening of friction angle. More...
const bool	_zero_psi_hardening
	True if there is no hardening of dilation angle. More...

Private Member Functions
void	initializeAandB (Real intnl, Real &aaa, Real &bbb) const
	Returns the Drucker-Prager parameters A nice reference on the different relationships between Drucker-Prager and Mohr-Coulomb is H Jiang and X Yongli, A note on the Mohr-Coulomb and Drucker-Prager strength criteria, Mechanics Research Communications 38 (2011) 309-314. More...
void	initializeB (Real intnl, int fd, Real &bbb) const
	Returns the Drucker-Prager parameters A nice reference on the different relationships between Drucker-Prager and Mohr-Coulomb is H Jiang and X Yongli, A note on the Mohr-Coulomb and Drucker-Prager strength criteria, Mechanics Research Communications 38 (2011) 309-314. More...

Private Attributes
const Real	_smoother2
	smoothing parameter for the cone's tip More...
const bool	_use_custom_returnMap
	whether to use the custom returnMap function More...
const bool	_use_custom_cto
	Whether to use the custom consistent tangent operator calculation. More...
const unsigned	_max_iters
	max iters for custom return map loop More...
Real	_aaa
Real	_bbb
Real	_bbb_flow

Detailed Description

Rate-independent non-associative Drucker Prager with hardening/softening.

The cone's tip is smoothed in a hyperbolic fashion Most functions (eg flowPotential, etc) are simply inherited from TensorMechanicsPlasticDruckerPrager. Note df_dsig is over-ridden

Definition at line 26 of file TensorMechanicsPlasticDruckerPragerHyperbolic.h.

Member Enumeration Documentation

FrictionDilation

enum TensorMechanicsPlasticDruckerPrager::FrictionDilation

inherited

bbb (friction) and bbb_flow (dilation) are computed using the same function, onlyB, and this parameter tells that function whether to compute bbb or bbb_flow

Enumerator
friction
dilation

Definition at line 46 of file TensorMechanicsPlasticDruckerPrager.h.

  {
    friction = 0,
    dilation = 1
  };

Constructor & Destructor Documentation

TensorMechanicsPlasticDruckerPragerHyperbolic()

TensorMechanicsPlasticDruckerPragerHyperbolic::TensorMechanicsPlasticDruckerPragerHyperbolic

(

const InputParameters &

parameters

)

Definition at line 51 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

  : TensorMechanicsPlasticDruckerPrager(parameters),
    _smoother2(Utility::pow<2>(getParam<Real>("smoother"))),
    _use_custom_returnMap(getParam<bool>("use_custom_returnMap")),
    _use_custom_cto(getParam<bool>("use_custom_cto")),
    _max_iters(getParam<unsigned>("max_iterations"))
{
}

Member Function Documentation

activeConstraints()

void TensorMechanicsPlasticModel::activeConstraints ( const std::vector< Real > &  f, const RankTwoTensor &  stress, Real  intnl, const RankFourTensor &  Eijkl, std::vector< bool > &  act, RankTwoTensor &  returned_stress  ) const

virtualinherited

The active yield surfaces, given a vector of yield functions.

This is used by FiniteStrainMultiPlasticity to determine the initial set of active constraints at the trial (stress, intnl) configuration. It is up to you (the coder) to determine how accurate you want the returned_stress to be. Currently it is only used by FiniteStrainMultiPlasticity to estimate a good starting value for the Newton-Rahson procedure, so currently it may not need to be super perfect.

Parameters

	f	values of the yield functions
	stress	stress tensor
	intnl	internal parameter
	Eijkl	elasticity tensor (stress = Eijkl*strain)
[out]	act	act[i] = true if the i_th yield function is active
[out]	returned_stress	Approximate value of the returned stress

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, TensorMechanicsPlasticTensileMulti, TensorMechanicsPlasticMeanCapTC, TensorMechanicsPlasticWeakPlaneShear, and TensorMechanicsPlasticWeakPlaneTensile.

Definition at line 188 of file TensorMechanicsPlasticModel.C.

{
  mooseAssert(f.size() == numberSurfaces(),
              "f incorrectly sized at " << f.size() << " in activeConstraints");
  act.resize(numberSurfaces());
  for (unsigned surface = 0; surface < numberSurfaces(); ++surface)
    act[surface] = (f[surface] > _f_tol);
}

bothAB()

void TensorMechanicsPlasticDruckerPrager::bothAB ( Real  intnl, Real &  aaa, Real &  bbb  ) const

inherited

Calculates aaa and bbb as a function of the internal parameter intnl.

Definition at line 149 of file TensorMechanicsPlasticDruckerPrager.C.

{
  if (_zero_cohesion_hardening && _zero_phi_hardening)
  {
    aaa = _aaa;
    bbb = _bbb;
    return;
  }
  initializeAandB(intnl, aaa, bbb);
}

Referenced by CappedDruckerPragerStressUpdate::computeAllQ(), CappedDruckerPragerStressUpdate::initializeVars(), returnMap(), yieldFunction(), TensorMechanicsPlasticDruckerPrager::yieldFunction(), and CappedDruckerPragerStressUpdate::yieldFunctionValues().

consistentTangentOperator()

RankFourTensor TensorMechanicsPlasticDruckerPragerHyperbolic::consistentTangentOperator ( const RankTwoTensor &  trial_stress, Real  intnl_old, const RankTwoTensor &  stress, Real  intnl, const RankFourTensor &  E_ijkl, const std::vector< Real > &  cumulative_pm  ) const

overrideprotectedvirtual

Calculates a custom consistent tangent operator.

You may choose to over-ride this in your derived TensorMechanicsPlasticXXXX class.

(Note, if you over-ride returnMap, you will probably want to override consistentTangentOpertor too, otherwise it will default to E_ijkl.)

Parameters

stress_old	trial stress before returning
intnl_old	internal parameter before returning
stress	current returned stress state
intnl	internal parameter
E_ijkl	elasticity tensor
cumulative_pm	the cumulative plastic multipliers

Returns

the consistent tangent operator: E_ijkl if not over-ridden

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 201 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

{
  if (!_use_custom_cto)
    return TensorMechanicsPlasticModel::consistentTangentOperator(
        trial_stress, intnl_old, stress, intnl, E_ijkl, cumulative_pm);
 
  const Real mu = E_ijkl(0, 1, 0, 1);
  const Real la = E_ijkl(0, 0, 0, 0) - 2.0 * mu;
  const Real bulky = 3.0 * la + 2.0 * mu;
  Real bbb;
  onlyB(intnl, friction, bbb);
  Real bbb_flow;
  onlyB(intnl, dilation, bbb_flow);
  Real dbbb_flow;
  donlyB(intnl, dilation, dbbb_flow);
  const Real bbb_flow_mod = bbb_flow + cumulative_pm[0] * dbbb_flow;
  const Real J2 = stress.secondInvariant();
  const RankTwoTensor sij = stress.deviatoric();
  const Real sq = std::sqrt(J2 + _smoother2);
 
  const Real one_over_h =
      1.0 / (-dyieldFunction_dintnl(stress, intnl) + mu * J2 / Utility::pow<2>(sq) +
             3.0 * bbb * bbb_flow_mod * bulky); // correct up to hard
 
  const RankTwoTensor df_dsig_timesE =
      mu * sij / sq + bulky * bbb * RankTwoTensor(RankTwoTensor::initIdentity); // correct
  const RankTwoTensor rmod_timesE =
      mu * sij / sq +
      bulky * bbb_flow_mod * RankTwoTensor(RankTwoTensor::initIdentity); // correct up to hard
 
  const RankFourTensor coeff_ep =
      E_ijkl - one_over_h * rmod_timesE.outerProduct(df_dsig_timesE); // correct
 
  const RankFourTensor dr_dsig_timesE = -0.5 * mu * sij.outerProduct(sij) / Utility::pow<3>(sq) +
                                        mu * stress.d2secondInvariant() / sq; // correct
  const RankTwoTensor df_dsig_E_dr_dsig =
      0.5 * mu * _smoother2 * sij / Utility::pow<4>(sq); // correct
 
  const RankFourTensor coeff_si =
      RankFourTensor(RankFourTensor::initIdentitySymmetricFour) +
      cumulative_pm[0] *
          (dr_dsig_timesE - one_over_h * rmod_timesE.outerProduct(df_dsig_E_dr_dsig));
 
  RankFourTensor s_inv;
  try
  {
    s_inv = coeff_si.invSymm();
  }
  catch (MooseException & e)
  {
    return coeff_ep; // when coeff_si is singular return the "linear" tangent operator
  }
 
  return s_inv * coeff_ep;
}

dbothAB()

void TensorMechanicsPlasticDruckerPrager::dbothAB ( Real  intnl, Real &  daaa, Real &  dbbb  ) const

inherited

Calculates d(aaa)/d(intnl) and d(bbb)/d(intnl) as a function of the internal parameter intnl.

Definition at line 219 of file TensorMechanicsPlasticDruckerPrager.C.

{
  if (_zero_cohesion_hardening && _zero_phi_hardening)
  {
    daaa = 0;
    dbbb = 0;
    return;
  }
 
  const Real C = _mc_cohesion.value(intnl);
  const Real dC = _mc_cohesion.derivative(intnl);
  const Real cosphi = std::cos(_mc_phi.value(intnl));
  const Real dcosphi = -std::sin(_mc_phi.value(intnl)) * _mc_phi.derivative(intnl);
  const Real sinphi = std::sin(_mc_phi.value(intnl));
  const Real dsinphi = std::cos(_mc_phi.value(intnl)) * _mc_phi.derivative(intnl);
  switch (_mc_interpolation_scheme)
  {
    case 0: // outer_tip
      daaa = 2.0 * std::sqrt(3.0) *
             (dC * cosphi / (3.0 - sinphi) + C * dcosphi / (3.0 - sinphi) +
              C * cosphi * dsinphi / Utility::pow<2>(3.0 - sinphi));
      dbbb = 2.0 / std::sqrt(3.0) *
             (dsinphi / (3.0 - sinphi) + sinphi * dsinphi / Utility::pow<2>(3.0 - sinphi));
      break;
    case 1: // inner_tip
      daaa = 2.0 * std::sqrt(3.0) *
             (dC * cosphi / (3.0 + sinphi) + C * dcosphi / (3.0 + sinphi) -
              C * cosphi * dsinphi / Utility::pow<2>(3.0 + sinphi));
      dbbb = 2.0 / std::sqrt(3.0) *
             (dsinphi / (3.0 + sinphi) - sinphi * dsinphi / Utility::pow<2>(3.0 + sinphi));
      break;
    case 2: // lode_zero
      daaa = dC * cosphi + C * dcosphi;
      dbbb = dsinphi / 3.0;
      break;
    case 3: // inner_edge
      daaa = 3.0 * dC * cosphi / std::sqrt(9.0 + 3.0 * Utility::pow<2>(sinphi)) +
             3.0 * C * dcosphi / std::sqrt(9.0 + 3.0 * Utility::pow<2>(sinphi)) -
             3.0 * C * cosphi * 3.0 * sinphi * dsinphi /
                 std::pow(9.0 + 3.0 * Utility::pow<2>(sinphi), 1.5);
      dbbb = dsinphi / std::sqrt(9.0 + 3.0 * Utility::pow<2>(sinphi)) -
             3.0 * sinphi * sinphi * dsinphi / std::pow(9.0 + 3.0 * Utility::pow<2>(sinphi), 1.5);
      break;
    case 4: // native
      daaa = dC;
      dbbb = dsinphi / cosphi - sinphi * dcosphi / Utility::pow<2>(cosphi);
      break;
  }
}

Referenced by CappedDruckerPragerStressUpdate::computeAllQ(), TensorMechanicsPlasticDruckerPrager::dyieldFunction_dintnl(), and returnMap().

df_dsig()

RankTwoTensor TensorMechanicsPlasticDruckerPragerHyperbolic::df_dsig ( const RankTwoTensor &  stress, Real  bbb  ) const

overrideprotectedvirtual

Function that's used in dyieldFunction_dstress and flowPotential.

Reimplemented from TensorMechanicsPlasticDruckerPrager.

Definition at line 72 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

{
  return 0.5 * stress.dsecondInvariant() / std::sqrt(stress.secondInvariant() + _smoother2) +
         stress.dtrace() * bbb;
}

dflowPotential_dintnl()

RankTwoTensor TensorMechanicsPlasticDruckerPrager::dflowPotential_dintnl ( const RankTwoTensor &  stress, Real  intnl  ) const

overrideprotectedvirtualinherited

The derivative of the flow potential with respect to the internal parameter.

Parameters

stress	the stress at which to calculate the flow potential
intnl	internal parameter

Returns

dr_dintnl(i, j) = dr(i, j)/dintnl

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 134 of file TensorMechanicsPlasticDruckerPrager.C.

{
  Real dbbb;
  donlyB(intnl, dilation, dbbb);
  return stress.dtrace() * dbbb;
}

dflowPotential_dintnlV()

void TensorMechanicsPlasticModel::dflowPotential_dintnlV ( const RankTwoTensor &  stress, Real  intnl, std::vector< RankTwoTensor > &  dr_dintnl  ) const

virtualinherited

The derivative of the flow potential with respect to the internal parameter.

Parameters

	stress	the stress at which to calculate the flow potential
	intnl	internal parameter
[out]	dr_dintnl	dr_dintnl[alpha](i, j) = dr[alpha](i, j)/dintnl

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 139 of file TensorMechanicsPlasticModel.C.

{
  return dr_dintnl.assign(1, dflowPotential_dintnl(stress, intnl));
}

dflowPotential_dstress()

RankFourTensor TensorMechanicsPlasticDruckerPragerHyperbolic::dflowPotential_dstress ( const RankTwoTensor &  stress, Real  intnl  ) const

overrideprotectedvirtual

The derivative of the flow potential with respect to stress.

Parameters

stress	the stress at which to calculate the flow potential
intnl	internal parameter

Returns

dr_dstress(i, j, k, l) = dr(i, j)/dstress(k, l)

Reimplemented from TensorMechanicsPlasticDruckerPrager.

Definition at line 79 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

{
  RankFourTensor dr_dstress;
  dr_dstress = 0.5 * stress.d2secondInvariant() / std::sqrt(stress.secondInvariant() + _smoother2);
  dr_dstress += -0.5 * 0.5 * stress.dsecondInvariant().outerProduct(stress.dsecondInvariant()) /
                std::pow(stress.secondInvariant() + _smoother2, 1.5);
  return dr_dstress;
}

dflowPotential_dstressV()

void TensorMechanicsPlasticModel::dflowPotential_dstressV ( const RankTwoTensor &  stress, Real  intnl, std::vector< RankFourTensor > &  dr_dstress  ) const

virtualinherited

The derivative of the flow potential with respect to stress.

Parameters

	stress	the stress at which to calculate the flow potential
	intnl	internal parameter
[out]	dr_dstress	dr_dstress[alpha](i, j, k, l) = dr[alpha](i, j)/dstress(k, l)

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 125 of file TensorMechanicsPlasticModel.C.

{
  return dr_dstress.assign(1, dflowPotential_dstress(stress, intnl));
}

dhardPotential_dintnl()

Real TensorMechanicsPlasticModel::dhardPotential_dintnl ( const RankTwoTensor &  stress, Real  intnl  ) const

protectedvirtualinherited

The derivative of the hardening potential with respect to the internal parameter.

Parameters

stress	the stress at which to calculate the hardening potentials
intnl	internal parameter

Returns

the derivative

Reimplemented in TensorMechanicsPlasticMeanCapTC.

Definition at line 174 of file TensorMechanicsPlasticModel.C.

{
  return 0.0;
}

Referenced by TensorMechanicsPlasticModel::dhardPotential_dintnlV().

dhardPotential_dintnlV()

void TensorMechanicsPlasticModel::dhardPotential_dintnlV ( const RankTwoTensor &  stress, Real  intnl, std::vector< Real > &  dh_dintnl  ) const

virtualinherited

The derivative of the hardening potential with respect to the internal parameter.

Parameters

	stress	the stress at which to calculate the hardening potentials
	intnl	internal parameter
[out]	dh_dintnl	dh_dintnl[alpha] = dh[alpha]/dintnl

Definition at line 180 of file TensorMechanicsPlasticModel.C.

{
  dh_dintnl.resize(numberSurfaces(), dhardPotential_dintnl(stress, intnl));
}

dhardPotential_dstress()

RankTwoTensor TensorMechanicsPlasticModel::dhardPotential_dstress ( const RankTwoTensor &  stress, Real  intnl  ) const

protectedvirtualinherited

The derivative of the hardening potential with respect to stress.

Parameters

stress	the stress at which to calculate the hardening potentials
intnl	internal parameter

Returns

dh_dstress(i, j) = dh/dstress(i, j)

Reimplemented in TensorMechanicsPlasticMeanCapTC.

Definition at line 160 of file TensorMechanicsPlasticModel.C.

{
  return RankTwoTensor();
}

Referenced by TensorMechanicsPlasticModel::dhardPotential_dstressV().

dhardPotential_dstressV()

void TensorMechanicsPlasticModel::dhardPotential_dstressV ( const RankTwoTensor &  stress, Real  intnl, std::vector< RankTwoTensor > &  dh_dstress  ) const

virtualinherited

The derivative of the hardening potential with respect to stress.

Parameters

	stress	the stress at which to calculate the hardening potentials
	intnl	internal parameter
[out]	dh_dstress	dh_dstress[alpha](i, j) = dh[alpha]/dstress(i, j)

Definition at line 166 of file TensorMechanicsPlasticModel.C.

{
  dh_dstress.assign(numberSurfaces(), dhardPotential_dstress(stress, intnl));
}

donlyB()

void TensorMechanicsPlasticDruckerPrager::donlyB ( Real  intnl, int  fd, Real &  dbbb  ) const

inherited

Calculate d(bbb)/d(intnl) or d(bbb_flow)/d(intnl)

Parameters

intnl	the internal parameter
fd	if fd==friction then bbb is calculated. if fd==dilation then bbb_flow is calculated
bbb	either bbb or bbb_flow, depending on fd

Definition at line 177 of file TensorMechanicsPlasticDruckerPrager.C.

{
  if (_zero_phi_hardening && (fd == friction))
  {
    dbbb = 0;
    return;
  }
  if (_zero_psi_hardening && (fd == dilation))
  {
    dbbb = 0;
    return;
  }
  const Real s = (fd == friction) ? std::sin(_mc_phi.value(intnl)) : std::sin(_mc_psi.value(intnl));
  const Real ds = (fd == friction) ? std::cos(_mc_phi.value(intnl)) * _mc_phi.derivative(intnl)
                                   : std::cos(_mc_psi.value(intnl)) * _mc_psi.derivative(intnl);
  switch (_mc_interpolation_scheme)
  {
    case 0: // outer_tip
      dbbb = 2.0 / std::sqrt(3.0) * (ds / (3.0 - s) + s * ds / Utility::pow<2>(3.0 - s));
      break;
    case 1: // inner_tip
      dbbb = 2.0 / std::sqrt(3.0) * (ds / (3.0 + s) - s * ds / Utility::pow<2>(3.0 + s));
      break;
    case 2: // lode_zero
      dbbb = ds / 3.0;
      break;
    case 3: // inner_edge
      dbbb = ds / std::sqrt(9.0 + 3.0 * Utility::pow<2>(s)) -
             3 * s * s * ds / std::pow(9.0 + 3.0 * Utility::pow<2>(s), 1.5);
      break;
    case 4: // native
      const Real c =
          (fd == friction) ? std::cos(_mc_phi.value(intnl)) : std::cos(_mc_psi.value(intnl));
      const Real dc = (fd == friction)
                          ? -std::sin(_mc_phi.value(intnl)) * _mc_phi.derivative(intnl)
                          : -std::sin(_mc_psi.value(intnl)) * _mc_psi.derivative(intnl);
      dbbb = ds / c - s * dc / Utility::pow<2>(c);
      break;
  }
}

Referenced by CappedDruckerPragerStressUpdate::computeAllQ(), consistentTangentOperator(), TensorMechanicsPlasticDruckerPrager::dflowPotential_dintnl(), returnMap(), and CappedDruckerPragerStressUpdate::setIntnlDerivatives().

dyieldFunction_dintnl()

Real TensorMechanicsPlasticDruckerPrager::dyieldFunction_dintnl ( const RankTwoTensor &  stress, Real  intnl  ) const

overrideprotectedvirtualinherited

The derivative of yield function with respect to the internal parameter.

Parameters

stress	the stress at which to calculate the yield function
intnl	internal parameter

Returns

the derivative

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 105 of file TensorMechanicsPlasticDruckerPrager.C.

{
  Real daaa;
  Real dbbb;
  dbothAB(intnl, daaa, dbbb);
  return stress.trace() * dbbb - daaa;
}

Referenced by consistentTangentOperator().

dyieldFunction_dintnlV()

void TensorMechanicsPlasticModel::dyieldFunction_dintnlV ( const RankTwoTensor &  stress, Real  intnl, std::vector< Real > &  df_dintnl  ) const

virtualinherited

The derivative of yield functions with respect to the internal parameter.

Parameters

	stress	the stress at which to calculate the yield function
	intnl	internal parameter
[out]	df_dintnl	df_dintnl[alpha] = df[alpha]/dintnl

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 98 of file TensorMechanicsPlasticModel.C.

{
  return df_dintnl.assign(1, dyieldFunction_dintnl(stress, intnl));
}

dyieldFunction_dstress()

RankTwoTensor TensorMechanicsPlasticDruckerPrager::dyieldFunction_dstress ( const RankTwoTensor &  stress, Real  intnl  ) const

overrideprotectedvirtualinherited

The derivative of yield function with respect to stress.

Parameters

stress	the stress at which to calculate the yield function
intnl	internal parameter

Returns

df_dstress(i, j) = dyieldFunction/dstress(i, j)

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 96 of file TensorMechanicsPlasticDruckerPrager.C.

{
  Real bbb;
  onlyB(intnl, friction, bbb);
  return df_dsig(stress, bbb);
}

dyieldFunction_dstressV()

void TensorMechanicsPlasticModel::dyieldFunction_dstressV ( const RankTwoTensor &  stress, Real  intnl, std::vector< RankTwoTensor > &  df_dstress  ) const

virtualinherited

The derivative of yield functions with respect to stress.

Parameters

	stress	the stress at which to calculate the yield function
	intnl	internal parameter
[out]	df_dstress	df_dstress[alpha](i, j) = dyieldFunction[alpha]/dstress(i, j)

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 84 of file TensorMechanicsPlasticModel.C.

{
  df_dstress.assign(1, dyieldFunction_dstress(stress, intnl));
}

execute()

void TensorMechanicsPlasticModel::execute ( )

inherited

Definition at line 47 of file TensorMechanicsPlasticModel.C.

{
}

finalize()

void TensorMechanicsPlasticModel::finalize ( )

inherited

Definition at line 52 of file TensorMechanicsPlasticModel.C.

{
}

flowPotential()

RankTwoTensor TensorMechanicsPlasticDruckerPrager::flowPotential ( const RankTwoTensor &  stress, Real  intnl  ) const

overrideprotectedvirtualinherited

The flow potential.

Parameters

stress	the stress at which to calculate the flow potential
intnl	internal parameter

Returns

the flow potential

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 115 of file TensorMechanicsPlasticDruckerPrager.C.

{
  Real bbb_flow;
  onlyB(intnl, dilation, bbb_flow);
  return df_dsig(stress, bbb_flow);
}

flowPotentialV()

void TensorMechanicsPlasticModel::flowPotentialV ( const RankTwoTensor &  stress, Real  intnl, std::vector< RankTwoTensor > &  r  ) const

virtualinherited

The flow potentials.

Parameters

	stress	the stress at which to calculate the flow potential
	intnl	internal parameter
[out]	r	r[alpha] is the flow potential for the "alpha" yield function

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 111 of file TensorMechanicsPlasticModel.C.

{
  return r.assign(1, flowPotential(stress, intnl));
}

hardPotential()

Real TensorMechanicsPlasticModel::hardPotential ( const RankTwoTensor &  stress, Real  intnl  ) const

protectedvirtualinherited

The hardening potential.

Parameters

stress	the stress at which to calculate the hardening potential
intnl	internal parameter

Returns

the hardening potential

Reimplemented in TensorMechanicsPlasticMeanCapTC.

Definition at line 147 of file TensorMechanicsPlasticModel.C.

{
  return -1.0;
}

Referenced by TensorMechanicsPlasticModel::hardPotentialV().

hardPotentialV()

void TensorMechanicsPlasticModel::hardPotentialV ( const RankTwoTensor &  stress, Real  intnl, std::vector< Real > &  h  ) const

virtualinherited

The hardening potential.

Parameters

	stress	the stress at which to calculate the hardening potential
	intnl	internal parameter
[out]	h	h[alpha] is the hardening potential for the "alpha" yield function

Definition at line 152 of file TensorMechanicsPlasticModel.C.

{
  h.assign(numberSurfaces(), hardPotential(stress, intnl));
}

initialize()

void TensorMechanicsPlasticModel::initialize ( )

inherited

Definition at line 42 of file TensorMechanicsPlasticModel.C.

{
}

initializeAandB()

void TensorMechanicsPlasticDruckerPrager::initializeAandB ( Real  intnl, Real &  aaa, Real &  bbb  ) const

privateinherited

Returns the Drucker-Prager parameters A nice reference on the different relationships between Drucker-Prager and Mohr-Coulomb is H Jiang and X Yongli, A note on the Mohr-Coulomb and Drucker-Prager strength criteria, Mechanics Research Communications 38 (2011) 309-314.

This function uses Table1 in that reference, with the following translations aaa = k bbb = -alpha/3

Parameters

	intnl	The internal parameter
[out]	aaa	The Drucker-Prager aaa quantity
[out]	bbb	The Drucker-Prager bbb quantity

Definition at line 270 of file TensorMechanicsPlasticDruckerPrager.C.

{
  const Real C = _mc_cohesion.value(intnl);
  const Real cosphi = std::cos(_mc_phi.value(intnl));
  const Real sinphi = std::sin(_mc_phi.value(intnl));
  switch (_mc_interpolation_scheme)
  {
    case 0: // outer_tip
      aaa = 2.0 * std::sqrt(3.0) * C * cosphi / (3.0 - sinphi);
      bbb = 2.0 * sinphi / std::sqrt(3.0) / (3.0 - sinphi);
      break;
    case 1: // inner_tip
      aaa = 2.0 * std::sqrt(3.0) * C * cosphi / (3.0 + sinphi);
      bbb = 2.0 * sinphi / std::sqrt(3.0) / (3.0 + sinphi);
      break;
    case 2: // lode_zero
      aaa = C * cosphi;
      bbb = sinphi / 3.0;
      break;
    case 3: // inner_edge
      aaa = 3.0 * C * cosphi / std::sqrt(9.0 + 3.0 * Utility::pow<2>(sinphi));
      bbb = sinphi / std::sqrt(9.0 + 3.0 * Utility::pow<2>(sinphi));
      break;
    case 4: // native
      aaa = C;
      bbb = sinphi / cosphi;
      break;
  }
}

Referenced by TensorMechanicsPlasticDruckerPrager::bothAB(), and TensorMechanicsPlasticDruckerPrager::TensorMechanicsPlasticDruckerPrager().

initializeB()

void TensorMechanicsPlasticDruckerPrager::initializeB ( Real  intnl, int  fd, Real &  bbb  ) const

privateinherited

Returns the Drucker-Prager parameters A nice reference on the different relationships between Drucker-Prager and Mohr-Coulomb is H Jiang and X Yongli, A note on the Mohr-Coulomb and Drucker-Prager strength criteria, Mechanics Research Communications 38 (2011) 309-314.

This function uses Table1 in that reference, with the following translations aaa = k bbb = -alpha/3

Parameters

	intnl	The internal parameter
	fd	If fd == frction then the friction angle is used to set bbb, otherwise the dilation angle is used
[out]	bbb	The Drucker-Prager bbb quantity

Definition at line 301 of file TensorMechanicsPlasticDruckerPrager.C.

{
  const Real s = (fd == friction) ? std::sin(_mc_phi.value(intnl)) : std::sin(_mc_psi.value(intnl));
  switch (_mc_interpolation_scheme)
  {
    case 0: // outer_tip
      bbb = 2.0 * s / std::sqrt(3.0) / (3.0 - s);
      break;
    case 1: // inner_tip
      bbb = 2.0 * s / std::sqrt(3.0) / (3.0 + s);
      break;
    case 2: // lode_zero
      bbb = s / 3.0;
      break;
    case 3: // inner_edge
      bbb = s / std::sqrt(9.0 + 3.0 * Utility::pow<2>(s));
      break;
    case 4: // native
      const Real c =
          (fd == friction) ? std::cos(_mc_phi.value(intnl)) : std::cos(_mc_psi.value(intnl));
      bbb = s / c;
      break;
  }
}

Referenced by TensorMechanicsPlasticDruckerPrager::onlyB(), and TensorMechanicsPlasticDruckerPrager::TensorMechanicsPlasticDruckerPrager().

KuhnTuckerSingleSurface()

bool TensorMechanicsPlasticModel::KuhnTuckerSingleSurface ( Real  yf, Real  dpm, Real  dpm_tol  ) const

inherited

Returns true if the Kuhn-Tucker conditions for the single surface are satisfied.

Parameters

yf	Yield function value
dpm	plastic multiplier
dpm_tol	tolerance on plastic multiplier: viz dpm>-dpm_tol means "dpm is non-negative"

Definition at line 248 of file TensorMechanicsPlasticModel.C.

{
  return (dpm == 0 && yf <= _f_tol) || (dpm > -dpm_tol && yf <= _f_tol && yf >= -_f_tol);
}

Referenced by TensorMechanicsPlasticMohrCoulombMulti::KuhnTuckerOK(), TensorMechanicsPlasticTensileMulti::KuhnTuckerOK(), and TensorMechanicsPlasticModel::returnMap().

modelName()

std::string TensorMechanicsPlasticDruckerPragerHyperbolic::modelName ( ) const

overridevirtual

Reimplemented from TensorMechanicsPlasticDruckerPrager.

Definition at line 90 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

{
  return "DruckerPragerHyperbolic";
}

numberSurfaces()

unsigned TensorMechanicsPlasticModel::numberSurfaces ( ) const

virtualinherited

The number of yield surfaces for this plasticity model.

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 57 of file TensorMechanicsPlasticModel.C.

{
  return 1;
}

Referenced by TensorMechanicsPlasticModel::activeConstraints(), TensorMechanicsPlasticModel::dhardPotential_dintnlV(), TensorMechanicsPlasticModel::dhardPotential_dstressV(), TensorMechanicsPlasticModel::hardPotentialV(), and TensorMechanicsPlasticModel::returnMap().

onlyB()

void TensorMechanicsPlasticDruckerPrager::onlyB ( Real  intnl, int  fd, Real &  bbb  ) const

inherited

Calculate bbb or bbb_flow.

Parameters

intnl	the internal parameter
fd	if fd==friction then bbb is calculated. if fd==dilation then bbb_flow is calculated
bbb	either bbb or bbb_flow, depending on fd

Definition at line 161 of file TensorMechanicsPlasticDruckerPrager.C.

{
  if (_zero_phi_hardening && (fd == friction))
  {
    bbb = _bbb;
    return;
  }
  if (_zero_psi_hardening && (fd == dilation))
  {
    bbb = _bbb_flow;
    return;
  }
  initializeB(intnl, fd, bbb);
}

Referenced by CappedDruckerPragerStressUpdate::computeAllQ(), consistentTangentOperator(), TensorMechanicsPlasticDruckerPrager::dyieldFunction_dstress(), TensorMechanicsPlasticDruckerPrager::flowPotential(), CappedDruckerPragerStressUpdate::initializeVars(), returnMap(), CappedDruckerPragerStressUpdate::setIntnlDerivatives(), and CappedDruckerPragerStressUpdate::setIntnlValues().

returnMap()

bool TensorMechanicsPlasticDruckerPragerHyperbolic::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

overrideprotectedvirtual

Performs a custom return-map.

You may choose to over-ride this in your derived TensorMechanicsPlasticXXXX class, and you may implement the return-map algorithm in any way that suits you. Eg, using a Newton-Raphson approach, or a radial-return, etc. This may also be used as a quick way of ascertaining whether (trial_stress, intnl_old) is in fact admissible.

For over-riding this function, please note the following.

(1) Denoting the return value of the function by "successful_return", the only possible output values should be: (A) trial_stress_inadmissible=false, successful_return=true. That is, (trial_stress, intnl_old) is in fact admissible (in the elastic domain). (B) trial_stress_inadmissible=true, successful_return=false. That is (trial_stress, intnl_old) is inadmissible (outside the yield surface), and you didn't return to the yield surface. (C) trial_stress_inadmissible=true, successful_return=true. That is (trial_stress, intnl_old) is inadmissible (outside the yield surface), but you did return to the yield surface. The default implementation only handles case (A) and (B): it does not attempt to do a return-map algorithm.

(2) you must correctly signal "successful_return" using the return value of this function. Don't assume the calling function will do Kuhn-Tucker checking and so forth!

(3) In cases (A) and (B) you needn't set returned_stress, returned_intnl, delta_dp, or dpm. This is for computational efficiency.

(4) In cases (A) and (B), you MUST place the yield function values at (trial_stress, intnl_old) into yf so the calling function can use this information optimally. You will have already calculated these yield function values, which can be quite expensive, and it's not very optimal for the calling function to have to re-calculate them.

(5) In case (C), you need to set: returned_stress (the returned value of stress) returned_intnl (the returned value of the internal variable) delta_dp (the change in plastic strain) dpm (the plastic multipliers needed to bring about the return) yf (yield function values at the returned configuration)

(Note, if you over-ride returnMap, you will probably want to override consistentTangentOpertor too, otherwise it will default to E_ijkl.)

Parameters

	trial_stress	The trial stress
	intnl_old	Value of the internal parameter
	E_ijkl	Elasticity tensor
	ep_plastic_tolerance	Tolerance defined by the user for the plastic strain
[out]	returned_stress	In case (C): lies on the yield surface after returning and produces the correct plastic strain (normality condition). Otherwise: not defined
[out]	returned_intnl	In case (C): the value of the internal parameter after returning. Otherwise: not defined
[out]	dpm	In case (C): the plastic multipliers needed to bring about the return. Otherwise: not defined
[out]	delta_dp	In case (C): The change in plastic strain induced by the return process. Otherwise: not defined
[out]	yf	In case (C): the yield function at (returned_stress, returned_intnl). Otherwise: the yield function at (trial_stress, intnl_old)
[out]	trial_stress_inadmissible	Should be set to false if the trial_stress is admissible, and true if the trial_stress is inadmissible. This can be used by the calling prorgram

Returns

true if a successful return (or a return-map not needed), false if the trial_stress is inadmissible but the return process failed

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 96 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

{
  if (!(_use_custom_returnMap))
    return TensorMechanicsPlasticModel::returnMap(trial_stress,
                                                  intnl_old,
                                                  E_ijkl,
                                                  ep_plastic_tolerance,
                                                  returned_stress,
                                                  returned_intnl,
                                                  dpm,
                                                  delta_dp,
                                                  yf,
                                                  trial_stress_inadmissible);
 
  yf.resize(1);
 
  yf[0] = yieldFunction(trial_stress, intnl_old);
 
  if (yf[0] < _f_tol)
  {
    // the trial_stress is admissible
    trial_stress_inadmissible = false;
    return true;
  }
 
  trial_stress_inadmissible = true;
  const Real mu = E_ijkl(0, 1, 0, 1);
  const Real lambda = E_ijkl(0, 0, 0, 0) - 2.0 * mu;
  const Real bulky = 3.0 * lambda + 2.0 * mu;
  const Real Tr_trial = trial_stress.trace();
  const Real J2trial = trial_stress.secondInvariant();
 
  // Perform a Newton-Raphson to find dpm when
  // residual = (1 + dpm*mu/ll)sqrt(ll^2 - s^2) - sqrt(J2trial) = 0, with s=smoother
  // with ll = sqrt(J2 + s^2) = aaa - bbb*Tr(stress) = aaa - bbb(Tr_trial - p*3*bulky*bbb_flow)
  Real aaa;
  Real daaa;
  Real bbb;
  Real dbbb;
  Real bbb_flow;
  Real dbbb_flow;
  Real ll;
  Real dll;
  Real residual;
  Real jac;
  dpm[0] = 0;
  unsigned int iter = 0;
  do
  {
    bothAB(intnl_old + dpm[0], aaa, bbb);
    dbothAB(intnl_old + dpm[0], daaa, dbbb);
    onlyB(intnl_old + dpm[0], dilation, bbb_flow);
    donlyB(intnl_old + dpm[0], dilation, dbbb_flow);
    ll = aaa - bbb * (Tr_trial - dpm[0] * bulky * 3 * bbb_flow);
    dll = daaa - dbbb * (Tr_trial - dpm[0] * bulky * 3 * bbb_flow) +
          bbb * bulky * 3 * (bbb_flow + dpm[0] * dbbb_flow);
    residual = bbb * (Tr_trial - dpm[0] * bulky * 3 * bbb_flow) - aaa +
               std::sqrt(J2trial / Utility::pow<2>(1 + dpm[0] * mu / ll) + _smoother2);
    jac = dbbb * (Tr_trial - dpm[0] * bulky * 3 * bbb_flow) -
          bbb * bulky * 3 * (bbb_flow + dpm[0] * dbbb_flow) - daaa +
          0.5 * J2trial * (-2.0) * (mu / ll - dpm[0] * mu * dll / ll / ll) /
              Utility::pow<3>(1 + dpm[0] * mu / ll) /
              std::sqrt(J2trial / Utility::pow<2>(1.0 + dpm[0] * mu / ll) + _smoother2);
    dpm[0] += -residual / jac;
    if (iter > _max_iters) // not converging
      return false;
    iter++;
  } while (residual * residual > _f_tol * _f_tol);
 
  // set the returned values
  yf[0] = 0;
  returned_intnl = intnl_old + dpm[0];
 
  bothAB(returned_intnl, aaa, bbb);
  onlyB(returned_intnl, dilation, bbb_flow);
  ll = aaa - bbb * (Tr_trial - dpm[0] * bulky * 3.0 * bbb_flow);
  returned_stress =
      trial_stress.deviatoric() / (1.0 + dpm[0] * mu / ll); // this is the deviatoric part only
 
  RankTwoTensor rij = 0.5 * returned_stress.deviatoric() /
                      ll; // this is the derivatoric part the flow potential only
 
  // form the returned stress and the full flow potential
  const Real returned_trace_over_3 = (aaa - ll) / bbb / 3.0;
  for (unsigned i = 0; i < 3; ++i)
  {
    returned_stress(i, i) += returned_trace_over_3;
    rij(i, i) += bbb_flow;
  }
 
  delta_dp = rij * dpm[0];
 
  return true;
}

useCustomCTO()

bool TensorMechanicsPlasticDruckerPragerHyperbolic::useCustomCTO ( ) const

overridevirtual

Returns false. You will want to override this in your derived class if you write a custom consistent tangent operator function.

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 270 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

{
  return _use_custom_cto;
}

useCustomReturnMap()

bool TensorMechanicsPlasticDruckerPragerHyperbolic::useCustomReturnMap ( ) const

overridevirtual

Returns false. You will want to override this in your derived class if you write a custom returnMap function.

Reimplemented from TensorMechanicsPlasticModel.

Definition at line 264 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

{
  return _use_custom_returnMap;
}

validParams()

InputParameters TensorMechanicsPlasticDruckerPragerHyperbolic::validParams ( )

static

Definition at line 19 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

{
  InputParameters params = TensorMechanicsPlasticDruckerPrager::validParams();
  params.addParam<bool>("use_custom_returnMap",
                        true,
                        "Whether to use the custom returnMap "
                        "algorithm.  Set to true if you are using "
                        "isotropic elasticity.");
  params.addParam<bool>("use_custom_cto",
                        true,
                        "Whether to use the custom consistent tangent "
                        "operator computations.  Set to true if you are "
                        "using isotropic elasticity.");
  params.addClassDescription("J2 plasticity, associative, with hardening");
  params.addRangeCheckedParam<Real>("smoother",
                                    0.0,
                                    "smoother>=0",
                                    "The cone vertex at J2=0 is smoothed.  The maximum mean "
                                    "stress possible, which is Cohesion*Cot(friction_angle) for "
                                    "smoother=0, becomes (Cohesion - "
                                    "smoother/3)*Cot(friction_angle).  This is a non-hardening "
                                    "parameter");
  params.addRangeCheckedParam<unsigned>(
      "max_iterations",
      40,
      "max_iterations>0",
      "Maximum iterations to use in the custom return map function");
  params.addClassDescription(
      "Non-associative Drucker Prager plasticity with hyperbolic smoothing of the cone tip.");
  return params;
}

yieldFunction()

Real TensorMechanicsPlasticDruckerPragerHyperbolic::yieldFunction ( const RankTwoTensor &  stress, Real  intnl  ) const

overrideprotectedvirtual

The following functions are what you should override when building single-plasticity models.

The yield function

Parameters

stress	the stress at which to calculate the yield function
intnl	internal parameter

Returns

the yield function

Reimplemented from TensorMechanicsPlasticDruckerPrager.

Definition at line 62 of file TensorMechanicsPlasticDruckerPragerHyperbolic.C.

{
  Real aaa;
  Real bbb;
  bothAB(intnl, aaa, bbb);
  return std::sqrt(stress.secondInvariant() + _smoother2) + stress.trace() * bbb - aaa;
}

Referenced by returnMap().

yieldFunctionV()

void TensorMechanicsPlasticModel::yieldFunctionV ( const RankTwoTensor &  stress, Real  intnl, std::vector< Real > &  f  ) const

virtualinherited

Calculates the yield functions.

Note that for single-surface plasticity you don't want to override this - override the private yieldFunction below

Parameters

	stress	the stress at which to calculate the yield function
	intnl	internal parameter
[out]	f	the yield functions

Reimplemented in TensorMechanicsPlasticMohrCoulombMulti, and TensorMechanicsPlasticTensileMulti.

Definition at line 69 of file TensorMechanicsPlasticModel.C.

{
  f.assign(1, yieldFunction(stress, intnl));
}

Referenced by TensorMechanicsPlasticModel::returnMap().

Member Data Documentation

_aaa

Real TensorMechanicsPlasticDruckerPrager::_aaa

privateinherited

Definition at line 113 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::bothAB(), and TensorMechanicsPlasticDruckerPrager::TensorMechanicsPlasticDruckerPrager().

_bbb

Real TensorMechanicsPlasticDruckerPrager::_bbb

privateinherited

Definition at line 114 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::bothAB(), TensorMechanicsPlasticDruckerPrager::onlyB(), and TensorMechanicsPlasticDruckerPrager::TensorMechanicsPlasticDruckerPrager().

_bbb_flow

Real TensorMechanicsPlasticDruckerPrager::_bbb_flow

privateinherited

Definition at line 115 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::onlyB(), and TensorMechanicsPlasticDruckerPrager::TensorMechanicsPlasticDruckerPrager().

_f_tol

const Real TensorMechanicsPlasticModel::_f_tol

inherited

Tolerance on yield function.

Definition at line 175 of file TensorMechanicsPlasticModel.h.

Referenced by TensorMechanicsPlasticWeakPlaneShear::activeConstraints(), TensorMechanicsPlasticWeakPlaneTensile::activeConstraints(), TensorMechanicsPlasticMeanCapTC::activeConstraints(), TensorMechanicsPlasticTensileMulti::activeConstraints(), TensorMechanicsPlasticMohrCoulombMulti::activeConstraints(), TensorMechanicsPlasticModel::activeConstraints(), TensorMechanicsPlasticMohrCoulombMulti::doReturnMap(), TensorMechanicsPlasticTensileMulti::doReturnMap(), TensorMechanicsPlasticModel::KuhnTuckerSingleSurface(), TensorMechanicsPlasticTensileMulti::returnEdge(), TensorMechanicsPlasticMohrCoulombMulti::returnEdge000101(), TensorMechanicsPlasticMohrCoulombMulti::returnEdge010100(), TensorMechanicsPlasticJ2::returnMap(), returnMap(), TensorMechanicsPlasticMeanCapTC::returnMap(), TensorMechanicsPlasticModel::returnMap(), TensorMechanicsPlasticTensileMulti::returnPlane(), TensorMechanicsPlasticMohrCoulombMulti::returnPlane(), TensorMechanicsPlasticTensileMulti::returnTip(), TensorMechanicsPlasticMohrCoulombMulti::returnTip(), TensorMechanicsPlasticMohrCoulombMulti::TensorMechanicsPlasticMohrCoulombMulti(), and TensorMechanicsPlasticTensileMulti::TensorMechanicsPlasticTensileMulti().

_ic_tol

const Real TensorMechanicsPlasticModel::_ic_tol

inherited

Tolerance on internal constraint.

Definition at line 178 of file TensorMechanicsPlasticModel.h.

_max_iters

const unsigned TensorMechanicsPlasticDruckerPragerHyperbolic::_max_iters

private

max iters for custom return map loop

Definition at line 77 of file TensorMechanicsPlasticDruckerPragerHyperbolic.h.

Referenced by returnMap().

_mc_cohesion

const TensorMechanicsHardeningModel& TensorMechanicsPlasticDruckerPrager::_mc_cohesion

protectedinherited

Hardening model for cohesion.

Definition at line 70 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::dbothAB(), TensorMechanicsPlasticDruckerPrager::initializeAandB(), and TensorMechanicsPlasticDruckerPrager::TensorMechanicsPlasticDruckerPrager().

_mc_interpolation_scheme

const MooseEnum TensorMechanicsPlasticDruckerPrager::_mc_interpolation_scheme

protectedinherited

The parameters aaa and bbb are chosen to closely match the Mohr-Coulomb yield surface.

Various matching schemes may be used and this parameter holds the user's choice.

Definition at line 98 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::dbothAB(), TensorMechanicsPlasticDruckerPrager::donlyB(), TensorMechanicsPlasticDruckerPrager::initializeAandB(), and TensorMechanicsPlasticDruckerPrager::initializeB().

_mc_phi

const TensorMechanicsHardeningModel& TensorMechanicsPlasticDruckerPrager::_mc_phi

protectedinherited

Hardening model for tan(phi)

Definition at line 73 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::dbothAB(), TensorMechanicsPlasticDruckerPrager::donlyB(), TensorMechanicsPlasticDruckerPrager::initializeAandB(), TensorMechanicsPlasticDruckerPrager::initializeB(), and TensorMechanicsPlasticDruckerPrager::TensorMechanicsPlasticDruckerPrager().

_mc_psi

const TensorMechanicsHardeningModel& TensorMechanicsPlasticDruckerPrager::_mc_psi

protectedinherited

Hardening model for tan(psi)

Definition at line 76 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::donlyB(), TensorMechanicsPlasticDruckerPrager::initializeB(), and TensorMechanicsPlasticDruckerPrager::TensorMechanicsPlasticDruckerPrager().

_smoother2

const Real TensorMechanicsPlasticDruckerPragerHyperbolic::_smoother2

private

smoothing parameter for the cone's tip

Definition at line 68 of file TensorMechanicsPlasticDruckerPragerHyperbolic.h.

Referenced by consistentTangentOperator(), df_dsig(), dflowPotential_dstress(), returnMap(), and yieldFunction().

_use_custom_cto

const bool TensorMechanicsPlasticDruckerPragerHyperbolic::_use_custom_cto

private

Whether to use the custom consistent tangent operator calculation.

Definition at line 74 of file TensorMechanicsPlasticDruckerPragerHyperbolic.h.

Referenced by consistentTangentOperator(), and useCustomCTO().

_use_custom_returnMap

const bool TensorMechanicsPlasticDruckerPragerHyperbolic::_use_custom_returnMap

private

whether to use the custom returnMap function

Definition at line 71 of file TensorMechanicsPlasticDruckerPragerHyperbolic.h.

Referenced by returnMap(), and useCustomReturnMap().

_zero_cohesion_hardening

const bool TensorMechanicsPlasticDruckerPrager::_zero_cohesion_hardening

protectedinherited

True if there is no hardening of cohesion.

Definition at line 101 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::bothAB(), and TensorMechanicsPlasticDruckerPrager::dbothAB().

_zero_phi_hardening

const bool TensorMechanicsPlasticDruckerPrager::_zero_phi_hardening

protectedinherited

True if there is no hardening of friction angle.

Definition at line 104 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::bothAB(), TensorMechanicsPlasticDruckerPrager::dbothAB(), TensorMechanicsPlasticDruckerPrager::donlyB(), and TensorMechanicsPlasticDruckerPrager::onlyB().

_zero_psi_hardening

const bool TensorMechanicsPlasticDruckerPrager::_zero_psi_hardening

protectedinherited

True if there is no hardening of dilation angle.

Definition at line 107 of file TensorMechanicsPlasticDruckerPrager.h.

Referenced by TensorMechanicsPlasticDruckerPrager::donlyB(), and TensorMechanicsPlasticDruckerPrager::onlyB().

---

The documentation for this class was generated from the following files:

• tensor_mechanics/include/userobjects/TensorMechanicsPlasticDruckerPragerHyperbolic.h
• tensor_mechanics/src/userobjects/TensorMechanicsPlasticDruckerPragerHyperbolic.C