#include <ComputeSimoHughesJ2PlasticityStress.h>

Inheritance diagram for ComputeSimoHughesJ2PlasticityStress:

Public Types
typedef DerivativeMaterialPropertyNameInterface::SymbolName	SymbolName

Public Member Functions
	ComputeSimoHughesJ2PlasticityStress (const InputParameters &parameters)

virtual void	initialSetup () override

const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialProperty (const std::string &name)

const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialPropertyByName (const std::string &name)

void	validateDerivativeMaterialPropertyBase (const std::string &base)

const MaterialPropertyName	derivativePropertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const

const MaterialPropertyName	derivativePropertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const

const MaterialPropertyName	derivativePropertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const

const MaterialPropertyName	derivativePropertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)

void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)

void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const

const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const

const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const

const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const

const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const

const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const

const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	initQpStatefulProperties () override

virtual void	computeQpPK1Stress () override

void	returnMappingSolve (const GenericReal< is_ad > &effective_trial_stress, GenericReal< is_ad > &scalar, const ConsoleStream &console)
	Perform the return mapping iterations.

virtual GenericReal< is_ad >	minimumPermissibleValue (const GenericReal< is_ad > &effective_trial_stress) const
	Compute the minimum permissible value of the scalar.

virtual GenericReal< is_ad >	maximumPermissibleValue (const GenericReal< is_ad > &effective_trial_stress) const
	Compute the maximum permissible value of the scalar.

virtual GenericReal< is_ad >	initialGuess (const GenericReal< is_ad > &)
	Compute an initial guess for the value of the scalar.

virtual GenericReal< is_ad >	computeResidual (const GenericReal< is_ad > &, const GenericReal< is_ad > &)=0
	Compute the residual for a predicted value of the scalar.

virtual GenericReal< is_ad >	computeDerivative (const GenericReal< is_ad > &, const GenericReal< is_ad > &)=0
	Compute the derivative of the residual as a function of the scalar variable.

virtual GenericChainedReal< is_ad >	computeResidualAndDerivative (const GenericReal< is_ad > &, const GenericChainedReal< is_ad > &)
	Compute the residual and the derivative for a predicted value of the scalar.

virtual Real	computeReferenceResidual (const GenericReal< is_ad > &effective_trial_stress, const GenericReal< is_ad > &scalar)=0
	Compute a reference quantity to be used for checking relative convergence.

virtual void	preStep (const GenericReal< is_ad > &, const GenericReal< is_ad > &, const GenericReal< is_ad > &)
	This method is called before taking a step in the return mapping algorithm.

virtual void	iterationFinalize (const GenericReal< is_ad > &)
	Finalize internal state variables for a model for a given iteration.

virtual void	outputIterationSummary (std::stringstream *iter_output, const unsigned int total_it)
	Output summary information for the convergence history of the model.

virtual void	outputIterationStep (std::stringstream *iter_output, const GenericReal< is_ad > &effective_trial_stress, const GenericReal< is_ad > &scalar, const Real reference_residual)
	Output information for a single iteration step to build the convergence history of the model.

bool	converged (const GenericReal< is_ad > &residual, const Real reference)
	Check to see whether the residual is within the convergence limits.


virtual Real	computeReferenceResidual (const Real &effective_trial_stress, const Real &scalar) override
	The return mapping residual and derivative.

virtual Real	computeResidual (const Real &effective_trial_stress, const Real &scalar) override

virtual Real	computeDerivative (const Real &effective_trial_stress, const Real &scalar) override

virtual void	preStep (const Real &scalar_old, const Real &residual, const Real &jacobian) override

Protected Attributes
const MaterialPropertyName	_elasticity_tensor_name

const MaterialProperty< RankFourTensor > &	_elasticity_tensor

const MaterialProperty< RankTwoTensor > &	_F_old

const std::string	_ep_name

MaterialProperty< Real > &	_ep

const MaterialProperty< Real > &	_ep_old

MaterialProperty< RankTwoTensor > &	_be

const MaterialProperty< RankTwoTensor > &	_be_old

MaterialProperty< RankTwoTensor > &	_Np

MaterialBase *	_flow_stress_material

const std::string	_flow_stress_name

const MaterialProperty< Real > &	_H

const MaterialProperty< Real > &	_dH

const MaterialProperty< Real > &	_d2H

bool	_check_range
	Whether to check to see whether iterative solution is within admissible range, and set within that range if outside.

bool	_line_search
	Whether to use line searches to improve convergence.

bool	_bracket_solution
	Whether to save upper and lower bounds of root for scalar, and set solution to the midpoint between those bounds if outside them.

Private Types
enum class	InternalSolveOutput { NEVER , ON_ERROR , ALWAYS }

enum class	SolveState { SUCCESS , NAN_INF , EXCEEDED_ITERATIONS }

Private Member Functions
bool	haveMaterialProperty (const std::string &prop_name)

std::vector< VariableName >	buildVariableVector (const VariableName &c1, const VariableName &c2, const VariableName &c3)

void	validateCouplingHelper (const MaterialPropertyName &base, const std::vector< VariableName > &c, const System &system, std::vector< VariableName > &missing)

bool	isNotObjectVariable (const VariableName &name)

void	computeResidualAndDerivativeHelper (const GenericReal< is_ad > &effective_trial_stress, const GenericReal< is_ad > &scalar)
	Helper function to compute and set the _residual and _derivative.

SolveState	internalSolve (const GenericReal< is_ad > effective_trial_stress, GenericReal< is_ad > &scalar, std::stringstream *iter_output=nullptr)
	Method called from within this class to perform the actual return mappping iterations.

bool	convergedAcceptable (const unsigned int it, const Real reference)
	Check to see whether the residual is within acceptable convergence limits.

void	checkPermissibleRange (GenericReal< is_ad > &scalar, GenericReal< is_ad > &scalar_increment, const GenericReal< is_ad > &scalar_old, const GenericReal< is_ad > min_permissible_scalar, const GenericReal< is_ad > max_permissible_scalar, std::stringstream *iter_output)
	Check to see whether solution is within admissible range, and set it within that range if it is not.

void	updateBounds (const GenericReal< is_ad > &scalar, const GenericReal< is_ad > &residual, const Real init_resid_sign, GenericReal< is_ad > &scalar_upper_bound, GenericReal< is_ad > &scalar_lower_bound, std::stringstream *iter_output)
	Update the upper and lower bounds of the root for the effective inelastic strain.

Private Attributes
FEProblemBase &	_dmi_fe_problem

enum SingleVariableReturnMappingSolutionTempl::InternalSolveOutput	_internal_solve_output_on

