https://mooseframework.inl.gov
Loading...
Searching...
No Matches
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 <MooseObjectTagWarehouse.h>

Inheritance diagram for MooseObjectTagWarehouse< T >:
[legend]

Public Member Functions

 MooseObjectTagWarehouse (bool threaded=true)
 Constructor.
 
virtual void updateActive (THREAD_ID tid=0) override
 Update the active status of Kernels.
 
MooseObjectWarehouse< T > & getVectorTagObjectWarehouse (TagID tag_id, THREAD_ID tid)
 Retrieve a moose object warehouse in which every moose object has the given vector tag.
 
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.
 
MooseObjectWarehouse< T > & getMatrixTagObjectWarehouse (TagID tag_id, THREAD_ID tid)
 Retrieve a moose object warehouse in which every moose object has the given matrix tag.
 
const MooseObjectWarehouse< T > & getMatrixTagObjectWarehouse (TagID tag_id, THREAD_ID tid) const
 const version of the above
 
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.
 
virtual void addObject (std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
 Adds an object to the storage structure.
 
bool hasVariableObjects (unsigned int variable_id, THREAD_ID tid=0) const
 Checks for whether this warehouse has objects for a given variable.
 
unsigned int size (THREAD_ID tid=0) const
 Return how many kernels we store in the current warehouse.
 
bool hasObjectsForVariableAndBlocks (const VariableName &var_name, const std::set< SubdomainID > &blocks, std::set< SubdomainID > &blocks_covered, THREAD_ID tid) const
 Whether there are objects for this variable and the set of blocks passed.
 
std::set< SubdomainID > getActiveBlocks (THREAD_ID tid=0) const
 Return a set of active SubdomainsIDs.
 
const std::vector< std::shared_ptr< T > > & getObjectsForVariable (const VariableName &var_name, THREAD_ID tid) const
 Getter for objects that have the 'variable' set to a particular variable Note that users should check whether there are objects using 'hasObjectsForVariable' before calling this routine, because it will throw if there are no objects for this variable.
 
void sort (THREAD_ID tid=0)
 Sort the objects using the DependencyResolver.
 
void subdomainsCovered (std::set< SubdomainID > &subdomains_covered, std::set< std::string > &unique_variables, THREAD_ID tid=0) const
 Populates a set of covered subdomains and the associated variable names.
 
THREAD_ID numThreads () const
 Return the number of threads.
 
std::string activeObjectsToFormattedString (THREAD_ID tid=0, const std::string &prefix="[DBG]") const
 Output the active content of the warehouse to a string, meant to be output to the console.
 
virtual void initialSetup (THREAD_ID tid=0) const
 Convenience methods for calling object setup methods.
 
virtual void timestepSetup (THREAD_ID tid=0) const
 
virtual void customSetup (const ExecFlagType &exec_type, THREAD_ID tid=0) const
 
virtual void subdomainSetup (THREAD_ID tid=0) const
 
virtual void subdomainSetup (SubdomainID id, THREAD_ID tid=0) const
 
virtual void jacobianSetup (THREAD_ID tid=0) const
 
virtual void residualSetup (THREAD_ID tid=0) const
 
bool hasActiveVariableBlockObjects (unsigned int variable_id, SubdomainID block_id, THREAD_ID tid=0) const
 Methods for checking/getting variable kernels for a variable and SubdomainID.
 
const std::vector< std::shared_ptr< T > > & getActiveVariableBlockObjects (unsigned int variable_id, SubdomainID block_id, THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getObjects (THREAD_ID tid=0) const
 Retrieve complete vector to the all/block/boundary restricted objects for a given thread.
 
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getBlockObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getBlockObjects (SubdomainID id, THREAD_ID tid=0) const
 
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getBoundaryObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getActiveObjects (THREAD_ID tid=0) const
 Retrieve complete vector to the active all/block/boundary restricted objects for a given thread.
 
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const
 
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
 
bool hasObjects (THREAD_ID tid=0) const
 Convenience functions for determining if objects exist.
 
bool hasActiveObjects (THREAD_ID tid=0) const
 
bool hasObjectsForVariable (const VariableName &var_name, THREAD_ID tid) const
 
bool hasActiveBlockObjects (THREAD_ID tid=0) const
 
bool hasActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const
 
bool hasActiveBoundaryObjects (THREAD_ID tid=0) const
 
bool hasActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
 
bool hasBoundaryObjects (THREAD_ID tid=0) const
 
bool hasBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
 
bool hasActiveObject (const std::string &name, THREAD_ID tid=0) const
 Convenience functions for checking/getting specific objects.
 
std::shared_ptr< T > getObject (const std::string &name, THREAD_ID tid=0) const
 
std::shared_ptr< T > getActiveObject (const std::string &name, THREAD_ID tid=0) const
 
void updateVariableDependency (std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
 Update variable dependency vector.
 
void updateBlockVariableDependency (SubdomainID id, std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
 
void updateBoundaryVariableDependency (std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
 
void updateBoundaryVariableDependency (BoundaryID id, std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
 
void updateFEVariableCoupledVectorTagDependency (std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
 Update FE variable coupleable vector tag vector for all objects, block-restricted objects, and boundary-restricted objects.
 
void updateBlockFEVariableCoupledVectorTagDependency (SubdomainID id, std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
 
void updateBoundaryFEVariableCoupledVectorTagDependency (BoundaryID id, std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
 
void updateMatPropDependency (std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const
 Update material property dependency vector.
 
void updateBlockMatPropDependency (SubdomainID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const
 
void updateBoundaryMatPropDependency (std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const
 
void updateBoundaryMatPropDependency (BoundaryID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const
 

Protected Member Functions

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

Static Protected Member Functions

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

Protected Attributes

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.
 
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.
 
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.
 
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.
 
std::map< unsigned int, MooseObjectWarehouse< T > > _variable_objects
 Variable based storage.
 
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
 Storage container for the ALL pointers (THREAD_ID on outer vector)
 
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
 All active objects (THREAD_ID on outer vector)
 
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
 
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _active_block_objects
 Active block restricted objects (THREAD_ID on outer vector)
 
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
 
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _active_boundary_objects
 Active boundary restricted objects (THREAD_ID on outer vector)
 
std::vector< std::map< VariableName, std::vector< std::shared_ptr< T > > > > _all_variable_objects
 All objects with a certain variable selected, as the 'variable' parameter.
 

Detailed Description

template<typename T>
class 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 23 of file MooseObjectTagWarehouse.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}
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::_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
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_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
A storage container for MooseObjects that inherit from SetupInterface.
Definition MooseObjectWarehouse.h:28
libMesh::n_threads
unsigned int n_threads()

Member Function Documentation

◆ activeObjectsToFormattedString()

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

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

Parameters
tidthe thread id
prefixa string to prepend to the string

Definition at line 898 of file MooseObjectWarehouseBase.h.

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}
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
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
libMesh::Quality::name
std::string name(const ElemQuality q)

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

◆ addObject()

template<typename T >
void MooseObjectWarehouse< T >::addObject ( std::shared_ptr< T >  object,
THREAD_ID  tid = 0,
bool  recurse = true 
)
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< AuxKernelBase >, ExecuteMooseObjectWarehouse< AuxKernelTempl >, ExecuteMooseObjectWarehouse< AuxKernelTempl< Real > >, ExecuteMooseObjectWarehouse< AuxKernelTempl< RealVectorValue > >, ExecuteMooseObjectWarehouse< AuxScalarKernel >, ExecuteMooseObjectWarehouse< Control >, ExecuteMooseObjectWarehouse< MultiApp >, ExecuteMooseObjectWarehouse< T >, ExecuteMooseObjectWarehouse< Transfer >, and ExecuteMooseObjectWarehouse< TransientMultiApp >.

Definition at line 99 of file MooseObjectWarehouse.h.

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}
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
MooseObjectWarehouse::_variable_objects
std::map< unsigned int, MooseObjectWarehouse< T > > _variable_objects
Variable based storage.
Definition MooseObjectWarehouse.h:88
MooseVariableInterface
Interface for objects that need to get values of MooseVariables.
Definition MooseVariableInterface.h:31

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< T >::addObject(), MaterialWarehouse::addObjects(), NonlinearSystemBase::addScalarKernel(), and FEProblemBase::checkNonlocalCoupling().

◆ checkThreadID()

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

Calls assert on thread id.

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

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

◆ customSetup()

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

Definition at line 176 of file MooseObjectWarehouse.h.

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
MooseObjectWarehouse::customSetup
virtual void customSetup(const ExecFlagType &exec_type, THREAD_ID tid=0) const
Definition MooseObjectWarehouse.h:176

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

◆ getActiveBlockObjects() [1/2]

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

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

◆ getActiveBlockObjects() [2/2]

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

Definition at line 469 of file MooseObjectWarehouseBase.h.

470{
471 checkThreadID(tid);
472 return _active_block_objects[tid];
473}

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

◆ getActiveBlocks()

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

Return a set of active SubdomainsIDs.

Definition at line 649 of file MooseObjectWarehouseBase.h.

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}

Referenced by FEProblemBase::checkProblemIntegrity().

◆ getActiveBoundaryObjects() [1/2]

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

Definition at line 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::_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::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.

451{
452 checkThreadID(tid);
453 return _active_boundary_objects[tid];
454}

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

◆ getActiveObject()

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

Definition at line 630 of file MooseObjectWarehouseBase.h.

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}
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application.
Definition MooseError.h:311
if
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD

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

◆ getActiveObjects()

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

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

Parameters
tidThe thread id to retrieve objects from

Definition at line 442 of file MooseObjectWarehouseBase.h.

443{
444 checkThreadID(tid);
445 return _active_objects[tid];
446}

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

◆ getActiveVariableBlockObjects()

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

Definition at line 143 of file MooseObjectWarehouse.h.

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}

Referenced by ComputeFullJacobianThread::computeOnElement().

◆ getBlockObjects() [1/2]

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

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

◆ getBlockObjects() [2/2]

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

Definition at line 423 of file MooseObjectWarehouseBase.h.

424{
425 checkThreadID(tid);
426 return _all_block_objects[tid];
427}

Referenced by MaterialPropertyDebugOutput::printMaterialMap().

◆ getBoundaryObjects() [1/2]

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

Definition at line 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::_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::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.

397{
398 checkThreadID(tid);
399 return _all_boundary_objects[tid];
400}

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

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

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

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

◆ 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
A storage container for MooseObjects that inherit from SetupInterface.
Definition MooseObjectTagWarehouse.h:24
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

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

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}

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

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

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

Referenced by FEProblemBase::getMultiApp().

◆ getObjects()

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

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

Parameters
tidThe thread id to retrieve objects from

Definition at line 388 of file MooseObjectWarehouseBase.h.

389{
390 checkThreadID(tid);
391 return _all_objects[tid];
392}

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

◆ getObjectsForVariable()

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

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

Definition at line 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 'variable' 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.

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}

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

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

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}

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

◆ hasActiveBlockObjects() [1/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}

◆ hasActiveBlockObjects() [2/2]

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

Definition at line 552 of file MooseObjectWarehouseBase.h.

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}

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

◆ hasActiveBoundaryObjects() [1/2]

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

Definition at line 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}

◆ hasActiveBoundaryObjects() [2/2]

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

Definition at line 592 of file MooseObjectWarehouseBase.h.

593{
594 return hasBoundaryObjectsHelper(_active_boundary_objects, tid);
595}
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

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(), FEProblemBase::needInterfaceMaterialOnSide(), NonlinearSystemBase::needInterfaceMaterialOnSide(), ComputeMaterialsObjectThread::onBoundary(), NonlinearThread::onBoundary(), NonlinearThread::onExternalSide(), ComputeMaterialsObjectThread::onInterface(), NonlinearThread::onInterface(), ComputeBoundaryInitialConditionThread::onNode(), ComputeNodalKernelBCJacobiansThread::onNode(), ComputeNodalKernelBcsThread::onNode(), NonlinearThread::printBoundaryExecutionInformation(), ComputeNodalKernelBCJacobiansThread::printGeneralExecutionInformation(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsInterface(), NonlinearSystemBase::setInitialSolution(), MooseObjectWarehouseBase< T >::updateBoundaryFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency(), MooseObjectWarehouseBase< T >::updateBoundaryMatPropDependency(), MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency(), and MooseObjectWarehouseBase< T >::updateBoundaryVariableDependency().

◆ hasActiveObject()

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

Convenience functions for checking/getting specific objects.

Definition at line 608 of file MooseObjectWarehouseBase.h.

609{
610 checkThreadID(tid);
611 for (const auto & object : _active_objects[tid])
612 if (object->name() == name)
613 return true;
614 return false;
615}

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

◆ hasActiveObjects()

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

Definition at line 496 of file MooseObjectWarehouseBase.h.

497{
498 checkThreadID(tid);
499 return !_active_objects[tid].empty();
500}

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::hasMultiApps(), ElementSubdomainModifierBase::modify(), NonlinearSystemBase::needBoundaryMaterialOnSide(), ComputeNodalKernelBcsThread::printGeneralExecutionInformation(), ComputeNodalKernelJacobiansThread::printGeneralExecutionInformation(), ComputeNodalKernelsThread::printGeneralExecutionInformation(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::timestepSetup(), MooseObjectWarehouseBase< T >::updateFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< T >::updateMatPropDependency(), and MooseObjectWarehouseBase< T >::updateVariableDependency().

◆ hasActiveVariableBlockObjects()

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

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

Definition at line 133 of file MooseObjectWarehouse.h.

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

Referenced by ComputeFullJacobianThread::computeOnElement().

◆ hasBoundaryObjects() [1/2]

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

Definition at line 404 of file MooseObjectWarehouseBase.h.

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

◆ hasBoundaryObjects() [2/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}

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

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

◆ hasObjects()

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

Convenience functions for determining if objects exist.

Definition at line 488 of file MooseObjectWarehouseBase.h.

489{
490 checkThreadID(tid);
491 return !_all_objects[tid].empty();
492}

Referenced by NonlinearSystemBase::setInitialSolution().

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

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

◆ hasObjectsForVariableAndBlocks()

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

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

Parameters
var_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::hasObjectsForVariable
bool hasObjectsForVariable(const VariableName &var_name, THREAD_ID tid) const
Definition MooseObjectWarehouseBase.h:504

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

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

Referenced by ExplicitTimeIntegrator::initialSetup().

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

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}
MooseObjectWarehouse::initialSetup
virtual void initialSetup(THREAD_ID tid=0) const
Convenience methods for calling object setup methods.
Definition MooseObjectWarehouse.h:157

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

◆ jacobianSetup()

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

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

Definition at line 207 of file MooseObjectWarehouse.h.

208{
209 checkThreadID(tid);
210 for (const auto & object : _active_objects[tid])
211 object->jacobianSetup();
212}
MooseObjectWarehouse::jacobianSetup
virtual void jacobianSetup(THREAD_ID tid=0) const
Definition MooseObjectWarehouse.h:207

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

◆ numThreads()

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

Return the number of threads.

Definition at line 205 of file MooseObjectWarehouseBase.h.

205{ return _num_threads; }

◆ residualSetup()

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

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

Definition at line 216 of file MooseObjectWarehouse.h.

217{
218 checkThreadID(tid);
219 for (const auto & object : _active_objects[tid])
220 object->residualSetup();
221}
MooseObjectWarehouse::residualSetup
virtual void residualSetup(THREAD_ID tid=0) const
Definition MooseObjectWarehouse.h:216

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

◆ size()

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

Return how many kernels we store in the current warehouse.

Definition at line 306 of file MooseObjectWarehouseBase.h.

307{
308 checkThreadID(tid);
309 return _all_objects[tid].size();
310}

Referenced by NonlinearThread::printBlockExecutionInformation().

◆ sort()

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

Sort the objects using the DependencyResolver.

Definition at line 689 of file MooseObjectWarehouseBase.h.

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::sortHelper
static void sortHelper(std::vector< std::shared_ptr< T > > &objects)
Helper method for sorting vectors of objects.
Definition MooseObjectWarehouseBase.h:909
MooseObjectWarehouseBase::updateActive
virtual void updateActive(THREAD_ID tid=0)
Updates the active objects storage.
Definition MooseObjectWarehouseBase.h:660

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

◆ sortHelper()

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

Helper method for sorting vectors of objects.

Definition at line 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}

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

◆ subdomainsCovered()

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

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

Definition at line 880 of file MooseObjectWarehouseBase.h.

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}

Referenced by NonlinearSystemBase::checkKernelCoverage().

◆ subdomainSetup() [1/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::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition MooseObjectWarehouseBase.h:469
MooseObjectWarehouseBase::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition MooseObjectWarehouseBase.h:552
MooseObjectWarehouse::subdomainSetup
virtual void subdomainSetup(THREAD_ID tid=0) const
Definition MooseObjectWarehouse.h:198

◆ subdomainSetup() [2/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.

199{
200 checkThreadID(tid);
201 for (const auto & object : _active_objects[tid])
202 object->subdomainSetup();
203}

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

◆ timestepSetup()

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

Reimplemented in MaterialWarehouse.

Definition at line 167 of file MooseObjectWarehouse.h.

168{
169 checkThreadID(tid);
170 for (const auto & object : _active_objects[tid])
171 object->timestepSetup();
172}
MooseObjectWarehouse::timestepSetup
virtual void timestepSetup(THREAD_ID tid=0) const
Definition MooseObjectWarehouse.h:167

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

◆ updateActive()

template<typename T >
void MooseObjectTagWarehouse< T >::updateActive ( THREAD_ID  tid = 0)
overridevirtual

Update the active status of Kernels.

Reimplemented from MooseObjectWarehouse< T >.

Definition at line 105 of file MooseObjectTagWarehouse.h.

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::updateActive
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
Definition MooseObjectTagWarehouse.h:105
MooseObjectWarehouse::updateActive
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
Definition MooseObjectWarehouse.h:225

Referenced by NonlinearSystemBase::updateActive().

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

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

◆ updateBlockFEVariableCoupledVectorTagDependency()

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

Definition at line 778 of file MooseObjectWarehouseBase.h.

780{
781 if (hasActiveBlockObjects(id, tid))
782 updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
783 getActiveBlockObjects(id, tid));
784}
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

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

◆ updateBlockMatPropDependency()

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

Definition at line 825 of file MooseObjectWarehouseBase.h.

830{
831 if (hasActiveBlockObjects(id, tid))
832 updateMatPropDependencyHelper(needed_mat_props, getActiveBlockObjects(id, tid), producer_only);
833}
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

Referenced by FEProblemBase::prepareMaterials().

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

720{
721 if (hasActiveBlockObjects(id, tid))
722 updateVariableDependencyHelper(needed_moose_vars, getActiveBlockObjects(id, tid));
723}
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.

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

Referenced by ComputeNodalKernelBcsThread::onNode().

◆ updateBoundaryMatPropDependency() [1/2]

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

Definition at line 849 of file MooseObjectWarehouseBase.h.

854{
855 if (hasActiveBoundaryObjects(id, tid))
856 updateMatPropDependencyHelper(
857 needed_mat_props, getActiveBoundaryObjects(id, tid), producer_only);
858}

◆ updateBoundaryMatPropDependency() [2/2]

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

Definition at line 837 of file MooseObjectWarehouseBase.h.

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}

Referenced by FEProblemBase::prepareMaterials().

◆ updateBoundaryVariableDependency() [1/2]

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

Definition at line 740 of file MooseObjectWarehouseBase.h.

744{
745 if (hasActiveBoundaryObjects(id, tid))
746 updateVariableDependencyHelper(needed_moose_vars, getActiveBoundaryObjects(id, tid));
747}

◆ updateBoundaryVariableDependency() [2/2]

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

Definition at line 727 of file MooseObjectWarehouseBase.h.

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}

