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 "VectorKernel.h"
      11             : #include "Assembly.h"
      12             : #include "MooseVariableFE.h"
      13             : #include "MooseVariableScalar.h"
      14             : #include "SubProblem.h"
      15             : #include "NonlinearSystem.h"
      16             : 
      17             : #include "libmesh/threads.h"
      18             : #include "libmesh/quadrature.h"
      19             : 
      20             : InputParameters
      21      173571 : VectorKernel::validParams()
      22             : {
      23      173571 :   InputParameters params = KernelBase::validParams();
      24      173571 :   params.registerBase("VectorKernel");
      25      173571 :   return params;
      26           0 : }
      27             : 
      28        1242 : VectorKernel::VectorKernel(const InputParameters & parameters)
      29             :   : KernelBase(parameters),
      30             :     MooseVariableInterface<RealVectorValue>(this,
      31             :                                             false,
      32             :                                             "variable",
      33             :                                             Moose::VarKindType::VAR_SOLVER,
      34             :                                             Moose::VarFieldType::VAR_FIELD_VECTOR),
      35        2476 :     _var(*mooseVariable()),
      36        1238 :     _test(_var.phi()),
      37        1238 :     _grad_test(_var.gradPhi()),
      38        1238 :     _phi(_assembly.phi(_var)),
      39        1238 :     _grad_phi(_assembly.gradPhi(_var)),
      40        1238 :     _u(_is_implicit ? _var.sln() : _var.slnOld()),
      41        2480 :     _grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld())
      42             : {
      43        1238 :   addMooseVariableDependency(mooseVariable());
      44        1238 : }
      45             : 
      46             : void
      47     1896407 : VectorKernel::computeResidual()
      48             : {
      49     1896407 :   prepareVectorTag(_assembly, _var.number());
      50     1896407 :   precalculateResidual();
      51    22797881 :   for (_i = 0; _i < _test.size(); _i++)
      52   153980212 :     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      53             :     {
      54   133078738 :       Real residual = _JxW[_qp] * _coord[_qp] * computeQpResidual();
      55   133078738 :       _local_re(_i) += residual;
      56             :     }
      57     1896407 :   accumulateTaggedLocalResidual();
      58             : 
      59     1896407 :   if (_has_save_in)
      60           0 :     for (const auto & var : _save_in)
      61           0 :       var->sys().solution().add_vector(_local_re, var->dofIndices());
      62     1896407 : }
      63             : 
      64             : void
      65      600501 : VectorKernel::computeJacobian()
      66             : {
      67      600501 :   prepareMatrixTag(_assembly, _var.number(), _var.number());
      68      600501 :   precalculateJacobian();
      69     4970083 :   for (_i = 0; _i < _test.size(); _i++)
      70    46049928 :     for (_j = 0; _j < _phi.size(); _j++)
      71   280757744 :       for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      72   239077398 :         _local_ke(_i, _j) += _JxW[_qp] * _coord[_qp] * computeQpJacobian();
      73      600501 :   accumulateTaggedLocalMatrix();
      74             : 
      75      600501 :   if (_has_diag_save_in && !_sys.computingScalingJacobian())
      76             :   {
      77           0 :     unsigned int rows = _local_ke.m();
      78           0 :     DenseVector<Number> diag(rows);
      79           0 :     for (unsigned int i = 0; i < rows; i++)
      80           0 :       diag(i) = _local_ke(i, i);
      81             : 
      82           0 :     for (const auto & var : _diag_save_in)
      83           0 :       var->sys().solution().add_vector(diag, var->dofIndices());
      84           0 :   }
      85      600501 : }
      86             : 
      87             : void
      88     1099756 : VectorKernel::computeOffDiagJacobian(const unsigned int jvar_num)
      89             : {
      90     1099756 :   if (jvar_num == _var.number())
      91      559685 :     computeJacobian();
      92             :   else
      93             :   {
      94      540071 :     const auto & jvar = getVariable(jvar_num);
      95             : 
      96      540071 :     prepareMatrixTag(_assembly, _var.number(), jvar_num);
      97             : 
      98             :     // This (undisplaced) jvar could potentially yield the wrong phi size if this object is acting
      99             :     // on the displaced mesh
     100      540071 :     const auto phi_size = jvar.dofIndices().size();
     101             : 
     102      540071 :     precalculateOffDiagJacobian(jvar_num);
     103     4015235 :     for (_i = 0; _i < _test.size(); _i++)
     104    18852044 :       for (_j = 0; _j < phi_size; _j++)
     105    77812400 :         for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     106    62435520 :           _local_ke(_i, _j) += _JxW[_qp] * _coord[_qp] * computeQpOffDiagJacobian(jvar_num);
     107             : 
     108      540071 :     accumulateTaggedLocalMatrix();
     109             :   }
     110     1099756 : }
     111             : 
     112             : void
     113           0 : VectorKernel::computeOffDiagJacobianScalar(unsigned int jvar)
     114             : {
     115           0 :   prepareMatrixTag(_assembly, _var.number(), jvar);
     116           0 :   MooseVariableScalar & jv = _sys.getScalarVariable(_tid, jvar);
     117             : 
     118           0 :   for (_i = 0; _i < _test.size(); _i++)
     119           0 :     for (_j = 0; _j < jv.order(); _j++)
     120           0 :       for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     121           0 :         _local_ke(_i, _j) += _JxW[_qp] * _coord[_qp] * computeQpOffDiagJacobianScalar(jvar);
     122           0 :   accumulateTaggedLocalMatrix();
     123           0 : }