www.mooseframework.org
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Types | Private Attributes | List of all members
CappedWeakPlaneCosseratStressUpdate Class Reference

CappedWeakPlaneCosseratStressUpdate performs the return-map algorithm and associated stress updates for plastic models that describe capped weak-plane Cosserat plasticity. More...

#include <CappedWeakPlaneCosseratStressUpdate.h>

Inheritance diagram for CappedWeakPlaneCosseratStressUpdate:
[legend]

Public Member Functions

 CappedWeakPlaneCosseratStressUpdate (const InputParameters &parameters)
 
bool requiresIsotropicTensor () override
 Does the model require the elasticity tensor to be isotropic? More...
 
void setQp (unsigned int qp)
 Sets the value of the global variable _qp for inheriting classes. More...
 
virtual bool isIsotropic ()
 Is the implmented model isotropic? The safe default is 'false'. More...
 
virtual Real computeTimeStepLimit ()
 
void resetQpProperties () final
 Retained as empty methods to avoid a warning from Material.C in framework. These methods are unused in all inheriting classes and should not be overwritten. More...
 
void resetProperties () final
 

Static Public Member Functions

static InputParameters validParams ()
 

Protected Types

enum  StressReturnType { StressReturnType::nothing_special, StressReturnType::no_compression, StressReturnType::no_tension }
 This allows some simplification in the return-map process. More...
 

Protected Member Functions

virtual void consistentTangentOperator (const RankTwoTensor &stress_trial, Real p_trial, Real q_trial, const RankTwoTensor &stress, Real p, Real q, Real gaE, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, bool compute_full_tangent_operator, RankFourTensor &cto) const override
 Calculates the consistent tangent operator. More...
 
virtual void setStressAfterReturn (const RankTwoTensor &stress_trial, Real p_ok, Real q_ok, Real gaE, const std::vector< Real > &intnl, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, RankTwoTensor &stress) const override
 Sets stress from the admissible parameters. More...
 
virtual RankTwoTensor dqdstress (const RankTwoTensor &stress) const override
 d(q)/d(stress) Derived classes must override this More...
 
virtual RankFourTensor d2qdstress2 (const RankTwoTensor &stress) const override
 d2(q)/d(stress)/d(stress) Derived classes must override this More...
 
virtual void yieldFunctionValues (Real p, Real q, const std::vector< Real > &intnl, std::vector< Real > &yf) const override
 Computes the values of the yield functions, given p, q and intnl parameters. More...
 
virtual void computeAllQ (Real p, Real q, const std::vector< Real > &intnl, std::vector< yieldAndFlow > &all_q) const override
 Completely fills all_q with correct values. More...
 
virtual void preReturnMap (Real p_trial, Real q_trial, const RankTwoTensor &stress_trial, const std::vector< Real > &intnl_old, const std::vector< Real > &yf, const RankFourTensor &Eijkl) override
 Derived classes may employ this function to record stuff or do other computations prior to the return-mapping algorithm. More...
 
virtual void initializeVars (Real p_trial, Real q_trial, const std::vector< Real > &intnl_old, Real &p, Real &q, Real &gaE, std::vector< Real > &intnl) const override
 Sets (p, q, gaE, intnl) at "good guesses" of the solution to the Return-Map algorithm. More...
 
virtual void setIntnlValues (Real p_trial, Real q_trial, Real p, Real q, const std::vector< Real > &intnl_old, std::vector< Real > &intnl) const override
 Sets the internal parameters based on the trial values of p and q, their current values, and the old values of the internal parameters. More...
 
virtual void setIntnlDerivatives (Real p_trial, Real q_trial, Real p, Real q, const std::vector< Real > &intnl, std::vector< std::vector< Real >> &dintnl) const override
 Sets the derivatives of internal parameters, based on the trial values of p and q, their current values, and the old values of the internal parameters. More...
 
virtual void computePQ (const RankTwoTensor &stress, Real &p, Real &q) const override
 Computes p and q, given stress. More...
 
virtual void initializeReturnProcess () override
 Derived classes may use this to perform calculations before any return-map process is performed, for instance, to initialize variables. More...
 
virtual void finalizeReturnProcess (const RankTwoTensor &rotation_increment) override
 Derived classes may use this to perform calculations after the return-map process has completed successfully in stress_param space but before the returned stress tensor has been calculcated. More...
 
virtual void setEppEqq (const RankFourTensor &Eijkl, Real &Epp, Real &Eqq) const override
 Set Epp and Eqq based on the elasticity tensor Derived classes must override this. More...
 
virtual RankTwoTensor dpdstress (const RankTwoTensor &stress) const override
 d(p)/d(stress) Derived classes must override this More...
 
virtual RankFourTensor d2pdstress2 (const RankTwoTensor &stress) const override
 d2(p)/d(stress)/d(stress) Derived classes must override this More...
 
void yieldFunctionValuesV (const std::vector< Real > &stress_params, const std::vector< Real > &intnl, std::vector< Real > &yf) const override
 Computes the values of the yield functions, given stress_params and intnl parameters. More...
 
void computeAllQV (const std::vector< Real > &stress_params, const std::vector< Real > &intnl, std::vector< yieldAndFlow > &all_q) const override
 Completely fills all_q with correct values. More...
 
void preReturnMapV (const std::vector< Real > &trial_stress_params, const RankTwoTensor &stress_trial, const std::vector< Real > &intnl_old, const std::vector< Real > &yf, const RankFourTensor &Eijkl) override
 Derived classes may employ this function to record stuff or do other computations prior to the return-mapping algorithm. More...
 
void initializeVarsV (const std::vector< Real > &trial_stress_params, const std::vector< Real > &intnl_old, std::vector< Real > &stress_params, Real &gaE, std::vector< Real > &intnl) const override
 Sets (stress_params, intnl) at "good guesses" of the solution to the Return-Map algorithm. More...
 
void setIntnlValuesV (const std::vector< Real > &trial_stress_params, const std::vector< Real > &current_stress_params, const std::vector< Real > &intnl_old, std::vector< Real > &intnl) const override
 Sets the internal parameters based on the trial values of stress_params, their current values, and the old values of the internal parameters. More...
 
virtual void setIntnlDerivativesV (const std::vector< Real > &trial_stress_params, const std::vector< Real > &current_stress_params, const std::vector< Real > &intnl, std::vector< std::vector< Real >> &dintnl) const override
 Sets the derivatives of internal parameters, based on the trial values of stress_params, their current values, and the current values of the internal parameters. More...
 
virtual void computeStressParams (const RankTwoTensor &stress, std::vector< Real > &stress_params) const override
 Computes stress_params, given stress. More...
 
virtual void setEffectiveElasticity (const RankFourTensor &Eijkl) override
 Sets _Eij and _En and _Cij. More...
 
void setStressAfterReturnV (const RankTwoTensor &stress_trial, const std::vector< Real > &stress_params, Real gaE, const std::vector< Real > &intnl, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, RankTwoTensor &stress) const override
 Sets stress from the admissible parameters. More...
 
void setInelasticStrainIncrementAfterReturn (const RankTwoTensor &stress_trial, Real gaE, const yieldAndFlow &smoothed_q, const RankFourTensor &elasticity_tensor, const RankTwoTensor &returned_stress, RankTwoTensor &inelastic_strain_increment) const override
 Sets inelastic strain increment from the returned configuration This is called after the return-map process has completed successfully in stress_param space, just after finalizeReturnProcess has been called. More...
 
void consistentTangentOperatorV (const RankTwoTensor &stress_trial, const std::vector< Real > &trial_stress_params, const RankTwoTensor &stress, const std::vector< Real > &stress_params, Real gaE, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, bool compute_full_tangent_operator, const std::vector< std::vector< Real >> &dvar_dtrial, RankFourTensor &cto) override
 Calculates the consistent tangent operator. More...
 
virtual std::vector< RankTwoTensor > dstress_param_dstress (const RankTwoTensor &stress) const override
 d(stress_param[i])/d(stress) at given stress More...
 
virtual std::vector< RankFourTensor > d2stress_param_dstress (const RankTwoTensor &stress) const override
 d2(stress_param[i])/d(stress)/d(stress) at given stress More...
 
virtual void initQpStatefulProperties () override
 
virtual void updateState (RankTwoTensor &strain_increment, RankTwoTensor &inelastic_strain_increment, const RankTwoTensor &rotation_increment, RankTwoTensor &stress_new, const RankTwoTensor &stress_old, const RankFourTensor &elasticity_tensor, const RankTwoTensor &elastic_strain_old, bool compute_full_tangent_operator, RankFourTensor &tangent_operator) override
 Given a strain increment that results in a trial stress, perform some procedure (such as an iterative return-mapping process) to produce an admissible stress, an elastic strain increment and an inelastic strain increment. More...
 
virtual void propagateQpStatefulProperties () override
 If updateState is not called during a timestep, this will be. More...
 
virtual TangentCalculationMethod getTangentCalculationMethod () override
 
Real yieldF (const std::vector< Real > &stress_params, const std::vector< Real > &intnl) const
 Computes the smoothed yield function. More...
 
Real yieldF (const std::vector< Real > &yfs) const
 Computes the smoothed yield function. More...
 
Real ismoother (Real f_diff) const
 Smooths yield functions. More...
 
Real smoother (Real f_diff) const
 Derivative of ismoother. More...
 
Real dsmoother (Real f_diff) const
 Derivative of smoother. More...
 
yieldAndFlow smoothAllQuantities (const std::vector< Real > &stress_params, const std::vector< Real > &intnl) const
 Calculates all yield functions and derivatives, and then performs the smoothing scheme. More...
 
int lineSearch (Real &res2, std::vector< Real > &stress_params, Real &gaE, const std::vector< Real > &trial_stress_params, yieldAndFlow &smoothed_q, const std::vector< Real > &intnl_ok, std::vector< Real > &intnl, std::vector< Real > &rhs, Real &linesearch_needed) const
 Performs a line-search to find stress_params and gaE Upon entry: More...
 
int nrStep (const yieldAndFlow &smoothed_q, const std::vector< Real > &trial_stress_params, const std::vector< Real > &stress_params, const std::vector< Real > &intnl, Real gaE, std::vector< Real > &rhs) const
 Performs a Newton-Raphson step to attempt to zero rhs Upon return, rhs will contain the solution. More...
 
Real calculateRes2 (const std::vector< Real > &rhs) const
 Calculates the residual-squared for the Newton-Raphson + line-search. More...
 
void calculateRHS (const std::vector< Real > &trial_stress_params, const std::vector< Real > &stress_params, Real gaE, const yieldAndFlow &smoothed_q, std::vector< Real > &rhs) const
 Calculates the RHS in the following 0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, j] * dg/dS[j] 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, j] * dg/dS[j] ... More...
 
void dnRHSdVar (const yieldAndFlow &smoothed_q, const std::vector< std::vector< Real >> &dintnl, const std::vector< Real > &stress_params, Real gaE, std::vector< double > &jac) const
 Derivative of -RHS with respect to the stress_params and gaE, placed into an array ready for solving the linear system using LAPACK gsev. More...
 
virtual void errorHandler (const std::string &message) const
 Performs any necessary cleaning-up, then throw MooseException(message) More...
 
void dVardTrial (bool elastic_only, const std::vector< Real > &trial_stress_params, const std::vector< Real > &stress_params, Real gaE, const std::vector< Real > &intnl, const yieldAndFlow &smoothed_q, Real step_size, bool compute_full_tangent_operator, std::vector< std::vector< Real >> &dvar_dtrial) const
 Calculates derivatives of the stress_params and gaE with repect to the trial values of the stress_params for the (sub)strain increment. More...
 
bool precisionLoss (const std::vector< Real > &solution, const std::vector< Real > &stress_params, Real gaE) const
 Check whether precision loss has occurred. More...
 

Protected Attributes

const TensorMechanicsHardeningModel & _cohesion
 Hardening model for cohesion. More...
 
const TensorMechanicsHardeningModel & _tan_phi
 Hardening model for tan(phi) More...
 
const TensorMechanicsHardeningModel & _tan_psi
 Hardening model for tan(psi) More...
 
const TensorMechanicsHardeningModel & _tstrength
 Hardening model for tensile strength. More...
 
const TensorMechanicsHardeningModel & _cstrength
 Hardening model for compressive strength. More...
 
const Real _small_smoother2
 The cone vertex is smoothed by this amount. More...
 
const bool _perfect_guess
 Initialize the NR proceedure from a guess coming from perfect plasticity. More...
 
enum CappedWeakPlaneStressUpdate::StressReturnType _stress_return_type
 
Real _in_trial02
 trial value of stress(0, 2) More...
 
Real _in_trial12
 trial value of stress(1, 2) More...
 
Real _in_q_trial
 trial value of q More...
 
Real _p_trial
 Trial value of p. More...
 
Real _q_trial
 Trial value of q. More...
 
Real _Epp
 elasticity tensor in p direction More...
 
Real _Eqq
 elasticity tensor in q direction More...
 
Real _dgaE_dpt
 derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation) More...
 
Real _dgaE_dqt
 derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation) More...
 
Real _dp_dpt
 derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation) More...
 
Real _dq_dpt
 derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation) More...
 
Real _dp_dqt
 derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation) More...
 
Real _dq_dqt
 derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation) More...
 
const unsigned _num_sp
 Number of stress parameters. More...
 
const std::vector< Real > _definitely_ok_sp
 An admissible value of stress_params at the initial time. More...
 
std::vector< std::vector< Real > > _Eij
 E[i, j] in the system of equations to be solved. More...
 
Real _En
 normalising factor More...
 
std::vector< std::vector< Real > > _Cij
 _Cij[i, j] * _Eij[j, k] = 1 iff j == k More...
 
const unsigned _num_yf
 Number of yield functions. More...
 
const unsigned _num_intnl
 Number of internal parameters. More...
 
const unsigned _max_nr_its
 Maximum number of Newton-Raphson iterations allowed in the return-map process. More...
 
const bool _perform_finite_strain_rotations
 Whether to perform finite-strain rotations. More...
 
const Real _smoothing_tol
 Smoothing tolerance: edges of the yield surface get smoothed by this amount. More...
 
const Real _smoothing_tol2
 Square of the smoothing tolerance. More...
 
const Real _f_tol
 The yield-function tolerance. More...
 
const Real _f_tol2
 Square of the yield-function tolerance. More...
 
const Real _min_step_size
 In order to help the Newton-Raphson procedure, the applied strain increment may be applied in sub-increments of size greater than this value. More...
 
bool _step_one
 handles case of initial_stress that is inadmissible being supplied More...
 
const bool _warn_about_precision_loss
 Output a warning message if precision loss is encountered during the return-map process. More...
 
MaterialProperty< RankTwoTensor > & _plastic_strain
 plastic strain More...
 
const MaterialProperty< RankTwoTensor > & _plastic_strain_old
 Old value of plastic strain. More...
 
MaterialProperty< std::vector< Real > > & _intnl
 internal parameters More...
 
const MaterialProperty< std::vector< Real > > & _intnl_old
 old values of internal parameters More...
 
MaterialProperty< std::vector< Real > > & _yf
 yield functions More...
 
MaterialProperty< Real > & _iter
 Number of Newton-Raphson iterations used in the return-map. More...
 
MaterialProperty< Real > & _max_iter_used
 Maximum number of Newton-Raphson iterations used in the return-map during the course of the entire simulation. More...
 
const MaterialProperty< Real > & _max_iter_used_old
 Old value of maximum number of Newton-Raphson iterations used in the return-map during the course of the entire simulation. More...
 
MaterialProperty< Real > & _linesearch_needed
 Whether a line-search was needed in the latest Newton-Raphson process (1 if true, 0 otherwise) More...
 
const std::string _base_name
 Name used as a prefix for all material properties related to the stress update model. More...
 

Static Protected Attributes

constexpr static int _num_pq = 2
 Number of variables = 2 = (p, q) More...
 
constexpr static unsigned _tensor_dimensionality = 3
 Internal dimensionality of tensors (currently this is 3 throughout tensor_mechanics) More...
 

Private Types

enum  SmootherFunctionType { SmootherFunctionType::cos, SmootherFunctionType::poly1, SmootherFunctionType::poly2, SmootherFunctionType::poly3 }
 The type of smoother function. More...
 

Private Attributes

std::vector< Real > _trial_sp
 "Trial" value of stress_params that initializes the return-map process This is derived from stress = stress_old + Eijkl * strain_increment. More...
 
RankTwoTensor _stress_trial
 "Trial" value of stress that is set at the beginning of the return-map process. More...
 
std::vector< Real > _rhs
 0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, i] * dg/dS[i] 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, i] * dg/dS[i] ... More...
 
std::vector< std::vector< Real > > _dvar_dtrial
 d({stress_param[i], gaE})/d(trial_stress_param[j]) More...
 
std::vector< Real > _ok_sp
 The state (ok_sp, ok_intnl) is known to be admissible, so ok_sp are stress_params that are "OK". More...
 
std::vector< Real > _ok_intnl
 The state (ok_sp, ok_intnl) is known to be admissible. More...
 
std::vector< Real > _del_stress_params
 _del_stress_params = trial_stress_params - ok_sp This is fixed at the beginning of the return-map process, irrespective of substepping. More...
 
std::vector< Real > _current_sp
 The current values of the stress params during the Newton-Raphson. More...
 
std::vector< Real > _current_intnl
 The current values of the internal params during the Newton-Raphson. More...
 
enum MultiParameterPlasticityStressUpdate::SmootherFunctionType _smoother_function_type
 

Detailed Description

CappedWeakPlaneCosseratStressUpdate performs the return-map algorithm and associated stress updates for plastic models that describe capped weak-plane Cosserat plasticity.

It assumes various things about the elasticity tensor, viz E(i,i,j,k) = 0 except if k=j E(0,0,i,j) = E(1,1,i,j)

Definition at line 28 of file CappedWeakPlaneCosseratStressUpdate.h.

Member Enumeration Documentation

◆ SmootherFunctionType

enum MultiParameterPlasticityStressUpdate::SmootherFunctionType
strongprivateinherited

The type of smoother function.

Enumerator
cos 
poly1 
poly2 
poly3 

Definition at line 743 of file MultiParameterPlasticityStressUpdate.h.

744  {
745  cos,
746  poly1,
747  poly2,
748  poly3
749  } _smoother_function_type;

◆ StressReturnType

enum CappedWeakPlaneStressUpdate::StressReturnType
strongprotectedinherited

This allows some simplification in the return-map process.

If the tensile yield function yf[1] >= 0 at the trial stress then clearly the quadpoint is not going to fail in compression, so _stress_return_type is set to no_compression, and every time the compressive yield function is evaluated it is set -(very large). If the compressive yield function yf[2] >= 0 at the trial stress then clearly the quadpoint is not going to fail in tension, so _stress_return_type is set to no_tension, and every time the tensile yield function is evaluated it is set -(very large). Otherwise (and at the very end after return-map) _stress_return_type is set to nothing_special.

Enumerator
nothing_special 
no_compression 
no_tension 

Definition at line 78 of file CappedWeakPlaneStressUpdate.h.

79  {
80  nothing_special,
81  no_compression,
82  no_tension
83  } _stress_return_type;

Constructor & Destructor Documentation

◆ CappedWeakPlaneCosseratStressUpdate()

CappedWeakPlaneCosseratStressUpdate::CappedWeakPlaneCosseratStressUpdate ( const InputParameters &  parameters)

Definition at line 26 of file CappedWeakPlaneCosseratStressUpdate.C.

28  : CappedWeakPlaneStressUpdate(parameters)
29 {
30 }

Member Function Documentation

◆ calculateRes2()

Real MultiParameterPlasticityStressUpdate::calculateRes2 ( const std::vector< Real > &  rhs) const
protectedinherited

Calculates the residual-squared for the Newton-Raphson + line-search.

Parameters
rhs[in]The RHS vector
Returns
sum_i (rhs[i] * rhs[i])

Definition at line 802 of file MultiParameterPlasticityStressUpdate.C.

