www.mooseframework.org
Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
MooseObjectWarehouseBase< T > Class Template Reference

A base storage container for MooseObjects. More...

#include <MooseObjectWarehouseBase.h>

Inheritance diagram for MooseObjectWarehouseBase< T >:
[legend]

Public Member Functions

 MooseObjectWarehouseBase (bool threaded=true)
 Constructor. More...
 
virtual ~MooseObjectWarehouseBase ()
 Destructor. More...
 
virtual void addObject (std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true)
 Adds an object to the storage structure. More...
 
unsigned int size (THREAD_ID tid=0)
 Return how many kernels we store in the current warehouse. More...
 
std::set< SubdomainIDgetActiveBlocks (THREAD_ID tid=0) const
 Return a set of active SubdomainsIDs. More...
 
virtual void updateActive (THREAD_ID tid=0)
 Updates the active objects storage. More...
 
void sort (THREAD_ID tid=0)
 Sort the objects using the DependencyResolver. More...
 
void subdomainsCovered (std::set< SubdomainID > &subdomains_covered, std::set< std::string > &unique_variables, THREAD_ID tid=0) const
 Populates a set of covered subdomains and the associated variable names. More...
 
THREAD_ID numThreads ()
 Return the number of threads. More...
 
const std::vector< std::shared_ptr< T > > & getObjects (THREAD_ID tid=0) const
 Retrieve complete vector to the all/block/boundary restricted objects for a given thread. More...
 
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getBlockObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getBlockObjects (SubdomainID id, THREAD_ID tid=0) const
 
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getBoundaryObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getActiveObjects (THREAD_ID tid=0) const
 Retrieve complete vector to the active all/block/boundary restricted objects for a given thread. More...
 
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const
 
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< T > > & getActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
 
bool hasObjects (THREAD_ID tid=0) const
 Convenience functions for determining if objects exist. More...
 
bool hasActiveObjects (THREAD_ID tid=0) const
 
bool hasActiveBlockObjects (THREAD_ID tid=0) const
 
bool hasActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const
 
bool hasActiveBoundaryObjects (THREAD_ID tid=0) const
 
bool hasActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
 
bool hasActiveObject (const std::string &name, THREAD_ID tid=0) const
 Convenience functions for checking/getting specific objects. More...
 
std::shared_ptr< T > getObject (const std::string &name, THREAD_ID tid=0) const
 
std::shared_ptr< T > getActiveObject (const std::string &name, THREAD_ID tid=0) const
 
