MooseObjectTagWarehouse< T > Class Template Reference

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

#include <ComputeDiracThread.h>

Inheritance diagram for MooseObjectTagWarehouse< T >:

Public Member Functions
	MooseObjectTagWarehouse (bool threaded=true)
	Constructor. More...
virtual void	updateActive (THREAD_ID tid=0) override
	Update the active status of Kernels. More...
MooseObjectWarehouse< T > &	getVectorTagObjectWarehouse (TagID tag_id, THREAD_ID tid)
	Retrieve a moose object warehouse in which every moose object has the given vector tag. More...
MooseObjectWarehouse< T > &	getVectorTagsObjectWarehouse (const std::set< TagID > &tags, THREAD_ID tid)
	Retrieve a moose object warehouse in which every moose object at least has one of the given vector tags. More...
MooseObjectWarehouse< T > &	getMatrixTagObjectWarehouse (TagID tag_id, THREAD_ID tid)
	Retrieve a moose object warehouse in which every moose object has the given matrix tag. More...
MooseObjectWarehouse< T > &	getMatrixTagsObjectWarehouse (const std::set< TagID > &tags, THREAD_ID tid)
	Retrieve a moose object warehouse in which every moose object has one of the given matrix tags. More...
virtual void	addObject (std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
	Adds an object to the storage structure. 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	sort (THREAD_ID tid=0)
	Sort the objects using the DependencyResolver. 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...
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
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. 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	hasObjects (THREAD_ID tid=0) const
	Convenience functions for determining if objects exist. More...
bool	hasActiveObjects (THREAD_ID tid=0) 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	hasActiveObject (const std::string &name, THREAD_ID tid=0) const
	Convenience functions for checking/getting specific objects. More...
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< 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
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
const THREAD_ID	_num_threads
std::vector< std::map< TagID, MooseObjectWarehouse< T > > >	_vector_tag_to_object_warehouse
	Tag based storage. Map from a tag to a moose object warehouse for vector tags. More...
std::vector< std::map< std::set< TagID >, MooseObjectWarehouse< T > > >	_vector_tags_to_object_warehouse
	std::set<TagID> based storage. Map from a std::set of tags to a moose object warehouse for vector tags. More...
std::vector< std::map< TagID, MooseObjectWarehouse< T > > >	_matrix_tag_to_object_warehouse
	Tag based storage. Map fro a tag to moose object warehouse for matrix tags. More...
std::vector< std::map< std::set< TagID >, MooseObjectWarehouse< T > > >	_matrix_tags_to_object_warehouse
	std::set<TagID> based storage. Map from a std::set of tags to moose object warehouse for matrix tags. More...
std::map< unsigned int, MooseObjectWarehouse< T > >	_variable_objects
	Variable based storage. 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 MooseObjectTagWarehouse< 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 21 of file ComputeDiracThread.h.

Constructor & Destructor Documentation

MooseObjectTagWarehouse()

template<typename T >

MooseObjectTagWarehouse< T >::MooseObjectTagWarehouse

(

bool

threaded = true

)

Constructor.

Parameters

threaded

When true (default) threaded storage is enabled.

Definition at line 89 of file MooseObjectTagWarehouse.h.

  : MooseObjectWarehouse<T>(threaded),
    _num_threads(threaded ? libMesh::n_threads() : 1),
    _vector_tag_to_object_warehouse(_num_threads),
    _vector_tags_to_object_warehouse(_num_threads),
    _matrix_tag_to_object_warehouse(_num_threads),
    _matrix_tags_to_object_warehouse(_num_threads)
{
}

Member Function Documentation

addObject()

template<typename T>

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

overridevirtualinherited

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< T >, ExecuteMooseObjectWarehouse< TransientMultiApp >, ExecuteMooseObjectWarehouse< Sampler >, ExecuteMooseObjectWarehouse< UserObject >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< AuxKernel >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< Transfer >, and ConstraintWarehouse.

Definition at line 93 of file MooseObjectWarehouse.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addDamper(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), FEProblemBase::addFunction(), FEProblemBase::addIndicator(), NonlinearSystemBase::addInterfaceKernel(), MooseEigenSystem::addKernel(), NonlinearSystemBase::addKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), NonlinearSystemBase::addNodalKernel(), ConstraintWarehouse::addObject(), ExecuteMooseObjectWarehouse< Transfer >::addObjectMask(), MaterialWarehouse::addObjects(), NonlinearSystemBase::addScalarKernel(), and FEProblemBase::checkNonlocalCoupling().

