TwoParameterPlasticityStressUpdate.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 "MultiParameterPlasticityStressUpdate.h"
 
#include <array>
 
class TwoParameterPlasticityStressUpdate : public MultiParameterPlasticityStressUpdate
{
public:
  static InputParameters validParams();
 
  TwoParameterPlasticityStressUpdate(const InputParameters & parameters,
                                     unsigned num_yf,
                                     unsigned num_intnl);
 
protected:
  constexpr static int _num_pq = 2;
 
  Real _p_trial;
 
  Real _q_trial;
 
  Real _Epp;
 
  Real _Eqq;
 
  Real _dgaE_dpt;
  Real _dgaE_dqt;
  Real _dp_dpt;
  Real _dq_dpt;
  Real _dp_dqt;
  Real _dq_dqt;
 
  virtual void yieldFunctionValues(Real p,
                                   Real q,
                                   const std::vector<Real> & intnl,
                                   std::vector<Real> & yf) const = 0;
  void yieldFunctionValuesV(const std::vector<Real> & stress_params,
                            const std::vector<Real> & intnl,
                            std::vector<Real> & yf) const override;
 
  virtual void computeAllQ(Real p,
                           Real q,
                           const std::vector<Real> & intnl,
                           std::vector<yieldAndFlow> & all_q) const = 0;
  void computeAllQV(const std::vector<Real> & stress_params,
                    const std::vector<Real> & intnl,
                    std::vector<yieldAndFlow> & all_q) const override;
 
  virtual void preReturnMap(Real p_trial,
                            Real q_trial,
                            const RankTwoTensor & stress_trial,
                            const std::vector<Real> & intnl_old,
                            const std::vector<Real> & yf,
                            const RankFourTensor & Eijkl);
  void preReturnMapV(const std::vector<Real> & trial_stress_params,
                     const RankTwoTensor & stress_trial,
                     const std::vector<Real> & intnl_old,
                     const std::vector<Real> & yf,
                     const RankFourTensor & Eijkl) override;
 
  virtual void initializeVars(Real p_trial,
                              Real q_trial,
                              const std::vector<Real> & intnl_old,
                              Real & p,
                              Real & q,
                              Real & gaE,
                              std::vector<Real> & intnl) const;
  void initializeVarsV(const std::vector<Real> & trial_stress_params,
                       const std::vector<Real> & intnl_old,
                       std::vector<Real> & stress_params,
                       Real & gaE,
                       std::vector<Real> & intnl) const override;
 
  virtual void setIntnlValues(Real p_trial,
                              Real q_trial,
                              Real p,
                              Real q,
                              const std::vector<Real> & intnl_old,
                              std::vector<Real> & intnl) const = 0;
  void setIntnlValuesV(const std::vector<Real> & trial_stress_params,
                       const std::vector<Real> & current_stress_params,
                       const std::vector<Real> & intnl_old,
                       std::vector<Real> & intnl) const override;
 
  virtual void setIntnlDerivatives(Real p_trial,
                                   Real q_trial,
                                   Real p,
                                   Real q,
                                   const std::vector<Real> & intnl,
                                   std::vector<std::vector<Real>> & dintnl) const = 0;
  virtual void setIntnlDerivativesV(const std::vector<Real> & trial_stress_params,
                                    const std::vector<Real> & current_stress_params,
                                    const std::vector<Real> & intnl,
                                    std::vector<std::vector<Real>> & dintnl) const override;
 
  virtual void computePQ(const RankTwoTensor & stress, Real & p, Real & q) const = 0;
  virtual void computeStressParams(const RankTwoTensor & stress,
                                   std::vector<Real> & stress_params) const override;
 
  virtual void setEppEqq(const RankFourTensor & Eijkl, Real & Epp, Real & Eqq) const = 0;
  virtual void setEffectiveElasticity(const RankFourTensor & Eijkl) override;
 
  virtual void setStressAfterReturn(const RankTwoTensor & stress_trial,
                                    Real p_ok,
                                    Real q_ok,
                                    Real gaE,
                                    const std::vector<Real> & intnl,
                                    const yieldAndFlow & smoothed_q,
                                    const RankFourTensor & Eijkl,
                                    RankTwoTensor & stress) const = 0;
  void setStressAfterReturnV(const RankTwoTensor & stress_trial,
                             const std::vector<Real> & stress_params,
                             Real gaE,
                             const std::vector<Real> & intnl,
                             const yieldAndFlow & smoothed_q,
                             const RankFourTensor & Eijkl,
                             RankTwoTensor & stress) const override;
 
  void setInelasticStrainIncrementAfterReturn(const RankTwoTensor & stress_trial,
                                              Real gaE,
                                              const yieldAndFlow & smoothed_q,
                                              const RankFourTensor & elasticity_tensor,
                                              const RankTwoTensor & returned_stress,
                                              RankTwoTensor & inelastic_strain_increment) override;
 
  virtual void consistentTangentOperator(const RankTwoTensor & stress_trial,
                                         Real p_trial,
                                         Real q_trial,
                                         const RankTwoTensor & stress,
                                         Real p,
                                         Real q,
                                         Real gaE,
                                         const yieldAndFlow & smoothed_q,
                                         const RankFourTensor & Eijkl,
                                         bool compute_full_tangent_operator,
                                         RankFourTensor & cto) const;
 
  void consistentTangentOperatorV(const RankTwoTensor & stress_trial,
                                  const std::vector<Real> & trial_stress_params,
                                  const RankTwoTensor & stress,
                                  const std::vector<Real> & stress_params,
                                  Real gaE,
                                  const yieldAndFlow & smoothed_q,
                                  const RankFourTensor & Eijkl,
                                  bool compute_full_tangent_operator,
                                  const std::vector<std::vector<Real>> & dvar_dtrial,
                                  RankFourTensor & cto) override;
 
  virtual void dstressparam_dstress(const RankTwoTensor & stress,
                                    std::vector<RankTwoTensor> & dsp) const override;
  virtual void d2stressparam_dstress(const RankTwoTensor & stress,
                                     std::vector<RankFourTensor> & d2sp) const override;
  virtual RankTwoTensor dpdstress(const RankTwoTensor & stress) const = 0;
 
  virtual RankFourTensor d2pdstress2(const RankTwoTensor & stress) const = 0;
 
  virtual RankTwoTensor dqdstress(const RankTwoTensor & stress) const = 0;
 
  virtual RankFourTensor d2qdstress2(const RankTwoTensor & stress) const = 0;
 
private:
  mutable std::vector<RankTwoTensor> _dsp_scratch;
 
  mutable std::vector<RankTwoTensor> _dsp_trial_scratch;
 
  mutable std::vector<RankFourTensor> _d2sp_scratch;
};