Warehouse for storing initial conditions. More...

#include <InitialConditionWarehouse.h>

Inheritance diagram for InitialConditionWarehouse:

Public Member Functions
	InitialConditionWarehouse (THREAD_ID num_threads=libMesh::n_threads())

void	initialSetup (THREAD_ID tid)
	Initial setup.

void	addObject (std::shared_ptr< InitialConditionBase > object, THREAD_ID tid, bool recurse=true)
	Add object to the warehouse.

std::set< std::string >	getDependObjects () const
	Get a list of dependent UserObjects for this exec type.

virtual void	addObject (std::shared_ptr< InitialConditionBase > object, THREAD_ID tid=0, bool recurse=true)
	Adds an object to the storage structure.

unsigned int	size (THREAD_ID tid=0) const
	Return how many kernels we store in the current warehouse.

bool	hasObjectsForVariableAndBlocks (const VariableName &var_name, const std::set< SubdomainID > &blocks, std::set< SubdomainID > &blocks_covered, THREAD_ID tid) const
	Whether there are objects for this variable and the set of blocks passed.

std::set< SubdomainID >	getActiveBlocks (THREAD_ID tid=0) const
	Return a set of active SubdomainsIDs.

const std::vector< std::shared_ptr< InitialConditionBase > > &	getObjectsForVariable (const VariableName &var_name, THREAD_ID tid) const
	Getter for objects that have the 'variable' set to a particular variable Note that users should check whether there are objects using 'hasObjectsForVariable' before calling this routine, because it will throw if there are no objects for this variable.

virtual void	updateActive (THREAD_ID tid=0)
	Updates the active objects storage.

void	sort (THREAD_ID tid=0)
	Sort the objects using the DependencyResolver.

void	subdomainsCovered (std::set< SubdomainID > &subdomains_covered, std::set< std::string > &unique_variables, THREAD_ID tid=0) const
	Populates a set of covered subdomains and the associated variable names.

THREAD_ID	numThreads () const
	Return the number of threads.

std::string	activeObjectsToFormattedString (THREAD_ID tid=0, const std::string &prefix="[DBG]") const
	Output the active content of the warehouse to a string, meant to be output to the console.


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.

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.

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.

bool	hasActiveObjects (THREAD_ID tid=0) const

bool	hasObjectsForVariable (const VariableName &var_name, THREAD_ID tid) const

bool	hasActiveBlockObjects (THREAD_ID tid=0) const

bool	hasActiveBlockObjects (SubdomainID id, THREAD_ID tid=0) const

bool	hasActiveBoundaryObjects (THREAD_ID tid=0) const

bool	hasActiveBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const

bool	hasBoundaryObjects (THREAD_ID tid=0) const

bool	hasBoundaryObjects (BoundaryID id, THREAD_ID tid=0) const


bool	hasActiveObject (const std::string &name, THREAD_ID tid=0) const
	Convenience functions for checking/getting specific objects.

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

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


