MaterialBase objects are special in that they have additional objects created automatically (see FEProblemBase::addMaterial). More...

#include <MaterialWarehouse.h>

Inheritance diagram for MaterialWarehouse:

[legend]

Public Member Functions
const MooseObjectWarehouse< MaterialBase > &	operator[] (Moose::MaterialDataType data_type) const

void	addObjects (std::shared_ptr< MaterialBase > block, std::shared_ptr< MaterialBase > neighbor, std::shared_ptr< MaterialBase > face, THREAD_ID tid=0)
	A special method unique to this class for adding Block, Neighbor, and Face material objects. More...

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

bool	hasVariableObjects (unsigned int variable_id, THREAD_ID tid=0) const
	Checks for whether this warehouse has objects for a given variable. More...

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

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

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

const std::vector< std::shared_ptr< MaterialBase > > &	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. 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 () const
	Return the number of threads. More...

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


virtual void	initialSetup (THREAD_ID tid=0) const
	Convenience methods for calling object setup methods that handle the extra neighbor and face objects. More...

virtual void	timestepSetup (THREAD_ID tid=0) const

virtual void	subdomainSetup (THREAD_ID tid=0) const

virtual void	subdomainSetup (SubdomainID id, THREAD_ID tid=0) const

virtual void	neighborSubdomainSetup (THREAD_ID tid=0) const

virtual void	neighborSubdomainSetup (SubdomainID id, THREAD_ID tid=0) const

virtual void	jacobianSetup (THREAD_ID tid=0) const

virtual void	residualSetup (THREAD_ID tid=0) const

virtual void	updateActive (THREAD_ID tid=0)
	Update the active status of Kernels. More...

void	sort (THREAD_ID tid=0)


virtual void	customSetup (const ExecFlagType &exec_type, THREAD_ID tid=0) const


bool	hasActiveVariableBlockObjects (unsigned int variable_id, SubdomainID block_id, THREAD_ID tid=0) const
	Methods for checking/getting variable kernels for a variable and SubdomainID. More...

const std::vector< std::shared_ptr< MaterialBase > > &	getActiveVariableBlockObjects (unsigned int variable_id, SubdomainID block_id, THREAD_ID tid=0) const


const std::vector< std::shared_ptr< MaterialBase > > &	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< MaterialBase > > > &	getBlockObjects (THREAD_ID tid=0) const

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

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

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


const std::vector< std::shared_ptr< MaterialBase > > &	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< MaterialBase > > > &	getActiveBlockObjects (THREAD_ID tid=0) const

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

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

