RadialReturnStressUpdate.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "StressUpdateBase.h"
#include "SingleVariableReturnMappingSolution.h"
#include "ADSingleVariableReturnMappingSolution.h"
 
template <bool is_ad>
class RadialReturnStressUpdateTempl : public StressUpdateBaseTempl<is_ad>,
                                      public SingleVariableReturnMappingSolutionTempl<is_ad>
{
public:
  static InputParameters validParams();
 
  RadialReturnStressUpdateTempl(const InputParameters & parameters);
 
  using Material::_current_elem;
  using Material::_dt;
  using Material::_q_point;
  using Material::_qp;
 
  enum class SubsteppingType
  {
    NONE,
    ERROR_BASED,
    INCREMENT_BASED
  };
 
  virtual void updateState(
      GenericRankTwoTensor<is_ad> & strain_increment,
      GenericRankTwoTensor<is_ad> & inelastic_strain_increment,
      const GenericRankTwoTensor<is_ad> & rotation_increment,
      GenericRankTwoTensor<is_ad> & stress_new,
      const RankTwoTensor & stress_old,
      const GenericRankFourTensor<is_ad> & elasticity_tensor,
      const RankTwoTensor & elastic_strain_old,
      bool compute_full_tangent_operator = false,
      RankFourTensor & tangent_operator = StressUpdateBaseTempl<is_ad>::_identityTensor) override;
 
  virtual void updateStateSubstepInternal(
      GenericRankTwoTensor<is_ad> & /*strain_increment*/,
      GenericRankTwoTensor<is_ad> & /*inelastic_strain_increment*/,
      const GenericRankTwoTensor<is_ad> & /*rotation_increment*/,
      GenericRankTwoTensor<is_ad> & /*stress_new*/,
      const RankTwoTensor & /*stress_old*/,
      const GenericRankFourTensor<is_ad> & /*elasticity_tensor*/,
      const RankTwoTensor & /*elastic_strain_old*/,
      unsigned int total_number_substeps,
      bool compute_full_tangent_operator = false,
      RankFourTensor & tangent_operator = StressUpdateBaseTempl<is_ad>::_identityTensor);
 
  virtual void updateStateSubstep(
      GenericRankTwoTensor<is_ad> & /*strain_increment*/,
      GenericRankTwoTensor<is_ad> & /*inelastic_strain_increment*/,
      const GenericRankTwoTensor<is_ad> & /*rotation_increment*/,
      GenericRankTwoTensor<is_ad> & /*stress_new*/,
      const RankTwoTensor & /*stress_old*/,
      const GenericRankFourTensor<is_ad> & /*elasticity_tensor*/,
      const RankTwoTensor & /*elastic_strain_old*/,
      bool compute_full_tangent_operator = false,
      RankFourTensor & tangent_operator = StressUpdateBaseTempl<is_ad>::_identityTensor) override;
 
  virtual Real
  computeReferenceResidual(const GenericReal<is_ad> & effective_trial_stress,
                           const GenericReal<is_ad> & scalar_effective_inelastic_strain) override;
 
  virtual GenericReal<is_ad>
  minimumPermissibleValue(const GenericReal<is_ad> & /*effective_trial_stress*/) const override
  {
    return 0.0;
  }
 
  virtual GenericReal<is_ad>
  maximumPermissibleValue(const GenericReal<is_ad> & effective_trial_stress) const override;
 
  virtual Real computeTimeStepLimit() override;
 
  bool requiresIsotropicTensor() override { return true; }
 
  bool isIsotropic() override { return true; };
 
  virtual int
  calculateNumberSubsteps(const GenericRankTwoTensor<is_ad> & strain_increment) override;
 
  virtual bool substeppingCapabilityRequested() override
  {
    return _use_substepping != SubsteppingType::NONE;
  }
 
  const GenericReal<is_ad> & effectiveInelasticStrainIncrement() const
  {
    return _effective_inelastic_strain_increment;
  }
 
  void updateEffectiveInelasticStrainIncrement(const GenericReal<is_ad> & eisi)
  {
    _effective_inelastic_strain_increment = eisi;
  }
 
  void updateEffectiveInelasticStrain(const GenericReal<is_ad> & increment)
  {
    _effective_inelastic_strain[_qp] = _effective_inelastic_strain_old[_qp] + increment;
  }
 
  void computeTangentOperator(Real effective_trial_stress,
                              const RankTwoTensor & stress_new,
                              RankFourTensor & tangent_operator);
 
protected:
  virtual void initQpStatefulProperties() override;
 
  void propagateQpStatefulPropertiesRadialReturn();
 
  virtual void computeStressInitialize(const GenericReal<is_ad> & effective_trial_stress,
                                       const GenericRankFourTensor<is_ad> & elasticity_tensor);
 
  virtual Real computeStressDerivative(const Real /*effective_trial_stress*/, const Real /*scalar*/)
  {
    return 0.0;
  }
 
  virtual void
  computeStressFinalize(const GenericRankTwoTensor<is_ad> & /*inelasticStrainIncrement*/)
  {
  }
 
  void outputIterationSummary(std::stringstream * iter_output,
                              const unsigned int total_it) override;
 
  GenericReal<is_ad> _three_shear_modulus;
 
  GenericMaterialProperty<Real, is_ad> & _effective_inelastic_strain;
  const MaterialProperty<Real> & _effective_inelastic_strain_old;
 
  GenericReal<is_ad> _effective_inelastic_strain_increment;
 
  Real _max_inelastic_increment;
 
  const Real _substep_tolerance;
 
  const RankTwoTensor _identity_two;
 
  const RankFourTensor _identity_symmetric_four;
 
  const RankFourTensor _deviatoric_projection_four;
 
  const bool _apply_strain;
 
  SubsteppingType _use_substepping;
 
  const bool _adaptive_substepping;
 
  const unsigned int _maximum_number_substeps;
 
  Real _dt_original;
};
 
typedef RadialReturnStressUpdateTempl<false> RadialReturnStressUpdate;
typedef RadialReturnStressUpdateTempl<true> ADRadialReturnStressUpdate;
 
template <>
void
RadialReturnStressUpdateTempl<false>::computeTangentOperator(Real effective_trial_stress,
                                                             const RankTwoTensor & stress_new,
                                                             RankFourTensor & tangent_operator);