Referenced by FEProblemBase::prepareMaterials().

◆ 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::hasActiveObjects
bool hasActiveObjects(THREAD_ID tid=0) const
Definition MooseObjectWarehouseBase.h:496

◆ 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:53
Coupleable::getFEVariableCoupleableVectorTags
std::set< TagID > & getFEVariableCoupleableVectorTags()
Definition Coupleable.h:120

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

◆ updateMatPropDependency()

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

Update material property dependency vector.

Parameters
producer_onlyOnly append dependencies of materials producing the needed_mat_props

Definition at line 814 of file MooseObjectWarehouseBase.h.

818{
819 if (hasActiveObjects(tid))
820 updateMatPropDependencyHelper(needed_mat_props, _active_objects[tid], producer_only);
821}

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

◆ updateMatPropDependencyHelper()

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

Helper method for updating material property dependency vector.

Definition at line 862 of file MooseObjectWarehouseBase.h.

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
An interface for accessing Materials.
Definition MaterialPropertyInterface.h:70
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

Referenced by MaterialWarehouse::updateMatPropDependencyHelper().

◆ updateVariableDependency()

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

Update variable dependency vector.

Definition at line 707 of file MooseObjectWarehouseBase.h.

709{
710 if (hasActiveObjects(tid))
711 updateVariableDependencyHelper(needed_moose_vars, _active_objects[tid]);
712}

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

