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 (THREAD_ID num_threads=libMesh::n_threads())
 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 ( THREAD_ID  num_threads = libMesh::n_threads())

Constructor.

Definition at line 92 of file MooseObjectTagWarehouse.h.

93 : MooseObjectWarehouse<T>(num_threads),
94 _num_threads(num_threads),
95 _vector_tag_to_object_warehouse(_num_threads),
96 _vector_tags_to_object_warehouse(_num_threads),
97 _matrix_tag_to_object_warehouse(_num_threads),
98 _matrix_tags_to_object_warehouse(_num_threads)
99{
100}
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:88
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:79
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:82
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:85
MooseObjectWarehouse
A storage container for MooseObjects that inherit from SetupInterface.
Definition MooseObjectWarehouse.h:28

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

899{
900 std::vector<std::string> output;
901 for (const auto & object : _active_objects[tid])
902 output.push_back(object->name());
903 return ConsoleUtils::formatString(MooseUtils::join(output, " "), prefix);
904}
MooseObjectWarehouseBase::_active_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
Definition MooseObjectWarehouseBase.h:222
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:581
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 98 of file MooseObjectWarehouse.h.

101{
102 MooseObjectWarehouseBase<T>::addObject(object, tid, recurse);
103
104 if (recurse)
105 {
106 if (auto mvir = std::dynamic_pointer_cast<MooseVariableInterface<Real>>(object); mvir)
107 _variable_objects[mvir->mooseVariableBase()->number()].addObject(object, tid, false);
108 else if (auto mviv = std::dynamic_pointer_cast<MooseVariableInterface<RealVectorValue>>(object);
109 mviv)
110 _variable_objects[mviv->mooseVariableBase()->number()].addObject(object, tid, false);
111 else if (auto mvie = std::dynamic_pointer_cast<MooseVariableInterface<RealEigenVector>>(object);
112 mvie)
113 _variable_objects[mvie->mooseVariableBase()->number()].addObject(object, tid, false);
114 // Some objects, such as ScalarKernels, do not inherit from the MooseVariableInterface (which is
115 // for field variables). These objects *do* inherit from ResidualObject which has this more
116 // generic variable() API
117 else if (auto ro = std::dynamic_pointer_cast<ResidualObject>(object); ro)
118 _variable_objects[ro->variable().number()].addObject(object, tid, false);
119 }
120}
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:313
MooseObjectWarehouse::_variable_objects
std::map< unsigned int, MooseObjectWarehouse< T > > _variable_objects
Variable based storage.
Definition MooseObjectWarehouse.h:87
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(), MFEMProblem::addFunction(), FEProblemBase::addFunctorMaterial(), NonlinearSystemBase::addHDGKernel(), FEProblemBase::addIndicator(), NonlinearSystemBase::addInterfaceKernel(), MooseEigenSystem::addKernel(), NonlinearSystemBase::addKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), NonlinearSystemBase::addNodalKernel(), ConstraintWarehouse::addObject(), ExecuteMooseObjectWarehouse< T >::addObject(), MaterialWarehouse::addObjects(), NonlinearSystemBase::addScalarKernel(), and FEProblemBase::checkNonlocalCoupling().

◆ checkThreadID()

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

Calls assert on thread id.

Definition at line 928 of file MooseObjectWarehouseBase.h.

929{
930 mooseAssert(tid < _num_threads,
931 "Attempting to access a thread id ("
932 << tid << ") greater than the number allowed by the storage item ("
933 << _num_threads << ")");
934}
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:216

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

176{
177 checkThreadID(tid);
178 for (const auto & object : _active_objects[tid])
179 object->customSetup(exec_type);
180}
MooseObjectWarehouseBase::checkThreadID
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
Definition MooseObjectWarehouseBase.h:928
MooseObjectWarehouse::customSetup
virtual void customSetup(const ExecFlagType &exec_type, THREAD_ID tid=0) const
Definition MooseObjectWarehouse.h:175

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

◆ getActiveBlockObjects() [1/2]

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

Definition at line 476 of file MooseObjectWarehouseBase.h.

477{
478 checkThreadID(tid);
479 const auto iter = _active_block_objects[tid].find(id);
480 mooseAssert(iter != _active_block_objects[tid].end(),
481 "Unable to located active block objects for the given id: " << id << ".");
482 return iter->second;
483}
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:228

◆ getActiveBlockObjects() [2/2]

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

Definition at line 468 of file MooseObjectWarehouseBase.h.

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

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

◆ getActiveBlocks()

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

Return a set of active SubdomainsIDs.

Definition at line 648 of file MooseObjectWarehouseBase.h.

649{
650 checkThreadID(tid);
651 std::set<SubdomainID> ids;
652 for (const auto & object_pair : _active_block_objects[tid])
653 ids.insert(object_pair.first);
654 return ids;
655}