void	updateVariableDependency (std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const
	Update variable dependency vector.

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

void	updateBoundaryVariableDependency (std::set< MooseVariableFieldBase * > &needed_moose_vars, THREAD_ID tid=0) const

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


void	updateFEVariableCoupledVectorTagDependency (std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
	Update FE variable coupleable vector tag vector for all objects, block-restricted objects, and boundary-restricted objects.

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

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


void	updateMatPropDependency (std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0, const bool producer_only=false) const
	Update material property dependency vector.

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

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

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

Protected Member Functions
virtual void	updateMatPropDependencyHelper (std::unordered_set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< InitialConditionBase > > &objects, const bool producer_only) const
	Helper method for updating material property dependency vector.

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

bool	hasBoundaryObjectsHelper (const std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< InitialConditionBase > > > > &boundary_objects, const THREAD_ID tid=0) const
	Helper for determining whether we have boundary objects.

Static Protected Member Functions
static void	updateActiveHelper (std::vector< std::shared_ptr< InitialConditionBase > > &active, const std::vector< std::shared_ptr< InitialConditionBase > > &all)
	Helper method for updating active vectors.

static void	sortHelper (std::vector< std::shared_ptr< InitialConditionBase > > &objects)
	Helper method for sorting vectors of objects.

static void	updateVariableDependencyHelper (std::set< MooseVariableFieldBase * > &needed_moose_vars, const std::vector< std::shared_ptr< InitialConditionBase > > &objects)
	Helper method for updating variable dependency vector.

static void	updateFEVariableCoupledVectorTagDependencyHelper (std::set< TagID > &needed_fe_var_vector_tags, const std::vector< std::shared_ptr< InitialConditionBase > > &objects)
	Helper method for updating FE variable coupleable vector tag vector.

Protected Attributes
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< InitialConditionBase > > >	_all_objects
	Storage container for the ALL pointers (THREAD_ID on outer vector)

std::vector< std::vector< std::shared_ptr< InitialConditionBase > > >	_active_objects
	All active objects (THREAD_ID on outer vector)

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)

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)

std::vector< std::map< VariableName, std::vector< std::shared_ptr< InitialConditionBase > > > >	_all_variable_objects
	All objects with a certain variable selected, as the 'variable' parameter.

using	ic_key_type = std::tuple< VariableName, unsigned short >

std::vector< std::map< ic_key_type, std::set< BoundaryID > > >	_boundary_ics

std::vector< std::map< ic_key_type, std::set< SubdomainID > > >	_block_ics

Detailed Description

Warehouse for storing initial conditions.

Definition at line 20 of file InitialConditionWarehouse.h.

Member Typedef Documentation

◆ ic_key_type

using InitialConditionWarehouse::ic_key_type = std::tuple<VariableName, unsigned short>

protected

Maps used to check if multiple ICs define the same variable on the same block/boundary for the same state (e.g CURRENT, OLD, OLDER). They are vectors of maps because each map is repeated for each thread. Each map relates string-int tuples to a set of block/boundary IDs. The string-int tuple is a unique identifier for a specific variable and state. The string-int tuple is renamed to ic_key_type for clarity. The algorithm then makes sure that a new IC object does not overlap with a previous IC object (i.e. same block/boundary).

Definition at line 48 of file InitialConditionWarehouse.h.

Constructor & Destructor Documentation

◆ InitialConditionWarehouse()

InitialConditionWarehouse::InitialConditionWarehouse ( THREAD_ID num_threads = libMesh::n_threads() )

Definition at line 16 of file InitialConditionWarehouse.C.

  : MooseObjectWarehouseBase<InitialConditionBase>(num_threads),
    _boundary_ics(num_threads),
    _block_ics(num_threads)
{
}

Member Function Documentation

◆ activeObjectsToFormattedString()

std::string MooseObjectWarehouseBase< InitialConditionBase >::activeObjectsToFormattedString	(	THREAD_ID	tid = `0`,
		const std::string &	prefix = `"[DBG]"`
	)		const

inherited

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

Parameters

tid	the thread id
prefix	a string to prepend to the string

Definition at line 211 of file MooseObjectWarehouseBase.h.

{
  std::vector<std::string> output;
  for (const auto & object : _active_objects[tid])
    output.push_back(object->name());
  return ConsoleUtils::formatString(MooseUtils::join(output, " "), prefix);
}

◆ addObject() [1/2]

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

Add object to the warehouse.

Definition at line 32 of file InitialConditionWarehouse.C.