803 {
804  Real res2 = 0.0;
805  for (const auto & r : rhs)
806  res2 += r * r;
807  return res2;
808 }

Referenced by MultiParameterPlasticityStressUpdate::lineSearch(), and MultiParameterPlasticityStressUpdate::updateState().

◆ calculateRHS()

void MultiParameterPlasticityStressUpdate::calculateRHS ( const std::vector< Real > &  trial_stress_params,
const std::vector< Real > &  stress_params,
Real  gaE,
const yieldAndFlow &  smoothed_q,
std::vector< Real > &  rhs 
) const
protectedinherited

Calculates the RHS in the following 0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, j] * dg/dS[j] 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, j] * dg/dS[j] ...

0 = rhs[N-1] = S[N-1] - S[N-1]^trial + ga * E[N-1, j] * dg/dS[j] 0 = rhs[N] = f(S, intnl) where N = _num_sp

Parameters
trial_stress_params[in]The trial stress parameters for this (sub)strain increment, S[:]^trial
stress_params[in]The current stress parameters, S[:]
gaE[in]ga*_En (the normalisation with _En is so that gaE is of similar magnitude to S)
smoothed_q[in]Holds the current value of yield function and derivatives evaluated at the current stress parameters and the current internal parameters
rhs[out]The result

Definition at line 811 of file MultiParameterPlasticityStressUpdate.C.

816 {
817  const Real ga = gaE / _En;
818  for (unsigned i = 0; i < _num_sp; ++i)
819  {
820  rhs[i] = stress_params[i] - trial_stress_params[i];
821  for (unsigned j = 0; j < _num_sp; ++j)
822  rhs[i] += ga * _Eij[i][j] * smoothed_q.dg[j];
823  }
824  rhs[_num_sp] = smoothed_q.f;
825 }

Referenced by MultiParameterPlasticityStressUpdate::lineSearch(), and MultiParameterPlasticityStressUpdate::updateState().

◆ computeAllQ()

void CappedWeakPlaneStressUpdate::computeAllQ ( Real  p,
Real  q,
const std::vector< Real > &  intnl,
std::vector< yieldAndFlow > &  all_q 
) const
overrideprotectedvirtualinherited

Completely fills all_q with correct values.

These values are: (1) the yield function values, yf[i] (2) d(yf[i])/d(p, q) (3) d(yf[i])/d(intnl[j]) (4) d(flowPotential[i])/d(p, q) (5) d2(flowPotential[i])/d(p, q)/d(p, q) (6) d2(flowPotential[i])/d(p, q)/d(intnl[j])

Parameters
pp stress
qq stress
intnlThe internal parameters
[out]all_qAll the desired quantities

Implements TwoParameterPlasticityStressUpdate.

Definition at line 283 of file CappedWeakPlaneStressUpdate.C.

287 {
288  // yield function values
289  all_q[0].f = std::sqrt(Utility::pow<2>(q) + _small_smoother2) + p * _tan_phi.value(intnl[0]) -
290  _cohesion.value(intnl[0]);
291  if (_stress_return_type == StressReturnType::no_tension)
292  all_q[1].f = std::numeric_limits<Real>::lowest();
293  else
294  all_q[1].f = p - _tstrength.value(intnl[1]);
295  if (_stress_return_type == StressReturnType::no_compression)
296  all_q[2].f = std::numeric_limits<Real>::lowest();
297  else
298  all_q[2].f = -p - _cstrength.value(intnl[1]);
299 
300  // d(yield Function)/d(p, q)
301  // derivatives wrt p
302  all_q[0].df[0] = _tan_phi.value(intnl[0]);
303  all_q[1].df[0] = 1.0;
304  all_q[2].df[0] = -1.0;
305 
306  // derivatives wrt q
307  if (_small_smoother2 == 0.0)
308  all_q[0].df[1] = 1.0;
309  else
310  all_q[0].df[1] = q / std::sqrt(Utility::pow<2>(q) + _small_smoother2);
311  all_q[1].df[1] = 0.0;
312  all_q[2].df[1] = 0.0;
313 
314  // d(yield Function)/d(intnl)
315  // derivatives wrt intnl[0] (shear plastic strain)
316  all_q[0].df_di[0] = p * _tan_phi.derivative(intnl[0]) - _cohesion.derivative(intnl[0]);
317  all_q[1].df_di[0] = 0.0;
318  all_q[2].df_di[0] = 0.0;
319  // derivatives wrt intnl[q] (tensile plastic strain)
320  all_q[0].df_di[1] = 0.0;
321  all_q[1].df_di[1] = -_tstrength.derivative(intnl[1]);
322  all_q[2].df_di[1] = -_cstrength.derivative(intnl[1]);
323 
324  // d(flowPotential)/d(p, q)
325  // derivatives wrt p
326  all_q[0].dg[0] = _tan_psi.value(intnl[0]);
327  all_q[1].dg[0] = 1.0;
328  all_q[2].dg[0] = -1.0;
329  // derivatives wrt q
330  if (_small_smoother2 == 0.0)
331  all_q[0].dg[1] = 1.0;
332  else
333  all_q[0].dg[1] = q / std::sqrt(Utility::pow<2>(q) + _small_smoother2);
334  all_q[1].dg[1] = 0.0;
335  all_q[2].dg[1] = 0.0;
336 
337  // d2(flowPotential)/d(p, q)/d(intnl)
338  // d(dg/dp)/dintnl[0]
339  all_q[0].d2g_di[0][0] = _tan_psi.derivative(intnl[0]);
340  all_q[1].d2g_di[0][0] = 0.0;
341  all_q[2].d2g_di[0][0] = 0.0;
342  // d(dg/dp)/dintnl[1]
343  all_q[0].d2g_di[0][1] = 0.0;
344  all_q[1].d2g_di[0][1] = 0.0;
345  all_q[2].d2g_di[0][1] = 0.0;
346  // d(dg/dq)/dintnl[0]
347  all_q[0].d2g_di[1][0] = 0.0;
348  all_q[1].d2g_di[1][0] = 0.0;
349  all_q[2].d2g_di[1][0] = 0.0;
350  // d(dg/dq)/dintnl[1]
351  all_q[0].d2g_di[1][1] = 0.0;
352  all_q[1].d2g_di[1][1] = 0.0;
353  all_q[2].d2g_di[1][1] = 0.0;
354 
355  // d2(flowPotential)/d(p, q)/d(p, q)
356  // d(dg/dp)/dp
357  all_q[0].d2g[0][0] = 0.0;
358  all_q[1].d2g[0][0] = 0.0;
359  all_q[2].d2g[0][0] = 0.0;
360  // d(dg/dp)/dq
361  all_q[0].d2g[0][1] = 0.0;
362  all_q[1].d2g[0][1] = 0.0;
363  all_q[2].d2g[0][1] = 0.0;
364  // d(dg/dq)/dp
365  all_q[0].d2g[1][0] = 0.0;
366  all_q[1].d2g[1][0] = 0.0;
367  all_q[2].d2g[1][0] = 0.0;
368  // d(dg/dq)/dq
369  if (_small_smoother2 == 0.0)
370  all_q[0].d2g[1][1] = 0.0;
371  else
372  all_q[0].d2g[1][1] = _small_smoother2 / std::pow(Utility::pow<2>(q) + _small_smoother2, 1.5);
373  all_q[1].d2g[1][1] = 0.0;
374  all_q[2].d2g[1][1] = 0.0;
375 }

◆ computeAllQV()

void TwoParameterPlasticityStressUpdate::computeAllQV ( const std::vector< Real > &  stress_params,
const std::vector< Real > &  intnl,
std::vector< yieldAndFlow > &  all_q 
) const
overrideprotectedvirtualinherited

Completely fills all_q with correct values.

These values are: (1) the yield function values, yf[i] (2) d(yf[i])/d(stress_params[j]) (3) d(yf[i])/d(intnl[j]) (4) d(flowPotential[i])/d(stress_params[j]) (5) d2(flowPotential[i])/d(stress_params[j])/d(stress_params[k]) (6) d2(flowPotential[i])/d(stress_params[j])/d(intnl[k])

Parameters
stress_params[in]The stress parameters
intnl[in]The internal parameters
[out]all_qAll the desired quantities

Implements MultiParameterPlasticityStressUpdate.

Definition at line 103 of file TwoParameterPlasticityStressUpdate.C.

106 {
107  const Real p = stress_params[0];
108  const Real q = stress_params[1];
109  computeAllQ(p, q, intnl, all_q);
110 }

◆ computePQ()

void CappedWeakPlaneStressUpdate::computePQ ( const RankTwoTensor &  stress,
Real &  p,
Real &  q 
) const
overrideprotectedvirtualinherited

Computes p and q, given stress.

Derived classes must override this

Parameters
stressStress tensor
pp stress
qq q stress

Implements TwoParameterPlasticityStressUpdate.

Reimplemented in CappedWeakInclinedPlaneStressUpdate.

Definition at line 121 of file CappedWeakPlaneStressUpdate.C.

122 {
123  p = stress(2, 2);
124  // Because the following is not explicitly symmeterised, it is useful for the Cosserat case too
125  q = std::sqrt(Utility::pow<2>(stress(0, 2)) + Utility::pow<2>(stress(1, 2)));
126 }

◆ computeStressParams()

void TwoParameterPlasticityStressUpdate::computeStressParams ( const RankTwoTensor &  stress,
std::vector< Real > &  stress_params 
) const
overrideprotectedvirtualinherited

Computes stress_params, given stress.

Derived classes must override this

Parameters
stress[in]Stress tensor
stress_params[out]The compute stress_params

Implements MultiParameterPlasticityStressUpdate.

Definition at line 156 of file TwoParameterPlasticityStressUpdate.C.

158 {
159  Real p;
160  Real q;
161  computePQ(stress, p, q);
162  stress_params[0] = p;
163  stress_params[1] = q;
164 }

◆ computeTimeStepLimit()

Real StressUpdateBase::computeTimeStepLimit ( )
virtualinherited

Reimplemented in RadialReturnStressUpdate.

Definition at line 56 of file StressUpdateBase.C.

57 {
58  return std::numeric_limits<Real>::max();
59 }

◆ consistentTangentOperator()

void CappedWeakPlaneCosseratStressUpdate::consistentTangentOperator ( const RankTwoTensor &  stress_trial,
Real  p_trial,
Real  q_trial,
const RankTwoTensor &  stress,
Real  p,
Real  q,
Real  gaE,
const yieldAndFlow &  smoothed_q,
const RankFourTensor &  Eijkl,
bool  compute_full_tangent_operator,
RankFourTensor &  cto 
) const
overrideprotectedvirtual

Calculates the consistent tangent operator.

Derived classes may choose to override this for computational efficiency. The implementation in this class is quite expensive, even though it looks compact and clean, because of all the manipulations of RankFourTensors involved.

Parameters
stress_trialthe trial value of the stress tensor for this strain increment
p_trialthe trial value of p for this strain increment
q_trialthe trial value of q for this strain increment
stressthe returned value of the stress tensor for this strain increment
pthe returned value of p for this strain increment
qthe returned value of q for this strain increment
gaEthe total value of that came from this strain increment
smoothed_qcontains the yield function and derivatives evaluated at (p, q)
EijklThe elasticity tensor
compute_full_tangent_operatortrue if the full consistent tangent operator is needed, otherwise false
[out]ctoThe consistent tangent operator

Reimplemented from CappedWeakPlaneStressUpdate.

Definition at line 58 of file CappedWeakPlaneCosseratStressUpdate.C.

70 {
71  cto = Eijkl;
72  if (!compute_full_tangent_operator)
73  return;
74 
75  const Real Ezzzz = Eijkl(2, 2, 2, 2);
76  const Real Exzxz = Eijkl(0, 2, 0, 2);
77  const Real tanpsi = _tan_psi.value(_intnl[_qp][0]);
78  const Real dintnl0_dq = -1.0 / Exzxz;
79  const Real dintnl0_dqt = 1.0 / Exzxz;
80  const Real dintnl1_dp = -1.0 / Ezzzz;
81  const Real dintnl1_dpt = 1.0 / Ezzzz;
82  const Real dintnl1_dq =
83  tanpsi / Exzxz - (q_trial - q) * _tan_psi.derivative(_intnl[_qp][0]) * dintnl0_dq / Exzxz;
84  const Real dintnl1_dqt =
85  -tanpsi / Exzxz - (q_trial - q) * _tan_psi.derivative(_intnl[_qp][0]) * dintnl0_dqt / Exzxz;
86 
87  for (unsigned i = 0; i < _tensor_dimensionality; ++i)
88  {
89  const Real dpt_depii = Eijkl(2, 2, i, i);
90  cto(2, 2, i, i) = _dp_dpt * dpt_depii;
91  const Real poisson_effect =
92  Eijkl(2, 2, 0, 0) / Ezzzz *
93  (_dgaE_dpt * smoothed_q.dg[0] + gaE * smoothed_q.d2g[0][0] * _dp_dpt +
94  gaE * smoothed_q.d2g[0][1] * _dq_dpt +
95  gaE * smoothed_q.d2g_di[0][0] * (dintnl0_dq * _dq_dpt) +
96  gaE * smoothed_q.d2g_di[0][1] *
97  (dintnl1_dpt + dintnl1_dp * _dp_dpt + dintnl1_dq * _dq_dpt)) *
98  dpt_depii;
99  cto(0, 0, i, i) -= poisson_effect;
100  cto(1, 1, i, i) -= poisson_effect;
101  if (q_trial > 0.0)
102  {
103  cto(0, 2, i, i) = _in_trial02 / q_trial * _dq_dpt * dpt_depii;
104  cto(1, 2, i, i) = _in_trial12 / q_trial * _dq_dpt * dpt_depii;
105  }
106  }
107 
108  const Real poisson_effect =
109  -Eijkl(2, 2, 0, 0) / Ezzzz *
110  (_dgaE_dqt * smoothed_q.dg[0] + gaE * smoothed_q.d2g[0][0] * _dp_dqt +
111  gaE * smoothed_q.d2g[0][1] * _dq_dqt +
112  gaE * smoothed_q.d2g_di[0][0] * (dintnl0_dqt + dintnl0_dq * _dq_dqt) +
113  gaE * smoothed_q.d2g_di[0][1] * (dintnl1_dqt + dintnl1_dp * _dp_dqt + dintnl1_dq * _dq_dqt));
114 
115  const Real dqt_dep02 = (q_trial == 0.0 ? 1.0 : _in_trial02 / q_trial) * Eijkl(0, 2, 0, 2);
116  cto(2, 2, 0, 2) = _dp_dqt * dqt_dep02;
117  cto(0, 0, 0, 2) = cto(1, 1, 0, 2) = poisson_effect * dqt_dep02;
118  if (q_trial > 0.0)
119  {
120  // for q_trial=0, Jacobian_mult is just given by the elastic case
121  cto(0, 2, 0, 2) = Eijkl(0, 2, 0, 2) * q / q_trial +
122  _in_trial02 * (_dq_dqt - q / q_trial) / q_trial * dqt_dep02;
123  cto(1, 2, 0, 2) = _in_trial12 * (_dq_dqt - q / q_trial) / q_trial * dqt_dep02;
124  }
125 
126  const Real dqt_dep20 = (q_trial == 0.0 ? 1.0 : _in_trial02 / q_trial) * Eijkl(0, 2, 2, 0);
127  cto(2, 2, 2, 0) = _dp_dqt * dqt_dep20;
128  cto(0, 0, 2, 0) = cto(1, 1, 2, 0) = poisson_effect * dqt_dep20;
129  if (q_trial > 0.0)
130  {
131  // for q_trial=0, Jacobian_mult is just given by the elastic case
132  cto(0, 2, 2, 0) = Eijkl(0, 2, 2, 0) * q / q_trial +
133  _in_trial02 * (_dq_dqt - q / q_trial) / q_trial * dqt_dep20;
134  cto(1, 2, 2, 0) = _in_trial12 * (_dq_dqt - q / q_trial) / q_trial * dqt_dep20;
135  }
136 
137  const Real dqt_dep12 = (q_trial == 0.0 ? 1.0 : _in_trial12 / q_trial) * Eijkl(1, 2, 1, 2);
138  cto(2, 2, 1, 2) = _dp_dqt * dqt_dep12;
139  cto(0, 0, 1, 2) = cto(1, 1, 1, 2) = poisson_effect * dqt_dep12;
140  if (q_trial > 0.0)
141  {
142  // for q_trial=0, Jacobian_mult is just given by the elastic case
143  cto(0, 2, 1, 2) = _in_trial02 * (_dq_dqt - q / q_trial) / q_trial * dqt_dep12;
144  cto(1, 2, 1, 2) = Eijkl(1, 2, 1, 2) * q / q_trial +
145  _in_trial12 * (_dq_dqt - q / q_trial) / q_trial * dqt_dep12;
146  }
147 
148  const Real dqt_dep21 = (q_trial == 0.0 ? 1.0 : _in_trial12 / q_trial) * Eijkl(1, 2, 2, 1);
149  cto(2, 2, 2, 1) = _dp_dqt * dqt_dep21;
150  cto(0, 0, 2, 1) = cto(1, 1, 2, 1) = poisson_effect * dqt_dep21;
151  if (q_trial > 0.0)
152  {
153  // for q_trial=0, Jacobian_mult is just given by the elastic case
154  cto(0, 2, 2, 1) = _in_trial02 * (_dq_dqt - q / q_trial) / q_trial * dqt_dep21;
155  cto(1, 2, 2, 1) = Eijkl(1, 2, 2, 1) * q / q_trial +
156  _in_trial12 * (_dq_dqt - q / q_trial) / q_trial * dqt_dep21;
157  }
158 }

◆ consistentTangentOperatorV()

void TwoParameterPlasticityStressUpdate::consistentTangentOperatorV ( const RankTwoTensor &  stress_trial,
const std::vector< Real > &  trial_stress_params,
const RankTwoTensor &  stress,
const std::vector< Real > &  stress_params,
Real  gaE,
const yieldAndFlow &  smoothed_q,
const RankFourTensor &  Eijkl,
bool  compute_full_tangent_operator,
const std::vector< std::vector< Real >> &  dvar_dtrial,
RankFourTensor &  cto 
)
overrideprotectedvirtualinherited

Calculates the consistent tangent operator.

Derived classes may choose to override this for computational efficiency. The implementation in this class is quite expensive, even though it looks compact and clean, because of all the manipulations of RankFourTensors involved.

Parameters
stress_trial[in]the trial value of the stress tensor for this strain increment
trial_stress_params[in]the trial values of the stress_params for this strain increment
stress[in]the returned value of the stress tensor for this strain increment
stress_params[in]the returned value of the stress_params for this strain increment
gaE[in]the total value of that came from this strain increment
smoothed_q[in]contains the yield function and derivatives evaluated at (p, q)
Eijkl[in]The elasticity tensor
compute_full_tangent_operator[in]true if the full consistent tangent operator is needed, otherwise false
dvar_dtrial[in]dvar_dtrial[i][j] = d({stress_param[i],gaE})/d(trial_stress_param[j]) for this strain increment
[out]ctoThe consistent tangent operator

Reimplemented from MultiParameterPlasticityStressUpdate.

Definition at line 167 of file TwoParameterPlasticityStressUpdate.C.

178 {
179  const Real p_trial = trial_stress_params[0];
180  const Real q_trial = trial_stress_params[1];
181  const Real p = stress_params[0];
182  const Real q = stress_params[1];
183  _dp_dpt = dvar_dtrial[0][0];
184  _dp_dqt = dvar_dtrial[0][1];
185  _dq_dpt = dvar_dtrial[1][0];
186  _dq_dqt = dvar_dtrial[1][1];
187  _dgaE_dpt = dvar_dtrial[2][0];
188  _dgaE_dqt = dvar_dtrial[2][1];
189  consistentTangentOperator(stress_trial,
190  p_trial,
191  q_trial,
192  stress,
193  p,
194  q,
195  gaE,
196  smoothed_q,
197  Eijkl,
198  compute_full_tangent_operator,
199  cto);
200 }

◆ d2pdstress2()

