www.mooseframework.org
Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
InitialConditionWarehouse Class Reference

Warehouse for storing initial conditions. More...

#include <InitialConditionWarehouse.h>

Inheritance diagram for InitialConditionWarehouse:
[legend]

Public Member Functions

 InitialConditionWarehouse ()
 
void initialSetup (THREAD_ID tid)
 Initial setup. More...
 
void addObject (std::shared_ptr< InitialConditionBase > object, THREAD_ID tid, bool recurse=true)
 Add object to the warehouse. More...
 
std::set< std::string > getDependObjects () const
 Get a list of dependent UserObjects for this exec type. 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< InitialConditionBase > > & 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< InitialConditionBase > > > & getBlockObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< InitialConditionBase > > & getBlockObjects (SubdomainID id, THREAD_ID tid=0) const
 
const std::map< BoundaryID, std::vector< std::shared_ptr< InitialConditionBase > > > & getBoundaryObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< InitialConditionBase > > & getBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< InitialConditionBase > > & 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< InitialConditionBase > > > & getActiveBlockObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< InitialConditionBase > > & getActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const
 
const std::map< BoundaryID, std::vector< std::shared_ptr< InitialConditionBase > > > & getActiveBoundaryObjects (THREAD_ID tid=0) const
 
const std::vector< std::shared_ptr< InitialConditionBase > > & 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< InitialConditionBasegetObject (const std::string &name, THREAD_ID tid=0) const
 
std::shared_ptr< InitialConditionBasegetActiveObject (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< InitialConditionBase >> &active, const std::vector< std::shared_ptr< InitialConditionBase >> &all)
 Helper method for updating active vectors. More...
 
static void sortHelper (std::vector< std::shared_ptr< InitialConditionBase >> &objects)
 Helper method for sorting vectors of objects. More...
 