{
  // Check that when object is boundary restricted that the variable is nodal
  const MooseVariableFEBase & var = object->variable();
  const auto ic_key = std::tuple(var.name(), object->getState());
 
  // Boundary Restricted
  if (object->boundaryRestricted())
  {
    if (!var.isNodal())
      mooseError("You are trying to set a boundary restricted variable on non-nodal variable. That "
                 "is not allowed.");
 
    const auto iter = _boundary_ics[tid].find(ic_key);
    if (iter != _boundary_ics[tid].end() && object->hasBoundary(iter->second))
      mooseError("The initial condition '",
                 object->name(),
                 "' is being defined on a boundary that already has an initial condition defined "
                 "with the same variable and state.");
    else
      _boundary_ics[tid][ic_key].insert(object->boundaryIDs().begin(), object->boundaryIDs().end());
  }
 
  // Block Restricted
  else if (object->blockRestricted())
  {
    auto iter = _block_ics[tid].find(ic_key);
    if (iter != _block_ics[tid].end() &&
        (object->hasBlocks(iter->second) ||
         (iter->second.find(Moose::ANY_BLOCK_ID) != iter->second.end())))
      mooseError("The initial condition '",
                 object->name(),
                 "' is being defined on a block that already has an initial condition defined "
                 "with the same variable and state.");
    else
      _block_ics[tid][ic_key].insert(object->blockIDs().begin(), object->blockIDs().end());
  }
 
  // Non-restricted
  else
  {
    auto iter = _block_ics[tid].find(ic_key);
    if (iter != _block_ics[tid].end())
      mooseError("The initial condition '",
                 object->name(),
                 "' is being defined on a block that already has an initial condition defined "
                 "with the same variable and state.");
    else
      _block_ics[tid][ic_key].insert(Moose::ANY_BLOCK_ID);
  }
 
  // Add the IC to the storage
  MooseObjectWarehouseBase<InitialConditionBase>::addObject(object, tid, recurse);
}

Referenced by FEProblemBase::addInitialCondition().

◆ addObject() [2/2]

void MooseObjectWarehouseBase< InitialConditionBase >::addObject	(	std::shared_ptr< InitialConditionBase >	object,
		THREAD_ID	tid = `0`,
		bool	recurse = `true`
	)

virtualinherited

Adds an object to the storage structure.

Parameters

tid	The thread ID (default is 0)
recurse	Whether or not to build recusive warehouses (typically for Kernels)

Definition at line 48 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
 
  // Stores object in list of all objects
  _all_objects[tid].push_back(object);
 
  // If enabled, store object in a list of all active
  bool enabled = object->enabled();
  if (enabled)
    _active_objects[tid].push_back(object);
 
  // Perform casts to the Block/BoundaryRestrictable
  std::shared_ptr<BoundaryRestrictable> bnd =
      std::dynamic_pointer_cast<BoundaryRestrictable>(object);
  std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
 
  // Boundary Restricted
  if (bnd && bnd->boundaryRestricted())
  {
    const std::set<BoundaryID> & ids = bnd->boundaryIDs();
    for (std::set<BoundaryID>::const_iterator it = ids.begin(); it != ids.end(); ++it)
    {
      _all_boundary_objects[tid][*it].push_back(object);
      if (enabled)
        _active_boundary_objects[tid][*it].push_back(object);
    }
  }
 
  // Block Restricted
  else if (blk)
  {
    const std::set<SubdomainID> & ids =
        blk->blockRestricted() ? blk->blockIDs() : blk->meshBlockIDs();
    for (std::set<SubdomainID>::const_iterator it = ids.begin(); it != ids.end(); ++it)
    {
      _all_block_objects[tid][*it].push_back(object);
      if (enabled)
        _active_block_objects[tid][*it].push_back(object);
    }
 
    // Check variables
    std::shared_ptr<Coupleable> c_ptr = std::dynamic_pointer_cast<Coupleable>(object);
    if (c_ptr)
      for (MooseVariableFieldBase * var : c_ptr->getCoupledMooseVars())
        blk->checkVariable(*var);
 
    const InputParameters & parameters = object->parameters();
 
    SubProblem & problem = *parameters.get<SubProblem *>("_subproblem");
 
    THREAD_ID tid = parameters.get<THREAD_ID>("_tid");
 
    if (parameters.isParamValid("variable"))
    {
      // Try the scalar version first
      std::string variable_name = parameters.getMooseType("variable");
      if (variable_name == "")
        // When using vector variables, we are only going to use the first one in the list at the
        // interface level...
        variable_name = parameters.getVecMooseType("variable")[0];
 
      blk->checkVariable(problem.getVariable(
          tid, variable_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY));
 
      _all_variable_objects[tid][variable_name].push_back(object);
    }
  }
}

