Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #pragma once
      11             : 
      12             : #include "MultiParameterPlasticityStressUpdate.h"
      13             : #include "SolidMechanicsHardeningModel.h"
      14             : 
      15             : /**
      16             :  * CappedMohrCoulombStressUpdate implements rate-independent nonassociative
      17             :  * Mohr-Coulomb plus tensile plus compressive plasticity with hardening/softening.
      18             :  */
      19             : class CappedMohrCoulombStressUpdate : public MultiParameterPlasticityStressUpdate
      20             : {
      21             : public:
      22             :   static InputParameters validParams();
      23             : 
      24             :   CappedMohrCoulombStressUpdate(const InputParameters & parameters);
      25             : 
      26             :   /**
      27             :    * Does the model require the elasticity tensor to be isotropic?
      28             :    */
      29         534 :   bool requiresIsotropicTensor() override { return true; }
      30             : 
      31         639 :   bool isIsotropic() override { return true; };
      32             : 
      33             : protected:
      34             :   /// Hardening model for tensile strength
      35             :   const SolidMechanicsHardeningModel & _tensile_strength;
      36             : 
      37             :   /// Hardening model for compressive strength
      38             :   const SolidMechanicsHardeningModel & _compressive_strength;
      39             : 
      40             :   /// Hardening model for cohesion
      41             :   const SolidMechanicsHardeningModel & _cohesion;
      42             : 
      43             :   /// Hardening model for friction angle
      44             :   const SolidMechanicsHardeningModel & _phi;
      45             : 
      46             :   /// Hardening model for dilation angle
      47             :   const SolidMechanicsHardeningModel & _psi;
      48             : 
      49             :   /// Whether to provide an estimate of the returned stress, based on perfect plasticity
      50             :   const bool _perfect_guess;
      51             : 
      52             :   /// Poisson's ratio
      53             :   Real _poissons_ratio;
      54             : 
      55             :   /**
      56             :    * When equal-eigenvalues are predicted from the stress initialization routine, shift them by this
      57             :    * amount.
      58             :    * This avoids equal-eigenvalue problems, but also accounts for the smoothing of the yield surface
      59             :    */
      60             :   const Real _shifter;
      61             : 
      62             :   /// Eigenvectors of the trial stress as a RankTwoTensor, in order to rotate the returned stress back to stress space
      63             :   RankTwoTensor _eigvecs;
      64             : 
      65             :   void computeStressParams(const RankTwoTensor & stress,
      66             :                            std::vector<Real> & stress_params) const override;
      67             : 
      68             :   void dstressparam_dstress(const RankTwoTensor & stress,
      69             :                             std::vector<RankTwoTensor> & dsp) const override;
      70             : 
      71             :   void d2stressparam_dstress(const RankTwoTensor & stress,
      72             :                              std::vector<RankFourTensor> & d2sp) const override;
      73             : 
      74             :   virtual void setStressAfterReturnV(const RankTwoTensor & stress_trial,
      75             :                                      const std::vector<Real> & stress_params,
      76             :                                      Real gaE,
      77             :                                      const std::vector<Real> & intnl,
      78             :                                      const yieldAndFlow & smoothed_q,
      79             :                                      const RankFourTensor & Eijkl,
      80             :                                      RankTwoTensor & stress) const override;
      81             : 
      82             :   virtual void preReturnMapV(const std::vector<Real> & trial_stress_params,
      83             :                              const RankTwoTensor & stress_trial,
      84             :                              const std::vector<Real> & intnl_old,
      85             :                              const std::vector<Real> & yf,
      86             :                              const RankFourTensor & Eijkl) override;
      87             : 
      88             :   void setEffectiveElasticity(const RankFourTensor & Eijkl) override;
      89             : 
      90             :   void yieldFunctionValuesV(const std::vector<Real> & stress_params,
      91             :                             const std::vector<Real> & intnl,
      92             :                             std::vector<Real> & yf) const override;
      93             : 
      94             :   void computeAllQV(const std::vector<Real> & stress_params,
      95             :                     const std::vector<Real> & intnl,
      96             :                     std::vector<yieldAndFlow> & all_q) const override;
      97             : 
      98             :   void initializeVarsV(const std::vector<Real> & trial_stress_params,
      99             :                        const std::vector<Real> & intnl_old,
     100             :                        std::vector<Real> & stress_params,
     101             :                        Real & gaE,
     102             :                        std::vector<Real> & intnl) const override;
     103             : 
     104             :   void setIntnlValuesV(const std::vector<Real> & trial_stress_params,
     105             :                        const std::vector<Real> & current_stress_params,
     106             :                        const std::vector<Real> & intnl_old,
     107             :                        std::vector<Real> & intnl) const override;
     108             : 
     109             :   void setIntnlDerivativesV(const std::vector<Real> & trial_stress_params,
     110             :                             const std::vector<Real> & current_stress_params,
     111             :                             const std::vector<Real> & intnl,
     112             :                             std::vector<std::vector<Real>> & dintnl) const override;
     113             : 
     114             :   virtual void consistentTangentOperatorV(const RankTwoTensor & stress_trial,
     115             :                                           const std::vector<Real> & trial_stress_params,
     116             :                                           const RankTwoTensor & stress,
     117             :                                           const std::vector<Real> & stress_params,
     118             :                                           Real gaE,
     119             :                                           const yieldAndFlow & smoothed_q,
     120             :                                           const RankFourTensor & Eijkl,
     121             :                                           bool compute_full_tangent_operator,
     122             :                                           const std::vector<std::vector<Real>> & dvar_dtrial,
     123             :                                           RankFourTensor & cto) override;
     124             : 
     125             : private:
     126             :   /**
     127             :    * this is d(stress_param[:])/d(stress) which is calculated by dstressparam_dstress.  Using this
     128             :    * mutable means repeated allocation/deallocation is unnecessary.
     129             :    */
     130             :   mutable std::vector<RankTwoTensor> _dsp_trial_scratch;
     131             : 
     132             :   /**
     133             :    * eigenvalues of the stress, used in dstressparam_dstress and preReturnMapV.  Using this mutable
     134             :    * means repeated allocation/deallocation is unnecessary.
     135             :    */
     136             :   mutable std::vector<Real> _eigvals_scratch;
     137             : 
     138             :   /**
     139             :    * derivative of ga_shear w.r.t. the stress parameters, used in setIntnlDerivativesV.  Using
     140             :    * this mutable means repeated allocation/deallocation is unnecessary.
     141             :    */
     142             :   mutable std::vector<Real> _dga_shear_scratch;
     143             : 
     144             :   /**
     145             :    * scratch vector used in setIntnlDerivativesV.  Using
     146             :    * this mutable means repeated allocation/deallocation is unnecessary.
     147             :    */
     148             :   mutable std::vector<Real> _dshear_correction_scratch;
     149             : };