static void updateVariableDependencyHelper (std::set< MooseVariableFEBase * > &needed_moose_vars, const std::vector< std::shared_ptr< InitialConditionBase >> &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< InitialConditionBase >> &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< InitialConditionBase > > > _all_objects
 Storage container for the ALL pointers (THREAD_ID on outer vector) More...
 
std::vector< std::vector< std::shared_ptr< InitialConditionBase > > > _active_objects
 All active objects (THREAD_ID on outer vector) More...
 
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< InitialConditionBase > > > > _all_block_objects
 
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< InitialConditionBase > > > > _active_block_objects
 Active block restricted objects (THREAD_ID on outer vector) More...
 
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< InitialConditionBase > > > > _all_boundary_objects
 
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< InitialConditionBase > > > > _active_boundary_objects
 Active boundary restricted objects (THREAD_ID on outer vector) More...
 
std::vector< std::map< std::string, std::set< BoundaryID > > > _boundary_ics
 
std::vector< std::map< std::string, std::set< SubdomainID > > > _block_ics
 

Detailed Description

Warehouse for storing initial conditions.

Definition at line 20 of file InitialConditionWarehouse.h.

Constructor & Destructor Documentation

◆ InitialConditionWarehouse()

InitialConditionWarehouse::InitialConditionWarehouse ( )

Definition at line 16 of file InitialConditionWarehouse.C.

18  _boundary_ics(libMesh::n_threads()),
19  _block_ics(libMesh::n_threads())
20 {
21 }
std::vector< std::map< std::string, std::set< BoundaryID > > > _boundary_ics
std::vector< std::map< std::string, std::set< SubdomainID > > > _block_ics

Member Function Documentation

◆ addObject()

void InitialConditionWarehouse::addObject ( std::shared_ptr< InitialConditionBase object,
THREAD_ID  tid,
bool  recurse = true 
)
virtual

Add object to the warehouse.

Reimplemented from MooseObjectWarehouseBase< InitialConditionBase >.

Definition at line 32 of file InitialConditionWarehouse.C.

Referenced by FEProblemBase::addInitialCondition().

35 {
36  // Check that when object is boundary restricted that the variable is nodal
37  const MooseVariableFEBase & var = object->variable();
38 
39  // Boundary Restricted
40  if (object->boundaryRestricted())
41  {
42  if (!var.isNodal())
43  mooseError("You are trying to set a boundary restricted variable on non-nodal variable. That "
44  "is not allowed.");
45 
46  std::map<std::string, std::set<BoundaryID>>::const_iterator iter =
47  _boundary_ics[tid].find(var.name());
48  if (iter != _boundary_ics[tid].end() && object->hasBoundary(iter->second))
49  mooseError("The initial condition '",
50  object->name(),
51  "' is being defined on a boundary that already has an initial condition defined.");
52  else
53  _boundary_ics[tid][var.name()].insert(object->boundaryIDs().begin(),
54  object->boundaryIDs().end());
55  }
56 
57  // Block Restricted
58  else if (object->blockRestricted())
59  {
60  std::map<std::string, std::set<SubdomainID>>::const_iterator iter =
61  _block_ics[tid].find(var.name());
62  if (iter != _block_ics[tid].end() &&
63  (object->hasBlocks(iter->second) ||
64  (iter->second.find(Moose::ANY_BLOCK_ID) != iter->second.end())))
65  mooseError("The initial condition '",
66  object->name(),
67  "' is being defined on a block that already has an initial condition defined.");
68  else
69  _block_ics[tid][var.name()].insert(object->blockIDs().begin(), object->blockIDs().end());
70  }
71 
72  // Non-restricted
73  else
74  {
75  std::map<std::string, std::set<SubdomainID>>::const_iterator iter =
76  _block_ics[tid].find(var.name());
77  if (iter != _block_ics[tid].end())
78  mooseError("The initial condition '",
79  object->name(),
80  "' is being defined on a block that already has an initial condition defined.");
81  else
82  _block_ics[tid][var.name()].insert(Moose::ANY_BLOCK_ID);
83  }
84 
85  // Add the IC to the storage
87 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
std::vector< std::map< std::string, std::set< BoundaryID > > > _boundary_ics
virtual bool isNodal() const =0
Is this variable nodal.
std::vector< std::map< std::string, std::set< SubdomainID > > > _block_ics
const SubdomainID ANY_BLOCK_ID
Definition: MooseTypes.C:15
const std::string & name() const
Get the variable name.
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true)
Adds an object to the storage structure.

◆ checkThreadID()

void MooseObjectWarehouseBase< InitialConditionBase >::checkThreadID ( THREAD_ID  tid) const
inlineprotectedinherited

Calls assert on thread id.

Definition at line 693 of file MooseObjectWarehouseBase.h.

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

◆ getActiveBlockObjects() [1/2]

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

Definition at line 387 of file MooseObjectWarehouseBase.h.

388 {
389  checkThreadID(tid);
390  return _active_block_objects[tid];
391 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< InitialConditionBase > > > > _active_block_objects
Active block restricted objects (THREAD_ID on outer vector)
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.

◆ getActiveBlockObjects() [2/2]

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

Definition at line 395 of file MooseObjectWarehouseBase.h.

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

◆ getActiveBlocks()

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

Return a set of active SubdomainsIDs.

Definition at line 495 of file MooseObjectWarehouseBase.h.

496 {
497  checkThreadID(tid);
498  std::set<SubdomainID> ids;
499  for (const auto & object_pair : _active_block_objects[tid])
500  ids.insert(object_pair.first);
501  return ids;
502 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< InitialConditionBase > > > > _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]

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

Definition at line 368 of file MooseObjectWarehouseBase.h.

369 {
370  checkThreadID(tid);
371  return _active_boundary_objects[tid];
372 }
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< InitialConditionBase > > > > _active_boundary_objects
Active boundary restricted objects (THREAD_ID on outer vector)

◆ getActiveBoundaryObjects() [2/2]

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

Definition at line 376 of file MooseObjectWarehouseBase.h.

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

◆ getActiveObject()

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

Definition at line 484 of file MooseObjectWarehouseBase.h.

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

◆ getActiveObjects()

const std::vector< std::shared_ptr< InitialConditionBase > > & MooseObjectWarehouseBase< InitialConditionBase >::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 360 of file MooseObjectWarehouseBase.h.

Referenced by getDependObjects().

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

◆ getBlockObjects() [1/2]

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

Definition at line 341 of file MooseObjectWarehouseBase.h.

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

◆ getBlockObjects() [2/2]

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

Definition at line 349 of file MooseObjectWarehouseBase.h.

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

◆ getBoundaryObjects() [1/2]

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

Definition at line 322 of file MooseObjectWarehouseBase.h.

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

◆ getBoundaryObjects() [2/2]

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

Definition at line 330 of file MooseObjectWarehouseBase.h.

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

◆ getDependObjects()

std::set< std::string > InitialConditionWarehouse::getDependObjects ( ) const

Get a list of dependent UserObjects for this exec type.

Returns
a set of dependent user objects

Definition at line 90 of file InitialConditionWarehouse.C.

Referenced by FEProblemBase::initialSetup().

91 {
92  std::set<std::string> depend_objects;
93 
94  const auto & ics = getActiveObjects();
95  for (const auto & ic : ics)
96  {
97  const auto & uo = ic->getDependObjects();
98  depend_objects.insert(uo.begin(), uo.end());
99  }
100 
101  return depend_objects;
102 }
const std::vector< std::shared_ptr< InitialConditionBase > > & getActiveObjects(THREAD_ID tid=0) const
Retrieve complete vector to the active all/block/boundary restricted objects for a given thread...

◆ getObject()

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

Definition at line 473 of file MooseObjectWarehouseBase.h.

474 {
475  checkThreadID(tid);
476  for (const auto & object : _all_objects[tid])
477  if (object->name() == name)
478  return object;
479  mooseError("Unable to locate object: ", name, ".");
480 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
std::vector< std::vector< std::shared_ptr< InitialConditionBase > > > _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()

const std::vector< std::shared_ptr< InitialConditionBase > > & MooseObjectWarehouseBase< InitialConditionBase >::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 314 of file MooseObjectWarehouseBase.h.

315 {
316  checkThreadID(tid);
317  return _all_objects[tid];
318 }
std::vector< std::vector< std::shared_ptr< InitialConditionBase > > > _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]

bool MooseObjectWarehouseBase< InitialConditionBase >::hasActiveBlockObjects ( THREAD_ID  tid = 0) const
inherited

Definition at line 422 of file MooseObjectWarehouseBase.h.

423 {
424  checkThreadID(tid);
425  bool has_active_block_objects = false;
426  for (const auto & object_pair : _active_block_objects[tid])
427  has_active_block_objects |= !(object_pair.second.empty());
428  return has_active_block_objects;
429 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< InitialConditionBase > > > > _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]

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

Definition at line 433 of file MooseObjectWarehouseBase.h.

434 {
435  checkThreadID(tid);
436  const auto iter = _active_block_objects[tid].find(id);
437  return iter != _active_block_objects[tid].end();
438 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< InitialConditionBase > > > > _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]

bool MooseObjectWarehouseBase< InitialConditionBase >::hasActiveBoundaryObjects ( THREAD_ID  tid = 0) const
inherited

Definition at line 442 of file MooseObjectWarehouseBase.h.

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

◆ hasActiveBoundaryObjects() [2/2]

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

Definition at line 453 of file MooseObjectWarehouseBase.h.

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

◆ hasActiveObject()

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

Convenience functions for checking/getting specific objects.

Definition at line 462 of file MooseObjectWarehouseBase.h.

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

◆ hasActiveObjects()

bool MooseObjectWarehouseBase< InitialConditionBase >::hasActiveObjects ( THREAD_ID  tid = 0) const
inherited

Definition at line 414 of file MooseObjectWarehouseBase.h.

415 {
416  checkThreadID(tid);
417  return !_active_objects[tid].empty();
418 }
void checkThreadID(THREAD_ID tid) const
Calls assert on thread id.
std::vector< std::vector< std::shared_ptr< InitialConditionBase > > > _active_objects
All active objects (THREAD_ID on outer vector)

◆ hasObjects()

bool MooseObjectWarehouseBase< InitialConditionBase >::hasObjects ( THREAD_ID  tid = 0) const
inherited

Convenience functions for determining if objects exist.

Definition at line 406 of file MooseObjectWarehouseBase.h.

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

◆ initialSetup()

void InitialConditionWarehouse::initialSetup ( THREAD_ID  tid)

Initial setup.

Definition at line 24 of file InitialConditionWarehouse.C.

Referenced by FEProblemBase::initialSetup().

25 {
27  for (const auto & ic : _active_objects[tid])
28  ic->initialSetup();
29 }
void sort(THREAD_ID tid=0)
Sort the objects using the DependencyResolver.
std::vector< std::vector< std::shared_ptr< InitialConditionBase > > > _active_objects
All active objects (THREAD_ID on outer vector)

◆ numThreads()

THREAD_ID MooseObjectWarehouseBase< InitialConditionBase >::numThreads ( )
inlineinherited

Return the number of threads.

Definition at line 162 of file MooseObjectWarehouseBase.h.

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

◆ size()

unsigned int MooseObjectWarehouseBase< InitialConditionBase >::size ( THREAD_ID  tid = 0)
inherited

Return how many kernels we store in the current warehouse.

Definition at line 234 of file MooseObjectWarehouseBase.h.

235 {
236  checkThreadID(tid);
237  return _all_objects[tid].size();
238 }
std::vector< std::vector< std::shared_ptr< InitialConditionBase > > > _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()

void MooseObjectWarehouseBase< InitialConditionBase >::sort ( THREAD_ID  tid = 0)
inherited

Sort the objects using the DependencyResolver.

Definition at line 535 of file MooseObjectWarehouseBase.h.

536 {
537  checkThreadID(tid);
538 
539  for (auto & object_pair : _all_block_objects[tid])
540  sortHelper(object_pair.second);
541 
542  for (auto & object_pair : _all_boundary_objects[tid])
543  sortHelper(object_pair.second);
544 
545  sortHelper(_all_objects[tid]);
546 
547  // The active lists now must be update to reflect the order changes
548  updateActive(tid);
549 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< InitialConditionBase > > > > _all_block_objects
std::vector< std::vector< std::shared_ptr< InitialConditionBase > > > _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< InitialConditionBase >> &objects)
Helper method for sorting vectors of objects.
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< InitialConditionBase > > > > _all_boundary_objects
virtual void updateActive(THREAD_ID tid=0)
Updates the active objects storage.

◆ sortHelper()

void MooseObjectWarehouseBase< InitialConditionBase >::sortHelper ( std::vector< std::shared_ptr< InitialConditionBase >> &  objects)
staticprotectedinherited

Helper method for sorting vectors of objects.

Definition at line 673 of file MooseObjectWarehouseBase.h.

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

◆ subdomainsCovered()

void MooseObjectWarehouseBase< InitialConditionBase >::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 660 of file MooseObjectWarehouseBase.h.

663 {
664  for (const auto & object : _active_objects[tid])
665  unique_variables.insert(object->variable().name());
666 
667  for (const auto & object_pair : _active_block_objects[tid])
668  subdomains_covered.insert(object_pair.first);
669 }
std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< InitialConditionBase > > > > _active_block_objects
Active block restricted objects (THREAD_ID on outer vector)
std::vector< std::vector< std::shared_ptr< InitialConditionBase > > > _active_objects
All active objects (THREAD_ID on outer vector)

◆ updateActive()

void MooseObjectWarehouseBase< InitialConditionBase >::updateActive ( THREAD_ID  tid = 0)
virtualinherited

Updates the active objects storage.

Definition at line 506 of file MooseObjectWarehouseBase.h.

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

◆ updateActiveHelper()

void MooseObjectWarehouseBase< InitialConditionBase >::updateActiveHelper ( std::vector< std::shared_ptr< InitialConditionBase >> &  active,
const std::vector< std::shared_ptr< InitialConditionBase >> &  all 
)
staticprotectedinherited

Helper method for updating active vectors.

Definition at line 521 of file MooseObjectWarehouseBase.h.

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

◆ updateBlockMatPropDependency()

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

Definition at line 619 of file MooseObjectWarehouseBase.h.

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

◆ updateBlockVariableDependency()

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

Definition at line 562 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryMatPropDependency() [1/2]

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

Definition at line 629 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryMatPropDependency() [2/2]

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

Definition at line 639 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryVariableDependency() [1/2]

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

Definition at line 573 of file MooseObjectWarehouseBase.h.

575 {
576  if (hasActiveBoundaryObjects(tid))
577  {
578  typename std::map<BoundaryID, std::vector<std::shared_ptr<T>>>::const_iterator it;
579  for (const auto & object_pair : _active_boundary_objects[tid])
580  updateVariableDependencyHelper(needed_moose_vars, object_pair.second);
581  }
582 }
std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< InitialConditionBase > > > > _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< InitialConditionBase >> &objects)
Helper method for updating variable dependency vector.

◆ updateBoundaryVariableDependency() [2/2]

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

Definition at line 586 of file MooseObjectWarehouseBase.h.

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

◆ updateMatPropDependency()

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

Update material property dependency vector.

Definition at line 610 of file MooseObjectWarehouseBase.h.

612 {
613  if (hasActiveObjects(tid))
614  updateMatPropDependencyHelper(needed_mat_props, _all_objects[tid]);
615 }
std::vector< std::vector< std::shared_ptr< InitialConditionBase > > > _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< InitialConditionBase >> &objects)
Helper method for updating material property dependency vector.

