www.mooseframework.org
MooseObjectWarehouseBase.h
Go to the documentation of this file.
1 /****************************************************************/
2 /* DO NOT MODIFY THIS HEADER */
3 /* MOOSE - Multiphysics Object Oriented Simulation Environment */
4 /* */
5 /* (c) 2010 Battelle Energy Alliance, LLC */
6 /* ALL RIGHTS RESERVED */
7 /* */
8 /* Prepared by Battelle Energy Alliance, LLC */
9 /* Under Contract No. DE-AC07-05ID14517 */
10 /* With the U. S. Department of Energy */
11 /* */
12 /* See COPYRIGHT for full restrictions */
13 /****************************************************************/
14 
15 #ifndef MOOSEOBJECTWAREHOUSEBASE_H
16 #define MOOSEOBJECTWAREHOUSEBASE_H
17 
18 // MOOSE includes
20 #include "BoundaryRestrictable.h"
21 #include "BlockRestrictable.h"
22 #include "TransientInterface.h"
23 #include "Coupleable.h"
24 #include "MooseVariableInterface.h"
25 
26 // Forward declarations
27 class MooseVariable;
28 
32 template <typename T>
34 {
35 public:
40  MooseObjectWarehouseBase(bool threaded = true);
41 
45  virtual ~MooseObjectWarehouseBase();
46 
51  virtual void addObject(std::shared_ptr<T> object, THREAD_ID tid = 0);
52 
54 
58  const std::vector<std::shared_ptr<T>> & getObjects(THREAD_ID tid = 0) const;
59  const std::map<SubdomainID, std::vector<std::shared_ptr<T>>> &
60  getBlockObjects(THREAD_ID tid = 0) const;
61  const std::vector<std::shared_ptr<T>> & getBlockObjects(SubdomainID id, THREAD_ID tid = 0) const;
62  const std::map<BoundaryID, std::vector<std::shared_ptr<T>>> &
63  getBoundaryObjects(THREAD_ID tid = 0) const;
64  const std::vector<std::shared_ptr<T>> & getBoundaryObjects(BoundaryID id,
65  THREAD_ID tid = 0) const;
67 
69 
74  const std::vector<std::shared_ptr<T>> & getActiveObjects(THREAD_ID tid = 0) const;
75  const std::map<SubdomainID, std::vector<std::shared_ptr<T>>> &
76  getActiveBlockObjects(THREAD_ID tid = 0) const;
77  const std::vector<std::shared_ptr<T>> & getActiveBlockObjects(SubdomainID id,
78  THREAD_ID tid = 0) const;
79  const std::map<BoundaryID, std::vector<std::shared_ptr<T>>> &
80  getActiveBoundaryObjects(THREAD_ID tid = 0) const;
81  const std::vector<std::shared_ptr<T>> & getActiveBoundaryObjects(BoundaryID id,
82  THREAD_ID tid = 0) const;
84 
86 
89  bool hasActiveObjects(THREAD_ID tid = 0) const;
90  bool hasActiveBlockObjects(THREAD_ID tid = 0) const;
91  bool hasActiveBlockObjects(SubdomainID id, THREAD_ID tid = 0) const;
92  bool hasActiveBoundaryObjects(THREAD_ID tid = 0) const;
93  bool hasActiveBoundaryObjects(BoundaryID id, THREAD_ID tid = 0) const;
95 
99  std::set<SubdomainID> getActiveBlocks(THREAD_ID tid = 0) const;
100 
102 
105  bool hasActiveObject(const std::string & name, THREAD_ID tid = 0) const;
106  std::shared_ptr<T> getActiveObject(const std::string & name, THREAD_ID tid = 0) const;
108 
112  virtual void updateActive(THREAD_ID tid = 0);
113 
117  void sort(THREAD_ID tid = 0);
118 
120 
123  void updateVariableDependency(std::set<MooseVariable *> & needed_moose_vars,
124  THREAD_ID tid = 0) const;
126  std::set<MooseVariable *> & needed_moose_vars,
127  THREAD_ID tid = 0) const;
128  void updateBoundaryVariableDependency(std::set<MooseVariable *> & needed_moose_vars,
129  THREAD_ID tid = 0) const;
131  std::set<MooseVariable *> & needed_moose_vars,
132  THREAD_ID tid = 0) const;
134 
136 
139  void updateMatPropDependency(std::set<unsigned int> & needed_mat_props, THREAD_ID tid = 0) const;
141  std::set<unsigned int> & needed_mat_props,
142  THREAD_ID tid = 0) const;
143  void updateBoundaryMatPropDependency(std::set<unsigned int> & needed_mat_props,
144  THREAD_ID tid = 0) const;
146  std::set<unsigned int> & needed_mat_props,
147  THREAD_ID tid = 0) const;
149 
153  void subdomainsCovered(std::set<SubdomainID> & subdomains_covered,
154  std::set<std::string> & unique_variables,
155  THREAD_ID tid = 0) const;
156 
157 protected:
160 
162  std::vector<std::vector<std::shared_ptr<T>>> _all_objects;
163 
165  std::vector<std::vector<std::shared_ptr<T>>> _active_objects;
166 
167  // All block restricted objects (THREAD_ID on outer vector)
168  std::vector<std::map<SubdomainID, std::vector<std::shared_ptr<T>>>> _all_block_objects;
169 
171  std::vector<std::map<SubdomainID, std::vector<std::shared_ptr<T>>>> _active_block_objects;
172 
173  // All boundary restricted objects (THREAD_ID on outer vector)
174  std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<T>>>> _all_boundary_objects;
175 
177  std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<T>>>> _active_boundary_objects;
178 
182  static void updateActiveHelper(std::vector<std::shared_ptr<T>> & active,
183  const std::vector<std::shared_ptr<T>> & all);
184 
188  static void sortHelper(std::vector<std::shared_ptr<T>> & objects);
189 
193  static void updateVariableDependencyHelper(std::set<MooseVariable *> & needed_moose_vars,
194  const std::vector<std::shared_ptr<T>> & objects);
195 
199  static void updateMatPropDependencyHelper(std::set<unsigned int> & needed_mat_props,
200  const std::vector<std::shared_ptr<T>> & objects);
201 
205  void checkThreadID(THREAD_ID tid) const;
206 };
207 
208 template <typename T>
210  : _num_threads(threaded ? libMesh::n_threads() : 1),
217 {
218 }
219 
220 template <typename T>
222 {
223 }
224 
225 template <typename T>
226 void
227 MooseObjectWarehouseBase<T>::addObject(std::shared_ptr<T> object, THREAD_ID tid /*= 0*/)
228 {
229  checkThreadID(tid);
230 
231  // Stores object in list of all objects
232  _all_objects[tid].push_back(object);
233 
234  // If enabled, store object in a list of all active
235  bool enabled = object->enabled();
236  if (enabled)
237  _active_objects[tid].push_back(object);
238 
239  // Perform casts to the Block/BoundaryRestrictable
240  std::shared_ptr<BoundaryRestrictable> bnd =
241  std::dynamic_pointer_cast<BoundaryRestrictable>(object);
242  std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
243 
244  // Boundary Restricted
245  if (bnd && bnd->boundaryRestricted())
246  {
247  const std::set<BoundaryID> & ids = bnd->boundaryIDs();
248  for (std::set<BoundaryID>::const_iterator it = ids.begin(); it != ids.end(); ++it)
249  {
250  _all_boundary_objects[tid][*it].push_back(object);
251  if (enabled)
252  _active_boundary_objects[tid][*it].push_back(object);
253  }
254  }
255 
256  // Block Restricted
257  else if (blk)
258  {
259  const std::set<SubdomainID> & ids =
260  blk->blockRestricted() ? blk->blockIDs() : blk->meshBlockIDs();
261  for (std::set<SubdomainID>::const_iterator it = ids.begin(); it != ids.end(); ++it)
262  {
263  _all_block_objects[tid][*it].push_back(object);
264  if (enabled)
265  _active_block_objects[tid][*it].push_back(object);
266  }
267 
268  // Check variables
269  std::shared_ptr<Coupleable> c_ptr = std::dynamic_pointer_cast<Coupleable>(object);
270  if (c_ptr)
271  for (MooseVariable * var : c_ptr->getCoupledMooseVars())
272  blk->checkVariable(*var);
273 
274  std::shared_ptr<MooseVariableInterface> mvi_ptr =
275  std::dynamic_pointer_cast<MooseVariableInterface>(object);
276  if (mvi_ptr)
277  blk->checkVariable(*(mvi_ptr->mooseVariable()));
278  }
279 }
280 
281 template <typename T>
282 inline const std::vector<std::shared_ptr<T>> &
284 {
285  checkThreadID(tid);
286  return _all_objects[tid];
287 }
288 
289 template <typename T>
290 inline const std::map<BoundaryID, std::vector<std::shared_ptr<T>>> &
292 {
293  checkThreadID(tid);
294  return _all_boundary_objects[tid];
295 }
296 
297 template <typename T>
298 const std::vector<std::shared_ptr<T>> &
300 {
301  checkThreadID(tid);
302  const auto iter = _all_boundary_objects[tid].find(id);
303  mooseAssert(iter != _all_boundary_objects[tid].end(),
304  "Unable to located active boundary objects for the given id: " << id << ".");
305  return iter->second;
306 }
307 
308 template <typename T>
309 inline const std::map<SubdomainID, std::vector<std::shared_ptr<T>>> &
311 {
312  checkThreadID(tid);
313  return _all_block_objects[tid];
314 }
315 
316 template <typename T>
317 const std::vector<std::shared_ptr<T>> &
319 {
320  checkThreadID(tid);
321  const auto iter = _all_block_objects[tid].find(id);
322  mooseAssert(iter != _all_block_objects[tid].end(),
323  "Unable to located active block objects for the given id: " << id << ".");
324  return iter->second;
325 }
326 
327 template <typename T>
328 inline const std::vector<std::shared_ptr<T>> &
330 {
331  checkThreadID(tid);
332  return _active_objects[tid];
333 }
334 
335 template <typename T>
336 inline const std::map<BoundaryID, std::vector<std::shared_ptr<T>>> &
338 {
339  checkThreadID(tid);
340  return _active_boundary_objects[tid];
341 }
342 
343 template <typename T>
344 const std::vector<std::shared_ptr<T>> &
346 {
347  checkThreadID(tid);
348  const auto iter = _active_boundary_objects[tid].find(id);
349  mooseAssert(iter != _active_boundary_objects[tid].end(),
350  "Unable to located active boundary objects for the given id: " << id << ".");
351  return iter->second;
352 }
353 
354 template <typename T>
355 inline const std::map<SubdomainID, std::vector<std::shared_ptr<T>>> &
357 {
358  checkThreadID(tid);
359  return _active_block_objects[tid];
360 }
361 
362 template <typename T>
363 const std::vector<std::shared_ptr<T>> &
365 {
366  checkThreadID(tid);
367  const auto iter = _active_block_objects[tid].find(id);
368  mooseAssert(iter != _active_block_objects[tid].end(),
369  "Unable to located active block objects for the given id: " << id << ".");
370  return iter->second;
371 }
372 
373 template <typename T>
374 bool
376 {
377  checkThreadID(tid);
378  return !_active_objects[tid].empty();
379 }
380 
381 template <typename T>
382 bool
384 {
385  checkThreadID(tid);
386  bool has_active_block_objects = false;
387  for (const auto & object_pair : _active_block_objects[tid])
388  has_active_block_objects |= !(object_pair.second.empty());
389  return has_active_block_objects;
390 }
391 
392 template <typename T>
393 bool
395 {
396  checkThreadID(tid);
397  const auto iter = _active_block_objects[tid].find(id);
398  return iter != _active_block_objects[tid].end();
399 }
400 
401 template <typename T>
402 bool
404 {
405  checkThreadID(tid);
406  bool has_active_boundary_objects = false;
407  for (const auto & object_pair : _active_boundary_objects[tid])
408  has_active_boundary_objects |= !(object_pair.second.empty());
409  return has_active_boundary_objects;
410 }
411 
412 template <typename T>
413 bool
415 {
416  checkThreadID(tid);
417  const auto iter = _active_boundary_objects[tid].find(id);
418  return iter != _active_boundary_objects[tid].end();
419 }
420 
421 template <typename T>
422 bool
423 MooseObjectWarehouseBase<T>::hasActiveObject(const std::string & name, THREAD_ID tid /* = 0*/) const
424 {
425  checkThreadID(tid);
426  for (const auto & object : _active_objects[tid])
427  if (object->name() == name)
428  return true;
429  return false;
430 }
431 
432 template <typename T>
433 std::shared_ptr<T>
434 MooseObjectWarehouseBase<T>::getActiveObject(const std::string & name, THREAD_ID tid /* = 0*/) const
435 {
436  checkThreadID(tid);
437  for (const auto & object : _active_objects[tid])
438  if (object->name() == name)
439  return object;
440  mooseError("Unable to locate active object: ", name, ".");
441 }
442 
443 template <typename T>
444 std::set<SubdomainID>
446 {
447  checkThreadID(tid);
448  std::set<SubdomainID> ids;
449  for (const auto & object_pair : _active_block_objects[tid])
450  ids.insert(object_pair.first);
451  return ids;
452 }
453 
454 template <typename T>
455 void
457 {
458  checkThreadID(tid);
459 
461 
462  for (const auto & object_pair : _all_block_objects[tid])
463  updateActiveHelper(_active_block_objects[tid][object_pair.first], object_pair.second);
464 
465  for (const auto & object_pair : _all_boundary_objects[tid])
466  updateActiveHelper(_active_boundary_objects[tid][object_pair.first], object_pair.second);
467 }
468 
469 template <typename T>
470 void
471 MooseObjectWarehouseBase<T>::updateActiveHelper(std::vector<std::shared_ptr<T>> & active,
472  const std::vector<std::shared_ptr<T>> & all)
473 {
474  // Clear the active list
475  active.clear();
476 
477  std::copy_if(all.begin(),
478  all.end(),
479  std::back_inserter(active),
480  [](const std::shared_ptr<T> & object) { return object->enabled(); });
481 }
482 
483 template <typename T>
484 void
486 {
487  checkThreadID(tid);
488 
489  for (auto & object_pair : _all_block_objects[tid])
490  sortHelper(object_pair.second);
491 
492  for (auto & object_pair : _all_boundary_objects[tid])
493  sortHelper(object_pair.second);
494 
495  sortHelper(_all_objects[tid]);
496 
497  // The active lists now must be update to reflect the order changes
498  updateActive(tid);
499 }
500 
501 template <typename T>
502 void
503 MooseObjectWarehouseBase<T>::updateVariableDependency(std::set<MooseVariable *> & needed_moose_vars,
504  THREAD_ID tid /* = 0*/) const
505 {
506  if (hasActiveObjects(tid))
507  updateVariableDependencyHelper(needed_moose_vars, _all_objects[tid]);
508 }
509 
510 template <typename T>
511 void
513  SubdomainID id, std::set<MooseVariable *> & needed_moose_vars, THREAD_ID tid /* = 0*/) const
514 {
515  if (hasActiveBlockObjects(id, tid))
516  updateVariableDependencyHelper(needed_moose_vars, getActiveBlockObjects(id, tid));
517 }
518 
519 template <typename T>
520 void
522  std::set<MooseVariable *> & needed_moose_vars, THREAD_ID tid /* = 0*/) const
523 {
524  if (hasActiveBoundaryObjects(tid))
525  {
526  typename std::map<BoundaryID, std::vector<std::shared_ptr<T>>>::const_iterator it;
527  for (const auto & object_pair : _active_boundary_objects[tid])
528  updateVariableDependencyHelper(needed_moose_vars, object_pair.second);
529  }
530 }
531 
532 template <typename T>
533 void
535  BoundaryID id, std::set<MooseVariable *> & needed_moose_vars, THREAD_ID tid /* = 0*/) const
536 {
537  if (hasActiveBoundaryObjects(id, tid))
538  updateVariableDependencyHelper(needed_moose_vars, getActiveBoundaryObjects(id, tid));
539 }
540 
541 template <typename T>
542 void
544  std::set<MooseVariable *> & needed_moose_vars, const std::vector<std::shared_ptr<T>> & objects)
545 {
546  for (const auto & object : objects)
547  {
548  const auto & mv_deps = object->getMooseVariableDependencies();
549  needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
550  }
551 }
552 
553 template <typename T>
554 void
555 MooseObjectWarehouseBase<T>::updateMatPropDependency(std::set<unsigned int> & needed_mat_props,
556  THREAD_ID tid /* = 0*/) const
557 {
558  if (hasActiveObjects(tid))
559  updateMatPropDependencyHelper(needed_mat_props, _all_objects[tid]);
560 }
561 
562 template <typename T>
563 void
565  std::set<unsigned int> & needed_mat_props,
566  THREAD_ID tid /* = 0*/) const
567 {
568  if (hasActiveBlockObjects(id, tid))
569  updateMatPropDependencyHelper(needed_mat_props, getActiveBlockObjects(id, tid));
570 }
571 
572 template <typename T>
573 void
575  std::set<unsigned int> & needed_mat_props, THREAD_ID tid /* = 0*/) const
576 {
577  if (hasActiveBoundaryObjects(tid))
578  for (auto & active_bnd_object : _active_boundary_objects[tid])
579  updateMatPropDependencyHelper(needed_mat_props, active_bnd_object.second);
580 }
581 
582 template <typename T>
583 void
585  BoundaryID id, std::set<unsigned int> & needed_mat_props, THREAD_ID tid /* = 0*/) const
586 {
587  if (hasActiveBoundaryObjects(id, tid))
588  updateMatPropDependencyHelper(needed_mat_props, getActiveBoundaryObjects(id, tid));
589 }
590 
591 template <typename T>
592 void
594  std::set<unsigned int> & needed_mat_props, const std::vector<std::shared_ptr<T>> & objects)
595 {
596  for (auto & object : objects)
597  {
598  auto & mp_deps = object->getMatPropDependencies();
599  needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
600  }
601 }
602 
603 template <typename T>
604 void
605 MooseObjectWarehouseBase<T>::subdomainsCovered(std::set<SubdomainID> & subdomains_covered,
606  std::set<std::string> & unique_variables,
607  THREAD_ID tid /*=0*/) const
608 {
609  for (const auto & object : _active_objects[tid])
610  unique_variables.insert(object->variable().name());
611 
612  for (const auto & object_pair : _active_block_objects[tid])
613  subdomains_covered.insert(object_pair.first);
614 }
615 
616 template <typename T>
617 void
618 MooseObjectWarehouseBase<T>::sortHelper(std::vector<std::shared_ptr<T>> & objects)
619 {
620  // Do nothing if the vector is empty
621  if (objects.empty())
622  return;
623 
624  // Make sure the object is sortable
625  mooseAssert(std::dynamic_pointer_cast<DependencyResolverInterface>(objects[0]),
626  "Objects must inhert from DependencyResolverInterface to be sorted.");
627 
628  try
629  {
630  // Sort based on dependencies
631  DependencyResolverInterface::sort<std::shared_ptr<T>>(objects);
632  }
633  catch (CyclicDependencyException<std::shared_ptr<T>> & e)
634  {
635  DependencyResolverInterface::cyclicDependencyError<std::shared_ptr<T>>(
636  e, "Cyclic dependency detected in object ordering");
637  }
638 }
639 
640 template <typename T>
641 inline void
643 {
644  mooseAssert(tid < _num_threads,
645  "Attempting to access a thread id ("
646  << tid
647  << ") greater than the number allowed by the storage item ("
648  << _num_threads
649  << ")");
650 }
651 
652 #endif // MOOSEOBJECTWAREHOUSEBASE_H
void sort(THREAD_ID tid=0)
Sort the objects using the DependencyResolver.
void updateBlockVariableDependency(SubdomainID id, std::set< MooseVariable * > &needed_moose_vars, THREAD_ID tid=0) const
std::shared_ptr< T > getActiveObject(const std::string &name, THREAD_ID tid=0) const
void updateBlockMatPropDependency(SubdomainID id, std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
Class for stuff related to variables.
Definition: MooseVariable.h:43
subdomain_id_type SubdomainID
Definition: MooseTypes.h:77
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)
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
bool hasActiveObject(const std::string &name, THREAD_ID tid=0) const
Convenience functions for checking/getting specific objects.
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.
void mooseError(Args &&...args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:182
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< T > > > > _active_block_objects
Active block restricted objects (THREAD_ID on outer vector)
virtual ~MooseObjectWarehouseBase()
Destructor.
/class BoundaryRestrictable /brief Provides functionality for limiting the object to certain boundary...
MooseObjectWarehouseBase(bool threaded=true)
Constructor.
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0)
Adds an object to the storage structure.
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getBoundaryObjects(THREAD_ID tid=0) const
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
void updateBoundaryVariableDependency(std::set< MooseVariable * > &needed_moose_vars, 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)
void updateVariableDependency(std::set< MooseVariable * > &needed_moose_vars, THREAD_ID tid=0) const
Update variable dependency vector.
void updateBoundaryMatPropDependency(std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
static void sortHelper(std::vector< std::shared_ptr< T >> &objects)
Helper method for sorting vectors of objects.
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
bool hasActiveObjects(THREAD_ID tid=0) const
Convenience functions for determining if objects exist.
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< T > > > > _all_boundary_objects
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
const THREAD_ID _num_threads
Convenience member storing the number of threads used for storage (1 or libMesh::n_threads) ...
std::set< SubdomainID > getActiveBlocks(THREAD_ID tid=0) const
Return a set of active SubdomainsIDs.
Interface for objects that needs coupling capabilities.
Definition: Coupleable.h:35
void updateMatPropDependency(std::set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
Update material property dependency vector.
Interface for objects that need to get values of MooseVariables.
An interface that restricts an object to subdomains via the &#39;blocks&#39; input parameter.
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getBlockObjects(THREAD_ID tid=0) const
bool hasActiveBlockObjects(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...
std::vector< std::vector< std::shared_ptr< T > > > _active_objects
All active objects (THREAD_ID on outer vector)
static void updateVariableDependencyHelper(std::set< MooseVariable * > &needed_moose_vars, const std::vector< std::shared_ptr< T >> &objects)
Helper method for updating variable dependency vector.
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...
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.
A base storage container for MooseObjects.
static void updateActiveHelper(std::vector< std::shared_ptr< T >> &active, const std::vector< std::shared_ptr< T >> &all)
Helper method for updating active vectors.
virtual void updateActive(THREAD_ID tid=0)
Updates the active objects storage.
boundary_id_type BoundaryID
Definition: MooseTypes.h:75
unsigned int THREAD_ID
Definition: MooseTypes.h:79