const std::vector< std::shared_ptr< MaterialBase > > &	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	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 (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< MaterialBase >	getObject (const std::string &name, THREAD_ID tid=0) const

std::shared_ptr< MaterialBase >	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. More...

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	updateBlockFEVariableCoupledVectorTagDependency (SubdomainID id, std::set< TagID > &needed_fe_var_vector_tags, THREAD_ID tid=0) const
	Update FE variable coupleable vector tag vector. More...

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
	Update material property dependency vector. More...

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

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

void	updateBoundaryMatPropDependency (BoundaryID id, std::unordered_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< MaterialBase >> &active, const std::vector< std::shared_ptr< MaterialBase >> &all)
	Helper method for updating active vectors. More...

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

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

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

static void	updateMatPropDependencyHelper (std::unordered_set< unsigned int > &needed_mat_props, const std::vector< std::shared_ptr< MaterialBase >> &objects)
	Helper method for updating material property dependency vector. More...

Protected Attributes
MooseObjectWarehouse< MaterialBase >	_neighbor_materials
	Storage for neighbor material objects (Block are stored in the base class) More...

MooseObjectWarehouse< MaterialBase >	_face_materials
	Storage for face material objects (Block are stored in the base class) More...

std::map< unsigned int, MooseObjectWarehouse< MaterialBase > >	_variable_objects
	Variable based storage. More...

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< MaterialBase > > >	_all_objects
	Storage container for the ALL pointers (THREAD_ID on outer vector) More...

std::vector< std::vector< std::shared_ptr< MaterialBase > > >	_active_objects
	All active objects (THREAD_ID on outer vector) More...

std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase > > > >	_all_block_objects

std::vector< std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase > > > >	_active_block_objects
	Active block restricted objects (THREAD_ID on outer vector) More...

std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< MaterialBase > > > >	_all_boundary_objects

std::vector< std::map< BoundaryID, std::vector< std::shared_ptr< MaterialBase > > > >	_active_boundary_objects
	Active boundary restricted objects (THREAD_ID on outer vector) More...

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

Detailed Description

MaterialBase objects are special in that they have additional objects created automatically (see FEProblemBase::addMaterial).

This class specializes the base class to acount for the additional Neightbor and face objects that may exist.

Definition at line 26 of file MaterialWarehouse.h.

Member Function Documentation

◆ activeObjectsToFormattedString()

std::string MooseObjectWarehouseBase< MaterialBase >::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 847 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()

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

overridevirtualinherited

Adds an object to the storage structure.

Parameters

object	A shared pointer to the object being added
tid	The thread ID (default is 0)
recurse	Whether or not to build recusive warehouses (typically for Kernels)

Reimplemented from MooseObjectWarehouseBase< MaterialBase >.

Definition at line 99 of file MooseObjectWarehouse.h.

 {
   MooseObjectWarehouseBase<T>::addObject(object, tid, recurse);
 
   if (recurse)
   {
     if (auto mvir = std::dynamic_pointer_cast<MooseVariableInterface<Real>>(object); mvir)
       _variable_objects[mvir->mooseVariableBase()->number()].addObject(object, tid, false);
     else if (auto mviv = std::dynamic_pointer_cast<MooseVariableInterface<RealVectorValue>>(object);
              mviv)
       _variable_objects[mviv->mooseVariableBase()->number()].addObject(object, tid, false);
     else if (auto mvie = std::dynamic_pointer_cast<MooseVariableInterface<RealEigenVector>>(object);
              mvie)
       _variable_objects[mvie->mooseVariableBase()->number()].addObject(object, tid, false);
     // Some objects, such as ScalarKernels, do not inherit from the MooseVariableInterface (which is
     // for field variables). These objects *do* inherit from ResidualObject which has this more
     // generic variable() API
     else if (auto ro = std::dynamic_pointer_cast<ResidualObject>(object); ro)
       _variable_objects[ro->variable().number()].addObject(object, tid, false);
   }
 }

◆ addObjects()

void MaterialWarehouse::addObjects	(	std::shared_ptr< MaterialBase >	block,
		std::shared_ptr< MaterialBase >	neighbor,
		std::shared_ptr< MaterialBase >	face,
		THREAD_ID	tid = `0`
	)

A special method unique to this class for adding Block, Neighbor, and Face material objects.

Definition at line 15 of file MaterialWarehouse.C.

Referenced by FEProblemBase::addMaterialHelper().

 {
   MooseObjectWarehouse<MaterialBase>::addObject(block, tid);
   _neighbor_materials.addObject(neighbor, tid);
   _face_materials.addObject(face, tid);
 }

◆ checkThreadID()

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

inlineprotectedinherited

Calls assert on thread id.

Definition at line 878 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 << ")");
 }

◆ customSetup()

void MooseObjectWarehouse< MaterialBase >::customSetup	(	const ExecFlagType &	exec_type,
		THREAD_ID	tid = `0`
	)		const

virtualinherited

Definition at line 176 of file MooseObjectWarehouse.h.

 {
   checkThreadID(tid);
   for (const auto & object : _active_objects[tid])
     object->customSetup(exec_type);
 }

◆ getActiveBlockObjects() [1/2]

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

inlineinherited

Definition at line 452 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::updateBlockFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< Indicator >::updateBlockMatPropDependency(), and MooseObjectWarehouseBase< Indicator >::updateBlockVariableDependency().

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

