#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

bool	hasGuaranteedMaterialProperty (const MaterialPropertyName &prop, Guarantee guarantee)

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

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

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

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

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

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. More...

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. More...

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. More...

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. More...

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

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

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. More...

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


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

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. More...

bool	_line_search
	Whether to use line searches to improve convergence. More...

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. More...

Private Attributes

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

RankFourTensor	_d_n_d_be

RankTwoTensor	_d_deltaep_d_betr

RankTwoTensor	_d_R_d_betr

RankTwoTensor	_d_J_d_betr

Detailed Description

Definition at line 20 of file ComputeSimoHughesJ2PlasticityStress.h.

Constructor & Destructor Documentation

◆ ComputeSimoHughesJ2PlasticityStress()

ComputeSimoHughesJ2PlasticityStress::ComputeSimoHughesJ2PlasticityStress ( const InputParameters & parameters )

Definition at line 27 of file ComputeSimoHughesJ2PlasticityStress.C.

   : DerivativeMaterialInterface<ComputeLagrangianStressPK1>(parameters),
     GuaranteeConsumer(this),
     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

◆ computeDerivative() [1/2]

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

overrideprotectedvirtual

Definition at line 166 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];
 }

◆ computeDerivative() [2/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 >, CompositePowerLawCreepStressUpdateTempl< is_ad >, IsotropicPlasticityStressUpdateTempl< is_ad >, PowerLawCreepStressUpdateTempl< is_ad >, PowerLawCreepTestTempl< is_ad >, and CombinedNonlinearHardeningPlasticityTempl< is_ad >.

◆ computeQpPK1Stress()

void ComputeSimoHughesJ2PlasticityStress::computeQpPK1Stress ( )

overrideprotectedvirtual

Definition at line 72 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]

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

overrideprotectedvirtual

The return mapping residual and derivative.

Definition at line 145 of file ComputeSimoHughesJ2PlasticityStress.C.

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

◆ computeReferenceResidual() [2/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 >.

◆ computeResidual() [1/2]

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

overrideprotectedvirtual

Definition at line 153 of file ComputeSimoHughesJ2PlasticityStress.C.

Referenced by computeQpPK1Stress().

 {
   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];
 }

◆ computeResidual() [2/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 LAROMANCEStressUpdateBaseTempl< is_ad >, IsotropicPlasticityStressUpdateTempl< is_ad >, CompositePowerLawCreepStressUpdateTempl< is_ad >, PowerLawCreepStressUpdateTempl< is_ad >, PowerLawCreepTestTempl< is_ad >, and CombinedNonlinearHardeningPlasticityTempl< is_ad >.

◆ 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;
   };

◆ 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 326 of file SingleVariableReturnMappingSolution.C.

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

◆ hasGuaranteedMaterialProperty()

bool GuaranteeConsumer::hasGuaranteedMaterialProperty	(	const MaterialPropertyName &	prop,
		Guarantee	guarantee
	)

protectedinherited

Definition at line 28 of file GuaranteeConsumer.C.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress(), ADComputeSmearedCrackingStress::initialSetup(), ComputeSmearedCrackingStress::initialSetup(), ComputeLinearElasticPFFractureStress::initialSetup(), initialSetup(), CriticalTimeStep::initialSetup(), ComputeStVenantKirchhoffStress::initialSetup(), ComputeMultipleInelasticStressBase::initialSetup(), and ADComputeMultipleInelasticStress::initialSetup().

 {
   if (!_gc_feproblem->startedInitialSetup())
     mooseError("hasGuaranteedMaterialProperty() needs to be called in initialSetup()");
 
   // Reference to MaterialWarehouse for testing and retrieving block ids
   const auto & warehouse = _gc_feproblem->getMaterialWarehouse();
 
   // Complete set of ids that this object is active
   const auto & ids = (_gc_block_restrict && _gc_block_restrict->blockRestricted())
                          ? _gc_block_restrict->blockIDs()
                          : _gc_feproblem->mesh().meshSubdomains();
 
   // Loop over each id for this object
   for (const auto & id : ids)
   {
     // If block materials exist, look if any issue the required guarantee
     if (warehouse.hasActiveBlockObjects(id))
     {
       const std::vector<std::shared_ptr<MaterialBase>> & mats = warehouse.getActiveBlockObjects(id);
       for (const auto & mat : mats)
       {
         const auto & mat_props = mat->getSuppliedItems();
         if (mat_props.count(prop_name))
         {
           auto guarantee_mat = dynamic_cast<GuaranteeProvider *>(mat.get());
           if (guarantee_mat && !guarantee_mat->hasGuarantee(prop_name, guarantee))
           {
             // we found at least one material on the set of block we operate on
             // that does _not_ provide the requested guarantee
             return false;
           }
         }
       }
     }
   }
 
   return true;
 }

◆ 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 54 of file ComputeSimoHughesJ2PlasticityStress.C.

 {
   _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 64 of file ComputeSimoHughesJ2PlasticityStress.C.

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

◆ 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 IsotropicPlasticityStressUpdateTempl< is_ad >, and CombinedNonlinearHardeningPlasticityTempl< 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 RadialReturnStressUpdateTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< is_ad >, and PowerLawCreepTestTempl< 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 419 of file SingleVariableReturnMappingSolution.C.

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

 {
   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';
   }
 }

◆ 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 RadialReturnStressUpdateTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< is_ad >, and ADViscoplasticityStressUpdate.

Definition at line 442 of file SingleVariableReturnMappingSolution.C.

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

 {
   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;
 }

◆ preStep() [1/2]

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

overrideprotectedvirtual

Definition at line 179 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;
 }

◆ preStep() [2/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 }

◆ 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.

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

 {
   // 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;
   }
 }

◆ 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;
 }