◆ updateMatPropDependencyHelper()

void MooseObjectWarehouseBase< InitialConditionBase >::updateMatPropDependencyHelper ( std::set< unsigned int > &  needed_mat_props,
const std::vector< std::shared_ptr< InitialConditionBase >> &  objects 
)
staticprotectedinherited

Helper method for updating material property dependency vector.

Definition at line 648 of file MooseObjectWarehouseBase.h.

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

◆ updateVariableDependency()

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

Update variable dependency vector.

Definition at line 553 of file MooseObjectWarehouseBase.h.

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

◆ updateVariableDependencyHelper()

void MooseObjectWarehouseBase< InitialConditionBase >::updateVariableDependencyHelper ( std::set< MooseVariableFEBase *> &  needed_moose_vars,
const std::vector< std::shared_ptr< InitialConditionBase >> &  objects 
)
staticprotectedinherited

Helper method for updating variable dependency vector.

Definition at line 597 of file MooseObjectWarehouseBase.h.

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

Member Data Documentation

◆ _active_block_objects

std::vector<std::map<SubdomainID, std::vector<std::shared_ptr<InitialConditionBase > > > > MooseObjectWarehouseBase< InitialConditionBase >::_active_block_objects
protectedinherited

Active block restricted objects (THREAD_ID on outer vector)