◆ checkThreadID()

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

inlineprotectedinherited

Calls assert on thread id.

Definition at line 273 of file MooseObjectWarehouseBase.h.

{
  mooseAssert(tid < _num_threads,
              "Attempting to access a thread id ("
                  << tid << ") greater than the number allowed by the storage item ("
                  << _num_threads << ")");
}

◆ getActiveBlockObjects() [1/2]

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

inherited

Definition at line 79 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  const auto iter = _active_block_objects[tid].find(id);
  mooseAssert(iter != _active_block_objects[tid].end(),
              "Unable to located active block objects for the given id: " << id << ".");
  return iter->second;
}

◆ getActiveBlockObjects() [2/2]

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

inlineinherited

Definition at line 78 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _active_block_objects[tid];
}

◆ getActiveBlocks()

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

inherited

Return a set of active SubdomainsIDs.

Definition at line 116 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  std::set<SubdomainID> ids;
  for (const auto & object_pair : _active_block_objects[tid])
    ids.insert(object_pair.first);
  return ids;
}

◆ getActiveBoundaryObjects() [1/2]

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

inherited

Definition at line 83 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  const auto iter = _active_boundary_objects[tid].find(id);
  mooseAssert(iter != _active_boundary_objects[tid].end(),
              "Unable to located active boundary objects for the given id: " << id << ".");
  return iter->second;
}

◆ getActiveBoundaryObjects() [2/2]

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

inlineinherited

Definition at line 82 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _active_boundary_objects[tid];
}

◆ getActiveObject()

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

inherited

Definition at line 124 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  for (const auto & object : _active_objects[tid])
    if (object->name() == name)
      return object;
  mooseError("Unable to locate active object: ", name, ".");
}

◆ 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

tid	The thread id to retrieve objects from

Definition at line 76 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _active_objects[tid];
}

◆ getBlockObjects() [1/2]

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

inherited

Definition at line 63 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  const auto iter = _all_block_objects[tid].find(id);
  mooseAssert(iter != _all_block_objects[tid].end(),
              "Unable to located active block objects for the given id: " << id << ".");
  return iter->second;
}

◆ getBlockObjects() [2/2]

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

inlineinherited

Definition at line 62 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _all_block_objects[tid];
}

◆ getBoundaryObjects() [1/2]

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

inherited

Definition at line 66 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  const auto iter = _all_boundary_objects[tid].find(id);
  mooseAssert(iter != _all_boundary_objects[tid].end(),
              "Unable to located active boundary objects for the given id: " << id << ".");
  return iter->second;
}

◆ getBoundaryObjects() [2/2]

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

inlineinherited

Definition at line 65 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _all_boundary_objects[tid];
}

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

{
  std::set<std::string> depend_objects;
 
  const auto & ics = getActiveObjects();
  for (const auto & ic : ics)
  {
    const auto & uo = ic->getDependObjects();
    depend_objects.insert(uo.begin(), uo.end());
  }
 
  return depend_objects;
}

◆ getObject()

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

inherited

Definition at line 123 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  for (const auto & object : _all_objects[tid])
    if (object->name() == name)
      return object;
  mooseError("Unable to locate object: ", name, ".");
}

◆ 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

tid	The thread id to retrieve objects from

Definition at line 60 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _all_objects[tid];
}

◆ getObjectsForVariable()