RankFourTensor CappedWeakPlaneStressUpdate::d2pdstress2 ( const RankTwoTensor &  stress) const
overrideprotectedvirtualinherited

d2(p)/d(stress)/d(stress) Derived classes must override this

Parameters
stressstress tensor
Returns
d2(p)/d(stress)/d(stress)

Implements TwoParameterPlasticityStressUpdate.

Definition at line 494 of file CappedWeakPlaneStressUpdate.C.

495 {
496  return RankFourTensor();
497 }

◆ d2qdstress2()

RankFourTensor CappedWeakPlaneCosseratStressUpdate::d2qdstress2 ( const RankTwoTensor &  stress) const
overrideprotectedvirtual

d2(q)/d(stress)/d(stress) Derived classes must override this

Parameters
stressstress tensor
Returns
d2(q)/d(stress)/d(stress)

Reimplemented from CappedWeakPlaneStressUpdate.

Definition at line 180 of file CappedWeakPlaneCosseratStressUpdate.C.

181 {
182  RankFourTensor d2 = RankFourTensor();
183 
184  const Real q = std::sqrt(Utility::pow<2>(stress(0, 2)) + Utility::pow<2>(stress(1, 2)));
185  if (q == 0.0)
186  return d2;
187 
188  const Real dq02 = stress(0, 2) / q;
189  const Real dq12 = stress(1, 2) / q;
190 
191  d2(0, 2, 0, 2) = 1.0 / q - dq02 * dq02 / q;
192  d2(0, 2, 1, 2) = -dq02 * dq12 / q;
193  d2(1, 2, 0, 2) = -dq12 * dq02 / q;
194  d2(1, 2, 1, 2) = 1.0 / q - dq12 * dq12 / q;
195 
196  return d2;
197 }

◆ d2stress_param_dstress()

std::vector< RankFourTensor > TwoParameterPlasticityStressUpdate::d2stress_param_dstress ( const RankTwoTensor &  stress) const
overrideprotectedvirtualinherited

d2(stress_param[i])/d(stress)/d(stress) at given stress

Parameters
stressstress tensor
Returns
d2(stress_param[:])/d(stress)/d(stress)

Implements MultiParameterPlasticityStressUpdate.

Definition at line 301 of file TwoParameterPlasticityStressUpdate.C.

302 {
303  std::vector<RankFourTensor> d2(_num_pq, RankFourTensor());
304  d2[0] = d2pdstress2(stress);
305  d2[1] = d2qdstress2(stress);
306  return d2;
307 }

◆ dnRHSdVar()

void MultiParameterPlasticityStressUpdate::dnRHSdVar ( const yieldAndFlow &  smoothed_q,
const std::vector< std::vector< Real >> &  dintnl,
const std::vector< Real > &  stress_params,
Real  gaE,
std::vector< double > &  jac 
) const
protectedinherited

Derivative of -RHS with respect to the stress_params and gaE, placed into an array ready for solving the linear system using LAPACK gsev.

Parameters
smoothed_q[in]Holds the current value of yield function and derivatives evaluated at the current values of the stress_params and the internal parameters
dintnl[in]The derivatives of the internal parameters wrt the stress_params
stress_params[in]The current value of the stress_params during the Newton-Raphson process
gaE[in]The current value of gaE
jac[out]The outputted derivatives

Definition at line 828 of file MultiParameterPlasticityStressUpdate.C.

833 {
834  for (auto & jac_entry : jac)
835  jac_entry = 0.0;
836 
837  const Real ga = gaE / _En;
838 
839  unsigned ind = 0;
840  for (unsigned var = 0; var < _num_sp; ++var)
841  {
842  for (unsigned rhs = 0; rhs < _num_sp; ++rhs)
843  {
844  if (var == rhs)
845  jac[ind] -= 1.0;
846  for (unsigned j = 0; j < _num_sp; ++j)
847  {
848  jac[ind] -= ga * _Eij[rhs][j] * smoothed_q.d2g[j][var];
849  for (unsigned k = 0; k < _num_intnl; ++k)
850  jac[ind] -= ga * _Eij[rhs][j] * smoothed_q.d2g_di[j][k] * dintnl[k][var];
851  }
852  ind++;
853  }
854  // now rhs = _num_sp (that is, the yield function)
855  jac[ind] -= smoothed_q.df[var];
856  for (unsigned k = 0; k < _num_intnl; ++k)
857  jac[ind] -= smoothed_q.df_di[k] * dintnl[k][var];
858  ind++;
859  }
860 
861  // now var = _num_sp (that is, gaE)
862  for (unsigned rhs = 0; rhs < _num_sp; ++rhs)
863  {
864  for (unsigned j = 0; j < _num_sp; ++j)
865  jac[ind] -= (1.0 / _En) * _Eij[rhs][j] * smoothed_q.dg[j];
866  ind++;
867  }
868  // now rhs = _num_sp (that is, the yield function)
869  jac[ind] = 0.0;
870 }

Referenced by MultiParameterPlasticityStressUpdate::dVardTrial(), and MultiParameterPlasticityStressUpdate::nrStep().

◆ dpdstress()

RankTwoTensor CappedWeakPlaneStressUpdate::dpdstress ( const RankTwoTensor &  stress) const
overrideprotectedvirtualinherited

d(p)/d(stress) Derived classes must override this

Parameters
stressstress tensor
Returns
d(p)/d(stress)

Implements TwoParameterPlasticityStressUpdate.

Reimplemented in CappedWeakInclinedPlaneStressUpdate.

Definition at line 486 of file CappedWeakPlaneStressUpdate.C.

487 {
488  RankTwoTensor deriv = RankTwoTensor();
489  deriv(2, 2) = 1.0;
490  return deriv;
491 }

◆ dqdstress()

RankTwoTensor CappedWeakPlaneCosseratStressUpdate::dqdstress ( const RankTwoTensor &  stress) const
overrideprotectedvirtual

d(q)/d(stress) Derived classes must override this

Parameters
stressstress tensor
Returns
d(q)/d(stress)

Reimplemented from CappedWeakPlaneStressUpdate.

Definition at line 161 of file CappedWeakPlaneCosseratStressUpdate.C.

162 {
163  RankTwoTensor deriv = RankTwoTensor();
164  const Real q = std::sqrt(Utility::pow<2>(stress(0, 2)) + Utility::pow<2>(stress(1, 2)));
165  if (q > 0.0)
166  {
167  deriv(0, 2) = stress(0, 2) / q;
168  deriv(1, 2) = stress(1, 2) / q;
169  }
170  else
171  {
172  // derivative is not defined here. For now i'll set:
173  deriv(0, 2) = 1.0;
174  deriv(1, 2) = 1.0;
175  }
176  return deriv;
177 }

◆ dsmoother()

Real MultiParameterPlasticityStressUpdate::dsmoother ( Real  f_diff) const
protectedinherited

Derivative of smoother.

Definition at line 533 of file MultiParameterPlasticityStressUpdate.C.

534 {
535  if (std::abs(f_diff) >= _smoothing_tol)
536  return 0.0;
537  switch (_smoother_function_type)
538  {
539  case SmootherFunctionType::cos:
540  return 0.25 * M_PI / _smoothing_tol * std::cos(f_diff * M_PI * 0.5 / _smoothing_tol);
541  case SmootherFunctionType::poly1:
542  return 0.75 / _smoothing_tol * (1.0 - Utility::pow<2>(f_diff / _smoothing_tol));
543  case SmootherFunctionType::poly2:
544  return 0.625 / _smoothing_tol * (1.0 - Utility::pow<4>(f_diff / _smoothing_tol));
545  case SmootherFunctionType::poly3:
546  return (7.0 / 12.0 / _smoothing_tol) * (1.0 - Utility::pow<6>(f_diff / _smoothing_tol));
547  default:
548  return 0.0;
549  }
550 }

Referenced by MultiParameterPlasticityStressUpdate::smoothAllQuantities().

◆ dstress_param_dstress()

std::vector< RankTwoTensor > TwoParameterPlasticityStressUpdate::dstress_param_dstress ( const RankTwoTensor &  stress) const
overrideprotectedvirtualinherited

d(stress_param[i])/d(stress) at given stress

Parameters
stressstress tensor
Returns
d(stress_param[:])/d(stress)

Implements MultiParameterPlasticityStressUpdate.

Definition at line 292 of file TwoParameterPlasticityStressUpdate.C.

293 {
294  std::vector<RankTwoTensor> dsp(_num_pq, RankTwoTensor());
295  dsp[0] = dpdstress(stress);
296  dsp[1] = dqdstress(stress);
297  return dsp;
298 }

◆ dVardTrial()

void MultiParameterPlasticityStressUpdate::dVardTrial ( bool  elastic_only,
const std::vector< Real > &  trial_stress_params,
const std::vector< Real > &  stress_params,
Real  gaE,
const std::vector< Real > &  intnl,
const yieldAndFlow &  smoothed_q,
Real  step_size,
bool  compute_full_tangent_operator,
std::vector< std::vector< Real >> &  dvar_dtrial 
) const
protectedinherited

Calculates derivatives of the stress_params and gaE with repect to the trial values of the stress_params for the (sub)strain increment.

After the strain increment has been fully applied, dvar_dtrial will contain the result appropriate to the full strain increment. Before that time (if applying in sub-strain increments) it will contain the result appropriate to the amount of strain increment applied successfully.

Parameters
elastic_only[in]whether this was an elastic step: if so then the updates to dvar_dtrial are fairly trivial
trial_stress_params[in]Trial values of stress_params for this (sub)strain increment
stress_params[in]Returned values of stress_params for this (sub)strain increment
gaE[in]the value of gaE that came from this (sub)strain increment
intnl[in]the value of the internal parameters at the returned position
smoothed_q[in]contains the yield function and derivatives evaluated at (stress_params, intnl)
step_size[in]size of this (sub)strain increment
compute_full_tangent_operator[in]true if the full consistent tangent operator is needed, otherwise false
dvar_dtrial[out]dvar_dtrial[i][j] = d({stress_param[i],gaE})/d(trial_stress_param[j])

Definition at line 873 of file MultiParameterPlasticityStressUpdate.C.

882 {
883  if (!_fe_problem.currentlyComputingJacobian())
884  return;
885 
886  if (!compute_full_tangent_operator)
887  return;
888 
889  if (elastic_only)
890  {
891  // no change to gaE, and all off-diag stuff remains unchanged from previous step
892  for (unsigned v = 0; v < _num_sp; ++v)
893  dvar_dtrial[v][v] += step_size;
894  return;
895  }
896 
897  const Real ga = gaE / _En;
898 
899  std::vector<std::vector<Real>> dintnl(_num_intnl, std::vector<Real>(_num_sp));
900  setIntnlDerivativesV(trial_stress_params, stress_params, intnl, dintnl);
901 
902  // rhs is described elsewhere, the following are changes in rhs wrt the trial_stress_param
903  // values
904  // In the following we use d(intnl)/d(trial variable) = - d(intnl)/d(variable)
905  std::vector<Real> rhs_cto((_num_sp + 1) * _num_sp);
906 
907  unsigned ind = 0;
908  for (unsigned a = 0; a < _num_sp; ++a)
909  {
910  // change in RHS[b] wrt changes in stress_param_trial[a]
911  for (unsigned b = 0; b < _num_sp; ++b)
912  {
913  if (a == b)
914  rhs_cto[ind] -= 1.0;
915  for (unsigned j = 0; j < _num_sp; ++j)
916  for (unsigned k = 0; k < _num_intnl; ++k)
917  rhs_cto[ind] -= ga * _Eij[b][j] * smoothed_q.d2g_di[j][k] * dintnl[k][a];
918  ind++;
919  }
920  // now b = _num_sp (that is, the yield function)
921  for (unsigned k = 0; k < _num_intnl; ++k)
922  rhs_cto[ind] -= smoothed_q.df_di[k] * dintnl[k][a];
923  ind++;
924  }
925 
926  // jac = d(-rhs)/d(var)
927  std::vector<double> jac((_num_sp + 1) * (_num_sp + 1));
928  dnRHSdVar(smoothed_q, dintnl, stress_params, gaE, jac);
929 
930  std::vector<int> ipiv(_num_sp + 1);
931  int info;
932  const int gesv_num_rhs = _num_sp + 1;
933  const int gesv_num_pq = _num_sp;
934  LAPACKgesv_(&gesv_num_rhs,
935  &gesv_num_pq,
936  &jac[0],
937  &gesv_num_rhs,
938  &ipiv[0],
939  &rhs_cto[0],
940  &gesv_num_rhs,
941  &info);
942  if (info != 0)
943  errorHandler("MultiParameterPlasticityStressUpdate: PETSC LAPACK gsev routine returned with "
944  "error code " +
945  Moose::stringify(info));
946 
947  ind = 0;
948  std::vector<std::vector<Real>> dvarn_dtrialn(_num_sp + 1, std::vector<Real>(_num_sp, 0.0));
949  for (unsigned spt = 0; spt < _num_sp; ++spt) // loop over trial stress-param variables
950  {
951  for (unsigned v = 0; v < _num_sp; ++v) // loop over variables in NR procedure
952  {
953  dvarn_dtrialn[v][spt] = rhs_cto[ind];
954  ind++;
955  }
956  // the final NR variable is gaE
957  dvarn_dtrialn[_num_sp][spt] = rhs_cto[ind];
958  ind++;
959  }
960 
961  const std::vector<std::vector<Real>> dvar_dtrial_old = dvar_dtrial;
962 
963  for (unsigned v = 0; v < _num_sp; ++v) // loop over variables in NR procedure
964  {
965  for (unsigned spt = 0; spt < _num_sp; ++spt) // loop over trial stress-param variables
966  {
967  dvar_dtrial[v][spt] = step_size * dvarn_dtrialn[v][spt];
968  for (unsigned a = 0; a < _num_sp; ++a)
969  dvar_dtrial[v][spt] += dvarn_dtrialn[v][a] * dvar_dtrial_old[a][spt];
970  }
971  }
972  // for gaE the formulae are a little different
973  const unsigned v = _num_sp;
974  for (unsigned spt = 0; spt < _num_sp; ++spt)
975  {
976  dvar_dtrial[v][spt] += step_size * dvarn_dtrialn[v][spt]; // note +=
977  for (unsigned a = 0; a < _num_sp; ++a)
978  dvar_dtrial[v][spt] += dvarn_dtrialn[v][a] * dvar_dtrial_old[a][spt];
979  }
980 }

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ errorHandler()

void MultiParameterPlasticityStressUpdate::errorHandler ( const std::string &  message) const
protectedvirtualinherited

Performs any necessary cleaning-up, then throw MooseException(message)

Parameters
messageThe message to using in MooseException

Definition at line 661 of file MultiParameterPlasticityStressUpdate.C.

662 {
663  throw MooseException(message);
664 }

Referenced by MultiParameterPlasticityStressUpdate::dVardTrial(), and MultiParameterPlasticityStressUpdate::updateState().

◆ finalizeReturnProcess()

void CappedWeakPlaneStressUpdate::finalizeReturnProcess ( const RankTwoTensor &  rotation_increment)
overrideprotectedvirtualinherited

Derived classes may use this to perform calculations after the return-map process has completed successfully in stress_param space but before the returned stress tensor has been calculcated.

Parameters
rotation_increment[in]The large-strain rotation increment

Reimplemented from MultiParameterPlasticityStressUpdate.

Reimplemented in CappedWeakInclinedPlaneStressUpdate.

Definition at line 95 of file CappedWeakPlaneStressUpdate.C.

96 {
97  _stress_return_type = StressReturnType::nothing_special;
98 }

Referenced by CappedWeakInclinedPlaneStressUpdate::finalizeReturnProcess().

◆ getTangentCalculationMethod()

virtual TangentCalculationMethod MultiParameterPlasticityStressUpdate::getTangentCalculationMethod ( )
inlineoverrideprotectedvirtualinherited

Reimplemented from StressUpdateBase.

Definition at line 123 of file MultiParameterPlasticityStressUpdate.h.

124  {
125  return TangentCalculationMethod::FULL;
126  }

◆ initializeReturnProcess()

void CappedWeakPlaneStressUpdate::initializeReturnProcess ( )
overrideprotectedvirtualinherited

Derived classes may use this to perform calculations before any return-map process is performed, for instance, to initialize variables.

This is called at the very start of updateState, even before any checking for admissible stresses, etc, is performed

Reimplemented from MultiParameterPlasticityStressUpdate.

Reimplemented in CappedWeakInclinedPlaneStressUpdate.

Definition at line 89 of file CappedWeakPlaneStressUpdate.C.

90 {
91  _stress_return_type = StressReturnType::nothing_special;
92 }

Referenced by CappedWeakInclinedPlaneStressUpdate::initializeReturnProcess().

◆ initializeVars()

void CappedWeakPlaneStressUpdate::initializeVars ( Real  p_trial,
Real  q_trial,
const std::vector< Real > &  intnl_old,
Real &  p,
Real &  q,
Real &  gaE,
std::vector< Real > &  intnl 
) const
overrideprotectedvirtualinherited

Sets (p, q, gaE, intnl) at "good guesses" of the solution to the Return-Map algorithm.

The purpose of these "good guesses" is to speed up the Newton-Raphson process by providing it with a good initial guess. Derived classes may choose to override this if their plastic models are easy enough to solve approximately. The default values, provided by this class, are simply p=p_trial, etc: that is, the "good guess" is just the trial point for this (sub)strain increment.

Parameters
p_trialThe trial value of p for this (sub)strain increment
q_trialThe trial value of q for this (sub)strain increment
intnl_oldThe internal parameters before applying the (sub)strain increment
p[out]The "good guess" value of p. Default = p_trial
q[out]The "good guess" value of q. Default = q_trial
gaE[out]The "good guess" value of gaE. Default = 0
intnl[out]The "good guess" value of the internal parameters

Reimplemented from TwoParameterPlasticityStressUpdate.

Definition at line 378 of file CappedWeakPlaneStressUpdate.C.

385 {
386  const Real tanpsi = _tan_psi.value(intnl_old[0]);
387 
388  if (!_perfect_guess)
389  {
390  p = p_trial;
391  q = q_trial;
392  gaE = 0.0;
393  }
394  else
395  {
396  const Real coh = _cohesion.value(intnl_old[0]);
397  const Real tanphi = _tan_phi.value(intnl_old[0]);
398  const Real tens = _tstrength.value(intnl_old[1]);
399  const Real comp = _cstrength.value(intnl_old[1]);
400  const Real q_at_T = coh - tens * tanphi;
401  const Real q_at_C = coh + comp * tanphi;
402 
403  if ((p_trial >= tens) && (q_trial <= q_at_T))
404  {
405  // pure tensile failure
406  p = tens;
407  q = q_trial;
408  gaE = p_trial - p;
409  }
410  else if ((p_trial <= -comp) && (q_trial <= q_at_C))
411  {
412  // pure compressive failure
413  p = -comp;
414  q = q_trial;
415  gaE = p - p_trial;
416  }
417  else
418  {
419  // shear failure or a mixture
420  // Calculate ga assuming a pure shear failure
421  const Real ga = (q_trial + p_trial * tanphi - coh) / (_Eqq + _Epp * tanphi * tanpsi);
422  if (ga <= 0 && p_trial <= tens && p_trial >= -comp)
423  {
424  // very close to one of the rounded corners: there is no advantage to guessing the
425  // solution, so:
426  p = p_trial;
427  q = q_trial;
428  gaE = 0.0;
429  }
430  else
431  {
432  q = q_trial - _Eqq * ga;
433  if (q <= 0.0 && q_at_T <= 0.0)
434  {
435  // user has set tensile strength so large that it is irrelevant: return to the tip of the
436  // shear cone
437  q = 0.0;
438  p = coh / tanphi;
439  gaE = (p_trial - p) / tanpsi; // just a guess, based on the angle to the corner
440  }
441  else if (q <= q_at_T)
442  {
443  // pure shear is incorrect: mixture of tension and shear is correct
444  q = q_at_T;
445  p = tens;
446  gaE = (p_trial - p) / tanpsi; // just a guess, based on the angle to the corner
447  }
448  else if (q >= q_at_C)
449  {
450  // pure shear is incorrect: mixture of compression and shear is correct
451  q = q_at_C;
452  p = -comp;
453  if (p - p_trial < _Epp * tanpsi * (q_trial - q) / _Eqq)
454  // trial point is sitting almost directly above corner
455  gaE = (q_trial - q) * _Epp / _Eqq;
456  else
457  // trial point is sitting to the left of the corner
458  gaE = (p - p_trial) / tanpsi;
459  }
460  else
461  {
462  // pure shear was correct
463  p = p_trial - _Epp * ga * tanpsi;
464  gaE = ga * _Epp;
465  }
466  }
467  }
468  }
469  setIntnlValues(p_trial, q_trial, p, q, intnl_old, intnl);
470 }