◆ getActiveBlockObjects() [2/2]

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

inherited

Definition at line 460 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;
 }

◆ getActiveBlocks()

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

inherited

Return a set of active SubdomainsIDs.

Definition at line 616 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::map< BoundaryID, std::vector< std::shared_ptr< MaterialBase > > > & MooseObjectWarehouseBase< MaterialBase >::getActiveBoundaryObjects ( THREAD_ID tid = 0 ) const

inlineinherited

Definition at line 433 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::updateBoundaryFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< Indicator >::updateBoundaryMatPropDependency(), and MooseObjectWarehouseBase< Indicator >::updateBoundaryVariableDependency().

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

◆ getActiveBoundaryObjects() [2/2]

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

inherited

Definition at line 441 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;
 }

◆ getActiveObject()

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

inherited

Definition at line 597 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< MaterialBase > > & MooseObjectWarehouseBase< MaterialBase >::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 425 of file MooseObjectWarehouseBase.h.

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

◆ getActiveVariableBlockObjects()

const std::vector< std::shared_ptr< MaterialBase > > & MooseObjectWarehouse< MaterialBase >::getActiveVariableBlockObjects	(	unsigned int	variable_id,
		SubdomainID	block_id,
		THREAD_ID	tid = `0`
	)		const

inherited

Definition at line 143 of file MooseObjectWarehouse.h.

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

◆ getBlockObjects() [1/2]

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

inlineinherited

Definition at line 406 of file MooseObjectWarehouseBase.h.

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

◆ getBlockObjects() [2/2]

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

inherited

Definition at line 414 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;
 }

◆ getBoundaryObjects() [1/2]

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

inlineinherited

Definition at line 379 of file MooseObjectWarehouseBase.h.

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

◆ getBoundaryObjects() [2/2]

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

inherited

Definition at line 395 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;
 }

◆ getObject()

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

inherited

Definition at line 586 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< MaterialBase > > & MooseObjectWarehouseBase< MaterialBase >::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 371 of file MooseObjectWarehouseBase.h.

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

◆ getObjectsForVariable()

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

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

◆ hasActiveBlockObjects() [1/2]

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

inherited

Definition at line 535 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::updateBlockFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< Indicator >::updateBlockMatPropDependency(), and MooseObjectWarehouseBase< Indicator >::updateBlockVariableDependency().

 {
   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;
 }

◆ hasActiveBlockObjects() [2/2]

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

inherited

Definition at line 546 of file MooseObjectWarehouseBase.h.

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

◆ hasActiveBoundaryObjects() [1/2]

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

inherited

Definition at line 555 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::updateBoundaryFEVariableCoupledVectorTagDependency(), MooseObjectWarehouseBase< Indicator >::updateBoundaryMatPropDependency(), and MooseObjectWarehouseBase< Indicator >::updateBoundaryVariableDependency().

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

◆ hasActiveBoundaryObjects() [2/2]

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

inherited

Definition at line 566 of file MooseObjectWarehouseBase.h.

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

◆ hasActiveObject()

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

inherited

Convenience functions for checking/getting specific objects.

Definition at line 575 of file MooseObjectWarehouseBase.h.

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

◆ hasActiveObjects()

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

inherited

Definition at line 479 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::updateMatPropDependency(), and MooseObjectWarehouseBase< Indicator >::updateVariableDependency().

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

◆ hasActiveVariableBlockObjects()

bool MooseObjectWarehouse< MaterialBase >::hasActiveVariableBlockObjects	(	unsigned int	variable_id,
		SubdomainID	block_id,
		THREAD_ID	tid = `0`
	)		const

inherited

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

Definition at line 133 of file MooseObjectWarehouse.h.

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

◆ hasBoundaryObjects()

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

inherited

Definition at line 387 of file MooseObjectWarehouseBase.h.

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

◆ hasObjects()

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

inherited

Convenience functions for determining if objects exist.

Definition at line 471 of file MooseObjectWarehouseBase.h.

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

◆ hasObjectsForVariable()

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

