ComputeMultipleInelasticStressBase.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 "ComputeFiniteStrainElasticStress.h"
#include "DamageBase.h"
#include "StressUpdateBase.h"
 
class ComputeMultipleInelasticStressBase : public ComputeFiniteStrainElasticStress
{
public:
  static InputParameters validParams();
 
  ComputeMultipleInelasticStressBase(const InputParameters & parameters);
 
  virtual void initialSetup() override;
 
protected:
  virtual std::vector<MaterialName> getInelasticModelNames() = 0;
 
  virtual void initQpStatefulProperties() override;
 
  virtual void computeQpStress() override;
 
  virtual void computeQpStressIntermediateConfiguration();
 
  virtual void finiteStrainRotation(const bool force_elasticity_rotation = false);
 
  virtual void updateQpState(RankTwoTensor & elastic_strain_increment,
                             RankTwoTensor & combined_inelastic_strain_increment) = 0;
 
  virtual void updateQpStateSingleModel(unsigned model_number,
                                        RankTwoTensor & elastic_strain_increment,
                                        RankTwoTensor & combined_inelastic_strain_increment);
 
  virtual void computeQpJacobianMult();
 
  virtual void computeAdmissibleState(unsigned model_number,
                                      RankTwoTensor & elastic_strain_increment,
                                      RankTwoTensor & inelastic_strain_increment,
                                      RankFourTensor & consistent_tangent_operator);
 
  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;
 
  const MaterialProperty<RankTwoTensor> & _elastic_strain_old;
  const MaterialProperty<RankTwoTensor> & _strain_increment;
 
  MaterialProperty<RankTwoTensor> & _inelastic_strain;
 
  const MaterialProperty<RankTwoTensor> & _inelastic_strain_old;
 
  const enum class TangentOperatorEnum { elastic, nonlinear } _tangent_operator_type;
 
  unsigned _num_models;
 
  std::vector<bool> _tangent_computation_flag;
 
  TangentCalculationMethod _tangent_calculation_method;
 
  std::vector<Real> _inelastic_weights;
 
  std::vector<RankFourTensor> _consistent_tangent_operator;
 
  const bool _cycle_models;
 
  MaterialProperty<Real> & _material_timestep_limit;
 
  const RankFourTensor _identity_symmetric_four;
 
  std::vector<StressUpdateBase *> _models;
 
  bool _is_elasticity_tensor_guaranteed_isotropic;
 
  bool _all_models_isotropic;
 
  DamageBaseTempl<false> * _damage_model;
 
  RankTwoTensor _undamaged_stress_old;
};