◆ initializeVarsV()

void TwoParameterPlasticityStressUpdate::initializeVarsV ( const std::vector< Real > &  trial_stress_params,
const std::vector< Real > &  intnl_old,
std::vector< Real > &  stress_params,
Real &  gaE,
std::vector< Real > &  intnl 
) const
overrideprotectedvirtualinherited

Sets (stress_params, intnl) at "good guesses" of the solution to the Return-Map algorithm.

The purpose of these "good guesses" is to speed up the Newton-Raphson process by providing it with a good initial guess. Derived classes may choose to override this if their plastic models are easy enough to solve approximately. The default values, provided by this class, are simply gaE = 0, stress_params = trial_stress_params, that is, the "good guess" is just the trial point for this (sub)strain increment.

Parameters
trial_stress_params[in]The stress_params at the trial point
intnl_old[in]The internal parameters before applying the (sub)strain increment
stress_params[out]The "good guess" value of the stress_params
gaE[out]The "good guess" value of gaE
intnl[out]The "good guess" value of the internal parameters

Reimplemented from MultiParameterPlasticityStressUpdate.

Definition at line 113 of file TwoParameterPlasticityStressUpdate.C.

118 {
119  const Real p_trial = trial_stress_params[0];
120  const Real q_trial = trial_stress_params[1];
121  Real p;
122  Real q;
123  initializeVars(p_trial, q_trial, intnl_old, p, q, gaE, intnl);
124  stress_params[0] = p;
125  stress_params[1] = q;
126 }

◆ initQpStatefulProperties()

void MultiParameterPlasticityStressUpdate::initQpStatefulProperties ( )
overrideprotectedvirtualinherited

Reimplemented in CappedWeakInclinedPlaneStressUpdate.

Definition at line 141 of file MultiParameterPlasticityStressUpdate.C.

142 {
143  _plastic_strain[_qp].zero();
144  _intnl[_qp].assign(_num_intnl, 0);
145  _yf[_qp].assign(_num_yf, 0);
146  _iter[_qp] = 0.0;
147  _max_iter_used[_qp] = 0.0;
148  _linesearch_needed[_qp] = 0.0;
149 }

Referenced by CappedWeakInclinedPlaneStressUpdate::initQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ isIsotropic()

virtual bool StressUpdateBase::isIsotropic ( )
inlinevirtualinherited

Is the implmented model isotropic? The safe default is 'false'.

Reimplemented in RadialReturnStressUpdate, CappedDruckerPragerStressUpdate, and CappedMohrCoulombStressUpdate.

Definition at line 112 of file StressUpdateBase.h.

112 { return false; };

Referenced by ComputeMultipleInelasticStress::initialSetup().

◆ ismoother()

Real MultiParameterPlasticityStressUpdate::ismoother ( Real  f_diff) const
protectedinherited

Smooths yield functions.

The returned value must be zero if abs(f_diff) >= _smoothing_tol and otherwise must satisfy, over -_smoothing_tol <= f_diff <= _smoothing_tol: (1) C2 (2) zero at f_diff = +/- _smoothing_tol (3) derivative is +/-0.5 at f_diff = +/- _smoothing_tol (4) derivative must be in [-0.5, 0.5] (5) second derivative is zero at f_diff = +/- _smoothing_tol (6) second derivative must be non-negative in order to ensure C2 differentiability and convexity of the smoothed yield surface.

Definition at line 484 of file MultiParameterPlasticityStressUpdate.C.

485 {
486  if (std::abs(f_diff) >= _smoothing_tol)
487  return 0.0;
488  switch (_smoother_function_type)
489  {
490  case SmootherFunctionType::cos:
491  return -_smoothing_tol / M_PI * std::cos(0.5 * M_PI * f_diff / _smoothing_tol);
492  case SmootherFunctionType::poly1:
493  return 0.75 / _smoothing_tol *
494  (0.5 * (Utility::pow<2>(f_diff) - _smoothing_tol2) -
495  (_smoothing_tol2 / 12.0) * (Utility::pow<4>(f_diff / _smoothing_tol) - 1.0));
496  case SmootherFunctionType::poly2:
497  return 0.625 / _smoothing_tol *
498  (0.5 * (Utility::pow<2>(f_diff) - _smoothing_tol2) -
499  (_smoothing_tol2 / 30.0) * (Utility::pow<6>(f_diff / _smoothing_tol) - 1.0));
500  case SmootherFunctionType::poly3:
501  return (7.0 / 12.0 / _smoothing_tol) *
502  (0.5 * (Utility::pow<2>(f_diff) - _smoothing_tol2) -
503  (_smoothing_tol2 / 56.0) * (Utility::pow<8>(f_diff / _smoothing_tol) - 1.0));
504  default:
505  return 0.0;
506  }
507 }

Referenced by MultiParameterPlasticityStressUpdate::smoothAllQuantities(), and MultiParameterPlasticityStressUpdate::yieldF().

◆ lineSearch()

int MultiParameterPlasticityStressUpdate::lineSearch ( Real &  res2,
std::vector< Real > &  stress_params,
Real &  gaE,
const std::vector< Real > &  trial_stress_params,
yieldAndFlow &  smoothed_q,
const std::vector< Real > &  intnl_ok,
std::vector< Real > &  intnl,
std::vector< Real > &  rhs,
Real &  linesearch_needed 
) const
protectedinherited

Performs a line-search to find stress_params and gaE Upon entry:

  • rhs contains the solution to the Newton-Raphson (ie nrStep should have been called). If a full Newton step is used then stress_params[:] += rhs[0:_num_sp-1] and gaE += rhs[_num_sp]
  • res2 contains the residual-squared before applying any of solution
  • stress_params contains the stress_params before applying any of the solution
  • gaE contains gaE before applying any of the solution (that is contained in rhs) Upon exit:
  • stress_params will be the stress_params after applying the solution
  • gaE will be the stress_params after applying the solution
  • rhs will contain the updated rhs values (after applying the solution) ready for the next Newton-Raphson step,
  • res2 will be the residual-squared after applying the solution
  • intnl will contain the internal variables corresponding to the return from trial_stress_params to stress_params (and starting from intnl_ok)
  • linesearch_needed will be 1.0 if a linesearch was needed
  • smoothed_q will contain the value of the yield function and its derivatives, etc, at (stress_params, intnl)
    Parameters
    res2[in,out]the residual-squared, both as an input and output
    stress_params[in,out]Upon input the value of the stress_params before the current Newton-Raphson process was initiated. Upon exit this will hold the values coming from the line search.
    trial_stress_params[in]Trial value for the stress_params for this (sub)strain increment
    gaE[in,out]Upon input the value of gaE before the current Newton-Raphson iteration was initiated. Upon exit this will hold the value coming from the line-search
    smoothed_q[in,out]Upon input, the value of the smoothed yield function and derivatives at the prior-to-Newton configuration. Upon exit this is evaluated at the new (stress_params, intnl)
    intnl_ok[in]The value of the internal parameters from the start of this (sub)strain increment
    intnl[in,out]The value of the internal parameters after the line-search has converged
    rhs[in,out]Upon entry this contains the solution to the Newton-Raphson. Upon exit this contains the updated rhs values
    Returns
    0 if successful, 1 otherwise

Definition at line 553 of file MultiParameterPlasticityStressUpdate.C.

562 {
563  const Real res2_old = res2;
564  const std::vector<Real> sp_params_old = stress_params;
565  const Real gaE_old = gaE;
566  const std::vector<Real> delta_nr_params = rhs;
567 
568  Real lam = 1.0; // line-search parameter
569  const Real lam_min = 1E-10; // minimum value of lam allowed
570  const Real slope = -2.0 * res2_old; // "Numerical Recipes" uses -b*A*x, in order to check for
571  // roundoff, but i hope the nrStep would warn if there were
572  // problems
573  Real tmp_lam; // cached value of lam used in quadratic & cubic line search
574  Real f2 = res2_old; // cached value of f = residual2 used in the cubic in the line search
575  Real lam2 = lam; // cached value of lam used in the cubic in the line search
576 
577  while (true)
578  {
579  // update variables using the current line-search parameter
580  for (unsigned i = 0; i < _num_sp; ++i)
581  stress_params[i] = sp_params_old[i] + lam * delta_nr_params[i];
582  gaE = gaE_old + lam * delta_nr_params[_num_sp];
583 
584  // and internal parameters
585  setIntnlValuesV(trial_stress_params, stress_params, intnl_ok, intnl);
586 
587  smoothed_q = smoothAllQuantities(stress_params, intnl);
588 
589  // update rhs for next-time through
590  calculateRHS(trial_stress_params, stress_params, gaE, smoothed_q, rhs);
591  res2 = calculateRes2(rhs);
592 
593  // do the line-search
594  if (res2 < res2_old + 1E-4 * lam * slope)
595  break;
596  else if (lam < lam_min)
597  return 1;
598  else if (lam == 1.0)
599  {
600  // model as a quadratic
601  tmp_lam = -0.5 * slope / (res2 - res2_old - slope);
602  }
603  else
604  {
605  // model as a cubic
606  const Real rhs1 = res2 - res2_old - lam * slope;
607  const Real rhs2 = f2 - res2_old - lam2 * slope;
608  const Real a = (rhs1 / Utility::pow<2>(lam) - rhs2 / Utility::pow<2>(lam2)) / (lam - lam2);
609  const Real b =
610  (-lam2 * rhs1 / Utility::pow<2>(lam) + lam * rhs2 / Utility::pow<2>(lam2)) / (lam - lam2);
611  if (a == 0.0)
612  tmp_lam = -slope / (2.0 * b);
613  else
614  {
615  const Real disc = Utility::pow<2>(b) - 3.0 * a * slope;
616  if (disc < 0)
617  tmp_lam = 0.5 * lam;
618  else if (b <= 0)
619  tmp_lam = (-b + std::sqrt(disc)) / (3.0 * a);
620  else
621  tmp_lam = -slope / (b + std::sqrt(disc));
622  }
623  if (tmp_lam > 0.5 * lam)
624  tmp_lam = 0.5 * lam;
625  }
626  lam2 = lam;
627  f2 = res2;
628  lam = std::max(tmp_lam, 0.1 * lam);
629  }
630 
631  if (lam < 1.0)
632  linesearch_needed = 1.0;
633  return 0;
634 }

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ nrStep()

int MultiParameterPlasticityStressUpdate::nrStep ( const yieldAndFlow &  smoothed_q,
const std::vector< Real > &  trial_stress_params,
const std::vector< Real > &  stress_params,
const std::vector< Real > &  intnl,
Real  gaE,
std::vector< Real > &  rhs 
) const
protectedinherited

Performs a Newton-Raphson step to attempt to zero rhs Upon return, rhs will contain the solution.

Parameters
smoothed_q[in]The value of the smoothed yield function and derivatives prior to this Newton-Raphson step
trial_stress_params[in]Trial value for the stress_params for this (sub)strain increment
stress_params[in]The current value of the stress_params
intnl[in]The current value of the internal parameters
gaE[in]The current value of gaE
rhs[in,out]Upon entry, the rhs to zero using Newton-Raphson. Upon exit, the solution to the Newton-Raphson problem
Returns
0 if successful, 1 otherwise

Definition at line 637 of file MultiParameterPlasticityStressUpdate.C.

643 {
644  std::vector<std::vector<Real>> dintnl(_num_intnl, std::vector<Real>(_num_sp));
645  setIntnlDerivativesV(trial_stress_params, stress_params, intnl, dintnl);
646 
647  std::vector<double> jac((_num_sp + 1) * (_num_sp + 1));
648  dnRHSdVar(smoothed_q, dintnl, stress_params, gaE, jac);
649 
650  // use LAPACK to solve the linear system
651  const int nrhs = 1;
652  std::vector<int> ipiv(_num_sp + 1);
653  int info;
654  const int gesv_num_rhs = _num_sp + 1;
655  LAPACKgesv_(
656  &gesv_num_rhs, &nrhs, &jac[0], &gesv_num_rhs, &ipiv[0], &rhs[0], &gesv_num_rhs, &info);
657  return info;
658 }

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ precisionLoss()

bool MultiParameterPlasticityStressUpdate::precisionLoss ( const std::vector< Real > &  solution,
const std::vector< Real > &  stress_params,
Real  gaE 
) const
protectedinherited

Check whether precision loss has occurred.

Parameters
[in]solutionThe solution to the Newton-Raphson system
[in]stress_paramsThe currect values of the stress_params for this (sub)strain increment
[in]gaEThe currenct value of gaE for this (sub)strain increment
Returns
true if precision loss has occurred

Definition at line 983 of file MultiParameterPlasticityStressUpdate.C.

986 {
987  if (std::abs(solution[_num_sp]) > 1E-13 * std::abs(gaE))
988  return false;
989  for (unsigned i = 0; i < _num_sp; ++i)
990  if (std::abs(solution[i]) > 1E-13 * std::abs(stress_params[i]))
991  return false;
992  return true;
993 }

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ preReturnMap()

void CappedWeakPlaneStressUpdate::preReturnMap ( Real  p_trial,
Real  q_trial,
const RankTwoTensor &  stress_trial,
const std::vector< Real > &  intnl_old,
const std::vector< Real > &  yf,
const RankFourTensor &  Eijkl 
)
overrideprotectedvirtualinherited

Derived classes may employ this function to record stuff or do other computations prior to the return-mapping algorithm.

We know that (p_trial, q_trial, intnl_old) is inadmissible.

Parameters
p_trialTrial value of p
q_trialTrial value of q
stress_trialTrial stress tensor
intnl_oldOld value of the internal parameters.
yfThe yield functions at (p_trial, q_trial, intnl_old)
EijklThe elasticity tensor

Reimplemented from TwoParameterPlasticityStressUpdate.

Reimplemented in CappedWeakInclinedPlaneStressUpdate.

Definition at line 101 of file CappedWeakPlaneStressUpdate.C.

107 {
108  // If it's obvious, then simplify the return-type
109  if (yf[1] >= 0)
110  _stress_return_type = StressReturnType::no_compression;
111  else if (yf[2] >= 0)
112  _stress_return_type = StressReturnType::no_tension;
113 
114  // The following are useful for the Cosserat case too
115  _in_trial02 = stress_trial(0, 2);
116  _in_trial12 = stress_trial(1, 2);
117  _in_q_trial = q_trial;
118 }

◆ preReturnMapV()

void TwoParameterPlasticityStressUpdate::preReturnMapV ( const std::vector< Real > &  trial_stress_params,
const RankTwoTensor &  stress_trial,
const std::vector< Real > &  intnl_old,
const std::vector< Real > &  yf,
const RankFourTensor &  Eijkl 
)
overrideprotectedvirtualinherited

Derived classes may employ this function to record stuff or do other computations prior to the return-mapping algorithm.

We know that (trial_stress_params, intnl_old) is inadmissible when this is called

Parameters
trial_stress_params[in]The trial values of the stress parameters
stress_trial[in]Trial stress tensor
intnl_old[in]Old value of the internal parameters.
yf[in]The yield functions at (p_trial, q_trial, intnl_old)
Eijkl[in]The elasticity tensor

Reimplemented from MultiParameterPlasticityStressUpdate.

Definition at line 65 of file TwoParameterPlasticityStressUpdate.C.

70 {
71  const Real p_trial = trial_stress_params[0];
72  const Real q_trial = trial_stress_params[1];
73  preReturnMap(p_trial, q_trial, stress_trial, intnl_old, yf, Eijkl);
74 }

◆ propagateQpStatefulProperties()

void MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties ( )
overrideprotectedvirtualinherited

If updateState is not called during a timestep, this will be.

This method allows derived classes to set internal parameters from their Old values, for instance

Reimplemented from StressUpdateBase.

Definition at line 152 of file MultiParameterPlasticityStressUpdate.C.

153 {
154  _plastic_strain[_qp] = _plastic_strain_old[_qp];
155  std::copy(_intnl_old[_qp].begin(), _intnl_old[_qp].end(), _intnl[_qp].begin());
156  _max_iter_used[_qp] = _max_iter_used_old[_qp];
157 }

◆ requiresIsotropicTensor()

bool CappedWeakPlaneCosseratStressUpdate::requiresIsotropicTensor ( )
inlineoverridevirtual

Does the model require the elasticity tensor to be isotropic?

Implements StressUpdateBase.

Definition at line 38 of file CappedWeakPlaneCosseratStressUpdate.h.

38 { return false; }

◆ resetProperties()

void StressUpdateBase::resetProperties ( )
inlinefinalinherited

Definition at line 123 of file StressUpdateBase.h.

123 {}

◆ resetQpProperties()

void StressUpdateBase::resetQpProperties ( )
inlinefinalinherited

Retained as empty methods to avoid a warning from Material.C in framework. These methods are unused in all inheriting classes and should not be overwritten.

Definition at line 122 of file StressUpdateBase.h.

122 {}

◆ setEffectiveElasticity()

void TwoParameterPlasticityStressUpdate::setEffectiveElasticity ( const RankFourTensor &  Eijkl)
overrideprotectedvirtualinherited

Sets _Eij and _En and _Cij.

Implements MultiParameterPlasticityStressUpdate.

Definition at line 52 of file TwoParameterPlasticityStressUpdate.C.

53 {
54  setEppEqq(Eijkl, _Epp, _Eqq);
55  _Eij[0][0] = _Epp;
56  _Eij[1][0] = _Eij[0][1] = 0.0;
57  _Eij[1][1] = _Eqq;
58  _En = _Epp;
59  _Cij[0][0] = 1.0 / _Epp;
60  _Cij[1][0] = _Cij[0][1] = 0.0;
61  _Cij[1][1] = 1.0 / _Eqq;
62 }

◆ setEppEqq()

void CappedWeakPlaneStressUpdate::setEppEqq ( const RankFourTensor &  Eijkl,
Real &  Epp,
Real &  Eqq 
) const
overrideprotectedvirtualinherited

Set Epp and Eqq based on the elasticity tensor Derived classes must override this.

Parameters
Eijklelasticity tensor
[out]EppEpp value
[out]EqqEqq value

Implements TwoParameterPlasticityStressUpdate.

Reimplemented in CappedWeakInclinedPlaneStressUpdate.

Definition at line 129 of file CappedWeakPlaneStressUpdate.C.

130 {
131  Epp = Eijkl(2, 2, 2, 2);
132  Eqq = Eijkl(0, 2, 0, 2);
133 }

◆ setInelasticStrainIncrementAfterReturn()

void TwoParameterPlasticityStressUpdate::setInelasticStrainIncrementAfterReturn ( const RankTwoTensor &  stress_trial,
Real  gaE,
const yieldAndFlow &  smoothed_q,
const RankFourTensor &  elasticity_tensor,
const RankTwoTensor &  returned_stress,
RankTwoTensor &  inelastic_strain_increment 
) const
overrideprotectedvirtualinherited

Sets inelastic strain increment from the returned configuration This is called after the return-map process has completed successfully in stress_param space, just after finalizeReturnProcess has been called.

Derived classes may override this function

Parameters
stress_trial[in]The trial value of stress
gaE[in]The value of gaE after the return-map process has completed successfully
smoothed_q[in]Holds the current value of yield function and derivatives evaluated at the returned configuration
elasticity_tensor[in]The elasticity tensor
returned_stress[in]The stress after the return-map process
inelastic_strain_increment[out]The inelastic strain increment resulting from this return-map