inherited

Definition at line 487 of file MooseObjectWarehouseBase.h.

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

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

◆ hasObjectsForVariableAndBlocks()

bool MooseObjectWarehouseBase< MaterialBase >::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 496 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);
 }

◆ hasVariableObjects()

bool MooseObjectWarehouse< MaterialBase >::hasVariableObjects	(	unsigned int	variable_id,
		THREAD_ID	tid = `0`
	)		const

inherited

Checks for whether this warehouse has objects for a given variable.

Definition at line 125 of file MooseObjectWarehouse.h.

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

◆ initialSetup()

void MaterialWarehouse::initialSetup ( THREAD_ID tid = 0 ) const

virtual

Convenience methods for calling object setup methods that handle the extra neighbor and face objects.

Reimplemented from MooseObjectWarehouse< MaterialBase >.

Definition at line 42 of file MaterialWarehouse.C.

Referenced by FEProblemBase::initialSetup().

 {
   MooseObjectWarehouse<MaterialBase>::initialSetup(tid);
   _neighbor_materials.initialSetup(tid);
   _face_materials.initialSetup(tid);
 }

◆ jacobianSetup()

void MaterialWarehouse::jacobianSetup ( THREAD_ID tid = 0 ) const

virtual

Reimplemented from MooseObjectWarehouse< MaterialBase >.

Definition at line 92 of file MaterialWarehouse.C.

Referenced by FEProblemBase::computeJacobianTags().

 {
   MooseObjectWarehouse<MaterialBase>::jacobianSetup(tid);
   _neighbor_materials.jacobianSetup(tid);
   _face_materials.jacobianSetup(tid);
 }

◆ neighborSubdomainSetup() [1/2]

void MaterialWarehouse::neighborSubdomainSetup ( THREAD_ID tid = 0 ) const

virtual

Definition at line 65 of file MaterialWarehouse.C.

Referenced by FEProblemBase::neighborSubdomainSetup().

 {
   _neighbor_materials.subdomainSetup(tid);
 }

◆ neighborSubdomainSetup() [2/2]

void MaterialWarehouse::neighborSubdomainSetup	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

virtual

Definition at line 78 of file MaterialWarehouse.C.

 {
   _neighbor_materials.subdomainSetup(id, tid);
 }

◆ numThreads()

THREAD_ID MooseObjectWarehouseBase< MaterialBase >::numThreads ( ) const

inlineinherited

Return the number of threads.

Definition at line 196 of file MooseObjectWarehouseBase.h.

196 { return _num_threads; }

MooseObjectWarehouseBase< MaterialBase >::_num_threads

const THREAD_ID _num_threads

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

Definition: MooseObjectWarehouseBase.h:208

◆ operator[]()

const MooseObjectWarehouse< MaterialBase > & MaterialWarehouse::operator[] ( Moose::MaterialDataType data_type ) const

Definition at line 26 of file MaterialWarehouse.C.

 {
   switch (data_type)
   {
     case Moose::NEIGHBOR_MATERIAL_DATA:
       return _neighbor_materials;
 
     case Moose::FACE_MATERIAL_DATA:
       return _face_materials;
 
     default:
       return *this;
   }
 }

◆ residualSetup()

void MaterialWarehouse::residualSetup ( THREAD_ID tid = 0 ) const

virtual

Reimplemented from MooseObjectWarehouse< MaterialBase >.

Definition at line 84 of file MaterialWarehouse.C.

Referenced by FEProblemBase::computeBounds(), FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::computeResidualTags().

 {
   MooseObjectWarehouse<MaterialBase>::residualSetup(tid);
   _neighbor_materials.residualSetup(tid);
   _face_materials.residualSetup(tid);
 }

◆ size()

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

inherited

Return how many kernels we store in the current warehouse.

Definition at line 289 of file MooseObjectWarehouseBase.h.

Referenced by ActionWarehouse::addActionBlock(), BatchMeshGeneratorAction::addMeshGenerators(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), and MaterialOutputAction::outputHelper().

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