const unsigned int	_max_its
	Maximum number of return mapping iterations.

const bool	_internal_solve_full_iteration_history
	Whether to output iteration information all the time (regardless of whether iterations converge)

Real	_relative_tolerance
	Relative convergence tolerance.

Real	_absolute_tolerance
	Absolute convergence tolerance.

Real	_acceptable_multiplier
	Multiplier applied to relative and absolute tolerances for acceptable convergence.

const bool	_ad_derivative

const std::size_t	_num_resids
	Number of residuals to be stored in history.

std::vector< Real >	_residual_history
	History of residuals used to check whether progress is still being made on decreasing the residual.

unsigned int	_iteration
	iteration number

GenericReal< is_ad >	_derivative
	Derivative of the residual.

const std::string	_svrms_name
	MOOSE input name of the object performing the solve.


RankFourTensor	_d_be_d_F
	Helper (dummy) variables for iteratively updating the consistant tangent during return mapping.

RankFourTensor	_d_n_d_be

RankTwoTensor	_d_deltaep_d_betr

RankTwoTensor	_d_R_d_betr

RankTwoTensor	_d_J_d_betr


GenericReal< is_ad >	_initial_residual
	Residual values, kept as members to retain solver state for summary outputting.

GenericReal< is_ad >	_residual

Detailed Description

Definition at line 20 of file ComputeSimoHughesJ2PlasticityStress.h.

Member Enumeration Documentation

◆ InternalSolveOutput

template<bool is_ad>

enum class SingleVariableReturnMappingSolutionTempl::InternalSolveOutput

strongprivateinherited

Enumerator
NEVER
ON_ERROR
ALWAYS

Definition at line 172 of file SingleVariableReturnMappingSolution.h.

  {
    NEVER,
    ON_ERROR,
    ALWAYS
  } _internal_solve_output_on;

◆ SolveState

template<bool is_ad>

enum class SingleVariableReturnMappingSolutionTempl::SolveState

strongprivateinherited

Enumerator
SUCCESS
NAN_INF
EXCEEDED_ITERATIONS

Definition at line 179 of file SingleVariableReturnMappingSolution.h.

  {
    SUCCESS,
    NAN_INF,
    EXCEEDED_ITERATIONS
  };

Constructor & Destructor Documentation

◆ ComputeSimoHughesJ2PlasticityStress()

ComputeSimoHughesJ2PlasticityStress::ComputeSimoHughesJ2PlasticityStress ( const InputParameters & parameters )

Definition at line 27 of file ComputeSimoHughesJ2PlasticityStress.C.

  : DerivativeMaterialInterface<ComputeLagrangianStressPK1>(parameters),
    SingleVariableReturnMappingSolution(parameters),
    _elasticity_tensor_name(_base_name + getParam<MaterialPropertyName>("elasticity_tensor")),
    _elasticity_tensor(getMaterialProperty<RankFourTensor>(_elasticity_tensor_name)),
    _F_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "deformation_gradient")),
    _ep_name(_base_name + "effective_plastic_strain"),
    _ep(declareProperty<Real>(_ep_name)),
    _ep_old(getMaterialPropertyOldByName<Real>(_ep_name)),
    _be(declareProperty<RankTwoTensor>(_base_name +
                                       "volume_preserving_elastic_left_cauchy_green_strain")),
    _be_old(getMaterialPropertyOldByName<RankTwoTensor>(
        _base_name + "volume_preserving_elastic_left_cauchy_green_strain")),
    _Np(declareProperty<RankTwoTensor>(_base_name + "flow_direction")),
    _flow_stress_material(nullptr),
    _flow_stress_name(_base_name + "flow_stress"),
    _H(getMaterialPropertyByName<Real>(_flow_stress_name)),
    _dH(getDefaultMaterialPropertyByName<Real, false>(
        derivativePropertyName(_flow_stress_name, {_ep_name}))),
    _d2H(getDefaultMaterialPropertyByName<Real, false>(
        derivativePropertyName(_flow_stress_name, {_ep_name, _ep_name})))
{
}

Member Function Documentation

◆ checkPermissibleRange()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::checkPermissibleRange	(	GenericReal< is_ad > &	scalar,
		GenericReal< is_ad > &	scalar_increment,
		const GenericReal< is_ad > &	scalar_old,
		const GenericReal< is_ad >	min_permissible_scalar,
		const GenericReal< is_ad >	max_permissible_scalar,
		std::stringstream *	iter_output
	)

privateinherited

Check to see whether solution is within admissible range, and set it within that range if it is not.

Parameters

scalar	Current value of the inelastic strain increment
scalar_increment	Incremental change in scalar from the previous iteration
scalar_old	Previous value of scalar
min_permissible_scalar	Minimum permissible value of scalar
max_permissible_scalar	Maximum permissible value of scalar
iter_output	Output stream

Definition at line 361 of file SingleVariableReturnMappingSolution.C.

{
  if (scalar > max_permissible_scalar)
  {
    scalar_increment = (max_permissible_scalar - scalar_old) / 2.0;
    scalar = scalar_old + scalar_increment;
    if (iter_output)
      *iter_output << "Scalar greater than maximum ("
                   << MetaPhysicL::raw_value(max_permissible_scalar)
                   << ") adjusted scalar=" << MetaPhysicL::raw_value(scalar)
                   << " scalar_increment=" << MetaPhysicL::raw_value(scalar_increment) << std::endl;
  }
  else if (scalar < min_permissible_scalar)
  {
    scalar_increment = (min_permissible_scalar - scalar_old) / 2.0;
    scalar = scalar_old + scalar_increment;
    if (iter_output)
      *iter_output << "Scalar less than minimum (" << MetaPhysicL::raw_value(min_permissible_scalar)
                   << ") adjusted scalar=" << MetaPhysicL::raw_value(scalar)
                   << " scalar_increment=" << MetaPhysicL::raw_value(scalar_increment) << std::endl;
  }
}

◆ computeDerivative() [1/2]

template<bool is_ad>

virtual GenericReal< is_ad > SingleVariableReturnMappingSolutionTempl< is_ad >::computeDerivative	(	const GenericReal< is_ad > &	,
		const GenericReal< is_ad > &
	)

protectedpure virtualinherited

Compute the derivative of the residual as a function of the scalar variable.

The residual should be in strain increment units for all models for consistency.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for

Implemented in LAROMANCEStressUpdateBaseTempl< is_ad >, CombinedNonlinearHardeningPlasticityTempl< is_ad >, CompositePowerLawCreepStressUpdateTempl< is_ad >, IsotropicPlasticityStressUpdateTempl< is_ad >, PowerLawCreepStressUpdateTempl< is_ad >, and PowerLawCreepTestTempl< is_ad >.