Reimplemented from MultiParameterPlasticityStressUpdate.

Definition at line 279 of file TwoParameterPlasticityStressUpdate.C.

286 {
287  inelastic_strain_increment = (gaE / _Epp) * (smoothed_q.dg[0] * dpdstress(returned_stress) +
288  smoothed_q.dg[1] * dqdstress(returned_stress));
289 }

◆ setIntnlDerivatives()

void CappedWeakPlaneStressUpdate::setIntnlDerivatives ( Real  p_trial,
Real  q_trial,
Real  p,
Real  q,
const std::vector< Real > &  intnl,
std::vector< std::vector< Real >> &  dintnl 
) const
overrideprotectedvirtualinherited

Sets the derivatives of internal parameters, based on the trial values of p and q, their current values, and the old values of the internal parameters.

Derived classes must override this.

Parameters
p_trialTrial value of p
q_trialTrial value of q
pCurrent value of p
qCurrent value of q
intnlThe current value of the internal parameters
dintnlThe derivatives dintnl[i][j] = d(intnl[i])/d(variable j), where variable0=p and variable1=q

Implements TwoParameterPlasticityStressUpdate.

Definition at line 161 of file CappedWeakPlaneStressUpdate.C.

167 {
168  const Real tanpsi = _tan_psi.value(intnl[0]);
169  dintnl[0][0] = 0.0;
170  dintnl[0][1] = -1.0 / _Eqq;
171  dintnl[1][0] = -1.0 / _Epp;
172  dintnl[1][1] =
173  tanpsi / _Eqq - (q_trial - q) * _tan_psi.derivative(intnl[0]) * dintnl[0][1] / _Eqq;
174 }

◆ setIntnlDerivativesV()

void TwoParameterPlasticityStressUpdate::setIntnlDerivativesV ( const std::vector< Real > &  trial_stress_params,
const std::vector< Real > &  current_stress_params,
const std::vector< Real > &  intnl,
std::vector< std::vector< Real >> &  dintnl 
) const
overrideprotectedvirtualinherited

Sets the derivatives of internal parameters, based on the trial values of stress_params, their current values, and the current values of the internal parameters.

Derived classes must override this.

Parameters
trial_stress_params[in]The trial stress parameters
current_stress_params[in]The current stress parameters
intnl[in]The current value of the internal parameters
dintnl[out]The derivatives dintnl[i][j] = d(intnl[i])/d(stress_param j)

Implements MultiParameterPlasticityStressUpdate.

Definition at line 142 of file TwoParameterPlasticityStressUpdate.C.

147 {
148  const Real p_trial = trial_stress_params[0];
149  const Real q_trial = trial_stress_params[1];
150  const Real p = current_stress_params[0];
151  const Real q = current_stress_params[1];
152  setIntnlDerivatives(p_trial, q_trial, p, q, intnl_old, dintnl);
153 }

◆ setIntnlValues()

void CappedWeakPlaneStressUpdate::setIntnlValues ( Real  p_trial,
Real  q_trial,
Real  p,
Real  q,
const std::vector< Real > &  intnl_old,
std::vector< Real > &  intnl 
) const
overrideprotectedvirtualinherited

Sets the internal parameters based on the trial values of p and q, their current values, and the old values of the internal parameters.

Derived classes must override this.

Parameters
p_trialTrial value of p
q_trialTrial value of q
pCurrent value of p
qCurrent value of q
intnl_oldOld value of internal parameters
intnl[out]The value of internal parameters to be set

Implements TwoParameterPlasticityStressUpdate.

Definition at line 473 of file CappedWeakPlaneStressUpdate.C.

479 {
480  intnl[0] = intnl_old[0] + (q_trial - q) / _Eqq;
481  const Real tanpsi = _tan_psi.value(intnl[0]);
482  intnl[1] = intnl_old[1] + (p_trial - p) / _Epp - (q_trial - q) * tanpsi / _Eqq;
483 }

Referenced by CappedWeakPlaneStressUpdate::initializeVars().

◆ setIntnlValuesV()

void TwoParameterPlasticityStressUpdate::setIntnlValuesV ( const std::vector< Real > &  trial_stress_params,
const std::vector< Real > &  current_stress_params,
const std::vector< Real > &  intnl_old,
std::vector< Real > &  intnl 
) const
overrideprotectedvirtualinherited

Sets the internal parameters based on the trial values of stress_params, their current values, and the old values of the internal parameters.

Derived classes must override this.

Parameters
trial_stress_params[in]The trial stress parameters (eg trial_p and trial_q)
current_stress_params[in]The current stress parameters (eg p and q)
intnl_old[out]Old value of internal parameters
intnl[out]The value of internal parameters to be set

Implements MultiParameterPlasticityStressUpdate.

Definition at line 129 of file TwoParameterPlasticityStressUpdate.C.

133 {
134  const Real p_trial = trial_stress_params[0];
135  const Real q_trial = trial_stress_params[1];
136  const Real p = current_stress_params[0];
137  const Real q = current_stress_params[1];
138  setIntnlValues(p_trial, q_trial, p, q, intnl_old, intnl);
139 }

◆ setQp()

void StressUpdateBase::setQp ( unsigned int  qp)
inherited

Sets the value of the global variable _qp for inheriting classes.

Definition at line 43 of file StressUpdateBase.C.

44 {
45  _qp = qp;
46 }

◆ setStressAfterReturn()

void CappedWeakPlaneCosseratStressUpdate::setStressAfterReturn ( const RankTwoTensor &  stress_trial,
Real  p_ok,
Real  q_ok,
Real  gaE,
const std::vector< Real > &  intnl,
const yieldAndFlow &  smoothed_q,
const RankFourTensor &  Eijkl,
RankTwoTensor &  stress 
) const
overrideprotectedvirtual

Sets stress from the admissible parameters.

This is called after the return-map process has completed successfully in (p, q) space, just after finalizeReturnProcess has been called. Derived classes may override this function

Parameters
stress_trialThe trial value of stress
p_okReturned value of p
q_okReturned value of q
gaEValue of gaE induced by the return (gaE = gamma * Epp)
smoothed_qHolds the current value of yield function and derivatives evaluated at (p_ok, q_ok, _intnl)
EijklThe elasticity tensor
stress[out]The returned value of the stress tensor

Reimplemented from CappedWeakPlaneStressUpdate.

Definition at line 33 of file CappedWeakPlaneCosseratStressUpdate.C.

41 {
42  stress = stress_trial;
43  stress(2, 2) = p_ok;
44  // stress_xx and stress_yy are sitting at their trial-stress values
45  // so need to bring them back via Poisson's ratio
46  stress(0, 0) -= Eijkl(2, 2, 0, 0) * gaE / _Epp * smoothed_q.dg[0];
47  stress(1, 1) -= Eijkl(2, 2, 1, 1) * gaE / _Epp * smoothed_q.dg[0];
48  if (_in_q_trial == 0.0)
49  stress(0, 2) = stress(1, 2) = 0.0;
50  else
51  {
52  stress(0, 2) = _in_trial02 * q_ok / _in_q_trial;
53  stress(1, 2) = _in_trial12 * q_ok / _in_q_trial;
54  }
55 }

◆ setStressAfterReturnV()

void TwoParameterPlasticityStressUpdate::setStressAfterReturnV ( const RankTwoTensor &  stress_trial,
const std::vector< Real > &  stress_params,
Real  gaE,
const std::vector< Real > &  intnl,
const yieldAndFlow &  smoothed_q,
const RankFourTensor &  Eijkl,
RankTwoTensor &  stress 
) const
overrideprotectedvirtualinherited

Sets stress from the admissible parameters.

This is called after the return-map process has completed successfully in stress_param space, just after finalizeReturnProcess has been called. Derived classes must override this function

Parameters
stress_trial[in]The trial value of stress
stress_params[in]The value of the stress_params after the return-map process has completed successfully
gaE[in]The value of gaE after the return-map process has completed successfully
intnl[in]The value of the internal parameters after the return-map process has completed successfully
smoothed_q[in]Holds the current value of yield function and derivatives evaluated at the returned state
Eijkl[in]The elasticity tensor
stress[out]The returned value of the stress tensor

Implements MultiParameterPlasticityStressUpdate.

Definition at line 265 of file TwoParameterPlasticityStressUpdate.C.

272 {
273  const Real p_ok = stress_params[0];
274  const Real q_ok = stress_params[1];
275  setStressAfterReturn(stress_trial, p_ok, q_ok, gaE, intnl, smoothed_q, Eijkl, stress);
276 }

◆ smoothAllQuantities()

MultiParameterPlasticityStressUpdate::yieldAndFlow MultiParameterPlasticityStressUpdate::smoothAllQuantities ( const std::vector< Real > &  stress_params,
const std::vector< Real > &  intnl 
) const
protectedinherited

Calculates all yield functions and derivatives, and then performs the smoothing scheme.

Parameters
stress_params[in]The stress parameters (eg stress_params[0] = stress_zz and stress_params[1] = sqrt(stress_zx^2 + stress_zy^2))
intnl[in]Internal parameters
Returns
The smoothed yield function and derivatives

Definition at line 400 of file MultiParameterPlasticityStressUpdate.C.

402 {
403  std::vector<yieldAndFlow> all_q(_num_yf, yieldAndFlow(_num_sp, _num_intnl));
404  computeAllQV(stress_params, intnl, all_q);
405 
406  /* This routine holds the key to my smoothing strategy. It
407  * may be proved that this smoothing strategy produces a
408  * yield surface that is both C2 differentiable and convex,
409  * assuming the individual yield functions are C2 and
410  * convex too.
411  * Of course all the derivatives must also be smoothed.
412  * Also, I assume that d(flow potential)/dstress gets smoothed
413  * by the Yield Function (which produces a C2 flow potential).
414  * See the line identified in the loop below.
415  * Only time will tell whether this is a good strategy, but it
416  * works well in all tests so far. Convexity is irrelevant
417  * for the non-associated case, but at least the return-map
418  * problem should always have a unique solution.
419  * For two yield functions+flows, labelled 1 and 2, we
420  * should have
421  * d(g1 - g2) . d(f1 - f2) >= 0
422  * If not then the return-map problem for even the
423  * multi-surface plasticity with no smoothing won't have a
424  * unique solution. If the multi-surface plasticity has
425  * a unique solution then the smoothed version defined
426  * below will too.
427  */
428 
429  // res_f is the index that contains the smoothed yieldAndFlow
430  std::size_t res_f = 0;
431 
432  for (std::size_t a = 1; a < all_q.size(); ++a)
433  {
434  if (all_q[res_f].f >= all_q[a].f + _smoothing_tol)
435  // no smoothing is needed: res_f is already indexes the largest yield function
436  continue;
437  else if (all_q[a].f >= all_q[res_f].f + _smoothing_tol)
438  {
439  // no smoothing is needed, and res_f needs to index to all_q[a]
440  res_f = a;
441  continue;
442  }
443  else
444  {
445  // smoothing is required
446  const Real f_diff = all_q[res_f].f - all_q[a].f;
447  const Real ism = ismoother(f_diff);
448  const Real sm = smoother(f_diff);
449  const Real dsm = dsmoother(f_diff);
450  // we want: all_q[res_f].f = 0.5 * all_q[res_f].f + all_q[a].f + _smoothing_tol) + ism,
451  // but we have to do the derivatives first
452  for (unsigned i = 0; i < _num_sp; ++i)
453  {
454  for (unsigned j = 0; j < _num_sp; ++j)
455  all_q[res_f].d2g[i][j] =
456  0.5 * (all_q[res_f].d2g[i][j] + all_q[a].d2g[i][j]) +
457  dsm * (all_q[res_f].df[j] - all_q[a].df[j]) * (all_q[res_f].dg[i] - all_q[a].dg[i]) +
458  sm * (all_q[res_f].d2g[i][j] - all_q[a].d2g[i][j]);
459  for (unsigned j = 0; j < _num_intnl; ++j)
460  all_q[res_f].d2g_di[i][j] = 0.5 * (all_q[res_f].d2g_di[i][j] + all_q[a].d2g_di[i][j]) +
461  dsm * (all_q[res_f].df_di[j] - all_q[a].df_di[j]) *
462  (all_q[res_f].dg[i] - all_q[a].dg[i]) +
463  sm * (all_q[res_f].d2g_di[i][j] - all_q[a].d2g_di[i][j]);
464  }
465  for (unsigned i = 0; i < _num_sp; ++i)
466  {
467  all_q[res_f].df[i] = 0.5 * (all_q[res_f].df[i] + all_q[a].df[i]) +
468  sm * (all_q[res_f].df[i] - all_q[a].df[i]);
469  // whether the following (smoothing g with f's smoother) is a good strategy remains to be
470  // seen...
471  all_q[res_f].dg[i] = 0.5 * (all_q[res_f].dg[i] + all_q[a].dg[i]) +
472  sm * (all_q[res_f].dg[i] - all_q[a].dg[i]);
473  }
474  for (unsigned i = 0; i < _num_intnl; ++i)
475  all_q[res_f].df_di[i] = 0.5 * (all_q[res_f].df_di[i] + all_q[a].df_di[i]) +
476  sm * (all_q[res_f].df_di[i] - all_q[a].df_di[i]);
477  all_q[res_f].f = 0.5 * (all_q[res_f].f + all_q[a].f + _smoothing_tol) + ism;
478  }
479  }
480  return all_q[res_f];
481 }

Referenced by MultiParameterPlasticityStressUpdate::lineSearch(), and MultiParameterPlasticityStressUpdate::updateState().

◆ smoother()

Real MultiParameterPlasticityStressUpdate::smoother ( Real  f_diff) const
protectedinherited

Derivative of ismoother.

Definition at line 510 of file MultiParameterPlasticityStressUpdate.C.

511 {
512  if (std::abs(f_diff) >= _smoothing_tol)
513  return 0.0;
514  switch (_smoother_function_type)
515  {
516  case SmootherFunctionType::cos:
517  return 0.5 * std::sin(f_diff * M_PI * 0.5 / _smoothing_tol);
518  case SmootherFunctionType::poly1:
519  return 0.75 / _smoothing_tol *
520  (f_diff - (_smoothing_tol / 3.0) * Utility::pow<3>(f_diff / _smoothing_tol));
521  case SmootherFunctionType::poly2:
522  return 0.625 / _smoothing_tol *
523  (f_diff - (_smoothing_tol / 5.0) * Utility::pow<5>(f_diff / _smoothing_tol));
524  case SmootherFunctionType::poly3:
525  return (7.0 / 12.0 / _smoothing_tol) *
526  (f_diff - (_smoothing_tol / 7.0) * Utility::pow<7>(f_diff / _smoothing_tol));
527  default:
528  return 0.0;
529  }
530 }

Referenced by MultiParameterPlasticityStressUpdate::smoothAllQuantities().

◆ updateState()

void MultiParameterPlasticityStressUpdate::updateState ( RankTwoTensor &  strain_increment,
RankTwoTensor &  inelastic_strain_increment,
const RankTwoTensor &  rotation_increment,
RankTwoTensor &  stress_new,
const RankTwoTensor &  stress_old,
const RankFourTensor &  elasticity_tensor,
const RankTwoTensor &  elastic_strain_old,
bool  compute_full_tangent_operator,
RankFourTensor &  tangent_operator 
)
overrideprotectedvirtualinherited

Given a strain increment that results in a trial stress, perform some procedure (such as an iterative return-mapping process) to produce an admissible stress, an elastic strain increment and an inelastic strain increment.

If _fe_problem.currentlyComputingJacobian() = true, then updateState also computes d(stress)/d(strain) (or some approximation to it).

This method is called by ComputeMultipleInelasticStress. This method is pure virutal: all inheriting classes must overwrite this method.

Parameters
strain_incrementUpon input: the strain increment. Upon output: the elastic strain increment
inelastic_strain_incrementThe inelastic_strain resulting from the interative procedure
rotation_incrementThe finite-strain rotation increment
stress_newUpon input: the trial stress that results from applying strain_increment as an elastic strain. Upon output: the admissible stress
stress_oldThe old value of stress
elasticity_tensorThe elasticity tensor
compute_full_tangent_operatorThe calling routine would like the full consistent tangent operator to be placed in tangent_operator, if possible. This is irrelevant if _fe_problem.currentlyComputingJacobian() = false
tangent_operatord(stress)/d(strain), or some approximation to it If compute_full_tangent_operator=false, then tangent_operator=elasticity_tensor is an appropriate choice. tangent_operator is only computed if _fe_problem.currentlyComputingJacobian() = true

Implements StressUpdateBase.

Definition at line 160 of file MultiParameterPlasticityStressUpdate.C.

