https://mooseframework.inl.gov
Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
MooseObjectTagWarehouse< T > Class Template Reference

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

#include <BoundaryElemIntegrityCheckThread.h>

Inheritance diagram for MooseObjectTagWarehouse< T >:
[legend]

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...
 
const MooseObjectWarehouse< T > & getMatrixTagObjectWarehouse (TagID tag_id, THREAD_ID tid) const
 const version of the above 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...
 
bool hasVariableObjects (unsigned int variable_id, THREAD_ID tid=0) const
 Checks for whether this warehouse has objects for a given variable. More...
 
unsigned int size (THREAD_ID tid=0) const
 Return how many kernels we store in the current warehouse. More...
 
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. More...
 
std::set< SubdomainID > getActiveBlocks (THREAD_ID tid=0) const
 Return a set of active SubdomainsIDs. More...
 
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. 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 () const
 Return the number of threads. More...
 
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. 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 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. 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 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. 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< MooseVariableFieldBase *> &needed_moose_vars, THREAD_ID tid=0) const
 Update variable dependency vector. More...
 
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. More...
 
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. More...
 
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. More...
 
void checkThreadID (THREAD_ID tid) const
 Calls assert on thread id. More...
 
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. 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< MooseVariableFieldBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
 Helper method for updating variable dependency vector. More...
 
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. 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...
 
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. 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 19 of file BoundaryElemIntegrityCheckThread.h.

Constructor & Destructor Documentation

◆ MooseObjectTagWarehouse()

template<typename T >
MooseObjectTagWarehouse< T >::MooseObjectTagWarehouse ( bool  threaded = true)

Constructor.

Parameters
threadedWhen true (default) threaded storage is enabled.

Definition at line 93 of file MooseObjectTagWarehouse.h.

94  : MooseObjectWarehouse<T>(threaded),
95  _num_threads(threaded ? libMesh::n_threads() : 1),
96  _vector_tag_to_object_warehouse(_num_threads),
97  _vector_tags_to_object_warehouse(_num_threads),
98  _matrix_tag_to_object_warehouse(_num_threads),
99  _matrix_tags_to_object_warehouse(_num_threads)
100 {
101 }
libMesh::n_threads
unsigned int n_threads()
MooseObjectTagWarehouse::_vector_tags_to_object_warehouse
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 tag...
Definition: MooseObjectTagWarehouse.h:83
MooseObjectWarehouse
A storage container for MooseObjects that inherit from SetupInterface.
Definition: ComputeDiracThread.h:22
MooseObjectTagWarehouse::_matrix_tags_to_object_warehouse
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...
Definition: MooseObjectTagWarehouse.h:89
MooseObjectTagWarehouse::_matrix_tag_to_object_warehouse
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.
Definition: MooseObjectTagWarehouse.h:86
MooseObjectTagWarehouse::_vector_tag_to_object_warehouse
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.
Definition: MooseObjectTagWarehouse.h:80

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
tidthe thread id
prefixa string to prepend to the string

Definition at line 898 of file MooseObjectWarehouseBase.h.

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

900 {
901  std::vector<std::string> output;
902  for (const auto & object : _active_objects[tid])
903  output.push_back(object->name());
904  return ConsoleUtils::formatString(MooseUtils::join(output, " "), prefix);
905 }
ConsoleUtils::formatString
std::string formatString(std::string message, const std::string &prefix)
Add new lines and prefixes to a string for pretty display in output NOTE: This makes a copy of the st...
Definition: ConsoleUtils.C:583
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

◆ 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
objectA shared pointer to the object being added
tidThe thread ID (default is 0)
recurseWhether or not to build recusive warehouses (typically for Kernels)

Reimplemented from MooseObjectWarehouseBase< T >.

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

Definition at line 99 of file MooseObjectWarehouse.h.

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

102 {
103  MooseObjectWarehouseBase<T>::addObject(object, tid, recurse);
104 
105  if (recurse)
106  {
107  if (auto mvir = std::dynamic_pointer_cast<MooseVariableInterface<Real>>(object); mvir)
108  _variable_objects[mvir->mooseVariableBase()->number()].addObject(object, tid, false);
109  else if (auto mviv = std::dynamic_pointer_cast<MooseVariableInterface<RealVectorValue>>(object);
110  mviv)
111  _variable_objects[mviv->mooseVariableBase()->number()].addObject(object, tid, false);
112  else if (auto mvie = std::dynamic_pointer_cast<MooseVariableInterface<RealEigenVector>>(object);
113  mvie)
114  _variable_objects[mvie->mooseVariableBase()->number()].addObject(object, tid, false);
115  // Some objects, such as ScalarKernels, do not inherit from the MooseVariableInterface (which is
116  // for field variables). These objects *do* inherit from ResidualObject which has this more
117  // generic variable() API
118  else if (auto ro = std::dynamic_pointer_cast<ResidualObject>(object); ro)
119  _variable_objects[ro->variable().number()].addObject(object, tid, false);
120  }
121 }
dynamic_pointer_cast
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
Definition: CastUniquePointer.h:22
MooseObjectWarehouse::_variable_objects
std::map< unsigned int, MooseObjectWarehouse< T > > _variable_objects
Variable based storage.
Definition: MooseObjectWarehouse.h:88
MooseObjectWarehouseBase::addObject
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true)
Adds an object to the storage structure.
Definition: MooseObjectWarehouseBase.h:314

