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       28801 : ADKernelScalarBase::validParams()
      23             : {
      24       28801 :   InputParameters params = ADKernel::validParams();
      25             :   // This parameter can get renamed in derived class to a more relevant variable name
      26       28801 :   params.addCoupledVar("scalar_variable", "Primary coupled scalar variable");
      27       28801 :   params.addParam<bool>("compute_scalar_residuals", true, "Whether to compute scalar residuals");
      28       86403 :   params.addParam<bool>(
      29       57602 :       "compute_field_residuals", true, "Whether to compute residuals for the field variable.");
      30       28801 :   return params;
      31           0 : }
      32             : 
      33         142 : ADKernelScalarBase::ADKernelScalarBase(const InputParameters & parameters)
      34             :   : ADKernel(parameters),
      35         142 :     _use_scalar(isParamValid("scalar_variable") ? true : false),
      36         142 :     _compute_scalar_residuals(!_use_scalar ? false : getParam<bool>("compute_scalar_residuals")),
      37         142 :     _compute_field_residuals(getParam<bool>("compute_field_residuals")),
      38         142 :     _kappa_var_ptr(_use_scalar ? getScalarVar("scalar_variable", 0) : nullptr),
      39         142 :     _kappa_var(_use_scalar ? _kappa_var_ptr->number() : 0),
      40         142 :     _k_order(_use_scalar ? _kappa_var_ptr->order() : 0),
      41         284 :     _kappa(_use_scalar ? _kappa_var_ptr->adSln() : _ad_zero)
      42             : {
      43         142 : }
      44             : 
      45             : void
      46        1827 : ADKernelScalarBase::computeResidual()
      47             : {
      48        1827 :   if (_compute_field_residuals)
      49        1827 :     ADKernel::computeResidual(); // compute and assemble regular variable contributions
      50             : 
      51        1827 :   if (_compute_scalar_residuals)
      52             :   {
      53        1827 :     std::vector<Real> scalar_residuals(_k_order);
      54       18243 :     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      55             :     {
      56       16419 :       initScalarQpResidual();
      57       32835 :       for (_h = 0; _h < _k_order; _h++)
      58       16419 :         scalar_residuals[_h] += _JxW[_qp] * _coord[_qp] * raw_value(computeScalarQpResidual());
      59             :     }
      60        1824 :     addResiduals(
      61        1824 :         _assembly, scalar_residuals, _kappa_var_ptr->dofIndices(), _kappa_var_ptr->scalingFactor());
      62        1824 :   }
      63        1824 : }
      64             : 
      65             : void
      66         128 : ADKernelScalarBase::computeJacobian()
      67             : {
      68         128 :   if (_compute_field_residuals)
      69         128 :     ADKernel::computeJacobian();
      70             : 
      71         128 :   if (_compute_scalar_residuals)
      72             :   {
      73         128 :     computeScalarResidualsForJacobian();
      74         384 :     addResidualsAndJacobian(_assembly,
      75         128 :                             _scalar_residuals,
      76         128 :                             _kappa_var_ptr->dofIndices(),
      77         128 :                             _kappa_var_ptr->scalingFactor());
      78             :   }
      79         128 : }
      80             : 
      81             : void
      82         128 : ADKernelScalarBase::computeOffDiagJacobian(const unsigned int jvar_num)
      83             : {
      84             :   // Only need to do this once because AD does all the derivatives at once
      85         128 :   if (jvar_num == _var.number())
      86         128 :     computeJacobian();
      87         128 : }
      88             : 
      89             : void
      90         128 : ADKernelScalarBase::computeOffDiagJacobianScalar(const unsigned int /*jvar_num*/)
      91             : {
      92         128 : }
      93             : 
      94             : void
      95        2008 : ADKernelScalarBase::computeResidualAndJacobian()
      96             : {
      97        2008 :   if (_compute_field_residuals)
      98        2008 :     ADKernel::computeResidualAndJacobian();
      99             : 
     100        2008 :   if (_compute_scalar_residuals)
     101             :   {
     102        1936 :     computeScalarResidualsForJacobian();
     103        5808 :     addResidualsAndJacobian(_assembly,
     104        1936 :                             _scalar_residuals,
     105        1936 :                             _kappa_var_ptr->dofIndices(),
     106        1936 :                             _kappa_var_ptr->scalingFactor());
     107             :   }
     108        2008 : }
     109             : 
     110             : void
     111        2064 : ADKernelScalarBase::computeScalarResidualsForJacobian()
     112             : {
     113        2064 :   if (_scalar_residuals.size() != _k_order)
     114         118 :     _scalar_residuals.resize(_k_order, 0);
     115        4128 :   for (auto & sr : _scalar_residuals)
     116        2064 :     sr = 0;
     117             : 
     118             :   // precalculateResidual was already run for the field variable
     119       20640 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     120       37152 :     for (_h = 0; _h < _k_order; _h++)
     121       18576 :       _scalar_residuals[_h] += _JxW[_qp] * _coord[_qp] * computeScalarQpResidual();
     122        2064 : }