◆ computeDerivative() [2/2]

Real ComputeSimoHughesJ2PlasticityStress::computeDerivative	(	const Real &	effective_trial_stress,
		const Real &	scalar
	)

overrideprotectedvirtual

Definition at line 167 of file ComputeSimoHughesJ2PlasticityStress.C.

{
  const Real G = ElasticityTensorTools::getIsotropicShearModulus(_elasticity_tensor[_qp]);
 
  // Update the flow stress
  _ep[_qp] = _ep_old[_qp] + scalar;
  _flow_stress_material->computePropertiesAtQp(_qp);
 
  return -G * _be[_qp].trace() - _dH[_qp];
}

◆ computeQpPK1Stress()

void ComputeSimoHughesJ2PlasticityStress::computeQpPK1Stress ( )

overrideprotectedvirtual

Definition at line 73 of file ComputeSimoHughesJ2PlasticityStress.C.

{
  usingTensorIndices(i, j, k, l, m);
  const Real G = ElasticityTensorTools::getIsotropicShearModulus(_elasticity_tensor[_qp]);
  const Real K = ElasticityTensorTools::getIsotropicBulkModulus(_elasticity_tensor[_qp]);
  const auto I = RankTwoTensor::Identity();
  const auto Fit = _F[_qp].inverse().transpose();
  const auto detJ = _F[_qp].det();
 
  // Update configuration
  RankTwoTensor f = _inv_df[_qp].inverse();
  RankTwoTensor f_bar = f / std::cbrt(f.det());
 
  // Elastic predictor
  _be[_qp] = f_bar * _be_old[_qp] * f_bar.transpose();
  RankTwoTensor s = G * _be[_qp].deviatoric();
  _Np[_qp] = MooseUtils::absoluteFuzzyEqual(s.norm(), 0) ? std::sqrt(1. / 2.) * I
                                                         : std::sqrt(3. / 2.) * s / s.norm();
  Real s_eff = s.doubleContraction(_Np[_qp]);
 
  // Compute the derivative of the strain before return mapping
  if (_fe_problem.currentlyComputingJacobian())
    _d_be_d_F = _F_old[_qp].inverse().times<l, m, i, j, k, m>(
        (I.times<i, k, j, l>(f_bar * _be_old[_qp].transpose()) +
         I.times<j, k, i, l>(f_bar * _be_old[_qp])) /
            std::cbrt(f.det()) -
        2. / 3. * _be[_qp].times<i, j, l, k>(_inv_df[_qp]));
 
  // Check for plastic loading and do return mapping
  Real delta_ep = 0;
  if (computeResidual(s_eff, 0) > 0)
  {
    // Initialize the derivative of the internal variable
    if (_fe_problem.currentlyComputingJacobian())
    {
      _d_deltaep_d_betr.zero();
      if (MooseUtils::absoluteFuzzyEqual(s.norm(), 0))
        _d_n_d_be.zero();
      else
        _d_n_d_be = G / std::sqrt(6) / s.norm() *
                    (3 * I.times<i, k, j, l>(I) - 2 * _Np[_qp].times<i, j, k, l>(_Np[_qp]) -
                     I.times<i, j, k, l>(I));
    }
 
    returnMappingSolve(s_eff, delta_ep, _console);
 
    // Correct the derivative of the strain after return mapping
    if (_fe_problem.currentlyComputingJacobian())
      _d_be_d_F -=
          2. / 3. *
          (_be[_qp].trace() * _Np[_qp].times<i, j, k, l>(_d_deltaep_d_betr) +
           delta_ep * _Np[_qp].times<i, j, k, l>(I) + delta_ep * _be[_qp].trace() * _d_n_d_be) *
          _d_be_d_F;
  }
 
  // Update intermediate and current configurations
  _ep[_qp] = _ep_old[_qp] + delta_ep;
  _be[_qp] -= 2. / 3. * delta_ep * _be[_qp].trace() * _Np[_qp];
  s = G * _be[_qp].deviatoric();
  RankTwoTensor tau = (K * (detJ * detJ - 1) / 2) * I + s;
  _pk1_stress[_qp] = tau * Fit;
 
  // Compute the consistent tangent, i.e. the derivative of the PK1 stress w.r.t. the deformation
  // gradient.
  if (_fe_problem.currentlyComputingJacobian())
  {
    RankFourTensor d_tau_d_F = K * detJ * detJ * I.times<i, j, k, l>(Fit) +
                               G * (_d_be_d_F - I.times<i, j, k, l>(I) * _d_be_d_F / 3);
    _pk1_jacobian[_qp] = Fit.times<m, j, i, m, k, l>(d_tau_d_F) - Fit.times<k, j, i, l>(tau * Fit);
  }
}

◆ computeReferenceResidual() [1/2]

template<bool is_ad>

virtual Real SingleVariableReturnMappingSolutionTempl< is_ad >::computeReferenceResidual	(	const GenericReal< is_ad > &	effective_trial_stress,
		const GenericReal< is_ad > &	scalar
	)

protectedpure virtualinherited

Compute a reference quantity to be used for checking relative convergence.

This should be in strain increment units for all models for consistency.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for

Implemented in RadialReturnStressUpdateTempl< is_ad >.

◆ computeReferenceResidual() [2/2]

Real ComputeSimoHughesJ2PlasticityStress::computeReferenceResidual	(	const Real &	effective_trial_stress,
		const Real &	scalar
	)

overrideprotectedvirtual

The return mapping residual and derivative.

Definition at line 146 of file ComputeSimoHughesJ2PlasticityStress.C.

{
  const Real G = ElasticityTensorTools::getIsotropicShearModulus(_elasticity_tensor[_qp]);
  return effective_trial_stress - G * scalar * _be[_qp].trace();
}

◆ computeResidual() [1/2]

template<bool is_ad>

virtual GenericReal< is_ad > SingleVariableReturnMappingSolutionTempl< is_ad >::computeResidual	(	const GenericReal< is_ad > &	,
		const GenericReal< is_ad > &
	)

protectedpure virtualinherited

Compute the residual for a predicted value of the scalar.

This residual should be in strain increment units for all models for consistency.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for

Implemented in CombinedNonlinearHardeningPlasticityTempl< is_ad >, CompositePowerLawCreepStressUpdateTempl< is_ad >, IsotropicPlasticityStressUpdateTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< is_ad >, PowerLawCreepStressUpdateTempl< is_ad >, and PowerLawCreepTestTempl< is_ad >.

◆ computeResidual() [2/2]

Real ComputeSimoHughesJ2PlasticityStress::computeResidual	(	const Real &	effective_trial_stress,
		const Real &	scalar
	)

