ComputeMultipleCrystalPlasticityStress Class Reference

ComputeMultipleCrystalPlasticityStress (used together with CrystalPlasticityStressUpdateBase) uses the multiplicative decomposition of the deformation gradient and solves the PK2 stress residual equation at the intermediate configuration to evolve the material state. More...

#include <ComputeMultipleCrystalPlasticityStress.h>

Inheritance diagram for ComputeMultipleCrystalPlasticityStress:

Public Types
typedef DerivativeMaterialPropertyNameInterface::SymbolName	SymbolName

Public Member Functions
	ComputeMultipleCrystalPlasticityStress (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 Types
enum class	TangentModuliType { EXACT , NONE }
	Type of tangent moduli calculation. More...
enum class	LineSearchMethod { CutHalf , Bisection }
	strain formulation More...

Protected Member Functions
virtual void	computeQpStress () override
	Compute the stress and store it in the _stress material property for the current quadrature point.
virtual void	updateStress (RankTwoTensor &cauchy_stress, RankFourTensor &jacobian_mult)
	Updates the stress (PK2) at a quadrature point by calling constiutive relationship as defined in a child class Solves stress residual equation using Newton - Raphson: Updates slip system resistances iteratively.
virtual void	initQpStatefulProperties () override
	initializes the stateful properties such as PK2 stress, resolved shear stress, plastic deformation gradient, slip system resistances, etc.
void	calculateResidualAndJacobian ()
	Calls the residual and jacobian functions used in the stress update algorithm.
void	preSolveQp ()
	Reset the PK2 stress and the inverse deformation gradient to old values and provide an interface for inheriting classes to reset material properties.
void	solveQp ()
	Solve the stress and internal state variables (e.g.
void	postSolveQp (RankTwoTensor &stress_new, RankFourTensor &jacobian_mult)
	Save the final stress and internal variable values after the iterative solve.
void	solveStateVariables ()
	Solves the internal variables stress as a function of the slip specified by the constitutive model defined in the inheriting class.
void	solveStress ()
	solves for stress, updates plastic deformation gradient.
void	calculateResidual ()
	Calculate stress residual as the difference between the stored material property PK2 stress and the elastic PK2 stress calculated from the constitutively defined equivalent_slip_increment.
void	calculateJacobian ()
	Calculates the jacobian as $\mathbf{J} = \mathbf{I} - \mathbf{C} \frac{d\mathbf{E}^e}{d\mathbf{F}^e} \frac{d\mathbf{F}^e}{d\mathbf{F}^P^{-1}} \frac{d\mathbf{F}^P^{-1}}{d\mathbf{PK2}}$.
bool	lineSearchUpdate (const Real &rnorm_prev, const RankTwoTensor &dpk2)
	performs the line search update
void	calculateEigenstrainDeformationGrad ()
	Calculates the deformation gradient due to eigenstrain.
virtual void	computeQpProperties () override
bool	hasGuaranteedMaterialProperty (const MaterialPropertyName &prop, Guarantee guarantee)
void	calcTangentModuli (RankFourTensor &jacobian_mult)
	Calculates the tangent moduli for use as a preconditioner, using the elastic or elastic-plastic option as specified by the user.
void	elasticTangentModuli (RankFourTensor &jacobian_mult)
void	elastoPlasticTangentModuli (RankFourTensor &jacobian_mult)

Protected Attributes
const unsigned	_num_models
	number of plastic models
std::vector< CrystalPlasticityStressUpdateBase * >	_models
	The user supplied cyrstal plasticity consititutive models.
const unsigned	_num_eigenstrains
	number of eigenstrains
std::vector< ComputeCrystalPlasticityEigenstrainBase * >	_eigenstrains
	The user supplied cyrstal plasticity eigenstrains.
const std::string	_base_name
	optional parameter to define several mechanical systems on the same block, e.g. multiple phases
const MaterialProperty< RankFourTensor > &	_elasticity_tensor
	Elasticity tensor as defined by a separate class.
Real	_rtol
	Stress residual equation relative tolerance.
Real	_abs_tol
	Stress residual equation absolute tolerance.
RankTwoTensor	_residual_tensor
	Residual tensor.
RankFourTensor	_jacobian
	Jacobian tensor.
unsigned int	_maxiter
	Maximum number of iterations for stress update.
unsigned int	_maxiterg
	Maximum number of iterations for internal variable update.
enum ComputeMultipleCrystalPlasticityStress::TangentModuliType	_tan_mod_type
unsigned int	_max_substep_iter
	Maximum number of substep iterations.
Real	_substep_dt
	time step size during substepping
bool	_use_line_search
	Flag to activate line serach.
Real	_min_line_search_step_size
	Minimum line search step size.
Real	_line_search_tolerance
	Line search bisection method tolerance.
unsigned int	_line_search_max_iterations
	Line search bisection method maximum iteration number.
enum ComputeMultipleCrystalPlasticityStress::LineSearchMethod	_line_search_method
MaterialProperty< RankTwoTensor > &	_total_lagrangian_strain
	Lagrangian total strain measure for the entire crystal.
MaterialProperty< RankTwoTensor > &	_updated_rotation
	Tracks the rotation of the crystal during deformation Note: this rotation tensor is not applied to the crystal lattice.
const MaterialProperty< RankTwoTensor > &	_updated_rotation_old
MaterialProperty< Real > &	_misorientation
	Misorientation angle of the crystal during deformation.
const MaterialProperty< RankTwoTensor > &	_crysrot
	Crystal rotation in the original, or reference, configuration as defined by Euler angle arguments in the ComputeElasticityTensor classes.
const bool	_print_convergence_message
	Flag to print to console warning messages on stress, constitutive model convergence.
bool	_convergence_failed
	Flag to check whether convergence is achieved or if substepping is needed.
Real	_dfgrd_scale_factor
	Scales the substepping increment to obtain deformation gradient at a substep iteration.
const std::string	_elasticity_tensor_name
	Name of the elasticity tensor material property.
MaterialProperty< RankTwoTensor > &	_rotation_total
	Rotation up to current step "n" to compute anisotropic elasticity tensor.
const MaterialProperty< RankTwoTensor > &	_rotation_total_old
	Rotation up to "n - 1" (previous) step to compute anisotropic elasticity tensor.
const MaterialProperty< RankTwoTensor > &	_strain_increment
	Strain increment material property.
const MaterialProperty< RankTwoTensor > &	_rotation_increment
	Rotation increment material property.
const MaterialProperty< RankTwoTensor > &	_stress_old
	Old state of the stress tensor material property.
const MaterialProperty< RankTwoTensor > &	_elastic_strain_old
	The old elastic strain is used to calculate the old stress in the case of variable elasticity tensors.
const MaterialProperty< RankTwoTensor > &	_mechanical_strain
	Mechanical strain material property.
MaterialProperty< RankTwoTensor > &	_stress
	Stress material property.
MaterialProperty< RankTwoTensor > &	_elastic_strain
	Elastic strain material property.
const MaterialProperty< RankTwoTensor > &	_extra_stress
	Extra stress tensor.
std::vector< const Function * >	_initial_stress_fcn
	initial stress components
MaterialProperty< RankFourTensor > &	_Jacobian_mult
	derivative of stress w.r.t. strain (_dstress_dstrain)
MaterialProperty< RankTwoTensor > &	_plastic_deformation_gradient
	Plastic deformation gradient RankTwoTensor for the crystal.
const MaterialProperty< RankTwoTensor > &	_plastic_deformation_gradient_old
MaterialProperty< RankTwoTensor > *	_eigenstrain_deformation_gradient
	Generalized eigenstrain deformation gradient RankTwoTensor for the crystal.
const MaterialProperty< RankTwoTensor > *	_eigenstrain_deformation_gradient_old
const MaterialProperty< RankTwoTensor > &	_deformation_gradient
	Total deformation gradient RankTwoTensor for the crystal.
const MaterialProperty< RankTwoTensor > &	_deformation_gradient_old
MaterialProperty< RankTwoTensor > &	_pk2
	Second Piola-Kirchoff stress measure.
const MaterialProperty< RankTwoTensor > &	_pk2_old
RankTwoTensor	_temporary_deformation_gradient
	Helper deformation gradient tensor variables used in iterative solve.
RankTwoTensor	_elastic_deformation_gradient
RankTwoTensor	_inverse_plastic_deformation_grad
RankTwoTensor	_inverse_plastic_deformation_grad_old
RankTwoTensor	_inverse_eigenstrain_deformation_grad
RankTwoTensor	_delta_deformation_gradient
	Used for substepping; Uniformly divides the increment in deformation gradient.
RankTwoTensor	_temporary_deformation_gradient_old

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)

Private Attributes
FEProblemBase &	_dmi_fe_problem
const InputParameters &	_gc_params
	Parameters of the object with this interface.
FEProblemBase *const	_gc_feproblem
	Reference to the FEProblemBase class.
BlockRestrictable *const	_gc_block_restrict
	Access block restrictions of the object with this interface.

Detailed Description

ComputeMultipleCrystalPlasticityStress (used together with CrystalPlasticityStressUpdateBase) uses the multiplicative decomposition of the deformation gradient and solves the PK2 stress residual equation at the intermediate configuration to evolve the material state.

The internal variables are updated using an iterative predictor-corrector algorithm. Backward Euler integration rule is used for the rate equations.

This material that is not called by MOOSE because of the compute=false flag set in the parameter list.

Definition at line 30 of file ComputeMultipleCrystalPlasticityStress.h.

Member Enumeration Documentation

LineSearchMethod

enum class ComputeMultipleCrystalPlasticityStress::LineSearchMethod

strongprotected

strain formulation

Enumerator
CutHalf
Bisection

Definition at line 175 of file ComputeMultipleCrystalPlasticityStress.h.

{ CutHalf, Bisection } _line_search_method;

TangentModuliType

enum class ComputeMultipleCrystalPlasticityStress::TangentModuliType

strongprotected

Type of tangent moduli calculation.

Enumerator
EXACT
NONE

Definition at line 154 of file ComputeMultipleCrystalPlasticityStress.h.

{ EXACT, NONE } _tan_mod_type;

Constructor & Destructor Documentation

ComputeMultipleCrystalPlasticityStress()

ComputeMultipleCrystalPlasticityStress::ComputeMultipleCrystalPlasticityStress

(

const InputParameters &

parameters

)

Definition at line 64 of file ComputeMultipleCrystalPlasticityStress.C.

  : ComputeFiniteStrainElasticStress(parameters),
    _num_models(getParam<std::vector<MaterialName>>("crystal_plasticity_models").size()),
    _num_eigenstrains(getParam<std::vector<MaterialName>>("eigenstrain_names").size()),
    _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
    _elasticity_tensor(getMaterialPropertyByName<RankFourTensor>(_base_name + "elasticity_tensor")),
    _rtol(getParam<Real>("rtol")),
    _abs_tol(getParam<Real>("abs_tol")),
    _maxiter(getParam<unsigned int>("maxiter")),
    _maxiterg(getParam<unsigned int>("maxiter_state_variable")),
    _tan_mod_type(getParam<MooseEnum>("tan_mod_type").getEnum<TangentModuliType>()),
    _max_substep_iter(getParam<unsigned int>("maximum_substep_iteration")),
    _use_line_search(getParam<bool>("use_line_search")),
    _min_line_search_step_size(getParam<Real>("min_line_search_step_size")),
    _line_search_tolerance(getParam<Real>("line_search_tol")),
    _line_search_max_iterations(getParam<unsigned int>("line_search_maxiter")),
    _line_search_method(getParam<MooseEnum>("line_search_method").getEnum<LineSearchMethod>()),
    _plastic_deformation_gradient(declareProperty<RankTwoTensor>("plastic_deformation_gradient")),
    _plastic_deformation_gradient_old(
        getMaterialPropertyOld<RankTwoTensor>("plastic_deformation_gradient")),
    _eigenstrain_deformation_gradient(
        _num_eigenstrains ? &declareProperty<RankTwoTensor>("eigenstrain_deformation_gradient")
                          : nullptr),
    _eigenstrain_deformation_gradient_old(
        _num_eigenstrains
            ? &getMaterialPropertyOld<RankTwoTensor>("eigenstrain_deformation_gradient")
            : nullptr),
    _deformation_gradient(getMaterialProperty<RankTwoTensor>(_base_name + "deformation_gradient")),
    _deformation_gradient_old(
        getMaterialPropertyOld<RankTwoTensor>(_base_name + "deformation_gradient")),
    _pk2(declareProperty<RankTwoTensor>("second_piola_kirchhoff_stress")),
    _pk2_old(getMaterialPropertyOld<RankTwoTensor>("second_piola_kirchhoff_stress")),
    _total_lagrangian_strain(
        declareProperty<RankTwoTensor>("total_lagrangian_strain")), // Lagrangian strain
    _updated_rotation(declareProperty<RankTwoTensor>("updated_rotation")),
    _updated_rotation_old(getMaterialPropertyOld<RankTwoTensor>("updated_rotation")),
    _misorientation(declareProperty<Real>("misorientation")),
    _crysrot(getMaterialProperty<RankTwoTensor>(
        _base_name + "crysrot")), // defined in the elasticity tensor classes for crystal plasticity
    _print_convergence_message(getParam<bool>("print_state_variable_convergence_error_messages"))
{
  _convergence_failed = false;
}

Member Function Documentation

calcTangentModuli()

void ComputeMultipleCrystalPlasticityStress::calcTangentModuli ( RankFourTensor &  jacobian_mult )

protected

Calculates the tangent moduli for use as a preconditioner, using the elastic or elastic-plastic option as specified by the user.

Definition at line 589 of file ComputeMultipleCrystalPlasticityStress.C.

{
  switch (_tan_mod_type)
  {
    case TangentModuliType::EXACT:
      elastoPlasticTangentModuli(jacobian_mult);
      break;
    default:
      elasticTangentModuli(jacobian_mult);
  }
}

Referenced by postSolveQp().

calculateEigenstrainDeformationGrad()

void ComputeMultipleCrystalPlasticityStress::calculateEigenstrainDeformationGrad ( )

protected

Calculates the deformation gradient due to eigenstrain.

Definition at line 730 of file ComputeMultipleCrystalPlasticityStress.C.

{
  _inverse_eigenstrain_deformation_grad.zero();
  _inverse_eigenstrain_deformation_grad.addIa(1.0);
 
  for (unsigned int i = 0; i < _num_eigenstrains; ++i)
  {
    _eigenstrains[i]->setSubstepDt(_substep_dt);
    _eigenstrains[i]->computeQpProperties();
    _inverse_eigenstrain_deformation_grad *= _eigenstrains[i]->getDeformationGradientInverse();
  }
  (*_eigenstrain_deformation_gradient)[_qp] = _inverse_eigenstrain_deformation_grad.inverse();
}

Referenced by updateStress().

calculateJacobian()

void ComputeMultipleCrystalPlasticityStress::calculateJacobian ( )

protected

Calculates the jacobian as $\mathbf{J} = \mathbf{I} - \mathbf{C} \frac{d\mathbf{E}^e}{d\mathbf{F}^e} \frac{d\mathbf{F}^e}{d\mathbf{F}^P^{-1}} \frac{d\mathbf{F}^P^{-1}}{d\mathbf{PK2}}$.

Definition at line 554 of file ComputeMultipleCrystalPlasticityStress.C.

{
  // may not need to cache the dfpinvdpk2 here. need to double check
  RankFourTensor dfedfpinv, deedfe, dfpinvdpk2, dfpinvdpk2_per_model;
 
  RankTwoTensor ffeiginv = _temporary_deformation_gradient * _inverse_eigenstrain_deformation_grad;
 
  for (const auto i : make_range(Moose::dim))
    for (const auto j : make_range(Moose::dim))
      for (const auto k : make_range(Moose::dim))
        dfedfpinv(i, j, k, j) = ffeiginv(i, k);
 
  for (const auto i : make_range(Moose::dim))
    for (const auto j : make_range(Moose::dim))
      for (const auto k : make_range(Moose::dim))
      {
        deedfe(i, j, k, i) = deedfe(i, j, k, i) + _elastic_deformation_gradient(k, j) * 0.5;
        deedfe(i, j, k, j) = deedfe(i, j, k, j) + _elastic_deformation_gradient(k, i) * 0.5;
      }
 
  for (unsigned int i = 0; i < _num_models; ++i)
  {
    _models[i]->calculateTotalPlasticDeformationGradientDerivative(
        dfpinvdpk2_per_model,
        _inverse_plastic_deformation_grad_old,
        _inverse_eigenstrain_deformation_grad,
        _num_eigenstrains);
    dfpinvdpk2 += dfpinvdpk2_per_model;
  }
 
  _jacobian =
      RankFourTensor::IdentityFour() - (_elasticity_tensor[_qp] * deedfe * dfedfpinv * dfpinvdpk2);
}

Referenced by calculateResidualAndJacobian().

calculateResidual()

void ComputeMultipleCrystalPlasticityStress::calculateResidual ( )

protected

Calculate stress residual as the difference between the stored material property PK2 stress and the elastic PK2 stress calculated from the constitutively defined equivalent_slip_increment.

The equivalent_slip_increment is passed in as an input arguement.

Definition at line 510 of file ComputeMultipleCrystalPlasticityStress.C.

{
  RankTwoTensor ce, elastic_strain, ce_pk2, equivalent_slip_increment_per_model,
      equivalent_slip_increment, pk2_new;
 
  equivalent_slip_increment.zero();
 
  // calculate slip rate in order to compute F^{p-1}
  for (unsigned int i = 0; i < _num_models; ++i)
  {
    equivalent_slip_increment_per_model.zero();
 
    // calculate shear stress with consideration of contribution from other physics
    _models[i]->calculateShearStress(
        _pk2[_qp], _inverse_eigenstrain_deformation_grad, _num_eigenstrains);
 
    _convergence_failed = !_models[i]->calculateSlipRate();
 
    if (_convergence_failed)
      return;
 
    _models[i]->calculateEquivalentSlipIncrement(equivalent_slip_increment_per_model);
    equivalent_slip_increment += equivalent_slip_increment_per_model;
  }
 
  RankTwoTensor residual_equivalent_slip_increment =
      RankTwoTensor::Identity() - equivalent_slip_increment;
  _inverse_plastic_deformation_grad =
      _inverse_plastic_deformation_grad_old * residual_equivalent_slip_increment;
 
  _elastic_deformation_gradient = _temporary_deformation_gradient *
                                  _inverse_eigenstrain_deformation_grad *
                                  _inverse_plastic_deformation_grad;
 
  ce = _elastic_deformation_gradient.transpose() * _elastic_deformation_gradient;
 
  elastic_strain = ce - RankTwoTensor::Identity();
  elastic_strain *= 0.5;
 
  pk2_new = _elasticity_tensor[_qp] * elastic_strain;
  _residual_tensor = _pk2[_qp] - pk2_new;
}

Referenced by calculateResidualAndJacobian(), and lineSearchUpdate().

calculateResidualAndJacobian()

void ComputeMultipleCrystalPlasticityStress::calculateResidualAndJacobian ( )

protected

Calls the residual and jacobian functions used in the stress update algorithm.

Definition at line 501 of file ComputeMultipleCrystalPlasticityStress.C.

{
  calculateResidual();
  if (_convergence_failed)
    return;
  calculateJacobian();
}

Referenced by solveStress().

computeQpProperties()

void ComputeGeneralStressBase::computeQpProperties ( )

overrideprotectedvirtualinherited

Definition at line 44 of file ComputeGeneralStressBase.C.

{
  computeQpStress();
 
  // Add in extra stress
  _stress[_qp] += _extra_stress[_qp];
}

computeQpStress()

void ComputeMultipleCrystalPlasticityStress::computeQpStress ( )

overrideprotectedvirtual

Compute the stress and store it in the _stress material property for the current quadrature point.

Reimplemented from ComputeFiniteStrainElasticStress.

Definition at line 188 of file ComputeMultipleCrystalPlasticityStress.C.

{
  for (unsigned int i = 0; i < _num_models; ++i)
  {
    _models[i]->setQp(_qp);
    _models[i]->setMaterialVectorSize();
  }
 
  for (unsigned int i = 0; i < _num_eigenstrains; ++i)
    _eigenstrains[i]->setQp(_qp);
 
  updateStress(_stress[_qp], _Jacobian_mult[_qp]); // This is NOT the exact jacobian
}

elasticTangentModuli()

void ComputeMultipleCrystalPlasticityStress::elasticTangentModuli ( RankFourTensor &  jacobian_mult )

protected

Definition at line 648 of file ComputeMultipleCrystalPlasticityStress.C.

{
  // update jacobian_mult
  jacobian_mult = _elasticity_tensor[_qp];
}

Referenced by calcTangentModuli().

elastoPlasticTangentModuli()

void ComputeMultipleCrystalPlasticityStress::elastoPlasticTangentModuli ( RankFourTensor &  jacobian_mult )

protected

Definition at line 602 of file ComputeMultipleCrystalPlasticityStress.C.

{
  RankFourTensor tan_mod;
  RankTwoTensor pk2fet, fepk2, feiginvfpinv;
  RankFourTensor deedfe, dsigdpk2dfe, dfedf;
 
  // Fill in the matrix stiffness material property
  for (const auto i : make_range(Moose::dim))
    for (const auto j : make_range(Moose::dim))
      for (const auto k : make_range(Moose::dim))
      {
        deedfe(i, j, k, i) = deedfe(i, j, k, i) + _elastic_deformation_gradient(k, j) * 0.5;
        deedfe(i, j, k, j) = deedfe(i, j, k, j) + _elastic_deformation_gradient(k, i) * 0.5;
      }
 
  usingTensorIndices(i_, j_, k_, l_);
  dsigdpk2dfe = _elastic_deformation_gradient.times<i_, k_, j_, l_>(_elastic_deformation_gradient) *
                _elasticity_tensor[_qp] * deedfe;
 
  pk2fet = _pk2[_qp] * _elastic_deformation_gradient.transpose();
  fepk2 = _elastic_deformation_gradient * _pk2[_qp];
 
  for (const auto i : make_range(Moose::dim))
    for (const auto j : make_range(Moose::dim))
      for (const auto l : make_range(Moose::dim))
      {
        tan_mod(i, j, i, l) += pk2fet(l, j);
        tan_mod(i, j, j, l) += fepk2(i, l);
      }
 
  tan_mod += dsigdpk2dfe;
 
  const auto je = _elastic_deformation_gradient.det();
  if (je > 0.0)
    tan_mod /= je;
 
  feiginvfpinv = _inverse_eigenstrain_deformation_grad * _inverse_plastic_deformation_grad;
  for (const auto i : make_range(Moose::dim))
    for (const auto j : make_range(Moose::dim))
      for (const auto l : make_range(Moose::dim))
        dfedf(i, j, i, l) = feiginvfpinv(l, j);
 
  jacobian_mult = tan_mod * dfedf;
}

Referenced by calcTangentModuli().

hasGuaranteedMaterialProperty()

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

protectedinherited

Definition at line 28 of file GuaranteeConsumer.C.

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

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

initialSetup()

void ComputeMultipleCrystalPlasticityStress::initialSetup ( )

overridevirtual

Definition at line 148 of file ComputeMultipleCrystalPlasticityStress.C.

{
  // get crystal plasticity models
  std::vector<MaterialName> model_names =
      getParam<std::vector<MaterialName>>("crystal_plasticity_models");
 
  for (unsigned int i = 0; i < _num_models; ++i)
  {
    CrystalPlasticityStressUpdateBase * model =
        dynamic_cast<CrystalPlasticityStressUpdateBase *>(&getMaterialByName(model_names[i]));
 
    if (model)
    {
      _models.push_back(model);
      // TODO: check to make sure that the material model is compatible with this class
    }
    else
      mooseError("Model " + model_names[i] +
                 " is not compatible with ComputeMultipleCrystalPlasticityStress");
  }
 
  // get crystal plasticity eigenstrains
  std::vector<MaterialName> eigenstrain_names =
      getParam<std::vector<MaterialName>>("eigenstrain_names");
 
  for (unsigned int i = 0; i < _num_eigenstrains; ++i)
  {
    ComputeCrystalPlasticityEigenstrainBase * eigenstrain =
        dynamic_cast<ComputeCrystalPlasticityEigenstrainBase *>(
            &getMaterialByName(eigenstrain_names[i]));
 
    if (eigenstrain)
      _eigenstrains.push_back(eigenstrain);
    else
      mooseError("Eigenstrain" + eigenstrain_names[i] +
                 " is not compatible with ComputeMultipleCrystalPlasticityStress");
  }
}

initQpStatefulProperties()

void ComputeMultipleCrystalPlasticityStress::initQpStatefulProperties ( )

overrideprotectedvirtual

initializes the stateful properties such as PK2 stress, resolved shear stress, plastic deformation gradient, slip system resistances, etc.

This class is often overwritten by inherting classes.

Reimplemented from ComputeFiniteStrainElasticStress.

Definition at line 110 of file ComputeMultipleCrystalPlasticityStress.C.

{
  _plastic_deformation_gradient[_qp].zero();
  _plastic_deformation_gradient[_qp].addIa(1.0);
 
  if (_num_eigenstrains)
  {
    (*_eigenstrain_deformation_gradient)[_qp].zero();
    (*_eigenstrain_deformation_gradient)[_qp].addIa(1.0);
  }
  else
  {
    // set to identity if no eigenstrain is added
    _inverse_eigenstrain_deformation_grad.zero();
    _inverse_eigenstrain_deformation_grad.addIa(1.0);
  }
 
  _pk2[_qp].zero();
 
  _total_lagrangian_strain[_qp].zero();
 
  _updated_rotation[_qp].zero();
  _updated_rotation[_qp].addIa(1.0);
 
  for (unsigned int i = 0; i < _num_models; ++i)
  {
    _models[i]->setQp(_qp);
    _models[i]->initQpStatefulProperties();
  }
 
  for (unsigned int i = 0; i < _num_eigenstrains; ++i)
  {
    _eigenstrains[i]->setQp(_qp);
    _eigenstrains[i]->initQpStatefulProperties();
  }
}

lineSearchUpdate()

bool ComputeMultipleCrystalPlasticityStress::lineSearchUpdate ( const Real &  rnorm_prev, const RankTwoTensor &  dpk2  )

protected

performs the line search update

Definition at line 655 of file ComputeMultipleCrystalPlasticityStress.C.

{
  if (_line_search_method == LineSearchMethod::CutHalf)
  {
    Real rnorm;
    Real step = 1.0;
 
    do
    {
      _pk2[_qp] = _pk2[_qp] - step * dpk2;
      step /= 2.0;
      _pk2[_qp] = _pk2[_qp] + step * dpk2;
 
      calculateResidual();
      rnorm = _residual_tensor.L2norm();
    } while (rnorm > rnorm_prev && step > _min_line_search_step_size);
 
    // has norm improved or is the step still above minumum search step size?
    return (rnorm <= rnorm_prev || step > _min_line_search_step_size);
  }
  else if (_line_search_method == LineSearchMethod::Bisection)
  {
    unsigned int count = 0;
    Real step_a = 0.0;
    Real step_b = 1.0;
    Real step = 1.0;
    Real s_m = 1000.0;
    Real rnorm = 1000.0;
 
    calculateResidual();
    auto s_b = _residual_tensor.doubleContraction(dpk2);
    const auto rnorm1 = _residual_tensor.L2norm();
    _pk2[_qp] = _pk2[_qp] - dpk2;
    calculateResidual();
    auto s_a = _residual_tensor.doubleContraction(dpk2);
    const auto rnorm0 = _residual_tensor.L2norm();
    _pk2[_qp] = _pk2[_qp] + dpk2;
 
    if ((rnorm1 / rnorm0) < _line_search_tolerance || s_a * s_b > 0)
    {
      calculateResidual();
      return true;
    }
 
    while ((rnorm / rnorm0) > _line_search_tolerance && count < _line_search_max_iterations)
    {
      _pk2[_qp] = _pk2[_qp] - step * dpk2;
      step = 0.5 * (step_b + step_a);
      _pk2[_qp] = _pk2[_qp] + step * dpk2;
      calculateResidual();
      s_m = _residual_tensor.doubleContraction(dpk2);
      rnorm = _residual_tensor.L2norm();
 
      if (s_m * s_a < 0.0)
      {
        step_b = step;
        s_b = s_m;
      }
      if (s_m * s_b < 0.0)
      {
        step_a = step;
        s_a = s_m;
      }
      count++;
    }
 
    // below tolerance and max iterations?
    return ((rnorm / rnorm0) < _line_search_tolerance && count < _line_search_max_iterations);
  }
  else
    mooseError("Line search method is not provided.");
}

Referenced by solveStress().

postSolveQp()

void ComputeMultipleCrystalPlasticityStress::postSolveQp ( RankTwoTensor &  stress_new, RankFourTensor &  jacobian_mult  )

protected

Save the final stress and internal variable values after the iterative solve.

Definition at line 303 of file ComputeMultipleCrystalPlasticityStress.C.

{
  cauchy_stress = _elastic_deformation_gradient * _pk2[_qp] *
                  _elastic_deformation_gradient.transpose() / _elastic_deformation_gradient.det();
 
  calcTangentModuli(jacobian_mult);
 
  _total_lagrangian_strain[_qp] =
      _deformation_gradient[_qp].transpose() * _deformation_gradient[_qp] -
      RankTwoTensor::Identity();
  _total_lagrangian_strain[_qp] = _total_lagrangian_strain[_qp] * 0.5;
 
  // Calculate crystal rotation to track separately
  RankTwoTensor rot;
  _elastic_deformation_gradient.getRUDecompositionRotation(rot);
  _updated_rotation[_qp] = rot * _crysrot[_qp];
 
  // Calculate the misorientation
  auto _delta_misorientation_mat = _updated_rotation[_qp] * _updated_rotation_old[_qp].inverse();
  auto cos_val = (_delta_misorientation_mat.trace() - 1.0) / 2.0;
  // Mathematically, the values should lie in the range of [-1, 1]. However, there maybe numerical
  // errors during calculation. Let's guard small numerical errors here and throw an error when the
  // numerical error is too big, which indicates other issues.
  if (cos_val > 1.0 || cos_val < -1.0)
  {
    if (MooseUtils::absoluteFuzzyEqual(cos_val, -1.0))
      cos_val = -1.0;
    else if (MooseUtils::absoluteFuzzyEqual(cos_val, 1.0))
      cos_val = 1.0;
    else
      mooseError("Misorientation value is undefined. This should not happen.");
  }
  _misorientation[_qp] = std::acos(cos_val);
}

Referenced by updateStress().

preSolveQp()

void ComputeMultipleCrystalPlasticityStress::preSolveQp ( )

protected

Reset the PK2 stress and the inverse deformation gradient to old values and provide an interface for inheriting classes to reset material properties.

Definition at line 271 of file ComputeMultipleCrystalPlasticityStress.C.

{
  for (unsigned int i = 0; i < _num_models; ++i)
    _models[i]->setInitialConstitutiveVariableValues();
 
  _pk2[_qp] = _pk2_old[_qp];
  _inverse_plastic_deformation_grad_old = _plastic_deformation_gradient_old[_qp].inverse();
}

Referenced by updateStress().

solveQp()

void ComputeMultipleCrystalPlasticityStress::solveQp ( )

protected

Solve the stress and internal state variables (e.g.

slip increment, slip system resistance) at each qp points

Definition at line 281 of file ComputeMultipleCrystalPlasticityStress.C.

{
  for (unsigned int i = 0; i < _num_models; ++i)
  {
    _models[i]->setSubstepConstitutiveVariableValues();
    _models[i]->calculateSlipResistance();
  }
 
  _inverse_plastic_deformation_grad = _inverse_plastic_deformation_grad_old;
 
  solveStateVariables();
  if (_convergence_failed)
    return; // pop back up and take a smaller substep
 
  for (unsigned int i = 0; i < _num_models; ++i)
    _models[i]->updateSubstepConstitutiveVariableValues();
 
  // save off the old F^{p} inverse now that have converged on the stress and state variables
  _inverse_plastic_deformation_grad_old = _inverse_plastic_deformation_grad;
}

Referenced by updateStress().

solveStateVariables()

void ComputeMultipleCrystalPlasticityStress::solveStateVariables ( )

protected

Solves the internal variables stress as a function of the slip specified by the constitutive model defined in the inheriting class.

Definition at line 340 of file ComputeMultipleCrystalPlasticityStress.C.

{
  unsigned int iteration;
  bool iter_flag = true;
 
  iteration = 0;
  // Check for slip system resistance update tolerance
  do
  {
    solveStress();
    if (_convergence_failed)
      return;
 
    _plastic_deformation_gradient[_qp] =
        _inverse_plastic_deformation_grad.inverse(); // the postSoveStress
 
    // Update slip system resistance and state variable after the stress has been finalized
    // We loop through all the models for each calculation
    // in order to make sure that when coupling appears, the state variables are updated based on
    // the same components
    for (unsigned int i = 0; i < _num_models; ++i)
      _models[i]->cacheStateVariablesBeforeUpdate();
 
    for (unsigned int i = 0; i < _num_models; ++i)
      _models[i]->calculateStateVariableEvolutionRateComponent();
 
    for (unsigned int i = 0; i < _num_models; ++i)
      if (!_models[i]->updateStateVariables())
        _convergence_failed = true;
 
    for (unsigned int i = 0; i < _num_models; ++i)
      _models[i]->calculateSlipResistance();
 
    if (_convergence_failed)
      return;
 
    for (unsigned int i = 0; i < _num_models; ++i)
    {
      // iter_flag = false, stop iteration if all values are converged and good to go
      // iter_flag = true, continue iteration if any value is not converged
      if (!_models[i]->areConstitutiveStateVariablesConverged())
      {
        iter_flag = true;
        break;
      }
      else
        iter_flag = false; // iter_flag = false, stop iteration only when all models returns true
    }
 
    if (iter_flag)
    {
      if (_print_convergence_message)
        mooseWarning("ComputeMultipleCrystalPlasticityStress: State variables (or the system "
                     "resistance) did not converge at element ",
                     _current_elem->id(),
                     " and qp ",
                     _qp,
                     "\n");
    }
    iteration++;
  } while (iter_flag && iteration < _maxiterg);
 
  if (iteration == _maxiterg)
  {
    if (_print_convergence_message)
      mooseWarning(
          "ComputeMultipleCrystalPlasticityStress: Hardness Integration error. Reached the "
          "maximum number of iterations to solve for the state variables at element ",
          _current_elem->id(),
          " and qp ",
          _qp,
          "\n");
 
    _convergence_failed = true;
  }
}

Referenced by solveQp().

solveStress()

void ComputeMultipleCrystalPlasticityStress::solveStress ( )

protected

solves for stress, updates plastic deformation gradient.

Definition at line 418 of file ComputeMultipleCrystalPlasticityStress.C.

{
  unsigned int iteration = 0;
  RankTwoTensor dpk2;
  Real rnorm, rnorm0, rnorm_prev;
 
  // Calculate stress residual
  calculateResidualAndJacobian();
  if (_convergence_failed)
  {
    if (_print_convergence_message)
      mooseWarning("ComputeMultipleCrystalPlasticityStress: the slip increment exceeds tolerance "
                   "at element ",
                   _current_elem->id(),
                   " and Gauss point ",
                   _qp);
 
    return;
  }
 
  rnorm = _residual_tensor.L2norm();
  rnorm0 = rnorm;
 
  // Check for stress residual tolerance; different from user object version which
  // compares the absolute tolerance of only the original rnorm value
  while (rnorm > _rtol * rnorm0 && rnorm > _abs_tol && iteration < _maxiter)
  {
    // Calculate stress increment
    dpk2 = -_jacobian.invSymm() * _residual_tensor;
    _pk2[_qp] = _pk2[_qp] + dpk2;
 
    calculateResidualAndJacobian();
 
    if (_convergence_failed)
    {
      if (_print_convergence_message)
        mooseWarning("ComputeMultipleCrystalPlasticityStress: the slip increment exceeds tolerance "
                     "at element ",
                     _current_elem->id(),
                     " and Gauss point ",
                     _qp);
 
      return;
    }
 
    rnorm_prev = rnorm;
    rnorm = _residual_tensor.L2norm();
 
    if (_use_line_search && rnorm > rnorm_prev && !lineSearchUpdate(rnorm_prev, dpk2))
    {
      if (_print_convergence_message)
        mooseWarning("ComputeMultipleCrystalPlasticityStress: Failed with line search");
 
      _convergence_failed = true;
      return;
    }
 
    if (_use_line_search)
      rnorm = _residual_tensor.L2norm();
 
    iteration++;
  }
 
  if (iteration >= _maxiter)
  {
    if (_print_convergence_message)
      mooseWarning("ComputeMultipleCrystalPlasticityStress: Stress Integration error rmax = ",
                   rnorm,
                   " and the tolerance is ",
                   _rtol * rnorm0,
                   " when the rnorm0 value is ",
                   rnorm0,
                   " for element ",
                   _current_elem->id(),
                   " and qp ",
                   _qp);
 
    _convergence_failed = true;
  }
}

Referenced by solveStateVariables().

updateStress()

void ComputeMultipleCrystalPlasticityStress::updateStress ( RankTwoTensor &  cauchy_stress, RankFourTensor &  jacobian_mult  )

protectedvirtual

Updates the stress (PK2) at a quadrature point by calling constiutive relationship as defined in a child class Solves stress residual equation using Newton - Raphson: Updates slip system resistances iteratively.

Definition at line 203 of file ComputeMultipleCrystalPlasticityStress.C.

{
  // Does not support face/boundary material property calculation
  if (isBoundaryMaterial())
    return;
 
  // Initialize substepping variables
  unsigned int substep_iter = 1;
  unsigned int num_substep = 1;
 
  _temporary_deformation_gradient_old = _deformation_gradient_old[_qp];
  if (_temporary_deformation_gradient_old.det() == 0)
    _temporary_deformation_gradient_old.addIa(1.0);
 
  _delta_deformation_gradient = _deformation_gradient[_qp] - _temporary_deformation_gradient_old;
 
  // Loop through all models and calculate the schmid tensor for the current state of the crystal
  // lattice
  // Not sure if we should pass in the updated or the original rotation here
  // If not, then we should not need to compute the flow direction every iteration here
  for (unsigned int i = 0; i < _num_models; ++i)
    _models[i]->calculateFlowDirection(_crysrot[_qp]);
 
  do
  {
    _convergence_failed = false;
    preSolveQp();
 
    _substep_dt = _dt / num_substep;
    for (unsigned int i = 0; i < _num_models; ++i)
      _models[i]->setSubstepDt(_substep_dt);
 
    // calculate F^{eigen} only when we have eigenstrain
    _inverse_eigenstrain_deformation_grad.zero();
    _inverse_eigenstrain_deformation_grad.addIa(1.0);
    if (_num_eigenstrains)
      calculateEigenstrainDeformationGrad();
 
    for (unsigned int istep = 0; istep < num_substep; ++istep)
    {
      _temporary_deformation_gradient =
          (static_cast<Real>(istep) + 1) / num_substep * _delta_deformation_gradient;
      _temporary_deformation_gradient += _temporary_deformation_gradient_old;
 
      solveQp();
 
      if (_convergence_failed)
      {
        if (_print_convergence_message)
          mooseWarning(
              "The crystal plasticity constitutive model has failed to converge. Increasing "
              "the number of substeps.");
 
        substep_iter++;
        num_substep *= 2;
        break;
      }
    }
 
    if (substep_iter > _max_substep_iter && _convergence_failed)
      mooseException("ComputeMultipleCrystalPlasticityStress: Constitutive failure");
  } while (_convergence_failed);
 
  postSolveQp(cauchy_stress, jacobian_mult);
}

Referenced by computeQpStress().

validParams()

InputParameters ComputeMultipleCrystalPlasticityStress::validParams ( )

static

Definition at line 20 of file ComputeMultipleCrystalPlasticityStress.C.

{
  InputParameters params = ComputeFiniteStrainElasticStress::validParams();
 
  params.addClassDescription(
      "Crystal Plasticity base class: handles the Newton iteration over the stress residual and "
      "calculates the Jacobian based on constitutive laws from multiple material classes "
      "that are inherited from CrystalPlasticityStressUpdateBase");
  params.addParam<std::string>(
      "base_name",
      "Optional parameter that allows the user to define multiple mechanics material systems on "
      "the same block, i.e. for multiple phases");
 
  params.addRequiredParam<std::vector<MaterialName>>(
      "crystal_plasticity_models",
      "The material objects to use to calculate crystal plasticity stress and strains.");
  params.addParam<std::vector<MaterialName>>(
      "eigenstrain_names", {}, "The material objects to calculate eigenstrains.");
  params.addParam<MooseEnum>("tan_mod_type",
                             MooseEnum("exact none", "none"),
                             "Type of tangent moduli for preconditioner: default elastic");
  params.addParam<Real>("rtol", 1e-6, "Constitutive stress residual relative tolerance");
  params.addParam<Real>("abs_tol", 1e-6, "Constitutive stress residual absolute tolerance");
  params.addParam<unsigned int>("maxiter", 100, "Maximum number of iterations for stress update");
  params.addParam<unsigned int>(
      "maxiter_state_variable", 100, "Maximum number of iterations for state variable update");
  params.addParam<unsigned int>(
      "maximum_substep_iteration", 1, "Maximum number of substep iteration");
  params.addParam<bool>("use_line_search", false, "Use line search in constitutive update");
  params.addParam<Real>("min_line_search_step_size", 0.01, "Minimum line search step size");
  params.addParam<Real>("line_search_tol", 0.5, "Line search bisection method tolerance");
  params.addParam<unsigned int>(
      "line_search_maxiter", 20, "Line search bisection method maximum number of iteration");
  params.addParam<MooseEnum>("line_search_method",
                             MooseEnum("CUT_HALF BISECTION", "CUT_HALF"),
                             "The method used in line search");
  params.addParam<bool>(
      "print_state_variable_convergence_error_messages",
      false,
      "Whether or not to print warning messages from the crystal plasticity specific convergence "
      "checks on the stress measure and general constitutive model quantinties.");
  return params;
}

Member Data Documentation

_abs_tol

Real ComputeMultipleCrystalPlasticityStress::_abs_tol

protected

Stress residual equation absolute tolerance.

Definition at line 141 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by solveStress().

_base_name

const std::string ComputeMultipleCrystalPlasticityStress::_base_name

protected

optional parameter to define several mechanical systems on the same block, e.g. multiple phases

Definition at line 133 of file ComputeMultipleCrystalPlasticityStress.h.

_convergence_failed

bool ComputeMultipleCrystalPlasticityStress::_convergence_failed

protected

Flag to check whether convergence is achieved or if substepping is needed.

Definition at line 230 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateResidual(), calculateResidualAndJacobian(), ComputeMultipleCrystalPlasticityStress(), solveQp(), solveStateVariables(), solveStress(), and updateStress().

_crysrot

const MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_crysrot

protected

Crystal rotation in the original, or reference, configuration as defined by Euler angle arguments in the ComputeElasticityTensor classes.

Definition at line 216 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by postSolveQp(), and updateStress().

_deformation_gradient

const MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_deformation_gradient

protected

Total deformation gradient RankTwoTensor for the crystal.

Definition at line 188 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by postSolveQp(), and updateStress().

_deformation_gradient_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_deformation_gradient_old

protected

Definition at line 189 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by updateStress().

_delta_deformation_gradient

RankTwoTensor ComputeMultipleCrystalPlasticityStress::_delta_deformation_gradient

protected

Used for substepping; Uniformly divides the increment in deformation gradient.

Definition at line 233 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by updateStress().

_dfgrd_scale_factor

Real ComputeMultipleCrystalPlasticityStress::_dfgrd_scale_factor

protected

Scales the substepping increment to obtain deformation gradient at a substep iteration.

Definition at line 238 of file ComputeMultipleCrystalPlasticityStress.h.

_eigenstrain_deformation_gradient

MaterialProperty<RankTwoTensor>* ComputeMultipleCrystalPlasticityStress::_eigenstrain_deformation_gradient

protected

Generalized eigenstrain deformation gradient RankTwoTensor for the crystal.

Definition at line 183 of file ComputeMultipleCrystalPlasticityStress.h.

_eigenstrain_deformation_gradient_old

const MaterialProperty<RankTwoTensor>* ComputeMultipleCrystalPlasticityStress::_eigenstrain_deformation_gradient_old

protected

Definition at line 184 of file ComputeMultipleCrystalPlasticityStress.h.

_eigenstrains

std::vector<ComputeCrystalPlasticityEigenstrainBase *> ComputeMultipleCrystalPlasticityStress::_eigenstrains

protected

The user supplied cyrstal plasticity eigenstrains.

Definition at line 130 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateEigenstrainDeformationGrad(), computeQpStress(), initialSetup(), and initQpStatefulProperties().

_elastic_deformation_gradient

RankTwoTensor ComputeMultipleCrystalPlasticityStress::_elastic_deformation_gradient

protected

Definition at line 220 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateJacobian(), calculateResidual(), elastoPlasticTangentModuli(), and postSolveQp().

_elastic_strain

MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_elastic_strain

protectedinherited

Elastic strain material property.

Definition at line 50 of file ComputeGeneralStressBase.h.

Referenced by ComputeSmearedCrackingStress::computeCrackStrainAndOrientation(), ComputeMultiPlasticityStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeSmearedCrackingStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), and ComputeGeneralStressBase::initQpStatefulProperties().

