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        6371 : ADKernelScalarBase::validParams()
      23             : {
      24        6371 :   InputParameters params = ADKernel::validParams();
      25             :   // This parameter can get renamed in derived class to a more relevant variable name
      26       25484 :   params.addCoupledVar("scalar_variable", "Primary coupled scalar variable");
      27       25484 :   params.addParam<bool>("compute_scalar_residuals", true, "Whether to compute scalar residuals");
      28       12742 :   params.addParam<bool>(
      29       12742 :       "compute_field_residuals", true, "Whether to compute residuals for the field variable.");
      30        6371 :   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             : void
      46        1572 : ADKernelScalarBase::computeResidual()
      47             : {
      48        1572 :   if (_compute_field_residuals)
      49        1572 :     ADKernel::computeResidual(); // compute and assemble regular variable contributions
      50             : 
      51        1572 :   if (_compute_scalar_residuals)
      52             :   {
      53        1572 :     std::vector<Real> scalar_residuals(_k_order);
      54       15684 :     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      55             :     {
      56       14116 :       initScalarQpResidual();
      57       28228 :       for (_h = 0; _h < _k_order; _h++)
      58       14116 :         scalar_residuals[_h] += _JxW[_qp] * _coord[_qp] * raw_value(computeScalarQpResidual());
      59             :     }
      60        1568 :     addResiduals(
      61        1568 :         _assembly, scalar_residuals, _kappa_var_ptr->dofIndices(), _kappa_var_ptr->scalingFactor());
      62        1568 :   }
      63        1568 : }
      64             : 
      65             : void
      66         112 : ADKernelScalarBase::computeJacobian()
      67             : {
      68         112 :   if (_compute_field_residuals)
      69         112 :     ADKernel::computeJacobian();
      70             : 
      71         112 :   if (_compute_scalar_residuals)
      72             :   {
      73         112 :     computeScalarResidualsForJacobian();
      74         336 :     addResidualsAndJacobian(_assembly,
      75         112 :                             _scalar_residuals,
      76         112 :                             _kappa_var_ptr->dofIndices(),
      77         112 :                             _kappa_var_ptr->scalingFactor());
      78             :   }
      79         112 : }
      80             : 
      81             : void
      82         112 : ADKernelScalarBase::computeOffDiagJacobian(const unsigned int jvar_num)
      83             : {
      84             :   // Only need to do this once because AD does all the derivatives at once
      85         112 :   if (jvar_num == _var.number())
      86         112 :     computeJacobian();
      87         112 : }
      88             : 
      89             : void
      90         112 : ADKernelScalarBase::computeOffDiagJacobianScalar(const unsigned int /*jvar_num*/)
      91             : {
      92         112 : }
      93             : 
      94             : void
      95        1728 : ADKernelScalarBase::computeResidualAndJacobian()
      96             : {
      97        1728 :   if (_compute_field_residuals)
      98        1728 :     ADKernel::computeResidualAndJacobian();
      99             : 
     100        1728 :   if (_compute_scalar_residuals)
     101             :   {
     102        1664 :     computeScalarResidualsForJacobian();
     103        4992 :     addResidualsAndJacobian(_assembly,
     104        1664 :                             _scalar_residuals,
     105        1664 :                             _kappa_var_ptr->dofIndices(),
     106        1664 :                             _kappa_var_ptr->scalingFactor());
     107             :   }
     108        1728 : }
     109             : 
     110             : void
     111        1776 : ADKernelScalarBase::computeScalarResidualsForJacobian()
     112             : {
     113        1776 :   if (_scalar_residuals.size() != _k_order)
     114         108 :     _scalar_residuals.resize(_k_order, 0);
     115        3552 :   for (auto & sr : _scalar_residuals)
     116        1776 :     sr = 0;
     117             : 
     118             :   // precalculateResidual was already run for the field variable
     119       17760 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     120       31968 :     for (_h = 0; _h < _k_order; _h++)
     121       15984 :       _scalar_residuals[_h] += _JxW[_qp] * _coord[_qp] * computeScalarQpResidual();
     122        1776 : }