const std::vector< std::shared_ptr< InitialConditionBase > > & MooseObjectWarehouseBase< InitialConditionBase >::getObjectsForVariable	(	const VariableName &	var_name,
		THREAD_ID	tid
	)		const

inherited

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

Definition at line 130 of file MooseObjectWarehouseBase.h.

{
  return libmesh_map_find(_all_variable_objects[tid], var_name);
}

◆ hasActiveBlockObjects() [1/2]

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

inherited

Definition at line 95 of file MooseObjectWarehouseBase.h.

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

◆ hasActiveBlockObjects() [2/2]

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

inherited

Definition at line 94 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  bool has_active_block_objects = false;
  for (const auto & object_pair : _active_block_objects[tid])
    has_active_block_objects |= !(object_pair.second.empty());
  return has_active_block_objects;
}

◆ hasActiveBoundaryObjects() [1/2]

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

inherited

Definition at line 97 of file MooseObjectWarehouseBase.h.

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

◆ hasActiveBoundaryObjects() [2/2]

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

inherited

Definition at line 96 of file MooseObjectWarehouseBase.h.

{
  return hasBoundaryObjectsHelper(_active_boundary_objects, tid);
}

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

{
  checkThreadID(tid);
  for (const auto & object : _active_objects[tid])
    if (object->name() == name)
      return true;
  return false;
}

◆ hasActiveObjects()

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

inherited

Definition at line 92 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return !_active_objects[tid].empty();
}

◆ hasBoundaryObjects() [1/2]

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

inherited

Definition at line 99 of file MooseObjectWarehouseBase.h.

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

◆ hasBoundaryObjects() [2/2]

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

inherited

Definition at line 98 of file MooseObjectWarehouseBase.h.

{
  return hasBoundaryObjectsHelper(_all_boundary_objects, tid);
}

◆ hasBoundaryObjectsHelper()

bool MooseObjectWarehouseBase< InitialConditionBase >::hasBoundaryObjectsHelper	(	const std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< InitialConditionBase > > > > &	boundary_objects,
		const THREAD_ID	tid = `0`
	)		const

protectedinherited

Helper for determining whether we have boundary objects.

Definition at line 278 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  bool has_boundary_objects = false;
  for (const auto & object_pair : boundary_objects[tid])
    has_boundary_objects |= !(object_pair.second.empty());
  return has_boundary_objects;
}

◆ hasObjects()

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

inherited

Convenience functions for determining if objects exist.

Definition at line 91 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return !_all_objects[tid].empty();
}

◆ hasObjectsForVariable()

bool MooseObjectWarehouseBase< InitialConditionBase >::hasObjectsForVariable	(	const VariableName &	var_name,
		THREAD_ID	tid
	)		const

inherited

Definition at line 93 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _all_variable_objects[tid].count(var_name);
}

◆ hasObjectsForVariableAndBlocks()

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

inherited

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

Parameters

var_name	name of the variable
blocks	blocks to consider
blocks_covered	subset of blocks for which there is an object

Definition at line 108 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  blocks_covered.clear();
  if (!hasObjectsForVariable(var_name, tid))
    return false;
 
  // Check block restriction as a whole
  for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
  {
    std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
    if (blk && blk->hasBlocks(blocks))
    {
      blocks_covered = blocks;
      return true;
    }
  }
  // No object has all the blocks, but one might overlap, which could be troublesome.
  // We'll keep track of which blocks are covered in case several overlap
  for (const auto & object : libmesh_map_find(_all_variable_objects[tid], var_name))
  {
    std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(object);
    if (blk)
      for (const auto & block : blocks)
        if (blk->hasBlocks(block))
          blocks_covered.insert(block);
  }
  // No overlap at all
  if (blocks_covered.empty())
    return false;
 
  return (blocks == blocks_covered);
}

◆ initialSetup()

void InitialConditionWarehouse::initialSetup ( THREAD_ID tid )

Initial setup.

Definition at line 24 of file InitialConditionWarehouse.C.

