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