overrideprotectedvirtual

Definition at line 154 of file ComputeSimoHughesJ2PlasticityStress.C.

{
  const Real G = ElasticityTensorTools::getIsotropicShearModulus(_elasticity_tensor[_qp]);
 
  // Update the flow stress
  _ep[_qp] = _ep_old[_qp] + scalar;
  _flow_stress_material->computePropertiesAtQp(_qp);
 
  return effective_trial_stress - G * scalar * _be[_qp].trace() - _H[_qp];
}

Referenced by computeQpPK1Stress().

◆ computeResidualAndDerivative()

template<bool is_ad>

virtual GenericChainedReal< is_ad > SingleVariableReturnMappingSolutionTempl< is_ad >::computeResidualAndDerivative	(	const GenericReal< is_ad > &	,
		const GenericChainedReal< is_ad > &
	)

inlineprotectedvirtualinherited

Compute the residual and the derivative for a predicted value of the scalar.

This residual should be in strain increment units for all models for consistency.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for

Reimplemented in CompositePowerLawCreepStressUpdateTempl< is_ad >, and PowerLawCreepStressUpdateTempl< is_ad >.

Definition at line 97 of file SingleVariableReturnMappingSolution.h.

  {
    mooseError("computeResidualAndDerivative has to be implemented if "
               "automatic_differentiation_return_mapping = true.");
    return 0;
  };

◆ computeResidualAndDerivativeHelper()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::computeResidualAndDerivativeHelper	(	const GenericReal< is_ad > &	effective_trial_stress,
		const GenericReal< is_ad > &	scalar
	)

privateinherited

Helper function to compute and set the _residual and _derivative.

Definition at line 308 of file SingleVariableReturnMappingSolution.C.

{
  if (_ad_derivative)
  {
    GenericChainedReal<is_ad> residual_and_derivative =
        computeResidualAndDerivative(effective_trial_stress, GenericChainedReal<is_ad>(scalar, 1));
    _residual = residual_and_derivative.value();
    _derivative = residual_and_derivative.derivatives();
  }
  else
  {
    _residual = computeResidual(effective_trial_stress, scalar);
    _derivative = computeDerivative(effective_trial_stress, scalar);
  }
}

◆ converged()

template<bool is_ad>

bool SingleVariableReturnMappingSolutionTempl< is_ad >::converged	(	const GenericReal< is_ad > &	residual,
		const Real	reference
	)

protectedinherited

Check to see whether the residual is within the convergence limits.

Parameters

residual	Current value of the residual
reference	Current value of the reference quantity

Returns: Whether the model converged

Definition at line 327 of file SingleVariableReturnMappingSolution.C.

{
  const Real residual = MetaPhysicL::raw_value(ad_residual);
  return (std::abs(residual) <= _absolute_tolerance ||
          std::abs(residual / reference) <= _relative_tolerance);
}

◆ convergedAcceptable()

template<bool is_ad>

bool SingleVariableReturnMappingSolutionTempl< is_ad >::convergedAcceptable	(	const unsigned int	it,
		const Real	reference
	)

privateinherited

Check to see whether the residual is within acceptable convergence limits.

This will only return true if it has been determined that progress is no longer being made and that the residual is within the acceptable limits.

Parameters

residual	Current iteration count
residual	Current value of the residual
reference	Current value of the reference quantity

Returns: Whether the model converged

Definition at line 337 of file SingleVariableReturnMappingSolution.C.

{
  using std::abs;
 
  // Require that we have at least done _num_resids evaluations before we allow for
  // acceptable convergence
  if (it < _num_resids)
    return false;
 
  // Check to see whether the residual has dropped by convergence_history_factor over
  // the last _num_resids iterations. If it has (which means it's still making progress),
  // don't consider it to be converged within the acceptable limits.
  const Real convergence_history_factor = 10.0;
  if (abs(_residual * convergence_history_factor) < abs(_residual_history[(it + 1) % _num_resids]))
    return false;
 
  // Now that it's determined that progress is not being made, treat it as converged if
  // we're within the acceptable convergence limits
  return converged(_residual / _acceptable_multiplier, reference);
}

◆ initialGuess()

template<bool is_ad>

virtual GenericReal< is_ad > SingleVariableReturnMappingSolutionTempl< is_ad >::initialGuess ( const GenericReal< is_ad > & )

inlineprotectedvirtualinherited

Compute an initial guess for the value of the scalar.

For some cases, an intellegent starting point can provide enhanced robustness in the Newton iterations. This is also an opportunity for classes that derive from this to perform initialization tasks.

Parameters

effective_trial_stress Effective trial stress

Reimplemented in PowerLawCreepTestTempl< is_ad >.

Definition at line 66 of file SingleVariableReturnMappingSolution.h.

  {
    return 0.0;
  }

◆ initialSetup()

void ComputeSimoHughesJ2PlasticityStress::initialSetup ( )

overridevirtual

Definition at line 53 of file ComputeSimoHughesJ2PlasticityStress.C.

{
  ComputeLagrangianStressBase::initialSetup();
 
  _flow_stress_material = &getMaterial("flow_stress_material");
 
  // Enforce isotropic elastic tensor
  if (!hasGuaranteedMaterialProperty(_elasticity_tensor_name, Guarantee::ISOTROPIC))
    mooseError("ComputeSimoHughesJ2PlasticityStress requires an isotropic elasticity tensor");
}

◆ initQpStatefulProperties()

void ComputeSimoHughesJ2PlasticityStress::initQpStatefulProperties ( )

overrideprotectedvirtual

Definition at line 65 of file ComputeSimoHughesJ2PlasticityStress.C.

{
  ComputeLagrangianStressPK1::initQpStatefulProperties();
  _be[_qp].setToIdentity();
  _ep[_qp] = 0;
}

◆ internalSolve()

template<bool is_ad>

SingleVariableReturnMappingSolutionTempl< is_ad >::SolveState SingleVariableReturnMappingSolutionTempl< is_ad >::internalSolve	(	const GenericReal< is_ad >	effective_trial_stress,
		GenericReal< is_ad > &	scalar,
		std::stringstream *	iter_output = `nullptr`
	)

privateinherited

Method called from within this class to perform the actual return mappping iterations.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for
iter_output	Output stream – if null, no output is produced

Returns: Whether the solution was successful

Definition at line 163 of file SingleVariableReturnMappingSolution.C.

