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       71910 : ArrayIntegratedBC::validParams()
      22             : {
      23       71910 :   InputParameters params = IntegratedBCBase::validParams();
      24       71910 :   return params;
      25             : }
      26             : 
      27         301 : 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         602 :     _var(*mooseVariable()),
      35         301 :     _normals(_assembly.normals()),
      36         301 :     _phi(_assembly.phiFace(_var)),
      37         301 :     _test(_var.phiFace()),
      38         301 :     _u(_is_implicit ? _var.sln() : _var.slnOld()),
      39         301 :     _count(_var.count()),
      40         602 :     _work_vector(_count)
      41             : {
      42         301 :   addMooseVariableDependency(mooseVariable());
      43             : 
      44         301 :   _save_in.resize(_save_in_strings.size());
      45         301 :   _diag_save_in.resize(_diag_save_in_strings.size());
      46             : 
      47         315 :   for (unsigned int i = 0; i < _save_in_strings.size(); i++)
      48             :   {
      49          14 :     ArrayMooseVariable * var = &_subproblem.getArrayVariable(_tid, _save_in_strings[i]);
      50             : 
      51          14 :     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          14 :     _save_in[i] = var;
      57          14 :     var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
      58          14 :     addMooseVariableDependency(var);
      59             :   }
      60             : 
      61         301 :   _has_save_in = _save_in.size() > 0;
      62             : 
      63         315 :   for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
      64             :   {
      65          14 :     ArrayMooseVariable * var = &_subproblem.getArrayVariable(_tid, _diag_save_in_strings[i]);
      66             : 
      67          14 :     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          14 :     _diag_save_in[i] = var;
      74          14 :     var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
      75          14 :     addMooseVariableDependency(var);
      76             :   }
      77             : 
      78         301 :   _has_diag_save_in = _diag_save_in.size() > 0;
      79         301 : }
      80             : 
      81             : void
      82       55920 : ArrayIntegratedBC::computeResidual()
      83             : {
      84       55920 :   prepareVectorTag(_assembly, _var.number());
      85             : 
      86      180048 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
      87             :   {
      88      124128 :     initQpResidual();
      89      771768 :     for (_i = 0; _i < _test.size(); _i++)
      90             :     {
      91      647640 :       _work_vector.setZero();
      92      647640 :       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      647640 :       _work_vector *= _JxW[_qp] * _coord[_qp];
      96      647640 :       _assembly.saveLocalArrayResidual(_local_re, _i, _test.size(), _work_vector);
      97             :     }
      98             :   }
      99             : 
     100       55920 :   accumulateTaggedLocalResidual();
     101             : 
     102       55920 :   if (_has_save_in)
     103             :   {
     104         108 :     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     105         216 :     for (const auto & var : _save_in)
     106             :     {
     107         108 :       auto * avar = dynamic_cast<ArrayMooseVariable *>(var);
     108         108 :       if (avar)
     109         108 :         avar->addSolution(_local_re);
     110             :       else
     111           0 :         mooseError("Save-in variable for an array kernel must be an array variable");
     112             :     }
     113         108 :   }
     114       55920 : }
     115             : 
     116             : void
     117        8110 : ArrayIntegratedBC::computeJacobian()
     118             : {
     119        8110 :   prepareMatrixTag(_assembly, _var.number(), _var.number());
     120             : 
     121       24762 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     122             :   {
     123       16652 :     initQpJacobian();
     124       88444 :     for (_i = 0; _i < _test.size(); _i++)
     125      410800 :       for (_j = 0; _j < _phi.size(); _j++)
     126             :       {
     127      339008 :         RealEigenVector v = _JxW[_qp] * _coord[_qp] * computeQpJacobian();
     128     1356032 :         _assembly.saveDiagLocalArrayJacobian(
     129      339008 :             _local_ke, _i, _test.size(), _j, _phi.size(), _var.number(), v);
     130      339008 :       }
     131             :   }
     132             : 
     133        8110 :   accumulateTaggedLocalMatrix();
     134             : 
     135        8110 :   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        8110 : }
     149             : 
     150             : RealEigenVector
     151      593600 : ArrayIntegratedBC::computeQpJacobian()
     152             : {
     153     1187200 :   return RealEigenVector::Zero(_var.count());
     154             : }
     155             : 
     156             : void
     157        2452 : ArrayIntegratedBC::computeOffDiagJacobian(const unsigned int jvar_num)
     158             : {
     159        2452 :   const auto & jvar = getVariable(jvar_num);
     160             : 
     161        2452 :   bool same_var = jvar_num == _var.number();
     162             : 
     163        2452 :   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        2452 :   auto phi_size = jvar.dofIndices().size();
     168             : 
     169       10920 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     170             :   {
     171        8468 :     initQpOffDiagJacobian(jvar);
     172       86944 :     for (_i = 0; _i < _test.size(); _i++)
     173      610432 :       for (_j = 0; _j < phi_size; _j++)
     174             :       {
     175      531956 :         RealEigenMatrix v = _JxW[_qp] * _coord[_qp] * computeQpOffDiagJacobian(jvar);
     176     1595868 :         _assembly.saveFullLocalArrayJacobian(
     177      531956 :             _local_ke, _i, _test.size(), _j, jvar.phiSize(), _var.number(), jvar_num, v);
     178      531956 :       }
     179             :   }
     180             : 
     181        2452 :   accumulateTaggedLocalMatrix();
     182             : 
     183        2452 :   if (_has_diag_save_in && same_var)
     184             :   {
     185          72 :     DenseVector<Number> diag = _assembly.getJacobianDiagonal(_local_ke);
     186          72 :     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     187         144 :     for (const auto & var : _diag_save_in)
     188             :     {
     189          72 :       auto * avar = dynamic_cast<ArrayMooseVariable *>(var);
     190          72 :       if (avar)
     191          72 :         avar->addSolution(diag);
     192             :       else
     193           0 :         mooseError("Save-in variable for an array kernel must be an array variable");
     194             :     }
     195          72 :   }
     196        2452 : }
     197             : 
     198             : RealEigenMatrix
     199      531956 : ArrayIntegratedBC::computeQpOffDiagJacobian(const MooseVariableFEBase & jvar)
     200             : {
     201      531956 :   if (jvar.number() == _var.number())
     202     1063912 :     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             : }