{
  MooseObjectWarehouseBase<InitialConditionBase>::sort(tid);
  for (const auto & ic : _active_objects[tid])
    ic->initialSetup();
}

◆ numThreads()

THREAD_ID MooseObjectWarehouseBase< InitialConditionBase >::numThreads ( ) const

inlineinherited

Return the number of threads.

Definition at line 204 of file MooseObjectWarehouseBase.h.

204{ return _num_threads; }

◆ size()

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

inherited

Return how many kernels we store in the current warehouse.

Definition at line 53 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
  return _all_objects[tid].size();
}

◆ sort()

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

inherited

Sort the objects using the DependencyResolver.

Definition at line 141 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
 
  for (auto & object_pair : _all_block_objects[tid])
    sortHelper(object_pair.second);
 
  for (auto & object_pair : _all_boundary_objects[tid])
    sortHelper(object_pair.second);
 
  sortHelper(_all_objects[tid]);
 
  // The active lists now must be update to reflect the order changes
  updateActive(tid);
}

◆ sortHelper()

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

staticprotectedinherited

Helper method for sorting vectors of objects.

Definition at line 248 of file MooseObjectWarehouseBase.h.

{
  // Do nothing if the vector is empty
  if (objects.empty())
    return;
 
  try
  {
    // Sort based on dependencies
    DependencyResolverInterface::sort<std::shared_ptr<T>>(objects);
  }
  catch (CyclicDependencyException<std::shared_ptr<T>> & e)
  {
    DependencyResolverInterface::cyclicDependencyError<std::shared_ptr<T>>(
        e, "Cyclic dependency detected in object ordering");
  }
}

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

{
  for (const auto & object : _active_objects[tid])
  {
    unique_variables.insert(object->variable().name());
    const auto additional_variables_covered = object->additionalROVariables();
    unique_variables.insert(additional_variables_covered.begin(),
                            additional_variables_covered.end());
  }
 
  for (const auto & object_pair : _active_block_objects[tid])
    subdomains_covered.insert(object_pair.first);
}

◆ updateActive()

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

virtualinherited

Updates the active objects storage.

Definition at line 136 of file MooseObjectWarehouseBase.h.

{
  checkThreadID(tid);
 
  updateActiveHelper(_active_objects[tid], _all_objects[tid]);
 
  for (const auto & object_pair : _all_block_objects[tid])
    updateActiveHelper(_active_block_objects[tid][object_pair.first], object_pair.second);
 
  for (const auto & object_pair : _all_boundary_objects[tid])
    updateActiveHelper(_active_boundary_objects[tid][object_pair.first], object_pair.second);
}

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

{
  // Clear the active list
  active.clear();
 
  std::copy_if(all.begin(),
               all.end(),
               std::back_inserter(active),
               [](const std::shared_ptr<T> & object) { return object->enabled(); });
}

◆ updateBlockFEVariableCoupledVectorTagDependency()

void MooseObjectWarehouseBase< InitialConditionBase >::updateBlockFEVariableCoupledVectorTagDependency	(	SubdomainID	id,
		std::set< TagID > &	needed_fe_var_vector_tags,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 166 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveBlockObjects(id, tid))
    updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
                                                     getActiveBlockObjects(id, tid));
}

◆ updateBlockMatPropDependency()

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

inherited

Definition at line 181 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveBlockObjects(id, tid))
    updateMatPropDependencyHelper(needed_mat_props, getActiveBlockObjects(id, tid), producer_only);
}

◆ updateBlockVariableDependency()

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

inherited

Definition at line 149 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveBlockObjects(id, tid))
    updateVariableDependencyHelper(needed_moose_vars, getActiveBlockObjects(id, tid));
}

◆ updateBoundaryFEVariableCoupledVectorTagDependency()