{
  scalar = initialGuess(effective_trial_stress);
  GenericReal<is_ad> scalar_old = scalar;
  GenericReal<is_ad> scalar_increment = 0.0;
  const GenericReal<is_ad> min_permissible_scalar = minimumPermissibleValue(effective_trial_stress);
  const GenericReal<is_ad> max_permissible_scalar = maximumPermissibleValue(effective_trial_stress);
  GenericReal<is_ad> scalar_upper_bound = max_permissible_scalar;
  GenericReal<is_ad> scalar_lower_bound = min_permissible_scalar;
  _iteration = 0;
 
  computeResidualAndDerivativeHelper(effective_trial_stress, scalar);
  _initial_residual = _residual;
 
  GenericReal<is_ad> residual_old = _residual;
  Real init_resid_sign = MathUtils::sign(MetaPhysicL::raw_value(_residual));
  Real reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
 
  if (converged(_residual, reference_residual))
  {
    iterationFinalize(scalar);
    outputIterationStep(iter_output, effective_trial_stress, scalar, reference_residual);
    return SolveState::SUCCESS;
  }
 
  _residual_history.assign(_num_resids, std::numeric_limits<Real>::max());
  _residual_history[0] = MetaPhysicL::raw_value(_residual);
 
  while (_iteration < _max_its && !converged(_residual, reference_residual) &&
         !convergedAcceptable(_iteration, reference_residual))
  {
    preStep(scalar_old, _residual, _derivative);
 
    scalar_increment = -_residual / _derivative;
    scalar = scalar_old + scalar_increment;
 
    if (_check_range)
      checkPermissibleRange(scalar,
                            scalar_increment,
                            scalar_old,
                            min_permissible_scalar,
                            max_permissible_scalar,
                            iter_output);
 
    computeResidualAndDerivativeHelper(effective_trial_stress, scalar);
    reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
    iterationFinalize(scalar);
 
    if (_bracket_solution)
      updateBounds(
          scalar, _residual, init_resid_sign, scalar_upper_bound, scalar_lower_bound, iter_output);
 
    if (converged(_residual, reference_residual))
    {
      outputIterationStep(iter_output, effective_trial_stress, scalar, reference_residual);
      break;
    }
    else
    {
      bool modified_increment = false;
 
      // Line Search
      if (_line_search)
      {
        if (residual_old - _residual != 0.0)
        {
          GenericReal<is_ad> alpha = residual_old / (residual_old - _residual);
          alpha = MathUtils::clamp(alpha, 1.0e-2, 1.0);
 
          if (alpha != 1.0)
          {
            modified_increment = true;
            scalar_increment *= alpha;
            if (iter_output)
              *iter_output << "  Line search alpha = " << MetaPhysicL::raw_value(alpha)
                           << " increment = " << MetaPhysicL::raw_value(scalar_increment)
                           << std::endl;
          }
        }
      }
 
      if (_bracket_solution)
      {
        // Check to see whether trial scalar_increment is outside the bounds, and set it to a point
        // within the bounds if it is
        if (scalar_old + scalar_increment >= scalar_upper_bound ||
            scalar_old + scalar_increment <= scalar_lower_bound)
        {
          if (scalar_upper_bound != max_permissible_scalar &&
              scalar_lower_bound != min_permissible_scalar)
          {
            const Real frac = 0.5;
            scalar_increment =
                (1.0 - frac) * scalar_lower_bound + frac * scalar_upper_bound - scalar_old;
            modified_increment = true;
            if (iter_output)
              *iter_output << "  Trial scalar_increment exceeded bounds.  Setting between "
                              "lower/upper bounds. frac: "
                           << frac << std::endl;
          }
        }
      }
 
      // Update the trial scalar and recompute residual if the line search or bounds checking
      // modified the increment
      if (modified_increment)
      {
        scalar = scalar_old + scalar_increment;
        computeResidualAndDerivativeHelper(effective_trial_stress, scalar);
        reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
        iterationFinalize(scalar);
 
        if (_bracket_solution)
          updateBounds(scalar,
                       _residual,
                       init_resid_sign,
                       scalar_upper_bound,
                       scalar_lower_bound,
                       iter_output);
      }
    }
 
    outputIterationStep(iter_output, effective_trial_stress, scalar, reference_residual);
 
    ++_iteration;
    residual_old = _residual;
    scalar_old = scalar;
    _residual_history[_iteration % _num_resids] = MetaPhysicL::raw_value(_residual);
  }
 
  using std::isnan, std::isinf;
  if (isnan(_residual) || isinf(MetaPhysicL::raw_value(_residual)))
    return SolveState::NAN_INF;
 
  if (_iteration == _max_its)
    return SolveState::EXCEEDED_ITERATIONS;
 
  return SolveState::SUCCESS;
}

◆ iterationFinalize()

template<bool is_ad>

virtual void SingleVariableReturnMappingSolutionTempl< is_ad >::iterationFinalize ( const GenericReal< is_ad > & )

inlineprotectedvirtualinherited

Finalize internal state variables for a model for a given iteration.

Parameters

scalar Inelastic strain increment magnitude being solved for

Reimplemented in CombinedNonlinearHardeningPlasticityTempl< is_ad >, and IsotropicPlasticityStressUpdateTempl< is_ad >.

Definition at line 128 of file SingleVariableReturnMappingSolution.h.

128{}

◆ maximumPermissibleValue()

template<bool is_ad>

GenericReal< is_ad > SingleVariableReturnMappingSolutionTempl< is_ad >::maximumPermissibleValue ( const GenericReal< is_ad > & effective_trial_stress ) const

protectedvirtualinherited

Compute the maximum permissible value of the scalar.

For some models, the magnitude of this may be known.

Parameters

effective_trial_stress Effective trial stress

Reimplemented in PowerLawCreepTestTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< is_ad >, and RadialReturnStressUpdateTempl< is_ad >.

Definition at line 92 of file SingleVariableReturnMappingSolution.C.

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

◆ minimumPermissibleValue()

template<bool is_ad>

GenericReal< is_ad > SingleVariableReturnMappingSolutionTempl< is_ad >::minimumPermissibleValue ( const GenericReal< is_ad > & effective_trial_stress ) const

protectedvirtualinherited

Compute the minimum permissible value of the scalar.

For some models, the magnitude of this may be known.

Parameters

effective_trial_stress Effective trial stress

Reimplemented in RadialReturnStressUpdateTempl< is_ad >, and PowerLawCreepTestTempl< is_ad >.

Definition at line 84 of file SingleVariableReturnMappingSolution.C.

{
  return std::numeric_limits<Real>::lowest();
}

◆ outputIterationStep()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::outputIterationStep	(	std::stringstream *	iter_output,
		const GenericReal< is_ad > &	effective_trial_stress,
		const GenericReal< is_ad > &	scalar,
		const Real	reference_residual
	)

