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 "DerivativeSumMaterial.h"
      11             : 
      12             : #include "libmesh/quadrature.h"
      13             : 
      14             : registerMooseObject("MooseApp", DerivativeSumMaterial);
      15             : registerMooseObject("MooseApp", ADDerivativeSumMaterial);
      16             : 
      17             : template <bool is_ad>
      18             : InputParameters
      19        6804 : DerivativeSumMaterialTempl<is_ad>::validParams()
      20             : {
      21        6804 :   InputParameters params = DerivativeFunctionMaterialBaseTempl<is_ad>::validParams();
      22       13608 :   params.addClassDescription("Meta-material to sum up multiple derivative materials");
      23       27216 :   params.addParam<std::vector<std::string>>("sum_materials",
      24             :                                             "Base name of the parsed sum material property");
      25             : 
      26             :   // All arguments of the parsed expression (free energy) being summed
      27       27216 :   params.addRequiredCoupledVar("coupled_variables", "Vector of names of variables being summed");
      28             : 
      29       27216 :   params.addCoupledVar("displacement_gradients",
      30             :                        "Vector of displacement gradient variables (see "
      31             :                        "Modules/PhaseField/DisplacementGradients "
      32             :                        "action)");
      33             : 
      34             :   // Advanced arguments to construct a sum of the form \f$ c+\gamma\sum_iF_i \f$
      35       27216 :   params.addParam<std::vector<Real>>("prefactor", {}, "Prefactor to multiply the sum term with.");
      36       27216 :   params.addParam<Real>("constant", 0.0, "Constant to be added to the prefactor multiplied sum.");
      37             : 
      38       20412 :   params.addParam<bool>("validate_coupling",
      39       13608 :                         true,
      40             :                         "Check if all variables the specified materials depend on are listed in "
      41             :                         "the `coupled_variables` parameter.");
      42       20412 :   params.addParamNamesToGroup("prefactor constant", "Advanced");
      43             : 
      44        6804 :   return params;
      45           0 : }
      46             : 
      47             : template <bool is_ad>
      48         522 : DerivativeSumMaterialTempl<is_ad>::DerivativeSumMaterialTempl(const InputParameters & parameters)
      49             :   : DerivativeFunctionMaterialBaseTempl<is_ad>(parameters),
      50         522 :     _sum_materials(this->template getParam<std::vector<std::string>>("sum_materials")),
      51         522 :     _num_materials(_sum_materials.size()),
      52        1044 :     _prefactor(_num_materials, 1.0),
      53        1044 :     _constant(this->template getParam<Real>("constant")),
      54        2088 :     _validate_coupling(this->template getParam<bool>("validate_coupling"))
      55             : {
      56             :   // we need at least one material in the sum
      57         522 :   if (_num_materials == 0)
      58           0 :     mooseError("Please supply at least one material to sum in DerivativeSumMaterial ", name());
      59             : 
      60             :   // get prefactor values if not 1.0
      61        1044 :   std::vector<Real> p = this->template getParam<std::vector<Real>>("prefactor");
      62             : 
      63             :   // if prefactor is used we need the same number of prefactors as sum materials
      64         522 :   if (_num_materials == p.size())
      65           0 :     _prefactor = p;
      66         522 :   else if (p.size() != 0)
      67           0 :     mooseError("Supply the same number of sum materials and prefactors.");
      68             : 
      69             :   // reserve space for summand material properties
      70         522 :   _summand_F.resize(_num_materials);
      71         522 :   _summand_dF.resize(_num_materials);
      72         522 :   _summand_d2F.resize(_num_materials);
      73         522 :   _summand_d3F.resize(_num_materials);
      74             : 
      75        1308 :   for (unsigned int n = 0; n < _num_materials; ++n)
      76             :   {
      77         786 :     _summand_F[n] = &this->template getGenericMaterialProperty<Real, is_ad>(_sum_materials[n]);
      78         786 :     _summand_dF[n].resize(_nargs);
      79         786 :     _summand_d2F[n].resize(_nargs);
      80         786 :     _summand_d3F[n].resize(_nargs);
      81             : 
      82        1572 :     for (unsigned int i = 0; i < _nargs; ++i)
      83             :     {
      84        3930 :       _summand_dF[n][i] = &this->template getMaterialPropertyDerivative<Real, is_ad>(
      85         786 :           _sum_materials[n], _arg_names[i]);
      86         786 :       _summand_d2F[n][i].resize(_nargs);
      87             : 
      88         786 :       if (_third_derivatives)
      89         396 :         _summand_d3F[n][i].resize(_nargs);
      90             : 
      91        1572 :       for (unsigned int j = 0; j < _nargs; ++j)
      92             :       {
      93        2358 :         _summand_d2F[n][i][j] = &this->template getMaterialPropertyDerivative<Real, is_ad>(
      94         786 :             _sum_materials[n], _arg_names[i], _arg_names[j]);
      95             : 
      96         786 :         if (_third_derivatives)
      97             :         {
      98         396 :           _summand_d3F[n][i][j].resize(_nargs);
      99             : 
     100         792 :           for (unsigned int k = 0; k < _nargs; ++k)
     101         396 :             _summand_d3F[n][i][j][k] = &this->template getMaterialPropertyDerivative<Real, is_ad>(
     102         396 :                 _sum_materials[n], _arg_names[i], _arg_names[j], _arg_names[k]);
     103             :         }
     104             :       }
     105             :     }
     106             :   }
     107         522 : }
     108             : 
     109             : template <bool is_ad>
     110             : void
     111         522 : DerivativeSumMaterialTempl<is_ad>::initialSetup()
     112             : {
     113         522 :   if (_validate_coupling)
     114        1044 :     for (unsigned int n = 0; n < _num_materials; ++n)
     115         588 :       this->template validateCoupling<Real>(_sum_materials[n]);
     116         522 : }
     117             : 
     118             : template <bool is_ad>
     119             : void
     120       61300 : DerivativeSumMaterialTempl<is_ad>::computeProperties()
     121             : {
     122             :   unsigned int i, j, k;
     123             : 
     124      306500 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     125             :   {
     126             :     // set function value
     127      245200 :     if (_prop_F)
     128             :     {
     129      245200 :       (*_prop_F)[_qp] = (*_summand_F[0])[_qp] * _prefactor[0];
     130      715600 :       for (unsigned int n = 1; n < _num_materials; ++n)
     131      470400 :         (*_prop_F)[_qp] += (*_summand_F[n])[_qp] * _prefactor[n];
     132             :     }
     133             : 
     134      490400 :     for (i = 0; i < _nargs; ++i)
     135             :     {
     136             :       // set first derivatives
     137      245200 :       if (_prop_dF[i])
     138             :       {
     139      245200 :         (*_prop_dF[i])[_qp] = (*_summand_dF[0][i])[_qp] * _prefactor[0];
     140      715600 :         for (unsigned int n = 1; n < _num_materials; ++n)
     141      470400 :           (*_prop_dF[i])[_qp] += (*_summand_dF[n][i])[_qp] * _prefactor[n];
     142             :       }
     143             : 
     144             :       // second derivatives
     145      490400 :       for (j = i; j < _nargs; ++j)
     146             :       {
     147      245200 :         if (_prop_d2F[i][j])
     148             :         {
     149      245200 :           (*_prop_d2F[i][j])[_qp] = (*_summand_d2F[0][i][j])[_qp] * _prefactor[0];
     150      715600 :           for (unsigned int n = 1; n < _num_materials; ++n)
     151      470400 :             (*_prop_d2F[i][j])[_qp] += (*_summand_d2F[n][i][j])[_qp] * _prefactor[n];
     152             :         }
     153             : 
     154             :         // third derivatives
     155      245200 :         if (_third_derivatives)
     156             :         {
     157      470400 :           for (k = j; k < _nargs; ++k)
     158      235200 :             if (_prop_d3F[i][j][k])
     159             :             {
     160      235200 :               (*_prop_d3F[i][j][k])[_qp] = (*_summand_d3F[0][i][j][k])[_qp] * _prefactor[0];
     161      705600 :               for (unsigned int n = 1; n < _num_materials; ++n)
     162      470400 :                 (*_prop_d3F[i][j][k])[_qp] += (*_summand_d3F[n][i][j][k])[_qp] * _prefactor[n];
     163             :             }
     164             :         }
     165             :       }
     166             :     }
     167             :   }
     168       61300 : }