_elastic_strain_old

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_elastic_strain_old

protectedinherited

The old elastic strain is used to calculate the old stress in the case of variable elasticity tensors.

Definition at line 51 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress().

_elasticity_tensor

const MaterialProperty<RankFourTensor>& ComputeMultipleCrystalPlasticityStress::_elasticity_tensor

protected

Elasticity tensor as defined by a separate class.

Definition at line 136 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateJacobian(), calculateResidual(), elasticTangentModuli(), and elastoPlasticTangentModuli().

_elasticity_tensor_name

const std::string ComputeFiniteStrainElasticStress::_elasticity_tensor_name

protectedinherited

Name of the elasticity tensor material property.

Definition at line 33 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress(), ComputeMultipleInelasticStressBase::initialSetup(), and ComputeSmearedCrackingStress::initialSetup().

_extra_stress

const MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_extra_stress

protectedinherited

Extra stress tensor.

Definition at line 53 of file ComputeGeneralStressBase.h.

Referenced by ComputeGeneralStressBase::computeQpProperties().

_gc_block_restrict

BlockRestrictable* const GuaranteeConsumer::_gc_block_restrict

privateinherited

Access block restrictions of the object with this interface.

Definition at line 41 of file GuaranteeConsumer.h.

Referenced by GuaranteeConsumer::hasGuaranteedMaterialProperty().

