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 "ComputeNodalAuxVarsThread.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "AuxiliarySystem.h"
      14             : #include "AuxKernel.h"
      15             : #include "FEProblem.h"
      16             : #include "MooseMesh.h"
      17             : 
      18             : #include "libmesh/threads.h"
      19             : 
      20             : template <typename AuxKernelType>
      21             : Threads::spin_mutex ComputeNodalAuxVarsThread<AuxKernelType>::writable_variable_mutex;
      22             : 
      23             : template <typename AuxKernelType>
      24      146860 : ComputeNodalAuxVarsThread<AuxKernelType>::ComputeNodalAuxVarsThread(
      25             :     FEProblemBase & fe_problem, const MooseObjectWarehouse<AuxKernelType> & storage)
      26             :   : ThreadedNodeLoop<ConstNodeRange, ConstNodeRange::const_iterator>(fe_problem),
      27      293720 :     _aux_sys(fe_problem.getAuxiliarySystem()),
      28      146860 :     _storage(storage)
      29             : {
      30      146860 : }
      31             : 
      32             : // Splitting Constructor
      33             : template <typename AuxKernelType>
      34       12694 : ComputeNodalAuxVarsThread<AuxKernelType>::ComputeNodalAuxVarsThread(ComputeNodalAuxVarsThread & x,
      35             :                                                                     Threads::split split)
      36             :   : ThreadedNodeLoop<ConstNodeRange, ConstNodeRange::const_iterator>(x, split),
      37       12694 :     _aux_sys(x._aux_sys),
      38       12694 :     _storage(x._storage)
      39             : {
      40       12694 : }
      41             : 
      42             : template <typename AuxKernelType>
      43             : void
      44      361128 : ComputeNodalAuxVarsThread<AuxKernelType>::subdomainChanged()
      45             : {
      46      361128 :   std::set<TagID> needed_vector_tags;
      47      361128 :   std::set<TagID> needed_matrix_tags;
      48             : 
      49      361128 :   const auto & block_kernels = _storage.getActiveBlockObjects(_tid);
      50             : 
      51      805506 :   for (const auto & block : _block_ids)
      52             :   {
      53      444378 :     const auto iter = block_kernels.find(block);
      54             : 
      55      444378 :     if (iter != block_kernels.end())
      56      868080 :       for (const auto & aux : iter->second)
      57             :       {
      58      495053 :         auto & matrix_tags = aux->getFEVariableCoupleableMatrixTags();
      59      495053 :         needed_matrix_tags.insert(matrix_tags.begin(), matrix_tags.end());
      60      495053 :         auto & vector_tags = aux->getFEVariableCoupleableVectorTags();
      61      495053 :         needed_vector_tags.insert(vector_tags.begin(), vector_tags.end());
      62             :       }
      63             :   }
      64             : 
      65      361128 :   _fe_problem.setActiveFEVariableCoupleableMatrixTags(needed_matrix_tags, _tid);
      66      361128 :   _fe_problem.setActiveFEVariableCoupleableVectorTags(needed_vector_tags, _tid);
      67      361128 : }
      68             : 
      69             : template <typename AuxKernelType>
      70             : void
      71    25291751 : ComputeNodalAuxVarsThread<AuxKernelType>::onNode(ConstNodeRange::const_iterator & node_it)
      72             : {
      73    25291751 :   const Node * node = *node_it;
      74             : 
      75    25291751 :   const auto & block_ids = _aux_sys.mesh().getNodeBlockIds(*node);
      76             : 
      77    25291751 :   if (_block_ids != block_ids)
      78             :   {
      79      361128 :     _block_ids.clear();
      80      361128 :     _block_ids.insert(block_ids.begin(), block_ids.end());
      81      361128 :     subdomainChanged();
      82             :   }
      83             : 
      84    25291751 :   _fe_problem.reinitNode(node, _tid);
      85             : 
      86             :   // Get a map of all active block restricted AuxKernel objects
      87    25291751 :   const auto & block_kernels = _storage.getActiveBlockObjects(_tid);
      88             : 
      89             :   // Loop over all SubdomainIDs for the current node, if an AuxKernel is active on this block then
      90             :   // compute it.
      91    50706090 :   for (const auto & block : block_ids)
      92             :   {
      93    25414343 :     const auto iter = block_kernels.find(block);
      94             : 
      95    25414343 :     if (iter != block_kernels.end())
      96    44746976 :       for (const auto & aux : iter->second)
      97             :       {
      98    25498007 :         aux->compute();
      99             :         // This is the same conditional check that the aux kernel performs internally before calling
     100             :         // computeValue and _var.setNodalValue. We don't want to attempt to insert into the solution
     101             :         // if we don't actually have any dofs on this node
     102    25498003 :         if (aux->variable().isNodalDefined())
     103    22771846 :           aux->variable().insert(_aux_sys.solution());
     104             : 
     105             :         // update the aux solution vector if writable coupled variables are used
     106    25498003 :         if (aux->hasWritableCoupledVariables())
     107             :         {
     108        2430 :           for (auto * var : aux->getWritableCoupledVariables())
     109        1620 :             if (var->isNodalDefined())
     110             :               // insert into the global solution vector
     111        1620 :               var->insert(_aux_sys.solution());
     112             : 
     113             :           // make solution values available for dependent AuxKernels
     114         810 :           _fe_problem.reinitNode(node, _tid);
     115             :         }
     116             :       }
     117             :   }
     118    25291747 : }
     119             : 
     120             : template <typename AuxKernelType>
     121             : void
     122      159550 : ComputeNodalAuxVarsThread<AuxKernelType>::post()
     123             : {
     124      159550 :   _fe_problem.clearActiveFEVariableCoupleableVectorTags(_tid);
     125      159550 :   _fe_problem.clearActiveFEVariableCoupleableMatrixTags(_tid);
     126      159550 : }
     127             : 
     128             : template <typename AuxKernelType>
     129             : void
     130       12694 : ComputeNodalAuxVarsThread<AuxKernelType>::join(const ComputeNodalAuxVarsThread & /*y*/)
     131             : {
     132       12694 : }
     133             : 
     134             : template <typename AuxKernelType>
     135             : void
     136      159554 : ComputeNodalAuxVarsThread<AuxKernelType>::printGeneralExecutionInformation() const
     137             : {
     138      159554 :   if (!_fe_problem.shouldPrintExecution(_tid) || !_storage.hasActiveObjects())
     139      159048 :     return;
     140             : 
     141         506 :   const auto & console = _fe_problem.console();
     142         506 :   const auto & execute_on = _fe_problem.getCurrentExecuteOnFlag();
     143         506 :   console << "[DBG] Beginning nodal loop of nodal auxiliary kernels on " << execute_on << std::endl;
     144         506 :   console << "[DBG] Ordering of the kernels on each block they are defined on:" << std::endl;
     145             :   // TODO Check that all objects are active at this point
     146         506 :   console << _storage.activeObjectsToFormattedString() << std::endl;
     147             : }
     148             : 
     149             : template class ComputeNodalAuxVarsThread<AuxKernel>;
     150             : template class ComputeNodalAuxVarsThread<VectorAuxKernel>;
     151             : template class ComputeNodalAuxVarsThread<ArrayAuxKernel>;