RadialReturnStressUpdate.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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);