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 "ADArrayKernel.h"
      11             : 
      12             : #include "Assembly.h"
      13             : #include "MooseVariableFE.h"
      14             : #include "MooseVariableScalar.h"
      15             : #include "SubProblem.h"
      16             : #include "NonlinearSystem.h"
      17             : 
      18             : #include "libmesh/threads.h"
      19             : #include "libmesh/quadrature.h"
      20             : 
      21             : InputParameters
      22        6254 : ADArrayKernel::validParams()
      23             : {
      24        6254 :   InputParameters params = KernelBase::validParams();
      25        6254 :   params.registerBase("ADArrayKernel");
      26        6254 :   return params;
      27           0 : }
      28             : 
      29          69 : ADArrayKernel::ADArrayKernel(const InputParameters & parameters)
      30             :   : KernelBase(parameters),
      31             :     MooseVariableInterface<RealEigenVector>(this,
      32             :                                             false,
      33             :                                             "variable",
      34             :                                             Moose::VarKindType::VAR_SOLVER,
      35             :                                             Moose::VarFieldType::VAR_FIELD_ARRAY),
      36             :     ADFunctorInterface(this),
      37         138 :     _var(*mooseVariable()),
      38          69 :     _test(_var.phi()),
      39          69 :     _grad_test(_var.gradPhi()),
      40          69 :     _array_grad_test(_var.arrayGradPhi()),
      41          69 :     _phi(_assembly.phi(_var)),
      42          69 :     _grad_phi(_assembly.gradPhi(_var)),
      43          69 :     _u(_var.adSln()),
      44          69 :     _grad_u(_var.adGradSln()),
      45          69 :     _count(_var.count()),
      46         276 :     _work_vector(_count)
      47             : {
      48          69 :   _subproblem.haveADObjects(true);
      49          69 :   addMooseVariableDependency(mooseVariable());
      50          69 : }
      51             : 
      52             : void
      53       31968 : ADArrayKernel::computeResidual()
      54             : {
      55             : 
      56       31968 :   prepareVectorTag(_assembly, _var.number());
      57             : 
      58       31968 :   precalculateResidual();
      59      159840 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      60             :   {
      61      127872 :     initQpResidual();
      62      639360 :     for (_i = 0; _i < _test.size(); _i++)
      63             :     {
      64      511488 :       _work_vector.setZero();
      65      511488 :       computeQpResidual(_work_vector);
      66      511488 :       auto raw_work_vector = MetaPhysicL::raw_value(_work_vector);
      67      511488 :       raw_work_vector *= _JxW[_qp] * _coord[_qp];
      68      511488 :       _assembly.saveLocalArrayResidual(_local_re, _i, _test.size(), raw_work_vector);
      69      511488 :     }
      70             :   }
      71             : 
      72       31968 :   accumulateTaggedLocalResidual();
      73       31968 : }
      74             : 
      75             : void
      76        1344 : ADArrayKernel::computeJacobian()
      77             : {
      78        1344 :   _local_ad_re.resize(_test.size() * _count);
      79       12096 :   for (auto & residual : _local_ad_re)
      80       10752 :     residual = 0;
      81             : 
      82        1344 :   precalculateJacobian();
      83        6720 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      84             :   {
      85        5376 :     initQpResidual();
      86       26880 :     for (_i = 0; _i < _test.size(); _i++)
      87             :     {
      88       21504 :       computeQpResidual(_work_vector);
      89       21504 :       _work_vector *= _JxW[_qp] * _coord[_qp];
      90       21504 :       _assembly.saveLocalADArray(_local_ad_re, _i, _test.size(), _work_vector);
      91             :     }
      92             :   }
      93             : 
      94        1344 :   addJacobian(_assembly, _local_ad_re, _var.dofIndices(), _var.arrayScalingFactor());
      95        1344 : }
      96             : 
      97             : void
      98         132 : ADArrayKernel::jacobianSetup()
      99             : {
     100         132 :   _my_elem = nullptr;
     101         132 : }
     102             : 
     103             : void
     104        1344 : ADArrayKernel::computeOffDiagJacobian(const unsigned int)
     105             : {
     106        1344 :   if (_my_elem != _current_elem)
     107             :   {
     108        1344 :     computeJacobian();
     109        1344 :     _my_elem = _current_elem;
     110             :   }
     111        1344 : }