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 "JohnsonCookHardening.h"
       6             : 
       7             : registerMooseObject("raccoonApp", JohnsonCookHardening);
       8             : 
       9             : InputParameters
      10         142 : JohnsonCookHardening::validParams()
      11             : {
      12         142 :   InputParameters params = PlasticHardeningModel::validParams();
      13         142 :   params.addClassDescription("The Johnson-Cook plasticity model.");
      14             : 
      15         284 :   params.addRequiredParam<MaterialPropertyName>("sigma_0",
      16             :                                                 "The reference yield stress $\\sigma_0$");
      17         284 :   params.addRequiredParam<Real>("n", "The exponent n in the JC Model");
      18         284 :   params.addRequiredParam<Real>("m", "The exponent m in the JC Model");
      19         284 :   params.addRequiredParam<Real>("reference_plastic_strain",
      20             :                                 "The $\\epsilon_0$ parameter in the JC Model");
      21         284 :   params.addRequiredParam<Real>("reference_plastic_strain_rate",
      22             :                                 "The ref plastic strain rate parameter in the JC model");
      23         284 :   params.addRequiredParam<Real>("T0", "Reference temperature of the material");
      24         284 :   params.addRequiredCoupledVar("T", "Temperature");
      25         284 :   params.addRangeCheckedParam<Real>(
      26             :       "taylor_quinney_factor",
      27             :       1,
      28             :       "taylor_quinney_factor<=1 & taylor_quinney_factor>=0",
      29             :       "The Taylor-Quinney factor. 1 (default) for purely dissipative, 0 for purely energetic.");
      30         284 :   params.addRequiredParam<MaterialPropertyName>("A", "'A' parameter for the JC model");
      31         284 :   params.addRequiredParam<Real>("B", "'B' parameter for the JC model");
      32         284 :   params.addRequiredParam<Real>("C", "'C' parameter for the JC model");
      33         284 :   params.addRequiredParam<Real>("Tm", "The melting temperature of the material");
      34             : 
      35         284 :   params.addRequiredCoupledVar("phase_field", "Name of the phase-field (damage) variable");
      36         284 :   params.addParam<MaterialPropertyName>(
      37             :       "plastic_energy_density",
      38             :       "psip",
      39             :       "Name of the plastic energy density computed by this material model");
      40         284 :   params.addParam<MaterialPropertyName>("degradation_function", "gp", "The degradation function");
      41         142 :   return params;
      42           0 : }
      43             : 
      44           3 : JohnsonCookHardening::JohnsonCookHardening(const InputParameters & parameters)
      45             :   : PlasticHardeningModel(parameters),
      46             :     DerivativeMaterialPropertyNameInterface(),
      47           6 :     _sigma_0(getADMaterialProperty<Real>(prependBaseName("sigma_0", true))),
      48           6 :     _n(getParam<Real>("n")),
      49           6 :     _m(getParam<Real>("m")),
      50           6 :     _ep0(getParam<Real>("reference_plastic_strain")),
      51           6 :     _epdot0(getParam<Real>("reference_plastic_strain_rate")),
      52           6 :     _T0(getParam<Real>("T0")),
      53           3 :     _T(coupledValueOld("T")),
      54           6 :     _tqf(getParam<Real>("taylor_quinney_factor")),
      55           6 :     _A(getADMaterialProperty<Real>("A")),
      56           6 :     _B(getParam<Real>("B")),
      57           6 :     _C(getParam<Real>("C")),
      58           6 :     _Tm(getParam<Real>("Tm")),
      59           6 :     _d_name(getVar("phase_field", 0)->name()),
      60             : 
      61             :     // The strain energy density and its derivatives
      62           3 :     _psip_name(prependBaseName("plastic_energy_density", true)),
      63           3 :     _psip(declareADProperty<Real>(_psip_name)),
      64           3 :     _psip_active(declareADProperty<Real>(_psip_name + "_active")),
      65           6 :     _dpsip_dd(declareADProperty<Real>(derivativePropertyName(_psip_name, {_d_name}))),
      66             : 
      67             :     // The degradation function and its derivatives
      68           3 :     _gp_name(prependBaseName("degradation_function", true)),
      69           3 :     _gp(getADMaterialProperty<Real>(_gp_name)),
      70          12 :     _dgp_dd(getADMaterialProperty<Real>(derivativePropertyName(_gp_name, {_d_name})))
      71             : {
      72           9 : }
      73             : 
      74             : ADReal // Temperature degradation
      75      497400 : JohnsonCookHardening::temperatureDependence()
      76             : {
      77      497400 :   return 1 - std::pow((_T[_qp] - _T0) / (_Tm - _T0), _m);
      78             : }
      79             : 
      80             : ADReal
      81        6968 : JohnsonCookHardening::initialGuess(const ADReal & effective_trial_stress)
      82             : {
      83             :   ADReal trial_over_stress =
      84       13936 :       effective_trial_stress / _sigma_0[_qp] / temperatureDependence() - _A[_qp];
      85        6968 :   if (trial_over_stress < 0)
      86           0 :     trial_over_stress = 0;
      87        6968 :   return std::max(_ep0 * std::pow(trial_over_stress / _B, 1 / _n),
      88       13936 :                   libMesh::TOLERANCE * libMesh::TOLERANCE);
      89             : }
      90             : 
      91             : ADReal
      92      239712 : JohnsonCookHardening::plasticEnergy(const ADReal & ep, const unsigned int derivative)
      93             : {
      94      239712 :   if (derivative == 0)
      95             :   {
      96       22048 :     _psip_active[_qp] = (1 - _tqf) * _sigma_0[_qp] *
      97       33072 :                         (_A[_qp] * ep + _B * _ep0 * std::pow(ep / _ep0, _n + 1) / (_n + 1)) *
      98       22048 :                         temperatureDependence();
      99       22048 :     _psip[_qp] = _gp[_qp] * _psip_active[_qp];
     100       22048 :     _dpsip_dd[_qp] = _dgp_dd[_qp] * _psip_active[_qp];
     101       11024 :     return _psip[_qp];
     102             :   }
     103             : 
     104      228688 :   if (derivative == 1)
     105             :   {
     106      479424 :     return _gp[_qp] * (1 - _tqf) * _sigma_0[_qp] * (_A[_qp] + _B * std::pow(ep / _ep0, _n)) *
     107      239712 :            temperatureDependence();
     108             :   }
     109      108832 :   if (derivative == 2)
     110             :   {
     111      217664 :     return _gp[_qp] * (1 - _tqf) * _sigma_0[_qp] * _B * std::pow(ep / _ep0, _n - 1) * _n / _ep0 *
     112      217664 :            temperatureDependence();
     113             :   }
     114           0 :   mooseError(name(), "internal error: unsupported derivative order.");
     115             : }
     116             : 
     117             : ADReal
     118      250720 : JohnsonCookHardening::plasticDissipation(const ADReal & delta_ep,
     119             :                                          const ADReal & ep,
     120             :                                          const unsigned int derivative)
     121             : {
     122             :   // For all cases, we are splitting between rate dependent and non rate dependent portions to avoid
     123             :   // /0 errors
     124             : 
     125      250720 :   ADReal result = 0;
     126             : 
     127      250720 :   if (derivative == 0)
     128             :   {
     129       44096 :     result += (_A[_qp] + _B * std::pow(ep / _ep0, _n)) * _tqf * delta_ep;
     130       11024 :     if (_t_step > 0 && delta_ep > libMesh::TOLERANCE * libMesh::TOLERANCE)
     131       13936 :       result += (_A[_qp] + _B * std::pow(ep / _ep0, _n)) *
     132       20904 :                 (_C * std::log(delta_ep / _dt / _epdot0) - _C) * delta_ep;
     133             :   }
     134             : 
     135      250720 :   if (derivative == 1)
     136             :   {
     137      523456 :     result += (_A[_qp] + _B * std::pow(ep / _ep0, _n)) * _tqf;
     138      130864 :     if (_t_step > 0 && delta_ep > libMesh::TOLERANCE * libMesh::TOLERANCE)
     139             :       result +=
     140      579000 :           (_A[_qp] + _B * std::pow(ep / _ep0, _n)) * (_C * std::log(delta_ep / _dt / _epdot0));
     141             :   }
     142             : 
     143      250720 :   if (derivative == 2)
     144             :   {
     145      326496 :     result += _B * std::pow(ep / _ep0, _n - 1) * _n / _ep0 * _tqf;
     146      108832 :     if (_t_step > 0 && delta_ep > libMesh::TOLERANCE * libMesh::TOLERANCE)
     147             :       result +=
     148      217664 :           (_A[_qp] + _B * std::pow(ep / _ep0, _n)) * _C / delta_ep +
     149      435328 :           _B * std::pow(ep / _ep0, _n - 1) * _n / _ep0 * _C * std::log(delta_ep / _dt / _epdot0);
     150             :   }
     151             : 
     152      501440 :   return _gp[_qp] * result * _sigma_0[_qp] * temperatureDependence();
     153             : 
     154             :   mooseError(name(), "internal error: unsupported derivative order.");
     155             : }
     156             : 
     157             : ADReal // Thermal conjugate term
     158       11008 : JohnsonCookHardening::thermalConjugate(const ADReal & ep)
     159             : {
     160             : 
     161       11008 :   return _gp[_qp] * _T[_qp] * (1 - _tqf) * _sigma_0[_qp] *
     162       33024 :          (_A[_qp] + _B * std::pow(ep / _ep0, _n)) *
     163       22016 :          (_m * (std::pow((_T0 - _T[_qp]) / (_T0 - _Tm), _m))) / (_T0 - _T[_qp]);
     164             : }