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 "NodalKernel.h"
      11             : #include "Problem.h"
      12             : #include "SubProblem.h"
      13             : #include "SystemBase.h"
      14             : #include "MooseVariableFE.h"
      15             : #include "Assembly.h"
      16             : 
      17             : InputParameters
      18      143660 : NodalKernel::validParams()
      19             : {
      20      143660 :   return NodalKernelBase::validParams();
      21             : }
      22             : 
      23         551 : NodalKernel::NodalKernel(const InputParameters & parameters)
      24             :   : NodalKernelBase(parameters),
      25        1102 :     _u(_var.dofValues()),
      26         551 :     _save_in_strings(parameters.get<std::vector<AuxVariableName>>("save_in")),
      27        1102 :     _diag_save_in_strings(parameters.get<std::vector<AuxVariableName>>("diag_save_in"))
      28             : 
      29             : {
      30         551 :   _save_in.resize(_save_in_strings.size());
      31         551 :   _diag_save_in.resize(_diag_save_in_strings.size());
      32             : 
      33         551 :   for (unsigned int i = 0; i < _save_in_strings.size(); i++)
      34             :   {
      35           0 :     MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]);
      36             : 
      37           0 :     if (var->feType() != _var.feType())
      38           0 :       paramError(
      39             :           "save_in",
      40             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      41           0 :           moose::internal::incompatVarMsg(*var, _var));
      42             : 
      43           0 :     _save_in[i] = var;
      44           0 :     var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
      45           0 :     addMooseVariableDependency(var);
      46             :   }
      47             : 
      48         551 :   _has_save_in = _save_in.size() > 0;
      49             : 
      50         551 :   for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
      51             :   {
      52           0 :     MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]);
      53             : 
      54           0 :     if (var->feType() != _var.feType())
      55           0 :       paramError(
      56             :           "diag_save_in",
      57             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      58           0 :           moose::internal::incompatVarMsg(*var, _var));
      59             : 
      60           0 :     _diag_save_in[i] = var;
      61           0 :     var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
      62           0 :     addMooseVariableDependency(var);
      63             :   }
      64             : 
      65         551 :   _has_diag_save_in = _diag_save_in.size() > 0;
      66         551 : }
      67             : 
      68             : void
      69     1223275 : NodalKernel::computeResidual()
      70             : {
      71     1223275 :   if (_var.isNodalDefined())
      72             :   {
      73     1223275 :     const dof_id_type & dof_idx = _var.nodalDofIndex();
      74     1223275 :     _qp = 0;
      75     1223275 :     const Real res = computeQpResidual();
      76     2446550 :     addResiduals(_assembly,
      77           0 :                  std::array<Real, 1>{{res}},
      78     1223275 :                  std::array<dof_id_type, 1>{{dof_idx}},
      79     1223275 :                  _var.scalingFactor());
      80             : 
      81     1223275 :     if (_has_save_in)
      82           0 :       for (const auto & var : _save_in)
      83           0 :         var->sys().solution().add(var->nodalDofIndex(), res);
      84             :   }
      85     1223275 : }
      86             : 
      87             : void
      88      598466 : NodalKernel::computeJacobian()
      89             : {
      90      598466 :   if (_var.isNodalDefined())
      91             :   {
      92      598466 :     _qp = 0;
      93      598466 :     const Real cached_val = computeQpJacobian();
      94      598466 :     const dof_id_type cached_row = _var.nodalDofIndex();
      95             : 
      96      598466 :     addJacobianElement(_assembly, cached_val, cached_row, cached_row, _var.scalingFactor());
      97             : 
      98      598466 :     if (_has_diag_save_in)
      99             :     {
     100           0 :       Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     101           0 :       for (const auto & var : _diag_save_in)
     102           0 :         var->sys().solution().add(var->nodalDofIndex(), cached_val);
     103           0 :     }
     104             :   }
     105      598466 : }
     106             : 
     107             : void
     108      873766 : NodalKernel::computeOffDiagJacobian(const unsigned int jvar_num)
     109             : {
     110      873766 :   const auto & jvar = getVariable(jvar_num);
     111             : 
     112      873766 :   if (_var.isNodalDefined())
     113             :   {
     114      873766 :     if (jvar.number() == _var.number())
     115      598466 :       computeJacobian();
     116             :     else
     117             :     {
     118      275300 :       _qp = 0;
     119      275300 :       const Real cached_val = computeQpOffDiagJacobian(jvar.number());
     120      275300 :       const dof_id_type cached_row = _var.nodalDofIndex();
     121             : 
     122             :       // Note: this only works for equal order Lagrange variables...
     123      275300 :       const dof_id_type cached_col = _current_node->dof_number(_sys.number(), jvar.number(), 0);
     124             : 
     125      275300 :       addJacobianElement(_assembly, cached_val, cached_row, cached_col, _var.scalingFactor());
     126             :     }
     127             :   }
     128      873766 : }
     129             : 
     130             : Real
     131           0 : NodalKernel::computeQpJacobian()
     132             : {
     133           0 :   return 0.;
     134             : }
     135             : 
     136             : Real
     137           0 : NodalKernel::computeQpOffDiagJacobian(unsigned int /*jvar*/)
     138             : {
     139           0 :   return 0.;
     140             : }