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 "MatDiffusionBase.h"
      11             : 
      12             : template <typename T, bool is_ad>
      13             : InputParameters
      14       34183 : MatDiffusionBaseTempl<T, is_ad>::validParams()
      15             : {
      16       34183 :   InputParameters params = GenericKernelGrad<is_ad>::validParams();
      17      136732 :   params.addParam<MaterialPropertyName>(
      18             :       "diffusivity", "D", "The diffusivity value or material property");
      19      102549 :   params.addCoupledVar("v",
      20             :                        "Coupled concentration variable for kernel to operate on; if this "
      21             :                        "is not specified, the kernel's nonlinear variable will be used as "
      22             :                        "usual");
      23       34183 :   return params;
      24           0 : }
      25             : 
      26             : template <typename T>
      27             : InputParameters
      28       18417 : MatDiffusionBase<T>::validParams()
      29             : {
      30       18417 :   InputParameters params = MatDiffusionBaseTempl<T, false>::validParams();
      31       55251 :   params.addCoupledVar("args",
      32             :                        "Optional vector of arguments for the diffusivity. If provided and "
      33             :                        "diffusivity is a derivative parsed material, Jacobian contributions from "
      34             :                        "the diffusivity will be automatically computed");
      35       18417 :   return params;
      36           0 : }
      37             : 
      38             : template <typename T, bool is_ad>
      39        2310 : MatDiffusionBaseTempl<T, is_ad>::MatDiffusionBaseTempl(const InputParameters & parameters)
      40             :   : DerivativeMaterialInterface<JvarMapKernelInterface<GenericKernelGrad<is_ad>>>(parameters),
      41        2310 :     _diffusivity(this->template getGenericMaterialProperty<T, is_ad>("diffusivity")),
      42        6930 :     _grad_v(isCoupled("v") ? this->template coupledGenericGradient<is_ad>("v") : _grad_u)
      43             : {
      44        2310 : }
      45             : 
      46             : template <typename T>
      47        1841 : MatDiffusionBase<T>::MatDiffusionBase(const InputParameters & parameters)
      48             :   : MatDiffusionBaseTempl<T, false>(parameters),
      49        9205 :     _ddiffusivity_dc(this->template getMaterialPropertyDerivative<T>("diffusivity", _var.name())),
      50        3682 :     _ddiffusivity_darg(_coupled_moose_vars.size()),
      51        3682 :     _is_coupled(this->isCoupled("v")),
      52        3682 :     _v_var(_is_coupled ? this->coupled("v") : _var.number())
      53             : {
      54             :   // fetch derivatives
      55        1995 :   for (unsigned int i = 0; i < _ddiffusivity_darg.size(); ++i)
      56        1078 :     _ddiffusivity_darg[i] = &this->template getMaterialPropertyDerivative<T>(
      57         154 :         "diffusivity", _coupled_moose_vars[i]->name());
      58        1841 : }
      59             : 
      60             : template <typename T, bool is_ad>
      61             : GenericRealVectorValue<is_ad>
      62    19009303 : MatDiffusionBaseTempl<T, is_ad>::precomputeQpResidual()
      63             : {
      64    19009303 :   return _diffusivity[_qp] * _grad_v[_qp];
      65             : }
      66             : 
      67             : template <typename T>
      68             : void
      69        1801 : MatDiffusionBase<T>::initialSetup()
      70             : {
      71        1801 :   this->template validateNonlinearCoupling<T>("diffusivity");
      72        1801 : }
      73             : 
      74             : template <typename T>
      75             : RealGradient
      76     6281216 : MatDiffusionBase<T>::precomputeQpCJacobian()
      77             : {
      78     6281216 :   return _diffusivity[_qp] * _grad_phi[_j][_qp];
      79             : }
      80             : 
      81             : template <typename T>
      82             : RealGradient
      83     6281216 : MatDiffusionBase<T>::precomputeQpJacobian()
      84             : {
      85     6281216 :   auto sum = _ddiffusivity_dc[_qp] * _phi[_j][_qp] * _grad_v[_qp];
      86     6281216 :   if (!_is_coupled)
      87     6281216 :     sum += precomputeQpCJacobian();
      88             : 
      89    12562432 :   return sum;
      90             : }
      91             : 
      92             : template <typename T>
      93             : Real
      94       64000 : MatDiffusionBase<T>::computeQpOffDiagJacobian(unsigned int jvar)
      95             : {
      96             :   // get the coupled variable jvar is referring to
      97       64000 :   const auto cvar = this->mapJvarToCvar(jvar);
      98             : 
      99       64000 :   auto sum = (*_ddiffusivity_darg[cvar])[_qp] * _phi[_j][_qp] * _grad_v[_qp];
     100       64000 :   if (_v_var == jvar)
     101           0 :     sum += precomputeQpCJacobian();
     102             : 
     103      128000 :   return sum * _grad_test[_i][_qp];
     104             : }
     105             : 
     106             : template class MatDiffusionBase<Real>;
     107             : template class MatDiffusionBase<RealTensorValue>;
     108             : template class MatDiffusionBaseTempl<Real, false>;
     109             : template class MatDiffusionBaseTempl<RealTensorValue, false>;
     110             : template class MatDiffusionBaseTempl<Real, true>;
     111             : template class MatDiffusionBaseTempl<RealTensorValue, true>;