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 "ArrayIntegratedBC.h"
      11             : 
      12             : #include "Assembly.h"
      13             : #include "SubProblem.h"
      14             : #include "SystemBase.h"
      15             : #include "MooseVariableFE.h"
      16             : #include "MooseVariableScalar.h"
      17             : 
      18             : #include "libmesh/quadrature.h"
      19             : 
      20             : InputParameters
      21       71870 : ArrayIntegratedBC::validParams()
      22             : {
      23       71870 :   InputParameters params = IntegratedBCBase::validParams();
      24       71870 :   return params;
      25             : }
      26             : 
      27         281 : ArrayIntegratedBC::ArrayIntegratedBC(const InputParameters & parameters)
      28             :   : IntegratedBCBase(parameters),
      29             :     MooseVariableInterface<RealEigenVector>(this,
      30             :                                             false,
      31             :                                             "variable",
      32             :                                             Moose::VarKindType::VAR_SOLVER,
      33             :                                             Moose::VarFieldType::VAR_FIELD_ARRAY),
      34         562 :     _var(*mooseVariable()),
      35         281 :     _normals(_assembly.normals()),
      36         281 :     _phi(_assembly.phiFace(_var)),
      37         281 :     _test(_var.phiFace()),
      38         281 :     _u(_is_implicit ? _var.sln() : _var.slnOld()),
      39         281 :     _count(_var.count()),
      40         562 :     _work_vector(_count)
      41             : {
      42         281 :   addMooseVariableDependency(mooseVariable());
      43             : 
      44         281 :   _save_in.resize(_save_in_strings.size());
      45         281 :   _diag_save_in.resize(_diag_save_in_strings.size());
      46             : 
      47         294 :   for (unsigned int i = 0; i < _save_in_strings.size(); i++)
      48             :   {
      49          13 :     ArrayMooseVariable * var = &_subproblem.getArrayVariable(_tid, _save_in_strings[i]);
      50             : 
      51          13 :     if (var->feType() != _var.feType())
      52           0 :       paramError(
      53             :           "save_in",
      54             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      55           0 :           moose::internal::incompatVarMsg(*var, _var));
      56          13 :     _save_in[i] = var;
      57          13 :     var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
      58          13 :     addMooseVariableDependency(var);
      59             :   }
      60             : 
      61         281 :   _has_save_in = _save_in.size() > 0;
      62             : 
      63         294 :   for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
      64             :   {
      65          13 :     ArrayMooseVariable * var = &_subproblem.getArrayVariable(_tid, _diag_save_in_strings[i]);
      66             : 
      67          13 :     if (var->feType() != _var.feType())
      68           0 :       paramError(
      69             :           "diag_save_in",
      70             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      71           0 :           moose::internal::incompatVarMsg(*var, _var));
      72             : 
      73          13 :     _diag_save_in[i] = var;
      74          13 :     var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
      75          13 :     addMooseVariableDependency(var);
      76             :   }
      77             : 
      78         281 :   _has_diag_save_in = _diag_save_in.size() > 0;
      79         281 : }
      80             : 
      81             : void
      82       48740 : ArrayIntegratedBC::computeResidual()
      83             : {
      84       48740 :   prepareVectorTag(_assembly, _var.number());
      85             : 
      86      157140 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      87             :   {
      88      108400 :     initQpResidual();
      89      676304 :     for (_i = 0; _i < _test.size(); _i++)
      90             :     {
      91      567904 :       _work_vector.setZero();
      92      567904 :       computeQpResidual(_work_vector);
      93             :       mooseAssert(_work_vector.size() == _count,
      94             :                   "Size of local residual is not equal to the number of array variable compoments");
      95      567904 :       _work_vector *= _JxW[_qp] * _coord[_qp];
      96      567904 :       _assembly.saveLocalArrayResidual(_local_re, _i, _test.size(), _work_vector);
      97             :     }
      98             :   }
      99             : 
     100       48740 :   accumulateTaggedLocalResidual();
     101             : 
     102       48740 :   if (_has_save_in)
     103             :   {
     104          96 :     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     105         192 :     for (const auto & var : _save_in)
     106             :     {
     107          96 :       auto * avar = dynamic_cast<ArrayMooseVariable *>(var);
     108          96 :       if (avar)
     109          96 :         avar->addSolution(_local_re);
     110             :       else
     111           0 :         mooseError("Save-in variable for an array kernel must be an array variable");
     112             :     }
     113          96 :   }
     114       48740 : }
     115             : 
     116             : void
     117        7040 : ArrayIntegratedBC::computeJacobian()
     118             : {
     119        7040 :   prepareMatrixTag(_assembly, _var.number(), _var.number());
     120             : 
     121       21504 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     122             :   {
     123       14464 :     initQpJacobian();
     124       76928 :     for (_i = 0; _i < _test.size(); _i++)
     125      358400 :       for (_j = 0; _j < _phi.size(); _j++)
     126             :       {
     127      295936 :         RealEigenVector v = _JxW[_qp] * _coord[_qp] * computeQpJacobian();
     128     1183744 :         _assembly.saveDiagLocalArrayJacobian(
     129      295936 :             _local_ke, _i, _test.size(), _j, _phi.size(), _var.number(), v);
     130      295936 :       }
     131             :   }
     132             : 
     133        7040 :   accumulateTaggedLocalMatrix();
     134             : 
     135        7040 :   if (_has_diag_save_in)
     136             :   {
     137           0 :     DenseVector<Number> diag = _assembly.getJacobianDiagonal(_local_ke);
     138           0 :     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     139           0 :     for (const auto & var : _diag_save_in)
     140             :     {
     141           0 :       auto * avar = dynamic_cast<ArrayMooseVariable *>(var);
     142           0 :       if (avar)
     143           0 :         avar->addSolution(diag);
     144             :       else
     145           0 :         mooseError("Save-in variable for an array kernel must be an array variable");
     146             :     }
     147           0 :   }
     148        7040 : }
     149             : 
     150             : RealEigenVector
     151      522240 : ArrayIntegratedBC::computeQpJacobian()
     152             : {
     153     1044480 :   return RealEigenVector::Zero(_var.count());
     154             : }
     155             : 
     156             : void
     157        2192 : ArrayIntegratedBC::computeOffDiagJacobian(const unsigned int jvar_num)
     158             : {
     159        2192 :   const auto & jvar = getVariable(jvar_num);
     160             : 
     161        2192 :   bool same_var = jvar_num == _var.number();
     162             : 
     163        2192 :   prepareMatrixTag(_assembly, _var.number(), jvar_num);
     164             : 
     165             :   // This (undisplaced) jvar could potentially yield the wrong phi size if this object is acting on
     166             :   // the displaced mesh
     167        2192 :   auto phi_size = jvar.dofIndices().size();
     168             : 
     169        9744 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     170             :   {
     171        7552 :     initQpOffDiagJacobian(jvar);
     172       77408 :     for (_i = 0; _i < _test.size(); _i++)
     173      543104 :       for (_j = 0; _j < phi_size; _j++)
     174             :       {
     175      473248 :         RealEigenMatrix v = _JxW[_qp] * _coord[_qp] * computeQpOffDiagJacobian(jvar);
     176     1419744 :         _assembly.saveFullLocalArrayJacobian(
     177      473248 :             _local_ke, _i, _test.size(), _j, jvar.phiSize(), _var.number(), jvar_num, v);
     178      473248 :       }
     179             :   }
     180             : 
     181        2192 :   accumulateTaggedLocalMatrix();
     182             : 
     183        2192 :   if (_has_diag_save_in && same_var)
     184             :   {
     185          64 :     DenseVector<Number> diag = _assembly.getJacobianDiagonal(_local_ke);
     186          64 :     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     187         128 :     for (const auto & var : _diag_save_in)
     188             :     {
     189          64 :       auto * avar = dynamic_cast<ArrayMooseVariable *>(var);
     190          64 :       if (avar)
     191          64 :         avar->addSolution(diag);
     192             :       else
     193           0 :         mooseError("Save-in variable for an array kernel must be an array variable");
     194             :     }
     195          64 :   }
     196        2192 : }
     197             : 
     198             : RealEigenMatrix
     199      473248 : ArrayIntegratedBC::computeQpOffDiagJacobian(const MooseVariableFEBase & jvar)
     200             : {
     201      473248 :   if (jvar.number() == _var.number())
     202      946496 :     return computeQpJacobian().asDiagonal();
     203             :   else
     204           0 :     return RealEigenMatrix::Zero(_var.count(), jvar.count());
     205             : }
     206             : 
     207             : void
     208           0 : ArrayIntegratedBC::computeOffDiagJacobianScalar(unsigned int jvar)
     209             : {
     210           0 :   prepareMatrixTag(_assembly, _var.number(), jvar);
     211             : 
     212           0 :   const MooseVariableScalar & jv = _sys.getScalarVariable(_tid, jvar);
     213           0 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     214           0 :     for (_i = 0; _i < _test.size(); _i++)
     215             :     {
     216           0 :       RealEigenMatrix v = _JxW[_qp] * _coord[_qp] * computeQpOffDiagJacobianScalar(jv);
     217           0 :       _assembly.saveFullLocalArrayJacobian(
     218           0 :           _local_ke, _i, _test.size(), 0, 1, _var.number(), jvar, v);
     219           0 :     }
     220             : 
     221           0 :   accumulateTaggedLocalMatrix();
     222           0 : }
     223             : 
     224             : RealEigenMatrix
     225           0 : ArrayIntegratedBC::computeQpOffDiagJacobianScalar(const MooseVariableScalar & jvar)
     226             : {
     227           0 :   return RealEigenMatrix::Zero(_var.count(), (unsigned int)jvar.order() + 1);
     228             : }