169 {
170  // Size _yf[_qp] appropriately
171  _yf[_qp].assign(_num_yf, 0);
172  // _plastic_strain and _intnl are usually sized appropriately because they are stateful, but this
173  // Material may be used from a DiracKernel where stateful materials are not allowed. The best we
174  // can do is:
175  if (_intnl[_qp].size() != _num_intnl)
176  initQpStatefulProperties();
177 
178  initializeReturnProcess();
179 
180  if (_t_step >= 2)
181  _step_one = false;
182 
183  // initially assume an elastic deformation
184  std::copy(_intnl_old[_qp].begin(), _intnl_old[_qp].end(), _intnl[_qp].begin());
185 
186  _iter[_qp] = 0.0;
187  _max_iter_used[_qp] = std::max(_max_iter_used[_qp], _max_iter_used_old[_qp]);
188  _linesearch_needed[_qp] = 0.0;
189 
190  computeStressParams(stress_new, _trial_sp);
191  yieldFunctionValuesV(_trial_sp, _intnl[_qp], _yf[_qp]);
192 
193  if (yieldF(_yf[_qp]) <= _f_tol)
194  {
195  _plastic_strain[_qp] = _plastic_strain_old[_qp];
196  inelastic_strain_increment.zero();
197  if (_fe_problem.currentlyComputingJacobian())
198  tangent_operator = elasticity_tensor;
199  return;
200  }
201 
202  _stress_trial = stress_new;
203  /* The trial stress must be inadmissible
204  * so we need to return to the yield surface. The following
205  * equations must be satisfied.
206  *
207  * 0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, i] * dg/dS[i]
208  * 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, i] * dg/dS[i]
209  * ...
210  * 0 = rhs[N-1] = S[N-1] - S[N-1]^trial + ga * E[N-1, i] * dg/dS[i]
211  * 0 = rhs[N] = f(S, intnl)
212  *
213  * as well as equations defining intnl parameters as functions of
214  * stress_params, trial_stress_params and intnl_old
215  *
216  * The unknowns are S[0], ..., S[N-1], gaE, and the intnl parameters.
217  * Here gaE = ga * _En (the _En serves to make gaE similar magnitude to S)
218  * I find it convenient to solve the first N+1 equations for p, q and gaE,
219  * while substituting the "intnl parameters" equations into these during the solve process
220  */
221 
222  for (auto & deriv : _dvar_dtrial)
223  deriv.assign(_num_sp, 0.0);
224 
225  preReturnMapV(_trial_sp, stress_new, _intnl_old[_qp], _yf[_qp], elasticity_tensor);
226 
227  setEffectiveElasticity(elasticity_tensor);
228 
229  if (_step_one)
230  std::copy(_definitely_ok_sp.begin(), _definitely_ok_sp.end(), _ok_sp.begin());
231  else
232  computeStressParams(stress_old, _ok_sp);
233  std::copy(_intnl_old[_qp].begin(), _intnl_old[_qp].end(), _ok_intnl.begin());
234 
235  // Return-map problem: must apply the following changes in stress_params,
236  // and find the returned stress_params and gaE
237  for (unsigned i = 0; i < _num_sp; ++i)
238  _del_stress_params[i] = _trial_sp[i] - _ok_sp[i];
239 
240  Real step_taken = 0.0; // amount of del_stress_params that we've applied and the return-map
241  // problem has succeeded
242  Real step_size = 1.0; // potentially can apply del_stress_params in substeps
243  Real gaE_total = 0.0;
244 
245  // current values of the yield function, derivatives, etc
246  yieldAndFlow smoothed_q;
247 
248  // In the following sub-stepping procedure it is possible that
249  // the last step is an elastic step, and therefore smoothed_q won't
250  // be computed on the last step, so we have to compute it.
251  bool smoothed_q_calculated = false;
252 
253  while (step_taken < 1.0 && step_size >= _min_step_size)
254  {
255  if (1.0 - step_taken < step_size)
256  // prevent over-shoots of substepping
257  step_size = 1.0 - step_taken;
258 
259  // trial variables in terms of admissible variables
260  for (unsigned i = 0; i < _num_sp; ++i)
261  _trial_sp[i] = _ok_sp[i] + step_size * _del_stress_params[i];
262 
263  // initialize variables that are to be found via Newton-Raphson
264  _current_sp = _trial_sp;
265  Real gaE = 0.0;
266 
267  // flags indicating failure of Newton-Raphson and line-search
268  int nr_failure = 0;
269  int ls_failure = 0;
270 
271  // NR iterations taken in this substep
272  unsigned step_iter = 0;
273 
274  // The residual-squared for the line-search
275  Real res2 = 0.0;
276 
277  if (step_size < 1.0 && yieldF(_trial_sp, _ok_intnl) <= _f_tol)
278  // This is an elastic step
279  // The "step_size < 1.0" in above condition is for efficiency: we definitely
280  // know that this is a plastic step if step_size = 1.0
281  smoothed_q_calculated = false;
282  else
283  {
284  // this is a plastic step
285 
286  // initialize current_sp, gaE and current_intnl based on the non-smoothed situation
287  initializeVarsV(_trial_sp, _ok_intnl, _current_sp, gaE, _current_intnl);
288  // and find the smoothed yield function, flow potential and derivatives
289  smoothed_q = smoothAllQuantities(_current_sp, _current_intnl);
290  smoothed_q_calculated = true;
291  calculateRHS(_trial_sp, _current_sp, gaE, smoothed_q, _rhs);
292  res2 = calculateRes2(_rhs);
293 
294  // Perform a Newton-Raphson with linesearch to get current_sp, gaE, and also smoothed_q
295  while (res2 > _f_tol2 && step_iter < _max_nr_its && nr_failure == 0 && ls_failure == 0)
296  {
297  // solve the linear system and store the answer (the "updates") in rhs
298  nr_failure = nrStep(smoothed_q, _trial_sp, _current_sp, _current_intnl, gaE, _rhs);
299  if (nr_failure != 0)
300  break;
301 
302  // handle precision loss
303  if (precisionLoss(_rhs, _current_sp, gaE))
304  {
305  if (_warn_about_precision_loss)
306  {
307  Moose::err << "MultiParameterPlasticityStressUpdate: precision-loss in element "
308  << _current_elem->id() << " quadpoint=" << _qp << ". Stress_params =";
309  for (unsigned i = 0; i < _num_sp; ++i)
310  Moose::err << " " << _current_sp[i];
311  Moose::err << " gaE = " << gaE << "\n";
312  }
313  res2 = 0.0;
314  break;
315  }
316 
317  // apply (parts of) the updates, re-calculate smoothed_q, and res2
318  ls_failure = lineSearch(res2,
319  _current_sp,
320  gaE,
321  _trial_sp,
322  smoothed_q,
323  _ok_intnl,
324  _current_intnl,
325  _rhs,
326  _linesearch_needed[_qp]);
327  step_iter++;
328  }
329  }
330  if (res2 <= _f_tol2 && step_iter < _max_nr_its && nr_failure == 0 && ls_failure == 0 &&
331  gaE >= 0.0)
332  {
333  // this Newton-Raphson worked fine, or this was an elastic step
334  std::copy(_current_sp.begin(), _current_sp.end(), _ok_sp.begin());
335  gaE_total += gaE;
336  step_taken += step_size;
337  setIntnlValuesV(_trial_sp, _ok_sp, _ok_intnl, _intnl[_qp]);
338  std::copy(_intnl[_qp].begin(), _intnl[_qp].end(), _ok_intnl.begin());
339  // calculate dp/dp_trial, dp/dq_trial, etc, for Jacobian
340  dVardTrial(!smoothed_q_calculated,
341  _trial_sp,
342  _ok_sp,
343  gaE,
344  _ok_intnl,
345  smoothed_q,
346  step_size,
347  compute_full_tangent_operator,
348  _dvar_dtrial);
349  if (static_cast<Real>(step_iter) > _iter[_qp])
350  _iter[_qp] = static_cast<Real>(step_iter);
351  if (static_cast<Real>(step_iter) > _max_iter_used[_qp])
352  _max_iter_used[_qp] = static_cast<Real>(step_iter);
353  step_size *= 1.1;
354  }
355  else
356  {
357  // Newton-Raphson + line-search process failed
358  step_size *= 0.5;
359  }
360  }
361 
362  if (step_size < _min_step_size)
363  errorHandler("MultiParameterPlasticityStressUpdate: Minimum step-size violated");
364 
365  // success!
366  finalizeReturnProcess(rotation_increment);
367  yieldFunctionValuesV(_ok_sp, _intnl[_qp], _yf[_qp]);
368 
369  if (!smoothed_q_calculated)
370  smoothed_q = smoothAllQuantities(_ok_sp, _intnl[_qp]);
371 
372  setStressAfterReturnV(
373  _stress_trial, _ok_sp, gaE_total, _intnl[_qp], smoothed_q, elasticity_tensor, stress_new);
374 
375  setInelasticStrainIncrementAfterReturn(_stress_trial,
376  gaE_total,
377  smoothed_q,
378  elasticity_tensor,
379  stress_new,
380  inelastic_strain_increment);
381 
382  strain_increment = strain_increment - inelastic_strain_increment;
383  _plastic_strain[_qp] = _plastic_strain_old[_qp] + inelastic_strain_increment;
384 
385  if (_fe_problem.currentlyComputingJacobian())
386  // for efficiency, do not compute the tangent operator if not currently computing Jacobian
387  consistentTangentOperatorV(_stress_trial,
388  _trial_sp,
389  stress_new,
390  _ok_sp,
391  gaE_total,
392  smoothed_q,
393  elasticity_tensor,
394  compute_full_tangent_operator,
395  _dvar_dtrial,
396  tangent_operator);
397 }

◆ validParams()

InputParameters CappedWeakPlaneCosseratStressUpdate::validParams ( )
static

Definition at line 19 of file CappedWeakPlaneCosseratStressUpdate.C.

20 {
21  InputParameters params = CappedWeakPlaneStressUpdate::validParams();
22  params.addClassDescription("Capped weak-plane plasticity Cosserat stress calculator");
23  return params;
24 }

◆ yieldF() [1/2]

Real MultiParameterPlasticityStressUpdate::yieldF ( const std::vector< Real > &  stress_params,
const std::vector< Real > &  intnl 
) const
protectedinherited

Computes the smoothed yield function.

Parameters
stress_paramsThe stress parameters (eg stress_params[0] = stress_zz and stress_params[1] = sqrt(stress_zx^2 + stress_zy^2))
intnlThe internal parameters (eg intnl[0] is shear, intnl[1] is tensile)
Returns
The smoothed yield function value

Definition at line 688 of file MultiParameterPlasticityStressUpdate.C.

690 {
691  std::vector<Real> yfs(_num_yf);
692  yieldFunctionValuesV(stress_params, intnl, yfs);
693  return yieldF(yfs);
694 }

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ yieldF() [2/2]

Real MultiParameterPlasticityStressUpdate::yieldF ( const std::vector< Real > &  yfs) const
protectedinherited

Computes the smoothed yield function.

Parameters
yfsThe values of the individual yield functions
Returns
The smoothed yield function value

Definition at line 697 of file MultiParameterPlasticityStressUpdate.C.

698 {
699  Real yf = yfs[0];
700  for (std::size_t i = 1; i < yfs.size(); ++i)
701  if (yf >= yfs[i] + _smoothing_tol)
702  // no smoothing is needed, and yf is the biggest yield function
703  continue;
704  else if (yfs[i] >= yf + _smoothing_tol)
705  // no smoothing is needed, and yfs[i] is the biggest yield function
706  yf = yfs[i];
707  else
708  yf = 0.5 * (yf + yfs[i] + _smoothing_tol) + ismoother(yf - yfs[i]);
709  return yf;
710 }

◆ yieldFunctionValues()

void CappedWeakPlaneStressUpdate::yieldFunctionValues ( Real  p,
Real  q,
const std::vector< Real > &  intnl,
std::vector< Real > &  yf 
) const
overrideprotectedvirtualinherited

Computes the values of the yield functions, given p, q and intnl parameters.

Derived classes must override this, to provide the values of the yield functions in yf.

Parameters
pp stress
qq stress
intnlThe internal parameters
[out]yfThe yield function values

Implements TwoParameterPlasticityStressUpdate.

Definition at line 263 of file CappedWeakPlaneStressUpdate.C.

267 {
268  yf[0] = std::sqrt(Utility::pow<2>(q) + _small_smoother2) + p * _tan_phi.value(intnl[0]) -
269  _cohesion.value(intnl[0]);
270 
271  if (_stress_return_type == StressReturnType::no_tension)
272  yf[1] = std::numeric_limits<Real>::lowest();
273  else
274  yf[1] = p - _tstrength.value(intnl[1]);
275 
276  if (_stress_return_type == StressReturnType::no_compression)
277  yf[2] = std::numeric_limits<Real>::lowest();
278  else
279  yf[2] = -p - _cstrength.value(intnl[1]);
280 }

◆ yieldFunctionValuesV()

void TwoParameterPlasticityStressUpdate::yieldFunctionValuesV ( const std::vector< Real > &  stress_params,
const std::vector< Real > &  intnl,
std::vector< Real > &  yf 
) const
overrideprotectedvirtualinherited

Computes the values of the yield functions, given stress_params and intnl parameters.

Derived classes must override this, to provide the values of the yield functions in yf.

Parameters
stress_params[in]The stress parameters
intnl[in]The internal parameters
[out]yfThe yield function values

Implements MultiParameterPlasticityStressUpdate.

Definition at line 42 of file TwoParameterPlasticityStressUpdate.C.

45 {
46  const Real p = stress_params[0];
47  const Real q = stress_params[1];
48  yieldFunctionValues(p, q, intnl, yf);
49 }

Member Data Documentation

◆ _base_name

const std::string StressUpdateBase::_base_name
protectedinherited

Name used as a prefix for all material properties related to the stress update model.

Definition at line 128 of file StressUpdateBase.h.

◆ _Cij

std::vector<std::vector<Real> > MultiParameterPlasticityStressUpdate::_Cij
protectedinherited

_Cij[i, j] * _Eij[j, k] = 1 iff j == k

Definition at line 144 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::consistentTangentOperatorV(), CappedMohrCoulombCosseratStressUpdate::setEffectiveElasticity(), TensileStressUpdate::setEffectiveElasticity(), CappedMohrCoulombStressUpdate::setEffectiveElasticity(), and TwoParameterPlasticityStressUpdate::setEffectiveElasticity().

◆ _cohesion

const TensorMechanicsHardeningModel& CappedWeakPlaneStressUpdate::_cohesion
protectedinherited

Hardening model for cohesion.

Definition at line 45 of file CappedWeakPlaneStressUpdate.h.

Referenced by CappedWeakPlaneStressUpdate::CappedWeakPlaneStressUpdate(), CappedWeakPlaneStressUpdate::computeAllQ(), CappedWeakPlaneStressUpdate::initializeVars(), and CappedWeakPlaneStressUpdate::yieldFunctionValues().

◆ _cstrength

const TensorMechanicsHardeningModel& CappedWeakPlaneStressUpdate::_cstrength
protectedinherited

Hardening model for compressive strength.

Definition at line 57 of file CappedWeakPlaneStressUpdate.h.

Referenced by CappedWeakPlaneStressUpdate::CappedWeakPlaneStressUpdate(), CappedWeakPlaneStressUpdate::computeAllQ(), CappedWeakPlaneStressUpdate::initializeVars(), and CappedWeakPlaneStressUpdate::yieldFunctionValues().

◆ _current_intnl

std::vector<Real> MultiParameterPlasticityStressUpdate::_current_intnl
privateinherited

The current values of the internal params during the Newton-Raphson.

Definition at line 737 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _current_sp

std::vector<Real> MultiParameterPlasticityStressUpdate::_current_sp
privateinherited

The current values of the stress params during the Newton-Raphson.

Definition at line 732 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _definitely_ok_sp

const std::vector<Real> MultiParameterPlasticityStressUpdate::_definitely_ok_sp
protectedinherited

An admissible value of stress_params at the initial time.

Definition at line 135 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::MultiParameterPlasticityStressUpdate(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _del_stress_params

std::vector<Real> MultiParameterPlasticityStressUpdate::_del_stress_params
privateinherited

_del_stress_params = trial_stress_params - ok_sp This is fixed at the beginning of the return-map process, irrespective of substepping.

The return-map problem is: apply del_stress_params to stress_prams, and then find an admissible (returned) stress_params and gaE

Definition at line 727 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _dgaE_dpt

Real TwoParameterPlasticityStressUpdate::_dgaE_dpt
protectedinherited

derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation)

Definition at line 55 of file TwoParameterPlasticityStressUpdate.h.

Referenced by consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), and TwoParameterPlasticityStressUpdate::consistentTangentOperatorV().

◆ _dgaE_dqt

Real TwoParameterPlasticityStressUpdate::_dgaE_dqt
protectedinherited

derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation)

Definition at line 57 of file TwoParameterPlasticityStressUpdate.h.

Referenced by consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), and TwoParameterPlasticityStressUpdate::consistentTangentOperatorV().

◆ _dp_dpt

Real TwoParameterPlasticityStressUpdate::_dp_dpt
protectedinherited

derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation)

Definition at line 59 of file TwoParameterPlasticityStressUpdate.h.

Referenced by consistentTangentOperator(), CappedDruckerPragerCosseratStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), CappedDruckerPragerStressUpdate::consistentTangentOperator(), TwoParameterPlasticityStressUpdate::consistentTangentOperator(), and TwoParameterPlasticityStressUpdate::consistentTangentOperatorV().

◆ _dp_dqt

Real TwoParameterPlasticityStressUpdate::_dp_dqt
protectedinherited

derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation)

Definition at line 63 of file TwoParameterPlasticityStressUpdate.h.

Referenced by consistentTangentOperator(), CappedDruckerPragerCosseratStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), CappedDruckerPragerStressUpdate::consistentTangentOperator(), TwoParameterPlasticityStressUpdate::consistentTangentOperator(), and TwoParameterPlasticityStressUpdate::consistentTangentOperatorV().

◆ _dq_dpt

Real TwoParameterPlasticityStressUpdate::_dq_dpt
protectedinherited

derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation)

Definition at line 61 of file TwoParameterPlasticityStressUpdate.h.

Referenced by consistentTangentOperator(), CappedDruckerPragerCosseratStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), CappedDruckerPragerStressUpdate::consistentTangentOperator(), TwoParameterPlasticityStressUpdate::consistentTangentOperator(), and TwoParameterPlasticityStressUpdate::consistentTangentOperatorV().

◆ _dq_dqt

Real TwoParameterPlasticityStressUpdate::_dq_dqt
protectedinherited

derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculation)

Definition at line 65 of file TwoParameterPlasticityStressUpdate.h.

Referenced by consistentTangentOperator(), CappedDruckerPragerCosseratStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), CappedDruckerPragerStressUpdate::consistentTangentOperator(), TwoParameterPlasticityStressUpdate::consistentTangentOperator(), and TwoParameterPlasticityStressUpdate::consistentTangentOperatorV().

◆ _dvar_dtrial

std::vector<std::vector<Real> > MultiParameterPlasticityStressUpdate::_dvar_dtrial
privateinherited

d({stress_param[i], gaE})/d(trial_stress_param[j])

Definition at line 703 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _Eij

std::vector<std::vector<Real> > MultiParameterPlasticityStressUpdate::_Eij
protectedinherited

E[i, j] in the system of equations to be solved.

Definition at line 138 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::calculateRHS(), MultiParameterPlasticityStressUpdate::dnRHSdVar(), MultiParameterPlasticityStressUpdate::dVardTrial(), CappedMohrCoulombStressUpdate::initializeVarsV(), CappedMohrCoulombCosseratStressUpdate::setEffectiveElasticity(), TensileStressUpdate::setEffectiveElasticity(), CappedMohrCoulombStressUpdate::setEffectiveElasticity(), TwoParameterPlasticityStressUpdate::setEffectiveElasticity(), TensileStressUpdate::setIntnlDerivativesV(), CappedMohrCoulombStressUpdate::setIntnlDerivativesV(), TensileStressUpdate::setIntnlValuesV(), and CappedMohrCoulombStressUpdate::setIntnlValuesV().

◆ _En

Real MultiParameterPlasticityStressUpdate::_En
protectedinherited

normalising factor

Definition at line 141 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::calculateRHS(), MultiParameterPlasticityStressUpdate::consistentTangentOperatorV(), MultiParameterPlasticityStressUpdate::dnRHSdVar(), MultiParameterPlasticityStressUpdate::dVardTrial(), CappedMohrCoulombCosseratStressUpdate::setEffectiveElasticity(), TensileStressUpdate::setEffectiveElasticity(), CappedMohrCoulombStressUpdate::setEffectiveElasticity(), TwoParameterPlasticityStressUpdate::setEffectiveElasticity(), and MultiParameterPlasticityStressUpdate::setInelasticStrainIncrementAfterReturn().

◆ _Epp

Real TwoParameterPlasticityStressUpdate::_Epp
protectedinherited

elasticity tensor in p direction

Definition at line 49 of file TwoParameterPlasticityStressUpdate.h.

Referenced by CappedDruckerPragerCosseratStressUpdate::consistentTangentOperator(), CappedDruckerPragerStressUpdate::consistentTangentOperator(), TwoParameterPlasticityStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::initializeVars(), CappedDruckerPragerStressUpdate::initializeVars(), TwoParameterPlasticityStressUpdate::setEffectiveElasticity(), TwoParameterPlasticityStressUpdate::setInelasticStrainIncrementAfterReturn(), CappedWeakPlaneStressUpdate::setIntnlDerivatives(), CappedDruckerPragerStressUpdate::setIntnlDerivatives(), CappedWeakPlaneStressUpdate::setIntnlValues(), CappedDruckerPragerStressUpdate::setIntnlValues(), setStressAfterReturn(), CappedWeakInclinedPlaneStressUpdate::setStressAfterReturn(), and CappedWeakPlaneStressUpdate::setStressAfterReturn().

◆ _Eqq

Real TwoParameterPlasticityStressUpdate::_Eqq
protectedinherited

elasticity tensor in q direction

Definition at line 52 of file TwoParameterPlasticityStressUpdate.h.

Referenced by CappedDruckerPragerStressUpdate::consistentTangentOperator(), TwoParameterPlasticityStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::initializeVars(), CappedDruckerPragerStressUpdate::initializeVars(), TwoParameterPlasticityStressUpdate::setEffectiveElasticity(), CappedWeakPlaneStressUpdate::setIntnlDerivatives(), CappedDruckerPragerStressUpdate::setIntnlDerivatives(), CappedWeakPlaneStressUpdate::setIntnlValues(), and CappedDruckerPragerStressUpdate::setIntnlValues().

◆ _f_tol

const Real MultiParameterPlasticityStressUpdate::_f_tol
protectedinherited

The yield-function tolerance.

Definition at line 165 of file MultiParameterPlasticityStressUpdate.h.

