MooseObjectWarehouseBase< T > Class Template Reference

A base storage container for MooseObjects. More...

#include <MooseObjectWarehouseBase.h>

Inheritance diagram for MooseObjectWarehouseBase< T >:

Public Member Functions
	MooseObjectWarehouseBase (bool threaded=true)
	Constructor. More...
virtual	~MooseObjectWarehouseBase ()
	Destructor. More...
virtual void	addObject (std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true)
	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...
virtual void	updateActive (THREAD_ID tid=0)
	Updates the active objects storage. 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...
const std::vector< std::shared_ptr< T > > &	getObjects (THREAD_ID tid=0) const
	Retrieve complete vector to the all/block/boundary restricted objects for a given thread. More...
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > &	getBlockObjects (THREAD_ID tid=0) const
const std::vector< std::shared_ptr< T > > &	getBlockObjects (SubdomainID id, THREAD_ID tid=0) const
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > &	getBoundaryObjects (THREAD_ID tid=0) const
const std::vector< std::shared_ptr< T > > &	getBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
const std::vector< std::shared_ptr< T > > &	getActiveObjects (THREAD_ID tid=0) const
	Retrieve complete vector to the active all/block/boundary restricted objects for a given thread. More...
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > &	getActiveBlockObjects (THREAD_ID tid=0) const
const std::vector< std::shared_ptr< T > > &	getActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > &	getActiveBoundaryObjects (THREAD_ID tid=0) const
const std::vector< std::shared_ptr< T > > &	getActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
bool	hasActiveObjects (THREAD_ID tid=0) const
	Convenience functions for determining if objects exist. More...
bool	hasActiveBlockObjects (THREAD_ID tid=0) const
bool	hasActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const
bool	hasActiveBoundaryObjects (THREAD_ID tid=0) const
bool	hasActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
bool	hasActiveObject (const std::string &name, THREAD_ID tid=0) const
	Convenience functions for checking/getting specific objects. More...
