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;
};