Referenced by FEProblemBase::checkProblemIntegrity().

◆ getActiveBoundaryObjects() [1/2]

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

Definition at line 457 of file MooseObjectWarehouseBase.h.

458{
459 checkThreadID(tid);
460 const auto iter = _active_boundary_objects[tid].find(id);
461 mooseAssert(iter != _active_boundary_objects[tid].end(),
462 "Unable to located active boundary objects for the given id: " << id << ".");
463 return iter->second;
464}
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:234

◆ getActiveBoundaryObjects() [2/2]

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

Definition at line 449 of file MooseObjectWarehouseBase.h.

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

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

◆ getActiveObject()

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

Definition at line 629 of file MooseObjectWarehouseBase.h.

630{
631 checkThreadID(tid);
632 for (const auto & object : _active_objects[tid])
633 if (object->name() == name)
634 return object;
635 mooseError("Unable to locate active object: ", name, ".");
636}
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 441 of file MooseObjectWarehouseBase.h.

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

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

◆ getActiveVariableBlockObjects()

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

Definition at line 142 of file MooseObjectWarehouse.h.

145{
146 checkThreadID(tid);
147 const auto iter = _variable_objects.find(variable_id);
148 mooseAssert(iter != _variable_objects.end(),
149 "Unable to locate variable kernels for the given variable id: " << variable_id
150 << ".");
151 return iter->second.getActiveBlockObjects(block_id, tid);
152}

Referenced by ComputeFullJacobianThread::computeOnElement().

◆ getBlockObjects() [1/2]

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

Definition at line 430 of file MooseObjectWarehouseBase.h.

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

◆ getBlockObjects() [2/2]

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

Definition at line 422 of file MooseObjectWarehouseBase.h.

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

Referenced by MaterialPropertyDebugOutput::printMaterialMap().

◆ getBoundaryObjects() [1/2]

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

Definition at line 411 of file MooseObjectWarehouseBase.h.

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

◆ getBoundaryObjects() [2/2]

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

Definition at line 395 of file MooseObjectWarehouseBase.h.

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

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

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

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

191{
192 return const_cast<MooseObjectTagWarehouse<T> *>(this)->getMatrixTagObjectWarehouse(tag_id, tid);
193}
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:156

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

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

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

619{
620 checkThreadID(tid);
621 for (const auto & object : _all_objects[tid])
622 if (object->name() == name)
623 return object;
624 mooseError("Unable to locate object: ", name, ".");
625}
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:219

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

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

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

◆ getObjectsForVariable()

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

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

Definition at line 640 of file MooseObjectWarehouseBase.h.

642{
643 return libmesh_map_find(_all_variable_objects[tid], var_name);
644}
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:237

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

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

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

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

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

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

◆ hasActiveBlockObjects() [2/2]

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

Definition at line 551 of file MooseObjectWarehouseBase.h.

552{
553 checkThreadID(tid);
554 bool has_active_block_objects = false;
555 for (const auto & object_pair : _active_block_objects[tid])
556 has_active_block_objects |= !(object_pair.second.empty());
557 return has_active_block_objects;
558}

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

◆ hasActiveBoundaryObjects() [1/2]

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

Definition at line 598 of file MooseObjectWarehouseBase.h.

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

◆ hasActiveBoundaryObjects() [2/2]

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

Definition at line 591 of file MooseObjectWarehouseBase.h.

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

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

◆ hasActiveObject()

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

Convenience functions for checking/getting specific objects.

Definition at line 607 of file MooseObjectWarehouseBase.h.

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

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

◆ hasActiveObjects()

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

Definition at line 495 of file MooseObjectWarehouseBase.h.

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

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

◆ hasActiveVariableBlockObjects()

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

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

Definition at line 132 of file MooseObjectWarehouse.h.

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

Referenced by ComputeFullJacobianThread::computeOnElement().

◆ hasBoundaryObjects() [1/2]

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

Definition at line 403 of file MooseObjectWarehouseBase.h.

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

◆ hasBoundaryObjects() [2/2]

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

Definition at line 584 of file MooseObjectWarehouseBase.h.

585{
586 return hasBoundaryObjectsHelper(_all_boundary_objects, tid);
587}

◆ hasBoundaryObjectsHelper()

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

Helper for determining whether we have boundary objects.

Definition at line 571 of file MooseObjectWarehouseBase.h.

574{
575 checkThreadID(tid);
576 bool has_boundary_objects = false;
577 for (const auto & object_pair : boundary_objects[tid])
578 has_boundary_objects |= !(object_pair.second.empty());
579 return has_boundary_objects;
580}

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

◆ hasObjects()

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

Convenience functions for determining if objects exist.

Definition at line 487 of file MooseObjectWarehouseBase.h.

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

Referenced by NonlinearSystemBase::setInitialSolution().

