StressUpdateBase.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 "Conversion.h"
#include "InputParameters.h"
#include "Material.h"
 
enum class TangentCalculationMethod
{
  ELASTIC,
  FULL,
  PARTIAL
};
 
template <bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>
class StressUpdateBaseTempl : public Material
{
public:
  static InputParameters validParams();
 
  StressUpdateBaseTempl(const InputParameters & parameters);
 
  using Material::_current_elem;
  using Material::_dt;
  using Material::_q_point;
  using Material::_qp;
 
  using GR2 = GenericRankTwoTensor<is_ad>;
  using GSR2 = Moose::GenericType<R2, is_ad>;
  using GR4 = GenericRankFourTensor<is_ad>;
  using GSR4 = Moose::GenericType<R4, is_ad>;
 
  virtual void
  updateState(GR2 & strain_increment,
              GR2 & inelastic_strain_increment,
              const GR2 & rotation_increment,
              GR2 & stress_new,
              const RankTwoTensor & stress_old,
              const GR4 & elasticity_tensor,
              const RankTwoTensor & elastic_strain_old,
              bool compute_full_tangent_operator = false,
              RankFourTensor & tangent_operator = StressUpdateBaseTempl<is_ad>::_identityTensor);
 
  virtual void updateStateSubstep(
      GR2 & /*strain_increment*/,
      GR2 & /*inelastic_strain_increment*/,
      const GR2 & /*rotation_increment*/,
      GR2 & /*stress_new*/,
      const RankTwoTensor & /*stress_old*/,
      const GR4 & /*elasticity_tensor*/,
      const RankTwoTensor & /*elastic_strain_old*/,
      bool compute_full_tangent_operator = false,
      RankFourTensor & tangent_operator = StressUpdateBaseTempl<is_ad>::_identityTensor);
 
  void setQp(unsigned int qp);
 
  virtual void propagateQpStatefulProperties();
 
  virtual bool requiresIsotropicTensor() = 0;
 
  virtual bool isIsotropic() { return false; };
 
  virtual Real computeTimeStepLimit();
 
  virtual TangentCalculationMethod getTangentCalculationMethod();
 
  void resetQpProperties() final {}
  void resetProperties() final {}
 
  virtual bool substeppingCapabilityEnabled() { return false; }
 
  virtual bool substeppingCapabilityRequested() { return false; }
 
  virtual int calculateNumberSubsteps(const GR2 & /*strain_increment*/) { return 1; }
 
  virtual void storeIncrementalMaterialProperties(const unsigned int /*total_number_of_substeps*/) {
  };
 
  virtual void resetIncrementalMaterialProperties() {}
 
  virtual Real computeStrainEnergyRateDensity(
      const GenericMaterialProperty<RankTwoTensor, is_ad> & /*stress*/,
      const GenericMaterialProperty<RankTwoTensor, is_ad> & /*strain_rate*/)
  {
    mooseError(
        "The computation of strain energy rate density needs to be implemented by a child class");
    return 0.0;
  }
 
protected:
  const std::string _base_name;
 
  static RankFourTensor _identityTensor;
};
typedef StressUpdateBaseTempl<false> StressUpdateBase;
typedef StressUpdateBaseTempl<true> ADStressUpdateBase;
 
template <bool is_ad, typename R2, typename R4>
RankFourTensor StressUpdateBaseTempl<is_ad, R2, R4>::_identityTensor =
    RankFourTensor(RankFourTensor::initIdentityFour);