◆ sort()

void MaterialWarehouse::sort ( THREAD_ID tid = 0 )

Definition at line 108 of file MaterialWarehouse.C.

Referenced by FEProblemBase::initialSetup().

 {
   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);
 
   for (auto & object_pair : _neighbor_materials._all_block_objects[tid])
     sortHelper(object_pair.second);
   for (auto & object_pair : _neighbor_materials._all_boundary_objects[tid])
     sortHelper(object_pair.second);
 
   for (auto & object_pair : _face_materials._all_block_objects[tid])
     sortHelper(object_pair.second);
   for (auto & object_pair : _face_materials._all_boundary_objects[tid])
     sortHelper(object_pair.second);
 
   updateActive(tid);
 }

◆ sortHelper()

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

staticprotectedinherited

Helper method for sorting vectors of objects.

Definition at line 858 of file MooseObjectWarehouseBase.h.

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

 {
   // 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< MaterialBase >::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 829 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);
 }

◆ subdomainSetup() [1/2]

void MaterialWarehouse::subdomainSetup ( THREAD_ID tid = 0 ) const

virtual

Reimplemented from MooseObjectWarehouse< MaterialBase >.

Definition at line 58 of file MaterialWarehouse.C.

Referenced by FEProblemBase::subdomainSetup().

 {
   MooseObjectWarehouse<MaterialBase>::subdomainSetup(tid);
   _face_materials.subdomainSetup(tid);
 }

◆ subdomainSetup() [2/2]

void MaterialWarehouse::subdomainSetup	(	SubdomainID	id,
		THREAD_ID	tid = `0`
	)		const

virtual

Reimplemented from MooseObjectWarehouse< MaterialBase >.

Definition at line 71 of file MaterialWarehouse.C.

 {
   MooseObjectWarehouse<MaterialBase>::subdomainSetup(id, tid);
   _face_materials.subdomainSetup(id, tid);
 }

◆ timestepSetup()

void MaterialWarehouse::timestepSetup ( THREAD_ID tid = 0 ) const

virtual

Reimplemented from MooseObjectWarehouse< MaterialBase >.

Definition at line 50 of file MaterialWarehouse.C.

Referenced by FEProblemBase::timestepSetup().

 {
   MooseObjectWarehouse<MaterialBase>::timestepSetup(tid);
   _neighbor_materials.timestepSetup(tid);
   _face_materials.timestepSetup(tid);
 }

◆ updateActive()

void MaterialWarehouse::updateActive ( THREAD_ID tid = 0 )

virtual

Update the active status of Kernels.

Reimplemented from MooseObjectWarehouse< MaterialBase >.

Definition at line 100 of file MaterialWarehouse.C.

Referenced by sort(), MooseObjectWarehouseBase< Indicator >::sort(), and FEProblemBase::updateActiveObjects().

 {
   MooseObjectWarehouse<MaterialBase>::updateActive(tid);
   _neighbor_materials.updateActive(tid);
   _face_materials.updateActive(tid);
 }

◆ updateActiveHelper()

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

staticprotectedinherited

Helper method for updating active vectors.

Definition at line 642 of file MooseObjectWarehouseBase.h.

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

 {
   // 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< MaterialBase >::updateBlockFEVariableCoupledVectorTagDependency	(	SubdomainID	id,
		std::set< TagID > &	needed_fe_var_vector_tags,
		THREAD_ID	tid = `0`
	)		const

inherited

Update FE variable coupleable vector tag vector.

Definition at line 735 of file MooseObjectWarehouseBase.h.

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

◆ updateBlockMatPropDependency()

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

inherited

Definition at line 780 of file MooseObjectWarehouseBase.h.

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

◆ updateBlockVariableDependency()

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

inherited

Definition at line 683 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryFEVariableCoupledVectorTagDependency()

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

inherited

Definition at line 745 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryMatPropDependency() [1/2]

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

inherited

Definition at line 791 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryMatPropDependency() [2/2]

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

inherited