◆ hasObjectsForVariable()

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

Definition at line 503 of file MooseObjectWarehouseBase.h.

505{
506 checkThreadID(tid);
507 return _all_variable_objects[tid].count(var_name);
508}

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

516{
517 checkThreadID(tid);
518 blocks_covered.clear();
519 if (!hasObjectsForVariable(var_name, tid))
520 return false;
521
522 // Check block restriction as a whole
523 for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
524 {
525 std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
526 if (blk && blk->hasBlocks(blocks))
527 {
528 blocks_covered = blocks;
529 return true;
530 }
531 }
532 // No object has all the blocks, but one might overlap, which could be troublesome.
533 // We'll keep track of which blocks are covered in case several overlap
534 for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
535 {
536 std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
537 if (blk)
538 for (const auto & block : blocks)
539 if (blk->hasBlocks(block))
540 blocks_covered.insert(block);
541 }
542 // No overlap at all
543 if (blocks_covered.empty())
544 return false;
545
546 return (blocks == blocks_covered);
547}
blocks
char ** blocks
Definition PetscDMMoose.C:1558
MooseObjectWarehouseBase::hasObjectsForVariable
bool hasObjectsForVariable(const VariableName &var_name, THREAD_ID tid) const
Definition MooseObjectWarehouseBase.h:503

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

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

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

157{
158 checkThreadID(tid);
159 // Initial Setup should be called on all objects because they may become active later
160 for (const auto & object : _all_objects[tid])
161 object->initialSetup();
162}
MooseObjectWarehouse::initialSetup
virtual void initialSetup(THREAD_ID tid=0) const
Convenience methods for calling object setup methods.
Definition MooseObjectWarehouse.h:156

Referenced by DumpObjectsProblem::initialSetup(), AuxiliarySystem::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 206 of file MooseObjectWarehouse.h.

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

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

◆ numThreads()

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

Return the number of threads.

Definition at line 204 of file MooseObjectWarehouseBase.h.

204{ 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 215 of file MooseObjectWarehouse.h.

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

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

◆ size()

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

Return how many kernels we store in the current warehouse.

Definition at line 305 of file MooseObjectWarehouseBase.h.

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

Referenced by NonlinearThread::printBlockExecutionInformation().

◆ sort()

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

Sort the objects using the DependencyResolver.

Definition at line 688 of file MooseObjectWarehouseBase.h.

689{
690 checkThreadID(tid);
691
692 for (auto & object_pair : _all_block_objects[tid])
693 sortHelper(object_pair.second);
694
695 for (auto & object_pair : _all_boundary_objects[tid])
696 sortHelper(object_pair.second);
697
698 sortHelper(_all_objects[tid]);
699
700 // The active lists now must be update to reflect the order changes
701 updateActive(tid);
702}
MooseObjectWarehouseBase::sortHelper
static void sortHelper(std::vector< std::shared_ptr< T > > &objects)
Helper method for sorting vectors of objects.
Definition MooseObjectWarehouseBase.h:908
MooseObjectWarehouseBase::updateActive
virtual void updateActive(THREAD_ID tid=0)
Updates the active objects storage.
Definition MooseObjectWarehouseBase.h:659

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

◆ sortHelper()

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

Helper method for sorting vectors of objects.

Definition at line 908 of file MooseObjectWarehouseBase.h.

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

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

◆ subdomainsCovered()

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

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

Definition at line 879 of file MooseObjectWarehouseBase.h.

882{
883 for (const auto & object : _active_objects[tid])
884 {
885 unique_variables.insert(object->variable().name());
886 const auto additional_variables_covered = object->additionalROVariables();
887 unique_variables.insert(additional_variables_covered.begin(),
888 additional_variables_covered.end());
889 }
890
891 for (const auto & object_pair : _active_block_objects[tid])
892 subdomains_covered.insert(object_pair.first);
893}

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

185{
186 checkThreadID(tid);
187 if (hasActiveBlockObjects(id, tid))
188 {
189 const auto & objects = getActiveBlockObjects(id, tid);
190 for (const auto & object : objects)
191 object->subdomainSetup();
192 }
193}
MooseObjectWarehouseBase::getActiveBlockObjects
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Definition MooseObjectWarehouseBase.h:468
MooseObjectWarehouseBase::hasActiveBlockObjects
bool hasActiveBlockObjects(THREAD_ID tid=0) const
Definition MooseObjectWarehouseBase.h:551
MooseObjectWarehouse::subdomainSetup
virtual void subdomainSetup(THREAD_ID tid=0) const
Definition MooseObjectWarehouse.h:197

◆ subdomainSetup() [2/2]

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

Reimplemented in MaterialWarehouse.

Definition at line 197 of file MooseObjectWarehouse.h.

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

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

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

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

105{
106 MooseObjectWarehouse<T>::updateActive(tid);
107
108 for (auto & it : _vector_tag_to_object_warehouse[tid])
109 it.second.updateActive(tid);
110
111 for (auto & it : _vector_tags_to_object_warehouse[tid])
112 it.second.updateActive(tid);
113
114 for (auto & it : _matrix_tag_to_object_warehouse[tid])
115 it.second.updateActive(tid);
116
117 for (auto & it : _matrix_tags_to_object_warehouse[tid])
118 it.second.updateActive(tid);
119}
MooseObjectTagWarehouse::updateActive
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
Definition MooseObjectTagWarehouse.h:104
MooseObjectWarehouse::updateActive
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
Definition MooseObjectWarehouse.h:224

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

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

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

◆ updateBlockFEVariableCoupledVectorTagDependency()

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

Definition at line 777 of file MooseObjectWarehouseBase.h.

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

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

◆ updateBlockMatPropDependency()

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

Definition at line 824 of file MooseObjectWarehouseBase.h.

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

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

◆ updateBlockVariableDependency()

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

Definition at line 715 of file MooseObjectWarehouseBase.h.

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

Referenced by NonlinearThread::subdomainChanged().

◆ updateBoundaryFEVariableCoupledVectorTagDependency()

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

Definition at line 787 of file MooseObjectWarehouseBase.h.

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

Referenced by ComputeNodalKernelBcsThread::onNode().

◆ updateBoundaryMatPropDependency() [1/2]

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

Definition at line 848 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryMatPropDependency() [2/2]

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

Definition at line 836 of file MooseObjectWarehouseBase.h.

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

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

◆ updateBoundaryVariableDependency() [1/2]

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

Definition at line 739 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryVariableDependency() [2/2]

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

Definition at line 726 of file MooseObjectWarehouseBase.h.

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

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

◆ updateFEVariableCoupledVectorTagDependency()

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

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

Definition at line 767 of file MooseObjectWarehouseBase.h.

769{
770 if (hasActiveObjects(tid))
771 updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
772 _active_objects[tid]);
773}
MooseObjectWarehouseBase::hasActiveObjects
bool hasActiveObjects(THREAD_ID tid=0) const
Definition MooseObjectWarehouseBase.h:495

