MooseObjectWarehouse< T > Class Template Reference

A storage container for MooseObjects that inherit from SetupInterface. More...

#include <MooseObjectWarehouse.h>

Inheritance diagram for MooseObjectWarehouse< T >:

Public Member Functions
	MooseObjectWarehouse (THREAD_ID num_threads=libMesh::n_threads())
	Constructor.
virtual void	addObject (std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
	Adds an object to the storage structure.
bool	hasVariableObjects (unsigned int variable_id, THREAD_ID tid=0) const
	Checks for whether this warehouse has objects for a given variable.
virtual void	updateActive (THREAD_ID tid=0) override
	Update the active status of Kernels.
unsigned int	size (THREAD_ID tid=0) const
	Return how many kernels we store in the current warehouse.
bool	hasObjectsForVariableAndBlocks (const VariableName &var_name, const std::set< SubdomainID > &blocks, std::set< SubdomainID > &blocks_covered, THREAD_ID tid) const
	Whether there are objects for this variable and the set of blocks passed.
std::set< SubdomainID >	getActiveBlocks (THREAD_ID tid=0) const
	Return a set of active SubdomainsIDs.
const std::vector< std::shared_ptr< T > > &	getObjectsForVariable (const VariableName &var_name, THREAD_ID tid) const
	Getter for objects that have the 'variable' set to a particular variable Note that users should check whether there are objects using 'hasObjectsForVariable' before calling this routine, because it will throw if there are no objects for this variable.
void	sort (THREAD_ID tid=0)
	Sort the objects using the DependencyResolver.
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.
THREAD_ID	numThreads () const
	Return the number of threads.
std::string	activeObjectsToFormattedString (THREAD_ID tid=0, const std::string &prefix="[DBG]") const
	Output the active content of the warehouse to a string, meant to be output to the console.
virtual void	initialSetup (THREAD_ID tid=0) const
	Convenience methods for calling object setup methods.
virtual void	timestepSetup (THREAD_ID tid=0) const
virtual void	customSetup (const ExecFlagType &exec_type, THREAD_ID tid=0) const
virtual void	subdomainSetup (THREAD_ID tid=0) const
virtual void	subdomainSetup (SubdomainID id, THREAD_ID tid=0) const
virtual void	jacobianSetup (THREAD_ID tid=0) const
virtual void	residualSetup (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.
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.
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.
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	hasObjects (THREAD_ID tid=0) const
	Convenience functions for determining if objects exist.
bool	hasActiveObjects (THREAD_ID tid=0) const
bool	hasObjectsForVariable (const VariableName &var_name, THREAD_ID tid) const
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	hasBoundaryObjects (THREAD_ID tid=0) const
bool	hasBoundaryObjects (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.
std::shared_ptr< T >	getObject (const std::string &name, THREAD_ID tid=0) const
std::shared_ptr< T >	getActiveObject (const std::string &name, THREAD_ID tid=0) const
void	updateVariableDependency (std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
	Update variable dependency vector.
void	updateBlockVariableDependency (SubdomainID id, std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
void	updateBoundaryVariableDependency (std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
void	updateBoundaryVariableDependency (BoundaryID id, std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
void	updateFEVariableCoupledVectorTagDependency (std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
	Update FE variable coupleable vector tag vector for all objects, block-restricted objects, and boundary-restricted objects.
void	updateBlockFEVariableCoupledVectorTagDependency (SubdomainID id, std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
void	updateBoundaryFEVariableCoupledVectorTagDependency (BoundaryID id, std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
void	updateMatPropDependency (std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const
	Update material property dependency vector.
void	updateBlockMatPropDependency (SubdomainID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const
void	updateBoundaryMatPropDependency (std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const
void	updateBoundaryMatPropDependency (BoundaryID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const

Protected Member Functions
virtual void	updateMatPropDependencyHelper (std::unordered_set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< T > > &objects, const bool producer_only) const
	Helper method for updating material property dependency vector.
void	checkThreadID (THREAD_ID tid) const
	Calls assert on thread id.
bool	hasBoundaryObjectsHelper (const std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > &boundary_objects, const THREAD_ID tid=0) const
	Helper for determining whether we have boundary objects.

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.
static void	sortHelper (std::vector< std::shared_ptr< T > > &objects)
	Helper method for sorting vectors of objects.
static void	updateVariableDependencyHelper (std::set< MooseVariableFieldBase * > &needed_moose_vars, const std::vector< std::shared_ptr< T > > &objects)
	Helper method for updating variable dependency vector.
static void	updateFEVariableCoupledVectorTagDependencyHelper (std::set< TagID > &needed_fe_var_vector_tags, const std::vector< std::shared_ptr< T > > &objects)
	Helper method for updating FE variable coupleable vector tag vector.

Protected Attributes
std::map< unsigned int, MooseObjectWarehouse< T > >	_variable_objects
	Variable based storage.
const THREAD_ID	_num_threads
	Convenience member storing the number of threads used for storage (1 or libMesh::n_threads)
std::vector< std::vector< std::shared_ptr< T > > >	_all_objects
	Storage container for the ALL pointers (THREAD_ID on outer vector)
std::vector< std::vector< std::shared_ptr< T > > >	_active_objects
	All active objects (THREAD_ID on outer vector)
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)
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)
std::vector< std::map< VariableName, std::vector< std::shared_ptr< T > > > >	_all_variable_objects
	All objects with a certain variable selected, as the 'variable' parameter.

Detailed Description

template<typename T>
class MooseObjectWarehouse< T >

A storage container for MooseObjects that inherit from SetupInterface.

Objects that inherit from SetupInterface have various functions (e.g., initialSetup). This class provides convenience functions for looping over all active objects stored in the warehouse and calling the setup methods.

Definition at line 27 of file MooseObjectWarehouse.h.

Constructor & Destructor Documentation

MooseObjectWarehouse()

template<typename T >

MooseObjectWarehouse< T >::MooseObjectWarehouse

(

THREAD_ID

num_threads = libMesh::n_threads()

)

Constructor.

Definition at line 91 of file MooseObjectWarehouse.h.

  : MooseObjectWarehouseBase<T>(num_threads)
{
}

Member Function Documentation

activeObjectsToFormattedString()

template<typename T >

std::string MooseObjectWarehouseBase< T >::activeObjectsToFormattedString ( THREAD_ID  tid = 0, const std::string &  prefix = "[DBG]"  ) const

inherited

Output the active content of the warehouse to a string, meant to be output to the console.

Parameters

tid	the thread id
prefix	a string to prepend to the string

Definition at line 897 of file MooseObjectWarehouseBase.h.

{
  std::vector<std::string> output;
  for (const auto & object : _active_objects[tid])
    output.push_back(object->name());
  return ConsoleUtils::formatString(MooseUtils::join(output, " "), prefix);
}

Referenced by NonlinearThread::printBlockExecutionInformation(), NonlinearThread::printBoundaryExecutionInformation(), ComputeNodalKernelBCJacobiansThread::printGeneralExecutionInformation(), ComputeNodalKernelBcsThread::printGeneralExecutionInformation(), ComputeNodalKernelJacobiansThread::printGeneralExecutionInformation(), and ComputeNodalKernelsThread::printGeneralExecutionInformation().

addObject()

template<typename T >

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

overridevirtual

Adds an object to the storage structure.

Parameters

object	A shared pointer to the object being added
tid	The thread ID (default is 0)
recurse	Whether or not to build recusive warehouses (typically for Kernels)

Reimplemented from MooseObjectWarehouseBase< T >.

Reimplemented in ExecuteMooseObjectWarehouse< AuxKernelBase >, ExecuteMooseObjectWarehouse< AuxKernelTempl >, ExecuteMooseObjectWarehouse< AuxKernelTempl< Real > >, ExecuteMooseObjectWarehouse< AuxKernelTempl< RealVectorValue > >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< T >, ExecuteMooseObjectWarehouse< Transfer >, and ExecuteMooseObjectWarehouse< TransientMultiApp >.

Definition at line 98 of file MooseObjectWarehouse.h.

{
  MooseObjectWarehouseBase<T>::addObject(object, tid, recurse);
 
  if (recurse)
  {
    if (auto mvir = std::dynamic_pointer_cast<MooseVariableInterface<Real>>(object); mvir)
      _variable_objects[mvir->mooseVariableBase()->number()].addObject(object, tid, false);
    else if (auto mviv = std::dynamic_pointer_cast<MooseVariableInterface<RealVectorValue>>(object);
             mviv)
      _variable_objects[mviv->mooseVariableBase()->number()].addObject(object, tid, false);
    else if (auto mvie = std::dynamic_pointer_cast<MooseVariableInterface<RealEigenVector>>(object);
             mvie)
      _variable_objects[mvie->mooseVariableBase()->number()].addObject(object, tid, false);
    // Some objects, such as ScalarKernels, do not inherit from the MooseVariableInterface (which is
    // for field variables). These objects *do* inherit from ResidualObject which has this more
    // generic variable() API
    else if (auto ro = std::dynamic_pointer_cast<ResidualObject>(object); ro)
      _variable_objects[ro->variable().number()].addObject(object, tid, false);
  }
}

Referenced by NonlinearSystemBase::addBoundaryCondition(), FEProblemBase::addConvergence(), NonlinearSystemBase::addDamper(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addFunctorMaterial(), NonlinearSystemBase::addHDGKernel(), FEProblemBase::addIndicator(), NonlinearSystemBase::addInterfaceKernel(), MooseEigenSystem::addKernel(), NonlinearSystemBase::addKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), NonlinearSystemBase::addNodalKernel(), ConstraintWarehouse::addObject(), ExecuteMooseObjectWarehouse< T >::addObject(), MaterialWarehouse::addObjects(), NonlinearSystemBase::addScalarKernel(), and FEProblemBase::checkNonlocalCoupling().

checkThreadID()

template<typename T >

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

inlineprotectedinherited

Calls assert on thread id.

Definition at line 928 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 << ")");
}

Referenced by MooseObjectWarehouseBase< T >::addObject(), MooseObjectWarehouseBase< T >::getActiveBlockObjects(), MooseObjectWarehouseBase< T >::getActiveBlockObjects(), MooseObjectWarehouseBase< T >::getActiveBlocks(), MooseObjectWarehouseBase< T >::getActiveBoundaryObjects(), MooseObjectWarehouseBase< T >::getActiveBoundaryObjects(), MooseObjectWarehouseBase< T >::getActiveObject(), MooseObjectWarehouseBase< T >::getActiveObjects(), MooseObjectWarehouseBase< T >::getBlockObjects(), MooseObjectWarehouseBase< T >::getBlockObjects(), MooseObjectWarehouseBase< T >::getBoundaryObjects(), MooseObjectWarehouseBase< T >::getBoundaryObjects(), MooseObjectWarehouseBase< T >::getObject(), MooseObjectWarehouseBase< T >::getObjects(), MooseObjectWarehouseBase< T >::hasActiveBlockObjects(), MooseObjectWarehouseBase< T >::hasActiveBlockObjects(), MooseObjectWarehouseBase< T >::hasActiveBoundaryObjects(), MooseObjectWarehouseBase< T >::hasActiveObject(), MooseObjectWarehouseBase< T >::hasActiveObjects(), MooseObjectWarehouseBase< T >::hasBoundaryObjects(), MooseObjectWarehouseBase< T >::hasBoundaryObjectsHelper(), MooseObjectWarehouseBase< T >::hasObjects(), MooseObjectWarehouseBase< T >::hasObjectsForVariable(), MooseObjectWarehouseBase< T >::hasObjectsForVariableAndBlocks(), ConstraintWarehouse::residualEnd(), MooseObjectWarehouseBase< T >::size(), MooseObjectWarehouseBase< T >::sort(), MaterialWarehouse::sort(), and MooseObjectWarehouseBase< T >::updateActive().

customSetup()

template<typename T >

void MooseObjectWarehouse< T >::customSetup ( const ExecFlagType &  exec_type, THREAD_ID  tid = 0  ) const

virtual

Definition at line 175 of file MooseObjectWarehouse.h.

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

Referenced by FEProblemBase::customSetup(), AuxiliarySystem::customSetup(), and NonlinearSystemBase::customSetup().

getActiveBlockObjects() [1/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 476 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;
}

getActiveBlockObjects() [2/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 468 of file MooseObjectWarehouseBase.h.

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

Referenced by MaterialPropertyInterface::buildRequiredMaterials(), Moose::checkArrayMaterialPropertySize(), FEProblemBase::checkProblemIntegrity(), NonlinearThread::computeOnElement(), ComputeFullJacobianThread::computeOnInternalFace(), ComputeResidualAndJacobianThread::computeOnInternalFace(), ComputeResidualThread::computeOnInternalFace(), NonlinearThread::computeOnInternalFace(), ComputeFullJacobianThread::computeOnInternalFace(), FEProblemBase::getFVMatsAndDependencies(), BlockRestrictable::hasBlockMaterialPropertyHelper(), NonlinearSystemBase::needInternalNeighborSideMaterial(), ComputeIndicatorThread::onElement(), ComputeMarkerThread::onElement(), ComputeMaterialsObjectThread::onElement(), ComputeIndicatorThread::onInternalSide(), ComputeNodalKernelJacobiansThread::onNode(), ComputeNodalKernelsThread::onNode(), ComputeFVInitialConditionThread::operator()(), ComputeInitialConditionThread::operator()(), ComputeDiracThread::printBlockExecutionInformation(), ComputeIndicatorThread::printBlockExecutionInformation(), ComputeMarkerThread::printBlockExecutionInformation(), FEProblemBase::reinitMaterials(), Moose::Mortar::setupMortarMaterials(), MooseObjectWarehouseBase< T >::updateBlockFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< T >::updateBlockMatPropDependency(), and MooseObjectWarehouseBase< T >::updateBlockVariableDependency().

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 648 of file MooseObjectWarehouseBase.h.

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

Referenced by FEProblemBase::checkProblemIntegrity().

getActiveBoundaryObjects() [1/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 457 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;
}

getActiveBoundaryObjects() [2/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 449 of file MooseObjectWarehouseBase.h.

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

Referenced by NonlinearSystemBase::computeJacobianBlocks(), AuxiliarySystem::computeMortarNodalVars(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), NonlinearThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnBoundary(), NonlinearThread::computeOnInterface(), ComputeFullJacobianThread::computeOnInterface(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), NonlinearSystemBase::needBoundaryMaterialOnSide(), NonlinearSystemBase::needInterfaceMaterialOnSide(), ComputeMaterialsObjectThread::onBoundary(), ComputeMaterialsObjectThread::onInterface(), NonlinearThread::onInterfaceWithHRefinementMismatch(), ComputeBoundaryInitialConditionThread::onNode(), ComputeNodalKernelBCJacobiansThread::onNode(), ComputeNodalKernelBcsThread::onNode(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsInterface(), NonlinearSystemBase::setInitialSolution(), MooseObjectWarehouseBase< T >::updateBoundaryFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency(), and MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency().

getActiveObject()

template<typename T >

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

inherited

Definition at line 629 of file MooseObjectWarehouseBase.h.

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

Referenced by DerivativeParsedMaterialHelperTempl< is_ad >::assembleDerivatives(), FEProblemBase::getConvergence(), FEProblemBase::getFunction(), FEProblemBase::getKokkosFunction(), FEProblemBase::getMaterial(), FEProblemBase::getMeshDivision(), NonlinearSystemBase::getSplit(), LibtorchControlValuePostprocessor::initialSetup(), and LibtorchArtificialNeuralNetParameters::initialSetup().

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 441 of file MooseObjectWarehouseBase.h.

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

Referenced by FEProblemBase::backupMultiApps(), NonlinearEigenSystem::checkIntegrity(), NonlinearSystemBase::checkKernelCoverage(), FEProblemBase::checkProblemIntegrity(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeDiracContributions(), FEProblemBase::computeIndicators(), FEProblemBase::computeMarkers(), FEProblemBase::computeMultiAppsDT(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScalarKernelsJacobians(), AuxiliarySystem::computeScalarVars(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::finalizeMultiApps(), FEProblemBase::finishMultiAppStep(), ConstraintWarehouse::getActiveNodalConstraints(), FEProblemBase::getConvergenceObjects(), AuxiliarySystem::getDependObjects(), AuxiliarySystem::getDependObjects(), FEProblemBase::getTransfers(), FEProblemBase::getTransfers(), FEProblemBase::incrementMultiAppTStep(), NonlinearSystemBase::needBoundaryMaterialOnSide(), ComputeDiracThread::onElement(), ComputeElemDampingThread::onElement(), ComputeNodalDampingThread::onNode(), FEProblemBase::partitionConcurrentMultiApps(), FEProblemBase::postExecute(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::restoreMultiApps(), and AuxiliarySystem::setScalarVariableCoupleableTags().

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

Definition at line 142 of file MooseObjectWarehouse.h.

{
  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);
}

Referenced by ComputeFullJacobianThread::computeOnElement().

getBlockObjects() [1/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 430 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;
}

getBlockObjects() [2/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 422 of file MooseObjectWarehouseBase.h.

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

Referenced by MaterialPropertyDebugOutput::printMaterialMap().

getBoundaryObjects() [1/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 411 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;
}

getBoundaryObjects() [2/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 395 of file MooseObjectWarehouseBase.h.

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

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

getObject()

template<typename T >

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

inherited

Definition at line 618 of file MooseObjectWarehouseBase.h.

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

Referenced by FEProblemBase::getMultiApp().

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 387 of file MooseObjectWarehouseBase.h.

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

Referenced by FEProblemBase::checkNonlocalCoupling(), MooseApp::collectCitations(), MooseApp::errorCheck(), MooseObjectTagWarehouse< T >::getMatrixTagObjectWarehouse(), MooseObjectTagWarehouse< T >::getMatrixTagsObjectWarehouse(), MooseObjectTagWarehouse< T >::getVectorTagObjectWarehouse(), MooseObjectTagWarehouse< T >::getVectorTagsObjectWarehouse(), ConsoleUtils::outputExecutionInformation(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), FEProblemBase::setActiveMaterialProperties(), FEProblemBase::setNonlocalCouplingMatrix(), and MooseApp::setOutputFileBase().

getObjectsForVariable()

template<typename T >

const std::vector< std::shared_ptr< T > > & MooseObjectWarehouseBase< T >::getObjectsForVariable ( const VariableName &  var_name, THREAD_ID  tid  ) const

inherited

Getter for objects that have the 'variable' set to a particular variable Note that users should check whether there are objects using 'hasObjectsForVariable' before calling this routine, because it will throw if there are no objects for this variable.

Definition at line 640 of file MooseObjectWarehouseBase.h.

{
  return libmesh_map_find(_all_variable_objects[tid], var_name);
}

hasActiveBlockObjects() [1/2]

template<typename T >

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

inherited

Definition at line 562 of file MooseObjectWarehouseBase.h.

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

hasActiveBlockObjects() [2/2]

template<typename T >

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

inherited

Definition at line 551 of file MooseObjectWarehouseBase.h.

{
  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;
}

Referenced by Moose::checkArrayMaterialPropertySize(), AuxiliarySystem::computeElementalVarsHelper(), NonlinearSystemBase::computeJacobianInternal(), AuxiliarySystem::computeMortarNodalVars(), AuxiliarySystem::computeNodalVarsHelper(), NonlinearThread::computeOnElement(), ComputeFullJacobianThread::computeOnInternalFace(), ComputeJacobianThread::computeOnInternalFace(), ComputeResidualAndJacobianThread::computeOnInternalFace(), ComputeResidualThread::computeOnInternalFace(), ComputeFullJacobianThread::computeOnInternalFace(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), BlockRestrictable::hasBlockMaterialPropertyHelper(), NonlinearSystemBase::needInternalNeighborSideMaterial(), ComputeIndicatorThread::onElement(), ComputeMarkerThread::onElement(), ComputeMaterialsObjectThread::onElement(), ProjectMaterialProperties::onElement(), ComputeIndicatorThread::onInternalSide(), ComputeNodalKernelJacobiansThread::onNode(), ComputeNodalKernelsThread::onNode(), ComputeFVInitialConditionThread::operator()(), ComputeInitialConditionThread::operator()(), ComputeJacobianBlocksThread::postInternalSide(), FEProblemBase::prepareMaterials(), ComputeDiracThread::printBlockExecutionInformation(), ComputeIndicatorThread::printBlockExecutionInformation(), ComputeMarkerThread::printBlockExecutionInformation(), NonlinearThread::printBlockExecutionInformation(), FEProblemBase::reinitMaterials(), MooseObjectWarehouseBase< T >::updateBlockFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< T >::updateBlockMatPropDependency(), and MooseObjectWarehouseBase< T >::updateBlockVariableDependency().

hasActiveBoundaryObjects() [1/2]

template<typename T >

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

inherited

Definition at line 598 of file MooseObjectWarehouseBase.h.

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

hasActiveBoundaryObjects() [2/2]

template<typename T >

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

inherited

Definition at line 591 of file MooseObjectWarehouseBase.h.

{
  return hasBoundaryObjectsHelper(_active_boundary_objects, tid);
}

Referenced by AuxiliarySystem::computeElementalVarsHelper(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), AuxiliarySystem::computeMortarNodalVars(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), AuxiliarySystem::computeNodalVarsHelper(), ComputeFullJacobianThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnInterface(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), NonlinearSystemBase::needBoundaryMaterialOnSide(), FEProblemBase::needInterfaceMaterialOnSide(), NonlinearSystemBase::needInterfaceMaterialOnSide(), ComputeMaterialsObjectThread::onBoundary(), NonlinearThread::onBoundary(), NonlinearThread::onExternalSide(), ComputeMaterialsObjectThread::onInterface(), NonlinearThread::onInterface(), ComputeBoundaryInitialConditionThread::onNode(), ComputeNodalKernelBCJacobiansThread::onNode(), ComputeNodalKernelBcsThread::onNode(), NonlinearThread::printBoundaryExecutionInformation(), ComputeNodalKernelBCJacobiansThread::printGeneralExecutionInformation(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsInterface(), NonlinearSystemBase::setInitialSolution(), MooseObjectWarehouseBase< T >::updateBoundaryFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency(), MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency(), MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency(), and MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency().

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 607 of file MooseObjectWarehouseBase.h.

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

Referenced by FEProblemBase::hasConvergence(), FEProblemBase::hasFunction(), and FEProblemBase::hasMultiApp().

hasActiveObjects()

template<typename T >

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

inherited

Definition at line 495 of file MooseObjectWarehouseBase.h.

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

Referenced by NonlinearEigenSystem::checkIntegrity(), NonlinearSystemBase::checkKernelCoverage(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeDiracContributions(), FEProblemBase::computeIndicators(), FEProblemBase::computeMarkers(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScalarKernelsJacobians(), AuxiliarySystem::computeScalarVars(), NonlinearSystemBase::containsTimeKernel(), FEProblemBase::execMultiAppTransfers(), ConstraintWarehouse::hasActiveNodalConstraints(), FEProblemBase::hasMultiApps(), FEProblemBase::hasMultiApps(), ElementSubdomainModifierBase::modify(), NonlinearSystemBase::needBoundaryMaterialOnSide(), ComputeNodalKernelBcsThread::printGeneralExecutionInformation(), ComputeNodalKernelJacobiansThread::printGeneralExecutionInformation(), ComputeNodalKernelsThread::printGeneralExecutionInformation(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::timestepSetup(), MooseObjectWarehouseBase< T >::updateFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< T >::updateMatPropDependency(), and MooseObjectWarehouseBase< T >::updateVariableDependency().

hasActiveVariableBlockObjects()

template<typename T >

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

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

Definition at line 132 of file MooseObjectWarehouse.h.

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

Referenced by ComputeFullJacobianThread::computeOnElement().

hasBoundaryObjects() [1/2]

template<typename T >

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

inherited

Definition at line 403 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _all_boundary_objects[tid].find(id) != _all_boundary_objects[tid].end();
}

hasBoundaryObjects() [2/2]

template<typename T >

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

inherited

Definition at line 584 of file MooseObjectWarehouseBase.h.

{
  return hasBoundaryObjectsHelper(_all_boundary_objects, tid);
}

hasBoundaryObjectsHelper()

template<typename T >

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

protectedinherited

Helper for determining whether we have boundary objects.

Definition at line 571 of file MooseObjectWarehouseBase.h.

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

Referenced by MooseObjectWarehouseBase< T >::hasActiveBoundaryObjects(), and MooseObjectWarehouseBase< T >::hasBoundaryObjects().

hasObjects()

template<typename T >

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

inherited

Convenience functions for determining if objects exist.

Definition at line 487 of file MooseObjectWarehouseBase.h.

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

Referenced by NonlinearSystemBase::setInitialSolution().

hasObjectsForVariable()

template<typename T >

bool MooseObjectWarehouseBase< T >::hasObjectsForVariable ( const VariableName &  var_name, THREAD_ID  tid  ) const

inherited

Definition at line 503 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _all_variable_objects[tid].count(var_name);
}

Referenced by MooseObjectWarehouseBase< T >::hasObjectsForVariableAndBlocks().

hasObjectsForVariableAndBlocks()

template<typename T >

bool MooseObjectWarehouseBase< T >::hasObjectsForVariableAndBlocks ( const VariableName &  var_name, const std::set< SubdomainID > &  blocks, std::set< SubdomainID > &  blocks_covered, THREAD_ID  tid  ) const

inherited

Whether there are objects for this variable and the set of blocks passed.

Parameters

var_name	name of the variable
blocks	blocks to consider
blocks_covered	subset of blocks for which there is an object

Definition at line 512 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  blocks_covered.clear();
  if (!hasObjectsForVariable(var_name, tid))
    return false;
 
  // Check block restriction as a whole
  for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
  {
    std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
    if (blk && blk->hasBlocks(blocks))
    {
      blocks_covered = blocks;
      return true;
    }
  }
  // No object has all the blocks, but one might overlap, which could be troublesome.
  // We'll keep track of which blocks are covered in case several overlap
  for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
  {
    std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
    if (blk)
      for (const auto & block : blocks)
        if (blk->hasBlocks(block))
          blocks_covered.insert(block);
  }
  // No overlap at all
  if (blocks_covered.empty())
    return false;
 
  return (blocks == blocks_covered);
}

hasVariableObjects()

template<typename T >

bool MooseObjectWarehouse< T >::hasVariableObjects	(	unsigned int	variable_id,
		THREAD_ID	tid = 0
	)		const

Checks for whether this warehouse has objects for a given variable.

Definition at line 124 of file MooseObjectWarehouse.h.

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

Referenced by ExplicitTimeIntegrator::initialSetup().

initialSetup()

template<typename T >

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

virtual

Convenience methods for calling object setup methods.

Reimplemented in MaterialWarehouse.

Definition at line 156 of file MooseObjectWarehouse.h.

{
  checkThreadID(tid);
  // Initial Setup should be called on all objects because they may become active later
  for (const auto & object : _all_objects[tid])
    object->initialSetup();
}

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

jacobianSetup()

template<typename T >

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

virtual

Reimplemented in MaterialWarehouse, ExecuteMooseObjectWarehouse< T >, ExecuteMooseObjectWarehouse< AuxKernelBase >, ExecuteMooseObjectWarehouse< AuxKernelTempl >, ExecuteMooseObjectWarehouse< AuxKernelTempl< Real > >, ExecuteMooseObjectWarehouse< AuxKernelTempl< RealVectorValue > >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< Transfer >, and ExecuteMooseObjectWarehouse< TransientMultiApp >.

Definition at line 206 of file MooseObjectWarehouse.h.

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

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), NonlinearSystemBase::jacobianSetup(), and MaterialWarehouse::jacobianSetup().

numThreads()

template<typename T >

THREAD_ID MooseObjectWarehouseBase< T >::numThreads ( ) const

inlineinherited

Return the number of threads.

Definition at line 204 of file MooseObjectWarehouseBase.h.

{ return _num_threads; }

residualSetup()

template<typename T >

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

virtual

Reimplemented in MaterialWarehouse, ExecuteMooseObjectWarehouse< T >, ExecuteMooseObjectWarehouse< AuxKernelBase >, ExecuteMooseObjectWarehouse< AuxKernelTempl >, ExecuteMooseObjectWarehouse< AuxKernelTempl< Real > >, ExecuteMooseObjectWarehouse< AuxKernelTempl< RealVectorValue > >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< Transfer >, and ExecuteMooseObjectWarehouse< TransientMultiApp >.

Definition at line 215 of file MooseObjectWarehouse.h.

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

Referenced by FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::residualSetup(), and MaterialWarehouse::residualSetup().

size()

template<typename T >

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

inherited

Return how many kernels we store in the current warehouse.

Definition at line 305 of file MooseObjectWarehouseBase.h.

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

Referenced by NonlinearThread::printBlockExecutionInformation().

sort()

template<typename T >

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

inherited

Sort the objects using the DependencyResolver.

Definition at line 688 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
 
  for (auto & object_pair : _all_block_objects[tid])
    sortHelper(object_pair.second);
 
  for (auto & object_pair : _all_boundary_objects[tid])
    sortHelper(object_pair.second);
 
  sortHelper(_all_objects[tid]);
 
  // The active lists now must be update to reflect the order changes
  updateActive(tid);
}

Referenced by ScalarInitialConditionWarehouse::initialSetup(), FVInitialConditionWarehouse::initialSetup(), and InitialConditionWarehouse::initialSetup().

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 908 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");
  }
}

Referenced by MooseObjectWarehouseBase< T >::sort(), and MaterialWarehouse::sort().

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 879 of file MooseObjectWarehouseBase.h.

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

Referenced by NonlinearSystemBase::checkKernelCoverage().

subdomainSetup() [1/2]

template<typename T >

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

virtual

Reimplemented in MaterialWarehouse.

Definition at line 184 of file MooseObjectWarehouse.h.

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

subdomainSetup() [2/2]

template<typename T >

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

virtual

Reimplemented in MaterialWarehouse.

Definition at line 197 of file MooseObjectWarehouse.h.

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

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

timestepSetup()

template<typename T >

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

virtual

Reimplemented in MaterialWarehouse.

Definition at line 166 of file MooseObjectWarehouse.h.

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

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

updateActive()

template<typename T >

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

overridevirtual

Update the active status of Kernels.

Reimplemented from MooseObjectWarehouseBase< T >.

Reimplemented in ConstraintWarehouse, MaterialWarehouse, ExecuteMooseObjectWarehouse< T >, ExecuteMooseObjectWarehouse< AuxKernelBase >, ExecuteMooseObjectWarehouse< AuxKernelTempl >, ExecuteMooseObjectWarehouse< AuxKernelTempl< Real > >, ExecuteMooseObjectWarehouse< AuxKernelTempl< RealVectorValue > >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< Transfer >, ExecuteMooseObjectWarehouse< TransientMultiApp >, MooseObjectTagWarehouse< T >, MooseObjectTagWarehouse< DGKernelBase >, MooseObjectTagWarehouse< DiracKernelBase >, MooseObjectTagWarehouse< HDGKernel >, MooseObjectTagWarehouse< IntegratedBCBase >, MooseObjectTagWarehouse< InterfaceKernelBase >, MooseObjectTagWarehouse< KernelBase >, MooseObjectTagWarehouse< NodalBCBase >, MooseObjectTagWarehouse< NodalKernelBase >, MooseObjectTagWarehouse< ResidualObject >, and MooseObjectTagWarehouse< ScalarKernelBase >.

Definition at line 224 of file MooseObjectWarehouse.h.

{
  MooseObjectWarehouseBase<T>::updateActive(tid);
 
  for (auto & it : _variable_objects)
    it.second.updateActive(tid);
}

Referenced by NonlinearSystemBase::updateActive(), ConstraintWarehouse::updateActive(), MaterialWarehouse::updateActive(), ExecuteMooseObjectWarehouse< T >::updateActive(), MooseObjectTagWarehouse< T >::updateActive(), and FEProblemBase::updateActiveObjects().

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 674 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(); });
}

Referenced by MooseObjectWarehouseBase< T >::updateActive().

updateBlockFEVariableCoupledVectorTagDependency()

template<typename T >

void MooseObjectWarehouseBase< T >::updateBlockFEVariableCoupledVectorTagDependency ( SubdomainID  id, std::set< TagID > &  needed_fe_var_vector_tags, THREAD_ID  tid = 0  ) const

inherited

Definition at line 777 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveBlockObjects(id, tid))
    updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
                                                     getActiveBlockObjects(id, tid));
}

Referenced by ComputeNodalKernelsThread::onNode(), ComputeIndicatorThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), ComputeUserObjectsThread::subdomainChanged(), and NonlinearThread::subdomainChanged().

updateBlockMatPropDependency()

template<typename T >

void MooseObjectWarehouseBase< T >::updateBlockMatPropDependency ( SubdomainID  id, std::unordered_set< unsigned int > &  needed_mat_props, THREAD_ID  tid = 0, const bool  producer_only = false  ) const

inherited

Definition at line 824 of file MooseObjectWarehouseBase.h.

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

Referenced by FEProblemBase::prepareMaterials(), and NonlinearThread::subdomainChanged().

updateBlockVariableDependency()

template<typename T >

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

inherited

Definition at line 715 of file MooseObjectWarehouseBase.h.

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

Referenced by NonlinearThread::subdomainChanged().

updateBoundaryFEVariableCoupledVectorTagDependency()

template<typename T >

void MooseObjectWarehouseBase< T >::updateBoundaryFEVariableCoupledVectorTagDependency ( BoundaryID  id, std::set< TagID > &  needed_fe_var_vector_tags, THREAD_ID  tid = 0  ) const

inherited

Definition at line 787 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveBoundaryObjects(id, tid))
    updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
                                                     getActiveBoundaryObjects(id, tid));
}

Referenced by ComputeNodalKernelBcsThread::onNode().

updateBoundaryMatPropDependency() [1/2]

template<typename T >

void MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency ( BoundaryID  id, std::unordered_set< unsigned int > &  needed_mat_props, THREAD_ID  tid = 0, const bool  producer_only = false  ) const

inherited

Definition at line 848 of file MooseObjectWarehouseBase.h.

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

updateBoundaryMatPropDependency() [2/2]

template<typename T >

void MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency ( std::unordered_set< unsigned int > &  needed_mat_props, THREAD_ID  tid = 0, const bool  producer_only = false  ) const

inherited

Definition at line 836 of file MooseObjectWarehouseBase.h.

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

Referenced by FEProblemBase::prepareMaterials(), and NonlinearThread::subdomainChanged().

updateBoundaryVariableDependency() [1/2]

template<typename T >

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

inherited

Definition at line 739 of file MooseObjectWarehouseBase.h.

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

updateBoundaryVariableDependency() [2/2]

template<typename T >

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

inherited

Definition at line 726 of file MooseObjectWarehouseBase.h.

{
  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);
  }
}

Referenced by FEProblemBase::prepareMaterials(), and NonlinearThread::subdomainChanged().

updateFEVariableCoupledVectorTagDependency()

template<typename T >

void MooseObjectWarehouseBase< T >::updateFEVariableCoupledVectorTagDependency ( std::set< TagID > &  needed_fe_var_vector_tags, THREAD_ID  tid = 0  ) const

inherited

Update FE variable coupleable vector tag vector for all objects, block-restricted objects, and boundary-restricted objects.

Definition at line 767 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveObjects(tid))
    updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
                                                     _active_objects[tid]);
}

