ComputeNodalAuxVarsThread< AuxKernelType > Class Template Reference

#include <ComputeNodalAuxVarsThread.h>

Inheritance diagram for ComputeNodalAuxVarsThread< AuxKernelType >:

Public Member Functions
	ComputeNodalAuxVarsThread (FEProblemBase &fe_problem, const MooseObjectWarehouse< AuxKernelType > &storage)
	ComputeNodalAuxVarsThread (ComputeNodalAuxVarsThread &x, Threads::split split)
void	onNode (ConstNodeRange::const_iterator &nd) override
void	join (const ComputeNodalAuxVarsThread &)
void	subdomainChanged ()
void	post () override
	Called after the node range loop.
void	operator() (const ConstNodeRange &range)
virtual void	pre ()
	Called before the node range loop.
virtual void	onNode (ConstNodeRange::const_iterator &node_it)
	Called for each node.
virtual void	postNode (ConstNodeRange::const_iterator &node_it)
	Called after the node assembly is done (including surface assembling)
virtual void	caughtMooseException (MooseException &e)
	Called if a MooseException is caught anywhere during the computation.
virtual bool	keepGoing ()
	Whether or not the loop should continue.

Protected Member Functions
void	printGeneralExecutionInformation () const override
	Print information about the loop, mostly order of execution of objects.

Protected Attributes
AuxiliarySystem &	_aux_sys
const MooseObjectWarehouse< AuxKernelType > &	_storage
	Storage object containing active AuxKernel objects.
std::set< SubdomainID >	_block_ids
FEProblemBase &	_fe_problem
THREAD_ID	_tid

Static Protected Attributes
static Threads::spin_mutex	writable_variable_mutex

Detailed Description

template<typename AuxKernelType>
class ComputeNodalAuxVarsThread< AuxKernelType >

Definition at line 24 of file ComputeNodalAuxVarsThread.h.

Constructor & Destructor Documentation

ComputeNodalAuxVarsThread() [1/2]

template<typename AuxKernelType >

ComputeNodalAuxVarsThread< AuxKernelType >::ComputeNodalAuxVarsThread	(	FEProblemBase &	fe_problem,
		const MooseObjectWarehouse< AuxKernelType > &	storage
	)

Definition at line 24 of file ComputeNodalAuxVarsThread.C.

  : ThreadedNodeLoop<ConstNodeRange, ConstNodeRange::const_iterator>(fe_problem),
    _aux_sys(fe_problem.getAuxiliarySystem()),
    _storage(storage)
{
}

ComputeNodalAuxVarsThread() [2/2]

template<typename AuxKernelType >

ComputeNodalAuxVarsThread< AuxKernelType >::ComputeNodalAuxVarsThread	(	ComputeNodalAuxVarsThread< AuxKernelType > &	x,
		Threads::split	split
	)

Definition at line 34 of file ComputeNodalAuxVarsThread.C.

  : ThreadedNodeLoop<ConstNodeRange, ConstNodeRange::const_iterator>(x, split),
    _aux_sys(x._aux_sys),
    _storage(x._storage)
{
}

Member Function Documentation

caughtMooseException()

virtual void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::caughtMooseException ( MooseException &  e )

inlinevirtualinherited

Called if a MooseException is caught anywhere during the computation.

The single input parameter taken is a MooseException object.

Definition at line 56 of file ThreadedNodeLoop.h.

  {
    Threads::spin_mutex::scoped_lock lock(threaded_node_mutex);
 
    std::string what(e.what());
    _fe_problem.setException(what);
  };

join()

template<typename AuxKernelType >

void ComputeNodalAuxVarsThread< AuxKernelType >::join

(

const ComputeNodalAuxVarsThread< AuxKernelType > &

)

Definition at line 130 of file ComputeNodalAuxVarsThread.C.

{
}

keepGoing()

virtual bool ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::keepGoing ( )

inlinevirtualinherited

Whether or not the loop should continue.

Returns

true to keep going, false to stop.

Definition at line 69 of file ThreadedNodeLoop.h.

{ return !_fe_problem.hasException(); }

onNode() [1/2]

template<typename AuxKernelType >

void ComputeNodalAuxVarsThread< AuxKernelType >::onNode ( ConstNodeRange::const_iterator &  nd )

override

Definition at line 71 of file ComputeNodalAuxVarsThread.C.

{
  const Node * node = *node_it;
 
  const auto & block_ids = _aux_sys.mesh().getNodeBlockIds(*node);
 
  if (_block_ids != block_ids)
  {
    _block_ids.clear();
    _block_ids.insert(block_ids.begin(), block_ids.end());
    subdomainChanged();
  }
 
  _fe_problem.reinitNode(node, _tid);
 
  // Get a map of all active block restricted AuxKernel objects
  const auto & block_kernels = _storage.getActiveBlockObjects(_tid);
 
  // Loop over all SubdomainIDs for the current node, if an AuxKernel is active on this block then
  // compute it.
  for (const auto & block : block_ids)
  {
    const auto iter = block_kernels.find(block);
 
    if (iter != block_kernels.end())
      for (const auto & aux : iter->second)
      {
        aux->compute();
        // This is the same conditional check that the aux kernel performs internally before calling
        // computeValue and _var.setNodalValue. We don't want to attempt to insert into the solution
        // if we don't actually have any dofs on this node
        if (aux->variable().isNodalDefined())
          aux->variable().insert(_aux_sys.solution());
 
        // update the aux solution vector if writable coupled variables are used
        if (aux->hasWritableCoupledVariables())
        {
          for (auto * var : aux->getWritableCoupledVariables())
            if (var->isNodalDefined())
              // insert into the global solution vector
              var->insert(_aux_sys.solution());
 
          // make solution values available for dependent AuxKernels
          _fe_problem.reinitNode(node, _tid);
        }
      }
  }
}

