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 "CombinedScalarDamage.h"
      11             : 
      12             : registerMooseObject("TensorMechanicsApp", CombinedScalarDamage);
      13             : registerMooseObject("TensorMechanicsApp", ADCombinedScalarDamage);
      14             : 
      15             : template <bool is_ad>
      16             : InputParameters
      17          96 : CombinedScalarDamageTempl<is_ad>::validParams()
      18             : {
      19          96 :   InputParameters params = ScalarDamageBaseTempl<is_ad>::validParams();
      20             : 
      21          96 :   params.addClassDescription(
      22             :       "Scalar damage model which is computed as a function of multiple scalar damage models");
      23             : 
      24         192 :   params.addRequiredParam<std::vector<MaterialName>>("damage_models",
      25             :                                                      "Name of the damage models used to compute "
      26             :                                                      "the damage index");
      27             : 
      28         192 :   MooseEnum combination_type("Maximum Product", "Maximum");
      29         192 :   params.addParam<MooseEnum>(
      30             :       "combination_type", combination_type, "How the damage models are combined");
      31             : 
      32          96 :   return params;
      33          96 : }
      34             : 
      35             : template <bool is_ad>
      36          72 : CombinedScalarDamageTempl<is_ad>::CombinedScalarDamageTempl(const InputParameters & parameters)
      37             :   : ScalarDamageBaseTempl<is_ad>(parameters),
      38          72 :     _combination_type(
      39         144 :         this->template getParam<MooseEnum>("combination_type").template getEnum<CombinationType>()),
      40         288 :     _damage_models_names(this->template getParam<std::vector<MaterialName>>("damage_models"))
      41             : {
      42          72 : }
      43             : 
      44             : template <bool is_ad>
      45             : void
      46          72 : CombinedScalarDamageTempl<is_ad>::initialSetup()
      47             : {
      48         216 :   for (unsigned int i = 0; i < _damage_models_names.size(); ++i)
      49             :   {
      50         144 :     ScalarDamageBaseTempl<is_ad> * model = dynamic_cast<ScalarDamageBaseTempl<is_ad> *>(
      51         144 :         &this->getMaterialByName(_damage_models_names[i]));
      52             : 
      53         144 :     if (model)
      54         144 :       _damage_models.push_back(model);
      55             :     else
      56           0 :       this->template paramError("damage_model",
      57             :                                 "Damage Model " + _damage_models_names[i] +
      58             :                                     " is not compatible with CombinedScalarDamage");
      59             :   }
      60          72 : }
      61             : 
      62             : template <bool is_ad>
      63             : void
      64        6912 : CombinedScalarDamageTempl<is_ad>::updateQpDamageIndex()
      65             : {
      66        6912 :   switch (_combination_type)
      67             :   {
      68        5184 :     case CombinationType::Maximum:
      69        5184 :       _damage_index[_qp] = _damage_index_old[_qp];
      70       15552 :       for (unsigned int i = 0; i < _damage_models.size(); ++i)
      71       12992 :         _damage_index[_qp] = std::max(_damage_index[_qp], _damage_models[i]->getQpDamageIndex(_qp));
      72             :       break;
      73        1728 :     case CombinationType::Product:
      74        1728 :       _damage_index[_qp] = 1.0;
      75        5184 :       for (unsigned int i = 0; i < _damage_models.size(); ++i)
      76        5120 :         _damage_index[_qp] *= 1.0 - _damage_models[i]->getQpDamageIndex(_qp);
      77        2560 :       _damage_index[_qp] = 1.0 - _damage_index[_qp];
      78        1728 :       break;
      79             :   }
      80             : 
      81       10240 :   _damage_index[_qp] =
      82       14080 :       std::max(_damage_index_old[_qp], std::max(0.0, std::min(1.0, _damage_index[_qp])));
      83        6912 : }