{
  MooseObjectWarehouseBase<T>::addObject(object, tid, recurse);

  if (recurse)
  {
    {
      auto mvi = std::dynamic_pointer_cast<MooseVariableInterface<Real>>(object);

      if (mvi)
        _variable_objects[mvi->mooseVariable()->number()].addObject(object, tid, false);
    }

    {
      auto mvi = std::dynamic_pointer_cast<MooseVariableInterface<RealVectorValue>>(object);

      if (mvi)
        _variable_objects[mvi->mooseVariable()->number()].addObject(object, tid, false);
    }
  }
}

checkThreadID()

template<typename T>

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

inlineprotectedinherited

Calls assert on thread id.

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

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

Referenced by FEProblemBase::checkProblemIntegrity(), ComputeFullJacobianThread::computeInternalFaceJacobian(), ComputeJacobianThread::computeInternalFaceJacobian(), ComputeFullJacobianThread::computeJacobian(), 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 396 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 496 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 369 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(), ComputeNodalKernelBcsThread::onNode(), ComputeNodalAuxBcsThread::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 377 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 485 of file MooseObjectWarehouseBase.h.

Referenced by DerivativeParsedMaterialHelper::assembleDerivatives(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getMaterial(), 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 361 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::finalizeMultiApps(), 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 129 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 342 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 350 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 323 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 331 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;
}

getMatrixTagObjectWarehouse()

template<typename T >

MooseObjectWarehouse< T > & MooseObjectTagWarehouse< T >::getMatrixTagObjectWarehouse	(	TagID	tag_id,
		THREAD_ID	tid
	)

Retrieve a moose object warehouse in which every moose object has the given matrix tag.

If the warehouse is not constructed yet, it will be constructed here and returned. If the warehouse is already cached (it was queried before), we just directly return the cached warehouse.

Definition at line 153 of file MooseObjectTagWarehouse.h.

Referenced by NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeScalarKernelsJacobians(), ComputeNodalKernelBCJacobiansThread::pre(), ComputeNodalKernelJacobiansThread::pre(), ComputeJacobianThread::subdomainChanged(), and ComputeDiracThread::subdomainChanged().

{
  auto & matrix_tag_to_object_warehouse = _matrix_tag_to_object_warehouse[tid];

  const auto & house_end = matrix_tag_to_object_warehouse.end();
  const auto & tag_warehouse = matrix_tag_to_object_warehouse.find(tag_id);

  if (tag_warehouse != house_end)
    return tag_warehouse->second;
  else
    matrix_tag_to_object_warehouse[tag_id];

  // Add moose objects to matrix-tag warehouse
  const auto & objects = MooseObjectWarehouse<T>::getActiveObjects(tid);
  for (auto & object : objects)
  {
    auto & tags = object->getMatrixTags();
    for (auto & tag : tags)
    {
      if (tag == tag_id)
      {
        // Tag based storage
        matrix_tag_to_object_warehouse[tag_id].addObject(object, tid);

        break;
      }
    }
  }

  return matrix_tag_to_object_warehouse[tag_id];
}

getMatrixTagsObjectWarehouse()

template<typename T >

MooseObjectWarehouse< T > & MooseObjectTagWarehouse< T >::getMatrixTagsObjectWarehouse	(	const std::set< TagID > &	tags,
		THREAD_ID	tid
	)

Retrieve a moose object warehouse in which every moose object has one of the given matrix tags.

If the warehouse is not constructed yet, it will be constructed here and returned. If the warehouse is already cached (it was queried before), we just directly return the cached warehouse.

Definition at line 226 of file MooseObjectTagWarehouse.h.

Referenced by NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeScalarKernelsJacobians(), ComputeNodalKernelBCJacobiansThread::pre(), ComputeNodalKernelJacobiansThread::pre(), ComputeJacobianThread::subdomainChanged(), and ComputeDiracThread::subdomainChanged().

{
  auto & matrix_tags_to_object_warehouse = _matrix_tags_to_object_warehouse[tid];

  const auto & house_end = matrix_tags_to_object_warehouse.end();
  const auto & tags_warehouse = matrix_tags_to_object_warehouse.find(m_tags);

  if (tags_warehouse != house_end)
    return tags_warehouse->second;
  else
    matrix_tags_to_object_warehouse[m_tags];

  const auto & objects = MooseObjectWarehouse<T>::getActiveObjects(tid);
  for (auto & object : objects)
  {
    auto & tags = object->getMatrixTags();
    const auto & tags_end = tags.end();
    for (auto & m_tag : m_tags)
    {
      const auto & tag_found = tags.find(m_tag);
      // Object contains at least one of required tags
      if (tag_found != tags_end)
      {
        // std::vector<Tag> based storage
        matrix_tags_to_object_warehouse[m_tags].addObject(object, tid);
        // Then we should work for next object
        break;
      }
    }
  }

  return matrix_tags_to_object_warehouse[m_tags];
}