◆ updateVariableDependencyHelper()

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

Helper method for updating variable dependency vector.

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

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

Member Data Documentation

◆ _active_block_objects

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

Active block restricted objects (THREAD_ID on outer vector)

Definition at line 229 of file MooseObjectWarehouseBase.h.

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

◆ _active_boundary_objects

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

Active boundary restricted objects (THREAD_ID on outer vector)

Definition at line 235 of file MooseObjectWarehouseBase.h.

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

◆ _active_objects

template<typename T >
std::vector<std::vector<std::shared_ptr<T> > > MooseObjectWarehouseBase< T >::_active_objects
protectedinherited

All active objects (THREAD_ID on outer vector)

Definition at line 223 of file MooseObjectWarehouseBase.h.

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

◆ _all_block_objects

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

Definition at line 226 of file MooseObjectWarehouseBase.h.

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

◆ _all_boundary_objects

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

Definition at line 232 of file MooseObjectWarehouseBase.h.

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

◆ _all_objects

template<typename T >
std::vector<std::vector<std::shared_ptr<T> > > MooseObjectWarehouseBase< T >::_all_objects
protectedinherited

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

Definition at line 220 of file MooseObjectWarehouseBase.h.

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

◆ _all_variable_objects

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

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

Definition at line 238 of file MooseObjectWarehouseBase.h.

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

◆ _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 Fri Aug 21 2026 13:36:20 for https://mooseframework.inl.gov by doxygen 1.9.8