◆ checkThreadID()

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

Calls assert on thread id.

Definition at line 929 of file MooseObjectWarehouseBase.h.

930 {
931  mooseAssert(tid < _num_threads,
932  "Attempting to access a thread id ("
933  << tid << ") greater than the number allowed by the storage item ("
934  << _num_threads << ")");
935 }
MooseObjectWarehouseBase::_num_threads
const THREAD_ID _num_threads
Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) ...
Definition: MooseObjectWarehouseBase.h:217

◆ customSetup()

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

Definition at line 176 of file MooseObjectWarehouse.h.

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

177 {
178  checkThreadID(tid);
179  for (const auto & object : _active_objects[tid])
180  object->customSetup(exec_type);
181 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

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

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

470 {
471  checkThreadID(tid);
472  return _active_block_objects[tid];
473 }
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:229
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

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

478 {
479  checkThreadID(tid);
480  const auto iter = _active_block_objects[tid].find(id);
481  mooseAssert(iter != _active_block_objects[tid].end(),
482  "Unable to located active block objects for the given id: " << id << ".");
483  return iter->second;
484 }
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:229
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

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

Referenced by FEProblemBase::checkProblemIntegrity().

650 {
651  checkThreadID(tid);
652  std::set<SubdomainID> ids;
653  for (const auto & object_pair : _active_block_objects[tid])
654  ids.insert(object_pair.first);
655  return ids;
656 }
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:229
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

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

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

451 {
452  checkThreadID(tid);
453  return _active_boundary_objects[tid];
454 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:235

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

459 {
460  checkThreadID(tid);
461  const auto iter = _active_boundary_objects[tid].find(id);
462  mooseAssert(iter != _active_boundary_objects[tid].end(),
463  "Unable to located active boundary objects for the given id: " << id << ".");
464  return iter->second;
465 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:235

◆ getActiveObject()

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

Definition at line 630 of file MooseObjectWarehouseBase.h.

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

631 {
632  checkThreadID(tid);
633  for (const auto & object : _active_objects[tid])
634  if (object->name() == name)
635  return object;
636  mooseError("Unable to locate active object: ", name, ".");
637 }
name
std::string name(const ElemQuality q)
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:311
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

◆ 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
tidThe thread id to retrieve objects from

Definition at line 442 of file MooseObjectWarehouseBase.h.

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::execTransfers(), FEProblemBase::finalizeMultiApps(), FEProblemBase::finishMultiAppStep(), ConstraintWarehouse::getActiveNodalConstraints(), FEProblemBase::getConvergenceObjects(), AuxiliarySystem::getDependObjects(), FEProblemBase::getTransfers(), FEProblemBase::incrementMultiAppTStep(), FEProblemBase::initialSetup(), NonlinearSystemBase::needBoundaryMaterialOnSide(), ComputeElemDampingThread::onElement(), ComputeDiracThread::onElement(), ComputeNodalDampingThread::onNode(), FEProblemBase::postExecute(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::restoreMultiApps(), and AuxiliarySystem::setScalarVariableCoupleableTags().

443 {
444  checkThreadID(tid);
445  return _active_objects[tid];
446 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

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

Referenced by ComputeFullJacobianThread::computeOnElement().

146 {
147  checkThreadID(tid);
148  const auto iter = _variable_objects.find(variable_id);
149  mooseAssert(iter != _variable_objects.end(),
150  "Unable to locate variable kernels for the given variable id: " << variable_id
151  << ".");
152  return iter->second.getActiveBlockObjects(block_id, tid);
153 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouse::_variable_objects
std::map< unsigned int, MooseObjectWarehouse< T > > _variable_objects
Variable based storage.
Definition: MooseObjectWarehouse.h:88

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

Referenced by MaterialPropertyDebugOutput::printMaterialMap().

424 {
425  checkThreadID(tid);
426  return _all_block_objects[tid];
427 }
MooseObjectWarehouseBase::_all_block_objects
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
Definition: MooseObjectWarehouseBase.h:226
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

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

432 {
433  checkThreadID(tid);
434  const auto iter = _all_block_objects[tid].find(id);
435  mooseAssert(iter != _all_block_objects[tid].end(),
436  "Unable to located active block objects for the given id: " << id << ".");
437  return iter->second;
438 }
MooseObjectWarehouseBase::_all_block_objects
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
Definition: MooseObjectWarehouseBase.h:226
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

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

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

397 {
398  checkThreadID(tid);
399  return _all_boundary_objects[tid];
400 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
Definition: MooseObjectWarehouseBase.h:232

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

413 {
414  checkThreadID(tid);
415  const auto iter = _all_boundary_objects[tid].find(id);
416  mooseAssert(iter != _all_boundary_objects[tid].end(),
417  "Unable to located active boundary objects for the given id: " << id << ".");
418  return iter->second;
419 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
Definition: MooseObjectWarehouseBase.h:232

◆ getMatrixTagObjectWarehouse() [1/2]

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 157 of file MooseObjectTagWarehouse.h.

Referenced by NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeScalarKernelsJacobians(), ComputeJacobianThread::determineObjectWarehouses(), ExplicitTimeIntegrator::initialSetup(), ComputeNodalKernelBCJacobiansThread::pre(), ComputeNodalKernelJacobiansThread::pre(), and ComputeDiracThread::subdomainChanged().

158 {
159  auto & matrix_tag_to_object_warehouse = _matrix_tag_to_object_warehouse[tid];
160 
161  const auto & house_end = matrix_tag_to_object_warehouse.end();
162  const auto & tag_warehouse = matrix_tag_to_object_warehouse.find(tag_id);
163 
164  if (tag_warehouse != house_end)
165  return tag_warehouse->second;
166  else
167  matrix_tag_to_object_warehouse[tag_id];
168 
169  // Add moose objects to matrix-tag warehouse
170  const auto & objects = MooseObjectWarehouse<T>::getObjects(tid);
171  for (auto & object : objects)
172  {
173  auto & tags = object->getMatrixTags({});
174  for (auto & tag : tags)
175  {
176  if (tag == tag_id)
177  {
178  // Tag based storage
179  matrix_tag_to_object_warehouse[tag_id].addObject(object, tid);
180 
181  break;
182  }
183  }
184  }
185 
186  return matrix_tag_to_object_warehouse[tag_id];
187 }
MooseObjectWarehouseBase::getObjects
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...
Definition: MooseObjectWarehouseBase.h:388
MooseObjectTagWarehouse::_matrix_tag_to_object_warehouse
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.
Definition: MooseObjectTagWarehouse.h:86

◆ getMatrixTagObjectWarehouse() [2/2]

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

const version of the above

Definition at line 191 of file MooseObjectTagWarehouse.h.

192 {
193  return const_cast<MooseObjectTagWarehouse<T> *>(this)->getMatrixTagObjectWarehouse(tag_id, tid);
194 }
MooseObjectTagWarehouse::getMatrixTagObjectWarehouse
MooseObjectWarehouse< T > & getMatrixTagObjectWarehouse(TagID tag_id, THREAD_ID tid)
Retrieve a moose object warehouse in which every moose object has the given matrix tag...
Definition: MooseObjectTagWarehouse.h:157
MooseObjectTagWarehouse
A storage container for MooseObjects that inherit from SetupInterface.
Definition: BoundaryElemIntegrityCheckThread.h:19

◆ 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 237 of file MooseObjectTagWarehouse.h.

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

239 {
240  auto & matrix_tags_to_object_warehouse = _matrix_tags_to_object_warehouse[tid];
241 
242  const auto & house_end = matrix_tags_to_object_warehouse.end();
243  const auto & tags_warehouse = matrix_tags_to_object_warehouse.find(m_tags);
244 
245  if (tags_warehouse != house_end)
246  return tags_warehouse->second;
247  else
248  matrix_tags_to_object_warehouse[m_tags];
249 
250  const auto & objects = MooseObjectWarehouse<T>::getObjects(tid);
251  for (auto & object : objects)
252  {
253  auto & tags = object->getMatrixTags({});
254  const auto & tags_end = tags.end();
255  for (auto & m_tag : m_tags)
256  {
257  const auto & tag_found = tags.find(m_tag);
258  // Object contains at least one of required tags
259  if (tag_found != tags_end)
260  {
261  // std::vector<Tag> based storage
262  matrix_tags_to_object_warehouse[m_tags].addObject(object, tid);
263  // Then we should work for next object
264  break;
265  }
266  }
267  }
268 
269  return matrix_tags_to_object_warehouse[m_tags];
270 }
MooseObjectWarehouseBase::getObjects
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...
Definition: MooseObjectWarehouseBase.h:388
MooseObjectTagWarehouse::_matrix_tags_to_object_warehouse
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...
Definition: MooseObjectTagWarehouse.h:89

◆ getObject()

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

Definition at line 619 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::getMultiApp().

620 {
621  checkThreadID(tid);
622  for (const auto & object : _all_objects[tid])
623  if (object->name() == name)
624  return object;
625  mooseError("Unable to locate object: ", name, ".");
626 }
name
std::string name(const ElemQuality q)
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:311
MooseObjectWarehouseBase::_all_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

◆ 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
tidThe thread id to retrieve objects from

Definition at line 388 of file MooseObjectWarehouseBase.h.

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

389 {
390  checkThreadID(tid);
391  return _all_objects[tid];
392 }
MooseObjectWarehouseBase::_all_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

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

643 {
644  return libmesh_map_find(_all_variable_objects[tid], var_name);
645 }
MooseObjectWarehouseBase::_all_variable_objects
std::vector< std::map< VariableName, std::vector< std::shared_ptr< T > > > > _all_variable_objects
All objects with a certain variable selected, as the &#39;variable&#39; parameter.
Definition: MooseObjectWarehouseBase.h:238

◆ 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 124 of file MooseObjectTagWarehouse.h.

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

125 {
126  auto & vector_tag_to_object_warehouse = _vector_tag_to_object_warehouse[tid];
127 
128  const auto & house_end = vector_tag_to_object_warehouse.end();
129  const auto & tag_warehouse = vector_tag_to_object_warehouse.find(tag_id);
130 
131  if (tag_warehouse != house_end)
132  return tag_warehouse->second;
133  else
134  vector_tag_to_object_warehouse[tag_id];
135 
136  // Now add actual moose objects into warehouse
137  const auto & objects = MooseObjectWarehouse<T>::getObjects(tid);
138  for (auto & object : objects)
139  {
140  auto & tags = object->getVectorTags({});
141  for (auto & tag : tags)
142  {
143  if (tag == tag_id)
144  {
145  // Tag based storage
146  vector_tag_to_object_warehouse[tag_id].addObject(object, tid);
147  break;
148  }
149  }
150  }
151 
152  return vector_tag_to_object_warehouse[tag_id];
153 }
MooseObjectWarehouseBase::getObjects
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...
Definition: MooseObjectWarehouseBase.h:388
MooseObjectTagWarehouse::_vector_tag_to_object_warehouse
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.
Definition: MooseObjectTagWarehouse.h:80

◆ 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 198 of file MooseObjectTagWarehouse.h.

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

200 {
201  // std::map is not thread-safe for writes
202  auto & vector_tags_to_object_warehouse = _vector_tags_to_object_warehouse[tid];
203 
204  const auto & house_end = vector_tags_to_object_warehouse.end();
205  const auto & tags_warehouse = vector_tags_to_object_warehouse.find(v_tags);
206 
207  if (tags_warehouse != house_end)
208  return tags_warehouse->second;
209  else
210  vector_tags_to_object_warehouse[v_tags];
211 
212  // Add moose objects to vector-tags warehouse
213  const auto & objects = MooseObjectWarehouse<T>::getObjects(tid);
214  for (auto & object : objects)
215  {
216  auto & tags = object->getVectorTags({});
217  const auto & tags_end = tags.end();
218  for (auto & v_tag : v_tags)
219  {
220  const auto & tag_found = tags.find(v_tag);
221  // Object contains at least one of required tags
222  if (tag_found != tags_end)
223  {
224  // std::vector<Tag> based storage
225  vector_tags_to_object_warehouse[v_tags].addObject(object, tid);
226  // Then we should work for next object
227  break;
228  }
229  }
230  }
231 
232  return vector_tags_to_object_warehouse[v_tags];
233 }
MooseObjectTagWarehouse::_vector_tags_to_object_warehouse
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 tag...
Definition: MooseObjectTagWarehouse.h:83
MooseObjectWarehouseBase::getObjects
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...
Definition: MooseObjectWarehouseBase.h:388

◆ hasActiveBlockObjects() [1/2]

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

Definition at line 552 of file MooseObjectWarehouseBase.h.

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

553 {
554  checkThreadID(tid);
555  bool has_active_block_objects = false;
556  for (const auto & object_pair : _active_block_objects[tid])
557  has_active_block_objects |= !(object_pair.second.empty());
558  return has_active_block_objects;
559 }
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:229
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

◆ hasActiveBlockObjects() [2/2]

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

Definition at line 563 of file MooseObjectWarehouseBase.h.

564 {
565  checkThreadID(tid);
566  const auto iter = _active_block_objects[tid].find(id);
567  return iter != _active_block_objects[tid].end();
568 }
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:229
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

◆ hasActiveBoundaryObjects() [1/2]

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

Definition at line 592 of file MooseObjectWarehouseBase.h.

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

593 {
594  return hasBoundaryObjectsHelper(_active_boundary_objects, tid);
595 }
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:235
MooseObjectWarehouseBase::hasBoundaryObjectsHelper
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.
Definition: MooseObjectWarehouseBase.h:572

◆ hasActiveBoundaryObjects() [2/2]

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

Definition at line 599 of file MooseObjectWarehouseBase.h.

600 {
601  checkThreadID(tid);
602  const auto iter = _active_boundary_objects[tid].find(id);
603  return iter != _active_boundary_objects[tid].end();
604 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:235

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

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

609 {
610  checkThreadID(tid);
611  for (const auto & object : _active_objects[tid])
612  if (object->name() == name)
613  return true;
614  return false;
615 }
name
std::string name(const ElemQuality q)
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

◆ hasActiveObjects()

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

Definition at line 496 of file MooseObjectWarehouseBase.h.

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

497 {
498  checkThreadID(tid);
499  return !_active_objects[tid].empty();
500 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

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

Referenced by ComputeFullJacobianThread::computeOnElement().

136 {
137  auto iter = _variable_objects.find(variable_id);
138  return (iter != _variable_objects.end() && iter->second.hasActiveBlockObjects(block_id, tid));
139 }
MooseObjectWarehouse::_variable_objects
std::map< unsigned int, MooseObjectWarehouse< T > > _variable_objects
Variable based storage.
Definition: MooseObjectWarehouse.h:88

◆ hasBoundaryObjects() [1/2]

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

Definition at line 585 of file MooseObjectWarehouseBase.h.

586 {
587  return hasBoundaryObjectsHelper(_all_boundary_objects, tid);
588 }
MooseObjectWarehouseBase::_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
Definition: MooseObjectWarehouseBase.h:232
MooseObjectWarehouseBase::hasBoundaryObjectsHelper
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.
Definition: MooseObjectWarehouseBase.h:572

◆ hasBoundaryObjects() [2/2]

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

Definition at line 404 of file MooseObjectWarehouseBase.h.

405 {
406  checkThreadID(tid);
407  return _all_boundary_objects[tid].find(id) != _all_boundary_objects[tid].end();
408 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
Definition: MooseObjectWarehouseBase.h:232

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

575 {
576  checkThreadID(tid);
577  bool has_boundary_objects = false;
578  for (const auto & object_pair : boundary_objects[tid])
579  has_boundary_objects |= !(object_pair.second.empty());
580  return has_boundary_objects;
581 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

◆ hasObjects()

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

Convenience functions for determining if objects exist.

Definition at line 488 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::initialSetup(), and NonlinearSystemBase::setInitialSolution().

489 {
490  checkThreadID(tid);
491  return !_all_objects[tid].empty();
492 }
MooseObjectWarehouseBase::_all_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

◆ hasObjectsForVariable()

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

Definition at line 504 of file MooseObjectWarehouseBase.h.

506 {
507  checkThreadID(tid);
508  return _all_variable_objects[tid].count(var_name);
509 }
MooseObjectWarehouseBase::_all_variable_objects
std::vector< std::map< VariableName, std::vector< std::shared_ptr< T > > > > _all_variable_objects
All objects with a certain variable selected, as the &#39;variable&#39; parameter.
Definition: MooseObjectWarehouseBase.h:238
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

◆ 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_namename of the variable
blocksblocks to consider
blocks_coveredsubset of blocks for which there is an object

Definition at line 513 of file MooseObjectWarehouseBase.h.

517 {
518  checkThreadID(tid);
519  blocks_covered.clear();
520  if (!hasObjectsForVariable(var_name, tid))
521  return false;
522 
523  // Check block restriction as a whole
524  for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
525  {
526  std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
527  if (blk && blk->hasBlocks(blocks))
528  {
529  blocks_covered = blocks;
530  return true;
531  }
532  }
533  // No object has all the blocks, but one might overlap, which could be troublesome.
534  // We'll keep track of which blocks are covered in case several overlap
535  for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
536  {
537  std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
538  if (blk)
539  for (const auto & block : blocks)
540  if (blk->hasBlocks(block))
541  blocks_covered.insert(block);
542  }
543  // No overlap at all
544  if (blocks_covered.empty())
545  return false;
546 
547  return (blocks == blocks_covered);
548 }
blocks
char ** blocks
Definition: PetscDMMoose.C:1733
MooseObjectWarehouseBase::_all_variable_objects
std::vector< std::map< VariableName, std::vector< std::shared_ptr< T > > > > _all_variable_objects
All objects with a certain variable selected, as the &#39;variable&#39; parameter.
Definition: MooseObjectWarehouseBase.h:238
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
dynamic_pointer_cast
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
Definition: CastUniquePointer.h:22
MooseObjectWarehouseBase::hasObjectsForVariable
bool hasObjectsForVariable(const VariableName &var_name, THREAD_ID tid) const
Definition: MooseObjectWarehouseBase.h:504
BlockRestrictable
An interface that restricts an object to subdomains via the &#39;blocks&#39; input parameter.
Definition: BlockRestrictable.h:68

◆ hasVariableObjects()

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

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

Definition at line 125 of file MooseObjectWarehouse.h.

Referenced by ExplicitTimeIntegrator::initialSetup().

126 {
127  auto iter = _variable_objects.find(variable_id);
128  return (iter != _variable_objects.end() && iter->second.hasObjects(tid));
129 }
MooseObjectWarehouse::_variable_objects
std::map< unsigned int, MooseObjectWarehouse< T > > _variable_objects
Variable based storage.
Definition: MooseObjectWarehouse.h:88

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

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

158 {
159  checkThreadID(tid);
160  // Initial Setup should be called on all objects because they may become active later
161  for (const auto & object : _all_objects[tid])
162  object->initialSetup();
163 }
MooseObjectWarehouseBase::_all_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

◆ jacobianSetup()

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

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

Definition at line 207 of file MooseObjectWarehouse.h.

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

208 {
209  checkThreadID(tid);
210  for (const auto & object : _active_objects[tid])
211  object->jacobianSetup();
212 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

◆ numThreads()

template<typename T>
THREAD_ID MooseObjectWarehouseBase< T >::numThreads ( ) const
inlineinherited

Return the number of threads.

Definition at line 205 of file MooseObjectWarehouseBase.h.

205 { return _num_threads; }
MooseObjectWarehouseBase::_num_threads
const THREAD_ID _num_threads
Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) ...
Definition: MooseObjectWarehouseBase.h:217

◆ residualSetup()

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

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

Definition at line 216 of file MooseObjectWarehouse.h.

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

217 {
218  checkThreadID(tid);
219  for (const auto & object : _active_objects[tid])
220  object->residualSetup();
221 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

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

Referenced by NonlinearThread::printBlockExecutionInformation().

307 {
308  checkThreadID(tid);
309  return _all_objects[tid].size();
310 }
MooseObjectWarehouseBase::_all_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

◆ sort()

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

Sort the objects using the DependencyResolver.

Definition at line 689 of file MooseObjectWarehouseBase.h.

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

690 {
691  checkThreadID(tid);
692 
693  for (auto & object_pair : _all_block_objects[tid])
694  sortHelper(object_pair.second);
695 
696  for (auto & object_pair : _all_boundary_objects[tid])
697  sortHelper(object_pair.second);
698 
699  sortHelper(_all_objects[tid]);
700 
701  // The active lists now must be update to reflect the order changes
702  updateActive(tid);
703 }
MooseObjectWarehouseBase::_all_block_objects
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
Definition: MooseObjectWarehouseBase.h:226
MooseObjectWarehouseBase::_all_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:220
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::sortHelper
static void sortHelper(std::vector< std::shared_ptr< T >> &objects)
Helper method for sorting vectors of objects.
Definition: MooseObjectWarehouseBase.h:909
MooseObjectWarehouseBase::_all_boundary_objects
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
Definition: MooseObjectWarehouseBase.h:232
MooseObjectWarehouseBase::updateActive
virtual void updateActive(THREAD_ID tid=0)
Updates the active objects storage.
Definition: MooseObjectWarehouseBase.h:660

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

910 {
911  // Do nothing if the vector is empty
912  if (objects.empty())
913  return;
914 
915  try
916  {
917  // Sort based on dependencies
918  DependencyResolverInterface::sort<std::shared_ptr<T>>(objects);
919  }
920  catch (CyclicDependencyException<std::shared_ptr<T>> & e)
921  {
922  DependencyResolverInterface::cyclicDependencyError<std::shared_ptr<T>>(
923  e, "Cyclic dependency detected in object ordering");
924  }
925 }

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

Referenced by NonlinearSystemBase::checkKernelCoverage().

883 {
884  for (const auto & object : _active_objects[tid])
885  {
886  unique_variables.insert(object->variable().name());
887  const auto additional_variables_covered = object->additionalROVariables();
888  unique_variables.insert(additional_variables_covered.begin(),
889  additional_variables_covered.end());
890  }
891 
892  for (const auto & object_pair : _active_block_objects[tid])
893  subdomains_covered.insert(object_pair.first);
894 }
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:229
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

◆ subdomainSetup() [1/2]

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

Reimplemented in MaterialWarehouse.

Definition at line 198 of file MooseObjectWarehouse.h.

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

199 {
200  checkThreadID(tid);
201  for (const auto & object : _active_objects[tid])
202  object->subdomainSetup();
203 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

◆ subdomainSetup() [2/2]

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

Reimplemented in MaterialWarehouse.

Definition at line 185 of file MooseObjectWarehouse.h.

186 {
187  checkThreadID(tid);
188  if (hasActiveBlockObjects(id, tid))
189  {
190  const auto & objects = getActiveBlockObjects(id, tid);
191  for (const auto & object : objects)
192  object->subdomainSetup();
193  }
194 }
MooseObjectWarehouseBase::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:552
MooseObjectWarehouseBase::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:469
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929

◆ timestepSetup()

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

Reimplemented in MaterialWarehouse.

Definition at line 167 of file MooseObjectWarehouse.h.

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

168 {
169  checkThreadID(tid);
170  for (const auto & object : _active_objects[tid])
171  object->timestepSetup();
172 }
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition: MooseObjectWarehouseBase.h:929
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

◆ 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 105 of file MooseObjectTagWarehouse.h.

Referenced by NonlinearSystemBase::updateActive().

106 {
107  MooseObjectWarehouse<T>::updateActive(tid);
108 
109  for (auto & it : _vector_tag_to_object_warehouse[tid])
110  it.second.updateActive(tid);
111 
112  for (auto & it : _vector_tags_to_object_warehouse[tid])
113  it.second.updateActive(tid);
114 
115  for (auto & it : _matrix_tag_to_object_warehouse[tid])
116  it.second.updateActive(tid);
117 
118  for (auto & it : _matrix_tags_to_object_warehouse[tid])
119  it.second.updateActive(tid);
120 }
MooseObjectTagWarehouse::_vector_tags_to_object_warehouse
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 tag...
Definition: MooseObjectTagWarehouse.h:83
MooseObjectTagWarehouse::_matrix_tags_to_object_warehouse
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...
Definition: MooseObjectTagWarehouse.h:89
MooseObjectTagWarehouse::_matrix_tag_to_object_warehouse
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.
Definition: MooseObjectTagWarehouse.h:86
MooseObjectWarehouse::updateActive
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
Definition: MooseObjectWarehouse.h:225
MooseObjectTagWarehouse::_vector_tag_to_object_warehouse
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.
Definition: MooseObjectTagWarehouse.h:80

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

677 {
678  // Clear the active list
679  active.clear();
680 
681  std::copy_if(all.begin(),
682  all.end(),
683  std::back_inserter(active),
684  [](const std::shared_ptr<T> & object) { return object->enabled(); });
685 }

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

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

780 {
781  if (hasActiveBlockObjects(id, tid))
782  updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
783  getActiveBlockObjects(id, tid));
784 }
MooseObjectWarehouseBase::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:552
MooseObjectWarehouseBase::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:469
MooseObjectWarehouseBase::updateFEVariableCoupledVectorTagDependencyHelper
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.
Definition: MooseObjectWarehouseBase.h:798

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

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

830 {
831  if (hasActiveBlockObjects(id, tid))
832  updateMatPropDependencyHelper(needed_mat_props, getActiveBlockObjects(id, tid), producer_only);
833 }
MooseObjectWarehouseBase::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:552
MooseObjectWarehouseBase::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:469
MooseObjectWarehouseBase::updateMatPropDependencyHelper
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.
Definition: MooseObjectWarehouseBase.h:862

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

Referenced by NonlinearThread::subdomainChanged().

720 {
721  if (hasActiveBlockObjects(id, tid))
722  updateVariableDependencyHelper(needed_moose_vars, getActiveBlockObjects(id, tid));
723 }
MooseObjectWarehouseBase::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:552
MooseObjectWarehouseBase::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:469
MooseObjectWarehouseBase::updateVariableDependencyHelper
static void updateVariableDependencyHelper(std::set< MooseVariableFieldBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating variable dependency vector.
Definition: MooseObjectWarehouseBase.h:751

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

Referenced by ComputeNodalKernelBcsThread::onNode().

790 {
791  if (hasActiveBoundaryObjects(id, tid))
792  updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
793  getActiveBoundaryObjects(id, tid));
794 }
MooseObjectWarehouseBase::updateFEVariableCoupledVectorTagDependencyHelper
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.
Definition: MooseObjectWarehouseBase.h:798
MooseObjectWarehouseBase::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:592
MooseObjectWarehouseBase::getActiveBoundaryObjects
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:450

◆ updateBoundaryMatPropDependency() [1/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 837 of file MooseObjectWarehouseBase.h.

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

841 {
842  if (hasActiveBoundaryObjects(tid))
843  for (auto & active_bnd_object : _active_boundary_objects[tid])
844  updateMatPropDependencyHelper(needed_mat_props, active_bnd_object.second, producer_only);
845 }
MooseObjectWarehouseBase::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:592
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:235
MooseObjectWarehouseBase::updateMatPropDependencyHelper
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.
Definition: MooseObjectWarehouseBase.h:862

◆ updateBoundaryMatPropDependency() [2/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 849 of file MooseObjectWarehouseBase.h.

854 {
855  if (hasActiveBoundaryObjects(id, tid))
856  updateMatPropDependencyHelper(
857  needed_mat_props, getActiveBoundaryObjects(id, tid), producer_only);
858 }
MooseObjectWarehouseBase::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:592
MooseObjectWarehouseBase::getActiveBoundaryObjects
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:450
MooseObjectWarehouseBase::updateMatPropDependencyHelper
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.
Definition: MooseObjectWarehouseBase.h:862

◆ updateBoundaryVariableDependency() [1/2]

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

Definition at line 727 of file MooseObjectWarehouseBase.h.

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

729 {
730  if (hasActiveBoundaryObjects(tid))
731  {
732  typename std::map<BoundaryID, std::vector<std::shared_ptr<T>>>::const_iterator it;
733  for (const auto & object_pair : _active_boundary_objects[tid])
734  updateVariableDependencyHelper(needed_moose_vars, object_pair.second);
735  }
736 }
MooseObjectWarehouseBase::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:592
MooseObjectWarehouseBase::_active_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)
Definition: MooseObjectWarehouseBase.h:235
MooseObjectWarehouseBase::updateVariableDependencyHelper
static void updateVariableDependencyHelper(std::set< MooseVariableFieldBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating variable dependency vector.
Definition: MooseObjectWarehouseBase.h:751

◆ updateBoundaryVariableDependency() [2/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 740 of file MooseObjectWarehouseBase.h.

744 {
745  if (hasActiveBoundaryObjects(id, tid))
746  updateVariableDependencyHelper(needed_moose_vars, getActiveBoundaryObjects(id, tid));
747 }
MooseObjectWarehouseBase::hasActiveBoundaryObjects
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:592
MooseObjectWarehouseBase::updateVariableDependencyHelper
static void updateVariableDependencyHelper(std::set< MooseVariableFieldBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating variable dependency vector.
Definition: MooseObjectWarehouseBase.h:751
MooseObjectWarehouseBase::getActiveBoundaryObjects
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:450

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

770 {
771  if (hasActiveObjects(tid))
772  updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
773  _active_objects[tid]);
774 }
MooseObjectWarehouseBase::updateFEVariableCoupledVectorTagDependencyHelper
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.
Definition: MooseObjectWarehouseBase.h:798
MooseObjectWarehouseBase::hasActiveObjects
bool hasActiveObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:496
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

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

800 {
801  for (const auto & object : objects)
802  {
803  auto c = dynamic_cast<const Coupleable *>(object.get());
804  if (c)
805  {
806  const auto & tag_deps = c->getFEVariableCoupleableVectorTags();
807  needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
808  }
809  }
810 }
Coupleable
Interface for objects that needs coupling capabilities.
Definition: Coupleable.h:52
Coupleable::getFEVariableCoupleableVectorTags
std::set< TagID > & getFEVariableCoupleableVectorTags()
Definition: Coupleable.h:120

◆ 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_onlyOnly append dependencies of materials producing the needed_mat_props

Definition at line 814 of file MooseObjectWarehouseBase.h.

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

818 {
819  if (hasActiveObjects(tid))
820  updateMatPropDependencyHelper(needed_mat_props, _active_objects[tid], producer_only);
821 }
MooseObjectWarehouseBase::hasActiveObjects
bool hasActiveObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:496
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223
MooseObjectWarehouseBase::updateMatPropDependencyHelper
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.
Definition: MooseObjectWarehouseBase.h:862

◆ 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.

Reimplemented in MaterialWarehouse.

Definition at line 862 of file MooseObjectWarehouseBase.h.

Referenced by MaterialWarehouse::updateMatPropDependencyHelper().

866 {
867  for (auto & object : objects)
868  {
869  auto c = dynamic_cast<const MaterialPropertyInterface *>(object.get());
870  if (c)
871  {
872  auto & mp_deps = c->getMatPropDependencies();
873  needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
874  }
875  }
876 }
MaterialPropertyInterface::getMatPropDependencies
virtual const std::unordered_set< unsigned int > & getMatPropDependencies() const
Retrieve the set of material properties that this object depends on.
Definition: MaterialPropertyInterface.h:442
MaterialPropertyInterface
An interface for accessing Materials.
Definition: MaterialPropertyInterface.h:69

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

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

709 {
710  if (hasActiveObjects(tid))
711  updateVariableDependencyHelper(needed_moose_vars, _active_objects[tid]);
712 }
MooseObjectWarehouseBase::updateVariableDependencyHelper
static void updateVariableDependencyHelper(std::set< MooseVariableFieldBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating variable dependency vector.
Definition: MooseObjectWarehouseBase.h:751
MooseObjectWarehouseBase::hasActiveObjects
bool hasActiveObjects(THREAD_ID tid=0) const
Definition: MooseObjectWarehouseBase.h:496
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition: MooseObjectWarehouseBase.h:223

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

754 {
755  for (const auto & object : objects)
756  {
757  auto c = dynamic_cast<const MooseVariableDependencyInterface *>(object.get());
758  if (c)
759  {
760  const auto & mv_deps = c->getMooseVariableDependencies();
761  needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
762  }
763  }
764 }
MooseVariableDependencyInterface::getMooseVariableDependencies
const std::set< MooseVariableFieldBase * > & getMooseVariableDependencies() const
Retrieve the set of MooseVariableFieldBase that this object depends on.
Definition: MooseVariableDependencyInterface.h:45

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

Referenced by MaterialWarehouse::sort().

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

Referenced by MaterialWarehouse::sort().

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

Referenced by MaterialWarehouse::sort().

◆ _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 238 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 86 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 89 of file MooseObjectTagWarehouse.h.

◆ _num_threads

template<typename T>
const THREAD_ID MooseObjectTagWarehouse< T >::_num_threads
protected

Definition at line 77 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 88 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 80 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 83 of file MooseObjectTagWarehouse.h.

The documentation for this class was generated from the following files:
Generated on Tue Jul 14 2026 14:44:50 for https://mooseframework.inl.gov by   doxygen 1.8.14