Definition at line 178 of file MooseObjectWarehouseBase.h.

◆ _active_boundary_objects

std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<InitialConditionBase > > > > MooseObjectWarehouseBase< InitialConditionBase >::_active_boundary_objects
protectedinherited

Active boundary restricted objects (THREAD_ID on outer vector)

Definition at line 184 of file MooseObjectWarehouseBase.h.

◆ _active_objects

std::vector<std::vector<std::shared_ptr<InitialConditionBase > > > MooseObjectWarehouseBase< InitialConditionBase >::_active_objects
protectedinherited

All active objects (THREAD_ID on outer vector)

Definition at line 172 of file MooseObjectWarehouseBase.h.

Referenced by initialSetup().

◆ _all_block_objects

std::vector<std::map<SubdomainID, std::vector<std::shared_ptr<InitialConditionBase > > > > MooseObjectWarehouseBase< InitialConditionBase >::_all_block_objects
protectedinherited

Definition at line 175 of file MooseObjectWarehouseBase.h.

◆ _all_boundary_objects

std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<InitialConditionBase > > > > MooseObjectWarehouseBase< InitialConditionBase >::_all_boundary_objects
protectedinherited

Definition at line 181 of file MooseObjectWarehouseBase.h.

◆ _all_objects

std::vector<std::vector<std::shared_ptr<InitialConditionBase > > > MooseObjectWarehouseBase< InitialConditionBase >::_all_objects
protectedinherited

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

Definition at line 169 of file MooseObjectWarehouseBase.h.

◆ _block_ics

std::vector<std::map<std::string, std::set<SubdomainID> > > InitialConditionWarehouse::_block_ics
protected

Definition at line 45 of file InitialConditionWarehouse.h.

Referenced by addObject().

◆ _boundary_ics

std::vector<std::map<std::string, std::set<BoundaryID> > > InitialConditionWarehouse::_boundary_ics
protected

Variable name to block/boundary IDs for error checking

Definition at line 44 of file InitialConditionWarehouse.h.

Referenced by addObject().

◆ _num_threads

const THREAD_ID MooseObjectWarehouseBase< InitialConditionBase >::_num_threads
protectedinherited

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

Definition at line 166 of file MooseObjectWarehouseBase.h.


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