onNode() [2/2]

void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::onNode ( ConstNodeRange::const_iterator &  node_it )

virtualinherited

Called for each node.

Definition at line 43 of file ThreadedNodeLoop.h.

{
}

operator()()

void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::operator() ( const ConstNodeRange &  range )

inherited

Definition at line 28 of file ThreadedNodeLoop.h.

{
  try
  {
    ParallelUniqueId puid;
    _tid = puid.id;
 
    pre();
    printGeneralExecutionInformation();
 
    for (IteratorType nd = range.begin(); nd != range.end(); ++nd)
    {
      if (!keepGoing())
        break;
 
      onNode(nd);
 
      postNode(nd);
    }
 
    post();
  }
  catch (MooseException & e)
  {
    caughtMooseException(e);
  }
}

post()

template<typename AuxKernelType >

void ComputeNodalAuxVarsThread< AuxKernelType >::post ( )

overridevirtual

Called after the node range loop.

Reimplemented from ThreadedNodeLoop< ConstNodeRange, ConstNodeRange::const_iterator >.

Definition at line 122 of file ComputeNodalAuxVarsThread.C.

{
  _fe_problem.clearActiveFEVariableCoupleableVectorTags(_tid);
  _fe_problem.clearActiveFEVariableCoupleableMatrixTags(_tid);
}

postNode()

void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::postNode ( ConstNodeRange::const_iterator &  node_it )

virtualinherited

Called after the node assembly is done (including surface assembling)

Parameters

node	- active node

Definition at line 50 of file ThreadedNodeLoop.h.

{
}

pre()

void ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::pre ( )

virtualinherited

Called before the node range loop.

Reimplemented in ComputeNodalKernelJacobiansThread, and ComputeNodalKernelsThread.

Definition at line 33 of file ThreadedNodeLoop.h.

{
}

printGeneralExecutionInformation()

template<typename AuxKernelType >

void ComputeNodalAuxVarsThread< AuxKernelType >::printGeneralExecutionInformation ( ) const

overrideprotectedvirtual

Print information about the loop, mostly order of execution of objects.

Reimplemented from ThreadedNodeLoop< ConstNodeRange, ConstNodeRange::const_iterator >.

Definition at line 136 of file ComputeNodalAuxVarsThread.C.

{
  if (!_fe_problem.shouldPrintExecution(_tid) || !_storage.hasActiveObjects())
    return;
 
  const auto & console = _fe_problem.console();
  const auto & execute_on = _fe_problem.getCurrentExecuteOnFlag();
  console << "[DBG] Beginning nodal loop of nodal " << MooseUtils::prettyCppType<AuxKernelType>()
          << " on " << execute_on << std::endl;
  console << "[DBG] Ordering of the kernels on each block they are defined on:" << std::endl;
  // TODO Check that all objects are active at this point
  console << _storage.activeObjectsToFormattedString() << std::endl;
}

subdomainChanged()

template<typename AuxKernelType >

void ComputeNodalAuxVarsThread< AuxKernelType >::subdomainChanged

(

)

Definition at line 44 of file ComputeNodalAuxVarsThread.C.

{
  std::set<TagID> needed_vector_tags;
  std::set<TagID> needed_matrix_tags;
 
  const auto & block_kernels = _storage.getActiveBlockObjects(_tid);
 
  for (const auto & block : _block_ids)
  {
    const auto iter = block_kernels.find(block);
 
    if (iter != block_kernels.end())
      for (const auto & aux : iter->second)
      {
        auto & matrix_tags = aux->getFEVariableCoupleableMatrixTags();
        needed_matrix_tags.insert(matrix_tags.begin(), matrix_tags.end());
        auto & vector_tags = aux->getFEVariableCoupleableVectorTags();
        needed_vector_tags.insert(vector_tags.begin(), vector_tags.end());
      }
  }
 
  _fe_problem.setActiveFEVariableCoupleableMatrixTags(needed_matrix_tags, _tid);
  _fe_problem.setActiveFEVariableCoupleableVectorTags(needed_vector_tags, _tid);
}

Member Data Documentation

_aux_sys

template<typename AuxKernelType >

AuxiliarySystem& ComputeNodalAuxVarsThread< AuxKernelType >::_aux_sys

protected

Definition at line 46 of file ComputeNodalAuxVarsThread.h.

_block_ids

template<typename AuxKernelType >

std::set<SubdomainID> ComputeNodalAuxVarsThread< AuxKernelType >::_block_ids

protected

Definition at line 51 of file ComputeNodalAuxVarsThread.h.

_fe_problem

FEProblemBase& ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::_fe_problem

protectedinherited

Definition at line 72 of file ThreadedNodeLoop.h.

_storage

template<typename AuxKernelType >

const MooseObjectWarehouse<AuxKernelType>& ComputeNodalAuxVarsThread< AuxKernelType >::_storage

protected

Storage object containing active AuxKernel objects.

Definition at line 49 of file ComputeNodalAuxVarsThread.h.

_tid

THREAD_ID ThreadedNodeLoop< ConstNodeRange , ConstNodeRange::const_iterator >::_tid

protectedinherited

Definition at line 73 of file ThreadedNodeLoop.h.

writable_variable_mutex

template<typename AuxKernelType >

Threads::spin_mutex ComputeNodalAuxVarsThread< AuxKernelType >::writable_variable_mutex

staticprotected

Definition at line 53 of file ComputeNodalAuxVarsThread.h.

---

The documentation for this class was generated from the following files:

• include/loops/ComputeNodalAuxVarsThread.h
• src/loops/ComputeNodalAuxVarsThread.C