updateFEVariableCoupledVectorTagDependencyHelper()

template<typename T >

void MooseObjectWarehouseBase< T >::updateFEVariableCoupledVectorTagDependencyHelper ( std::set< TagID > &  needed_fe_var_vector_tags, const std::vector< std::shared_ptr< T > > &  objects  )

staticprotectedinherited

Helper method for updating FE variable coupleable vector tag vector.

Definition at line 797 of file MooseObjectWarehouseBase.h.

{
  for (const auto & object : objects)
  {
    auto c = dynamic_cast<const Coupleable *>(object.get());
    if (c)
    {
      const auto & tag_deps = c->getFEVariableCoupleableVectorTags();
      needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
    }
  }
}

Referenced by MooseObjectWarehouseBase< T >::updateBlockFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< T >::updateBoundaryFEVariableCoupledVectorTagDependency(), and MooseObjectWarehouseBase< T >::updateFEVariableCoupledVectorTagDependency().

updateMatPropDependency()

template<typename T >

void MooseObjectWarehouseBase< T >::updateMatPropDependency ( std::unordered_set< unsigned int > &  needed_mat_props, THREAD_ID  tid = 0, const bool  producer_only = false  ) const

inherited

Update material property dependency vector.

Parameters

producer_only

Only append dependencies of materials producing the needed_mat_props