Definition at line 801 of file MooseObjectWarehouseBase.h.

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

◆ updateBoundaryVariableDependency() [1/2]

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

inherited

Definition at line 694 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);
   }
 }

◆ updateBoundaryVariableDependency() [2/2]

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

inherited

Definition at line 707 of file MooseObjectWarehouseBase.h.

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

◆ updateFEVariableCoupledVectorTagDependencyHelper()

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

staticprotectedinherited

Helper method for updating FE variable coupleable vector tag vector.

Definition at line 755 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::updateBlockFEVariableCoupledVectorTagDependency(), and MooseObjectWarehouseBase< Indicator >::updateBoundaryFEVariableCoupledVectorTagDependency().

 {
   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< MaterialBase >::updateMatPropDependency	(	std::unordered_set< unsigned int > &	needed_mat_props,
		THREAD_ID	tid = `0`
	)		const

inherited

Update material property dependency vector.

Definition at line 771 of file MooseObjectWarehouseBase.h.

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

◆ updateMatPropDependencyHelper()

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

staticprotectedinherited

Helper method for updating material property dependency vector.

Definition at line 812 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::updateBlockMatPropDependency(), MooseObjectWarehouseBase< Indicator >::updateBoundaryMatPropDependency(), and MooseObjectWarehouseBase< Indicator >::updateMatPropDependency().

 {
   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< MaterialBase >::updateVariableDependency	(	std::set< MooseVariableFieldBase *> &	needed_moose_vars,
		THREAD_ID	tid = `0`
	)		const

inherited

Update variable dependency vector.

Definition at line 674 of file MooseObjectWarehouseBase.h.

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

◆ updateVariableDependencyHelper()

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

staticprotectedinherited

Helper method for updating variable dependency vector.

Definition at line 718 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::updateBlockVariableDependency(), MooseObjectWarehouseBase< Indicator >::updateBoundaryVariableDependency(), and MooseObjectWarehouseBase< Indicator >::updateVariableDependency().

 {
   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<MaterialBase > > > > MooseObjectWarehouseBase< MaterialBase >::_active_block_objects

protectedinherited

Active block restricted objects (THREAD_ID on outer vector)

Definition at line 220 of file MooseObjectWarehouseBase.h.

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

◆ _active_boundary_objects

std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<MaterialBase > > > > MooseObjectWarehouseBase< MaterialBase >::_active_boundary_objects

protectedinherited

Active boundary restricted objects (THREAD_ID on outer vector)

Definition at line 226 of file MooseObjectWarehouseBase.h.

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

◆ _active_objects

std::vector<std::vector<std::shared_ptr<MaterialBase > > > MooseObjectWarehouseBase< MaterialBase >::_active_objects

protectedinherited

All active objects (THREAD_ID on outer vector)

Definition at line 214 of file MooseObjectWarehouseBase.h.

Referenced by MooseObjectWarehouseBase< Indicator >::activeObjectsToFormattedString(), MooseObjectWarehouseBase< Indicator >::addObject(), MooseObjectWarehouseBase< Indicator >::getActiveObject(), MooseObjectWarehouseBase< Indicator >::getActiveObjects(), MooseObjectWarehouseBase< Indicator >::hasActiveObject(), MooseObjectWarehouseBase< Indicator >::hasActiveObjects(), MooseObjectWarehouseBase< Indicator >::subdomainsCovered(), and MooseObjectWarehouseBase< Indicator >::updateActive().

◆ _all_block_objects

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

protectedinherited

Definition at line 217 of file MooseObjectWarehouseBase.h.

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

◆ _all_boundary_objects

std::vector<std::map<BoundaryID, std::vector<std::shared_ptr<MaterialBase > > > > MooseObjectWarehouseBase< MaterialBase >::_all_boundary_objects

protectedinherited

Definition at line 223 of file MooseObjectWarehouseBase.h.

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

◆ _all_objects

std::vector<std::vector<std::shared_ptr<MaterialBase > > > MooseObjectWarehouseBase< MaterialBase >::_all_objects

protectedinherited

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

Definition at line 211 of file MooseObjectWarehouseBase.h.

◆ _all_variable_objects

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

protectedinherited

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

Definition at line 229 of file MooseObjectWarehouseBase.h.

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

◆ _face_materials

MooseObjectWarehouse<MaterialBase> MaterialWarehouse::_face_materials

protected

Storage for face material objects (Block are stored in the base class)

Definition at line 61 of file MaterialWarehouse.h.

Referenced by addObjects(), initialSetup(), jacobianSetup(), operator[](), residualSetup(), sort(), subdomainSetup(), timestepSetup(), and updateActive().

◆ _neighbor_materials

MooseObjectWarehouse<MaterialBase> MaterialWarehouse::_neighbor_materials

protected

Storage for neighbor material objects (Block are stored in the base class)

Definition at line 58 of file MaterialWarehouse.h.

Referenced by addObjects(), initialSetup(), jacobianSetup(), neighborSubdomainSetup(), operator[](), residualSetup(), sort(), timestepSetup(), and updateActive().

◆ _num_threads

const THREAD_ID MooseObjectWarehouseBase< MaterialBase >::_num_threads

protectedinherited

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

Definition at line 208 of file MooseObjectWarehouseBase.h.

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

◆ _variable_objects

std::map<unsigned int, MooseObjectWarehouse<MaterialBase > > MooseObjectWarehouse< MaterialBase >::_variable_objects

protectedinherited

Variable based storage.

Definition at line 88 of file MooseObjectWarehouse.h.

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

include/materials/MaterialWarehouse.h
src/materials/MaterialWarehouse.C

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ activeObjectsToFormattedString()

◆ addObject()

◆ addObjects()

◆ checkThreadID()

◆ customSetup()

◆ getActiveBlockObjects() [1/2]

◆ getActiveBlockObjects() [2/2]

◆ getActiveBlocks()

◆ getActiveBoundaryObjects() [1/2]

◆ getActiveBoundaryObjects() [2/2]

◆ getActiveObject()

◆ getActiveObjects()

◆ getActiveVariableBlockObjects()

◆ getBlockObjects() [1/2]

◆ getBlockObjects() [2/2]

◆ getBoundaryObjects() [1/2]

◆ getBoundaryObjects() [2/2]

◆ getObject()

◆ getObjects()

◆ getObjectsForVariable()

◆ hasActiveBlockObjects() [1/2]

◆ hasActiveBlockObjects() [2/2]

◆ hasActiveBoundaryObjects() [1/2]

◆ hasActiveBoundaryObjects() [2/2]

◆ hasActiveObject()

◆ hasActiveObjects()

◆ hasActiveVariableBlockObjects()

◆ hasBoundaryObjects()

◆ hasObjects()

◆ hasObjectsForVariable()

◆ hasObjectsForVariableAndBlocks()

◆ hasVariableObjects()

◆ initialSetup()

◆ jacobianSetup()

◆ neighborSubdomainSetup() [1/2]

◆ neighborSubdomainSetup() [2/2]

◆ numThreads()

◆ operator[]()

◆ residualSetup()

◆ size()

◆ sort()

◆ sortHelper()

◆ subdomainsCovered()

◆ subdomainSetup() [1/2]

◆ subdomainSetup() [2/2]

◆ timestepSetup()

◆ updateActive()

◆ updateActiveHelper()

◆ updateBlockFEVariableCoupledVectorTagDependency()

◆ updateBlockMatPropDependency()

◆ updateBlockVariableDependency()

◆ updateBoundaryFEVariableCoupledVectorTagDependency()

◆ updateBoundaryMatPropDependency() [1/2]

◆ updateBoundaryMatPropDependency() [2/2]

◆ updateBoundaryVariableDependency() [1/2]

◆ updateBoundaryVariableDependency() [2/2]

◆ 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

◆ _face_materials

◆ _neighbor_materials

◆ _num_threads

◆ _variable_objects