_gc_feproblem

FEProblemBase* const GuaranteeConsumer::_gc_feproblem

privateinherited

Reference to the FEProblemBase class.

Definition at line 38 of file GuaranteeConsumer.h.

Referenced by GuaranteeConsumer::hasGuaranteedMaterialProperty().

_gc_params

const InputParameters& GuaranteeConsumer::_gc_params

privateinherited

Parameters of the object with this interface.

Definition at line 35 of file GuaranteeConsumer.h.

_initial_stress_fcn

std::vector<const Function *> ComputeGeneralStressBase::_initial_stress_fcn

protectedinherited

initial stress components

Definition at line 56 of file ComputeGeneralStressBase.h.

_inverse_eigenstrain_deformation_grad

RankTwoTensor ComputeMultipleCrystalPlasticityStress::_inverse_eigenstrain_deformation_grad

protected

Definition at line 223 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateEigenstrainDeformationGrad(), calculateJacobian(), calculateResidual(), elastoPlasticTangentModuli(), initQpStatefulProperties(), and updateStress().

_inverse_plastic_deformation_grad

RankTwoTensor ComputeMultipleCrystalPlasticityStress::_inverse_plastic_deformation_grad

protected

Definition at line 221 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateResidual(), elastoPlasticTangentModuli(), solveQp(), and solveStateVariables().

