ADComputeMultipleInelasticStress.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 "ADComputeFiniteStrainElasticStress.h"
 
#define usingComputeMultipleInelasticStressMembers                                                 \
  usingComputeFiniteStrainElasticStressMembers;                                                    \
  using ADComputeMultipleInelasticStress<compute_stage>::computeQpStressIntermediateConfiguration; \
  using ADComputeMultipleInelasticStress<compute_stage>::finiteStrainRotation;                     \
  using ADComputeMultipleInelasticStress<compute_stage>::updateQpState;                            \
  using ADComputeMultipleInelasticStress<compute_stage>::updateQpStateSingleModel;                 \
  using ADComputeMultipleInelasticStress<compute_stage>::computeAdmissibleState;                   \
  using ADComputeMultipleInelasticStress<compute_stage>::_inelastic_strain;                        \
  using ADComputeMultipleInelasticStress<compute_stage>::_inelastic_strain_old
 
// Forward Declarations
template <ComputeStage>
class ADComputeMultipleInelasticStress;
template <ComputeStage>
class ADStressUpdateBase;
template <typename>
class RankTwoTensorTempl;
typedef RankTwoTensorTempl<Real> RankTwoTensor;
typedef RankTwoTensorTempl<DualReal> DualRankTwoTensor;
template <typename>
class RankFourTensorTempl;
typedef RankFourTensorTempl<Real> RankFourTensor;
typedef RankFourTensorTempl<DualReal> DualRankFourTensor;
 
declareADValidParams(ADComputeMultipleInelasticStress);
 
template <ComputeStage compute_stage>
class ADComputeMultipleInelasticStress : public ADComputeFiniteStrainElasticStress<compute_stage>
{
public:
  static InputParameters validParams();
 
  ADComputeMultipleInelasticStress(const InputParameters & parameters);
 
  virtual void initialSetup() override;
 
protected:
  virtual void initQpStatefulProperties() override;
 
  virtual void computeQpStress() override;
 
  virtual void computeQpStressIntermediateConfiguration();
 
  virtual void finiteStrainRotation();
 
  virtual void updateQpState(ADRankTwoTensor & elastic_strain_increment,
                             ADRankTwoTensor & combined_inelastic_strain_increment);
 
  virtual void updateQpStateSingleModel(unsigned model_number,
                                        ADRankTwoTensor & elastic_strain_increment,
                                        ADRankTwoTensor & combined_inelastic_strain_increment);
 
  virtual void computeAdmissibleState(unsigned model_number,
                                      ADRankTwoTensor & elastic_strain_increment,
                                      ADRankTwoTensor & inelastic_strain_increment);
 
  const unsigned int _max_iterations;
  const Real _relative_tolerance;
  const Real _absolute_tolerance;
  const bool _internal_solve_full_iteration_history;
 
  const bool _perform_finite_strain_rotations;
 
  ADMaterialProperty(RankTwoTensor) & _inelastic_strain;
 
  const MaterialProperty<RankTwoTensor> & _inelastic_strain_old;
 
  const unsigned _num_models;
 
  const std::vector<Real> _inelastic_weights;
 
  const bool _cycle_models;
 
  MaterialProperty<Real> & _matl_timestep_limit;
 
  std::vector<ADStressUpdateBase<compute_stage> *> _models;
 
  bool _is_elasticity_tensor_guaranteed_isotropic;
 
  usingComputeFiniteStrainElasticStressMembers;
};