Definition at line 813 of file MooseObjectWarehouseBase.h.

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

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

updateMatPropDependencyHelper()

template<typename T >

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

protectedvirtualinherited

Helper method for updating material property dependency vector.

Definition at line 861 of file MooseObjectWarehouseBase.h.

{
  for (auto & object : objects)
  {
    auto c = dynamic_cast<const MaterialPropertyInterface *>(object.get());
    if (c)
    {
      auto & mp_deps = c->getMatPropDependencies();
      needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
    }
  }
}

Referenced by MaterialWarehouse::updateMatPropDependencyHelper().

updateVariableDependency()

template<typename T >

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

inherited

Update variable dependency vector.

Definition at line 706 of file MooseObjectWarehouseBase.h.

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

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

updateVariableDependencyHelper()

template<typename T >

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

staticprotectedinherited

Helper method for updating variable dependency vector.

Definition at line 750 of file MooseObjectWarehouseBase.h.

{
  for (const auto & object : objects)
  {
    auto c = dynamic_cast<const MooseVariableDependencyInterface *>(object.get());
    if (c)
    {
      const auto & mv_deps = c->getMooseVariableDependencies();
      needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
    }
  }
}

Referenced by MooseObjectWarehouseBase< T >::updateBlockVariableDependency(), MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency(), MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency(), and MooseObjectWarehouseBase< T >::updateVariableDependency().

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 228 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< T >::addObject(), MooseObjectWarehouseBase< T >::getActiveBlockObjects(), MooseObjectWarehouseBase< T >::getActiveBlockObjects(), MooseObjectWarehouseBase< T >::getActiveBlocks(), MooseObjectWarehouseBase< T >::hasActiveBlockObjects(), MooseObjectWarehouseBase< T >::hasActiveBlockObjects(), MooseObjectWarehouseBase< T >::subdomainsCovered(), and MooseObjectWarehouseBase< T >::updateActive().