getObject()

template<typename T >

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

inherited

Definition at line 474 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::getMultiApp().

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

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

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

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

getVectorTagObjectWarehouse()

template<typename T >

MooseObjectWarehouse< T > & MooseObjectTagWarehouse< T >::getVectorTagObjectWarehouse	(	TagID	tag_id,
		THREAD_ID	tid
	)

Retrieve a moose object warehouse in which every moose object has the given vector tag.

If the warehouse is not constructed yet, it will be constructed here and returned. If the warehouse is already cached (it was queried before), we just directly return the cached warehouse.

Definition at line 120 of file MooseObjectTagWarehouse.h.

Referenced by NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::containsTimeKernel(), ComputeNodalKernelBcsThread::pre(), ComputeNodalKernelsThread::pre(), ComputeResidualThread::subdomainChanged(), and ComputeDiracThread::subdomainChanged().

{
  auto & vector_tag_to_object_warehouse = _vector_tag_to_object_warehouse[tid];

  const auto & house_end = vector_tag_to_object_warehouse.end();
  const auto & tag_warehouse = vector_tag_to_object_warehouse.find(tag_id);

  if (tag_warehouse != house_end)
    return tag_warehouse->second;
  else
    vector_tag_to_object_warehouse[tag_id];

  // Now add actual moose objects into warehouse
  const auto & objects = MooseObjectWarehouse<T>::getActiveObjects(tid);
  for (auto & object : objects)
  {
    auto & tags = object->getVectorTags();
    for (auto & tag : tags)
    {
      if (tag == tag_id)
      {
        // Tag based storage
        vector_tag_to_object_warehouse[tag_id].addObject(object, tid);
        break;
      }
    }
  }

  return vector_tag_to_object_warehouse[tag_id];
}

getVectorTagsObjectWarehouse()

template<typename T >

MooseObjectWarehouse< T > & MooseObjectTagWarehouse< T >::getVectorTagsObjectWarehouse	(	const std::set< TagID > &	tags,
		THREAD_ID	tid
	)

Retrieve a moose object warehouse in which every moose object at least has one of the given vector tags.

If the warehouse is not constructed yet, it will be constructed here and returned. If the warehouse is already cached (it was queried before), we just directly return the cached warehouse.

Definition at line 187 of file MooseObjectTagWarehouse.h.

Referenced by NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeResidualInternal(), ComputeNodalKernelBcsThread::pre(), ComputeNodalKernelsThread::pre(), ComputeResidualThread::subdomainChanged(), and ComputeDiracThread::subdomainChanged().

{
  // std::map is not thread-safe for writes
  auto & vector_tags_to_object_warehouse = _vector_tags_to_object_warehouse[tid];

  const auto & house_end = vector_tags_to_object_warehouse.end();
  const auto & tags_warehouse = vector_tags_to_object_warehouse.find(v_tags);

  if (tags_warehouse != house_end)
    return tags_warehouse->second;
  else
    vector_tags_to_object_warehouse[v_tags];

  // Add moose objects to vector-tags warehouse
  const auto & objects = MooseObjectWarehouse<T>::getActiveObjects(tid);
  for (auto & object : objects)
  {
    auto & tags = object->getVectorTags();
    const auto & tags_end = tags.end();
    for (auto & v_tag : v_tags)
    {
      const auto & tag_found = tags.find(v_tag);
      // Object contains at least one of required tags
      if (tag_found != tags_end)
      {
        // std::vector<Tag> based storage
        vector_tags_to_object_warehouse[v_tags].addObject(object, tid);
        // Then we should work for next object
        break;
      }
    }
  }

  return vector_tags_to_object_warehouse[v_tags];
}

hasActiveBlockObjects() [1/2]

template<typename T >

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

inherited

Definition at line 423 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearSystemBase::checkKernelCoverage(), AuxiliarySystem::computeElementalVars(), ComputeFullJacobianThread::computeInternalFaceJacobian(), ComputeFullJacobianThread::computeJacobian(), 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 434 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 443 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 454 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 463 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

Definition at line 415 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 119 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));
}

hasObjects()

template<typename T >

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

inherited

Convenience functions for determining if objects exist.

