Line data    Source code

       1             : //* This file is part of the RACCOON application
       2             : //* being developed at Dolbow lab at Duke University
       3             : //* http://dolbow.pratt.duke.edu
       4             : 
       5             : #include "PowerLawHardening.h"
       6             : 
       7             : registerMooseObject("raccoonApp", PowerLawHardening);
       8             : 
       9             : InputParameters
      10         172 : PowerLawHardening::validParams()
      11             : {
      12         172 :   InputParameters params = PlasticHardeningModel::validParams();
      13         172 :   params.addClassDescription("Plastic hardening following a power law.");
      14             : 
      15         344 :   params.addRequiredParam<MaterialPropertyName>("yield_stress", "The yield stress $\\sigma_y$");
      16         344 :   params.addRequiredParam<MaterialPropertyName>("exponent",
      17             :                                                 "The exponent n in the power law hardening $n$");
      18         344 :   params.addRequiredParam<MaterialPropertyName>(
      19             :       "reference_plastic_strain", "The $\\epsilon_0$ parameter in the power law hardening");
      20             : 
      21         344 :   params.addRequiredCoupledVar("phase_field", "Name of the phase-field (damage) variable");
      22         344 :   params.addParam<MaterialPropertyName>(
      23             :       "plastic_energy_density",
      24             :       "psip",
      25             :       "Name of the plastic energy density computed by this material model");
      26         344 :   params.addParam<MaterialPropertyName>("degradation_function", "gp", "The degradation function");
      27             : 
      28         172 :   return params;
      29           0 : }
      30             : 
      31          27 : PowerLawHardening::PowerLawHardening(const InputParameters & parameters)
      32             :   : PlasticHardeningModel(parameters),
      33             :     DerivativeMaterialPropertyNameInterface(),
      34          81 :     _sigma_y(getADMaterialProperty<Real>(prependBaseName("yield_stress", true))),
      35          81 :     _n(getADMaterialProperty<Real>(prependBaseName("exponent", true))),
      36          54 :     _ep0(getADMaterialProperty<Real>(prependBaseName("reference_plastic_strain", true))),
      37             : 
      38          54 :     _d_name(getVar("phase_field", 0)->name()),
      39             : 
      40             :     // The strain energy density and its derivatives
      41          27 :     _psip_name(prependBaseName("plastic_energy_density", true)),
      42          27 :     _psip(declareADProperty<Real>(_psip_name)),
      43          27 :     _psip_active(declareADProperty<Real>(_psip_name + "_active")),
      44          54 :     _dpsip_dd(declareADProperty<Real>(derivativePropertyName(_psip_name, {_d_name}))),
      45             : 
      46             :     // The degradation function and its derivatives
      47          27 :     _gp_name(prependBaseName("degradation_function", true)),
      48          27 :     _gp(getADMaterialProperty<Real>(_gp_name)),
      49         108 :     _dgp_dd(getADMaterialProperty<Real>(derivativePropertyName(_gp_name, {_d_name})))
      50             : {
      51          81 : }
      52             : 
      53             : ADReal
      54      699022 : PowerLawHardening::plasticEnergy(const ADReal & ep, const unsigned int derivative)
      55             : {
      56             :   using std::pow;
      57      699022 :   if (derivative == 0)
      58             :   {
      59             :     using std::pow;
      60      513776 :     _psip_active[_qp] = _n[_qp] * _sigma_y[_qp] * _ep0[_qp] / (_n[_qp] + 1) *
      61     1284440 :                         (pow(1 + ep / _ep0[_qp], 1 / _n[_qp] + 1) - 1);
      62      513776 :     _psip[_qp] = _gp[_qp] * _psip_active[_qp];
      63      513776 :     _dpsip_dd[_qp] = _dgp_dd[_qp] * _psip_active[_qp];
      64      256888 :     return _psip[_qp];
      65             :   }
      66             : 
      67      442134 :   if (derivative == 1)
      68     1747555 :     return _gp[_qp] * _sigma_y[_qp] * pow(1 + ep / _ep0[_qp], 1 / _n[_qp]);
      69             : 
      70       92623 :   if (derivative == 2)
      71      463115 :     return _gp[_qp] * _sigma_y[_qp] * pow(1 + ep / _ep0[_qp], 1 / _n[_qp] - 1) / _n[_qp] /
      72       92623 :            _ep0[_qp];
      73             : 
      74           0 :   mooseError(name(), "internal error: unsupported derivative order.");
      75             :   return 0;
      76             : }