_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 234 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< T >::addObject(), MooseObjectWarehouseBase< T >::getActiveBoundaryObjects(), MooseObjectWarehouseBase< T >::getActiveBoundaryObjects(), MooseObjectWarehouseBase< T >::hasActiveBoundaryObjects(), MooseObjectWarehouseBase< T >::hasActiveBoundaryObjects(), MooseObjectWarehouseBase< T >::updateActive(), MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency(), and MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency().

_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 222 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< T >::activeObjectsToFormattedString(), MooseObjectWarehouseBase< T >::addObject(), MooseObjectWarehouseBase< T >::getActiveObject(), MooseObjectWarehouseBase< T >::getActiveObjects(), MooseObjectWarehouseBase< T >::hasActiveObject(), MooseObjectWarehouseBase< T >::hasActiveObjects(), ConstraintWarehouse::residualEnd(), MooseObjectWarehouseBase< T >::subdomainsCovered(), MooseObjectWarehouseBase< T >::updateActive(), MooseObjectWarehouseBase< T >::updateFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< T >::updateMatPropDependency(), and MooseObjectWarehouseBase< T >::updateVariableDependency().

_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 225 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< T >::addObject(), MooseObjectWarehouseBase< T >::getBlockObjects(), MooseObjectWarehouseBase< T >::getBlockObjects(), MooseObjectWarehouseBase< T >::sort(), MaterialWarehouse::sort(), and MooseObjectWarehouseBase< T >::updateActive().