void MooseObjectWarehouseBase< InitialConditionBase >::updateBoundaryFEVariableCoupledVectorTagDependency	(	BoundaryID	id,
		std::set< TagID > &	needed_fe_var_vector_tags,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 169 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveBoundaryObjects(id, tid))
    updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
                                                     getActiveBoundaryObjects(id, tid));
}

◆ updateBoundaryMatPropDependency() [1/2]

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

inherited

Definition at line 188 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveBoundaryObjects(id, tid))
    updateMatPropDependencyHelper(
        needed_mat_props, getActiveBoundaryObjects(id, tid), producer_only);
}

◆ updateBoundaryMatPropDependency() [2/2]

void MooseObjectWarehouseBase< InitialConditionBase >::updateBoundaryMatPropDependency	(	std::unordered_set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`,
		const bool	producer_only = `false`
	)		const

inherited

Definition at line 185 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryVariableDependency() [1/2]

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

inherited

Definition at line 154 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveBoundaryObjects(id, tid))
    updateVariableDependencyHelper(needed_moose_vars, getActiveBoundaryObjects(id, tid));
}

◆ updateBoundaryVariableDependency() [2/2]

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

inherited

Definition at line 152 of file MooseObjectWarehouseBase.h.

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

◆ updateFEVariableCoupledVectorTagDependency()

void MooseObjectWarehouseBase< InitialConditionBase >::updateFEVariableCoupledVectorTagDependency	(	std::set< TagID > &	needed_fe_var_vector_tags,
		THREAD_ID	tid = `0`
	)		const

inherited

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

Definition at line 164 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveObjects(tid))
    updateFEVariableCoupledVectorTagDependencyHelper(needed_fe_var_vector_tags,
                                                     _active_objects[tid]);
}

◆ updateFEVariableCoupledVectorTagDependencyHelper()

void MooseObjectWarehouseBase< InitialConditionBase >::updateFEVariableCoupledVectorTagDependencyHelper	(	std::set< TagID > &	needed_fe_var_vector_tags,
		const std::vector< std::shared_ptr< InitialConditionBase > > &	objects
	)

staticprotectedinherited

Helper method for updating FE variable coupleable vector tag vector.

Definition at line 260 of file MooseObjectWarehouseBase.h.

{
  for (const auto & object : objects)
  {
    auto c = dynamic_cast<const Coupleable *>(object.get());
    if (c)
    {
      const auto & tag_deps = c->getFEVariableCoupleableVectorTags();
      needed_fe_var_vector_tags.insert(tag_deps.begin(), tag_deps.end());
    }
  }
}

◆ updateMatPropDependency()

void MooseObjectWarehouseBase< InitialConditionBase >::updateMatPropDependency	(	std::unordered_set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`,
		const bool	producer_only = `false`
	)		const

inherited

Update material property dependency vector.

Parameters

producer_only Only append dependencies of materials producing the needed_mat_props

Definition at line 178 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveObjects(tid))
    updateMatPropDependencyHelper(needed_mat_props, _active_objects[tid], producer_only);
}

◆ updateMatPropDependencyHelper()

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

protectedvirtualinherited

Helper method for updating material property dependency vector.

Definition at line 266 of file MooseObjectWarehouseBase.h.

{
  for (auto & object : objects)
  {
    auto c = dynamic_cast<const MaterialPropertyInterface *>(object.get());
    if (c)
    {
      auto & mp_deps = c->getMatPropDependencies();
      needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
    }
  }
}

◆ updateVariableDependency()

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

inherited

Update variable dependency vector.

Definition at line 147 of file MooseObjectWarehouseBase.h.

{
  if (hasActiveObjects(tid))
    updateVariableDependencyHelper(needed_moose_vars, _active_objects[tid]);
}

◆ updateVariableDependencyHelper()

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

staticprotectedinherited

Helper method for updating variable dependency vector.

Definition at line 253 of file MooseObjectWarehouseBase.h.