Referenced by CappedMohrCoulombStressUpdate::initializeVarsV(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _f_tol2

const Real MultiParameterPlasticityStressUpdate::_f_tol2
protectedinherited

Square of the yield-function tolerance.

Definition at line 168 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _in_q_trial

Real CappedWeakPlaneStressUpdate::_in_q_trial
protectedinherited

trial value of q

Definition at line 92 of file CappedWeakPlaneStressUpdate.h.

Referenced by CappedWeakInclinedPlaneStressUpdate::preReturnMap(), CappedWeakPlaneStressUpdate::preReturnMap(), setStressAfterReturn(), CappedWeakInclinedPlaneStressUpdate::setStressAfterReturn(), and CappedWeakPlaneStressUpdate::setStressAfterReturn().

◆ _in_trial02

Real CappedWeakPlaneStressUpdate::_in_trial02
protectedinherited

trial value of stress(0, 2)

Definition at line 86 of file CappedWeakPlaneStressUpdate.h.

Referenced by consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), CappedWeakInclinedPlaneStressUpdate::preReturnMap(), CappedWeakPlaneStressUpdate::preReturnMap(), setStressAfterReturn(), CappedWeakInclinedPlaneStressUpdate::setStressAfterReturn(), and CappedWeakPlaneStressUpdate::setStressAfterReturn().

◆ _in_trial12

Real CappedWeakPlaneStressUpdate::_in_trial12
protectedinherited

trial value of stress(1, 2)

Definition at line 89 of file CappedWeakPlaneStressUpdate.h.

Referenced by consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), CappedWeakInclinedPlaneStressUpdate::preReturnMap(), CappedWeakPlaneStressUpdate::preReturnMap(), setStressAfterReturn(), CappedWeakInclinedPlaneStressUpdate::setStressAfterReturn(), and CappedWeakPlaneStressUpdate::setStressAfterReturn().

◆ _intnl

MaterialProperty<std::vector<Real> >& MultiParameterPlasticityStressUpdate::_intnl
protectedinherited

internal parameters

Definition at line 190 of file MultiParameterPlasticityStressUpdate.h.

Referenced by consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _intnl_old

const MaterialProperty<std::vector<Real> >& MultiParameterPlasticityStressUpdate::_intnl_old
protectedinherited

old values of internal parameters

Definition at line 193 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _iter

MaterialProperty<Real>& MultiParameterPlasticityStressUpdate::_iter
protectedinherited

Number of Newton-Raphson iterations used in the return-map.

Definition at line 199 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _linesearch_needed

MaterialProperty<Real>& MultiParameterPlasticityStressUpdate::_linesearch_needed
protectedinherited

Whether a line-search was needed in the latest Newton-Raphson process (1 if true, 0 otherwise)

Definition at line 208 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _max_iter_used

MaterialProperty<Real>& MultiParameterPlasticityStressUpdate::_max_iter_used
protectedinherited

Maximum number of Newton-Raphson iterations used in the return-map during the course of the entire simulation.

Definition at line 202 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _max_iter_used_old

const MaterialProperty<Real>& MultiParameterPlasticityStressUpdate::_max_iter_used_old
protectedinherited

Old value of maximum number of Newton-Raphson iterations used in the return-map during the course of the entire simulation.

Definition at line 205 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _max_nr_its

const unsigned MultiParameterPlasticityStressUpdate::_max_nr_its
protectedinherited

Maximum number of Newton-Raphson iterations allowed in the return-map process.

Definition at line 153 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _min_step_size

const Real MultiParameterPlasticityStressUpdate::_min_step_size
protectedinherited

In order to help the Newton-Raphson procedure, the applied strain increment may be applied in sub-increments of size greater than this value.

Definition at line 175 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _num_intnl

const unsigned MultiParameterPlasticityStressUpdate::_num_intnl
protectedinherited

Number of internal parameters.

Definition at line 150 of file MultiParameterPlasticityStressUpdate.h.

Referenced by CappedMohrCoulombStressUpdate::computeAllQV(), MultiParameterPlasticityStressUpdate::dnRHSdVar(), MultiParameterPlasticityStressUpdate::dVardTrial(), MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::nrStep(), MultiParameterPlasticityStressUpdate::smoothAllQuantities(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _num_pq

constexpr static int TwoParameterPlasticityStressUpdate::_num_pq = 2
staticconstexprprotectedinherited

Number of variables = 2 = (p, q)

Definition at line 40 of file TwoParameterPlasticityStressUpdate.h.

Referenced by TwoParameterPlasticityStressUpdate::d2stress_param_dstress(), and TwoParameterPlasticityStressUpdate::dstress_param_dstress().

◆ _num_sp

const unsigned MultiParameterPlasticityStressUpdate::_num_sp
protectedinherited

Number of stress parameters.

Definition at line 132 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::calculateRHS(), TensileStressUpdate::computeAllQV(), CappedMohrCoulombStressUpdate::computeAllQV(), TensileStressUpdate::consistentTangentOperatorV(), CappedMohrCoulombStressUpdate::consistentTangentOperatorV(), MultiParameterPlasticityStressUpdate::consistentTangentOperatorV(), MultiParameterPlasticityStressUpdate::dnRHSdVar(), MultiParameterPlasticityStressUpdate::dVardTrial(), TensileStressUpdate::initializeVarsV(), CappedMohrCoulombStressUpdate::initializeVarsV(), MultiParameterPlasticityStressUpdate::lineSearch(), MultiParameterPlasticityStressUpdate::MultiParameterPlasticityStressUpdate(), MultiParameterPlasticityStressUpdate::nrStep(), MultiParameterPlasticityStressUpdate::precisionLoss(), CappedMohrCoulombCosseratStressUpdate::setEffectiveElasticity(), TensileStressUpdate::setEffectiveElasticity(), CappedMohrCoulombStressUpdate::setEffectiveElasticity(), MultiParameterPlasticityStressUpdate::setInelasticStrainIncrementAfterReturn(), CappedMohrCoulombStressUpdate::setIntnlDerivativesV(), MultiParameterPlasticityStressUpdate::smoothAllQuantities(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _num_yf

const unsigned MultiParameterPlasticityStressUpdate::_num_yf
protectedinherited

Number of yield functions.

Definition at line 147 of file MultiParameterPlasticityStressUpdate.h.

Referenced by TensileStressUpdate::computeAllQV(), CappedMohrCoulombStressUpdate::computeAllQV(), MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::smoothAllQuantities(), MultiParameterPlasticityStressUpdate::updateState(), and MultiParameterPlasticityStressUpdate::yieldF().

◆ _ok_intnl

std::vector<Real> MultiParameterPlasticityStressUpdate::_ok_intnl
privateinherited

The state (ok_sp, ok_intnl) is known to be admissible.

Definition at line 718 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _ok_sp

std::vector<Real> MultiParameterPlasticityStressUpdate::_ok_sp
privateinherited

The state (ok_sp, ok_intnl) is known to be admissible, so ok_sp are stress_params that are "OK".

If the strain_increment is applied in substeps then ok_sp is updated after each sub strain_increment is applied and the return-map is successful. At the end of the entire return-map process _ok_sp will contain the stress_params where (_ok_sp, _intnl) is admissible.

Definition at line 713 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _p_trial

Real TwoParameterPlasticityStressUpdate::_p_trial
protectedinherited

Trial value of p.

Definition at line 43 of file TwoParameterPlasticityStressUpdate.h.

◆ _perfect_guess

const bool CappedWeakPlaneStressUpdate::_perfect_guess
protectedinherited

Initialize the NR proceedure from a guess coming from perfect plasticity.

Definition at line 63 of file CappedWeakPlaneStressUpdate.h.

Referenced by CappedWeakPlaneStressUpdate::initializeVars().

◆ _perform_finite_strain_rotations

const bool MultiParameterPlasticityStressUpdate::_perform_finite_strain_rotations
protectedinherited

Whether to perform finite-strain rotations.

Definition at line 156 of file MultiParameterPlasticityStressUpdate.h.

Referenced by CappedWeakInclinedPlaneStressUpdate::finalizeReturnProcess(), and CappedWeakInclinedPlaneStressUpdate::initializeReturnProcess().

◆ _plastic_strain

MaterialProperty<RankTwoTensor>& MultiParameterPlasticityStressUpdate::_plastic_strain
protectedinherited

plastic strain

Definition at line 184 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _plastic_strain_old

const MaterialProperty<RankTwoTensor>& MultiParameterPlasticityStressUpdate::_plastic_strain_old
protectedinherited

Old value of plastic strain.

Definition at line 187 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _q_trial

Real TwoParameterPlasticityStressUpdate::_q_trial
protectedinherited

Trial value of q.

Definition at line 46 of file TwoParameterPlasticityStressUpdate.h.

◆ _rhs

std::vector<Real> MultiParameterPlasticityStressUpdate::_rhs
privateinherited

0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, i] * dg/dS[i] 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, i] * dg/dS[i] ...

0 = rhs[N-1] = S[N-1] - S[N-1]^trial + ga * E[N-1, i] * dg/dS[i] 0 = rhs[N] = f(S, intnl) Here N = num_sp

Definition at line 698 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _small_smoother2

const Real CappedWeakPlaneStressUpdate::_small_smoother2
protectedinherited

The cone vertex is smoothed by this amount.

Definition at line 60 of file CappedWeakPlaneStressUpdate.h.

Referenced by CappedWeakPlaneStressUpdate::computeAllQ(), and CappedWeakPlaneStressUpdate::yieldFunctionValues().

◆ _smoother_function_type

enum MultiParameterPlasticityStressUpdate::SmootherFunctionType MultiParameterPlasticityStressUpdate::_smoother_function_type
privateinherited

Referenced by MultiParameterPlasticityStressUpdate::dsmoother(), MultiParameterPlasticityStressUpdate::ismoother(), and MultiParameterPlasticityStressUpdate::smoother().

◆ _smoothing_tol

const Real MultiParameterPlasticityStressUpdate::_smoothing_tol
protectedinherited

Smoothing tolerance: edges of the yield surface get smoothed by this amount.

Definition at line 159 of file MultiParameterPlasticityStressUpdate.h.

Referenced by CappedDruckerPragerStressUpdate::CappedDruckerPragerStressUpdate(), CappedWeakPlaneStressUpdate::CappedWeakPlaneStressUpdate(), MultiParameterPlasticityStressUpdate::dsmoother(), MultiParameterPlasticityStressUpdate::ismoother(), MultiParameterPlasticityStressUpdate::smoothAllQuantities(), MultiParameterPlasticityStressUpdate::smoother(), and MultiParameterPlasticityStressUpdate::yieldF().

◆ _smoothing_tol2

const Real MultiParameterPlasticityStressUpdate::_smoothing_tol2
protectedinherited

Square of the smoothing tolerance.

Definition at line 162 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::ismoother().

◆ _step_one

bool MultiParameterPlasticityStressUpdate::_step_one
protectedinherited

handles case of initial_stress that is inadmissible being supplied

Definition at line 178 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _stress_return_type

enum CappedWeakPlaneStressUpdate::StressReturnType CappedWeakPlaneStressUpdate::_stress_return_type
protectedinherited

Referenced by CappedWeakPlaneStressUpdate::computeAllQ(), CappedWeakPlaneStressUpdate::finalizeReturnProcess(), CappedWeakPlaneStressUpdate::initializeReturnProcess(), CappedWeakInclinedPlaneStressUpdate::preReturnMap(), CappedWeakPlaneStressUpdate::preReturnMap(), and CappedWeakPlaneStressUpdate::yieldFunctionValues().

◆ _stress_trial

RankTwoTensor MultiParameterPlasticityStressUpdate::_stress_trial
privateinherited

"Trial" value of stress that is set at the beginning of the return-map process.

It is fixed at stress_old + Eijkl * strain_increment irrespective of any sub-stepping

Definition at line 688 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _tan_phi

const TensorMechanicsHardeningModel& CappedWeakPlaneStressUpdate::_tan_phi
protectedinherited

Hardening model for tan(phi)

Definition at line 48 of file CappedWeakPlaneStressUpdate.h.

Referenced by CappedWeakPlaneStressUpdate::CappedWeakPlaneStressUpdate(), CappedWeakPlaneStressUpdate::computeAllQ(), CappedWeakPlaneStressUpdate::initializeVars(), and CappedWeakPlaneStressUpdate::yieldFunctionValues().

◆ _tan_psi

const TensorMechanicsHardeningModel& CappedWeakPlaneStressUpdate::_tan_psi
protectedinherited

Hardening model for tan(psi)

Definition at line 51 of file CappedWeakPlaneStressUpdate.h.

Referenced by CappedWeakPlaneStressUpdate::CappedWeakPlaneStressUpdate(), CappedWeakPlaneStressUpdate::computeAllQ(), consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::initializeVars(), CappedWeakPlaneStressUpdate::setIntnlDerivatives(), and CappedWeakPlaneStressUpdate::setIntnlValues().

◆ _tensor_dimensionality

constexpr static unsigned MultiParameterPlasticityStressUpdate::_tensor_dimensionality = 3
staticconstexprprotectedinherited

Internal dimensionality of tensors (currently this is 3 throughout tensor_mechanics)

Definition at line 129 of file MultiParameterPlasticityStressUpdate.h.

Referenced by consistentTangentOperator(), CappedDruckerPragerCosseratStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), CappedDruckerPragerStressUpdate::consistentTangentOperator(), TwoParameterPlasticityStressUpdate::consistentTangentOperator(), CappedMohrCoulombCosseratStressUpdate::consistentTangentOperatorV(), TensileStressUpdate::consistentTangentOperatorV(), CappedMohrCoulombStressUpdate::consistentTangentOperatorV(), and CappedWeakPlaneStressUpdate::d2qdstress2().

◆ _trial_sp

std::vector<Real> MultiParameterPlasticityStressUpdate::_trial_sp
privateinherited

"Trial" value of stress_params that initializes the return-map process This is derived from stress = stress_old + Eijkl * strain_increment.

However, since the return-map process can fail and be restarted by applying strain_increment in multiple substeps, _trial_sp can vary from substep to substep.

Definition at line 681 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _tstrength

const TensorMechanicsHardeningModel& CappedWeakPlaneStressUpdate::_tstrength
protectedinherited

Hardening model for tensile strength.

Definition at line 54 of file CappedWeakPlaneStressUpdate.h.

Referenced by CappedWeakPlaneStressUpdate::CappedWeakPlaneStressUpdate(), CappedWeakPlaneStressUpdate::computeAllQ(), CappedWeakPlaneStressUpdate::initializeVars(), and CappedWeakPlaneStressUpdate::yieldFunctionValues().

◆ _warn_about_precision_loss

const bool MultiParameterPlasticityStressUpdate::_warn_about_precision_loss
protectedinherited

Output a warning message if precision loss is encountered during the return-map process.

Definition at line 181 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _yf

MaterialProperty<std::vector<Real> >& MultiParameterPlasticityStressUpdate::_yf
protectedinherited

yield functions

Definition at line 196 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

