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 "IntegratedBC.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "Assembly.h"
      14             : #include "SubProblem.h"
      15             : #include "SystemBase.h"
      16             : #include "MooseVariableFE.h"
      17             : #include "MooseVariableScalar.h"
      18             : #include "FEProblemBase.h"
      19             : 
      20             : #include "libmesh/quadrature.h"
      21             : 
      22             : InputParameters
      23      129069 : IntegratedBC::validParams()
      24             : {
      25      129069 :   InputParameters params = IntegratedBCBase::validParams();
      26      129069 :   return params;
      27             : }
      28             : 
      29        6646 : IntegratedBC::IntegratedBC(const InputParameters & parameters)
      30             :   : IntegratedBCBase(parameters),
      31             :     MooseVariableInterface<Real>(this,
      32             :                                  false,
      33             :                                  "variable",
      34             :                                  Moose::VarKindType::VAR_SOLVER,
      35             :                                  Moose::VarFieldType::VAR_FIELD_STANDARD),
      36       13282 :     _var(*mooseVariable()),
      37        6641 :     _normals(_assembly.normals()),
      38        6641 :     _phi(_assembly.phiFace(_var)),
      39        6641 :     _grad_phi(_assembly.gradPhiFace(_var)),
      40        6641 :     _test(_var.phiFace()),
      41        6641 :     _grad_test(_var.gradPhiFace()),
      42        6641 :     _u(_is_implicit ? _var.sln() : _var.slnOld()),
      43       26569 :     _grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld())
      44             : {
      45        6641 :   addMooseVariableDependency(mooseVariable());
      46             : 
      47        6641 :   _save_in.resize(_save_in_strings.size());
      48        6641 :   _diag_save_in.resize(_diag_save_in_strings.size());
      49             : 
      50        6735 :   for (unsigned int i = 0; i < _save_in_strings.size(); i++)
      51             :   {
      52          94 :     MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]);
      53             : 
      54          94 :     if (var->feType() != _var.feType())
      55           0 :       paramError(
      56             :           "save_in",
      57             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      58           0 :           moose::internal::incompatVarMsg(*var, _var));
      59          94 :     _save_in[i] = var;
      60          94 :     var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
      61          94 :     addMooseVariableDependency(var);
      62             :   }
      63             : 
      64        6641 :   _has_save_in = _save_in.size() > 0;
      65             : 
      66        6688 :   for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
      67             :   {
      68          47 :     MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]);
      69             : 
      70          47 :     if (var->feType() != _var.feType())
      71           0 :       paramError(
      72             :           "diag_save_in",
      73             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      74           0 :           moose::internal::incompatVarMsg(*var, _var));
      75             : 
      76          47 :     _diag_save_in[i] = var;
      77          47 :     var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
      78          47 :     addMooseVariableDependency(var);
      79             :   }
      80             : 
      81        6641 :   _has_diag_save_in = _diag_save_in.size() > 0;
      82        6641 : }
      83             : 
      84             : void
      85     1881848 : IntegratedBC::computeResidual()
      86             : {
      87     1881848 :   prepareVectorTag(_assembly, _var.number());
      88             : 
      89     1881848 :   precalculateResidual();
      90             : 
      91     6999485 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      92             :   {
      93     5117637 :     precalculateQpResidual();
      94    46722729 :     for (_i = 0; _i < _test.size(); _i++)
      95    41605092 :       _local_re(_i) += _JxW[_qp] * _coord[_qp] * computeQpResidual();
      96             :   }
      97             : 
      98     1881848 :   accumulateTaggedLocalResidual();
      99             : 
     100     1881848 :   if (_has_save_in)
     101        2668 :     for (unsigned int i = 0; i < _save_in.size(); i++)
     102        1414 :       _save_in[i]->sys().solution().add_vector(_local_re, _save_in[i]->dofIndices());
     103     1881848 : }
     104             : 
     105             : void
     106      221560 : IntegratedBC::computeJacobian()
     107             : {
     108      221560 :   prepareMatrixTag(_assembly, _var.number(), _var.number());
     109             : 
     110      221560 :   precalculateJacobian();
     111             : 
     112      895139 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     113             :   {
     114      673579 :     precalculateQpJacobian();
     115     6220558 :     for (_i = 0; _i < _test.size(); _i++)
     116    81520066 :       for (_j = 0; _j < _phi.size(); _j++)
     117    75973087 :         _local_ke(_i, _j) += _JxW[_qp] * _coord[_qp] * computeQpJacobian();
     118             :   }
     119             : 
     120      221560 :   accumulateTaggedLocalMatrix();
     121             : 
     122      221560 :   if (_has_diag_save_in)
     123             :   {
     124         158 :     unsigned int rows = _local_ke.m();
     125         158 :     DenseVector<Number> diag(rows);
     126         790 :     for (unsigned int i = 0; i < rows; i++)
     127         632 :       diag(i) = _local_ke(i, i);
     128             : 
     129         316 :     for (unsigned int i = 0; i < _diag_save_in.size(); i++)
     130         158 :       _diag_save_in[i]->sys().solution().add_vector(diag, _diag_save_in[i]->dofIndices());
     131         158 :   }
     132      221560 : }
     133             : 
     134             : void
     135      122616 : IntegratedBC::computeOffDiagJacobian(const unsigned int jvar_num)
     136             : {
     137      122616 :   const auto & jvar = getVariable(jvar_num);
     138             : 
     139      122616 :   if (jvar_num == _var.number())
     140             :   {
     141      109082 :     computeJacobian();
     142      109082 :     return;
     143             :   }
     144             : 
     145       13534 :   prepareMatrixTag(_assembly, _var.number(), jvar_num);
     146             : 
     147       13534 :   precalculateOffDiagJacobian(jvar_num);
     148             : 
     149       13534 :   const auto n_dofs = jvar.dofIndices().size();
     150       13534 :   const auto phi_size = n_dofs / jvar.count();
     151             :   mooseAssert(n_dofs == _local_ke.n(),
     152             :               "The size of the phi container does not match the number of local Jacobian columns");
     153             : 
     154       52172 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     155             :   {
     156       38638 :     precalculateQpOffDiagJacobian(jvar);
     157      396694 :     for (_i = 0; _i < _test.size(); _i++)
     158     1185112 :       for (_j = 0; _j < phi_size; _j++)
     159      827056 :         _local_ke(_i, _j) += _JxW[_qp] * _coord[_qp] * computeQpOffDiagJacobian(jvar_num);
     160             :   }
     161             : 
     162       13534 :   accumulateTaggedLocalMatrix();
     163             : }
     164             : 
     165             : void
     166          46 : IntegratedBC::computeOffDiagJacobianScalar(const unsigned int jvar)
     167             : {
     168          46 :   prepareMatrixTag(_assembly, _var.number(), jvar);
     169             : 
     170          46 :   MooseVariableScalar & jv = _sys.getScalarVariable(_tid, jvar);
     171         128 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     172         390 :     for (_i = 0; _i < _test.size(); _i++)
     173         616 :       for (_j = 0; _j < jv.order(); _j++)
     174         308 :         _local_ke(_i, _j) += _JxW[_qp] * _coord[_qp] * computeQpOffDiagJacobianScalar(jvar);
     175             : 
     176          46 :   accumulateTaggedLocalMatrix();
     177          46 : }
     178             : 
     179             : void
     180         184 : IntegratedBC::computeResidualAndJacobian()
     181             : {
     182         184 :   computeResidual();
     183             : 
     184         824 :   for (const auto & [ivariable, jvariable] : _fe_problem.couplingEntries(_tid, _sys.number()))
     185             :   {
     186         640 :     const unsigned int ivar = ivariable->number();
     187         640 :     const unsigned int jvar = jvariable->number();
     188             : 
     189         640 :     if (ivar != _var.number())
     190         304 :       continue;
     191             : 
     192         336 :     if (_is_implicit)
     193             :     {
     194         336 :       prepareShapes(jvar);
     195         336 :       computeOffDiagJacobian(jvar);
     196             :     }
     197             :   }
     198             : 
     199             :   /// TODO: add nonlocal Jacobians and scalar Jacobians
     200         184 : }