A class for storing MooseObjects based on execution flag. More...

#include <ExecuteMooseObjectWarehouse.h>

Inheritance diagram for ExecuteMooseObjectWarehouse< T >:

Public Member Functions
	ExecuteMooseObjectWarehouse (const ExecFlagEnum &flags, bool threaded=true)
	Constructor. More...

virtual	~ExecuteMooseObjectWarehouse ()

virtual void	addObject (std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true)
	Adds an object to the storage structure. More...

void	addObjectMask (std::shared_ptr< T > object, THREAD_ID tid=0, std::uint16_t flag_mask=std::numeric_limits< std::uint16_t >::max())

virtual void	updateActive (THREAD_ID tid=0)
	Updates the active objects storage. More...

void	sort (THREAD_ID tid=0)
	Performs a sort using the DependencyResolver. More...

unsigned int	size (THREAD_ID tid=0)
	Return how many kernels we store in the current warehouse. More...

std::set< SubdomainID >	getActiveBlocks (THREAD_ID tid=0) const
	Return a set of active SubdomainsIDs. More...

void	subdomainsCovered (std::set< SubdomainID > &subdomains_covered, std::set< std::string > &unique_variables, THREAD_ID tid=0) const
	Populates a set of covered subdomains and the associated variable names. More...

THREAD_ID	numThreads ()
	Return the number of threads. More...


const MooseObjectWarehouse< T > &	operator[] (ExecFlagType exec_flag) const
	Retrieve shared pointers for the given thread and execution type for all/active objects. More...

MooseObjectWarehouse< T > &	operator[] (ExecFlagType exec_flag)


std::map< ExecFlagType, MooseObjectWarehouse< T > >::const_iterator	begin () const
	Provide access to begin/end iterators of the underlying map of execution flags. More...

std::map< ExecFlagType, MooseObjectWarehouse< T > >::const_iterator	end () const


void	jacobianSetup (THREAD_ID tid=0) const
	Convenience methods for calling object setup methods. More...

void	residualSetup (THREAD_ID tid=0) const

void	setup (const ExecFlagType &exec_flag, THREAD_ID tid=0) const


virtual void	initialSetup (THREAD_ID tid=0) const
	Convenience methods for calling object setup methods. More...

virtual void	timestepSetup (THREAD_ID tid=0) const

virtual void	subdomainSetup (THREAD_ID tid=0) const

virtual void	subdomainSetup (SubdomainID id, THREAD_ID tid=0) const


bool	hasActiveVariableBlockObjects (unsigned int variable_id, SubdomainID block_id, THREAD_ID tid=0) const
	Methods for checking/getting variable kernels for a variable and SubdomainID. More...

const std::vector< std::shared_ptr< T > > &	getActiveVariableBlockObjects (unsigned int variable_id, SubdomainID block_id, THREAD_ID tid=0) const


const std::vector< std::shared_ptr< T > > &	getObjects (THREAD_ID tid=0) const
	Retrieve complete vector to the all/block/boundary restricted objects for a given thread. More...

const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > &	getBlockObjects (THREAD_ID tid=0) const

const std::vector< std::shared_ptr< T > > &	getBlockObjects (SubdomainID id, THREAD_ID tid=0) const

const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > &	getBoundaryObjects (THREAD_ID tid=0) const

const std::vector< std::shared_ptr< T > > &	getBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const


const std::vector< std::shared_ptr< T > > &	getActiveObjects (THREAD_ID tid=0) const
	Retrieve complete vector to the active all/block/boundary restricted objects for a given thread. More...

const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > &	getActiveBlockObjects (THREAD_ID tid=0) const

const std::vector< std::shared_ptr< T > > &	getActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const

const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > &	getActiveBoundaryObjects (THREAD_ID tid=0) const

const std::vector< std::shared_ptr< T > > &	getActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const


bool	hasActiveObjects (THREAD_ID tid=0) const
	Convenience functions for determining if objects exist. More...

bool	hasActiveBlockObjects (THREAD_ID tid=0) const

bool	hasActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const

bool	hasActiveBoundaryObjects (THREAD_ID tid=0) const

bool	hasActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const


bool	hasActiveObject (const std::string &name, THREAD_ID tid=0) const
	Convenience functions for checking/getting specific objects. More...

std::shared_ptr< T >	getActiveObject (const std::string &name, THREAD_ID tid=0) const