The documentation for this class was generated from the following files:
MultiParameterPlasticityStressUpdate::computeAllQV
virtual void computeAllQV(const std::vector< Real > &stress_params, const std::vector< Real > &intnl, std::vector< yieldAndFlow > &all_q) const =0
Completely fills all_q with correct values.
MultiParameterPlasticityStressUpdate::_max_nr_its
const unsigned _max_nr_its
Maximum number of Newton-Raphson iterations allowed in the return-map process.
Definition: MultiParameterPlasticityStressUpdate.h:153
MultiParameterPlasticityStressUpdate::_warn_about_precision_loss
const bool _warn_about_precision_loss
Output a warning message if precision loss is encountered during the return-map process.
Definition: MultiParameterPlasticityStressUpdate.h:181
TwoParameterPlasticityStressUpdate::d2qdstress2
virtual RankFourTensor d2qdstress2(const RankTwoTensor &stress) const =0
d2(q)/d(stress)/d(stress) Derived classes must override this
CappedWeakPlaneStressUpdate::_tstrength
const TensorMechanicsHardeningModel & _tstrength
Hardening model for tensile strength.
Definition: CappedWeakPlaneStressUpdate.h:54
MultiParameterPlasticityStressUpdate::_stress_trial
RankTwoTensor _stress_trial
"Trial" value of stress that is set at the beginning of the return-map process.
Definition: MultiParameterPlasticityStressUpdate.h:688
MultiParameterPlasticityStressUpdate::ismoother
Real ismoother(Real f_diff) const
Smooths yield functions.
Definition: MultiParameterPlasticityStressUpdate.C:484
MultiParameterPlasticityStressUpdate::_current_intnl
std::vector< Real > _current_intnl
The current values of the internal params during the Newton-Raphson.
Definition: MultiParameterPlasticityStressUpdate.h:737
MultiParameterPlasticityStressUpdate::SmootherFunctionType::poly1
MultiParameterPlasticityStressUpdate::SmootherFunctionType::cos
CappedWeakPlaneStressUpdate::_cohesion
const TensorMechanicsHardeningModel & _cohesion
Hardening model for cohesion.
Definition: CappedWeakPlaneStressUpdate.h:45
CappedWeakPlaneStressUpdate::_perfect_guess
const bool _perfect_guess
Initialize the NR proceedure from a guess coming from perfect plasticity.
Definition: CappedWeakPlaneStressUpdate.h:63
MultiParameterPlasticityStressUpdate::_smoothing_tol
const Real _smoothing_tol
Smoothing tolerance: edges of the yield surface get smoothed by this amount.
Definition: MultiParameterPlasticityStressUpdate.h:159
TangentCalculationMethod::FULL
MultiParameterPlasticityStressUpdate::finalizeReturnProcess
virtual void finalizeReturnProcess(const RankTwoTensor &rotation_increment)
Derived classes may use this to perform calculations after the return-map process has completed succe...
Definition: MultiParameterPlasticityStressUpdate.C:672
CappedWeakPlaneStressUpdate::_in_trial02
Real _in_trial02
trial value of stress(0, 2)
Definition: CappedWeakPlaneStressUpdate.h:86
MultiParameterPlasticityStressUpdate::_smoother_function_type
enum MultiParameterPlasticityStressUpdate::SmootherFunctionType _smoother_function_type
MultiParameterPlasticityStressUpdate::_Cij
std::vector< std::vector< Real > > _Cij
_Cij[i, j] * _Eij[j, k] = 1 iff j == k
Definition: MultiParameterPlasticityStressUpdate.h:144
MultiParameterPlasticityStressUpdate::lineSearch
int lineSearch(Real &res2, std::vector< Real > &stress_params, Real &gaE, const std::vector< Real > &trial_stress_params, yieldAndFlow &smoothed_q, const std::vector< Real > &intnl_ok, std::vector< Real > &intnl, std::vector< Real > &rhs, Real &linesearch_needed) const
Performs a line-search to find stress_params and gaE Upon entry:
Definition: MultiParameterPlasticityStressUpdate.C:553
pow
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)
Definition: ExpressionBuilder.h:673
TwoParameterPlasticityStressUpdate::d2pdstress2
virtual RankFourTensor d2pdstress2(const RankTwoTensor &stress) const =0
d2(p)/d(stress)/d(stress) Derived classes must override this
TwoParameterPlasticityStressUpdate::yieldFunctionValues
virtual void yieldFunctionValues(Real p, Real q, const std::vector< Real > &intnl, std::vector< Real > &yf) const =0
Computes the values of the yield functions, given p, q and intnl parameters.
MultiParameterPlasticityStressUpdate::SmootherFunctionType::poly3
MultiParameterPlasticityStressUpdate::_iter
MaterialProperty< Real > & _iter
Number of Newton-Raphson iterations used in the return-map.
Definition: MultiParameterPlasticityStressUpdate.h:199
MultiParameterPlasticityStressUpdate::_f_tol2
const Real _f_tol2
Square of the yield-function tolerance.
Definition: MultiParameterPlasticityStressUpdate.h:168
MultiParameterPlasticityStressUpdate::_min_step_size
const Real _min_step_size
In order to help the Newton-Raphson procedure, the applied strain increment may be applied in sub-inc...
Definition: MultiParameterPlasticityStressUpdate.h:175
MultiParameterPlasticityStressUpdate::setEffectiveElasticity
virtual void setEffectiveElasticity(const RankFourTensor &Eijkl)=0
Sets _Eij and _En and _Cij.
TwoParameterPlasticityStressUpdate::setEppEqq
virtual void setEppEqq(const RankFourTensor &Eijkl, Real &Epp, Real &Eqq) const =0
Set Epp and Eqq based on the elasticity tensor Derived classes must override this.
TwoParameterPlasticityStressUpdate::setIntnlValues
virtual void setIntnlValues(Real p_trial, Real q_trial, Real p, Real q, const std::vector< Real > &intnl_old, std::vector< Real > &intnl) const =0
Sets the internal parameters based on the trial values of p and q, their current values,...
MultiParameterPlasticityStressUpdate::initQpStatefulProperties
virtual void initQpStatefulProperties() override
Definition: MultiParameterPlasticityStressUpdate.C:141
MultiParameterPlasticityStressUpdate::_ok_intnl
std::vector< Real > _ok_intnl
The state (ok_sp, ok_intnl) is known to be admissible.
Definition: MultiParameterPlasticityStressUpdate.h:718
TwoParameterPlasticityStressUpdate::_dp_dqt
Real _dp_dqt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:63
MultiParameterPlasticityStressUpdate::_linesearch_needed
MaterialProperty< Real > & _linesearch_needed
Whether a line-search was needed in the latest Newton-Raphson process (1 if true, 0 otherwise)
Definition: MultiParameterPlasticityStressUpdate.h:208
TwoParameterPlasticityStressUpdate::_Epp
Real _Epp
elasticity tensor in p direction
Definition: TwoParameterPlasticityStressUpdate.h:49
CappedWeakPlaneStressUpdate::StressReturnType::no_tension
TwoParameterPlasticityStressUpdate::_dgaE_dqt
Real _dgaE_dqt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:57
MultiParameterPlasticityStressUpdate::dVardTrial
void dVardTrial(bool elastic_only, const std::vector< Real > &trial_stress_params, const std::vector< Real > &stress_params, Real gaE, const std::vector< Real > &intnl, const yieldAndFlow &smoothed_q, Real step_size, bool compute_full_tangent_operator, std::vector< std::vector< Real >> &dvar_dtrial) const
Calculates derivatives of the stress_params and gaE with repect to the trial values of the stress_par...
Definition: MultiParameterPlasticityStressUpdate.C:873
MultiParameterPlasticityStressUpdate::initializeVarsV
virtual void initializeVarsV(const std::vector< Real > &trial_stress_params, const std::vector< Real > &intnl_old, std::vector< Real > &stress_params, Real &gaE, std::vector< Real > &intnl) const
Sets (stress_params, intnl) at "good guesses" of the solution to the Return-Map algorithm.
Definition: MultiParameterPlasticityStressUpdate.C:713
CappedWeakPlaneStressUpdate::validParams
static InputParameters validParams()
Definition: CappedWeakPlaneStressUpdate.C:19
MultiParameterPlasticityStressUpdate::precisionLoss
bool precisionLoss(const std::vector< Real > &solution, const std::vector< Real > &stress_params, Real gaE) const
Check whether precision loss has occurred.
Definition: MultiParameterPlasticityStressUpdate.C:983
TwoParameterPlasticityStressUpdate::_dq_dqt
Real _dq_dqt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:65
MultiParameterPlasticityStressUpdate::_plastic_strain_old
const MaterialProperty< RankTwoTensor > & _plastic_strain_old
Old value of plastic strain.
Definition: MultiParameterPlasticityStressUpdate.h:187
MultiParameterPlasticityStressUpdate::_Eij
std::vector< std::vector< Real > > _Eij
E[i, j] in the system of equations to be solved.
Definition: MultiParameterPlasticityStressUpdate.h:138
MultiParameterPlasticityStressUpdate::yieldF
Real yieldF(const std::vector< Real > &stress_params, const std::vector< Real > &intnl) const
Computes the smoothed yield function.
Definition: MultiParameterPlasticityStressUpdate.C:688
MultiParameterPlasticityStressUpdate::_del_stress_params
std::vector< Real > _del_stress_params
_del_stress_params = trial_stress_params - ok_sp This is fixed at the beginning of the return-map pro...
Definition: MultiParameterPlasticityStressUpdate.h:727
CappedWeakPlaneStressUpdate::StressReturnType::nothing_special
CappedWeakPlaneStressUpdate::_small_smoother2
const Real _small_smoother2
The cone vertex is smoothed by this amount.
Definition: CappedWeakPlaneStressUpdate.h:60
MultiParameterPlasticityStressUpdate::_intnl_old
const MaterialProperty< std::vector< Real > > & _intnl_old
old values of internal parameters
Definition: MultiParameterPlasticityStressUpdate.h:193
MultiParameterPlasticityStressUpdate::computeStressParams
virtual void computeStressParams(const RankTwoTensor &stress, std::vector< Real > &stress_params) const =0
Computes stress_params, given stress.
TwoParameterPlasticityStressUpdate::computePQ
virtual void computePQ(const RankTwoTensor &stress, Real &p, Real &q) const =0
Computes p and q, given stress.
MultiParameterPlasticityStressUpdate::initializeReturnProcess
virtual void initializeReturnProcess()
Derived classes may use this to perform calculations before any return-map process is performed,...
Definition: MultiParameterPlasticityStressUpdate.C:667
MultiParameterPlasticityStressUpdate::smoother
Real smoother(Real f_diff) const
Derivative of ismoother.
Definition: MultiParameterPlasticityStressUpdate.C:510
MultiParameterPlasticityStressUpdate::_rhs
std::vector< Real > _rhs
0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, i] * dg/dS[i] 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1,...
Definition: MultiParameterPlasticityStressUpdate.h:698
CappedWeakPlaneStressUpdate::_tan_psi
const TensorMechanicsHardeningModel & _tan_psi
Hardening model for tan(psi)
Definition: CappedWeakPlaneStressUpdate.h:51
MultiParameterPlasticityStressUpdate::_num_sp
const unsigned _num_sp
Number of stress parameters.
Definition: MultiParameterPlasticityStressUpdate.h:132
CappedWeakPlaneStressUpdate::_in_trial12
Real _in_trial12
trial value of stress(1, 2)
Definition: CappedWeakPlaneStressUpdate.h:89
CappedWeakPlaneStressUpdate::_tan_phi
const TensorMechanicsHardeningModel & _tan_phi
Hardening model for tan(phi)
Definition: CappedWeakPlaneStressUpdate.h:48
MultiParameterPlasticityStressUpdate::yieldFunctionValuesV
virtual void yieldFunctionValuesV(const std::vector< Real > &stress_params, const std::vector< Real > &intnl, std::vector< Real > &yf) const =0
Computes the values of the yield functions, given stress_params and intnl parameters.
TwoParameterPlasticityStressUpdate::_dp_dpt
Real _dp_dpt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:59
MultiParameterPlasticityStressUpdate::_yf
MaterialProperty< std::vector< Real > > & _yf
yield functions
Definition: MultiParameterPlasticityStressUpdate.h:196
MultiParameterPlasticityStressUpdate::_num_yf
const unsigned _num_yf
Number of yield functions.
Definition: MultiParameterPlasticityStressUpdate.h:147
CappedWeakPlaneStressUpdate::_cstrength
const TensorMechanicsHardeningModel & _cstrength
Hardening model for compressive strength.
Definition: CappedWeakPlaneStressUpdate.h:57
MultiParameterPlasticityStressUpdate::dnRHSdVar
void dnRHSdVar(const yieldAndFlow &smoothed_q, const std::vector< std::vector< Real >> &dintnl, const std::vector< Real > &stress_params, Real gaE, std::vector< double > &jac) const
Derivative of -RHS with respect to the stress_params and gaE, placed into an array ready for solving ...
Definition: MultiParameterPlasticityStressUpdate.C:828
MultiParameterPlasticityStressUpdate::_plastic_strain
MaterialProperty< RankTwoTensor > & _plastic_strain
plastic strain
Definition: MultiParameterPlasticityStressUpdate.h:184
TensorMechanicsHardeningModel::derivative
virtual Real derivative(Real intnl) const
Definition: TensorMechanicsHardeningModel.C:47
CappedWeakPlaneStressUpdate::_in_q_trial
Real _in_q_trial
trial value of q
Definition: CappedWeakPlaneStressUpdate.h:92
MultiParameterPlasticityStressUpdate::_definitely_ok_sp
const std::vector< Real > _definitely_ok_sp
An admissible value of stress_params at the initial time.
Definition: MultiParameterPlasticityStressUpdate.h:135
CappedWeakPlaneStressUpdate::StressReturnType::no_compression
TwoParameterPlasticityStressUpdate::preReturnMap
virtual void preReturnMap(Real p_trial, Real q_trial, const RankTwoTensor &stress_trial, const std::vector< Real > &intnl_old, const std::vector< Real > &yf, const RankFourTensor &Eijkl)
Derived classes may employ this function to record stuff or do other computations prior to the return...
Definition: TwoParameterPlasticityStressUpdate.C:77
TwoParameterPlasticityStressUpdate::dpdstress
virtual RankTwoTensor dpdstress(const RankTwoTensor &stress) const =0
d(p)/d(stress) Derived classes must override this
MultiParameterPlasticityStressUpdate::_trial_sp
std::vector< Real > _trial_sp
"Trial" value of stress_params that initializes the return-map process This is derived from stress = ...
Definition: MultiParameterPlasticityStressUpdate.h:681
TwoParameterPlasticityStressUpdate::_dgaE_dpt
Real _dgaE_dpt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:55
TensorMechanicsHardeningModel::value
virtual Real value(Real intnl) const
Definition: TensorMechanicsHardeningModel.C:45
MultiParameterPlasticityStressUpdate::_num_intnl
const unsigned _num_intnl
Number of internal parameters.
Definition: MultiParameterPlasticityStressUpdate.h:150
RankTwoTensor
RankTwoTensorTempl< Real > RankTwoTensor
Definition: ACGrGrElasticDrivingForce.h:17
MultiParameterPlasticityStressUpdate::_step_one
bool _step_one
handles case of initial_stress that is inadmissible being supplied
Definition: MultiParameterPlasticityStressUpdate.h:178
MultiParameterPlasticityStressUpdate::dsmoother
Real dsmoother(Real f_diff) const
Derivative of smoother.
Definition: MultiParameterPlasticityStressUpdate.C:533
MultiParameterPlasticityStressUpdate::calculateRes2
Real calculateRes2(const std::vector< Real > &rhs) const
Calculates the residual-squared for the Newton-Raphson + line-search.
Definition: MultiParameterPlasticityStressUpdate.C:802
MultiParameterPlasticityStressUpdate::setIntnlDerivativesV
virtual void setIntnlDerivativesV(const std::vector< Real > &trial_stress_params, const std::vector< Real > &current_stress_params, const std::vector< Real > &intnl, std::vector< std::vector< Real >> &dintnl) const =0
Sets the derivatives of internal parameters, based on the trial values of stress_params,...
TwoParameterPlasticityStressUpdate::initializeVars
virtual void initializeVars(Real p_trial, Real q_trial, const std::vector< Real > &intnl_old, Real &p, Real &q, Real &gaE, std::vector< Real > &intnl) const
Sets (p, q, gaE, intnl) at "good guesses" of the solution to the Return-Map algorithm.
Definition: TwoParameterPlasticityStressUpdate.C:88
MultiParameterPlasticityStressUpdate::errorHandler
virtual void errorHandler(const std::string &message) const
Performs any necessary cleaning-up, then throw MooseException(message)
Definition: MultiParameterPlasticityStressUpdate.C:661
MultiParameterPlasticityStressUpdate::_current_sp
std::vector< Real > _current_sp
The current values of the stress params during the Newton-Raphson.
Definition: MultiParameterPlasticityStressUpdate.h:732
MultiParameterPlasticityStressUpdate::_En
Real _En
normalising factor
Definition: MultiParameterPlasticityStressUpdate.h:141
TwoParameterPlasticityStressUpdate::_num_pq
constexpr static int _num_pq
Number of variables = 2 = (p, q)
Definition: TwoParameterPlasticityStressUpdate.h:40
CappedWeakPlaneStressUpdate::CappedWeakPlaneStressUpdate
CappedWeakPlaneStressUpdate(const InputParameters &parameters)
Definition: CappedWeakPlaneStressUpdate.C:59
TwoParameterPlasticityStressUpdate::setIntnlDerivatives
virtual void setIntnlDerivatives(Real p_trial, Real q_trial, Real p, Real q, const std::vector< Real > &intnl, std::vector< std::vector< Real >> &dintnl) const =0
Sets the derivatives of internal parameters, based on the trial values of p and q,...
RankFourTensorTempl
Definition: ACGrGrElasticDrivingForce.h:20
TwoParameterPlasticityStressUpdate::setStressAfterReturn
virtual void setStressAfterReturn(const RankTwoTensor &stress_trial, Real p_ok, Real q_ok, Real gaE, const std::vector< Real > &intnl, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, RankTwoTensor &stress) const =0
Sets stress from the admissible parameters.
MultiParameterPlasticityStressUpdate::consistentTangentOperatorV
virtual void consistentTangentOperatorV(const RankTwoTensor &stress_trial, const std::vector< Real > &trial_stress_params, const RankTwoTensor &stress, const std::vector< Real > &stress_params, Real gaE, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, bool compute_full_tangent_operator, const std::vector< std::vector< Real >> &dvar_dtrial, RankFourTensor &cto)
Calculates the consistent tangent operator.
Definition: MultiParameterPlasticityStressUpdate.C:725
MultiParameterPlasticityStressUpdate::_max_iter_used
MaterialProperty< Real > & _max_iter_used
Maximum number of Newton-Raphson iterations used in the return-map during the course of the entire si...
Definition: MultiParameterPlasticityStressUpdate.h:202
MultiParameterPlasticityStressUpdate::SmootherFunctionType::poly2
MultiParameterPlasticityStressUpdate::setIntnlValuesV
virtual void setIntnlValuesV(const std::vector< Real > &trial_stress_params, const std::vector< Real > &current_stress_params, const std::vector< Real > &intnl_old, std::vector< Real > &intnl) const =0
Sets the internal parameters based on the trial values of stress_params, their current values,...
MultiParameterPlasticityStressUpdate::_dvar_dtrial
std::vector< std::vector< Real > > _dvar_dtrial
d({stress_param[i], gaE})/d(trial_stress_param[j])
Definition: MultiParameterPlasticityStressUpdate.h:703
MultiParameterPlasticityStressUpdate::smoothAllQuantities
yieldAndFlow smoothAllQuantities(const std::vector< Real > &stress_params, const std::vector< Real > &intnl) const
Calculates all yield functions and derivatives, and then performs the smoothing scheme.
Definition: MultiParameterPlasticityStressUpdate.C:400
TwoParameterPlasticityStressUpdate::_dq_dpt
Real _dq_dpt
derivative of Variable with respect to trial variable (used in consistent-tangent-operator calculatio...
Definition: TwoParameterPlasticityStressUpdate.h:61
MultiParameterPlasticityStressUpdate::calculateRHS
void calculateRHS(const std::vector< Real > &trial_stress_params, const std::vector< Real > &stress_params, Real gaE, const yieldAndFlow &smoothed_q, std::vector< Real > &rhs) const
Calculates the RHS in the following 0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, j] * dg/dS[j] 0 = rhs[...
Definition: MultiParameterPlasticityStressUpdate.C:811
RankTwoTensorTempl< Real >
TwoParameterPlasticityStressUpdate::_Eqq
Real _Eqq
elasticity tensor in q direction
Definition: TwoParameterPlasticityStressUpdate.h:52
CappedWeakPlaneStressUpdate::_stress_return_type
enum CappedWeakPlaneStressUpdate::StressReturnType _stress_return_type
MultiParameterPlasticityStressUpdate::_ok_sp
std::vector< Real > _ok_sp
The state (ok_sp, ok_intnl) is known to be admissible, so ok_sp are stress_params that are "OK".
Definition: MultiParameterPlasticityStressUpdate.h:713
MultiParameterPlasticityStressUpdate::setStressAfterReturnV
virtual void setStressAfterReturnV(const RankTwoTensor &stress_trial, const std::vector< Real > &stress_params, Real gaE, const std::vector< Real > &intnl, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, RankTwoTensor &stress) const =0
Sets stress from the admissible parameters.
MultiParameterPlasticityStressUpdate::preReturnMapV
virtual void preReturnMapV(const std::vector< Real > &trial_stress_params, const RankTwoTensor &stress_trial, const std::vector< Real > &intnl_old, const std::vector< Real > &yf, const RankFourTensor &Eijkl)
Derived classes may employ this function to record stuff or do other computations prior to the return...
Definition: MultiParameterPlasticityStressUpdate.C:678
MultiParameterPlasticityStressUpdate::_smoothing_tol2
const Real _smoothing_tol2
Square of the smoothing tolerance.
Definition: MultiParameterPlasticityStressUpdate.h:162
MultiParameterPlasticityStressUpdate::nrStep
int nrStep(const yieldAndFlow &smoothed_q, const std::vector< Real > &trial_stress_params, const std::vector< Real > &stress_params, const std::vector< Real > &intnl, Real gaE, std::vector< Real > &rhs) const
Performs a Newton-Raphson step to attempt to zero rhs Upon return, rhs will contain the solution.
Definition: MultiParameterPlasticityStressUpdate.C:637
RankFourTensor
RankFourTensorTempl< Real > RankFourTensor
Definition: ACGrGrElasticDrivingForce.h:20
TwoParameterPlasticityStressUpdate::computeAllQ
virtual void computeAllQ(Real p, Real q, const std::vector< Real > &intnl, std::vector< yieldAndFlow > &all_q) const =0
Completely fills all_q with correct values.
MultiParameterPlasticityStressUpdate::_tensor_dimensionality
constexpr static unsigned _tensor_dimensionality
Internal dimensionality of tensors (currently this is 3 throughout tensor_mechanics)
Definition: MultiParameterPlasticityStressUpdate.h:129
MultiParameterPlasticityStressUpdate::_intnl
MaterialProperty< std::vector< Real > > & _intnl
internal parameters
Definition: MultiParameterPlasticityStressUpdate.h:190
TwoParameterPlasticityStressUpdate::consistentTangentOperator
virtual void consistentTangentOperator(const RankTwoTensor &stress_trial, Real p_trial, Real q_trial, const RankTwoTensor &stress, Real p, Real q, Real gaE, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, bool compute_full_tangent_operator, RankFourTensor &cto) const
Calculates the consistent tangent operator.
Definition: TwoParameterPlasticityStressUpdate.C:203
MultiParameterPlasticityStressUpdate::_max_iter_used_old
const MaterialProperty< Real > & _max_iter_used_old
Old value of maximum number of Newton-Raphson iterations used in the return-map during the course of ...
Definition: MultiParameterPlasticityStressUpdate.h:205
CappedWeakPlaneStressUpdate::setIntnlValues
virtual void setIntnlValues(Real p_trial, Real q_trial, Real p, Real q, const std::vector< Real > &intnl_old, std::vector< Real > &intnl) const override
Sets the internal parameters based on the trial values of p and q, their current values,...
Definition: CappedWeakPlaneStressUpdate.C:473
TwoParameterPlasticityStressUpdate::dqdstress
virtual RankTwoTensor dqdstress(const RankTwoTensor &stress) const =0
d(q)/d(stress) Derived classes must override this
MultiParameterPlasticityStressUpdate::setInelasticStrainIncrementAfterReturn
virtual void setInelasticStrainIncrementAfterReturn(const RankTwoTensor &stress_trial, Real gaE, const yieldAndFlow &smoothed_q, const RankFourTensor &elasticity_tensor, const RankTwoTensor &returned_stress, RankTwoTensor &inelastic_strain_increment) const
Sets inelastic strain increment from the returned configuration This is called after the return-map p...
Definition: MultiParameterPlasticityStressUpdate.C:786
MultiParameterPlasticityStressUpdate::_f_tol
const Real _f_tol
The yield-function tolerance.
Definition: MultiParameterPlasticityStressUpdate.h:165
Generated on Sat Jan 25 2020 12:04:56 for www.mooseframework.org by   doxygen 1.8.16