◆ updateFEVariableCoupledVectorTagDependencyHelper()

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

Helper method for updating FE variable coupleable vector tag vector.

Definition at line 797 of file MooseObjectWarehouseBase.h.

799{
800 for (const auto & object : objects)
801 {
802 auto c = dynamic_cast<const Coupleable *>(object.get());
803 if (c)
804 {
805 const auto & tag_deps = c->getFEVariableCoupleableVectorTags();
806 needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
807 }
808 }
809}
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 813 of file MooseObjectWarehouseBase.h.

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

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

◆ updateMatPropDependencyHelper()

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

Helper method for updating material property dependency vector.

Definition at line 861 of file MooseObjectWarehouseBase.h.

865{
866 for (auto & object : objects)
867 {
868 auto c = dynamic_cast<const MaterialPropertyInterface *>(object.get());
869 if (c)
870 {
871 auto & mp_deps = c->getMatPropDependencies();
872 needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
873 }
874 }
875}
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 706 of file MooseObjectWarehouseBase.h.

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

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

◆ updateVariableDependencyHelper()

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

Helper method for updating variable dependency vector.

Definition at line 750 of file MooseObjectWarehouseBase.h.

753{
754 for (const auto & object : objects)
755 {
756 auto c = dynamic_cast<const MooseVariableDependencyInterface *>(object.get());
757 if (c)
758 {
759 const auto & mv_deps = c->getMooseVariableDependencies();
760 needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
761 }
762 }
763}
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 228 of file MooseObjectWarehouseBase.h.

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

◆ _active_boundary_objects

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

Active boundary restricted objects (THREAD_ID on outer vector)

Definition at line 234 of file MooseObjectWarehouseBase.h.

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

◆ _active_objects

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

All active objects (THREAD_ID on outer vector)

Definition at line 222 of file MooseObjectWarehouseBase.h.

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

◆ _all_block_objects

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

Definition at line 225 of file MooseObjectWarehouseBase.h.

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

◆ _all_boundary_objects

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

Definition at line 231 of file MooseObjectWarehouseBase.h.

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

◆ _all_objects

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

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

Definition at line 219 of file MooseObjectWarehouseBase.h.

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

◆ _all_variable_objects

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

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

Definition at line 237 of file MooseObjectWarehouseBase.h.

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

◆ _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 85 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 88 of file MooseObjectTagWarehouse.h.

◆ _num_threads

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

Definition at line 76 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 87 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 79 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 82 of file MooseObjectTagWarehouse.h.

The documentation for this class was generated from the following files:
Generated on Fri Oct 23 2026 20:29:20 for https://mooseframework.inl.gov by doxygen 1.9.8