_inverse_plastic_deformation_grad_old

RankTwoTensor ComputeMultipleCrystalPlasticityStress::_inverse_plastic_deformation_grad_old

protected

Definition at line 222 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateJacobian(), calculateResidual(), preSolveQp(), and solveQp().

_jacobian

RankFourTensor ComputeMultipleCrystalPlasticityStress::_jacobian

protected

Jacobian tensor.

Definition at line 146 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateJacobian(), and solveStress().

_Jacobian_mult

MaterialProperty<RankFourTensor>& ComputeGeneralStressBase::_Jacobian_mult

protectedinherited

derivative of stress w.r.t. strain (_dstress_dstrain)

Definition at line 59 of file ComputeGeneralStressBase.h.

Referenced by ComputeStrainIncrementBasedStress::computeQpJacobian(), FiniteStrainHyperElasticViscoPlastic::computeQpJacobian(), ComputeMultipleInelasticStressBase::computeQpJacobianMult(), ComputeMultipleInelasticCosseratStress::computeQpJacobianMult(), ComputeMultiPlasticityStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStress(), ComputeSmearedCrackingStress::computeQpStress(), computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeLinearElasticPFFractureStress::computeStrainSpectral(), ComputeLinearElasticPFFractureStress::computeStrainVolDev(), ComputeLinearElasticPFFractureStress::computeStressSpectral(), FiniteStrainUObasedCP::elasticTangentModuli(), FiniteStrainUObasedCP::elastoPlasticTangentModuli(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), ComputeMultiPlasticityStress::postReturnMap(), FiniteStrainCrystalPlasticity::postSolveQp(), FiniteStrainCrystalPlasticity::preSolveQp(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_line_search_max_iterations

unsigned int ComputeMultipleCrystalPlasticityStress::_line_search_max_iterations

protected

Line search bisection method maximum iteration number.

Definition at line 172 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by lineSearchUpdate().

_line_search_method

enum ComputeMultipleCrystalPlasticityStress::LineSearchMethod ComputeMultipleCrystalPlasticityStress::_line_search_method

protected

Referenced by lineSearchUpdate().

_line_search_tolerance

Real ComputeMultipleCrystalPlasticityStress::_line_search_tolerance

protected

Line search bisection method tolerance.

Definition at line 169 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by lineSearchUpdate().

_max_substep_iter

unsigned int ComputeMultipleCrystalPlasticityStress::_max_substep_iter

protected

Maximum number of substep iterations.

Definition at line 157 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by updateStress().

_maxiter

unsigned int ComputeMultipleCrystalPlasticityStress::_maxiter

protected

Maximum number of iterations for stress update.

Definition at line 149 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by solveStress().

_maxiterg

unsigned int ComputeMultipleCrystalPlasticityStress::_maxiterg

protected

Maximum number of iterations for internal variable update.

Definition at line 151 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by solveStateVariables().

_mechanical_strain

const MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_mechanical_strain

protectedinherited

Mechanical strain material property.

Definition at line 46 of file ComputeGeneralStressBase.h.

Referenced by ComputeStrainIncrementBasedStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeStrainSpectral(), ComputeLinearElasticPFFractureStress::computeStrainVolDev(), and ComputeLinearElasticPFFractureStress::computeStressSpectral().

_min_line_search_step_size

Real ComputeMultipleCrystalPlasticityStress::_min_line_search_step_size

protected

Minimum line search step size.

Definition at line 166 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by lineSearchUpdate().

_misorientation

MaterialProperty<Real>& ComputeMultipleCrystalPlasticityStress::_misorientation

protected

Misorientation angle of the crystal during deformation.

Definition at line 210 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by postSolveQp().

_models

std::vector<CrystalPlasticityStressUpdateBase *> ComputeMultipleCrystalPlasticityStress::_models

protected

The user supplied cyrstal plasticity consititutive models.

Definition at line 124 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateJacobian(), calculateResidual(), computeQpStress(), initialSetup(), initQpStatefulProperties(), preSolveQp(), solveQp(), solveStateVariables(), and updateStress().

_num_eigenstrains

const unsigned ComputeMultipleCrystalPlasticityStress::_num_eigenstrains

protected

number of eigenstrains

Definition at line 127 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateEigenstrainDeformationGrad(), calculateJacobian(), calculateResidual(), computeQpStress(), initialSetup(), initQpStatefulProperties(), and updateStress().

_num_models

const unsigned ComputeMultipleCrystalPlasticityStress::_num_models

protected

number of plastic models

Definition at line 121 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateJacobian(), calculateResidual(), computeQpStress(), initialSetup(), initQpStatefulProperties(), preSolveQp(), solveQp(), solveStateVariables(), and updateStress().

_pk2

MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_pk2

protected

Second Piola-Kirchoff stress measure.

Definition at line 193 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateResidual(), elastoPlasticTangentModuli(), initQpStatefulProperties(), lineSearchUpdate(), postSolveQp(), preSolveQp(), and solveStress().

_pk2_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_pk2_old

protected

Definition at line 194 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by preSolveQp().

_plastic_deformation_gradient

MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_plastic_deformation_gradient

protected

Plastic deformation gradient RankTwoTensor for the crystal.

Definition at line 178 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by initQpStatefulProperties(), and solveStateVariables().

_plastic_deformation_gradient_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_plastic_deformation_gradient_old

protected

Definition at line 179 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by preSolveQp().

_print_convergence_message

const bool ComputeMultipleCrystalPlasticityStress::_print_convergence_message

protected

Flag to print to console warning messages on stress, constitutive model convergence.

Definition at line 227 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by solveStateVariables(), solveStress(), and updateStress().

_residual_tensor

RankTwoTensor ComputeMultipleCrystalPlasticityStress::_residual_tensor

protected

Residual tensor.

Definition at line 144 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateResidual(), lineSearchUpdate(), and solveStress().

_rotation_increment

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_rotation_increment

protectedinherited

Rotation increment material property.

Definition at line 43 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeMultipleInelasticCosseratStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStress(), ComputeSmearedCrackingStress::computeQpStress(), and ComputeMultipleInelasticStressBase::finiteStrainRotation().

_rotation_total

MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_rotation_total

protectedinherited

Rotation up to current step "n" to compute anisotropic elasticity tensor.

Definition at line 37 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress(), and ComputeFiniteStrainElasticStress::initQpStatefulProperties().

_rotation_total_old

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_rotation_total_old

protectedinherited

Rotation up to "n - 1" (previous) step to compute anisotropic elasticity tensor.

Definition at line 39 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress().

_rtol

Real ComputeMultipleCrystalPlasticityStress::_rtol

protected

Stress residual equation relative tolerance.

Definition at line 139 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by solveStress().

_strain_increment

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_strain_increment

protectedinherited

Strain increment material property.

Definition at line 41 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress().

_stress

MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_stress

protectedinherited

Stress material property.

Definition at line 48 of file ComputeGeneralStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeMultipleInelasticCosseratStress::computeAdmissibleState(), ComputeGeneralStressBase::computeQpProperties(), ComputeMultiPlasticityStress::computeQpStress(), ComputeStrainIncrementBasedStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), AbaqusUMATStress::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStress(), ComputeSmearedCrackingStress::computeQpStress(), computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeLinearElasticPFFractureStress::computeStrainSpectral(), ComputeLinearElasticPFFractureStress::computeStrainVolDev(), ComputeLinearElasticPFFractureStress::computeStressSpectral(), ComputeCreepPlasticityStress::computeTangentOperators(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), FiniteStrainCrystalPlasticity::initQpStatefulProperties(), FiniteStrainUObasedCP::initQpStatefulProperties(), FiniteStrainHyperElasticViscoPlastic::initQpStatefulProperties(), ComputeGeneralStressBase::initQpStatefulProperties(), ComputeMultiPlasticityStress::postReturnMap(), FiniteStrainCrystalPlasticity::postSolveQp(), FiniteStrainUObasedCP::postSolveQp(), FiniteStrainHyperElasticViscoPlastic::postSolveQp(), ComputeSmearedCrackingStress::updateCrackingStateAndStress(), ComputeCreepPlasticityStress::updateQpState(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_stress_old

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_stress_old

protectedinherited

Old state of the stress tensor material property.

Definition at line 45 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeMultipleInelasticStressBase::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeCreepPlasticityStress::computeStress(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_substep_dt

Real ComputeMultipleCrystalPlasticityStress::_substep_dt

protected

time step size during substepping

Definition at line 160 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateEigenstrainDeformationGrad(), and updateStress().

_tan_mod_type

enum ComputeMultipleCrystalPlasticityStress::TangentModuliType ComputeMultipleCrystalPlasticityStress::_tan_mod_type

protected

Referenced by calcTangentModuli().

_temporary_deformation_gradient

RankTwoTensor ComputeMultipleCrystalPlasticityStress::_temporary_deformation_gradient

protected

Helper deformation gradient tensor variables used in iterative solve.

Definition at line 219 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by calculateJacobian(), calculateResidual(), and updateStress().

_temporary_deformation_gradient_old

RankTwoTensor ComputeMultipleCrystalPlasticityStress::_temporary_deformation_gradient_old

protected

Definition at line 234 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by updateStress().

_total_lagrangian_strain

MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_total_lagrangian_strain

protected

Lagrangian total strain measure for the entire crystal.

Definition at line 198 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by initQpStatefulProperties(), and postSolveQp().

_updated_rotation

MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_updated_rotation

protected

Tracks the rotation of the crystal during deformation Note: this rotation tensor is not applied to the crystal lattice.

Definition at line 204 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by initQpStatefulProperties(), and postSolveQp().

_updated_rotation_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleCrystalPlasticityStress::_updated_rotation_old

protected

Definition at line 205 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by postSolveQp().

_use_line_search

bool ComputeMultipleCrystalPlasticityStress::_use_line_search

protected

Flag to activate line serach.

Definition at line 163 of file ComputeMultipleCrystalPlasticityStress.h.

Referenced by solveStress().

---

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

• solid_mechanics/include/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.h
• solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C