protectedvirtualinherited

Output information for a single iteration step to build the convergence history of the model.

Parameters

iter_output	Output stream
effective_trial_stress	Effective trial stress
residual	Current value of the residual
reference	Current value of the reference quantity

Reimplemented in LAROMANCEStressUpdateBaseTempl< is_ad >.

Definition at line 421 of file SingleVariableReturnMappingSolution.C.

{
  if (iter_output)
  {
    const unsigned int it = _iteration;
    const Real residual = MetaPhysicL::raw_value(_residual);
 
    *iter_output << " iteration=" << it
                 << " trial_stress=" << MetaPhysicL::raw_value(effective_trial_stress)
                 << " scalar=" << MetaPhysicL::raw_value(scalar) << " residual=" << residual
                 << " ref_res=" << reference_residual
                 << " rel_res=" << std::abs(residual) / reference_residual
                 << " rel_tol=" << _relative_tolerance << " abs_res=" << std::abs(residual)
                 << " abs_tol=" << _absolute_tolerance << '\n';
  }
}

Referenced by LAROMANCEStressUpdateBaseTempl< is_ad >::outputIterationStep().

◆ outputIterationSummary()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::outputIterationSummary	(	std::stringstream *	iter_output,
		const unsigned int	total_it
	)

protectedvirtualinherited

Output summary information for the convergence history of the model.

Parameters

iter_output	Output stream
total_it	Total iteration count

Reimplemented in ADViscoplasticityStressUpdate, LAROMANCEStressUpdateBaseTempl< is_ad >, and RadialReturnStressUpdateTempl< is_ad >.

Definition at line 444 of file SingleVariableReturnMappingSolution.C.

{
  if (iter_output)
    *iter_output << "In " << total_it << " iterations the residual went from "
                 << MetaPhysicL::raw_value(_initial_residual) << " to "
                 << MetaPhysicL::raw_value(_residual) << " in '" << _svrms_name << "'."
                 << std::endl;
}

Referenced by ADViscoplasticityStressUpdate::outputIterationSummary(), LAROMANCEStressUpdateBaseTempl< is_ad >::outputIterationSummary(), and RadialReturnStressUpdateTempl< is_ad >::outputIterationSummary().

◆ preStep() [1/2]

template<bool is_ad>

virtual void SingleVariableReturnMappingSolutionTempl< is_ad >::preStep	(	const GenericReal< is_ad > &	,
		const GenericReal< is_ad > &	,
		const GenericReal< is_ad > &
	)

inlineprotectedvirtualinherited

This method is called before taking a step in the return mapping algorithm.

A typical use case is to accumulate the exact algorithmic tangent during return mapping.

Definition at line 118 of file SingleVariableReturnMappingSolution.h.

121 {

122 }

◆ preStep() [2/2]

void ComputeSimoHughesJ2PlasticityStress::preStep	(	const Real &	scalar_old,
		const Real &	residual,
		const Real &	jacobian
	)

overrideprotectedvirtual

Definition at line 180 of file ComputeSimoHughesJ2PlasticityStress.C.

{
  if (!_fe_problem.currentlyComputingJacobian())
    return;
 
  const auto I = RankTwoTensor::Identity();
  const Real G = ElasticityTensorTools::getIsotropicShearModulus(_elasticity_tensor[_qp]);
 
  // Update the flow stress
  _ep[_qp] = _ep_old[_qp] + scalar;
  _flow_stress_material->computePropertiesAtQp(_qp);
 
  _d_R_d_betr =
      G * _Np[_qp] - G * scalar * I - (G * _be[_qp].trace() + _dH[_qp]) * _d_deltaep_d_betr;
  _d_J_d_betr = -G * I - _d2H[_qp] * _d_deltaep_d_betr;
  _d_deltaep_d_betr += -1 / J * _d_R_d_betr + R / J / J * _d_J_d_betr;
}

◆ returnMappingSolve()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::returnMappingSolve	(	const GenericReal< is_ad > &	effective_trial_stress,
		GenericReal< is_ad > &	scalar,
		const ConsoleStream &	console
	)

protectedinherited

Perform the return mapping iterations.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for
console	Console output

Definition at line 100 of file SingleVariableReturnMappingSolution.C.

{
  // construct the stringstream here only if the debug level is set to ALL
  std::unique_ptr<std::stringstream> iter_output =
      (_internal_solve_output_on == InternalSolveOutput::ALWAYS)
          ? std::make_unique<std::stringstream>()
          : nullptr;
 
  // do the internal solve and capture iteration info during the first round
  // iff full history output is requested regardless of whether the solve failed or succeeded
  auto solve_state =
      internalSolve(effective_trial_stress,
                    scalar,
                    _internal_solve_full_iteration_history ? iter_output.get() : nullptr);
  if (solve_state != SolveState::SUCCESS &&
      _internal_solve_output_on != InternalSolveOutput::ALWAYS)
  {
    // output suppressed by user, throw immediately
    if (_internal_solve_output_on == InternalSolveOutput::NEVER)
      mooseException("");
 
    // user expects some kind of output, if necessary setup output stream now
    if (!iter_output)
      iter_output = std::make_unique<std::stringstream>();
 
    // add the appropriate error message to the output
    switch (solve_state)
    {
      case SolveState::NAN_INF:
        *iter_output << "Encountered inf or nan in material return mapping iterations.\n";
        break;
 
      case SolveState::EXCEEDED_ITERATIONS:
        *iter_output << "Exceeded maximum iterations in material return mapping iterations.\n";
        break;
 
      default:
        mooseError("Unhandled solver state");
    }
 
    // if full history output is only requested for failed solves we have to repeat
    // the solve a second time
    if (_internal_solve_full_iteration_history)
      internalSolve(effective_trial_stress, scalar, iter_output.get());
 
    // Append summary and throw exception
    outputIterationSummary(iter_output.get(), _iteration);
    mooseException(iter_output->str());
  }
 
  if (_internal_solve_output_on == InternalSolveOutput::ALWAYS)
  {
    // the solve did not fail but the user requested debug output anyways
    outputIterationSummary(iter_output.get(), _iteration);
    console << iter_output->str() << std::flush;
  }
}

Referenced by ADViscoplasticityStressUpdate::computeInelasticStrainIncrement(), and computeQpPK1Stress().

◆ updateBounds()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::updateBounds	(	const GenericReal< is_ad > &	scalar,
		const GenericReal< is_ad > &	residual,
		const Real	init_resid_sign,
		GenericReal< is_ad > &	scalar_upper_bound,
		GenericReal< is_ad > &	scalar_lower_bound,
		std::stringstream *	iter_output
	)

