This class uses the stress update material for an anisotropic creep model. More...

#include <HillCreepStressUpdate.h>

Inheritance diagram for HillCreepStressUpdateTempl< is_ad >:

Public Member Functions
	HillCreepStressUpdateTempl (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeStressInitialize (const GenericDenseVector< is_ad > &stress_dev, const GenericDenseVector< is_ad > &stress, const GenericRankFourTensor< is_ad > &elasticity_tensor) override

virtual GenericReal< is_ad >	computeResidual (const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &scalar) override

virtual GenericReal< is_ad >	computeDerivative (const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &scalar) override

virtual Real	computeReferenceResidual (const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &residual, const GenericReal< is_ad > &scalar_effective_inelastic_strain) override

void	computeQsigmaChanged (GenericReal< is_ad > &qsigma_changed, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &delta_gamma, GenericRankTwoTensor< is_ad > &stress_changed)

virtual void	computeStrainFinalize (GenericRankTwoTensor< is_ad > &inelasticStrainIncrement, const GenericRankTwoTensor< is_ad > &stress, const GenericDenseVector< is_ad > &stress_dev, const GenericReal< is_ad > &delta_gamma) override
	Perform any necessary steps to finalize strain increment after return mapping iterations.

virtual void	computeStressFinalize (const GenericRankTwoTensor< is_ad > &inelasticStrainIncrement, const GenericReal< is_ad > &delta_gamma, GenericRankTwoTensor< is_ad > &stress, const GenericDenseVector< is_ad > &stress_dev, const GenericRankTwoTensor< is_ad > &stress_old, const GenericRankFourTensor< is_ad > &elasticity_tensor) override
	Perform any necessary steps to finalize state after return mapping iterations.

virtual GenericReal< is_ad >	initialGuess (const GenericDenseVector< is_ad > &) override

bool	requiresIsotropicTensor () override
	Does the model require the elasticity tensor to be isotropic? Not in principle.

virtual Real	computeIntegrationErrorTimeStep () override
	Compute the limiting value of the time step for this material according to the numerical integration error.

virtual void	initQpStatefulProperties () override

virtual void	propagateQpStatefulProperties () override

Protected Attributes
	usingTransientInterfaceMembers

const bool	_has_temp
	Flag to determine if temperature is supplied by the user.

const VariableValue &	_temperature
	Temperature variable value.

const Real	_coefficient
	Leading coefficient.

const Real	_n_exponent
	Exponent on the effective stress.

const Real	_m_exponent
	Exponent on time.

const Real	_activation_energy
	Activation energy for exp term.

const Real	_gas_constant
	Gas constant for exp term.

const Real	_start_time
	Simulation start time.

Real	_exponential
	Exponential calculated from activation, gas constant, and temperature.

Real	_exp_time
	Exponential calculated from current time.

const MaterialProperty< std::vector< Real > > &	_hill_constants
	Hill constant material.

const MaterialProperty< DenseMatrix< Real > > *	_hill_tensor
	Hill tensor, when global axes do not (somehow) align with those of the material Example: Large rotation due to rigid body and/or large deformation kinematics.

GenericReal< is_ad >	_two_shear_modulus
	2 * shear modulus

GenericDenseMatrix< is_ad >	_C
	Matrix form of the elasticity tensor.

const std::string	_elasticity_tensor_name
	Name of the elasticity tensor material property.

const GenericMaterialProperty< RankFourTensor, is_ad > &	_elasticity_tensor
	Anisotropic elasticity tensor material property.

bool	_anisotropic_elasticity
	Materials's elasticity tensor is anisotropic or not.

const Function *const	_prefactor_function
	Prefactor for scaling creep.

const Elem *const &	_current_elem

const MooseArray< Point > &	_q_point

unsigned int	_qp

GenericMaterialProperty< RankTwoTensor, is_ad > &	_creep_strain
	Creep strain tensor material property.

const MaterialProperty< RankTwoTensor > &	_creep_strain_old

Detailed Description

template<bool is_ad>
class HillCreepStressUpdateTempl< is_ad >

This class uses the stress update material for an anisotropic creep model.

This class is one of the basic radial return constitutive models; more complex constitutive models combine creep and plasticity.

This class inherits from AnisotropicReturnCreepStressUpdateBase and must be used in conjunction with ComputeMultipleInelasticStress. This class calculates creep based on stress, temperature, and time effects. This class also computes the creep strain as a stateful material property.

This class extends the usage of PowerLawCreep to Hill (i.e. anisotropic) cases. For more information, consult, e.g. Stewart et al, "An anisotropic tertiary creep damage constitutive model for anistropic materials", International Journal of Pressure Vessels and Piping 88 (2011) 356–364.

Definition at line 30 of file HillCreepStressUpdate.h.

Constructor & Destructor Documentation

◆ HillCreepStressUpdateTempl()

template<bool is_ad>

HillCreepStressUpdateTempl< is_ad >::HillCreepStressUpdateTempl ( const InputParameters & parameters )

Definition at line 43 of file HillCreepStressUpdate.C.

  : AnisotropicReturnCreepStressUpdateBaseTempl<is_ad>(parameters),
    _has_temp(this->isParamValid("temperature")),
    _temperature(this->_has_temp ? this->coupledValue("temperature") : this->_zero),
    _coefficient(this->template getParam<Real>("coefficient")),
    _n_exponent(this->template getParam<Real>("n_exponent")),
    _m_exponent(this->template getParam<Real>("m_exponent")),
    _activation_energy(this->template getParam<Real>("activation_energy")),
    _gas_constant(this->template getParam<Real>("gas_constant")),
    _start_time(this->template getParam<Real>("start_time")),
    _exponential(1.0),
    _exp_time(1.0),
    _hill_constants(this->template getMaterialPropertyByName<std::vector<Real>>(this->_base_name +
                                                                                "hill_constants")),
    _hill_tensor(this->_use_transformation
                     ? &this->template getMaterialPropertyByName<DenseMatrix<Real>>(
                           this->_base_name + "hill_tensor")
                     : nullptr),
    _C(6, 6),
    _elasticity_tensor_name(this->_base_name + "elasticity_tensor"),
    _elasticity_tensor(
        this->template getGenericMaterialProperty<RankFourTensor, is_ad>(_elasticity_tensor_name)),
    _anisotropic_elasticity(this->template getParam<bool>("anisotropic_elasticity")),
    _prefactor_function(
        this->isParamValid("creep_prefactor") ? &this->getFunction("creep_prefactor") : nullptr)
{
  if (_start_time < this->_app.getStartTime() && (std::trunc(_m_exponent) != _m_exponent))
    this->paramError("start_time",
                     "Start time must be equal to or greater than the Executioner start_time if a "
                     "non-integer m_exponent is used");
}

Member Function Documentation

◆ computeDerivative()

template<bool is_ad>

GenericReal< is_ad > HillCreepStressUpdateTempl< is_ad >::computeDerivative	(	const GenericDenseVector< is_ad > &	effective_trial_stress,
		const GenericDenseVector< is_ad > &	stress_new,
		const GenericReal< is_ad > &	scalar
	)

overrideprotectedvirtual

Definition at line 137 of file HillCreepStressUpdate.C.

{
  using std::pow;
 
  GenericReal<is_ad> qsigma_changed;
  GenericRankTwoTensor<is_ad> stress_changed;
 
  // Get the qsigma_changed and stress_changed
  // delta_gamma (scalar plastic strain) will change the stress (and qsigma as well)
  computeQsigmaChanged(qsigma_changed, stress_new, delta_gamma, stress_changed);
 
  ElasticityTensorTools::toMooseVoigtNotation<is_ad>(_C, _elasticity_tensor[_qp]);
  const unsigned int dimension = _C.n();
  GenericDenseMatrix<is_ad> d_stress_d_inelasticStrainIncrement(dimension, dimension);
 
  for (unsigned int index_i = 0; index_i < dimension; index_i++)
    for (unsigned int index_j = 0; index_j < dimension; index_j++)
    {
      if (index_j < 3)
        d_stress_d_inelasticStrainIncrement(index_i, index_j) =
            -1.0 * MetaPhysicL::raw_value(_C(index_i, index_j));
      else
        d_stress_d_inelasticStrainIncrement(index_i, index_j) =
            -2.0 * MetaPhysicL::raw_value(_C(index_i, index_j));
    }
 
  // Hill constants, some constraints apply
  const Real & F = _hill_constants[_qp][0];
  const Real & G = _hill_constants[_qp][1];
  const Real & H = _hill_constants[_qp][2];
  const Real & L = _hill_constants[_qp][3];
  const Real & M = _hill_constants[_qp][4];
  const Real & N = _hill_constants[_qp][5];
 
  GenericDenseVector<is_ad> d_qsigma_d_inelasticStrainIncrement(6);
  for (unsigned int index_k = 0; index_k < 6; index_k++)
  {
    d_qsigma_d_inelasticStrainIncrement(index_k) =
        F * (stress_changed(1, 1) - stress_changed(2, 2)) *
            (d_stress_d_inelasticStrainIncrement(1, index_k) -
             d_stress_d_inelasticStrainIncrement(2, index_k)) +
        G * (stress_changed(2, 2) - stress_changed(0, 0)) *
            (d_stress_d_inelasticStrainIncrement(2, index_k) -
             d_stress_d_inelasticStrainIncrement(0, index_k)) +
        H * (stress_changed(0, 0) - stress_changed(1, 1)) *
            (d_stress_d_inelasticStrainIncrement(0, index_k) -
             d_stress_d_inelasticStrainIncrement(1, index_k)) +
        2.0 * L * stress_changed(1, 2) * d_stress_d_inelasticStrainIncrement(4, index_k) +
        2.0 * M * stress_changed(2, 0) * d_stress_d_inelasticStrainIncrement(5, index_k) +
        2.0 * N * stress_changed(0, 1) * d_stress_d_inelasticStrainIncrement(3, index_k);
    d_qsigma_d_inelasticStrainIncrement(index_k) /= qsigma_changed;
  }
 
  GenericDenseVector<is_ad> d_qsigma_d_sigma(6);
 
  d_qsigma_d_sigma(0) = (H * (stress_changed(0, 0) - stress_changed(1, 1)) -
                         G * (stress_changed(2, 2) - stress_changed(0, 0))) /
                        qsigma_changed;
  d_qsigma_d_sigma(1) = (F * (stress_changed(1, 1) - stress_changed(2, 2)) -
                         H * (stress_changed(0, 0) - stress_changed(1, 1))) /
                        qsigma_changed;
  d_qsigma_d_sigma(2) = (G * (stress_changed(2, 2) - stress_changed(0, 0)) -
                         F * (stress_changed(1, 1) - stress_changed(2, 2))) /
                        qsigma_changed;
  d_qsigma_d_sigma(3) = 2.0 * N * stress_changed(0, 1) / qsigma_changed;
  d_qsigma_d_sigma(4) = 2.0 * L * stress_changed(1, 2) / qsigma_changed;
  d_qsigma_d_sigma(5) = 2.0 * M * stress_changed(0, 2) / qsigma_changed;
 
  GenericReal<is_ad> d_qsigma_d_deltaGamma =
      d_qsigma_d_inelasticStrainIncrement.dot(d_qsigma_d_sigma);
 
  GenericReal<is_ad> creep_rate_derivative = _coefficient * d_qsigma_d_deltaGamma * _n_exponent *
                                             pow(qsigma_changed, _n_exponent - 1.0) * _exponential *
                                             _exp_time;
 
  if (_prefactor_function)
    creep_rate_derivative *= _prefactor_function->value(_t, _q_point[_qp]);
 
  return (creep_rate_derivative * _dt - 1.0);
}

◆ computeIntegrationErrorTimeStep()

template<bool is_ad>

virtual Real HillCreepStressUpdateTempl< is_ad >::computeIntegrationErrorTimeStep ( )

inlineoverrideprotectedvirtual

Compute the limiting value of the time step for this material according to the numerical integration error.

Returns: Limiting time step

Definition at line 109 of file HillCreepStressUpdate.h.

  {
    return this->_max_integration_error_time_step;
  }

◆ computeQsigmaChanged()

template<bool is_ad>

void HillCreepStressUpdateTempl< is_ad >::computeQsigmaChanged	(	GenericReal< is_ad > &	qsigma_changed,
		const GenericDenseVector< is_ad > &	stress_new,
		const GenericReal< is_ad > &	delta_gamma,
		GenericRankTwoTensor< is_ad > &	stress_changed
	)

protected

Definition at line 353 of file HillCreepStressUpdate.C.

{
  using std::sqrt;
 
  GenericReal<is_ad> qsigma_square;
 
  // Hill constants, some constraints apply
  const Real & F = _hill_constants[_qp][0];
  const Real & G = _hill_constants[_qp][1];
  const Real & H = _hill_constants[_qp][2];
  const Real & L = _hill_constants[_qp][3];
  const Real & M = _hill_constants[_qp][4];
  const Real & N = _hill_constants[_qp][5];
 
  if (!this->_use_transformation)
  {
    qsigma_square = F * (stress_new(1) - stress_new(2)) * (stress_new(1) - stress_new(2));
    qsigma_square += G * (stress_new(2) - stress_new(0)) * (stress_new(2) - stress_new(0));
    qsigma_square += H * (stress_new(0) - stress_new(1)) * (stress_new(0) - stress_new(1));
    qsigma_square += 2 * L * stress_new(4) * stress_new(4);
    qsigma_square += 2 * M * stress_new(5) * stress_new(5);
    qsigma_square += 2 * N * stress_new(3) * stress_new(3);
  }
  else
  {
    GenericDenseVector<is_ad> Ms(6);
    (*_hill_tensor)[_qp].vector_mult(Ms, stress_new);
    qsigma_square = Ms.dot(stress_new);
  }
 
  GenericReal<is_ad> qsigma = sqrt(qsigma_square);
 
  if (!_anisotropic_elasticity)
    qsigma_changed = qsigma - 1.5 * _two_shear_modulus * delta_gamma;
  else
  {
    GenericRankTwoTensor<is_ad> stress;
    stress(0, 0) = stress_new(0);
    stress(1, 1) = stress_new(1);
    stress(2, 2) = stress_new(2);
    stress(0, 1) = stress(1, 0) = stress_new(3);
    stress(1, 2) = stress(2, 1) = stress_new(4);
    stress(0, 2) = stress(2, 0) = stress_new(5);
 
    GenericDenseVector<is_ad> b(6);
    b(0) = H * (stress(0, 0) - stress(1, 1)) - G * (stress(2, 2) - stress(0, 0));
    b(1) = F * (stress(1, 1) - stress(2, 2)) - H * (stress(0, 0) - stress(1, 1));
    b(2) = G * (stress(2, 2) - stress(0, 0)) - F * (stress(1, 1) - stress(2, 2));
    b(3) = 2.0 * N * stress(0, 1);
    b(4) = 2.0 * L * stress(1, 2);
    b(5) = 2.0 * M * stress(0, 2);
 
    GenericRankTwoTensor<is_ad> inelasticStrainIncrement;
    inelasticStrainIncrement(0, 0) = delta_gamma * b(0) / qsigma;
    inelasticStrainIncrement(1, 1) = delta_gamma * b(1) / qsigma;
    inelasticStrainIncrement(2, 2) = delta_gamma * b(2) / qsigma;
    inelasticStrainIncrement(0, 1) = inelasticStrainIncrement(1, 0) = delta_gamma * b(3) / qsigma;
    inelasticStrainIncrement(1, 2) = inelasticStrainIncrement(2, 1) = delta_gamma * b(4) / qsigma;
    inelasticStrainIncrement(0, 2) = inelasticStrainIncrement(2, 0) = delta_gamma * b(5) / qsigma;
 
    stress_changed = stress - _elasticity_tensor[_qp] * inelasticStrainIncrement;
 
    GenericReal<is_ad> qsigma_square_changed;
    qsigma_square_changed = F * (stress_changed(1, 1) - stress_changed(2, 2)) *
                            (stress_changed(1, 1) - stress_changed(2, 2));
    qsigma_square_changed += G * (stress_changed(2, 2) - stress_changed(0, 0)) *
                             (stress_changed(2, 2) - stress_changed(0, 0));
    qsigma_square_changed += H * (stress_changed(0, 0) - stress_changed(1, 1)) *
                             (stress_changed(0, 0) - stress_changed(1, 1));
    qsigma_square_changed += 2 * L * stress_changed(1, 2) * stress_changed(1, 2);
    qsigma_square_changed += 2 * M * stress_changed(0, 2) * stress_changed(0, 2);
    qsigma_square_changed += 2 * N * stress_changed(0, 1) * stress_changed(0, 1);
    qsigma_changed = sqrt(qsigma_square_changed);
  }
}

◆ computeReferenceResidual()

template<bool is_ad>

Real HillCreepStressUpdateTempl< is_ad >::computeReferenceResidual	(	const GenericDenseVector< is_ad > &	effective_trial_stress,
		const GenericDenseVector< is_ad > &	stress_new,
		const GenericReal< is_ad > &	residual,
		const GenericReal< is_ad > &	scalar_effective_inelastic_strain
	)

overrideprotectedvirtual

Definition at line 126 of file HillCreepStressUpdate.C.

{
  return 1.0;
}

◆ computeResidual()

template<bool is_ad>

GenericReal< is_ad > HillCreepStressUpdateTempl< is_ad >::computeResidual	(	const GenericDenseVector< is_ad > &	effective_trial_stress,
		const GenericDenseVector< is_ad > &	stress_new,
		const GenericReal< is_ad > &	scalar
	)

overrideprotectedvirtual

Definition at line 99 of file HillCreepStressUpdate.C.

{
  using std::pow;
 
  GenericReal<is_ad> qsigma_changed;
  GenericRankTwoTensor<is_ad> stress_changed;
 
  // Get the qsigma_changed and stress_changed (not used)
  // delta_gamma (scalar plastic strain) will change the stress (and qsigma as well)
  computeQsigmaChanged(qsigma_changed, stress_new, delta_gamma, stress_changed);
 
  GenericReal<is_ad> creep_rate =
      _coefficient * pow(qsigma_changed, _n_exponent) * _exponential * _exp_time;
 
  if (_prefactor_function)
    creep_rate *= _prefactor_function->value(_t, _q_point[_qp]);
 
  this->_inelastic_strain_rate[_qp] = MetaPhysicL::raw_value(creep_rate);
  // Return iteration difference between creep strain and inelastic strain multiplier
  return creep_rate * _dt - delta_gamma;
}

◆ computeStrainFinalize()

template<bool is_ad>

void HillCreepStressUpdateTempl< is_ad >::computeStrainFinalize	(	GenericRankTwoTensor< is_ad > &	inelasticStrainIncrement,
		const GenericRankTwoTensor< is_ad > &	stress,
		const GenericDenseVector< is_ad > &	stress_dev,
		const GenericReal< is_ad > &	delta_gamma
	)

overrideprotectedvirtual

Perform any necessary steps to finalize strain increment after return mapping iterations.

Parameters

inelasticStrainIncrement	Inelastic strain increment
stress	Cauchy stresss tensor
stress_dev	Deviatoric partt of the Cauchy stresss tensor
delta_gamma	Generalized radial return's plastic multiplier

Reimplemented from AnisotropicReturnCreepStressUpdateBaseTempl< is_ad >.

Definition at line 223 of file HillCreepStressUpdate.C.

{
  using std::sqrt;
 
  GenericReal<is_ad> qsigma_square;
  if (!this->_use_transformation)
  {
    // Hill constants, some constraints apply
    const Real & F = _hill_constants[_qp][0];
    const Real & G = _hill_constants[_qp][1];
    const Real & H = _hill_constants[_qp][2];
    const Real & L = _hill_constants[_qp][3];
    const Real & M = _hill_constants[_qp][4];
    const Real & N = _hill_constants[_qp][5];
 
    // Equivalent deviatoric stress function.
    qsigma_square = F * (stress(1, 1) - stress(2, 2)) * (stress(1, 1) - stress(2, 2));
    qsigma_square += G * (stress(2, 2) - stress(0, 0)) * (stress(2, 2) - stress(0, 0));
    qsigma_square += H * (stress(0, 0) - stress(1, 1)) * (stress(0, 0) - stress(1, 1));
    qsigma_square += 2 * L * stress(1, 2) * stress(1, 2);
    qsigma_square += 2 * M * stress(0, 2) * stress(0, 2);
    qsigma_square += 2 * N * stress(0, 1) * stress(0, 1);
  }
  else
  {
    GenericDenseVector<is_ad> Ms(6);
    (*_hill_tensor)[_qp].vector_mult(Ms, stress_dev);
    qsigma_square = Ms.dot(stress_dev);
  }
 
  if (qsigma_square == 0)
  {
    inelasticStrainIncrement.zero();
 
    AnisotropicReturnCreepStressUpdateBaseTempl<is_ad>::computeStrainFinalize(
        inelasticStrainIncrement, stress, stress_dev, delta_gamma);
 
    this->_effective_inelastic_strain[_qp] = this->_effective_inelastic_strain_old[_qp];
 
    return;
  }
 
  // Use Hill-type flow rule to compute the time step inelastic increment.
  GenericReal<is_ad> prefactor = delta_gamma / sqrt(qsigma_square);
 
  if (!this->_use_transformation)
  {
    // Hill constants, some constraints apply
    const Real & F = _hill_constants[_qp][0];
    const Real & G = _hill_constants[_qp][1];
    const Real & H = _hill_constants[_qp][2];
    const Real & L = _hill_constants[_qp][3];
    const Real & M = _hill_constants[_qp][4];
    const Real & N = _hill_constants[_qp][5];
 
    inelasticStrainIncrement(0, 0) =
        prefactor * (H * (stress(0, 0) - stress(1, 1)) - G * (stress(2, 2) - stress(0, 0)));
    inelasticStrainIncrement(1, 1) =
        prefactor * (F * (stress(1, 1) - stress(2, 2)) - H * (stress(0, 0) - stress(1, 1)));
    inelasticStrainIncrement(2, 2) =
        prefactor * (G * (stress(2, 2) - stress(0, 0)) - F * (stress(1, 1) - stress(2, 2)));
 
    inelasticStrainIncrement(0, 1) = inelasticStrainIncrement(1, 0) =
        prefactor * 2.0 * N * stress(0, 1);
    inelasticStrainIncrement(0, 2) = inelasticStrainIncrement(2, 0) =
        prefactor * 2.0 * M * stress(0, 2);
    inelasticStrainIncrement(1, 2) = inelasticStrainIncrement(2, 1) =
        prefactor * 2.0 * L * stress(1, 2);
  }
  else
  {
    GenericDenseVector<is_ad> inelastic_strain_increment(6);
    GenericDenseVector<is_ad> Ms(6);
    (*_hill_tensor)[_qp].vector_mult(Ms, stress_dev);
 
    for (unsigned int i = 0; i < 6; i++)
      inelastic_strain_increment(i) = Ms(i) * prefactor;
 
    inelasticStrainIncrement(0, 0) = inelastic_strain_increment(0);
    inelasticStrainIncrement(1, 1) = inelastic_strain_increment(1);
    inelasticStrainIncrement(2, 2) = inelastic_strain_increment(2);
 
    inelasticStrainIncrement(0, 1) = inelasticStrainIncrement(1, 0) = inelastic_strain_increment(3);
    inelasticStrainIncrement(1, 2) = inelasticStrainIncrement(2, 1) = inelastic_strain_increment(4);
    inelasticStrainIncrement(0, 2) = inelasticStrainIncrement(2, 0) = inelastic_strain_increment(5);
  }
 
  AnisotropicReturnCreepStressUpdateBaseTempl<is_ad>::computeStrainFinalize(
      inelasticStrainIncrement, stress, stress_dev, delta_gamma);
 
  this->_effective_inelastic_strain[_qp] = this->_effective_inelastic_strain_old[_qp] + delta_gamma;
}

◆ computeStressFinalize()

template<bool is_ad>

void HillCreepStressUpdateTempl< is_ad >::computeStressFinalize	(	const GenericRankTwoTensor< is_ad > &	inelasticStrainIncrement,
		const GenericReal< is_ad > &	delta_gamma,
		GenericRankTwoTensor< is_ad > &	stress,
		const GenericDenseVector< is_ad > &	stress_dev,
		const GenericRankTwoTensor< is_ad > &	stress_old,
		const GenericRankFourTensor< is_ad > &	elasticity_tensor
	)

overrideprotectedvirtual

Perform any necessary steps to finalize state after return mapping iterations.

Parameters

inelasticStrainIncrement	Inelastic strain increment
delta_gamma	Generalized radial return's plastic multiplier
stress	Cauchy stresss tensor
stress_dev	Deviatoric partt of the Cauchy stresss tensor

Definition at line 322 of file HillCreepStressUpdate.C.

{
  using std::abs;
 
  // Class only valid for isotropic elasticity (for now)
  stress_new -= elasticity_tensor * creepStrainIncrement;
 
  // Compute the maximum time step allowed due to creep strain numerical integration error
  Real stress_dif = MetaPhysicL::raw_value(stress_new - stress_old).L2norm();
 
  // Get a representative value of the elasticity tensor
  Real elasticity_value =
      1.0 / 3.0 *
      MetaPhysicL::raw_value((elasticity_tensor(0, 0, 0, 0) + elasticity_tensor(1, 1, 1, 1) +
                              elasticity_tensor(2, 2, 2, 2)));
 
  if (abs(stress_dif) > TOLERANCE * TOLERANCE)
    this->_max_integration_error_time_step =
        _dt / (stress_dif / elasticity_value / this->_max_integration_error);
  else
    this->_max_integration_error_time_step = std::numeric_limits<Real>::max();
}

◆ computeStressInitialize()

template<bool is_ad>

void HillCreepStressUpdateTempl< is_ad >::computeStressInitialize	(	const GenericDenseVector< is_ad > &	stress_dev,
		const GenericDenseVector< is_ad > &	stress,
		const GenericRankFourTensor< is_ad > &	elasticity_tensor
	)

overrideprotectedvirtual

Definition at line 77 of file HillCreepStressUpdate.C.

{
  if (_has_temp)
    _exponential = std::exp(-_activation_energy / (_gas_constant * _temperature[_qp]));
 
  _two_shear_modulus = 2.0 * ElasticityTensorTools::getIsotropicShearModulus(elasticity_tensor);
 
  _exp_time = std::pow(_t - _start_time, _m_exponent);
}

◆ initialGuess()

template<bool is_ad>

GenericReal< is_ad > HillCreepStressUpdateTempl< is_ad >::initialGuess ( const GenericDenseVector< is_ad > & )

overrideprotectedvirtual

Definition at line 92 of file HillCreepStressUpdate.C.

{
  return 0.0;
}

◆ initQpStatefulProperties()

template<bool is_ad>

void AnisotropicReturnCreepStressUpdateBaseTempl< is_ad >::initQpStatefulProperties ( )

overrideprotectedvirtualinherited

Definition at line 37 of file AnisotropicReturnCreepStressUpdateBase.C.

{
  _creep_strain[this->_qp].zero();
 
  GeneralizedRadialReturnStressUpdateTempl<is_ad>::initQpStatefulProperties();
}

◆ propagateQpStatefulProperties()

template<bool is_ad>

void AnisotropicReturnCreepStressUpdateBaseTempl< is_ad >::propagateQpStatefulProperties ( )

overrideprotectedvirtualinherited

Definition at line 46 of file AnisotropicReturnCreepStressUpdateBase.C.

{
  _creep_strain[this->_qp] = _creep_strain_old[this->_qp];
 
  this->propagateQpStatefulPropertiesRadialReturn();
}

◆ requiresIsotropicTensor()

template<bool is_ad>

bool HillCreepStressUpdateTempl< is_ad >::requiresIsotropicTensor ( )

inlineoverrideprotected

Does the model require the elasticity tensor to be isotropic? Not in principle.

TODO: Take care of rotation of anisotropy parameters

Definition at line 102 of file HillCreepStressUpdate.h.

102{ return false; }

◆ validParams()

template<bool is_ad>

InputParameters HillCreepStressUpdateTempl< is_ad >::validParams ( )

static

Definition at line 19 of file HillCreepStressUpdate.C.

{
  InputParameters params = AnisotropicReturnCreepStressUpdateBaseTempl<is_ad>::validParams();
  params.addClassDescription(
      "This class uses the stress update material in a generalized radial return anisotropic power "
      "law creep "
      "model.  This class can be used in conjunction with other creep and plasticity materials for "
      "more complex simulations.");
 
  // Linear strain hardening parameters
  params.addCoupledVar("temperature", "Coupled temperature");
  params.addRequiredParam<Real>("coefficient", "Leading coefficient in power-law equation");
  params.addRequiredParam<Real>("n_exponent", "Exponent on effective stress in power-law equation");
  params.addParam<Real>("m_exponent", 0.0, "Exponent on time in power-law equation");
  params.addRequiredParam<Real>("activation_energy", "Activation energy");
  params.addParam<Real>("gas_constant", 8.3143, "Universal gas constant");
  params.addParam<Real>("start_time", 0.0, "Start time (if not zero)");
  params.addParam<bool>("anisotropic_elasticity", false, "Enable using anisotropic elasticity");
  params.addParam<FunctionName>(
      "creep_prefactor", "Optional function to use as a scalar prefactor on the creep strain.");
  return params;
}

Member Data Documentation

◆ _activation_energy

template<bool is_ad>

const Real HillCreepStressUpdateTempl< is_ad >::_activation_energy

protected

Activation energy for exp term.

Definition at line 130 of file HillCreepStressUpdate.h.

◆ _anisotropic_elasticity

template<bool is_ad>

bool HillCreepStressUpdateTempl< is_ad >::_anisotropic_elasticity

protected

Materials's elasticity tensor is anisotropic or not.

Definition at line 164 of file HillCreepStressUpdate.h.

◆ _C

template<bool is_ad>

GenericDenseMatrix<is_ad> HillCreepStressUpdateTempl< is_ad >::_C

protected

Matrix form of the elasticity tensor.

Definition at line 155 of file HillCreepStressUpdate.h.

◆ _coefficient

template<bool is_ad>

const Real HillCreepStressUpdateTempl< is_ad >::_coefficient

protected

Leading coefficient.

Definition at line 121 of file HillCreepStressUpdate.h.

◆ _creep_strain

template<bool is_ad>

GenericMaterialProperty<RankTwoTensor, is_ad>& AnisotropicReturnCreepStressUpdateBaseTempl< is_ad >::_creep_strain

protectedinherited

Creep strain tensor material property.

Definition at line 51 of file AnisotropicReturnCreepStressUpdateBase.h.

◆ _creep_strain_old

template<bool is_ad>

const MaterialProperty<RankTwoTensor>& AnisotropicReturnCreepStressUpdateBaseTempl< is_ad >::_creep_strain_old

protectedinherited

Definition at line 52 of file AnisotropicReturnCreepStressUpdateBase.h.

◆ _current_elem

template<bool is_ad>

const Elem *const & Material::_current_elem

protected

◆ _elasticity_tensor

template<bool is_ad>

const GenericMaterialProperty<RankFourTensor, is_ad>& HillCreepStressUpdateTempl< is_ad >::_elasticity_tensor

protected

Anisotropic elasticity tensor material property.

Definition at line 161 of file HillCreepStressUpdate.h.

◆ _elasticity_tensor_name

template<bool is_ad>

const std::string HillCreepStressUpdateTempl< is_ad >::_elasticity_tensor_name

protected

Name of the elasticity tensor material property.

Definition at line 158 of file HillCreepStressUpdate.h.

◆ _exp_time

template<bool is_ad>

Real HillCreepStressUpdateTempl< is_ad >::_exp_time

protected

Exponential calculated from current time.

Definition at line 142 of file HillCreepStressUpdate.h.

◆ _exponential

template<bool is_ad>

Real HillCreepStressUpdateTempl< is_ad >::_exponential

protected

Exponential calculated from activation, gas constant, and temperature.

Definition at line 139 of file HillCreepStressUpdate.h.

◆ _gas_constant

template<bool is_ad>

const Real HillCreepStressUpdateTempl< is_ad >::_gas_constant

protected

Gas constant for exp term.

Definition at line 133 of file HillCreepStressUpdate.h.

◆ _has_temp

template<bool is_ad>

const bool HillCreepStressUpdateTempl< is_ad >::_has_temp

protected

Flag to determine if temperature is supplied by the user.

Definition at line 115 of file HillCreepStressUpdate.h.

◆ _hill_constants

template<bool is_ad>

const MaterialProperty<std::vector<Real> >& HillCreepStressUpdateTempl< is_ad >::_hill_constants

protected

Hill constant material.

Definition at line 145 of file HillCreepStressUpdate.h.

◆ _hill_tensor

template<bool is_ad>

const MaterialProperty<DenseMatrix<Real> >* HillCreepStressUpdateTempl< is_ad >::_hill_tensor

protected

Hill tensor, when global axes do not (somehow) align with those of the material Example: Large rotation due to rigid body and/or large deformation kinematics.

Definition at line 149 of file HillCreepStressUpdate.h.

◆ _m_exponent

template<bool is_ad>

const Real HillCreepStressUpdateTempl< is_ad >::_m_exponent

protected

Exponent on time.

Definition at line 127 of file HillCreepStressUpdate.h.

Referenced by HillCreepStressUpdateTempl< is_ad >::HillCreepStressUpdateTempl().

◆ _n_exponent

template<bool is_ad>

const Real HillCreepStressUpdateTempl< is_ad >::_n_exponent

protected

Exponent on the effective stress.

Definition at line 124 of file HillCreepStressUpdate.h.

◆ _prefactor_function

template<bool is_ad>

const Function* const HillCreepStressUpdateTempl< is_ad >::_prefactor_function

protected

Prefactor for scaling creep.

Definition at line 167 of file HillCreepStressUpdate.h.

◆ _q_point

template<bool is_ad>

const MooseArray< Point > & Material::_q_point

protected

◆ _qp

template<bool is_ad>

unsigned int Material::_qp

protected

◆ _start_time

template<bool is_ad>

const Real HillCreepStressUpdateTempl< is_ad >::_start_time

protected

Simulation start time.

Definition at line 136 of file HillCreepStressUpdate.h.

◆ _temperature

template<bool is_ad>

const VariableValue& HillCreepStressUpdateTempl< is_ad >::_temperature

protected

Temperature variable value.

Definition at line 118 of file HillCreepStressUpdate.h.

◆ _two_shear_modulus

template<bool is_ad>

GenericReal<is_ad> HillCreepStressUpdateTempl< is_ad >::_two_shear_modulus

protected

2 * shear modulus

Definition at line 152 of file HillCreepStressUpdate.h.

◆ usingTransientInterfaceMembers

template<bool is_ad>

HillCreepStressUpdateTempl< is_ad >::usingTransientInterfaceMembers

protected

Definition at line 38 of file HillCreepStressUpdate.h.

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

solid_mechanics/include/materials/HillCreepStressUpdate.h
solid_mechanics/src/materials/HillCreepStressUpdate.C

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ HillCreepStressUpdateTempl()

Member Function Documentation

◆ computeDerivative()

◆ computeIntegrationErrorTimeStep()

◆ computeQsigmaChanged()

◆ computeReferenceResidual()

◆ computeResidual()

◆ computeStrainFinalize()

◆ computeStressFinalize()

◆ computeStressInitialize()

◆ initialGuess()

◆ initQpStatefulProperties()

◆ propagateQpStatefulProperties()

◆ requiresIsotropicTensor()

◆ validParams()

Member Data Documentation

◆ _activation_energy

◆ _anisotropic_elasticity

◆ _C

◆ _coefficient

◆ _creep_strain

◆ _creep_strain_old

◆ _current_elem

◆ _elasticity_tensor

◆ _elasticity_tensor_name

◆ _exp_time

◆ _exponential

◆ _gas_constant

◆ _has_temp

◆ _hill_constants

◆ _hill_tensor

◆ _m_exponent

◆ _n_exponent

◆ _prefactor_function

◆ _q_point

◆ _qp

◆ _start_time

◆ _temperature

◆ _two_shear_modulus

◆ usingTransientInterfaceMembers