void	updateVariableDependency (std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const
	Update variable dependency vector. More...

void	updateBlockVariableDependency (SubdomainID id, std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const

void	updateBoundaryVariableDependency (std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const

void	updateBoundaryVariableDependency (BoundaryID id, std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const


void	updateMatPropDependency (std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
	Update material property dependency vector. More...

void	updateBlockMatPropDependency (SubdomainID id, std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const

void	updateBoundaryMatPropDependency (std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const

void	updateBoundaryMatPropDependency (BoundaryID id, std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const

Protected Member Functions
std::map< ExecFlagType, MooseObjectWarehouse< T > >::iterator	getStorageHelper (std::map< ExecFlagType, MooseObjectWarehouse< T >> &objects, ExecFlagType exec_flag) const
	A helper method for extracting objects from the various storage containers. More...

void	checkThreadID (THREAD_ID tid) const
	Calls assert on thread id. More...

Static Protected Member Functions
static void	updateActiveHelper (std::vector< std::shared_ptr< T >> &active, const std::vector< std::shared_ptr< T >> &all)
	Helper method for updating active vectors. More...

static void	sortHelper (std::vector< std::shared_ptr< T >> &objects)
	Helper method for sorting vectors of objects. More...

static void	updateVariableDependencyHelper (std::set< MooseVariableFEBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
	Helper method for updating variable dependency vector. More...

static void	updateMatPropDependencyHelper (std::set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< T >> &objects)
	Helper method for updating material property dependency vector. More...

Protected Attributes
std::map< ExecFlagType, MooseObjectWarehouse< T > >	_execute_objects

std::map< unsigned int, MooseObjectWarehouse< T > >	_variable_objects
	Variable based storage. More...

const THREAD_ID	_num_threads
	Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) More...

std::vector< std::vector< std::shared_ptr< T > > >	_all_objects
	Storage container for the ALL pointers (THREAD_ID on outer vector) More...

std::vector< std::vector< std::shared_ptr< T > > >	_active_objects
	All active objects (THREAD_ID on outer vector) More...

std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > >	_all_block_objects

std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > >	_active_block_objects
	Active block restricted objects (THREAD_ID on outer vector) More...

std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > >	_all_boundary_objects

std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > >	_active_boundary_objects
	Active boundary restricted objects (THREAD_ID on outer vector) More...

Detailed Description

template<typename T>
class ExecuteMooseObjectWarehouse< T >

A class for storing MooseObjects based on execution flag.

Note: The global list of objects, those accessed via the "get" methods of this class, are not sorted when the sort method is called. This is because cyclic errors occur even when the execution flags differ.

Definition at line 26 of file ExecuteMooseObjectWarehouse.h.

Constructor & Destructor Documentation

◆ ExecuteMooseObjectWarehouse()

template<typename T >

ExecuteMooseObjectWarehouse< T >::ExecuteMooseObjectWarehouse	(	const ExecFlagEnum &	flags,
		bool	threaded = `true`
	)

Constructor.

Parameters

threaded True enables threaded object storage (default).

Definition at line 107 of file ExecuteMooseObjectWarehouse.h.

   : MooseObjectWarehouse<T>(threaded)
 {
   // Initialize the active/all data structures with the correct map entries and empty vectors
   for (const auto & flag : flags.items())
     _execute_objects.insert(std::make_pair(flag, MooseObjectWarehouse<T>(threaded)));
 }

◆ ~ExecuteMooseObjectWarehouse()

template<typename T >

ExecuteMooseObjectWarehouse< T >::~ExecuteMooseObjectWarehouse ( )

virtual

Definition at line 117 of file ExecuteMooseObjectWarehouse.h.

118 {

119 }

Member Function Documentation

◆ addObject()

template<typename T>

void ExecuteMooseObjectWarehouse< T >::addObject	(	std::shared_ptr< T >	object,
		THREAD_ID	tid = `0`,
		bool	recurse = `true`
	)

virtual

Adds an object to the storage structure.

Parameters

object A shared pointer to the object being added

Reimplemented from MooseObjectWarehouse< T >.

Definition at line 203 of file ExecuteMooseObjectWarehouse.h.

Referenced by AuxiliarySystem::addKernel(), FEProblemBase::addMultiApp(), FEProblemBase::addSampler(), AuxiliarySystem::addScalarKernel(), FEProblemBase::addTransfer(), and FEProblemBase::addUserObject().

 {
   addObjectMask(object, tid, 0xFFFF);
 }

◆ addObjectMask()

template<typename T>

void ExecuteMooseObjectWarehouse< T >::addObjectMask	(	std::shared_ptr< T >	object,
		THREAD_ID	tid = `0`,
		std::uint16_t	flag_mask = `std::numeric_limits<std::uint16_t>::max()`
	)

Definition at line 212 of file ExecuteMooseObjectWarehouse.h.

 {
   // Update list of all objects
   MooseObjectWarehouse<T>::addObject(object, tid);
 
   // Update the execute flag lists of objects
   std::shared_ptr<SetupInterface> ptr = std::dynamic_pointer_cast<SetupInterface>(object);
   if (ptr)
   {
     MooseEnumIterator iter = ptr->getExecuteOnEnum().begin();
     for (; iter != ptr->getExecuteOnEnum().end(); ++iter)
     {
 
       auto masked_flag = static_cast<std::uint16_t>(iter->id()) & flag_mask;
       if (masked_flag != 0)
         _execute_objects[*iter].addObject(object, tid);
     }
   }
   else
     mooseError("The object being added (",
                object->name(),
                ") must inherit from SetupInterface to be added to the ExecuteMooseObjectWarehouse "
                "container.");
 }

◆ begin()

template<typename T>

std::map<ExecFlagType, MooseObjectWarehouse<T> >::const_iterator ExecuteMooseObjectWarehouse< T >::begin ( ) const

inline

Provide access to begin/end iterators of the underlying map of execution flags.

Definition at line 64 of file ExecuteMooseObjectWarehouse.h.

   {
     return _execute_objects.begin();
   }

◆ checkThreadID()

template<typename T>

void MooseObjectWarehouseBase< T >::checkThreadID ( THREAD_ID tid ) const

inlineprotectedinherited

Calls assert on thread id.

Definition at line 673 of file MooseObjectWarehouseBase.h.

 {
   mooseAssert(tid < _num_threads,
               "Attempting to access a thread id ("
                   << tid << ") greater than the number allowed by the storage item ("
                   << _num_threads << ")");
 }

◆ end()

template<typename T>

std::map<ExecFlagType, MooseObjectWarehouse<T> >::const_iterator ExecuteMooseObjectWarehouse< T >::end ( ) const

inline

Definition at line 68 of file ExecuteMooseObjectWarehouse.h.

   {
     return _execute_objects.end();
   }

◆ getActiveBlockObjects() [1/2]

template<typename T >

const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & MooseObjectWarehouseBase< T >::getActiveBlockObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Definition at line 386 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), ComputeFullJacobianThread::computeInternalFaceJacobian(), ComputeJacobianThread::computeInternalFaceJacobian(), ComputeJacobianThread::computeJacobian(), BlockRestrictable::hasBlockMaterialPropertyHelper(), ComputeMarkerThread::onElement(), ComputeElemAuxVarsThread::onElement(), ComputeIndicatorThread::onElement(), ComputeResidualThread::onElement(), ComputeMaterialsObjectThread::onElement(), ComputeIndicatorThread::onInternalSide(), ComputeResidualThread::onInternalSide(), ComputeNodalAuxVarsThread::onNode(), ComputeNodalKernelsThread::onNode(), ComputeNodalKernelJacobiansThread::onNode(), ComputeInitialConditionThread::operator()(), FEProblemBase::reinitMaterials(), ComputeElemAuxVarsThread::subdomainChanged(), and ComputeNodalAuxVarsThread::subdomainChanged().

 {
   checkThreadID(tid);
   return _active_block_objects[tid];
 }

◆ getActiveBlockObjects() [2/2]

template<typename T >

const std::vector< std::shared_ptr< T > > & MooseObjectWarehouseBase< T >::getActiveBlockObjects	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 394 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _active_block_objects[tid].find(id);
   mooseAssert(iter != _active_block_objects[tid].end(),
               "Unable to located active block objects for the given id: " << id << ".");
   return iter->second;
 }

◆ getActiveBlocks()

template<typename T >

std::set< SubdomainID > MooseObjectWarehouseBase< T >::getActiveBlocks ( THREAD_ID tid = 0 ) const

inherited

Return a set of active SubdomainsIDs.

Definition at line 475 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::checkProblemIntegrity().

 {
   checkThreadID(tid);
   std::set<SubdomainID> ids;
   for (const auto & object_pair : _active_block_objects[tid])
     ids.insert(object_pair.first);
   return ids;
 }

◆ getActiveBoundaryObjects() [1/2]

template<typename T >

const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & MooseObjectWarehouseBase< T >::getActiveBoundaryObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Definition at line 367 of file MooseObjectWarehouseBase.h.

Referenced by ComputeFullJacobianThread::computeFaceJacobian(), ComputeJacobianThread::computeFaceJacobian(), ComputeFullJacobianThread::computeInternalInterFaceJacobian(), ComputeJacobianThread::computeInternalInterFaceJacobian(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), ComputeResidualThread::onBoundary(), ComputeMaterialsObjectThread::onBoundary(), ComputeResidualThread::onInterface(), ComputeBoundaryInitialConditionThread::onNode(), ComputeNodalAuxBcsThread::onNode(), ComputeNodalKernelBcsThread::onNode(), ComputeNodalKernelBCJacobiansThread::onNode(), ComputeElemAuxBcsThread::operator()(), FEProblemBase::reinitMaterialsBoundary(), and NonlinearSystemBase::setInitialSolution().

 {
   checkThreadID(tid);
   return _active_boundary_objects[tid];
 }

◆ getActiveBoundaryObjects() [2/2]

template<typename T >

const std::vector< std::shared_ptr< T > > & MooseObjectWarehouseBase< T >::getActiveBoundaryObjects	(	BoundaryID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 375 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _active_boundary_objects[tid].find(id);
   mooseAssert(iter != _active_boundary_objects[tid].end(),
               "Unable to located active boundary objects for the given id: " << id << ".");
   return iter->second;
 }

◆ getActiveObject()

template<typename T >

std::shared_ptr< T > MooseObjectWarehouseBase< T >::getActiveObject	(	const std::string &	name,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 464 of file MooseObjectWarehouseBase.h.

Referenced by DerivativeParsedMaterialHelper::assembleDerivatives(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getMaterial(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), and NonlinearSystemBase::getSplit().

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     if (object->name() == name)
       return object;
   mooseError("Unable to locate active object: ", name, ".");
 }

◆ getActiveObjects()

template<typename T >

const std::vector< std::shared_ptr< T > > & MooseObjectWarehouseBase< T >::getActiveObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Retrieve complete vector to the active all/block/boundary restricted objects for a given thread.

Parameters

tid	The thread id to retrieve objects from

Definition at line 359 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::backupMultiApps(), NonlinearEigenSystem::checkIntegrity(), FEProblemBase::checkProblemIntegrity(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeDiracContributions(), FEProblemBase::computeIndicators(), FEProblemBase::computeMarkers(), FEProblemBase::computeMultiAppsDT(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScalarKernelsJacobians(), AuxiliarySystem::computeScalarVars(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), FEProblemBase::executeSamplers(), FEProblemBase::finishMultiAppStep(), ConstraintWarehouse::getActiveNodalConstraints(), AuxiliarySystem::getDependObjects(), MooseObjectTagWarehouse< InterfaceKernel >::getMatrixTagObjectWarehouse(), MooseObjectTagWarehouse< InterfaceKernel >::getMatrixTagsObjectWarehouse(), FEProblemBase::getTransfers(), MooseObjectTagWarehouse< InterfaceKernel >::getVectorTagObjectWarehouse(), MooseObjectTagWarehouse< InterfaceKernel >::getVectorTagsObjectWarehouse(), FEProblemBase::incrementMultiAppTStep(), ComputeElemDampingThread::onElement(), ComputeDiracThread::onElement(), ComputeNodalDampingThread::onNode(), FEProblemBase::postExecute(), FEProblemBase::projectSolution(), FEProblemBase::restoreMultiApps(), and AuxiliarySystem::setScalarVariableCoupleableTags().

 {
   checkThreadID(tid);
   return _active_objects[tid];
 }

◆ getActiveVariableBlockObjects()

template<typename T >

const std::vector< std::shared_ptr< T > > & MooseObjectWarehouse< T >::getActiveVariableBlockObjects	(	unsigned int	variable_id,
		SubdomainID	block_id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 128 of file MooseObjectWarehouse.h.

Referenced by ComputeFullJacobianThread::computeJacobian().

 {
   checkThreadID(tid);
   const auto iter = _variable_objects.find(variable_id);
   mooseAssert(iter != _variable_objects.end(),
               "Unable to locate variable kernels for the given variable id: " << variable_id
                                                                               << ".");
   return iter->second.getActiveBlockObjects(block_id, tid);
 }

◆ getBlockObjects() [1/2]

template<typename T >

const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & MooseObjectWarehouseBase< T >::getBlockObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Definition at line 340 of file MooseObjectWarehouseBase.h.

Referenced by MaterialPropertyDebugOutput::printMaterialMap().

 {
   checkThreadID(tid);
   return _all_block_objects[tid];
 }

◆ getBlockObjects() [2/2]

template<typename T >

const std::vector< std::shared_ptr< T > > & MooseObjectWarehouseBase< T >::getBlockObjects	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 348 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _all_block_objects[tid].find(id);
   mooseAssert(iter != _all_block_objects[tid].end(),
               "Unable to located active block objects for the given id: " << id << ".");
   return iter->second;
 }

◆ getBoundaryObjects() [1/2]

template<typename T >

const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & MooseObjectWarehouseBase< T >::getBoundaryObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Definition at line 321 of file MooseObjectWarehouseBase.h.

Referenced by ComputeFullJacobianThread::computeFaceJacobian(), and MaterialPropertyDebugOutput::printMaterialMap().

 {
   checkThreadID(tid);
   return _all_boundary_objects[tid];
 }

◆ getBoundaryObjects() [2/2]

template<typename T >

const std::vector< std::shared_ptr< T > > & MooseObjectWarehouseBase< T >::getBoundaryObjects	(	BoundaryID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 329 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _all_boundary_objects[tid].find(id);
   mooseAssert(iter != _all_boundary_objects[tid].end(),
               "Unable to located active boundary objects for the given id: " << id << ".");
   return iter->second;
 }

◆ getObjects()

template<typename T >

const std::vector< std::shared_ptr< T > > & MooseObjectWarehouseBase< T >::getObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Retrieve complete vector to the all/block/boundary restricted objects for a given thread.

Parameters

tid	The thread id to retrieve objects from

Definition at line 313 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearEigenSystem::addEigenTagToMooseObjects(), FEProblemBase::checkNonlocalCoupling(), and FEProblemBase::setNonlocalCouplingMatrix().

 {
   checkThreadID(tid);
   return _all_objects[tid];
 }

◆ getStorageHelper()

template<typename T>

std::map<ExecFlagType, MooseObjectWarehouse<T> >::iterator ExecuteMooseObjectWarehouse< T >::getStorageHelper	(	std::map< ExecFlagType, MooseObjectWarehouse< T >> &	objects,
		ExecFlagType	exec_flag
	)		const

protected

A helper method for extracting objects from the various storage containers.

◆ hasActiveBlockObjects() [1/2]

template<typename T >

bool MooseObjectWarehouseBase< T >::hasActiveBlockObjects ( THREAD_ID tid = 0 ) const

inherited

Definition at line 413 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearSystemBase::checkKernelCoverage(), AuxiliarySystem::computeElementalVars(), ComputeFullJacobianThread::computeInternalFaceJacobian(), ComputeJacobianThread::computeJacobian(), NonlinearSystemBase::computeJacobianInternal(), AuxiliarySystem::computeNodalVars(), NonlinearSystemBase::computeResidualInternal(), BlockRestrictable::hasBlockMaterialPropertyHelper(), ComputeMarkerThread::onElement(), ComputeElemAuxVarsThread::onElement(), ComputeIndicatorThread::onElement(), ComputeResidualThread::onElement(), ComputeMaterialsObjectThread::onElement(), ComputeJacobianThread::onInternalSide(), ComputeIndicatorThread::onInternalSide(), ComputeResidualThread::onInternalSide(), ComputeNodalKernelsThread::onNode(), ComputeNodalKernelJacobiansThread::onNode(), ComputeInitialConditionThread::operator()(), FEProblemBase::prepareMaterials(), FEProblemBase::reinitMaterials(), and ComputeElemAuxVarsThread::subdomainChanged().

 {
   checkThreadID(tid);
   bool has_active_block_objects = false;
   for (const auto & object_pair : _active_block_objects[tid])
     has_active_block_objects |= !(object_pair.second.empty());
   return has_active_block_objects;
 }

◆ hasActiveBlockObjects() [2/2]

template<typename T >

bool MooseObjectWarehouseBase< T >::hasActiveBlockObjects	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 424 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _active_block_objects[tid].find(id);
   return iter != _active_block_objects[tid].end();
 }

◆ hasActiveBoundaryObjects() [1/2]

template<typename T >

bool MooseObjectWarehouseBase< T >::hasActiveBoundaryObjects ( THREAD_ID tid = 0 ) const

inherited

Definition at line 433 of file MooseObjectWarehouseBase.h.

Referenced by AuxiliarySystem::computeElementalVars(), ComputeFullJacobianThread::computeFaceJacobian(), ComputeFullJacobianThread::computeInternalInterFaceJacobian(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), AuxiliarySystem::computeNodalVars(), NonlinearSystemBase::computeResidualInternal(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), NonlinearSystemBase::needBoundaryMaterialOnSide(), AuxiliarySystem::needMaterialOnSide(), ComputeJacobianThread::onBoundary(), ComputeResidualThread::onBoundary(), ComputeMaterialsObjectThread::onBoundary(), ComputeJacobianThread::onInterface(), ComputeResidualThread::onInterface(), ComputeBoundaryInitialConditionThread::onNode(), ComputeNodalKernelBcsThread::onNode(), ComputeNodalKernelBCJacobiansThread::onNode(), FEProblemBase::reinitMaterialsBoundary(), and NonlinearSystemBase::setInitialSolution().

 {
   checkThreadID(tid);
   bool has_active_boundary_objects = false;
   for (const auto & object_pair : _active_boundary_objects[tid])
     has_active_boundary_objects |= !(object_pair.second.empty());
   return has_active_boundary_objects;
 }

◆ hasActiveBoundaryObjects() [2/2]

template<typename T >

bool MooseObjectWarehouseBase< T >::hasActiveBoundaryObjects	(	BoundaryID	id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 444 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   const auto iter = _active_boundary_objects[tid].find(id);
   return iter != _active_boundary_objects[tid].end();
 }

◆ hasActiveObject()

template<typename T >

bool MooseObjectWarehouseBase< T >::hasActiveObject	(	const std::string &	name,
		THREAD_ID	tid = `0`
	)		const

inherited

Convenience functions for checking/getting specific objects.

Definition at line 453 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::getDistribution(), FEProblemBase::getSampler(), FEProblemBase::hasFunction(), and FEProblemBase::hasMultiApp().

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     if (object->name() == name)
       return true;
   return false;
 }

◆ hasActiveObjects()

template<typename T >

bool MooseObjectWarehouseBase< T >::hasActiveObjects ( THREAD_ID tid = 0 ) const

inherited

Convenience functions for determining if objects exist.

Definition at line 405 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearEigenSystem::checkIntegrity(), NonlinearSystemBase::checkKernelCoverage(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeDiracContributions(), FEProblemBase::computeIndicators(), FEProblemBase::computeMarkers(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScalarKernelsJacobians(), AuxiliarySystem::computeScalarVars(), NonlinearSystemBase::containsTimeKernel(), FEProblemBase::execMultiAppTransfers(), ConstraintWarehouse::hasActiveNodalConstraints(), FEProblemBase::hasMultiApps(), FEProblemBase::initialSetup(), FEProblemBase::projectSolution(), and FEProblemBase::timestepSetup().

 {
   checkThreadID(tid);
   return !_active_objects[tid].empty();
 }

◆ hasActiveVariableBlockObjects()

template<typename T >

bool MooseObjectWarehouse< T >::hasActiveVariableBlockObjects	(	unsigned int	variable_id,
		SubdomainID	block_id,
		THREAD_ID	tid = `0`
	)		const

inherited

Methods for checking/getting variable kernels for a variable and SubdomainID.

Definition at line 118 of file MooseObjectWarehouse.h.

Referenced by ComputeFullJacobianThread::computeJacobian().

 {
   auto iter = _variable_objects.find(variable_id);
   return (iter != _variable_objects.end() && iter->second.hasActiveBlockObjects(block_id, tid));
 }

◆ initialSetup()

template<typename T >

void MooseObjectWarehouse< T >::initialSetup ( THREAD_ID tid = 0 ) const

virtualinherited

Convenience methods for calling object setup methods.

Reimplemented in MaterialWarehouse.

Definition at line 142 of file MooseObjectWarehouse.h.

Referenced by MaterialWarehouse::initialSetup(), AuxiliarySystem::initialSetup(), NonlinearSystemBase::initialSetup(), and FEProblemBase::initialSetup().

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->initialSetup();
 }

◆ jacobianSetup()

template<typename T >

void ExecuteMooseObjectWarehouse< T >::jacobianSetup ( THREAD_ID tid = 0 ) const

virtual

Convenience methods for calling object setup methods.

Limits call to these methods only to objects being executed on linear/nonlinear iterations.

Reimplemented from MooseObjectWarehouse< T >.

Definition at line 166 of file ExecuteMooseObjectWarehouse.h.

Referenced by AuxiliarySystem::jacobianSetup().

 {
   checkThreadID(tid);
   const auto iter = _execute_objects.find(EXEC_NONLINEAR);
   if (iter != _execute_objects.end())
     iter->second.jacobianSetup(tid);
 }

◆ numThreads()

template<typename T>

THREAD_ID MooseObjectWarehouseBase< T >::numThreads ( )

inlineinherited

Return the number of threads.

Definition at line 161 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearEigenSystem::addEigenTagToMooseObjects().

161 { return _num_threads; }

MooseObjectWarehouseBase::_num_threads

const THREAD_ID _num_threads

Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) ...

Definition: MooseObjectWarehouseBase.h:165

◆ operator[]() [1/2]

template<typename T >

const MooseObjectWarehouse< T > & ExecuteMooseObjectWarehouse< T >::operator[] ( ExecFlagType exec_flag ) const

Retrieve shared pointers for the given thread and execution type for all/active objects.

Parameters

exec_flag The execution flag to retrieve objects from

Definition at line 123 of file ExecuteMooseObjectWarehouse.h.

 {
   // Use find to avoid accidental insertion
   const auto iter = _execute_objects.find(exec_flag);
 
   if (iter == _execute_objects.end())
     mooseError("Unable to locate the desired execute flag (",
                exec_flag,
                "), the supplied execution flag was likely "
                "not registered.");
 
   return iter->second;
 }

◆ operator[]() [2/2]

template<typename T >

MooseObjectWarehouse< T > & ExecuteMooseObjectWarehouse< T >::operator[] ( ExecFlagType exec_flag )

Definition at line 138 of file ExecuteMooseObjectWarehouse.h.

 {
   // Use find to avoid accidental insertion
   const auto iter = _execute_objects.find(exec_flag);
 
   if (iter == _execute_objects.end())
     mooseError("Unable to locate the desired execute flag (",
                exec_flag,
                "), the supplied execution flag was likely "
                "not registered.");
 
   return iter->second;
 }

◆ residualSetup()

template<typename T >

void ExecuteMooseObjectWarehouse< T >::residualSetup ( THREAD_ID tid = 0 ) const

virtual

Reimplemented from MooseObjectWarehouse< T >.

Definition at line 176 of file ExecuteMooseObjectWarehouse.h.

Referenced by AuxiliarySystem::residualSetup().

 {
   checkThreadID(tid);
   const auto iter = _execute_objects.find(EXEC_LINEAR);
   if (iter != _execute_objects.end())
     iter->second.residualSetup(tid);
 }

◆ setup()

template<typename T >

void ExecuteMooseObjectWarehouse< T >::setup	(	const ExecFlagType &	exec_flag,
		THREAD_ID	tid = `0`
	)		const

Definition at line 186 of file ExecuteMooseObjectWarehouse.h.

Referenced by FEProblemBase::executeControls(), and FEProblemBase::executeSamplers().

 {
   checkThreadID(tid);
   if (exec_flag == EXEC_INITIAL)
     initialSetup(tid);
   else if (exec_flag == EXEC_TIMESTEP_BEGIN)
     timestepSetup(tid);
   else if (exec_flag == EXEC_SUBDOMAIN)
     subdomainSetup(tid);
   else if (exec_flag == EXEC_NONLINEAR)
     jacobianSetup(tid);
   else if (exec_flag == EXEC_LINEAR)
     residualSetup(tid);
 }

◆ size()

template<typename T >

unsigned int MooseObjectWarehouseBase< T >::size ( THREAD_ID tid = 0 )

inherited

Return how many kernels we store in the current warehouse.

Definition at line 233 of file MooseObjectWarehouseBase.h.

 {
   checkThreadID(tid);
   return _all_objects[tid].size();
 }

◆ sort()

template<typename T >

void ExecuteMooseObjectWarehouse< T >::sort ( THREAD_ID tid = 0 )

Performs a sort using the DependencyResolver.

Parameters

tid	The thread id to access.

Definition at line 241 of file ExecuteMooseObjectWarehouse.h.

Referenced by AuxiliarySystem::initialSetup().

 {
   // Sort execute object storage
   for (auto & object_pair : _execute_objects)
     object_pair.second.sort(tid);
 }

◆ sortHelper()

template<typename T>

void MooseObjectWarehouseBase< T >::sortHelper ( std::vector< std::shared_ptr< T >> & objects )

staticprotectedinherited

Helper method for sorting vectors of objects.

Definition at line 653 of file MooseObjectWarehouseBase.h.

 {
   // Do nothing if the vector is empty
   if (objects.empty())
     return;
 
   try
   {
     // Sort based on dependencies
     DependencyResolverInterface::sort<std::shared_ptr<T>>(objects);
   }
   catch (CyclicDependencyException<std::shared_ptr<T>> & e)
   {
     DependencyResolverInterface::cyclicDependencyError<std::shared_ptr<T>>(
         e, "Cyclic dependency detected in object ordering");
   }
 }

◆ subdomainsCovered()

template<typename T >

void MooseObjectWarehouseBase< T >::subdomainsCovered	(	std::set< SubdomainID > &	subdomains_covered,
		std::set< std::string > &	unique_variables,
		THREAD_ID	tid = `0`
	)		const

inherited

Populates a set of covered subdomains and the associated variable names.

Definition at line 640 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearSystemBase::checkKernelCoverage().

 {
   for (const auto & object : _active_objects[tid])
     unique_variables.insert(object->variable().name());
 
   for (const auto & object_pair : _active_block_objects[tid])
     subdomains_covered.insert(object_pair.first);
 }

◆ subdomainSetup() [1/2]

template<typename T >

void MooseObjectWarehouse< T >::subdomainSetup ( THREAD_ID tid = 0 ) const

virtualinherited

Reimplemented in MaterialWarehouse.

Definition at line 173 of file MooseObjectWarehouse.h.

Referenced by MaterialWarehouse::neighborSubdomainSetup(), ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), MaterialWarehouse::subdomainSetup(), AuxiliarySystem::subdomainSetup(), and NonlinearSystemBase::subdomainSetup().

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->subdomainSetup();
 }

◆ subdomainSetup() [2/2]

template<typename T >

void MooseObjectWarehouse< T >::subdomainSetup	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

virtualinherited

Reimplemented in MaterialWarehouse.

Definition at line 160 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   if (hasActiveBlockObjects(id, tid))
   {
     const auto & objects = getActiveBlockObjects(id, tid);
     for (const auto & object : objects)
       object->subdomainSetup();
   }
 }

◆ timestepSetup()

template<typename T >

void MooseObjectWarehouse< T >::timestepSetup ( THREAD_ID tid = 0 ) const

virtualinherited

Reimplemented in MaterialWarehouse.

Definition at line 151 of file MooseObjectWarehouse.h.

Referenced by MaterialWarehouse::timestepSetup(), AuxiliarySystem::timestepSetup(), NonlinearSystemBase::timestepSetup(), and FEProblemBase::timestepSetup().

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->timestepSetup();
 }

◆ updateActive()

template<typename T >

void ExecuteMooseObjectWarehouse< T >::updateActive ( THREAD_ID tid = 0 )

virtual

Updates the active objects storage.

Reimplemented from MooseObjectWarehouse< T >.

Definition at line 154 of file ExecuteMooseObjectWarehouse.h.

Referenced by AuxiliarySystem::updateActive(), and FEProblemBase::updateActiveObjects().

 {
   // Update all objects active list
   MooseObjectWarehouse<T>::updateActive(tid);
 
   // Update the execute flag lists of objects
   for (auto & object_pair : _execute_objects)
     object_pair.second.updateActive(tid);
 }

◆ updateActiveHelper()

template<typename T>

void MooseObjectWarehouseBase< T >::updateActiveHelper	(	std::vector< std::shared_ptr< T >> &	active,
		const std::vector< std::shared_ptr< T >> &	all
	)

staticprotectedinherited

Helper method for updating active vectors.

Definition at line 501 of file MooseObjectWarehouseBase.h.

 {
   // Clear the active list
   active.clear();
 
   std::copy_if(all.begin(),
                all.end(),
                std::back_inserter(active),
                [](const std::shared_ptr<T> & object) { return object->enabled(); });
 }

◆ updateBlockMatPropDependency()

template<typename T >

void MooseObjectWarehouseBase< T >::updateBlockMatPropDependency	(	SubdomainID	id,
		std::set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 599 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::prepareMaterials(), ComputeJacobianThread::subdomainChanged(), and ComputeResidualThread::subdomainChanged().

 {
   if (hasActiveBlockObjects(id, tid))
     updateMatPropDependencyHelper(needed_mat_props, getActiveBlockObjects(id, tid));
 }

◆ updateBlockVariableDependency()

template<typename T >

void MooseObjectWarehouseBase< T >::updateBlockVariableDependency	(	SubdomainID	id,
		std::set< MooseVariableFEBase *> &	needed_moose_vars,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 542 of file MooseObjectWarehouseBase.h.

Referenced by ComputeJacobianThread::subdomainChanged(), and ComputeResidualThread::subdomainChanged().

 {
   if (hasActiveBlockObjects(id, tid))
     updateVariableDependencyHelper(needed_moose_vars, getActiveBlockObjects(id, tid));
 }

◆ updateBoundaryMatPropDependency() [1/2]

template<typename T >

void MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency	(	std::set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 609 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::prepareMaterials(), ComputeJacobianThread::subdomainChanged(), and ComputeResidualThread::subdomainChanged().

 {
   if (hasActiveBoundaryObjects(tid))
     for (auto & active_bnd_object : _active_boundary_objects[tid])
       updateMatPropDependencyHelper(needed_mat_props, active_bnd_object.second);
 }

◆ updateBoundaryMatPropDependency() [2/2]

template<typename T >

void MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency	(	BoundaryID	id,
		std::set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 619 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBoundaryObjects(id, tid))
     updateMatPropDependencyHelper(needed_mat_props, getActiveBoundaryObjects(id, tid));
 }

◆ updateBoundaryVariableDependency() [1/2]

template<typename T >

void MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency	(	std::set< MooseVariableFEBase *> &	needed_moose_vars,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 553 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::prepareMaterials(), ComputeJacobianThread::subdomainChanged(), and ComputeResidualThread::subdomainChanged().

 {
   if (hasActiveBoundaryObjects(tid))
   {
     typename std::map<BoundaryID, std::vector<std::shared_ptr<T>>>::const_iterator it;
     for (const auto & object_pair : _active_boundary_objects[tid])
       updateVariableDependencyHelper(needed_moose_vars, object_pair.second);
   }
 }

◆ updateBoundaryVariableDependency() [2/2]

template<typename T >

void MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency	(	BoundaryID	id,
		std::set< MooseVariableFEBase *> &	needed_moose_vars,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 566 of file MooseObjectWarehouseBase.h.

 {
   if (hasActiveBoundaryObjects(id, tid))
     updateVariableDependencyHelper(needed_moose_vars, getActiveBoundaryObjects(id, tid));
 }

◆ updateMatPropDependency()

template<typename T >

void MooseObjectWarehouseBase< T >::updateMatPropDependency	(	std::set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`
	)		const

inherited

Update material property dependency vector.

Definition at line 590 of file MooseObjectWarehouseBase.h.

Referenced by ComputeIndicatorThread::subdomainChanged(), and ComputeDiracThread::subdomainChanged().

 {
   if (hasActiveObjects(tid))
     updateMatPropDependencyHelper(needed_mat_props, _all_objects[tid]);
 }

◆ updateMatPropDependencyHelper()

template<typename T>

void MooseObjectWarehouseBase< T >::updateMatPropDependencyHelper	(	std::set< unsigned int > &	needed_mat_props,
		const std::vector< std::shared_ptr< T >> &	objects
	)

staticprotectedinherited

Helper method for updating material property dependency vector.

Definition at line 628 of file MooseObjectWarehouseBase.h.

 {
   for (auto & object : objects)
   {
     auto & mp_deps = object->getMatPropDependencies();
     needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
   }
 }

◆ updateVariableDependency()

template<typename T >

void MooseObjectWarehouseBase< T >::updateVariableDependency	(	std::set< MooseVariableFEBase *> &	needed_moose_vars,
		THREAD_ID	tid = `0`
	)		const

inherited

Update variable dependency vector.

Definition at line 533 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::prepareMaterials(), ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeDiracThread::subdomainChanged(), and ComputeMaterialsObjectThread::subdomainChanged().

 {
   if (hasActiveObjects(tid))
     updateVariableDependencyHelper(needed_moose_vars, _all_objects[tid]);
 }

◆ updateVariableDependencyHelper()

template<typename T>

void MooseObjectWarehouseBase< T >::updateVariableDependencyHelper	(	std::set< MooseVariableFEBase *> &	needed_moose_vars,
		const std::vector< std::shared_ptr< T >> &	objects
	)

staticprotectedinherited

Helper method for updating variable dependency vector.

Definition at line 577 of file MooseObjectWarehouseBase.h.

 {
   for (const auto & object : objects)
   {
     const auto & mv_deps = object->getMooseVariableDependencies();
     needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
   }
 }

Member Data Documentation

◆ _active_block_objects

template<typename T>

std::vector<std::map<SubdomainID, std::vector<std::shared_ptr<T> > > > MooseObjectWarehouseBase< T >::_active_block_objects

protectedinherited

Active block restricted objects (THREAD_ID on outer vector)

Definition at line 177 of file MooseObjectWarehouseBase.h.

◆ _active_boundary_objects

template<typename T>

std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<T> > > > MooseObjectWarehouseBase< T >::_active_boundary_objects

protectedinherited

Active boundary restricted objects (THREAD_ID on outer vector)

Definition at line 183 of file MooseObjectWarehouseBase.h.

◆ _active_objects

template<typename T>

std::vector<std::vector<std::shared_ptr<T> > > MooseObjectWarehouseBase< T >::_active_objects

protectedinherited

All active objects (THREAD_ID on outer vector)

Definition at line 171 of file MooseObjectWarehouseBase.h.

◆ _all_block_objects

template<typename T>

std::vector<std::map<SubdomainID, std::vector<std::shared_ptr<T> > > > MooseObjectWarehouseBase< T >::_all_block_objects

protectedinherited

Definition at line 174 of file MooseObjectWarehouseBase.h.

◆ _all_boundary_objects

template<typename T>

std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<T> > > > MooseObjectWarehouseBase< T >::_all_boundary_objects

protectedinherited

Definition at line 180 of file MooseObjectWarehouseBase.h.

◆ _all_objects

template<typename T>

std::vector<std::vector<std::shared_ptr<T> > > MooseObjectWarehouseBase< T >::_all_objects

protectedinherited

Storage container for the ALL pointers (THREAD_ID on outer vector)

Definition at line 168 of file MooseObjectWarehouseBase.h.

◆ _execute_objects

template<typename T>

std::map<ExecFlagType, MooseObjectWarehouse<T> > ExecuteMooseObjectWarehouse< T >::_execute_objects

protected

Definition at line 98 of file ExecuteMooseObjectWarehouse.h.

Referenced by ExecuteMooseObjectWarehouse< Transfer >::begin(), ExecuteMooseObjectWarehouse< Transfer >::end(), and ExecuteMooseObjectWarehouse< Transfer >::ExecuteMooseObjectWarehouse().

◆ _num_threads

template<typename T>

const THREAD_ID MooseObjectWarehouseBase< T >::_num_threads

protectedinherited

Convenience member storing the number of threads used for storage (1 or libMesh::n_threads)

Definition at line 165 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::numThreads().

◆ _variable_objects

template<typename T>

std::map<unsigned int, MooseObjectWarehouse<T> > MooseObjectWarehouse< T >::_variable_objects

protectedinherited

Variable based storage.

Definition at line 81 of file MooseObjectWarehouse.h.

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

include/warehouses/ExecuteMooseObjectWarehouse.h

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

template<typename T> class ExecuteMooseObjectWarehouse< T >

Constructor & Destructor Documentation

◆ ExecuteMooseObjectWarehouse()

◆ ~ExecuteMooseObjectWarehouse()

Member Function Documentation

◆ addObject()

◆ addObjectMask()

◆ begin()

◆ checkThreadID()

◆ end()

◆ getActiveBlockObjects() [1/2]

◆ getActiveBlockObjects() [2/2]

◆ getActiveBlocks()

◆ getActiveBoundaryObjects() [1/2]

◆ getActiveBoundaryObjects() [2/2]

◆ getActiveObject()

◆ getActiveObjects()

◆ getActiveVariableBlockObjects()

◆ getBlockObjects() [1/2]

◆ getBlockObjects() [2/2]

◆ getBoundaryObjects() [1/2]

◆ getBoundaryObjects() [2/2]

◆ getObjects()

◆ getStorageHelper()

◆ hasActiveBlockObjects() [1/2]

◆ hasActiveBlockObjects() [2/2]

◆ hasActiveBoundaryObjects() [1/2]

◆ hasActiveBoundaryObjects() [2/2]

◆ hasActiveObject()

◆ hasActiveObjects()

◆ hasActiveVariableBlockObjects()

◆ initialSetup()

◆ jacobianSetup()

◆ numThreads()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ residualSetup()

◆ setup()

◆ size()

◆ sort()

◆ sortHelper()

◆ subdomainsCovered()

◆ subdomainSetup() [1/2]

◆ subdomainSetup() [2/2]

◆ timestepSetup()

◆ updateActive()

◆ updateActiveHelper()

◆ updateBlockMatPropDependency()

◆ updateBlockVariableDependency()

◆ updateBoundaryMatPropDependency() [1/2]

◆ updateBoundaryMatPropDependency() [2/2]

◆ updateBoundaryVariableDependency() [1/2]

◆ updateBoundaryVariableDependency() [2/2]

◆ updateMatPropDependency()

◆ updateMatPropDependencyHelper()

◆ updateVariableDependency()

◆ updateVariableDependencyHelper()

Member Data Documentation

◆ _active_block_objects

◆ _active_boundary_objects

◆ _active_objects

◆ _all_block_objects

◆ _all_boundary_objects

◆ _all_objects

◆ _execute_objects

◆ _num_threads

◆ _variable_objects

template<typename T>
class ExecuteMooseObjectWarehouse< T >