Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://www.mooseframework.org
       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             : #include "TensorMechanicsHardeningCubic.h"
      11             : #include "libmesh/utility.h"
      12             : 
      13             : registerMooseObject("TensorMechanicsApp", TensorMechanicsHardeningCubic);
      14             : 
      15             : InputParameters
      16         716 : TensorMechanicsHardeningCubic::validParams()
      17             : {
      18         716 :   InputParameters params = TensorMechanicsHardeningModel::validParams();
      19        1432 :   params.addRequiredParam<Real>(
      20             :       "value_0", "The value of the parameter for all internal_parameter <= internal_0");
      21        1432 :   params.addParam<Real>("value_residual",
      22             :                         "The value of the parameter for internal_parameter >= "
      23             :                         "internal_limit.  Default = value_0, ie perfect "
      24             :                         "plasticity");
      25        1432 :   params.addParam<Real>(
      26        1432 :       "internal_0", 0.0, "The value of the internal_parameter when hardening begins");
      27        1432 :   params.addParam<Real>("internal_limit",
      28        1432 :                         1.0,
      29             :                         "The value of the internal_parameter when hardening "
      30             :                         "ends.  This hardening forms a cubic between "
      31             :                         "(internal_0, value_0) and (internal_limit, "
      32             :                         "value_residual) that is smooth at internal_0 and "
      33             :                         "internal_limit");
      34         716 :   params.addClassDescription("Hardening is Cubic");
      35         716 :   return params;
      36           0 : }
      37             : 
      38         358 : TensorMechanicsHardeningCubic::TensorMechanicsHardeningCubic(const InputParameters & parameters)
      39             :   : TensorMechanicsHardeningModel(parameters),
      40         358 :     _val_0(getParam<Real>("value_0")),
      41        1062 :     _val_res(parameters.isParamValid("value_residual") ? getParam<Real>("value_residual") : _val_0),
      42         716 :     _intnl_0(getParam<Real>("internal_0")),
      43         716 :     _intnl_limit(getParam<Real>("internal_limit")),
      44         358 :     _half_intnl_limit(0.5 * (_intnl_limit - _intnl_0)),
      45         358 :     _alpha((_val_0 - _val_res) / (4.0 * Utility::pow<3>(_half_intnl_limit))),
      46         358 :     _beta(-3.0 * _alpha * Utility::pow<2>(_half_intnl_limit))
      47             : {
      48         358 :   if (_intnl_limit <= _intnl_0)
      49           0 :     mooseError("internal_limit must be greater than internal_0 in Cubic Hardening");
      50         358 : }
      51             : 
      52             : Real
      53     7123462 : TensorMechanicsHardeningCubic::value(Real intnl) const
      54             : {
      55     7123462 :   const Real x = intnl - _intnl_0;
      56     7123462 :   if (x <= 0.0)
      57     2802804 :     return _val_0;
      58     4320658 :   else if (intnl >= _intnl_limit)
      59        9748 :     return _val_res;
      60             :   else
      61     4310910 :     return _alpha * Utility::pow<3>(x - _half_intnl_limit) + _beta * (x - _half_intnl_limit) +
      62     4310910 :            0.5 * (_val_0 + _val_res);
      63             : }
      64             : 
      65             : Real
      66     2559306 : TensorMechanicsHardeningCubic::derivative(Real intnl) const
      67             : {
      68     2559306 :   const Real x = intnl - _intnl_0;
      69     2559306 :   if (x <= 0.0)
      70             :     return 0.0;
      71     1878150 :   else if (intnl >= _intnl_limit)
      72             :     return 0.0;
      73             :   else
      74     1873958 :     return 3.0 * _alpha * Utility::pow<2>(x - _half_intnl_limit) + _beta;
      75             : }
      76             : 
      77             : std::string
      78        4172 : TensorMechanicsHardeningCubic::modelName() const
      79             : {
      80        4172 :   return "Cubic";
      81             : }