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 "ADKernelScalarBase.h"
      11             : 
      12             : #include "Assembly.h"
      13             : #include "SubProblem.h"
      14             : #include "SystemBase.h"
      15             : #include "MooseVariableFE.h"
      16             : #include "MooseVariableScalar.h"
      17             : #include "ADUtils.h"
      18             : 
      19             : #include "libmesh/quadrature.h"
      20             : 
      21             : InputParameters
      22       28791 : ADKernelScalarBase::validParams()
      23             : {
      24       28791 :   InputParameters params = ADKernel::validParams();
      25             :   // This parameter can get renamed in derived class to a more relevant variable name
      26       28791 :   params.addCoupledVar("scalar_variable", "Primary coupled scalar variable");
      27       28791 :   params.addParam<bool>("compute_scalar_residuals", true, "Whether to compute scalar residuals");
      28       86373 :   params.addParam<bool>(
      29       57582 :       "compute_field_residuals", true, "Whether to compute residuals for the field variable.");
      30       28791 :   return params;
      31           0 : }
      32             : 
      33         137 : ADKernelScalarBase::ADKernelScalarBase(const InputParameters & parameters)
      34             :   : ADKernel(parameters),
      35         137 :     _use_scalar(isParamValid("scalar_variable") ? true : false),
      36         137 :     _compute_scalar_residuals(!_use_scalar ? false : getParam<bool>("compute_scalar_residuals")),
      37         137 :     _compute_field_residuals(getParam<bool>("compute_field_residuals")),
      38         137 :     _kappa_var_ptr(_use_scalar ? getScalarVar("scalar_variable", 0) : nullptr),
      39         137 :     _kappa_var(_use_scalar ? _kappa_var_ptr->number() : 0),
      40         137 :     _k_order(_use_scalar ? _kappa_var_ptr->order() : 0),
      41         274 :     _kappa(_use_scalar ? _kappa_var_ptr->adSln() : _ad_zero)
      42             : {
      43         137 : }
      44             : 
      45             : void
      46        1811 : ADKernelScalarBase::computeResidual()
      47             : {
      48        1811 :   if (_compute_field_residuals)
      49        1811 :     ADKernel::computeResidual(); // compute and assemble regular variable contributions
      50             : 
      51        1811 :   if (_compute_scalar_residuals)
      52             :   {
      53        1811 :     std::vector<Real> scalar_residuals(_k_order);
      54       18083 :     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      55             :     {
      56       16275 :       initScalarQpResidual();
      57       32547 :       for (_h = 0; _h < _k_order; _h++)
      58       16275 :         scalar_residuals[_h] += _JxW[_qp] * _coord[_qp] * raw_value(computeScalarQpResidual());
      59             :     }
      60        1808 :     addResiduals(
      61        1808 :         _assembly, scalar_residuals, _kappa_var_ptr->dofIndices(), _kappa_var_ptr->scalingFactor());
      62        1808 :   }
      63        1808 : }
      64             : 
      65             : void
      66         120 : ADKernelScalarBase::computeJacobian()
      67             : {
      68         120 :   if (_compute_field_residuals)
      69         120 :     ADKernel::computeJacobian();
      70             : 
      71         120 :   if (_compute_scalar_residuals)
      72             :   {
      73         120 :     computeScalarResidualsForJacobian();
      74         360 :     addResidualsAndJacobian(_assembly,
      75         120 :                             _scalar_residuals,
      76         120 :                             _kappa_var_ptr->dofIndices(),
      77         120 :                             _kappa_var_ptr->scalingFactor());
      78             :   }
      79         120 : }
      80             : 
      81             : void
      82         120 : ADKernelScalarBase::computeOffDiagJacobian(const unsigned int jvar_num)
      83             : {
      84             :   // Only need to do this once because AD does all the derivatives at once
      85         120 :   if (jvar_num == _var.number())
      86         120 :     computeJacobian();
      87         120 : }
      88             : 
      89             : void
      90         120 : ADKernelScalarBase::computeOffDiagJacobianScalar(const unsigned int /*jvar_num*/)
      91             : {
      92         120 : }
      93             : 
      94             : void
      95        1984 : ADKernelScalarBase::computeResidualAndJacobian()
      96             : {
      97        1984 :   if (_compute_field_residuals)
      98        1984 :     ADKernel::computeResidualAndJacobian();
      99             : 
     100        1984 :   if (_compute_scalar_residuals)
     101             :   {
     102        1920 :     computeScalarResidualsForJacobian();
     103        5760 :     addResidualsAndJacobian(_assembly,
     104        1920 :                             _scalar_residuals,
     105        1920 :                             _kappa_var_ptr->dofIndices(),
     106        1920 :                             _kappa_var_ptr->scalingFactor());
     107             :   }
     108        1984 : }
     109             : 
     110             : void
     111        2040 : ADKernelScalarBase::computeScalarResidualsForJacobian()
     112             : {
     113        2040 :   if (_scalar_residuals.size() != _k_order)
     114         114 :     _scalar_residuals.resize(_k_order, 0);
     115        4080 :   for (auto & sr : _scalar_residuals)
     116        2040 :     sr = 0;
     117             : 
     118             :   // precalculateResidual was already run for the field variable
     119       20400 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     120       36720 :     for (_h = 0; _h < _k_order; _h++)
     121       18360 :       _scalar_residuals[_h] += _JxW[_qp] * _coord[_qp] * computeScalarQpResidual();
     122        2040 : }