privateinherited

Update the upper and lower bounds of the root for the effective inelastic strain.

Parameters

scalar	Current value of the inelastic strain increment
residual	Current value of the residual
init_resid_sign	Sign of the initial value of the residual
scalar_upper_bound	Upper bound value of scalar
scalar_lower_bound	Lower bound value of scalar
iter_output	Output stream

Definition at line 392 of file SingleVariableReturnMappingSolution.C.

{
  // Update upper/lower bounds as applicable
  if (residual * init_resid_sign < 0.0 && scalar < scalar_upper_bound)
  {
    scalar_upper_bound = scalar;
    if (scalar_upper_bound < scalar_lower_bound)
    {
      scalar_upper_bound = scalar_lower_bound;
      scalar_lower_bound = 0.0;
      if (iter_output)
        *iter_output << "  Corrected for scalar_upper_bound < scalar_lower_bound" << std::endl;
    }
  }
  // Don't permit setting scalar_lower_bound > scalar_upper_bound (but do permit the reverse).
  // This ensures that if we encounter multiple roots, we pick the lowest one.
  else if (residual * init_resid_sign > 0.0 && scalar > scalar_lower_bound &&
           scalar < scalar_upper_bound)
    scalar_lower_bound = scalar;
}

◆ validParams()

InputParameters ComputeSimoHughesJ2PlasticityStress::validParams ( )

static

Definition at line 15 of file ComputeSimoHughesJ2PlasticityStress.C.

{
  InputParameters params = DerivativeMaterialInterface<ComputeLagrangianStressPK1>::validParams();
  params += SingleVariableReturnMappingSolution::validParams();
  params.addClassDescription("The Simo-Hughes style J2 plasticity.");
  params.addParam<MaterialPropertyName>(
      "elasticity_tensor", "elasticity_tensor", "The name of the elasticity tensor.");
  params.addRequiredParam<MaterialName>("flow_stress_material",
                                        "The material defining the flow stress");
  return params;
}

Member Data Documentation

◆ _absolute_tolerance

template<bool is_ad>

Real SingleVariableReturnMappingSolutionTempl< is_ad >::_absolute_tolerance

privateinherited

Absolute convergence tolerance.

Definition at line 197 of file SingleVariableReturnMappingSolution.h.

◆ _acceptable_multiplier

template<bool is_ad>

Real SingleVariableReturnMappingSolutionTempl< is_ad >::_acceptable_multiplier

privateinherited

Multiplier applied to relative and absolute tolerances for acceptable convergence.

Definition at line 200 of file SingleVariableReturnMappingSolution.h.

◆ _ad_derivative

template<bool is_ad>

const bool SingleVariableReturnMappingSolutionTempl< is_ad >::_ad_derivative

privateinherited

Definition at line 205 of file SingleVariableReturnMappingSolution.h.

◆ _be

MaterialProperty<RankTwoTensor>& ComputeSimoHughesJ2PlasticityStress::_be

protected

Definition at line 52 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeDerivative(), computeQpPK1Stress(), computeReferenceResidual(), computeResidual(), initQpStatefulProperties(), and preStep().

◆ _be_old

const MaterialProperty<RankTwoTensor>& ComputeSimoHughesJ2PlasticityStress::_be_old

protected

Definition at line 53 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeQpPK1Stress().

◆ _bracket_solution

template<bool is_ad>

bool SingleVariableReturnMappingSolutionTempl< is_ad >::_bracket_solution

protectedinherited

Whether to save upper and lower bounds of root for scalar, and set solution to the midpoint between those bounds if outside them.

Definition at line 145 of file SingleVariableReturnMappingSolution.h.

◆ _check_range

template<bool is_ad>

bool SingleVariableReturnMappingSolutionTempl< is_ad >::_check_range

protectedinherited

Whether to check to see whether iterative solution is within admissible range, and set within that range if outside.

Definition at line 138 of file SingleVariableReturnMappingSolution.h.

Referenced by ADViscoplasticityStressUpdate::ADViscoplasticityStressUpdate(), LAROMANCEStressUpdateBaseTempl< is_ad >::LAROMANCEStressUpdateBaseTempl(), and PowerLawCreepTestTempl< is_ad >::PowerLawCreepTestTempl().

◆ _d2H

const MaterialProperty<Real>& ComputeSimoHughesJ2PlasticityStress::_d2H

protected

Definition at line 60 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by preStep().

◆ _d_be_d_F

RankFourTensor ComputeSimoHughesJ2PlasticityStress::_d_be_d_F

private

Helper (dummy) variables for iteratively updating the consistant tangent during return mapping.

Definition at line 64 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeQpPK1Stress().

◆ _d_deltaep_d_betr

RankTwoTensor ComputeSimoHughesJ2PlasticityStress::_d_deltaep_d_betr

private

Definition at line 66 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeQpPK1Stress(), and preStep().

◆ _d_J_d_betr

RankTwoTensor ComputeSimoHughesJ2PlasticityStress::_d_J_d_betr

private

Definition at line 68 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by preStep().

◆ _d_n_d_be

RankFourTensor ComputeSimoHughesJ2PlasticityStress::_d_n_d_be

private

Definition at line 65 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeQpPK1Stress().

◆ _d_R_d_betr

RankTwoTensor ComputeSimoHughesJ2PlasticityStress::_d_R_d_betr

private

Definition at line 67 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by preStep().

◆ _derivative

template<bool is_ad>

GenericReal<is_ad> SingleVariableReturnMappingSolutionTempl< is_ad >::_derivative

privateinherited

Derivative of the residual.

Definition at line 222 of file SingleVariableReturnMappingSolution.h.

◆ _dH

const MaterialProperty<Real>& ComputeSimoHughesJ2PlasticityStress::_dH

protected

Definition at line 59 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeDerivative(), and preStep().

◆ _elasticity_tensor

const MaterialProperty<RankFourTensor>& ComputeSimoHughesJ2PlasticityStress::_elasticity_tensor

protected

Definition at line 46 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeDerivative(), computeQpPK1Stress(), computeReferenceResidual(), computeResidual(), and preStep().

◆ _elasticity_tensor_name

const MaterialPropertyName ComputeSimoHughesJ2PlasticityStress::_elasticity_tensor_name

protected

Definition at line 45 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by initialSetup().

◆ _ep

MaterialProperty<Real>& ComputeSimoHughesJ2PlasticityStress::_ep

protected

Definition at line 50 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeDerivative(), computeQpPK1Stress(), computeResidual(), initQpStatefulProperties(), and preStep().

◆ _ep_name

const std::string ComputeSimoHughesJ2PlasticityStress::_ep_name