void updateVariableDependency (std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const
 Update variable dependency vector. More...
 
void updateBlockVariableDependency (SubdomainID id, std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const
 
void updateBoundaryVariableDependency (std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const
 
void updateBoundaryVariableDependency (BoundaryID id, std::set< MooseVariableFEBase *> &needed_moose_vars, THREAD_ID tid=0) const
 
void updateMatPropDependency (std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
 Update material property dependency vector. More...
 
void updateBlockMatPropDependency (SubdomainID id, std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
 
void updateBoundaryMatPropDependency (std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
 
void updateBoundaryMatPropDependency (BoundaryID id, std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
 

Protected Member Functions

void checkThreadID (THREAD_ID tid) const
 Calls assert on thread id. More...
 

Static Protected Member Functions

static void updateActiveHelper (std::vector< std::shared_ptr< T >> &active, const std::vector< std::shared_ptr< T >> &all)
 Helper method for updating active vectors. More...
 
static void sortHelper (std::vector< std::shared_ptr< T >> &objects)
 Helper method for sorting vectors of objects. More...
 
static void updateVariableDependencyHelper (std::set< MooseVariableFEBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
 Helper method for updating variable dependency vector. More...
 
static void updateMatPropDependencyHelper (std::set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< T >> &objects)
 Helper method for updating material property dependency vector. More...
 

Protected Attributes

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

Detailed Description

template<typename T>
class MooseObjectWarehouseBase< T >

A base storage container for MooseObjects.

Definition at line 28 of file MooseObjectWarehouseBase.h.

Constructor & Destructor Documentation

◆ MooseObjectWarehouseBase()

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

Constructor.

Parameters
threadedWhen true (default) threaded storage is enabled.

Definition at line 217 of file MooseObjectWarehouseBase.h.

218  : _num_threads(threaded ? libMesh::n_threads() : 1),
225 {
226 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
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 > > > > _active_boundary_objects
Active boundary restricted objects (THREAD_ID on outer vector)
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
const THREAD_ID _num_threads
Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) ...
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)

◆ ~MooseObjectWarehouseBase()

template<typename T >
MooseObjectWarehouseBase< T >::~MooseObjectWarehouseBase ( )
virtual

Destructor.

Definition at line 229 of file MooseObjectWarehouseBase.h.

230 {
231 }

Member Function Documentation

◆ addObject()

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

Adds an object to the storage structure.

Parameters
tidThe thread ID (default is 0)
recurseWhether or not to build recusive warehouses (typically for Kernels)

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

Definition at line 243 of file MooseObjectWarehouseBase.h.

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

246 {
247  checkThreadID(tid);
248 
249  // Stores object in list of all objects
250  _all_objects[tid].push_back(object);
251 
252  // If enabled, store object in a list of all active
253  bool enabled = object->enabled();
254  if (enabled)
255  _active_objects[tid].push_back(object);
256 
257  // Perform casts to the Block/BoundaryRestrictable
258  std::shared_ptr<BoundaryRestrictable> bnd =
260  std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
261 
262  // Boundary Restricted
263  if (bnd && bnd->boundaryRestricted())
264  {
265  const std::set<BoundaryID> & ids = bnd->boundaryIDs();
266  for (std::set<BoundaryID>::const_iterator it = ids.begin(); it != ids.end(); ++it)
267  {
268  _all_boundary_objects[tid][*it].push_back(object);
269  if (enabled)
270  _active_boundary_objects[tid][*it].push_back(object);
271  }
272  }
273 
274  // Block Restricted
275  else if (blk)
276  {
277  const std::set<SubdomainID> & ids =
278  blk->blockRestricted() ? blk->blockIDs() : blk->meshBlockIDs();
279  for (std::set<SubdomainID>::const_iterator it = ids.begin(); it != ids.end(); ++it)
280  {
281  _all_block_objects[tid][*it].push_back(object);
282  if (enabled)
283  _active_block_objects[tid][*it].push_back(object);
284  }
285 
286  // Check variables
287  std::shared_ptr<Coupleable> c_ptr = std::dynamic_pointer_cast<Coupleable>(object);
288  if (c_ptr)
289  for (MooseVariableFEBase * var : c_ptr->getCoupledMooseVars())
290  blk->checkVariable(*var);
291 
292  const InputParameters & parameters = object->parameters();
293 
294  SubProblem & problem = *parameters.get<SubProblem *>("_subproblem");
295 
296  THREAD_ID tid = parameters.get<THREAD_ID>("_tid");
297 
298  if (parameters.isParamValid("variable"))
299  {
300  // Try the scalar version first
301  std::string variable_name = parameters.getMooseType("variable");
302  if (variable_name == "")
303  // When using vector variables, we are only going to use the first one in the list at the
304  // interface level...
305  variable_name = parameters.getVecMooseType("variable")[0];
306 
307  blk->checkVariable(problem.getVariable(
309  }
310  }
311 }
std::string getMooseType(const std::string &name) const
Utility functions for retrieving one of the MooseTypes variables into the common "string" base class...
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
virtual MooseVariableFEBase & getVariable(THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY)=0
Returns the variable reference for requested variable which must be of the expected_var_type (Nonline...
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _active_block_objects
Active block restricted objects (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
/class BoundaryRestrictable /brief Provides functionality for limiting the object to certain boundary...
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
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< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
Interface for objects that needs coupling capabilities.
Definition: Coupleable.h:60
Generic class for solving transient nonlinear problems.
Definition: SubProblem.h:60
An interface that restricts an object to subdomains via the &#39;blocks&#39; input parameter.
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
std::vector< std::string > getVecMooseType(const std::string &name) const
unsigned int THREAD_ID
Definition: MooseTypes.h:126
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ checkThreadID()

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

Calls assert on thread id.

Definition at line 694 of file MooseObjectWarehouseBase.h.

695 {
696  mooseAssert(tid < _num_threads,
697  "Attempting to access a thread id ("
698  << tid << ") greater than the number allowed by the storage item ("
699  << _num_threads << ")");
700 }
const THREAD_ID _num_threads
Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) ...

◆ getActiveBlockObjects() [1/2]

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

◆ getActiveBlockObjects() [2/2]

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

Definition at line 396 of file MooseObjectWarehouseBase.h.

397 {
398  checkThreadID(tid);
399  const auto iter = _active_block_objects[tid].find(id);
400  mooseAssert(iter != _active_block_objects[tid].end(),
401  "Unable to located active block objects for the given id: " << id << ".");
402  return iter->second;
403 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _active_block_objects
Active block restricted objects (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ getActiveBlocks()

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

Return a set of active SubdomainsIDs.

Definition at line 496 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::checkProblemIntegrity().

497 {
498  checkThreadID(tid);
499  std::set<SubdomainID> ids;
500  for (const auto & object_pair : _active_block_objects[tid])
501  ids.insert(object_pair.first);
502  return ids;
503 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _active_block_objects
Active block restricted objects (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ getActiveBoundaryObjects() [1/2]

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

◆ getActiveBoundaryObjects() [2/2]

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

Definition at line 377 of file MooseObjectWarehouseBase.h.

378 {
379  checkThreadID(tid);
380  const auto iter = _active_boundary_objects[tid].find(id);
381  mooseAssert(iter != _active_boundary_objects[tid].end(),
382  "Unable to located active boundary objects for the given id: " << id << ".");
383  return iter->second;
384 }
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _active_boundary_objects
Active boundary restricted objects (THREAD_ID on outer vector)

◆ getActiveObject()

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

Definition at line 485 of file MooseObjectWarehouseBase.h.

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

486 {
487  checkThreadID(tid);
488  for (const auto & object : _active_objects[tid])
489  if (object->name() == name)
490  return object;
491  mooseError("Unable to locate active object: ", name, ".");
492 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)

◆ getActiveObjects()

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

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

Parameters
tidThe thread id to retrieve objects from

Definition at line 361 of file MooseObjectWarehouseBase.h.

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

362 {
363  checkThreadID(tid);
364  return _active_objects[tid];
365 }
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)

◆ getBlockObjects() [1/2]

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

Definition at line 342 of file MooseObjectWarehouseBase.h.

Referenced by MaterialPropertyDebugOutput::printMaterialMap().

343 {
344  checkThreadID(tid);
345  return _all_block_objects[tid];
346 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ getBlockObjects() [2/2]

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

Definition at line 350 of file MooseObjectWarehouseBase.h.

351 {
352  checkThreadID(tid);
353  const auto iter = _all_block_objects[tid].find(id);
354  mooseAssert(iter != _all_block_objects[tid].end(),
355  "Unable to located active block objects for the given id: " << id << ".");
356  return iter->second;
357 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ getBoundaryObjects() [1/2]

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

Definition at line 323 of file MooseObjectWarehouseBase.h.

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

324 {
325  checkThreadID(tid);
326  return _all_boundary_objects[tid];
327 }
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects

◆ getBoundaryObjects() [2/2]

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

Definition at line 331 of file MooseObjectWarehouseBase.h.

332 {
333  checkThreadID(tid);
334  const auto iter = _all_boundary_objects[tid].find(id);
335  mooseAssert(iter != _all_boundary_objects[tid].end(),
336  "Unable to located active boundary objects for the given id: " << id << ".");
337  return iter->second;
338 }
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects

◆ getObject()

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

Definition at line 474 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::getMultiApp().

475 {
476  checkThreadID(tid);
477  for (const auto & object : _all_objects[tid])
478  if (object->name() == name)
479  return object;
480  mooseError("Unable to locate object: ", name, ".");
481 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ getObjects()

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

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

Parameters
tidThe thread id to retrieve objects from

Definition at line 315 of file MooseObjectWarehouseBase.h.

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

316 {
317  checkThreadID(tid);
318  return _all_objects[tid];
319 }
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ hasActiveBlockObjects() [1/2]

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

Definition at line 423 of file MooseObjectWarehouseBase.h.

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

424 {
425  checkThreadID(tid);
426  bool has_active_block_objects = false;
427  for (const auto & object_pair : _active_block_objects[tid])
428  has_active_block_objects |= !(object_pair.second.empty());
429  return has_active_block_objects;
430 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _active_block_objects
Active block restricted objects (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ hasActiveBlockObjects() [2/2]

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

Definition at line 434 of file MooseObjectWarehouseBase.h.

435 {
436  checkThreadID(tid);
437  const auto iter = _active_block_objects[tid].find(id);
438  return iter != _active_block_objects[tid].end();
439 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _active_block_objects
Active block restricted objects (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ hasActiveBoundaryObjects() [1/2]

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

Definition at line 443 of file MooseObjectWarehouseBase.h.

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

444 {
445  checkThreadID(tid);
446  bool has_active_boundary_objects = false;
447  for (const auto & object_pair : _active_boundary_objects[tid])
448  has_active_boundary_objects |= !(object_pair.second.empty());
449  return has_active_boundary_objects;
450 }
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _active_boundary_objects
Active boundary restricted objects (THREAD_ID on outer vector)

◆ hasActiveBoundaryObjects() [2/2]

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

Definition at line 454 of file MooseObjectWarehouseBase.h.

455 {
456  checkThreadID(tid);
457  const auto iter = _active_boundary_objects[tid].find(id);
458  return iter != _active_boundary_objects[tid].end();
459 }
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _active_boundary_objects
Active boundary restricted objects (THREAD_ID on outer vector)

◆ hasActiveObject()

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

Convenience functions for checking/getting specific objects.

Definition at line 463 of file MooseObjectWarehouseBase.h.

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

464 {
465  checkThreadID(tid);
466  for (const auto & object : _active_objects[tid])
467  if (object->name() == name)
468  return true;
469  return false;
470 }
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)

◆ hasActiveObjects()

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

◆ hasObjects()

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

Convenience functions for determining if objects exist.

Definition at line 407 of file MooseObjectWarehouseBase.h.

Referenced by FEProblemBase::initialSetup().

408 {
409  checkThreadID(tid);
410  return !_all_objects[tid].empty();
411 }
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ numThreads()

template<typename T>
THREAD_ID MooseObjectWarehouseBase< T >::numThreads ( )
inline

Return the number of threads.

Definition at line 163 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearEigenSystem::addEigenTagToMooseObjects().

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

◆ size()

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

Return how many kernels we store in the current warehouse.

Definition at line 235 of file MooseObjectWarehouseBase.h.

236 {
237  checkThreadID(tid);
238  return _all_objects[tid].size();
239 }
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ sort()

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

Sort the objects using the DependencyResolver.

Definition at line 536 of file MooseObjectWarehouseBase.h.

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

537 {
538  checkThreadID(tid);
539 
540  for (auto & object_pair : _all_block_objects[tid])
541  sortHelper(object_pair.second);
542 
543  for (auto & object_pair : _all_boundary_objects[tid])
544  sortHelper(object_pair.second);
545 
546  sortHelper(_all_objects[tid]);
547 
548  // The active lists now must be update to reflect the order changes
549  updateActive(tid);
550 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
static void sortHelper(std::vector< std::shared_ptr< T >> &objects)
Helper method for sorting vectors of objects.
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
virtual void updateActive(THREAD_ID tid=0)
Updates the active objects storage.

◆ sortHelper()

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

Helper method for sorting vectors of objects.

Definition at line 674 of file MooseObjectWarehouseBase.h.

675 {
676  // Do nothing if the vector is empty
677  if (objects.empty())
678  return;
679 
680  try
681  {
682  // Sort based on dependencies
683  DependencyResolverInterface::sort<std::shared_ptr<T>>(objects);
684  }
685  catch (CyclicDependencyException<std::shared_ptr<T>> & e)
686  {
687  DependencyResolverInterface::cyclicDependencyError<std::shared_ptr<T>>(
688  e, "Cyclic dependency detected in object ordering");
689  }
690 }

◆ subdomainsCovered()

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

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

Definition at line 661 of file MooseObjectWarehouseBase.h.

Referenced by NonlinearSystemBase::checkKernelCoverage().

664 {
665  for (const auto & object : _active_objects[tid])
666  unique_variables.insert(object->variable().name());
667 
668  for (const auto & object_pair : _active_block_objects[tid])
669  subdomains_covered.insert(object_pair.first);
670 }
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::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)

◆ updateActive()

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

Updates the active objects storage.

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

Definition at line 507 of file MooseObjectWarehouseBase.h.

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

508 {
509  checkThreadID(tid);
510 
512 
513  for (const auto & object_pair : _all_block_objects[tid])
514  updateActiveHelper(_active_block_objects[tid][object_pair.first], object_pair.second);
515 
516  for (const auto & object_pair : _all_boundary_objects[tid])
517  updateActiveHelper(_active_boundary_objects[tid][object_pair.first], object_pair.second);
518 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _all_block_objects
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _active_block_objects
Active block restricted objects (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
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< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
static void updateActiveHelper(std::vector< std::shared_ptr< T >> &active, const std::vector< std::shared_ptr< T >> &all)
Helper method for updating active vectors.

◆ updateActiveHelper()

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

Helper method for updating active vectors.

Definition at line 522 of file MooseObjectWarehouseBase.h.

524 {
525  // Clear the active list
526  active.clear();
527 
528  std::copy_if(all.begin(),
529  all.end(),
530  std::back_inserter(active),
531  [](const std::shared_ptr<T> & object) { return object->enabled(); });
532 }

◆ updateBlockMatPropDependency()

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

Definition at line 620 of file MooseObjectWarehouseBase.h.

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

623 {
624  if (hasActiveBlockObjects(id, tid))
625  updateMatPropDependencyHelper(needed_mat_props, getActiveBlockObjects(id, tid));
626 }
bool hasActiveBlockObjects(THREAD_ID tid=0) const
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
static void updateMatPropDependencyHelper(std::set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating material property dependency vector.

◆ updateBlockVariableDependency()

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

Definition at line 563 of file MooseObjectWarehouseBase.h.

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

567 {
568  if (hasActiveBlockObjects(id, tid))
569  updateVariableDependencyHelper(needed_moose_vars, getActiveBlockObjects(id, tid));
570 }
bool hasActiveBlockObjects(THREAD_ID tid=0) const
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
static void updateVariableDependencyHelper(std::set< MooseVariableFEBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating variable dependency vector.

◆ updateBoundaryMatPropDependency() [1/2]

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

Definition at line 630 of file MooseObjectWarehouseBase.h.

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

632 {
633  if (hasActiveBoundaryObjects(tid))
634  for (auto & active_bnd_object : _active_boundary_objects[tid])
635  updateMatPropDependencyHelper(needed_mat_props, active_bnd_object.second);
636 }
static void updateMatPropDependencyHelper(std::set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating material property dependency vector.
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _active_boundary_objects
Active boundary restricted objects (THREAD_ID on outer vector)

◆ updateBoundaryMatPropDependency() [2/2]

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

Definition at line 640 of file MooseObjectWarehouseBase.h.

642 {
643  if (hasActiveBoundaryObjects(id, tid))
644  updateMatPropDependencyHelper(needed_mat_props, getActiveBoundaryObjects(id, tid));
645 }
static void updateMatPropDependencyHelper(std::set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating material property dependency vector.
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const

◆ updateBoundaryVariableDependency() [1/2]

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

Definition at line 574 of file MooseObjectWarehouseBase.h.

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

576 {
577  if (hasActiveBoundaryObjects(tid))
578  {
579  typename std::map<BoundaryID, std::vector<std::shared_ptr<T>>>::const_iterator it;
580  for (const auto & object_pair : _active_boundary_objects[tid])
581  updateVariableDependencyHelper(needed_moose_vars, object_pair.second);
582  }
583 }
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _active_boundary_objects
Active boundary restricted objects (THREAD_ID on outer vector)
static void updateVariableDependencyHelper(std::set< MooseVariableFEBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating variable dependency vector.

◆ updateBoundaryVariableDependency() [2/2]

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

Definition at line 587 of file MooseObjectWarehouseBase.h.

591 {
592  if (hasActiveBoundaryObjects(id, tid))
593  updateVariableDependencyHelper(needed_moose_vars, getActiveBoundaryObjects(id, tid));
594 }
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
static void updateVariableDependencyHelper(std::set< MooseVariableFEBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating variable dependency vector.

◆ updateMatPropDependency()

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

Update material property dependency vector.

Definition at line 611 of file MooseObjectWarehouseBase.h.

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

613 {
614  if (hasActiveObjects(tid))
615  updateMatPropDependencyHelper(needed_mat_props, _all_objects[tid]);
616 }
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
static void updateMatPropDependencyHelper(std::set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating material property dependency vector.
bool hasActiveObjects(THREAD_ID tid=0) const

◆ updateMatPropDependencyHelper()

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

Helper method for updating material property dependency vector.

Definition at line 649 of file MooseObjectWarehouseBase.h.

651 {
652  for (auto & object : objects)
653  {
654  auto & mp_deps = object->getMatPropDependencies();
655  needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
656  }
657 }

◆ updateVariableDependency()

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

Update variable dependency vector.

Definition at line 554 of file MooseObjectWarehouseBase.h.

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

556 {
557  if (hasActiveObjects(tid))
558  updateVariableDependencyHelper(needed_moose_vars, _all_objects[tid]);
559 }
std::vector< std::vector< std::shared_ptr< T > > > _all_objects
Storage container for the ALL pointers (THREAD_ID on outer vector)
bool hasActiveObjects(THREAD_ID tid=0) const
static void updateVariableDependencyHelper(std::set< MooseVariableFEBase *> &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating variable dependency vector.

◆ updateVariableDependencyHelper()

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

Helper method for updating variable dependency vector.

Definition at line 598 of file MooseObjectWarehouseBase.h.

601 {
602  for (const auto & object : objects)
603  {
604  const auto & mv_deps = object->getMooseVariableDependencies();
605  needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
606  }
607 }

Member Data Documentation

◆ _active_block_objects

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

Active block restricted objects (THREAD_ID on outer vector)

Definition at line 179 of file MooseObjectWarehouseBase.h.

◆ _active_boundary_objects

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

Active boundary restricted objects (THREAD_ID on outer vector)

Definition at line 185 of file MooseObjectWarehouseBase.h.

◆ _active_objects

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

All active objects (THREAD_ID on outer vector)

Definition at line 173 of file MooseObjectWarehouseBase.h.

◆ _all_block_objects

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

Definition at line 176 of file MooseObjectWarehouseBase.h.

◆ _all_boundary_objects

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

Definition at line 182 of file MooseObjectWarehouseBase.h.

◆ _all_objects

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

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

Definition at line 170 of file MooseObjectWarehouseBase.h.

◆ _num_threads

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

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

Definition at line 167 of file MooseObjectWarehouseBase.h.

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


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