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 "ODEKernel.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "Assembly.h"
      14             : #include "MooseVariableScalar.h"
      15             : #include "SystemBase.h"
      16             : 
      17             : InputParameters
      18       23514 : ODEKernel::validParams()
      19             : {
      20       23514 :   InputParameters params = ScalarKernel::validParams();
      21       23514 :   return params;
      22             : }
      23             : 
      24        1047 : ODEKernel::ODEKernel(const InputParameters & parameters) : ScalarKernel(parameters) {}
      25             : 
      26             : void
      27      194342 : ODEKernel::reinit()
      28             : {
      29      194342 : }
      30             : 
      31             : void
      32       65330 : ODEKernel::computeResidual()
      33             : {
      34       65330 :   prepareVectorTag(_assembly, _var.number());
      35             : 
      36      130964 :   for (_i = 0; _i < _var.order(); _i++)
      37       65634 :     _local_re(_i) += computeQpResidual();
      38             : 
      39       65330 :   accumulateTaggedLocalResidual();
      40       65330 : }
      41             : 
      42             : void
      43       29695 : ODEKernel::computeJacobian()
      44             : {
      45       29695 :   prepareMatrixTag(_assembly, _var.number(), _var.number());
      46             : 
      47       59468 :   for (_i = 0; _i < _var.order(); _i++)
      48       59780 :     for (_j = 0; _j < _var.order(); _j++)
      49       30007 :       _local_ke(_i, _j) += computeQpJacobian();
      50             : 
      51       29695 :   accumulateTaggedLocalMatrix();
      52             : 
      53             :   // compute off-diagonal jacobians wrt scalar variables
      54       29695 :   const std::vector<MooseVariableScalar *> & scalar_vars = _sys.getScalarVariables(_tid);
      55       73744 :   for (const auto & var : scalar_vars)
      56       44049 :     computeOffDiagJacobianScalar(var->number());
      57       29695 : }
      58             : 
      59             : void
      60       44049 : ODEKernel::computeOffDiagJacobianScalar(unsigned int jvar)
      61             : {
      62       44049 :   prepareMatrixTag(_assembly, _var.number(), jvar);
      63             : 
      64       44049 :   MooseVariableScalar & var_j = _sys.getScalarVariable(_tid, jvar);
      65       88176 :   for (_i = 0; _i < _var.order(); _i++)
      66       88488 :     for (_j = 0; _j < var_j.order(); _j++)
      67             :     {
      68       44361 :       if (jvar != _var.number())
      69       14354 :         _local_ke(_i, _j) += computeQpOffDiagJacobianScalar(jvar);
      70             :     }
      71             : 
      72       44049 :   accumulateTaggedLocalMatrix();
      73       44049 : }
      74             : 
      75             : Real
      76         324 : ODEKernel::computeQpJacobian()
      77             : {
      78         324 :   return 0.;
      79             : }