ComputeMultiPlasticityStress.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 "ComputeStressBase.h"
#include "MultiPlasticityDebugger.h"
 
class ComputeMultiPlasticityStress;
 
template <>
InputParameters validParams<ComputeMultiPlasticityStress>();
 
class ComputeMultiPlasticityStress : public ComputeStressBase, public MultiPlasticityDebugger
{
public:
  static InputParameters validParams();
 
  ComputeMultiPlasticityStress(const InputParameters & parameters);
 
protected:
  virtual void computeQpStress();
  virtual void initQpStatefulProperties();
 
  unsigned int _max_iter;
 
  Real _min_stepsize;
 
  Real _max_stepsize_for_dumb;
 
  bool _ignore_failures;
 
  enum TangentOperatorEnum
  {
    elastic,
    linear,
    nonlinear
  } _tangent_operator_type;
 
  Real _epp_tol;
 
  std::vector<Real> _dummy_pm;
 
  std::vector<Real> _cumulative_pm;
 
  /*
   * Scheme by which constraints are deactivated.
   * This enum is defined here for computational
   * efficiency.  If you add to this list you must
   * also add to the MooseEnum in the .C file
   */
  enum DeactivationSchemeEnum
  {
    optimized,
    safe,
    dumb,
    optimized_to_safe,
    safe_to_dumb,
    optimized_to_safe_to_dumb,
    optimized_to_dumb
  } _deactivation_scheme;
 
  bool _n_supplied;
 
  RealVectorValue _n_input;
 
  RealTensorValue _rot;
 
  bool _perform_finite_strain_rotations;
 
  const std::string _elasticity_tensor_name;
  const MaterialProperty<RankFourTensor> & _elasticity_tensor;
 
  MaterialProperty<RankTwoTensor> & _plastic_strain;
 
  const MaterialProperty<RankTwoTensor> & _plastic_strain_old;
 
  MaterialProperty<std::vector<Real>> & _intnl;
 
  const MaterialProperty<std::vector<Real>> & _intnl_old;
 
  MaterialProperty<std::vector<Real>> & _yf;
 
  MaterialProperty<Real> & _iter;
 
  MaterialProperty<Real> & _linesearch_needed;
 
  MaterialProperty<Real> & _ld_encountered;
 
  MaterialProperty<Real> & _constraints_added;
 
  MaterialProperty<RealVectorValue> & _n;
 
  const MaterialProperty<RealVectorValue> & _n_old;
 
  const MaterialProperty<RankTwoTensor> & _strain_increment;
 
  const MaterialProperty<RankTwoTensor> & _total_strain_old;
 
  const MaterialProperty<RankTwoTensor> & _rotation_increment;
 
  const MaterialProperty<RankTwoTensor> & _stress_old;
 
  const MaterialProperty<RankTwoTensor> & _elastic_strain_old;
 
  bool _cosserat;
 
  const MaterialProperty<RankTwoTensor> * _curvature;
 
  const MaterialProperty<RankFourTensor> * _elastic_flexural_rigidity_tensor;
 
  MaterialProperty<RankTwoTensor> * _couple_stress;
 
  const MaterialProperty<RankTwoTensor> * _couple_stress_old;
 
  MaterialProperty<RankFourTensor> * _Jacobian_mult_couple;
 
  RankFourTensor _my_elasticity_tensor;
 
  RankTwoTensor _my_strain_increment;
 
  RankFourTensor _my_flexural_rigidity_tensor;
 
  RankTwoTensor _my_curvature;
 
  virtual bool reinstateLinearDependentConstraints(std::vector<bool> & deactivated_due_to_ld);
 
  virtual unsigned int numberActive(const std::vector<bool> & active);
 
  virtual Real residual2(const std::vector<Real> & pm,
                         const std::vector<Real> & f,
                         const RankTwoTensor & epp,
                         const std::vector<Real> & ic,
                         const std::vector<bool> & active,
                         const std::vector<bool> & deactivated_due_to_ld);
 
  virtual bool returnMap(const RankTwoTensor & stress_old,
                         RankTwoTensor & stress,
                         const std::vector<Real> & intnl_old,
                         std::vector<Real> & intnl,
                         const RankTwoTensor & plastic_strain_old,
                         RankTwoTensor & plastic_strain,
                         const RankFourTensor & E_ijkl,
                         const RankTwoTensor & strain_increment,
                         std::vector<Real> & f,
                         unsigned int & iter,
                         bool can_revert_to_dumb,
                         bool & linesearch_needed,
                         bool & ld_encountered,
                         bool & constraints_added,
                         bool final_step,
                         RankFourTensor & consistent_tangent_operator,
                         std::vector<Real> & cumulative_pm);
 