protected

Definition at line 49 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by ComputeSimoHughesJ2PlasticityStress().

◆ _ep_old

const MaterialProperty<Real>& ComputeSimoHughesJ2PlasticityStress::_ep_old

protected

Definition at line 51 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeDerivative(), computeQpPK1Stress(), computeResidual(), and preStep().

◆ _F_old

const MaterialProperty<RankTwoTensor>& ComputeSimoHughesJ2PlasticityStress::_F_old

protected

Definition at line 48 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeQpPK1Stress().

◆ _flow_stress_material

MaterialBase* ComputeSimoHughesJ2PlasticityStress::_flow_stress_material

protected

Definition at line 56 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeDerivative(), computeResidual(), initialSetup(), and preStep().

◆ _flow_stress_name

const std::string ComputeSimoHughesJ2PlasticityStress::_flow_stress_name

protected

Definition at line 57 of file ComputeSimoHughesJ2PlasticityStress.h.

◆ _H

const MaterialProperty<Real>& ComputeSimoHughesJ2PlasticityStress::_H

protected

Definition at line 58 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeResidual().

◆ _initial_residual

template<bool is_ad>

GenericReal<is_ad> SingleVariableReturnMappingSolutionTempl< is_ad >::_initial_residual

privateinherited

Residual values, kept as members to retain solver state for summary outputting.

Definition at line 217 of file SingleVariableReturnMappingSolution.h.

◆ _internal_solve_full_iteration_history

template<bool is_ad>

const bool SingleVariableReturnMappingSolutionTempl< is_ad >::_internal_solve_full_iteration_history

privateinherited

Whether to output iteration information all the time (regardless of whether iterations converge)

Definition at line 191 of file SingleVariableReturnMappingSolution.h.

◆ _internal_solve_output_on

template<bool is_ad>

enum SingleVariableReturnMappingSolutionTempl::InternalSolveOutput SingleVariableReturnMappingSolutionTempl< is_ad >::_internal_solve_output_on

privateinherited

◆ _iteration

template<bool is_ad>

unsigned int SingleVariableReturnMappingSolutionTempl< is_ad >::_iteration

privateinherited

iteration number

Definition at line 214 of file SingleVariableReturnMappingSolution.h.

◆ _line_search

template<bool is_ad>

bool SingleVariableReturnMappingSolutionTempl< is_ad >::_line_search

protectedinherited

Whether to use line searches to improve convergence.

Definition at line 141 of file SingleVariableReturnMappingSolution.h.

◆ _max_its

template<bool is_ad>

const unsigned int SingleVariableReturnMappingSolutionTempl< is_ad >::_max_its

privateinherited

Maximum number of return mapping iterations.

This exists only to avoid an infinite loop, and is is intended to be a large number that is not settable by the user.

Definition at line 188 of file SingleVariableReturnMappingSolution.h.

◆ _Np

MaterialProperty<RankTwoTensor>& ComputeSimoHughesJ2PlasticityStress::_Np

protected

Definition at line 54 of file ComputeSimoHughesJ2PlasticityStress.h.

Referenced by computeQpPK1Stress(), and preStep().

◆ _num_resids

template<bool is_ad>

const std::size_t SingleVariableReturnMappingSolutionTempl< is_ad >::_num_resids

privateinherited

Number of residuals to be stored in history.

Definition at line 208 of file SingleVariableReturnMappingSolution.h.

◆ _relative_tolerance

template<bool is_ad>

Real SingleVariableReturnMappingSolutionTempl< is_ad >::_relative_tolerance

privateinherited

Relative convergence tolerance.

Definition at line 194 of file SingleVariableReturnMappingSolution.h.

◆ _residual

template<bool is_ad>

GenericReal<is_ad> SingleVariableReturnMappingSolutionTempl< is_ad >::_residual

privateinherited

Definition at line 218 of file SingleVariableReturnMappingSolution.h.

◆ _residual_history

template<bool is_ad>

std::vector<Real> SingleVariableReturnMappingSolutionTempl< is_ad >::_residual_history

privateinherited

History of residuals used to check whether progress is still being made on decreasing the residual.

Definition at line 211 of file SingleVariableReturnMappingSolution.h.

◆ _svrms_name

template<bool is_ad>

const std::string SingleVariableReturnMappingSolutionTempl< is_ad >::_svrms_name

privateinherited

MOOSE input name of the object performing the solve.

Definition at line 225 of file SingleVariableReturnMappingSolution.h.

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

solid_mechanics/include/materials/lagrangian/ComputeSimoHughesJ2PlasticityStress.h
solid_mechanics/src/materials/lagrangian/ComputeSimoHughesJ2PlasticityStress.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ InternalSolveOutput

◆ SolveState

Constructor & Destructor Documentation

◆ ComputeSimoHughesJ2PlasticityStress()

Member Function Documentation

◆ checkPermissibleRange()

◆ computeDerivative() [1/2]

◆ computeDerivative() [2/2]

◆ computeQpPK1Stress()

◆ computeReferenceResidual() [1/2]

◆ computeReferenceResidual() [2/2]

◆ computeResidual() [1/2]

◆ computeResidual() [2/2]

◆ computeResidualAndDerivative()

◆ computeResidualAndDerivativeHelper()

◆ converged()

◆ convergedAcceptable()

◆ initialGuess()

◆ initialSetup()

◆ initQpStatefulProperties()

◆ internalSolve()

◆ iterationFinalize()

◆ maximumPermissibleValue()

◆ minimumPermissibleValue()

◆ outputIterationStep()

◆ outputIterationSummary()

◆ preStep() [1/2]

◆ preStep() [2/2]

◆ returnMappingSolve()

◆ updateBounds()

◆ validParams()

Member Data Documentation

◆ _absolute_tolerance

◆ _acceptable_multiplier

◆ _ad_derivative

◆ _be

◆ _be_old

◆ _bracket_solution

◆ _check_range

◆ _d2H

◆ _d_be_d_F

◆ _d_deltaep_d_betr

◆ _d_J_d_betr

◆ _d_n_d_be

◆ _d_R_d_betr

◆ _derivative

◆ _dH

◆ _elasticity_tensor

◆ _elasticity_tensor_name

◆ _ep

◆ _ep_name

◆ _ep_old

◆ _F_old

◆ _flow_stress_material

◆ _flow_stress_name

◆ _H

◆ _initial_residual

◆ _internal_solve_full_iteration_history

◆ _internal_solve_output_on

◆ _iteration

◆ _line_search

◆ _max_its

◆ _Np

◆ _num_resids

◆ _relative_tolerance

◆ _residual

◆ _residual_history

◆ _svrms_name