ADViscoplasticityStressUpdate.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 "ViscoplasticityStressUpdateBase.h"
#include "ADSingleVariableReturnMappingSolution.h"

class ADViscoplasticityStressUpdate : public ADViscoplasticityStressUpdateBase,
                                      public ADSingleVariableReturnMappingSolution
{
public:
  static InputParameters validParams();

  ADViscoplasticityStressUpdate(const InputParameters & parameters);

  using ADViscoplasticityStressUpdateBase::updateState;

  virtual void updateState(ADRankTwoTensor & strain_increment,
                           ADRankTwoTensor & inelastic_strain_increment,
                           const ADRankTwoTensor & rotation_increment,
                           ADRankTwoTensor & stress_new,
                           const RankTwoTensor & stress_old,
                           const ADRankFourTensor & elasticity_tensor,
                           const RankTwoTensor & elastic_strain_old,
                           bool compute_full_tangent_operator = false,
                           RankFourTensor & tangent_operator = _identityTensor) override;

  virtual ADReal minimumPermissibleValue(const ADReal & effective_trial_stress) const override;

  virtual ADReal maximumPermissibleValue(const ADReal & effective_trial_stress) const override;

  virtual Real computeReferenceResidual(const ADReal & effective_trial_stress,
                                        const ADReal & scalar_effective_inelastic_strain) override;

protected:
  virtual ADReal initialGuess(const ADReal & effective_trial_stress) override;

  virtual ADReal computeResidual(const ADReal & effective_trial_stress,
                                 const ADReal & scalar) override;

  virtual ADReal computeDerivative(const ADReal & /*effective_trial_stress*/,
                                   const ADReal & /*scalar*/) override
  {
    return _derivative;
  }

  void outputIterationSummary(std::stringstream * iter_output,
                              const unsigned int total_it) override;

  ADReal computeH(const Real n, const ADReal & gauge_stress, const bool derivative = false);

  ADRankTwoTensor computeDGaugeDSigma(const ADReal & gauge_stress,
                                      const ADReal & equiv_stress,
                                      const ADRankTwoTensor & dev_stress,
                                      const ADRankTwoTensor & stress);

  void computeInelasticStrainIncrement(ADReal & gauge_stress,
                                       ADReal & dpsi_dgauge,
                                       ADRankTwoTensor & creep_strain_increment,
                                       const ADReal & equiv_stress,
                                       const ADRankTwoTensor & dev_stress,
                                       const ADRankTwoTensor & stress);

  const enum class ViscoplasticityModel { LPS, GTN } _model;

  const enum class PoreShapeModel { SPHERICAL, CYLINDRICAL } _pore_shape;

  const Real _pore_shape_factor;

  const Real _power;

  const Real _power_factor;

  const ADMaterialProperty<Real> & _coefficient;

  ADMaterialProperty<Real> & _gauge_stress;

  const Real _maximum_gauge_ratio;

  const Real _minimum_equivalent_stress;

  const Real _maximum_equivalent_stress;

  ADReal _hydro_stress;

  const RankTwoTensor _identity_two;

  const RankTwoTensor _dhydro_stress_dsigma;

  ADReal _derivative;
};