{
  for (const auto & object : objects)
  {
    auto c = dynamic_cast<const MooseVariableDependencyInterface *>(object.get());
    if (c)
    {
      const auto & mv_deps = c->getMooseVariableDependencies();
      needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
    }
  }
}

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 228 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 234 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 222 of file MooseObjectWarehouseBase.h.

◆ _all_block_objects

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

protectedinherited

Definition at line 225 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 231 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 219 of file MooseObjectWarehouseBase.h.

◆ _all_variable_objects

std::vector<std::map<VariableName, std::vector<std::shared_ptr<InitialConditionBase > > > > MooseObjectWarehouseBase< InitialConditionBase >::_all_variable_objects

protectedinherited

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

Definition at line 237 of file MooseObjectWarehouseBase.h.

◆ _block_ics

std::vector<std::map<ic_key_type, std::set<SubdomainID> > > InitialConditionWarehouse::_block_ics

protected

Definition at line 50 of file InitialConditionWarehouse.h.

Referenced by addObject().

◆ _boundary_ics

std::vector<std::map<ic_key_type, std::set<BoundaryID> > > InitialConditionWarehouse::_boundary_ics

protected

Definition at line 49 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 216 of file MooseObjectWarehouseBase.h.

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

include/ics/InitialConditionWarehouse.h
src/ics/InitialConditionWarehouse.C

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ ic_key_type

Constructor & Destructor Documentation

◆ InitialConditionWarehouse()

Member Function Documentation

◆ activeObjectsToFormattedString()

◆ addObject() [1/2]

◆ addObject() [2/2]

◆ checkThreadID()

◆ getActiveBlockObjects() [1/2]

◆ getActiveBlockObjects() [2/2]

◆ getActiveBlocks()

◆ getActiveBoundaryObjects() [1/2]

◆ getActiveBoundaryObjects() [2/2]

◆ getActiveObject()

◆ getActiveObjects()

◆ getBlockObjects() [1/2]

◆ getBlockObjects() [2/2]

◆ getBoundaryObjects() [1/2]

◆ getBoundaryObjects() [2/2]

◆ getDependObjects()

◆ getObject()

◆ getObjects()

◆ getObjectsForVariable()

◆ hasActiveBlockObjects() [1/2]

◆ hasActiveBlockObjects() [2/2]

◆ hasActiveBoundaryObjects() [1/2]

◆ hasActiveBoundaryObjects() [2/2]

◆ hasActiveObject()

◆ hasActiveObjects()

◆ hasBoundaryObjects() [1/2]

◆ hasBoundaryObjects() [2/2]

◆ hasBoundaryObjectsHelper()

◆ hasObjects()

◆ hasObjectsForVariable()

◆ hasObjectsForVariableAndBlocks()

◆ initialSetup()

◆ numThreads()

◆ size()

◆ sort()

◆ sortHelper()

◆ subdomainsCovered()

◆ updateActive()

◆ updateActiveHelper()

◆ updateBlockFEVariableCoupledVectorTagDependency()

◆ updateBlockMatPropDependency()

◆ updateBlockVariableDependency()

◆ updateBoundaryFEVariableCoupledVectorTagDependency()

◆ updateBoundaryMatPropDependency() [1/2]

◆ updateBoundaryMatPropDependency() [2/2]

◆ updateBoundaryVariableDependency() [1/2]

◆ updateBoundaryVariableDependency() [2/2]

◆ updateFEVariableCoupledVectorTagDependency()

◆ updateFEVariableCoupledVectorTagDependencyHelper()

◆ updateMatPropDependency()

◆ updateMatPropDependencyHelper()

◆ updateVariableDependency()

◆ updateVariableDependencyHelper()

Member Data Documentation

◆ _active_block_objects

◆ _active_boundary_objects

◆ _active_objects

◆ _all_block_objects

◆ _all_boundary_objects

◆ _all_objects

◆ _all_variable_objects

◆ _block_ics

◆ _boundary_ics

◆ _num_threads