Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "PowerLawCreepStressUpdate.h"
      11             : 
      12             : registerMooseObject("SolidMechanicsApp", PowerLawCreepStressUpdate);
      13             : registerMooseObject("SolidMechanicsApp", ADPowerLawCreepStressUpdate);
      14             : 
      15             : template <bool is_ad>
      16             : InputParameters
      17        3576 : PowerLawCreepStressUpdateTempl<is_ad>::validParams()
      18             : {
      19        3576 :   InputParameters params = RadialReturnCreepStressUpdateBaseTempl<is_ad>::validParams();
      20        3576 :   params.addClassDescription(
      21             :       "This class uses the stress update material in a radial return isotropic power law creep "
      22             :       "model. This class can be used in conjunction with other creep and plasticity materials "
      23             :       "for more complex simulations.");
      24             : 
      25             :   // Linear strain hardening parameters
      26        7152 :   params.addCoupledVar("temperature", "Coupled temperature");
      27        7152 :   params.addRequiredParam<Real>("coefficient", "Leading coefficient in power-law equation");
      28        7152 :   params.addRequiredParam<Real>("n_exponent", "Exponent on effective stress in power-law equation");
      29        7152 :   params.addParam<Real>("m_exponent", 0.0, "Exponent on time in power-law equation");
      30        7152 :   params.addRequiredParam<Real>("activation_energy", "Activation energy");
      31        7152 :   params.addParam<Real>("gas_constant", 8.3143, "Universal gas constant");
      32        7152 :   params.addParam<Real>("start_time", 0.0, "Start time (if not zero)");
      33        3576 :   return params;
      34           0 : }
      35             : 
      36             : template <bool is_ad>
      37        2682 : PowerLawCreepStressUpdateTempl<is_ad>::PowerLawCreepStressUpdateTempl(
      38             :     const InputParameters & parameters)
      39             :   : RadialReturnCreepStressUpdateBaseTempl<is_ad>(parameters),
      40        8046 :     _temperature(this->isParamValid("temperature")
      41        3126 :                      ? &this->template coupledGenericValue<is_ad>("temperature")
      42             :                      : nullptr),
      43        5364 :     _coefficient(this->template getParam<Real>("coefficient")),
      44        5364 :     _n_exponent(this->template getParam<Real>("n_exponent")),
      45        5364 :     _m_exponent(this->template getParam<Real>("m_exponent")),
      46        5364 :     _activation_energy(this->template getParam<Real>("activation_energy")),
      47        5364 :     _gas_constant(this->template getParam<Real>("gas_constant")),
      48        5364 :     _start_time(this->template getParam<Real>("start_time")),
      49        3870 :     _exponential(1.0)
      50             : {
      51        2682 :   if (_start_time < this->_app.getStartTime() && (std::trunc(_m_exponent) != _m_exponent))
      52           0 :     this->paramError("start_time",
      53             :                      "Start time must be equal to or greater than the Executioner start_time if a "
      54             :                      "non-integer m_exponent is used");
      55        2682 : }
      56             : 
      57             : template <bool is_ad>
      58             : void
      59    46388671 : PowerLawCreepStressUpdateTempl<is_ad>::computeStressInitialize(
      60             :     const GenericReal<is_ad> & effective_trial_stress,
      61             :     const GenericRankFourTensor<is_ad> & elasticity_tensor)
      62             : {
      63    24087204 :   RadialReturnStressUpdateTempl<is_ad>::computeStressInitialize(effective_trial_stress,
      64             :                                                                 elasticity_tensor);
      65             : 
      66    46388671 :   if (_temperature)
      67     2082016 :     _exponential = std::exp(-_activation_energy / (_gas_constant * (*_temperature)[_qp]));
      68             : 
      69    46388671 :   _exp_time = std::pow(_t - _start_time, _m_exponent);
      70    46388671 : }
      71             : 
      72             : template <bool is_ad>
      73             : template <typename ScalarType>
      74             : ScalarType
      75   246119566 : PowerLawCreepStressUpdateTempl<is_ad>::computeResidualInternal(
      76             :     const GenericReal<is_ad> & effective_trial_stress, const ScalarType & scalar)
      77             : {
      78   246119566 :   const ScalarType stress_delta = effective_trial_stress - _three_shear_modulus * scalar;
      79   385644665 :   const ScalarType creep_rate =
      80   246119566 :       _coefficient * std::pow(stress_delta, _n_exponent) * _exponential * _exp_time;
      81   246119566 :   return creep_rate * _dt - scalar;
      82             : }
      83             : 
      84             : template <bool is_ad>
      85             : GenericReal<is_ad>
      86   246542956 : PowerLawCreepStressUpdateTempl<is_ad>::computeDerivative(
      87             :     const GenericReal<is_ad> & effective_trial_stress, const GenericReal<is_ad> & scalar)
      88             : {
      89   246542956 :   const GenericReal<is_ad> stress_delta = effective_trial_stress - _three_shear_modulus * scalar;
      90   525593154 :   const GenericReal<is_ad> creep_rate_derivative =
      91   246542956 :       -_coefficient * _three_shear_modulus * _n_exponent *
      92   246542956 :       std::pow(stress_delta, _n_exponent - 1.0) * _exponential * _exp_time;
      93   386068055 :   return creep_rate_derivative * _dt - 1.0;
      94             : }
      95             : 
      96             : template <bool is_ad>
      97             : Real
      98      365520 : PowerLawCreepStressUpdateTempl<is_ad>::computeStrainEnergyRateDensity(
      99             :     const GenericMaterialProperty<RankTwoTensor, is_ad> & stress,
     100             :     const GenericMaterialProperty<RankTwoTensor, is_ad> & strain_rate)
     101             : {
     102      365520 :   if (_n_exponent <= 1)
     103             :     return 0.0;
     104             : 
     105      365520 :   Real creep_factor = _n_exponent / (_n_exponent + 1);
     106             : 
     107      467376 :   return MetaPhysicL::raw_value(creep_factor * stress[_qp].doubleContraction((strain_rate)[_qp]));
     108             : }
     109             : 
     110             : template <bool is_ad>
     111             : void
     112    46687703 : PowerLawCreepStressUpdateTempl<is_ad>::computeStressFinalize(
     113             :     const GenericRankTwoTensor<is_ad> & plastic_strain_increment)
     114             : {
     115    46687703 :   _creep_strain[_qp] += plastic_strain_increment;
     116    46687703 : }
     117             : 
     118             : template <bool is_ad>
     119             : void
     120    46069785 : PowerLawCreepStressUpdateTempl<is_ad>::resetIncrementalMaterialProperties()
     121             : {
     122    46069785 :   _creep_strain[_qp] = _creep_strain_old[_qp];
     123    46069785 : }
     124             : 
     125             : template <bool is_ad>
     126             : bool
     127    45761560 : PowerLawCreepStressUpdateTempl<is_ad>::substeppingCapabilityEnabled()
     128             : {
     129    45761560 :   return this->_use_substepping != RadialReturnStressUpdateTempl<is_ad>::SubsteppingType::NONE;
     130             : }
     131             : 
     132             : template class PowerLawCreepStressUpdateTempl<false>;
     133             : template class PowerLawCreepStressUpdateTempl<true>;
     134             : template Real PowerLawCreepStressUpdateTempl<false>::computeResidualInternal<Real>(const Real &,
     135             :                                                                                    const Real &);
     136             : template ADReal
     137             : PowerLawCreepStressUpdateTempl<true>::computeResidualInternal<ADReal>(const ADReal &,
     138             :                                                                       const ADReal &);
     139             : template ChainedReal
     140             : PowerLawCreepStressUpdateTempl<false>::computeResidualInternal<ChainedReal>(const Real &,
     141             :                                                                             const ChainedReal &);
     142             : template ChainedADReal
     143             : PowerLawCreepStressUpdateTempl<true>::computeResidualInternal<ChainedADReal>(const ADReal &,
     144             :                                                                              const ChainedADReal &);