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      149676 : NodalKernel::validParams()
      19             : {
      20      149676 :   auto params = NodalKernelBase::validParams();
      21      598704 :   params.addParam<std::vector<AuxVariableName>>(
      22             :       "save_in",
      23             :       {},
      24             :       "The name of auxiliary variables to save this BC's residual contributions to.  "
      25             :       "Everything about that variable must match everything about this variable (the "
      26             :       "type, what blocks it's on, etc.)");
      27      598704 :   params.addParam<std::vector<AuxVariableName>>(
      28             :       "diag_save_in",
      29             :       {},
      30             :       "The name of auxiliary variables to save this BC's diagonal jacobian "
      31             :       "contributions to.  Everything about that variable must match everything "
      32             :       "about this variable (the type, what blocks it's on, etc.)");
      33      449028 :   params.addParamNamesToGroup("diag_save_in save_in", "Advanced");
      34      149676 :   return params;
      35           0 : }
      36             : 
      37         551 : NodalKernel::NodalKernel(const InputParameters & parameters)
      38             :   : NodalKernelBase(parameters),
      39             :     MooseVariableInterface<Real>(this,
      40             :                                  true,
      41             :                                  "variable",
      42             :                                  Moose::VarKindType::VAR_SOLVER,
      43             :                                  Moose::VarFieldType::VAR_FIELD_STANDARD),
      44        1102 :     _var(*mooseVariable()),
      45         551 :     _u(_var.dofValues()),
      46         551 :     _save_in_strings(parameters.get<std::vector<AuxVariableName>>("save_in")),
      47        2755 :     _diag_save_in_strings(parameters.get<std::vector<AuxVariableName>>("diag_save_in"))
      48             : 
      49             : {
      50         551 :   addMooseVariableDependency(mooseVariable());
      51             : 
      52         551 :   _save_in.resize(_save_in_strings.size());
      53         551 :   _diag_save_in.resize(_diag_save_in_strings.size());
      54             : 
      55         551 :   for (unsigned int i = 0; i < _save_in_strings.size(); i++)
      56             :   {
      57           0 :     MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]);
      58             : 
      59           0 :     if (var->feType() != _var.feType())
      60           0 :       paramError(
      61             :           "save_in",
      62             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      63           0 :           moose::internal::incompatVarMsg(*var, _var));
      64             : 
      65           0 :     _save_in[i] = var;
      66           0 :     var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
      67           0 :     addMooseVariableDependency(var);
      68             :   }
      69             : 
      70         551 :   _has_save_in = _save_in.size() > 0;
      71             : 
      72         551 :   for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
      73             :   {
      74           0 :     MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]);
      75             : 
      76           0 :     if (var->feType() != _var.feType())
      77           0 :       paramError(
      78             :           "diag_save_in",
      79             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      80           0 :           moose::internal::incompatVarMsg(*var, _var));
      81             : 
      82           0 :     _diag_save_in[i] = var;
      83           0 :     var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
      84           0 :     addMooseVariableDependency(var);
      85             :   }
      86             : 
      87         551 :   _has_diag_save_in = _diag_save_in.size() > 0;
      88         551 : }
      89             : 
      90             : void
      91     2242153 : NodalKernel::computeResidual()
      92             : {
      93     2242153 :   if (_var.isNodalDefined())
      94             :   {
      95     2242153 :     const dof_id_type & dof_idx = _var.nodalDofIndex();
      96     2242153 :     _qp = 0;
      97     2242153 :     const Real res = computeQpResidual();
      98     4484306 :     addResiduals(_assembly,
      99           0 :                  std::array<Real, 1>{{res}},
     100     2242153 :                  std::array<dof_id_type, 1>{{dof_idx}},
     101     2242153 :                  _var.scalingFactor());
     102             : 
     103     2242153 :     if (_has_save_in)
     104           0 :       for (const auto & var : _save_in)
     105           0 :         var->sys().solution().add(var->nodalDofIndex(), res);
     106             :   }
     107     2242153 : }
     108             : 
     109             : void
     110      598466 : NodalKernel::computeJacobian()
     111             : {
     112      598466 :   if (_var.isNodalDefined())
     113             :   {
     114      598466 :     _qp = 0;
     115      598466 :     const Real cached_val = computeQpJacobian();
     116      598466 :     const dof_id_type cached_row = _var.nodalDofIndex();
     117             : 
     118      598466 :     addJacobianElement(_assembly, cached_val, cached_row, cached_row, _var.scalingFactor());
     119             : 
     120      598466 :     if (_has_diag_save_in)
     121             :     {
     122           0 :       Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     123           0 :       for (const auto & var : _diag_save_in)
     124           0 :         var->sys().solution().add(var->nodalDofIndex(), cached_val);
     125           0 :     }
     126             :   }
     127      598466 : }
     128             : 
     129             : void
     130      873766 : NodalKernel::computeOffDiagJacobian(const unsigned int jvar_num)
     131             : {
     132      873766 :   if (_var.isNodalDefined())
     133             :   {
     134      873766 :     if (jvar_num == _var.number())
     135      598466 :       computeJacobian();
     136             :     else
     137             :     {
     138      275300 :       _qp = 0;
     139      275300 :       const Real cached_val = computeQpOffDiagJacobian(jvar_num);
     140      275300 :       const dof_id_type cached_row = _var.nodalDofIndex();
     141             : 
     142             :       // Note: this only works for equal order Lagrange variables...
     143      275300 :       const dof_id_type cached_col = _current_node->dof_number(_sys.number(), jvar_num, 0);
     144             : 
     145      275300 :       addJacobianElement(_assembly, cached_val, cached_row, cached_col, _var.scalingFactor());
     146             :     }
     147             :   }
     148      873766 : }
     149             : 
     150             : Real
     151           0 : NodalKernel::computeQpJacobian()
     152             : {
     153           0 :   return 0.;
     154             : }
     155             : 
     156             : Real
     157           0 : NodalKernel::computeQpOffDiagJacobian(unsigned int /*jvar*/)
     158             : {
     159           0 :   return 0.;
     160             : }