  virtual bool lineSearch(Real & nr_res2,
                          RankTwoTensor & stress,
                          const std::vector<Real> & intnl_old,
                          std::vector<Real> & intnl,
                          std::vector<Real> & pm,
                          const RankFourTensor & E_inv,
                          RankTwoTensor & delta_dp,
                          const RankTwoTensor & dstress,
                          const std::vector<Real> & dpm,
                          const std::vector<Real> & dintnl,
                          std::vector<Real> & f,
                          RankTwoTensor & epp,
                          std::vector<Real> & ic,
                          const std::vector<bool> & active,
                          const std::vector<bool> & deactivated_due_to_ld,
                          bool & linesearch_needed);
 
  virtual bool singleStep(Real & nr_res2,
                          RankTwoTensor & stress,
                          const std::vector<Real> & intnl_old,
                          std::vector<Real> & intnl,
                          std::vector<Real> & pm,
                          RankTwoTensor & delta_dp,
                          const RankFourTensor & E_inv,
                          std::vector<Real> & f,
                          RankTwoTensor & epp,
                          std::vector<Real> & ic,
                          std::vector<bool> & active,
                          DeactivationSchemeEnum deactivation_scheme,
                          bool & linesearch_needed,
                          bool & ld_encountered);
 
  virtual bool checkAdmissible(const RankTwoTensor & stress,
                               const std::vector<Real> & intnl,
                               std::vector<Real> & all_f);
 
  void buildDumbOrder(const RankTwoTensor & stress,
                      const std::vector<Real> & intnl,
                      std::vector<unsigned int> & dumb_order);
 
  virtual void incrementDumb(int & dumb_iteration,
                             const std::vector<unsigned int> & dumb_order,
                             std::vector<bool> & act);
 
  virtual bool checkKuhnTucker(const std::vector<Real> & f,
                               const std::vector<Real> & pm,
                               const std::vector<bool> & active);
 
  virtual void applyKuhnTucker(const std::vector<Real> & f,
                               const std::vector<Real> & pm,
                               std::vector<bool> & active);
 
  // gets called before any return-map
  virtual void preReturnMap();
 
  // gets called after return-map
  virtual void postReturnMap();
 
  enum quickStep_called_from_t
  {
    computeQpStress_function,
    returnMap_function
  };
 
  virtual bool quickStep(const RankTwoTensor & stress_old,
                         RankTwoTensor & stress,
                         const std::vector<Real> & intnl_old,
                         std::vector<Real> & intnl,
                         std::vector<Real> & pm,
                         std::vector<Real> & cumulative_pm,
                         const RankTwoTensor & plastic_strain_old,
                         RankTwoTensor & plastic_strain,
                         const RankFourTensor & E_ijkl,
                         const RankTwoTensor & strain_increment,
                         std::vector<Real> & yf,
                         unsigned int & iterations,
                         RankFourTensor & consistent_tangent_operator,
                         const quickStep_called_from_t called_from,
                         bool final_step);
 
  virtual bool plasticStep(const RankTwoTensor & stress_old,
                           RankTwoTensor & stress,
                           const std::vector<Real> & intnl_old,
                           std::vector<Real> & intnl,
                           const RankTwoTensor & plastic_strain_old,
                           RankTwoTensor & plastic_strain,
                           const RankFourTensor & E_ijkl,
                           const RankTwoTensor & strain_increment,
                           std::vector<Real> & yf,
                           unsigned int & iterations,
                           bool & linesearch_needed,
                           bool & ld_encountered,
                           bool & constraints_added,
                           RankFourTensor & consistent_tangent_operator);
 
  //  bool checkAndModifyConstraints(bool nr_exit_condition, const RankTwoTensor & stress, const
  //  std::vector<Real> & intnl, const std::vector<Real> & pm, const std::vector<bool> &
  //  initial_act, bool can_revert_to_dumb, const RankTwoTensor & initial_stress, const
  //  std::vector<Real> & intnl_old, const std::vector<Real> & f, DeactivationSchemeEnum
  //  deact_scheme, std::vector<bool> & act, int & dumb_iteration, std::vector<unsigned int>
  //  dumb_order, bool & die);
 
  bool canChangeScheme(DeactivationSchemeEnum current_deactivation_scheme, bool can_revert_to_dumb);
 
  bool canIncrementDumb(int dumb_iteration);
 
  void changeScheme(const std::vector<bool> & initial_act,
                    bool can_revert_to_dumb,
                    const RankTwoTensor & initial_stress,
                    const std::vector<Real> & intnl_old,
                    DeactivationSchemeEnum & current_deactivation_scheme,
                    std::vector<bool> & act,
                    int & dumb_iteration,
                    std::vector<unsigned int> & dumb_order);
 
  bool canAddConstraints(const std::vector<bool> & act, const std::vector<Real> & all_f);
 
  unsigned int activeCombinationNumber(const std::vector<bool> & act);
 
  RankFourTensor consistentTangentOperator(const RankTwoTensor & stress,
                                           const std::vector<Real> & intnl,
                                           const RankFourTensor & E_ijkl,
                                           const std::vector<Real> & pm_this_step,
                                           const std::vector<Real> & cumulative_pm);
 
private:
  RankTwoTensor rot(const RankTwoTensor & tens);
};