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