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       31519 : NodalKernel::validParams()
      19             : {
      20       31519 :   auto params = NodalKernelBase::validParams();
      21      126076 :   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      126076 :   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       94557 :   params.addParamNamesToGroup("diag_save_in save_in", "Advanced");
      34       31519 :   return params;
      35           0 : }
      36             : 
      37         501 : 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        1002 :     _var(*mooseVariable()),
      45         501 :     _u(_var.dofValues()),
      46         501 :     _save_in_strings(parameters.get<std::vector<AuxVariableName>>("save_in")),
      47        2505 :     _diag_save_in_strings(parameters.get<std::vector<AuxVariableName>>("diag_save_in"))
      48             : 
      49             : {
      50         501 :   addMooseVariableDependency(mooseVariable());
      51             : 
      52         501 :   _save_in.resize(_save_in_strings.size());
      53         501 :   _diag_save_in.resize(_diag_save_in_strings.size());
      54             : 
      55         501 :   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         501 :   _has_save_in = _save_in.size() > 0;
      71             : 
      72         501 :   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         501 :   _has_diag_save_in = _diag_save_in.size() > 0;
      88         501 : }
      89             : 
      90             : void
      91     1994608 : NodalKernel::computeResidual()
      92             : {
      93     1994608 :   if (_var.isNodalDefined())
      94             :   {
      95     1994608 :     const dof_id_type & dof_idx = _var.nodalDofIndex();
      96     1994608 :     _qp = 0;
      97     1994608 :     const Real res = computeQpResidual();
      98     3989216 :     addResiduals(_assembly,
      99           0 :                  std::array<Real, 1>{{res}},
     100     1994608 :                  std::array<dof_id_type, 1>{{dof_idx}},
     101     1994608 :                  _var.scalingFactor());
     102             : 
     103     1994608 :     if (_has_save_in)
     104           0 :       for (const auto & var : _save_in)
     105           0 :         var->sys().solution().add(var->nodalDofIndex(), res);
     106             :   }
     107     1994608 : }
     108             : 
     109             : void
     110      522103 : NodalKernel::computeJacobian()
     111             : {
     112      522103 :   if (_var.isNodalDefined())
     113             :   {
     114      522103 :     _qp = 0;
     115      522103 :     const Real cached_val = computeQpJacobian();
     116      522103 :     const dof_id_type cached_row = _var.nodalDofIndex();
     117             : 
     118      522103 :     addJacobianElement(_assembly, cached_val, cached_row, cached_row, _var.scalingFactor());
     119             : 
     120      522103 :     if (_has_diag_save_in)
     121           0 :       for (const auto & var : _diag_save_in)
     122           0 :         var->sys().solution().add(var->nodalDofIndex(), cached_val);
     123             :   }
     124      522103 : }
     125             : 
     126             : void
     127      766443 : NodalKernel::computeOffDiagJacobian(const unsigned int jvar_num)
     128             : {
     129      766443 :   if (_var.isNodalDefined())
     130             :   {
     131      766443 :     if (jvar_num == _var.number())
     132      522103 :       computeJacobian();
     133             :     else
     134             :     {
     135      244340 :       _qp = 0;
     136      244340 :       const Real cached_val = computeQpOffDiagJacobian(jvar_num);
     137      244340 :       const dof_id_type cached_row = _var.nodalDofIndex();
     138             : 
     139             :       // Note: this only works for equal order Lagrange variables...
     140      244340 :       const dof_id_type cached_col = _current_node->dof_number(_sys.number(), jvar_num, 0);
     141             : 
     142      244340 :       addJacobianElement(_assembly, cached_val, cached_row, cached_col, _var.scalingFactor());
     143             :     }
     144             :   }
     145      766443 : }
     146             : 
     147             : Real
     148           0 : NodalKernel::computeQpJacobian()
     149             : {
     150           0 :   return 0.;
     151             : }
     152             : 
     153             : Real
     154           0 : NodalKernel::computeQpOffDiagJacobian(unsigned int /*jvar*/)
     155             : {
     156           0 :   return 0.;
     157             : }