Definition at line 407 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::initialSetup().

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

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 143 of file MooseObjectWarehouse.h.

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

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

jacobianSetup()

template<typename T >

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

virtualinherited

Reimplemented in ExecuteMooseObjectWarehouse< T >, ExecuteMooseObjectWarehouse< TransientMultiApp >, ExecuteMooseObjectWarehouse< Sampler >, ExecuteMooseObjectWarehouse< UserObject >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< AuxKernel >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< Transfer >, and MaterialWarehouse.

Definition at line 184 of file MooseObjectWarehouse.h.

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

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

numThreads()

template<typename T>

THREAD_ID MooseObjectWarehouseBase< T >::numThreads ( )

inlineinherited

Return the number of threads.

Definition at line 163 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearEigenSystem::addEigenTagToMooseObjects().

{ return _num_threads; }

residualSetup()

template<typename T >

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

virtualinherited

Reimplemented in ExecuteMooseObjectWarehouse< T >, ExecuteMooseObjectWarehouse< TransientMultiApp >, ExecuteMooseObjectWarehouse< Sampler >, ExecuteMooseObjectWarehouse< UserObject >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< AuxKernel >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< Transfer >, and MaterialWarehouse.

Definition at line 193 of file MooseObjectWarehouse.h.

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

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

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

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

sort()

template<typename T >

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

inherited

Sort the objects using the DependencyResolver.

Definition at line 536 of file MooseObjectWarehouseBase.h.

Referenced by InitialConditionWarehouse::initialSetup(), FEProblemBase::initialSetup(), and MaterialWarehouse::sort().

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

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 674 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 661 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 175 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 162 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 153 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 MooseObjectTagWarehouse< T >::updateActive ( THREAD_ID  tid = 0 )

overridevirtual

Update the active status of Kernels.

Reimplemented from MooseObjectWarehouse< T >.

Definition at line 101 of file MooseObjectTagWarehouse.h.

Referenced by NonlinearSystemBase::updateActive().

{
  MooseObjectWarehouse<T>::updateActive(tid);

  for (auto & it : _vector_tag_to_object_warehouse[tid])
    it.second.updateActive(tid);

  for (auto & it : _vector_tags_to_object_warehouse[tid])
    it.second.updateActive(tid);

  for (auto & it : _matrix_tag_to_object_warehouse[tid])
    it.second.updateActive(tid);

  for (auto & it : _matrix_tags_to_object_warehouse[tid])
    it.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 522 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 620 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 563 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 630 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 640 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 574 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 587 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 611 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 649 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 554 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 598 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 179 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 185 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 173 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 176 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 182 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 170 of file MooseObjectWarehouseBase.h.

_matrix_tag_to_object_warehouse

template<typename T>

std::vector<std::map<TagID, MooseObjectWarehouse<T> > > MooseObjectTagWarehouse< T >::_matrix_tag_to_object_warehouse

protected

Tag based storage. Map fro a tag to moose object warehouse for matrix tags.

Definition at line 82 of file MooseObjectTagWarehouse.h.

_matrix_tags_to_object_warehouse

template<typename T>

std::vector<std::map<std::set<TagID>, MooseObjectWarehouse<T> > > MooseObjectTagWarehouse< T >::_matrix_tags_to_object_warehouse

protected

std::set<TagID> based storage. Map from a std::set of tags to moose object warehouse for matrix tags.

Definition at line 85 of file MooseObjectTagWarehouse.h.

_num_threads

template<typename T>

const THREAD_ID MooseObjectTagWarehouse< T >::_num_threads

protected

Definition at line 73 of file MooseObjectTagWarehouse.h.

_variable_objects

template<typename T>

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

protectedinherited

Variable based storage.

Definition at line 82 of file MooseObjectWarehouse.h.

_vector_tag_to_object_warehouse

template<typename T>

std::vector<std::map<TagID, MooseObjectWarehouse<T> > > MooseObjectTagWarehouse< T >::_vector_tag_to_object_warehouse

protected

Tag based storage. Map from a tag to a moose object warehouse for vector tags.

Definition at line 76 of file MooseObjectTagWarehouse.h.

_vector_tags_to_object_warehouse

template<typename T>

std::vector<std::map<std::set<TagID>, MooseObjectWarehouse<T> > > MooseObjectTagWarehouse< T >::_vector_tags_to_object_warehouse

protected

std::set<TagID> based storage. Map from a std::set of tags to a moose object warehouse for vector tags.

Definition at line 79 of file MooseObjectTagWarehouse.h.

---

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

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