std::shared_ptr< T >	getActiveObject (const std::string &name, THREAD_ID tid=0) const
void	updateVariableDependency (std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const
	Update variable dependency vector. More...
void	updateBlockVariableDependency (SubdomainID id, std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const
void	updateBoundaryVariableDependency (std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const
void	updateBoundaryVariableDependency (BoundaryID id, std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const
void	updateMatPropDependency (std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
	Update material property dependency vector. More...
void	updateBlockMatPropDependency (SubdomainID id, std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
void	updateBoundaryMatPropDependency (std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
void	updateBoundaryMatPropDependency (BoundaryID id, std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const

Protected Member Functions
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
	Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) More...
std::vector< std::vector< std::shared_ptr< T > > >	_all_objects
	Storage container for the ALL pointers (THREAD_ID on outer vector) More...
std::vector< std::vector< std::shared_ptr< T > > >	_active_objects
	All active objects (THREAD_ID on outer vector) More...
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > >	_all_block_objects
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > >	_active_block_objects
	Active block restricted objects (THREAD_ID on outer vector) More...
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > >	_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > >	_active_boundary_objects
	Active boundary restricted objects (THREAD_ID on outer vector) More...

Detailed Description

template<typename T>
class MooseObjectWarehouseBase< T >

A base storage container for MooseObjects.

Definition at line 28 of file MooseObjectWarehouseBase.h.

Constructor & Destructor Documentation

MooseObjectWarehouseBase()

template<typename T >

MooseObjectWarehouseBase< T >::MooseObjectWarehouseBase

(

bool

threaded = true

)

Constructor.

Parameters

threaded

When true (default) threaded storage is enabled.

Definition at line 215 of file MooseObjectWarehouseBase.h.

  : _num_threads(threaded ? libMesh::n_threads() : 1),
    _all_objects(_num_threads),
    _active_objects(_num_threads),
    _all_block_objects(_num_threads),
    _active_block_objects(_num_threads),
    _all_boundary_objects(_num_threads),
    _active_boundary_objects(_num_threads)
{
}

~MooseObjectWarehouseBase()

template<typename T >

MooseObjectWarehouseBase< T >::~MooseObjectWarehouseBase ( )

virtual

Destructor.

Definition at line 227 of file MooseObjectWarehouseBase.h.

{
}

Member Function Documentation

addObject()

template<typename T>

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

virtual

Adds an object to the storage structure.

Parameters

tid	The thread ID (default is 0)
recurse	Whether or not to build recusive warehouses (typically for Kernels)

Reimplemented in MooseObjectWarehouse< T >, MooseObjectWarehouse< NodalDamper >, MooseObjectWarehouse< TransientMultiApp >, MooseObjectWarehouse< Sampler >, MooseObjectWarehouse< NodalBCBase >, MooseObjectWarehouse< DGKernel >, MooseObjectWarehouse< GeneralDamper >, MooseObjectWarehouse< NodalKernel >, MooseObjectWarehouse< PresetNodalBC >, MooseObjectWarehouse< UserObject >, MooseObjectWarehouse< AuxScalarKernel >, MooseObjectWarehouse< DiracKernel >, MooseObjectWarehouse< IntegratedBCBase >, MooseObjectWarehouse< ScalarKernel >, MooseObjectWarehouse< KernelBase >, MooseObjectWarehouse< Material >, MooseObjectWarehouse< AuxKernel >, MooseObjectWarehouse< MultiApp >, MooseObjectWarehouse< Function >, MooseObjectWarehouse< NodalConstraint >, MooseObjectWarehouse< Marker >, MooseObjectWarehouse< InterfaceKernel >, MooseObjectWarehouse< ElementDamper >, MooseObjectWarehouse< Constraint >, MooseObjectWarehouse< Control >, MooseObjectWarehouse< Transfer >, MooseObjectWarehouse< InternalSideIndicator >, MooseObjectWarehouse< Indicator >, ExecuteMooseObjectWarehouse< T >, ExecuteMooseObjectWarehouse< TransientMultiApp >, ExecuteMooseObjectWarehouse< Sampler >, ExecuteMooseObjectWarehouse< UserObject >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< AuxKernel >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< Transfer >, ConstraintWarehouse, and InitialConditionWarehouse.

Definition at line 241 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::addDistribution(), FEProblemBase::addInitialCondition(), InitialConditionWarehouse::addObject(), MooseObjectWarehouse< Indicator >::addObject(), and NonlinearSystemBase::addSplit().

{
  checkThreadID(tid);

  // Stores object in list of all objects
  _all_objects[tid].push_back(object);

  // If enabled, store object in a list of all active
  bool enabled = object->enabled();
  if (enabled)
    _active_objects[tid].push_back(object);

  // Perform casts to the Block/BoundaryRestrictable
  std::shared_ptr<BoundaryRestrictable> bnd =
      std::dynamic_pointer_cast<BoundaryRestrictable>(object);
  std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);

  // Boundary Restricted
  if (bnd && bnd->boundaryRestricted())
  {
    const std::set<BoundaryID> & ids = bnd->boundaryIDs();
    for (std::set<BoundaryID>::const_iterator it = ids.begin(); it != ids.end(); ++it)
    {
      _all_boundary_objects[tid][*it].push_back(object);
      if (enabled)
        _active_boundary_objects[tid][*it].push_back(object);
    }
  }

  // Block Restricted
  else if (blk)
  {
    const std::set<SubdomainID> & ids =
        blk->blockRestricted() ? blk->blockIDs() : blk->meshBlockIDs();
    for (std::set<SubdomainID>::const_iterator it = ids.begin(); it != ids.end(); ++it)
    {
      _all_block_objects[tid][*it].push_back(object);
      if (enabled)
        _active_block_objects[tid][*it].push_back(object);
    }

    // Check variables
    std::shared_ptr<Coupleable> c_ptr = std::dynamic_pointer_cast<Coupleable>(object);
    if (c_ptr)
      for (MooseVariableFEBase * var : c_ptr->getCoupledMooseVars())
        blk->checkVariable(*var);

    const InputParameters & parameters = object->parameters();

    SubProblem & problem = *parameters.get<SubProblem *>("_subproblem");

    THREAD_ID tid = parameters.get<THREAD_ID>("_tid");

    if (parameters.isParamValid("variable"))
    {
      // Try the scalar version first
      std::string variable_name = parameters.getMooseType("variable");
      if (variable_name == "")
        // When using vector variables, we are only going to use the first one in the list at the
        // interface level...
        variable_name = parameters.getVecMooseType("variable")[0];

      blk->checkVariable(problem.getVariable(
          tid, variable_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY));
    }
  }
}

checkThreadID()

template<typename T>

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

inlineprotected

Calls assert on thread id.

Definition at line 673 of file MooseObjectWarehouseBase.h.

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

getActiveBlockObjects() [1/2]

template<typename T >

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

inline

Definition at line 386 of file MooseObjectWarehouseBase.h.

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

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

getActiveBlockObjects() [2/2]

template<typename T >

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

Definition at line 394 of file MooseObjectWarehouseBase.h.

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

getActiveBlocks()

template<typename T >

std::set< SubdomainID > MooseObjectWarehouseBase< T >::getActiveBlocks

(

THREAD_ID

tid = 0

)

const

Return a set of active SubdomainsIDs.

Definition at line 475 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::checkProblemIntegrity().

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

getActiveBoundaryObjects() [1/2]

template<typename T >

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

inline

Definition at line 367 of file MooseObjectWarehouseBase.h.

Referenced by ComputeFullJacobianThread::computeFaceJacobian(), ComputeJacobianThread::computeFaceJacobian(), ComputeFullJacobianThread::computeInternalInterFaceJacobian(), ComputeJacobianThread::computeInternalInterFaceJacobian(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), ComputeResidualThread::onBoundary(), ComputeMaterialsObjectThread::onBoundary(), ComputeResidualThread::onInterface(), ComputeBoundaryInitialConditionThread::onNode(), 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

Definition at line 375 of file MooseObjectWarehouseBase.h.

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

getActiveObject()

template<typename T >

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

Definition at line 464 of file MooseObjectWarehouseBase.h.

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

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

getActiveObjects()

template<typename T >

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

inline

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

Parameters

tid	The thread id to retrieve objects from

Definition at line 359 of file MooseObjectWarehouseBase.h.

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

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

getBlockObjects() [1/2]

template<typename T >

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

inline

Definition at line 340 of file MooseObjectWarehouseBase.h.

Referenced by MaterialPropertyDebugOutput::printMaterialMap().

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

getBlockObjects() [2/2]

template<typename T >

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

Definition at line 348 of file MooseObjectWarehouseBase.h.

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

getBoundaryObjects() [1/2]

template<typename T >

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

inline

Definition at line 321 of file MooseObjectWarehouseBase.h.

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

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

getBoundaryObjects() [2/2]

template<typename T >

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

Definition at line 329 of file MooseObjectWarehouseBase.h.

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

getObjects()

template<typename T >

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

inline

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

Parameters

tid	The thread id to retrieve objects from

Definition at line 313 of file MooseObjectWarehouseBase.h.

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

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

hasActiveBlockObjects() [1/2]

template<typename T >

bool MooseObjectWarehouseBase< T >::hasActiveBlockObjects

(

THREAD_ID

tid = 0

)

const

Definition at line 413 of file MooseObjectWarehouseBase.h.

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

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

hasActiveBlockObjects() [2/2]

template<typename T >

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

Definition at line 424 of file MooseObjectWarehouseBase.h.

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

hasActiveBoundaryObjects() [1/2]

template<typename T >

bool MooseObjectWarehouseBase< T >::hasActiveBoundaryObjects

(

THREAD_ID

tid = 0

)

const

Definition at line 433 of file MooseObjectWarehouseBase.h.

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

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

hasActiveBoundaryObjects() [2/2]

template<typename T >

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

Definition at line 444 of file MooseObjectWarehouseBase.h.

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

hasActiveObject()

template<typename T >

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

Convenience functions for checking/getting specific objects.

Definition at line 453 of file MooseObjectWarehouseBase.h.

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

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

hasActiveObjects()

template<typename T >

bool MooseObjectWarehouseBase< T >::hasActiveObjects

(

THREAD_ID

tid = 0

)

const

Convenience functions for determining if objects exist.

Definition at line 405 of file MooseObjectWarehouseBase.h.

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

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

numThreads()

template<typename T>

THREAD_ID MooseObjectWarehouseBase< T >::numThreads ( )

inline

Return the number of threads.

Definition at line 161 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearEigenSystem::addEigenTagToMooseObjects().

{ return _num_threads; }

size()

template<typename T >

unsigned int MooseObjectWarehouseBase< T >::size

(

THREAD_ID

tid = 0

)

Return how many kernels we store in the current warehouse.

Definition at line 233 of file MooseObjectWarehouseBase.h.

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

sort()

template<typename T >

void MooseObjectWarehouseBase< T >::sort

(

THREAD_ID

tid = 0

)

Sort the objects using the DependencyResolver.

Definition at line 515 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 )

staticprotected

Helper method for sorting vectors of objects.

Definition at line 653 of file MooseObjectWarehouseBase.h.

{
  // Do nothing if the vector is empty
  if (objects.empty())
    return;

  try
  {
    // Sort based on dependencies
    DependencyResolverInterface::sort<std::shared_ptr<T>>(objects);
  }
  catch (CyclicDependencyException<std::shared_ptr<T>> & e)
  {
    DependencyResolverInterface::cyclicDependencyError<std::shared_ptr<T>>(
        e, "Cyclic dependency detected in object ordering");
  }
}

subdomainsCovered()

template<typename T >

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

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

Definition at line 640 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearSystemBase::checkKernelCoverage().

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

  for (const auto & object_pair : _active_block_objects[tid])
    subdomains_covered.insert(object_pair.first);
}

updateActive()

template<typename T >

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

virtual

Updates the active objects storage.

Reimplemented in ExecuteMooseObjectWarehouse< T >, MooseObjectWarehouse< T >, MooseObjectWarehouse< NodalDamper >, MooseObjectWarehouse< TransientMultiApp >, MooseObjectWarehouse< Sampler >, MooseObjectWarehouse< NodalBCBase >, MooseObjectWarehouse< DGKernel >, MooseObjectWarehouse< GeneralDamper >, MooseObjectWarehouse< NodalKernel >, MooseObjectWarehouse< PresetNodalBC >, MooseObjectWarehouse< UserObject >, MooseObjectWarehouse< AuxScalarKernel >, MooseObjectWarehouse< DiracKernel >, MooseObjectWarehouse< IntegratedBCBase >, MooseObjectWarehouse< ScalarKernel >, MooseObjectWarehouse< KernelBase >, MooseObjectWarehouse< Material >, MooseObjectWarehouse< AuxKernel >, MooseObjectWarehouse< MultiApp >, MooseObjectWarehouse< Function >, MooseObjectWarehouse< NodalConstraint >, MooseObjectWarehouse< Marker >, MooseObjectWarehouse< InterfaceKernel >, MooseObjectWarehouse< ElementDamper >, MooseObjectWarehouse< Constraint >, MooseObjectWarehouse< Control >, MooseObjectWarehouse< Transfer >, MooseObjectWarehouse< InternalSideIndicator >, MooseObjectWarehouse< Indicator >, ExecuteMooseObjectWarehouse< TransientMultiApp >, ExecuteMooseObjectWarehouse< Sampler >, ExecuteMooseObjectWarehouse< UserObject >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< AuxKernel >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< Transfer >, ConstraintWarehouse, MaterialWarehouse, MooseObjectTagWarehouse< T >, MooseObjectTagWarehouse< NodalBCBase >, MooseObjectTagWarehouse< DGKernel >, MooseObjectTagWarehouse< NodalKernel >, MooseObjectTagWarehouse< DiracKernel >, MooseObjectTagWarehouse< IntegratedBCBase >, MooseObjectTagWarehouse< ScalarKernel >, MooseObjectTagWarehouse< KernelBase >, and MooseObjectTagWarehouse< InterfaceKernel >.

Definition at line 486 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouse< Indicator >::updateActive().

{
  checkThreadID(tid);

  updateActiveHelper(_active_objects[tid], _all_objects[tid]);

  for (const auto & object_pair : _all_block_objects[tid])
    updateActiveHelper(_active_block_objects[tid][object_pair.first], object_pair.second);

  for (const auto & object_pair : _all_boundary_objects[tid])
    updateActiveHelper(_active_boundary_objects[tid][object_pair.first], object_pair.second);
}

updateActiveHelper()

template<typename T>

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

staticprotected

Helper method for updating active vectors.

Definition at line 501 of file MooseObjectWarehouseBase.h.

{
  // Clear the active list
  active.clear();

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

updateBlockMatPropDependency()

template<typename T >

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

Definition at line 599 of file MooseObjectWarehouseBase.h.

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

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

updateBlockVariableDependency()

template<typename T >

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

Definition at line 542 of file MooseObjectWarehouseBase.h.

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

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

updateBoundaryMatPropDependency() [1/2]

template<typename T >

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

Definition at line 609 of file MooseObjectWarehouseBase.h.

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

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

updateBoundaryMatPropDependency() [2/2]

template<typename T >

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

Definition at line 619 of file MooseObjectWarehouseBase.h.

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

updateBoundaryVariableDependency() [1/2]

template<typename T >

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

Definition at line 553 of file MooseObjectWarehouseBase.h.

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

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

updateBoundaryVariableDependency() [2/2]

template<typename T >

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

Definition at line 566 of file MooseObjectWarehouseBase.h.

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

updateMatPropDependency()

template<typename T >

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

Update material property dependency vector.

Definition at line 590 of file MooseObjectWarehouseBase.h.

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

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

updateMatPropDependencyHelper()

template<typename T>

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

staticprotected

Helper method for updating material property dependency vector.

Definition at line 628 of file MooseObjectWarehouseBase.h.

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

updateVariableDependency()

template<typename T >

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

Update variable dependency vector.

Definition at line 533 of file MooseObjectWarehouseBase.h.

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

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

updateVariableDependencyHelper()

template<typename T>

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

staticprotected

Helper method for updating variable dependency vector.

Definition at line 577 of file MooseObjectWarehouseBase.h.

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

Member Data Documentation

_active_block_objects

template<typename T>

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

protected

Active block restricted objects (THREAD_ID on outer vector)

Definition at line 177 of file MooseObjectWarehouseBase.h.

_active_boundary_objects

template<typename T>

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

protected

Active boundary restricted objects (THREAD_ID on outer vector)

Definition at line 183 of file MooseObjectWarehouseBase.h.

_active_objects

template<typename T>

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

protected

All active objects (THREAD_ID on outer vector)

Definition at line 171 of file MooseObjectWarehouseBase.h.

_all_block_objects

template<typename T>

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

protected

Definition at line 174 of file MooseObjectWarehouseBase.h.

_all_boundary_objects

template<typename T>

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

protected

Definition at line 180 of file MooseObjectWarehouseBase.h.

_all_objects

template<typename T>

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

protected

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

Definition at line 168 of file MooseObjectWarehouseBase.h.

_num_threads

template<typename T>

const THREAD_ID MooseObjectWarehouseBase< T >::_num_threads

protected

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

Definition at line 165 of file MooseObjectWarehouseBase.h.

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

---

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

• include/warehouses/MooseObjectWarehouseBase.h