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        6427 : ADKernelScalarBase::validParams()
      23             : {
      24        6427 :   InputParameters params = ADKernel::validParams();
      25             :   // This parameter can get renamed in derived class to a more relevant variable name
      26       25708 :   params.addCoupledVar("scalar_variable", "Primary coupled scalar variable");
      27       25708 :   params.addParam<bool>("compute_scalar_residuals", true, "Whether to compute scalar residuals");
      28       12854 :   params.addParam<bool>(
      29       12854 :       "compute_field_residuals", true, "Whether to compute residuals for the field variable.");
      30        6427 :   return params;
      31           0 : }
      32             : 
      33         133 : ADKernelScalarBase::ADKernelScalarBase(const InputParameters & parameters)
      34             :   : ADKernel(parameters),
      35         133 :     _use_scalar(isParamValid("scalar_variable") ? true : false),
      36         253 :     _compute_scalar_residuals(!_use_scalar ? false : getParam<bool>("compute_scalar_residuals")),
      37         266 :     _compute_field_residuals(getParam<bool>("compute_field_residuals")),
      38         253 :     _kappa_var_ptr(_use_scalar ? getScalarVar("scalar_variable", 0) : nullptr),
      39         133 :     _kappa_var(_use_scalar ? _kappa_var_ptr->number() : 0),
      40         133 :     _k_order(_use_scalar ? _kappa_var_ptr->order() : 0),
      41         266 :     _kappa(_use_scalar ? _kappa_var_ptr->adSln() : _ad_zero)
      42             : {
      43         133 : }
      44             : 
      45             : std::set<std::string>
      46          90 : ADKernelScalarBase::additionalROVariables()
      47             : {
      48          90 :   auto variables = ADKernel::additionalROVariables();
      49          90 :   if (_compute_scalar_residuals)
      50          90 :     variables.insert(_kappa_var_ptr->name());
      51             : 
      52          90 :   return variables;
      53           0 : }
      54             : 
      55             : void
      56        1571 : ADKernelScalarBase::computeResidual()
      57             : {
      58        1571 :   if (_compute_field_residuals)
      59        1571 :     ADKernel::computeResidual(); // compute and assemble regular variable contributions
      60             : 
      61        1571 :   if (_compute_scalar_residuals)
      62             :   {
      63        1571 :     std::vector<Real> scalar_residuals(_k_order);
      64       15683 :     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      65             :     {
      66       14115 :       initScalarQpResidual();
      67       28227 :       for (_h = 0; _h < _k_order; _h++)
      68       14115 :         scalar_residuals[_h] += _JxW[_qp] * _coord[_qp] * raw_value(computeScalarQpResidual());
      69             :     }
      70        1568 :     addResiduals(
      71        1568 :         _assembly, scalar_residuals, _kappa_var_ptr->dofIndices(), _kappa_var_ptr->scalingFactor());
      72        1568 :   }
      73        1568 : }
      74             : 
      75             : void
      76         112 : ADKernelScalarBase::computeJacobian()
      77             : {
      78         112 :   if (_compute_field_residuals)
      79         112 :     ADKernel::computeJacobian();
      80             : 
      81         112 :   if (_compute_scalar_residuals)
      82             :   {
      83         112 :     computeScalarResidualsForJacobian();
      84         336 :     addResidualsAndJacobian(_assembly,
      85         112 :                             _scalar_residuals,
      86         112 :                             _kappa_var_ptr->dofIndices(),
      87         112 :                             _kappa_var_ptr->scalingFactor());
      88             :   }
      89         112 : }
      90             : 
      91             : void
      92         112 : ADKernelScalarBase::computeOffDiagJacobian(const unsigned int jvar_num)
      93             : {
      94             :   // Only need to do this once because AD does all the derivatives at once
      95         112 :   if (jvar_num == _var.number())
      96         112 :     computeJacobian();
      97         112 : }
      98             : 
      99             : void
     100         112 : ADKernelScalarBase::computeOffDiagJacobianScalar(const unsigned int /*jvar_num*/)
     101             : {
     102         112 : }
     103             : 
     104             : void
     105        1728 : ADKernelScalarBase::computeResidualAndJacobian()
     106             : {
     107        1728 :   if (_compute_field_residuals)
     108        1728 :     ADKernel::computeResidualAndJacobian();
     109             : 
     110        1728 :   if (_compute_scalar_residuals)
     111             :   {
     112        1664 :     computeScalarResidualsForJacobian();
     113        4992 :     addResidualsAndJacobian(_assembly,
     114        1664 :                             _scalar_residuals,
     115        1664 :                             _kappa_var_ptr->dofIndices(),
     116        1664 :                             _kappa_var_ptr->scalingFactor());
     117             :   }
     118        1728 : }
     119             : 
     120             : void
     121        1776 : ADKernelScalarBase::computeScalarResidualsForJacobian()
     122             : {
     123        1776 :   if (_scalar_residuals.size() != _k_order)
     124          98 :     _scalar_residuals.resize(_k_order, 0);
     125        3552 :   for (auto & sr : _scalar_residuals)
     126        1776 :     sr = 0;
     127             : 
     128             :   // precalculateResidual was already run for the field variable
     129        1776 :   if (_use_displaced_mesh)
     130           0 :     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     131             :     {
     132           0 :       _r = _ad_JxW[_qp];
     133           0 :       _r *= _ad_coord[_qp];
     134           0 :       for (_h = 0; _h < _k_order; _h++)
     135           0 :         _scalar_residuals[_h] += _r * computeScalarQpResidual();
     136             :     }
     137             :   else
     138       17760 :     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     139       31968 :       for (_h = 0; _h < _k_order; _h++)
     140       15984 :         _scalar_residuals[_h] += _JxW[_qp] * _coord[_qp] * computeScalarQpResidual();
     141        1776 : }