_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 231 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< T >::addObject(), MooseObjectWarehouseBase< T >::getBoundaryObjects(), MooseObjectWarehouseBase< T >::getBoundaryObjects(), MooseObjectWarehouseBase< T >::hasBoundaryObjects(), MooseObjectWarehouseBase< T >::hasBoundaryObjects(), MooseObjectWarehouseBase< T >::sort(), MaterialWarehouse::sort(), and MooseObjectWarehouseBase< T >::updateActive().

_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 219 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< T >::addObject(), MooseObjectWarehouseBase< T >::getObject(), MooseObjectWarehouseBase< T >::getObjects(), MooseObjectWarehouseBase< T >::hasObjects(), MooseObjectWarehouseBase< T >::size(), MooseObjectWarehouseBase< T >::sort(), MaterialWarehouse::sort(), and MooseObjectWarehouseBase< T >::updateActive().

_all_variable_objects

template<typename T >

std::vector<std::map<VariableName, std::vector<std::shared_ptr<T> > > > MooseObjectWarehouseBase< T >::_all_variable_objects

protectedinherited

All objects with a certain variable selected, as the 'variable' parameter.

Definition at line 237 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< T >::addObject(), MooseObjectWarehouseBase< T >::getObjectsForVariable(), MooseObjectWarehouseBase< T >::hasObjectsForVariable(), and MooseObjectWarehouseBase< T >::hasObjectsForVariableAndBlocks().

_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 216 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< T >::checkThreadID(), and MooseObjectWarehouseBase< T >::numThreads().

_variable_objects

template<typename T >

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

protected

Variable based storage.

Definition at line 87 of file MooseObjectWarehouse.h.

---

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

• include/loops/ComputeDiracThread.h
• include/warehouses/MooseObjectWarehouse.h