AnnularMesh Class Reference

Mesh generated from parameters. More...

#include <AnnularMesh.h>

Inheritance diagram for AnnularMesh:

Public Types
enum	ParallelType { ParallelType::DEFAULT, ParallelType::REPLICATED, ParallelType::DISTRIBUTED }
using	PeriodicNodeInfo = std::pair< const Node *, BoundaryID >
	Helper type for building periodic node maps. More...

Public Member Functions
	AnnularMesh (const InputParameters &parameters)
	AnnularMesh (const AnnularMesh &)=default
AnnularMesh &	operator= (const AnnularMesh &other_mesh)=delete
virtual std::unique_ptr< MooseMesh >	safeClone () const override
	A safer version of the clone() method that hands back an allocated object wrapped in a smart pointer. More...
virtual void	buildMesh () override
	Must be overridden by child classes. More...
virtual Real	getMinInDimension (unsigned int component) const override
	Returns the min or max of the requested dimension respectively. More...
virtual Real	getMaxInDimension (unsigned int component) const override
virtual void	prepared (bool state) override
virtual MooseMesh &	clone () const
	Clone method. More...
std::unique_ptr< MeshBase >	buildMeshBaseObject (ParallelType override_type=ParallelType::DEFAULT)
	Method to construct a libMesh::MeshBase object that is normally set and used by the MooseMesh object during the "init()" phase. More...
void	setMeshBase (std::unique_ptr< MeshBase > mesh_base)
	Method to set the mesh_base object. More...
virtual void	init ()
	Initialize the Mesh object. More...
virtual unsigned int	dimension () const
	Returns MeshBase::mesh_dimsension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh mesh object. More...
virtual unsigned int	effectiveSpatialDimension () const
	Returns the effective spatial dimension determined by the coordinates actually used by the mesh. More...
std::vector< BoundaryID >	getBoundaryIDs (const Elem *const elem, const unsigned short int side) const
	Returns a vector of boundary IDs for the requested element on the requested side. More...
const std::set< BoundaryID > &	getBoundaryIDs () const
	Returns a const reference to a set of all user-specified boundary IDs. More...
std::vector< BoundaryID >	getBoundaryIDs (const std::vector< BoundaryName > &boundary_name, bool generate_unknown=false) const
	Get the associated BoundaryID for the boundary names that are passed in. More...
void	buildNodeList ()
	Calls BoundaryInfo::build_node_list()/build_side_list() and makes separate copies of Nodes/Elems in those lists. More...
void	buildBndElemList ()
const std::map< dof_id_type, std::vector< dof_id_type > > &	nodeToElemMap ()
	If not already created, creates a map from every node to all elements to which they are connected. More...
const std::map< dof_id_type, std::vector< dof_id_type > > &	nodeToActiveSemilocalElemMap ()
	If not already created, creates a map from every node to all active semilocal elements to which they are connected. More...
virtual bnd_node_iterator	bndNodesBegin ()
	Return iterators to the beginning/end of the boundary nodes list. More...
virtual bnd_node_iterator	bndNodesEnd ()
virtual bnd_elem_iterator	bndElemsBegin ()
	Return iterators to the beginning/end of the boundary elements list. More...
virtual bnd_elem_iterator	bndElemsEnd ()
void	buildNodeListFromSideList ()
	Calls BoundaryInfo::build_node_list_from_side_list(). More...
void	buildSideList (std::vector< dof_id_type > &el, std::vector< unsigned short int > &sl, std::vector< boundary_id_type > &il)
	Calls BoundaryInfo::build_side_list(). More...
std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	buildSideList ()
	As above, but uses the non-deprecated std::tuple interface. More...
unsigned int	sideWithBoundaryID (const Elem *const elem, const BoundaryID boundary_id) const
	Calls BoundaryInfo::side_with_boundary_id(). More...
MeshBase::const_node_iterator	localNodesBegin ()
	Calls local_nodes_begin/end() on the underlying libMesh mesh object. More...
MeshBase::const_node_iterator	localNodesEnd ()
MeshBase::const_element_iterator	activeLocalElementsBegin ()
	Calls active_local_nodes_begin/end() on the underlying libMesh mesh object. More...
const MeshBase::const_element_iterator	activeLocalElementsEnd ()
virtual dof_id_type	nNodes () const
	Calls n_nodes/elem() on the underlying libMesh mesh object. More...
virtual dof_id_type	nElem () const
virtual dof_id_type	maxNodeId () const
	Calls max_node/elem_id() on the underlying libMesh mesh object. More...
virtual dof_id_type	maxElemId () const
virtual const Node &	node (const dof_id_type i) const
	Various accessors (pointers/references) for Node "i". More...
virtual Node &	node (const dof_id_type i)
virtual const Node &	nodeRef (const dof_id_type i) const
virtual Node &	nodeRef (const dof_id_type i)
virtual const Node *	nodePtr (const dof_id_type i) const
virtual Node *	nodePtr (const dof_id_type i)
virtual const Node *	queryNodePtr (const dof_id_type i) const
virtual Node *	queryNodePtr (const dof_id_type i)
virtual Elem *	elem (const dof_id_type i)
	Various accessors (pointers/references) for Elem "i". More...
virtual const Elem *	elem (const dof_id_type i) const
virtual Elem *	elemPtr (const dof_id_type i)
virtual const Elem *	elemPtr (const dof_id_type i) const
virtual Elem *	queryElemPtr (const dof_id_type i)
virtual const Elem *	queryElemPtr (const dof_id_type i) const
bool	prepared () const
	Setter/getter for the _is_prepared flag. More...
void	needsPrepareForUse ()
	If this method is called, we will call libMesh's prepare_for_use method when we call Moose's prepare method. More...
void	meshChanged ()
	Declares that the MooseMesh has changed, invalidates cached data and rebuilds caches. More...
virtual void	onMeshChanged ()
	Declares a callback function that is executed at the conclusion of meshChanged(). More...
void	cacheChangedLists ()
	Cache information about what elements were refined and coarsened in the previous step. More...
ConstElemPointerRange *	refinedElementRange () const
	Return a range that is suitable for threaded execution over elements that were just refined. More...
ConstElemPointerRange *	coarsenedElementRange () const
	Return a range that is suitable for threaded execution over elements that were just coarsened. More...
const std::vector< const Elem * > &	coarsenedElementChildren (const Elem *elem) const
	Get the newly removed children element ids for an element that was just coarsened. More...
void	updateActiveSemiLocalNodeRange (std::set< dof_id_type > &ghosted_elems)
	Clears the "semi-local" node list and rebuilds it. More...
bool	isSemiLocal (Node *node)
	Returns true if the node is semi-local. More...
ConstElemRange *	getActiveLocalElementRange ()
	Return pointers to range objects for various types of ranges (local nodes, boundary elems, etc.). More...
NodeRange *	getActiveNodeRange ()
SemiLocalNodeRange *	getActiveSemiLocalNodeRange () const
ConstNodeRange *	getLocalNodeRange ()
StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > *	getBoundaryNodeRange ()
StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > *	getBoundaryElementRange ()
const std::set< SubdomainID > &	meshSubdomains () const
	Returns a read-only reference to the set of subdomains currently present in the Mesh. More...
const std::set< BoundaryID > &	meshBoundaryIds () const
	Returns a read-only reference to the set of boundary IDs currently present in the Mesh. More...
const std::set< BoundaryID > &	meshSidesetIds () const
	Returns a read-only reference to the set of sidesets currently present in the Mesh. More...
const std::set< BoundaryID > &	meshNodesetIds () const
	Returns a read-only reference to the set of nodesets currently present in the Mesh. More...
void	setBoundaryToNormalMap (std::unique_ptr< std::map< BoundaryID, RealVectorValue >> boundary_map)
	Sets the mapping between BoundaryID and normal vector Is called by AddAllSideSetsByNormals. More...
void	setBoundaryToNormalMap (std::map< BoundaryID, RealVectorValue > *boundary_map)
void	setMeshBoundaryIDs (std::set< BoundaryID > boundary_IDs)
	Sets the set of BoundaryIDs Is called by AddAllSideSetsByNormals. More...
const RealVectorValue &	getNormalByBoundaryID (BoundaryID id) const
	Returns the normal vector associated with a given BoundaryID. More...
void	prepare (bool force=false)
	Calls prepare_for_use() if force=true on the underlying Mesh object, then communicates various boundary information on parallel meshes. More...
void	update ()
	Calls buildNodeListFromSideList(), buildNodeList(), and buildBndElemList(). More...
unsigned int	uniformRefineLevel () const
	Returns the level of uniform refinement requested (zero if AMR is disabled). More...
void	setUniformRefineLevel (unsigned int)
	Set uniform refinement level. More...
void	addGhostedBoundary (BoundaryID boundary_id)
	This will add the boundary ids to be ghosted to this processor. More...
void	setGhostedBoundaryInflation (const std::vector< Real > &inflation)
	This sets the inflation amount for the bounding box for each partition for use in ghosting boundaries. More...
const std::set< unsigned int > &	getGhostedBoundaries () const
	Return a writable reference to the set of ghosted boundary IDs. More...
const std::vector< Real > &	getGhostedBoundaryInflation () const
	Return a writable reference to the _ghosted_boundaries_inflation vector. More...
void	ghostGhostedBoundaries ()
	Actually do the ghosting of boundaries that need to be ghosted to this processor. More...
unsigned int	getPatchSize () const
	Getter for the patch_size parameter. More...
unsigned int	getGhostingPatchSize () const
	Getter for the ghosting_patch_size parameter. More...
unsigned int	getMaxLeafSize () const
	Getter for the maximum leaf size parameter. More...
void	setPatchUpdateStrategy (Moose::PatchUpdateType patch_update_strategy)
	Set the patch size update strategy. More...
const Moose::PatchUpdateType &	getPatchUpdateStrategy () const
	Get the current patch update strategy. More...
BoundingBox	getInflatedProcessorBoundingBox (Real inflation_multiplier=0.01) const
	Get a (slightly inflated) processor bounding box. More...
	operator libMesh::MeshBase & ()
	Implicit conversion operator from MooseMesh -> libMesh::MeshBase. More...
	operator const libMesh::MeshBase & () const
MeshBase &	getMesh ()
	Accessor for the underlying libMesh Mesh object. More...
const MeshBase &	getMesh () const
virtual ExodusII_IO *	exReader () const
	Not implemented – always returns NULL. More...
void	printInfo (std::ostream &os=libMesh::out) const
	Calls print_info() on the underlying Mesh. More...
const std::set< SubdomainID > &	getNodeBlockIds (const Node &node) const
	Return list of blocks to which the given node belongs. More...
const std::vector< dof_id_type > &	getNodeList (boundary_id_type nodeset_id) const
	Return a writable reference to a vector of node IDs that belong to nodeset_id. More...
const Node *	addUniqueNode (const Point &p, Real tol=1e-6)
	Add a new node to the mesh. More...
Node *	addQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp, BoundaryID bid, const Point &point)
	Adds a fictitious "QuadratureNode". More...
Node *	getQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp)
	Get a specified quadrature node. More...
void	clearQuadratureNodes ()
	Clear out any existing quadrature nodes. More...
BoundaryID	getBoundaryID (const BoundaryName &boundary_name) const
	Get the associated BoundaryID for the boundary name. More...
SubdomainID	getSubdomainID (const SubdomainName &subdomain_name) const
	Get the associated subdomain ID for the subdomain name. More...
std::vector< SubdomainID >	getSubdomainIDs (const std::vector< SubdomainName > &subdomain_name) const
	Get the associated subdomainIDs for the subdomain names that are passed in. More...
void	setSubdomainName (SubdomainID subdomain_id, SubdomainName name)
	This method returns a writable reference to a subdomain name based on the id parameter. More...
const std::string &	getSubdomainName (SubdomainID subdomain_id)
	Return the name of a block given an id. More...
void	setBoundaryName (BoundaryID boundary_id, BoundaryName name)
	This method returns a writable reference to a boundary name based on the id parameter. More...
const std::string &	getBoundaryName (BoundaryID boundary_id)
	Return the name of the boundary given the id. More...
void	buildPeriodicNodeMap (std::multimap< dof_id_type, dof_id_type > &periodic_node_map, unsigned int var_number, PeriodicBoundaries *pbs) const
	This routine builds a multimap of boundary ids to matching boundary ids across all periodic boundaries in the system. More...
void	buildPeriodicNodeSets (std::map< BoundaryID, std::set< dof_id_type >> &periodic_node_sets, unsigned int var_number, PeriodicBoundaries *pbs) const
	This routine builds a datastructure of node ids organized by periodic boundary ids. More...
Real	dimensionWidth (unsigned int component) const
	Returns the width of the requested dimension. More...
bool	detectOrthogonalDimRanges (Real tol=1e-6)
	This routine determines whether the Mesh is a regular orthogonal mesh (i.e. More...
void	addPeriodicVariable (unsigned int var_num, BoundaryID primary, BoundaryID secondary)
	For "regular orthogonal" meshes, determine if variable var_num is periodic with respect to the primary and secondary BoundaryIDs, record this fact in the _periodic_dim data structure. More...
bool	isTranslatedPeriodic (unsigned int nonlinear_var_num, unsigned int component) const
	Returns whether this generated mesh is periodic in the given dimension for the given variable. More...
RealVectorValue	minPeriodicVector (unsigned int nonlinear_var_num, Point p, Point q) const
	This function returns the minimum vector between two points on the mesh taking into account periodicity for the given variable number. More...
Real	minPeriodicDistance (unsigned int nonlinear_var_num, Point p, Point q) const
	This function returns the distance between two points on the mesh taking into account periodicity for the given variable number. More...
const std::pair< BoundaryID, BoundaryID > *	getPairedBoundaryMapping (unsigned int component)
	This function attempts to return the paired boundary ids for the given component. More...
void	buildRefinementAndCoarseningMaps (Assembly *assembly)
	Create the refinement and coarsening maps necessary for projection of stateful material properties when using adaptivity. More...
const std::vector< std::vector< QpMap > > &	getRefinementMap (const Elem &elem, int parent_side, int child, int child_side)
	Get the refinement map for a given element type. More...
const std::vector< std::pair< unsigned int, QpMap > > &	getCoarseningMap (const Elem &elem, int input_side)
	Get the coarsening map for a given element type. More...
void	changeBoundaryId (const boundary_id_type old_id, const boundary_id_type new_id, bool delete_prev)
	Change all the boundary IDs for a given side from old_id to new_id. More...
const std::set< BoundaryID > &	getSubdomainBoundaryIds (SubdomainID subdomain_id) const
	Get the list of boundary ids associated with the given subdomain id. More...
bool	isBoundaryNode (dof_id_type node_id) const
	Returns true if the requested node is in the list of boundary nodes, false otherwise. More...
bool	isBoundaryNode (dof_id_type node_id, BoundaryID bnd_id) const
	Returns true if the requested node is in the list of boundary nodes for the specified boundary, false otherwise. More...
bool	isBoundaryElem (dof_id_type elem_id) const
	Returns true if the requested element is in the list of boundary elements, false otherwise. More...
bool	isBoundaryElem (dof_id_type elem_id, BoundaryID bnd_id) const
	Returns true if the requested element is in the list of boundary elements for the specified boundary, false otherwise. More...
void	errorIfDistributedMesh (std::string name) const
	Generate a unified error message if the underlying libMesh mesh is a DistributedMesh. More...
bool	isDistributedMesh () const
	Returns the final Mesh distribution type. More...
bool	isParallelTypeForced () const
	Tell the user if the distribution was overriden for any reason. More...
const MooseEnum &	partitionerName () const
bool	isPartitionerForced () const
	Tell the user if the partitioner was overriden for any reason. More...
void	allowRecovery (bool allow)
	Set whether or not this mesh is allowed to read a recovery file. More...
void	addMortarInterface (const std::string &name, BoundaryName master, BoundaryName slave, SubdomainName domain_id)
std::vector< std::unique_ptr< MooseMesh::MortarInterface > > &	getMortarInterfaces ()
MooseMesh::MortarInterface *	getMortarInterfaceByName (const std::string name)
MooseMesh::MortarInterface *	getMortarInterface (BoundaryID master, BoundaryID slave)
void	setCustomPartitioner (Partitioner *partitioner)
	Setter for custom partitioner. More...
bool	isRegularOrthogonal ()
	Getter to query if the mesh was detected to be regular and orthogonal. More...
bool	hasSecondOrderElements ()
	check if the mesh has SECOND order elements More...
virtual std::unique_ptr< PointLocatorBase >	getPointLocator () const
	Proxy function to get a (sub)PointLocator from either the underlying libMesh mesh (default), or to allow derived meshes to return a custom point locator. More...
virtual std::string	getFileName () const
	Returns the name of the mesh file read to produce this mesh if any or an empty string otherwise. More...
const std::string &	type () const
	Get the type of this object. More...
const std::string &	name () const
	Get the name of the object. More...
const InputParameters &	parameters () const
	Get the parameters of the object. More...
template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object. More...
template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...
bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid. More...
MooseApp &	getMooseApp () const
	Get the MooseApp this object is associated with. More...
virtual bool	enabled () const
	Return the enabled status of the object. More...
template<typename... Args>
void	paramError (const std::string &param, Args... args)
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramWarning (const std::string &param, Args... args)
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramInfo (const std::string &param, Args... args)
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	mooseError (Args &&... args) const
template<typename... Args>
void	mooseWarning (Args &&... args) const
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseInfo (Args &&... args) const
bool	isCustomPartitionerRequested () const
	Setter and getter for _custom_partitioner_requested. More...
void	setIsCustomPartitionerRequested (bool cpr)

Public Attributes
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects. More...

Protected Types
enum	{ X = 0, Y, Z }
	Convenience enums. More...
enum	{ MIN = 0, MAX }
typedef std::vector< BndNode * >::iterator	bnd_node_iterator_imp
typedef std::vector< BndNode * >::const_iterator	const_bnd_node_iterator_imp
typedef std::vector< BndElement * >::iterator	bnd_elem_iterator_imp
typedef std::vector< BndElement * >::const_iterator	const_bnd_elem_iterator_imp

Protected Member Functions
void	cacheInfo ()
void	freeBndNodes ()
void	freeBndElems ()
template<typename T >
T &	declareRestartableData (std::string data_name)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableData (std::string data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRestartableDataWithContext (std::string data_name, void *context)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataWithContext (std::string data_name, const T &init_value, void *context)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRecoverableData (std::string data_name)
	Declare a piece of data as "recoverable". More...
template<typename T >
T &	declareRecoverableData (std::string data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRestartableDataWithObjectName (std::string data_name, std::string object_name)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataWithObjectNameWithContext (std::string data_name, std::string object_name, void *context)
	Declare a piece of data as "restartable". More...
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level)
	Call to register a named section for timing. More...

Protected Attributes
const unsigned	_nr
	Number of elements in radial direction. More...
const unsigned	_nt
	Number of elements in angular direction. More...
const Real	_rmin
	Minimum radius. More...
const Real	_rmax
	Maximum radius. More...
const Real	_tmin
	Minimum angle. More...
const Real	_tmax
	Maximum angle. More...
const Real	_growth_r
	Bias on radial meshing. More...
const Real	_len
	rmax = rmin + len + len*g + len*g^2 + len*g^3 + ... + len*g^(nr-1) = rmin + len*(1 - g^nr)/(1 - g) More...
const bool	_full_annulus
	Whether a full annulus (as opposed to a sector) will needs to generate. More...
const SubdomainID	_quad_subdomain_id
	Subdomain ID of created quad elements. More...
const SubdomainID	_tri_subdomain_id
	Subdomain ID of created tri elements (that only exist if rmin=0) More...
bool	_dims_may_have_changed
	Boolean to indicate that dimensions may have changed. More...
std::vector< std::unique_ptr< GhostingFunctor > >	_ghosting_functors
	Deprecated (DO NOT USE) More...
std::vector< std::shared_ptr< RelationshipManager > >	_relationship_managers
	The list of active geometric relationship managers (bound to the underlying MeshBase object). More...
ParallelType	_parallel_type
	Can be set to DISTRIBUTED, REPLICATED, or DEFAULT. More...
bool	_use_distributed_mesh
	False by default. More...
bool	_distribution_overridden
bool	_parallel_type_overridden
std::unique_ptr< libMesh::MeshBase >	_mesh
	Pointer to underlying libMesh mesh object. More...
MooseEnum	_partitioner_name
	The partitioner used on this mesh. More...
bool	_partitioner_overridden
std::unique_ptr< Partitioner >	_custom_partitioner
	The custom partitioner. More...
bool	_custom_partitioner_requested
unsigned int	_uniform_refine_level
	The level of uniform refinement requested (set to zero if AMR is disabled) More...
bool	_is_changed
	true if mesh is changed (i.e. after adaptivity step) More...
bool	_is_nemesis
	True if a Nemesis Mesh was read in. More...
bool	_is_prepared
	True if prepare has been called on the mesh. More...
bool	_needs_prepare_for_use
	True if prepare_for_use should be called when Mesh is prepared. More...
std::unique_ptr< ConstElemPointerRange >	_refined_elements
	The elements that were just refined. More...
std::unique_ptr< ConstElemPointerRange >	_coarsened_elements
	The elements that were just coarsened. More...
std::map< const Elem *, std::vector< const Elem * > >	_coarsened_element_children
	Map of Parent elements to child elements for elements that were just coarsened. More...
std::set< Node * >	_semilocal_node_list
	Used for generating the semilocal node range. More...
std::unique_ptr< ConstElemRange >	_active_local_elem_range
	A range for use with threading. More...
std::unique_ptr< SemiLocalNodeRange >	_active_semilocal_node_range
std::unique_ptr< NodeRange >	_active_node_range
std::unique_ptr< ConstNodeRange >	_local_node_range
std::unique_ptr< StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > >	_bnd_node_range
std::unique_ptr< StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > >	_bnd_elem_range
std::map< dof_id_type, std::vector< dof_id_type > >	_node_to_elem_map
	A map of all of the current nodes to the elements that they are connected to. More...
bool	_node_to_elem_map_built
std::map< dof_id_type, std::vector< dof_id_type > >	_node_to_active_semilocal_elem_map
	A map of all of the current nodes to the active elements that they are connected to. More...
bool	_node_to_active_semilocal_elem_map_built
std::set< SubdomainID >	_mesh_subdomains
	A set of subdomain IDs currently present in the mesh. More...
std::unique_ptr< std::map< BoundaryID, RealVectorValue > >	_boundary_to_normal_map
	The boundary to normal map - valid only when AddAllSideSetsByNormals is active. More...
std::vector< BndNode * >	_bnd_nodes
	array of boundary nodes More...
std::map< boundary_id_type, std::set< dof_id_type > >	_bnd_node_ids
	Map of sets of node IDs in each boundary. More...
std::vector< BndElement * >	_bnd_elems
	array of boundary elems More...
std::map< boundary_id_type, std::set< dof_id_type > >	_bnd_elem_ids
	Map of set of elem IDs connected to each boundary. More...
std::map< dof_id_type, Node * >	_quadrature_nodes
std::map< dof_id_type, std::map< unsigned int, std::map< dof_id_type, Node * > > >	_elem_to_side_to_qp_to_quadrature_nodes
std::vector< BndNode >	_extra_bnd_nodes
std::map< dof_id_type, std::set< SubdomainID > >	_block_node_list
	list of nodes that belongs to a specified block (domain) More...
std::map< boundary_id_type, std::vector< dof_id_type > >	_node_set_nodes
	list of nodes that belongs to a specified nodeset: indexing [nodeset_id] -> [array of node ids] More...
std::set< unsigned int >	_ghosted_boundaries
std::vector< Real >	_ghosted_boundaries_inflation
unsigned int	_patch_size
	The number of nodes to consider in the NearestNode neighborhood. More...
unsigned int	_ghosting_patch_size
	The number of nearest neighbors to consider for ghosting purposes when iteration patch update strategy is used. More...
unsigned int	_max_leaf_size
Moose::PatchUpdateType	_patch_update_strategy
	The patch update strategy. More...
std::vector< Node * >	_node_map
	Vector of all the Nodes in the mesh for determining when to add a new point. More...
bool	_regular_orthogonal_mesh
	Boolean indicating whether this mesh was detected to be regular and orthogonal. More...
std::vector< std::vector< Real > >	_bounds
	The bounds in each dimension of the mesh for regular orthogonal meshes. More...
std::vector< std::pair< BoundaryID, BoundaryID > >	_paired_boundary
	A vector holding the paired boundaries for a regular orthogonal mesh. More...
std::map< std::string, MortarInterface * >	_mortar_interface_by_name
	Mortar interfaces mapped through their names. More...
std::vector< std::unique_ptr< MortarInterface > >	_mortar_interface
std::map< std::pair< BoundaryID, BoundaryID >, MortarInterface * >	_mortar_interface_by_ids
	Mortar interfaces mapped though master, slave IDs pairs. More...
const InputParameters &	_pars
	Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...
MooseApp &	_app
	The MooseApp this object is associated with. More...
const std::string &	_type
	The type of this object (the Class name) More...
const std::string &	_name
	The name of this object, reference to value stored in InputParameters. More...
const bool &	_enabled
	Reference to the "enable" InputParaemters, used by Controls for toggling on/off MooseObjects. More...
const InputParameters *	_pg_params
	Params. More...
PerfGraph &	_perf_graph
	The performance graph to add to. More...
std::string	_prefix
	A prefix to use for all sections. More...
std::set< BoundaryID >	_mesh_boundary_ids
	A set of boundary IDs currently present in the mesh. More...
std::set< BoundaryID >	_mesh_sideset_ids
std::set< BoundaryID >	_mesh_nodeset_ids

Detailed Description

Mesh generated from parameters.

Definition at line 23 of file AnnularMesh.h.

Member Typedef Documentation

bnd_elem_iterator_imp

typedef std::vector<BndElement *>::iterator MooseMesh::bnd_elem_iterator_imp

protectedinherited

Definition at line 980 of file MooseMesh.h.

bnd_node_iterator_imp

typedef std::vector<BndNode *>::iterator MooseMesh::bnd_node_iterator_imp

protectedinherited

Definition at line 973 of file MooseMesh.h.

const_bnd_elem_iterator_imp

typedef std::vector<BndElement *>::const_iterator MooseMesh::const_bnd_elem_iterator_imp

protectedinherited

Definition at line 981 of file MooseMesh.h.

const_bnd_node_iterator_imp

typedef std::vector<BndNode *>::const_iterator MooseMesh::const_bnd_node_iterator_imp

protectedinherited

Definition at line 974 of file MooseMesh.h.

PeriodicNodeInfo

using MooseMesh::PeriodicNodeInfo = std::pair<const Node *, BoundaryID>

inherited

Helper type for building periodic node maps.

Definition at line 855 of file MooseMesh.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

protectedinherited

Convenience enums.

Enumerator
X
Y
Z

Definition at line 887 of file MooseMesh.h.

  {
    X = 0,
    Y,
    Z
  };

anonymous enum

anonymous enum

protectedinherited

Enumerator
MIN
MAX

Definition at line 893 of file MooseMesh.h.

  {
    MIN = 0,
    MAX
  };

ParallelType

enum MooseMesh::ParallelType

stronginherited

Enumerator
DEFAULT
REPLICATED
DISTRIBUTED

Definition at line 85 of file MooseMesh.h.

  {
    DEFAULT,
    REPLICATED,
    DISTRIBUTED
  };

Constructor & Destructor Documentation

AnnularMesh() [1/2]

AnnularMesh::AnnularMesh

(

const InputParameters &

parameters

)

Definition at line 55 of file AnnularMesh.C.

  : MooseMesh(parameters),
    _nr(getParam<unsigned int>("nr")),
    _nt(getParam<unsigned int>("nt")),
    _rmin(getParam<Real>("rmin")),
    _rmax(getParam<Real>("rmax")),
    _tmin(getParam<Real>("tmin")),
    _tmax(getParam<Real>("tmax")),
    _growth_r(getParam<Real>("growth_r")),
    _len(_growth_r == 1.0 ? (_rmax - _rmin) / _nr
                          : (_rmax - _rmin) * (1.0 - _growth_r) / (1.0 - std::pow(_growth_r, _nr))),
    _full_annulus(_tmin == 0.0 && _tmax == 2 * M_PI),
    _quad_subdomain_id(getParam<SubdomainID>("quad_subdomain_id")),
    _tri_subdomain_id(getParam<SubdomainID>("tri_subdomain_id")),
    _dims_may_have_changed(false)
{
  // catch likely user errors
  if (_rmax <= _rmin)
    mooseError("AnnularMesh: rmax must be greater than rmin");
  if (_tmax <= _tmin)
    mooseError("AnnularMesh: tmax must be greater than tmin");
  if (_tmax - _tmin > 2 * M_PI)
    mooseError("AnnularMesh: tmax - tmin must be <= 2 Pi");
  if (_nt <= (_tmax - _tmin) / M_PI)
    mooseError("AnnularMesh: nt must be greater than (tmax - tmin) / Pi in order to avoid inverted "
               "elements");
  if (_quad_subdomain_id == _tri_subdomain_id)
    mooseError("AnnularMesh: quad_subdomain_id must not equal tri_subdomain_id");
}

AnnularMesh() [2/2]

AnnularMesh::AnnularMesh ( const AnnularMesh &  )

default

Member Function Documentation

activeLocalElementsBegin()

MeshBase::const_element_iterator MooseMesh::activeLocalElementsBegin ( )

inherited

Calls active_local_nodes_begin/end() on the underlying libMesh mesh object.

Definition at line 2212 of file MooseMesh.C.

Referenced by FEProblemBase::checkDisplacementOrders(), MooseMesh::hasSecondOrderElements(), and TopResidualDebugOutput::printTopResiduals().

{
  return getMesh().active_local_elements_begin();
}

activeLocalElementsEnd()

const MeshBase::const_element_iterator MooseMesh::activeLocalElementsEnd ( )

inherited

Definition at line 2218 of file MooseMesh.C.

Referenced by FEProblemBase::checkDisplacementOrders(), MooseMesh::hasSecondOrderElements(), and TopResidualDebugOutput::printTopResiduals().

{
  return getMesh().active_local_elements_end();
}

addGhostedBoundary()

void MooseMesh::addGhostedBoundary ( BoundaryID  boundary_id )

inherited

This will add the boundary ids to be ghosted to this processor.

Definition at line 2368 of file MooseMesh.C.

Referenced by FEProblemBase::addGhostedBoundary(), and SetupMeshAction::setupMesh().

{
  _ghosted_boundaries.insert(boundary_id);
}

addMortarInterface()

void MooseMesh::addMortarInterface ( const std::string &  name, BoundaryName  master, BoundaryName  slave, SubdomainName  domain_id  )

inherited

Definition at line 2753 of file MooseMesh.C.

{
  TIME_SECTION(_add_mortar_interface_timer);

  SubdomainID domain_id = getSubdomainID(domain_name);
  boundary_id_type master_id = getBoundaryID(master);
  boundary_id_type slave_id = getBoundaryID(slave);

  std::unique_ptr<MortarInterface> iface = libmesh_make_unique<MortarInterface>();

  iface->_id = domain_id;
  iface->_master = master;
  iface->_slave = slave;
  iface->_name = name;

  for (auto & elem : as_range(_mesh->level_elements_begin(0), _mesh->level_elements_end(0)))
  {
    if (elem->subdomain_id() == domain_id)
      iface->_elems.push_back(elem);
  }

  setSubdomainName(iface->_id, name);

  _mortar_interface.push_back(std::move(iface));
  _mortar_interface_by_name[name] = _mortar_interface.back().get();
  _mortar_interface_by_ids[std::pair<BoundaryID, BoundaryID>(master_id, slave_id)] =
      _mortar_interface.back().get();
}

addPeriodicVariable()

void MooseMesh::addPeriodicVariable ( unsigned int  var_num, BoundaryID  primary, BoundaryID  secondary  )

inherited

For "regular orthogonal" meshes, determine if variable var_num is periodic with respect to the primary and secondary BoundaryIDs, record this fact in the _periodic_dim data structure.

Definition at line 1479 of file MooseMesh.C.

Referenced by AddPeriodicBCAction::setPeriodicVars().

{
  if (!_regular_orthogonal_mesh)
    return;

  _periodic_dim[var_num].resize(dimension());

  _half_range = Point(dimensionWidth(0) / 2.0, dimensionWidth(1) / 2.0, dimensionWidth(2) / 2.0);

  for (unsigned int component = 0; component < dimension(); ++component)
  {
    const std::pair<BoundaryID, BoundaryID> * boundary_ids = getPairedBoundaryMapping(component);

    if (boundary_ids != nullptr &&
        ((boundary_ids->first == primary && boundary_ids->second == secondary) ||
         (boundary_ids->first == secondary && boundary_ids->second == primary)))
      _periodic_dim[var_num][component] = true;
  }
}

addQuadratureNode()

Node * MooseMesh::addQuadratureNode ( const Elem *  elem, const unsigned short int  side, const unsigned int  qp, BoundaryID  bid, const Point &  point  )

inherited

Adds a fictitious "QuadratureNode".

This doesn't actually add it to the libMesh mesh... we just keep track of these here in MooseMesh.

QuadratureNodes are fictitious "Nodes" that are located at quadrature points. This is useful for using the geometric search system to do searches based on quadrature point locations....

Parameters

elem	The element
side	The side number on which we want to add a quadrature node
qp	The number of the quadrature point
bid	The boundary ID for the point to be added with
point	The physical location of the point

Definition at line 920 of file MooseMesh.C.

Referenced by GeometricSearchData::generateMortarNodes(), and GeometricSearchData::generateQuadratureNodes().

{
  Node * qnode;

  if (_elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side].find(qp) ==
      _elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side].end())
  {
    // Create a new node id starting from the max node id and counting down.  This will be the least
    // likely to collide with an existing node id.
    // Note that we are using numeric_limits<unsigned>::max even
    // though max_id is stored as a dof_id_type.  I tried this with
    // numeric_limits<dof_id_type>::max and it broke several tests in
    // MOOSE.  So, this is some kind of a magic number that we will
    // just continue to use...
    dof_id_type max_id = std::numeric_limits<unsigned int>::max() - 100;
    dof_id_type new_id = max_id - _quadrature_nodes.size();

    if (new_id <= getMesh().max_node_id())
      mooseError("Quadrature node id collides with existing node id!");

    qnode = new Node(point, new_id);

    // Keep track of this new node in two different ways for easy lookup
    _quadrature_nodes[new_id] = qnode;
    _elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side][qp] = qnode;

    if (elem->active())
    {
      _node_to_elem_map[new_id].push_back(elem->id());
      _node_to_active_semilocal_elem_map[new_id].push_back(elem->id());
    }
  }
  else
    qnode = _elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side][qp];

  BndNode * bnode = new BndNode(qnode, bid);
  _bnd_nodes.push_back(bnode);
  _bnd_node_ids[bid].insert(qnode->id());

  _extra_bnd_nodes.push_back(*bnode);

  // Do this so the range will be regenerated next time it is accessed
  _bnd_node_range.reset();

  return qnode;
}

addUniqueNode()

const Node * MooseMesh::addUniqueNode ( const Point &  p, Real  tol = 1e-6  )

inherited

Add a new node to the mesh.

If there is already a node located at the point passed then the node will not be added. In either case a reference to the node at that location will be returned

Looping through the mesh nodes each time we add a point is very slow. To speed things up we keep a local data structure

Definition at line 886 of file MooseMesh.C.

{
  if (getMesh().n_nodes() != _node_map.size())
  {
    _node_map.clear();
    _node_map.reserve(getMesh().n_nodes());
    for (const auto & node : getMesh().node_ptr_range())
      _node_map.push_back(node);
  }

  Node * node = nullptr;
  for (unsigned int i = 0; i < _node_map.size(); ++i)
  {
    if (p.relative_fuzzy_equals(*_node_map[i], tol))
    {
      node = _node_map[i];
      break;
    }
  }
  if (node == nullptr)
  {
    node = getMesh().add_node(new Node(p));
    _node_map.push_back(node);
  }

  mooseAssert(node != nullptr, "Node is NULL");
  return node;
}

allowRecovery()

void MooseMesh::allowRecovery ( bool  allow )

inlineinherited

Set whether or not this mesh is allowed to read a recovery file.

Definition at line 795 of file MooseMesh.h.

{ _allow_recovery = allow; }

bndElemsBegin()

MooseMesh::bnd_elem_iterator MooseMesh::bndElemsBegin ( )

virtualinherited

Return iterators to the beginning/end of the boundary elements list.

Definition at line 871 of file MooseMesh.C.

Referenced by MooseMesh::getBoundaryElementRange(), and MeshSideSet::modify().

{
  Predicates::NotNull<bnd_elem_iterator_imp> p;
  return bnd_elem_iterator(_bnd_elems.begin(), _bnd_elems.end(), p);
}

bndElemsEnd()

MooseMesh::bnd_elem_iterator MooseMesh::bndElemsEnd ( )

virtualinherited

Definition at line 879 of file MooseMesh.C.

Referenced by MooseMesh::getBoundaryElementRange(), and MeshSideSet::modify().

{
  Predicates::NotNull<bnd_elem_iterator_imp> p;
  return bnd_elem_iterator(_bnd_elems.end(), _bnd_elems.end(), p);
}

bndNodesBegin()

MooseMesh::bnd_node_iterator MooseMesh::bndNodesBegin ( )

virtualinherited

Return iterators to the beginning/end of the boundary nodes list.

Definition at line 855 of file MooseMesh.C.

Referenced by MooseMesh::getBoundaryNodeRange().

{
  Predicates::NotNull<bnd_node_iterator_imp> p;
  return bnd_node_iterator(_bnd_nodes.begin(), _bnd_nodes.end(), p);
}

bndNodesEnd()

MooseMesh::bnd_node_iterator MooseMesh::bndNodesEnd ( )

virtualinherited

Definition at line 863 of file MooseMesh.C.

Referenced by MooseMesh::getBoundaryNodeRange().

{
  Predicates::NotNull<bnd_node_iterator_imp> p;
  return bnd_node_iterator(_bnd_nodes.end(), _bnd_nodes.end(), p);
}

buildBndElemList()

void MooseMesh::buildBndElemList ( )

inherited

Definition at line 668 of file MooseMesh.C.

Referenced by MeshSideSet::modify(), and MooseMesh::update().

{
  TIME_SECTION(_build_bnd_elem_list_timer);

  freeBndElems();

  auto bc_tuples = getMesh().get_boundary_info().build_active_side_list();

  int n = bc_tuples.size();
  _bnd_elems.clear();
  _bnd_elems.reserve(n);
  for (const auto & t : bc_tuples)
  {
    auto elem_id = std::get<0>(t);
    auto side_id = std::get<1>(t);
    auto bc_id = std::get<2>(t);

    _bnd_elems.push_back(new BndElement(getMesh().elem_ptr(elem_id), side_id, bc_id));
    _bnd_elem_ids[bc_id].insert(elem_id);
  }
}

buildMesh()

void AnnularMesh::buildMesh ( )

overridevirtual

Must be overridden by child classes.

This is where the Mesh object is actually created and filled in.

Implements MooseMesh.

Definition at line 140 of file AnnularMesh.C.

{
  const Real dt = (_tmax - _tmin) / _nt;

  MeshBase & mesh = getMesh();
  mesh.clear();
  mesh.set_mesh_dimension(2);
  mesh.set_spatial_dimension(2);
  BoundaryInfo & boundary_info = mesh.get_boundary_info();

  const unsigned num_angular_nodes = (_full_annulus ? _nt : _nt + 1);
  const unsigned num_nodes =
      (_rmin > 0.0 ? (_nr + 1) * num_angular_nodes : _nr * num_angular_nodes + 1);
  const unsigned min_nonzero_layer_num = (_rmin > 0.0 ? 0 : 1);
  std::vector<Node *> nodes(num_nodes);
  unsigned node_id = 0;

  // add nodes at rmax that aren't yet connected to any elements
  Real current_r = _rmax;
  for (unsigned angle_num = 0; angle_num < num_angular_nodes; ++angle_num)
  {
    const Real angle = _tmin + angle_num * dt;
    const Real x = current_r * std::cos(angle);
    const Real y = current_r * std::sin(angle);
    nodes[node_id] = mesh.add_point(Point(x, y, 0.0), node_id);
    node_id++;
  }

  // add nodes at smaller radii, and connect them with elements
  for (unsigned layer_num = _nr; layer_num > min_nonzero_layer_num; --layer_num)
  {
    if (layer_num == 1)
      current_r = _rmin; // account for precision loss
    else
      current_r -= _len * std::pow(_growth_r, layer_num - 1);

    // add node at angle = _tmin
    nodes[node_id] = mesh.add_point(
        Point(current_r * std::cos(_tmin), current_r * std::sin(_tmin), 0.0), node_id);
    node_id++;
    for (unsigned angle_num = 1; angle_num < num_angular_nodes; ++angle_num)
    {
      const Real angle = _tmin + angle_num * dt;
      const Real x = current_r * std::cos(angle);
      const Real y = current_r * std::sin(angle);
      nodes[node_id] = mesh.add_point(Point(x, y, 0.0), node_id);
      Elem * elem = mesh.add_elem(new Quad4);
      elem->set_node(0) = nodes[node_id];
      elem->set_node(1) = nodes[node_id - 1];
      elem->set_node(2) = nodes[node_id - num_angular_nodes - 1];
      elem->set_node(3) = nodes[node_id - num_angular_nodes];
      elem->subdomain_id() = _quad_subdomain_id;
      node_id++;

      if (layer_num == _nr)
        // add outer boundary (boundary_id = 1)
        boundary_info.add_side(elem, 2, 1);
      if (layer_num == 1)
        // add inner boundary (boundary_id = 0)
        boundary_info.add_side(elem, 0, 0);
      if (!_full_annulus && angle_num == 1)
        // add tmin boundary (boundary_id = 2)
        boundary_info.add_side(elem, 1, 2);
      if (!_full_annulus && angle_num == num_angular_nodes - 1)
        // add tmin boundary (boundary_id = 3)
        boundary_info.add_side(elem, 3, 3);
    }
    if (_full_annulus)
    {
      // add element connecting to node at angle=0
      Elem * elem = mesh.add_elem(new Quad4);
      elem->set_node(0) = nodes[node_id - num_angular_nodes];
      elem->set_node(1) = nodes[node_id - 1];
      elem->set_node(2) = nodes[node_id - num_angular_nodes - 1];
      elem->set_node(3) = nodes[node_id - 2 * num_angular_nodes];
      elem->subdomain_id() = _quad_subdomain_id;

      if (layer_num == _nr)
        // add outer boundary (boundary_id = 1)
        boundary_info.add_side(elem, 2, 1);
      if (layer_num == 1)
        // add inner boundary (boundary_id = 0)
        boundary_info.add_side(elem, 0, 0);
    }
  }

  // add single node at origin, if relevant
  if (_rmin == 0.0)
  {
    nodes[node_id] = mesh.add_point(Point(0.0, 0.0, 0.0), node_id);
    boundary_info.add_node(node_id, 0); // boundary_id=0 is centre
    for (unsigned angle_num = 0; angle_num < num_angular_nodes - 1; ++angle_num)
    {
      Elem * elem = mesh.add_elem(new Tri3);
      elem->set_node(0) = nodes[node_id];
      elem->set_node(1) = nodes[node_id - num_angular_nodes + angle_num];
      elem->set_node(2) = nodes[node_id - num_angular_nodes + angle_num + 1];
      elem->subdomain_id() = _tri_subdomain_id;
    }
    if (_full_annulus)
    {
      Elem * elem = mesh.add_elem(new Tri3);
      elem->set_node(0) = nodes[node_id];
      elem->set_node(1) = nodes[node_id - 1];
      elem->set_node(2) = nodes[node_id - num_angular_nodes];
      elem->subdomain_id() = _tri_subdomain_id;
    }
  }

  boundary_info.sideset_name(0) = "rmin";
  boundary_info.sideset_name(1) = "rmax";
  boundary_info.nodeset_name(0) = "rmin";
  boundary_info.nodeset_name(1) = "rmax";
  if (!_full_annulus)
  {
    boundary_info.sideset_name(2) = "tmin";
    boundary_info.sideset_name(3) = "tmax";
    boundary_info.nodeset_name(2) = "tmin";
    boundary_info.nodeset_name(3) = "tmax";
  }

  mesh.prepare_for_use(false);
}

buildMeshBaseObject()

std::unique_ptr< MeshBase > MooseMesh::buildMeshBaseObject ( ParallelType  override_type = ParallelType::DEFAULT )

inherited

Method to construct a libMesh::MeshBase object that is normally set and used by the MooseMesh object during the "init()" phase.

Definition at line 1964 of file MooseMesh.C.

Referenced by MooseMesh::init().

{
  switch (_parallel_type)
  {
    case ParallelType::DEFAULT:
      // The user did not specify 'parallel_type = XYZ' in the input file,
      // so we allow the --distributed-mesh command line arg to possibly turn
      // on DistributedMesh.  If the command line arg is not present, we pick ReplicatedMesh.
      if (_app.getDistributedMeshOnCommandLine())
        _use_distributed_mesh = true;
      break;
    case ParallelType::REPLICATED:
      if (_app.getDistributedMeshOnCommandLine() || _is_nemesis || _app.isUseSplit())
        _parallel_type_overridden = true;
      break;
    case ParallelType::DISTRIBUTED:
      _use_distributed_mesh = true;
      break;
  }

  // If the user specifies 'nemesis = true' in the Mesh block, or they are using --use-split,
  // we must use DistributedMesh.
  if (_is_nemesis || _app.isUseSplit())
    _use_distributed_mesh = true;

  unsigned dim = getParam<MooseEnum>("dim");

  std::unique_ptr<MeshBase> mesh;
  if (_use_distributed_mesh)
  {
    if (override_type == ParallelType::REPLICATED)
      mooseError("The requested override_type of \"Replicated\" may not be used when MOOSE is "
                 "running with a DistributedMesh");

    mesh = libmesh_make_unique<DistributedMesh>(_communicator, dim);
    if (_partitioner_name != "default" && _partitioner_name != "parmetis")
    {
      _partitioner_name = "parmetis";
      _partitioner_overridden = true;
    }
  }
  else
  {
    if (override_type == ParallelType::DISTRIBUTED)
      mooseError("The requested override_type of \"Distributed\" may not be used when MOOSE is "
                 "running with a ReplicatedMesh");

    mesh = libmesh_make_unique<ReplicatedMesh>(_communicator, dim);
  }

  if (!getParam<bool>("allow_renumbering"))
    mesh->allow_renumbering(false);

  return mesh;
}

buildNodeList()

void MooseMesh::buildNodeList ( )

inherited

Calls BoundaryInfo::build_node_list()/build_side_list() and makes separate copies of Nodes/Elems in those lists.

Allocates memory which is cleaned up in the freeBndNodes()/freeBndElems() functions.

Definition at line 634 of file MooseMesh.C.

Referenced by MooseMesh::update().

{
  TIME_SECTION(_build_node_list_timer);

  freeBndNodes();

  auto bc_tuples = getMesh().get_boundary_info().build_node_list();

  int n = bc_tuples.size();
  _bnd_nodes.clear();
  _bnd_nodes.reserve(n);
  for (const auto & t : bc_tuples)
  {
    auto node_id = std::get<0>(t);
    auto bc_id = std::get<1>(t);

    _bnd_nodes.push_back(new BndNode(getMesh().node_ptr(node_id), bc_id));
    _node_set_nodes[bc_id].push_back(node_id);
    _bnd_node_ids[bc_id].insert(node_id);
  }

  _bnd_nodes.reserve(_bnd_nodes.size() + _extra_bnd_nodes.size());
  for (unsigned int i = 0; i < _extra_bnd_nodes.size(); i++)
  {
    BndNode * bnode = new BndNode(_extra_bnd_nodes[i]._node, _extra_bnd_nodes[i]._bnd_id);
    _bnd_nodes.push_back(bnode);
    _bnd_node_ids[std::get<1>(bc_tuples[i])].insert(_extra_bnd_nodes[i]._node->id());
  }

  // This sort is here so that boundary conditions are always applied in the same order
  std::sort(_bnd_nodes.begin(), _bnd_nodes.end(), BndNodeCompare());
}

buildNodeListFromSideList()

void MooseMesh::buildNodeListFromSideList ( )

inherited

Calls BoundaryInfo::build_node_list_from_side_list().

Definition at line 2162 of file MooseMesh.C.

Referenced by MooseMesh::prepare(), and MooseMesh::update().

{
  if (_construct_node_list_from_side_list)
    getMesh().get_boundary_info().build_node_list_from_side_list();
}

buildPeriodicNodeMap()

void MooseMesh::buildPeriodicNodeMap ( std::multimap< dof_id_type, dof_id_type > &  periodic_node_map, unsigned int  var_number, PeriodicBoundaries *  pbs  ) const

inherited

This routine builds a multimap of boundary ids to matching boundary ids across all periodic boundaries in the system.

Definition at line 1166 of file MooseMesh.C.

{
  TIME_SECTION(_build_periodic_node_map_timer);

  // clear existing map
  periodic_node_map.clear();

  // get periodic nodes
  std::vector<PeriodicNodeInfo> periodic_nodes;
  for (const auto & t : getMesh().get_boundary_info().build_node_list())
  {
    // unfortunately libMesh does not give us a pointer, so we have to look it up ourselves
    auto node = _mesh->node_ptr(std::get<0>(t));
    mooseAssert(node != nullptr,
                "libMesh::BoundaryInfo::build_node_list() returned an ID for a non-existing node");
    auto bc_id = std::get<1>(t);
    periodic_nodes.emplace_back(node, bc_id);
  }

  // sort by boundary id
  std::sort(periodic_nodes.begin(),
            periodic_nodes.end(),
            [](const PeriodicNodeInfo & a, const PeriodicNodeInfo & b) -> bool {
              return a.second > b.second;
            });

  // build kd-tree
  using KDTreeType = nanoflann::KDTreeSingleIndexAdaptor<
      nanoflann::L2_Simple_Adaptor<Real, PointListAdaptor<PeriodicNodeInfo>>,
      PointListAdaptor<PeriodicNodeInfo>,
      LIBMESH_DIM>;
  const unsigned int max_leaf_size = 20; // slightly affects runtime
  auto point_list =
      PointListAdaptor<PeriodicNodeInfo>(periodic_nodes.begin(), periodic_nodes.end());
  auto kd_tree = libmesh_make_unique<KDTreeType>(
      LIBMESH_DIM, point_list, nanoflann::KDTreeSingleIndexAdaptorParams(max_leaf_size));
  mooseAssert(kd_tree != nullptr, "KDTree was not properly initialized.");
  kd_tree->buildIndex();

  // data structures for kd-tree search
  nanoflann::SearchParams search_params;
  std::vector<std::pair<std::size_t, Real>> ret_matches;

  // iterate over periodic nodes (boundary ids are in contiguous blocks)
  PeriodicBoundaryBase * periodic = nullptr;
  BoundaryID current_bc_id = BoundaryInfo::invalid_id;
  for (auto & pair : periodic_nodes)
  {
    // entering a new block of boundary IDs
    if (pair.second != current_bc_id)
    {
      current_bc_id = pair.second;
      periodic = pbs->boundary(current_bc_id);
      if (periodic && !periodic->is_my_variable(var_number))
        periodic = nullptr;
    }

    // variable is not periodic at this node, skip
    if (!periodic)
      continue;

    // clear result buffer
    ret_matches.clear();

    // id of the current node
    const auto id = pair.first->id();

    // position where we expect a periodic partner for the current node and boundary
    Point search_point = periodic->get_corresponding_pos(*pair.first);

    // search at the expected point
    kd_tree->radiusSearch(&(search_point)(0), libMesh::TOLERANCE, ret_matches, search_params);
    for (auto & match_pair : ret_matches)
    {
      const auto & match = periodic_nodes[match_pair.first];
      // add matched node if the boundary id is the corresponding id in the periodic pair
      if (match.second == periodic->pairedboundary)
        periodic_node_map.emplace(id, match.first->id());
    }
  }
}

buildPeriodicNodeSets()

void MooseMesh::buildPeriodicNodeSets ( std::map< BoundaryID, std::set< dof_id_type >> &  periodic_node_sets, unsigned int  var_number, PeriodicBoundaries *  pbs  ) const

inherited

This routine builds a datastructure of node ids organized by periodic boundary ids.

Definition at line 1251 of file MooseMesh.C.

{
  TIME_SECTION(_build_periodic_node_sets_timer);

  periodic_node_sets.clear();

  // Loop over all the boundary nodes adding the periodic nodes to the appropriate set
  for (const auto & t : getMesh().get_boundary_info().build_node_list())
  {
    auto node_id = std::get<0>(t);
    auto bc_id = std::get<1>(t);

    // Is this current node on a known periodic boundary?
    if (periodic_node_sets.find(bc_id) != periodic_node_sets.end())
      periodic_node_sets[bc_id].insert(node_id);
    else // This still might be a periodic node but we just haven't seen this boundary_id yet
    {
      const PeriodicBoundaryBase * periodic = pbs->boundary(bc_id);
      if (periodic && periodic->is_my_variable(var_number))
        periodic_node_sets[bc_id].insert(node_id);
    }
  }
}

buildRefinementAndCoarseningMaps()

void MooseMesh::buildRefinementAndCoarseningMaps ( Assembly *  assembly )

inherited

Create the refinement and coarsening maps necessary for projection of stateful material properties when using adaptivity.

Parameters

assembly

Pointer to the Assembly object for this Mesh.

Definition at line 1560 of file MooseMesh.C.

Referenced by FEProblemBase::initialSetup().

{
  TIME_SECTION(_build_refinement_and_coarsening_maps_timer);

  std::map<ElemType, Elem *> canonical_elems;

  // First, loop over all elements and find a canonical element for each type
  // Doing it this way guarantees that this is going to work in parallel
  for (const auto & elem : getMesh().element_ptr_range()) // TODO: Thread this
  {
    ElemType type = elem->type();

    if (canonical_elems.find(type) ==
        canonical_elems.end()) // If we haven't seen this type of elem before save it
      canonical_elems[type] = elem;
    else
    {
      Elem * stored = canonical_elems[type];
      if (elem->id() < stored->id()) // Arbitrarily keep the one with a lower id
        canonical_elems[type] = elem;
    }
  }
  // Now build the maps using these templates
  // Note: This MUST be done NOT threaded!
  for (const auto & can_it : canonical_elems)
  {
    Elem * elem = can_it.second;

    // Need to do this just once to get the right qrules put in place
    assembly->setCurrentSubdomainID(elem->subdomain_id());
    assembly->reinit(elem);
    assembly->reinit(elem, 0);
    QBase * qrule = assembly->qRule();
    QBase * qrule_face = assembly->qRuleFace();

    // Volume to volume projection for refinement
    buildRefinementMap(*elem, *qrule, *qrule_face, -1, -1, -1);

    // Volume to volume projection for coarsening
    buildCoarseningMap(*elem, *qrule, *qrule_face, -1);

    // Map the sides of children
    for (unsigned int side = 0; side < elem->n_sides(); side++)
    {
      // Side to side for sides that match parent's sides
      buildRefinementMap(*elem, *qrule, *qrule_face, side, -1, side);
      buildCoarseningMap(*elem, *qrule, *qrule_face, side);
    }

    // Child side to parent volume mapping for "internal" child sides
    for (unsigned int child = 0; child < elem->n_children(); ++child)
      for (unsigned int side = 0; side < elem->n_sides();
           ++side)                                // Assume children have the same number of sides!
        if (!elem->is_child_on_side(child, side)) // Otherwise we already computed that map
          buildRefinementMap(*elem, *qrule, *qrule_face, -1, child, side);
  }
}

buildSideList() [1/2]

void MooseMesh::buildSideList ( std::vector< dof_id_type > &  el, std::vector< unsigned short int > &  sl, std::vector< boundary_id_type > &  il  )

inherited

Calls BoundaryInfo::build_side_list().

Fills in the three passed vectors with list logical (element, side, id) tuples. This function will eventually be deprecated in favor of the one below, which returns a single std::vector of (elem-id, side-id, bc-id) tuples instead.

Definition at line 2169 of file MooseMesh.C.

Referenced by PenetrationLocator::detectPenetration().

{
#ifdef LIBMESH_ENABLE_DEPRECATED
  mooseDeprecated("The version of MooseMesh::buildSideList() taking three arguments is "
                  "deprecated, call the version that returns a vector of tuples instead.");
  getMesh().get_boundary_info().build_side_list(el, sl, il);
#else
  libmesh_ignore(el);
  libmesh_ignore(sl);
  libmesh_ignore(il);
  mooseError("The version of MooseMesh::buildSideList() taking three "
             "arguments is not available in your version of libmesh, call the "
             "version that returns a vector of tuples instead.");
#endif
}

buildSideList() [2/2]

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > > MooseMesh::buildSideList ( )

inherited

As above, but uses the non-deprecated std::tuple interface.

Definition at line 2188 of file MooseMesh.C.

{
  return getMesh().get_boundary_info().build_side_list();
}

cacheChangedLists()

void MooseMesh::cacheChangedLists ( )

inherited

Cache information about what elements were refined and coarsened in the previous step.

Definition at line 522 of file MooseMesh.C.

Referenced by FEProblemBase::meshChangedHelper().

{
  TIME_SECTION(_cache_changed_lists_timer);

  ConstElemRange elem_range(getMesh().local_elements_begin(), getMesh().local_elements_end(), 1);
  CacheChangedListsThread cclt(*this);
  Threads::parallel_reduce(elem_range, cclt);

  _coarsened_element_children.clear();

  _refined_elements = libmesh_make_unique<ConstElemPointerRange>(cclt._refined_elements.begin(),
                                                                 cclt._refined_elements.end());
  _coarsened_elements = libmesh_make_unique<ConstElemPointerRange>(cclt._coarsened_elements.begin(),
                                                                   cclt._coarsened_elements.end());
  _coarsened_element_children = cclt._coarsened_element_children;
}

cacheInfo()

void MooseMesh::cacheInfo ( )

protectedinherited

Definition at line 815 of file MooseMesh.C.

Referenced by MooseMesh::update().

{
  TIME_SECTION(_cache_info_timer);

  // TODO: Thread this!
  for (const auto & elem : getMesh().element_ptr_range())
  {
    SubdomainID subdomain_id = elem->subdomain_id();

    for (unsigned int side = 0; side < elem->n_sides(); side++)
    {
      std::vector<BoundaryID> boundaryids = getBoundaryIDs(elem, side);

      std::set<BoundaryID> & subdomain_set = _subdomain_boundary_ids[subdomain_id];

      subdomain_set.insert(boundaryids.begin(), boundaryids.end());
    }

    for (unsigned int nd = 0; nd < elem->n_nodes(); ++nd)
    {
      Node & node = *elem->node_ptr(nd);
      _block_node_list[node.id()].insert(elem->subdomain_id());
    }
  }
}

changeBoundaryId()

void MooseMesh::changeBoundaryId ( const boundary_id_type  old_id, const boundary_id_type  new_id, bool  delete_prev  )

inherited

Change all the boundary IDs for a given side from old_id to new_id.

If delete_prev is true, also actually remove the side with old_id from the BoundaryInfo object.

Definition at line 1906 of file MooseMesh.C.

Referenced by MeshExtruder::changeID().

{
  TIME_SECTION(_change_boundary_id_timer);

  // Get a reference to our BoundaryInfo object, we will use it several times below...
  BoundaryInfo & boundary_info = getMesh().get_boundary_info();

  // Container to catch ids passed back from BoundaryInfo
  std::vector<boundary_id_type> old_ids;

  // Only level-0 elements store BCs.  Loop over them.
  for (auto & elem : as_range(getMesh().level_elements_begin(0), getMesh().level_elements_end(0)))
  {
    unsigned int n_sides = elem->n_sides();
    for (unsigned int s = 0; s != n_sides; ++s)
    {
      boundary_info.boundary_ids(elem, s, old_ids);
      if (std::find(old_ids.begin(), old_ids.end(), old_id) != old_ids.end())
      {
        std::vector<boundary_id_type> new_ids(old_ids);
        std::replace(new_ids.begin(), new_ids.end(), old_id, new_id);
        if (delete_prev)
        {
          boundary_info.remove_side(elem, s);
          boundary_info.add_side(elem, s, new_ids);
        }
        else
          boundary_info.add_side(elem, s, new_ids);
      }
    }
  }

  // Remove any remaining references to the old ID from the
  // BoundaryInfo object.  This prevents things like empty sidesets
  // from showing up when printing information, etc.
  if (delete_prev)
    boundary_info.remove_id(old_id);
}

clearQuadratureNodes()

void MooseMesh::clearQuadratureNodes ( )

inherited

Clear out any existing quadrature nodes.

Most likely called before re-adding them.

Definition at line 990 of file MooseMesh.C.

Referenced by GeometricSearchData::reinit(), and MooseMesh::~MooseMesh().

{
  // Delete all the quadrature nodes
  for (auto & it : _quadrature_nodes)
    delete it.second;

  _quadrature_nodes.clear();
  _elem_to_side_to_qp_to_quadrature_nodes.clear();
  _extra_bnd_nodes.clear();
}

clone()

MooseMesh & MooseMesh::clone ( ) const

virtualinherited

Clone method.

Allocates memory you are responsible to clean up.

Definition at line 1958 of file MooseMesh.C.

Referenced by TiledMesh::buildMesh().

{
  mooseError("MooseMesh::clone() is no longer supported, use MooseMesh::safeClone() instead.");
}

coarsenedElementChildren()

const std::vector< const Elem * > & MooseMesh::coarsenedElementChildren ( const Elem *  elem ) const

inherited

Get the newly removed children element ids for an element that was just coarsened.

Parameters

elem	Pointer to the parent element that was coarsened to.

Returns

The child element ids in Elem::child() order.

Definition at line 552 of file MooseMesh.C.

Referenced by ProjectMaterialProperties::onBoundary(), and ProjectMaterialProperties::onElement().

{
  auto elem_to_child_pair = _coarsened_element_children.find(elem);
  mooseAssert(elem_to_child_pair != _coarsened_element_children.end(), "Missing element in map");
  return elem_to_child_pair->second;
}

coarsenedElementRange()

ConstElemPointerRange * MooseMesh::coarsenedElementRange ( ) const

inherited

Return a range that is suitable for threaded execution over elements that were just coarsened.

Note that these are the Parent elements that are now set to be INACTIVE. Their children are the elements that were just removed. Use coarsenedElementChildren() to get the element IDs for the children that were just removed for a particular parent element.

Definition at line 546 of file MooseMesh.C.

Referenced by FEProblemBase::meshChangedHelper().

{
  return _coarsened_elements.get();
}

declareRecoverableData() [1/2]

template<typename T >

T & Restartable::declareRecoverableData ( std::string  data_name )

protectedinherited

Declare a piece of data as "recoverable".

This means that in the event of a recovery this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 269 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;

  registerRecoverableDataOnApp(full_name);

  return declareRestartableDataWithContext<T>(data_name, nullptr);
}

declareRecoverableData() [2/2]

template<typename T >

T & Restartable::declareRecoverableData ( std::string  data_name, const T &  init_value  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
init_value	The initial value of the data

Definition at line 280 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;

  registerRecoverableDataOnApp(full_name);

  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
}

declareRestartableData() [1/2]

template<typename T >

T & Restartable::declareRestartableData ( std::string  data_name )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 202 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr);
}

declareRestartableData() [2/2]

template<typename T >

T & Restartable::declareRestartableData ( std::string  data_name, const T &  init_value  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
init_value	The initial value of the data

Definition at line 209 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
}

declareRestartableDataWithContext() [1/2]

template<typename T >

T & Restartable::declareRestartableDataWithContext ( std::string  data_name, void *  context  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions

Definition at line 216 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
  T & restartable_data_ref = data_ptr->get();

  registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid);

  return restartable_data_ref;
}

declareRestartableDataWithContext() [2/2]

template<typename T >

T & Restartable::declareRestartableDataWithContext ( std::string  data_name, const T &  init_value, void *  context  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
init_value	The initial value of the data
context	Context pointer that will be passed to the load and store functions

Definition at line 229 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
  data_ptr->set() = init_value;

  T & restartable_data_ref = data_ptr->get();
  registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid);

  return restartable_data_ref;
}

declareRestartableDataWithObjectName()

template<typename T >

T & Restartable::declareRestartableDataWithObjectName ( std::string  data_name, std::string  object_name  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.

Definition at line 245 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(data_name, object_name, nullptr);
}

declareRestartableDataWithObjectNameWithContext()

template<typename T >

T & Restartable::declareRestartableDataWithObjectNameWithContext ( std::string  data_name, std::string  object_name, void *  context  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
context	Context pointer that will be passed to the load and store functions

Definition at line 252 of file Restartable.h.

{
  std::string old_name = _restartable_name;

  _restartable_name = object_name;

  T & value = declareRestartableDataWithContext<T>(data_name, context);

  _restartable_name = old_name;

  return value;
}

detectOrthogonalDimRanges()

bool MooseMesh::detectOrthogonalDimRanges ( Real  tol = 1e-6 )

inherited

This routine determines whether the Mesh is a regular orthogonal mesh (i.e.

square in 2D, cubic in 3D). If it is, then we can use a number of convenience functions when periodic boundary conditions are applied. This routine populates the _range vector which is necessary for these convenience functions.

Note: This routine can potentially identify meshes with concave faces that still "fit" in the convex hull of the corresponding regular orthogonal mesh. This case is highly unlikely in practice and if a user does this, well.... release the kicker!

Definition at line 1278 of file MooseMesh.C.

Referenced by AddPeriodicBCAction::autoTranslationBoundaries(), and MooseMesh::prepare().

{
  TIME_SECTION(_detect_orthogonal_dim_ranges_timer);

  if (_regular_orthogonal_mesh)
    return true;

  std::vector<Real> min(3, std::numeric_limits<Real>::max());
  std::vector<Real> max(3, std::numeric_limits<Real>::min());
  unsigned int dim = getMesh().mesh_dimension();

  // Find the bounding box of our mesh
  for (const auto & node : getMesh().node_ptr_range())
    // Check all coordinates, we don't know if this mesh might be lying in a higher dim even if the
    // mesh dimension is lower.
    for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
    {
      if ((*node)(i) < min[i])
        min[i] = (*node)(i);
      if ((*node)(i) > max[i])
        max[i] = (*node)(i);
    }

  this->comm().max(max);
  this->comm().min(min);

  _extreme_nodes.resize(8); // 2^LIBMESH_DIM
  // Now make sure that there are actual nodes at all of the extremes
  std::vector<bool> extreme_matches(8, false);
  std::vector<unsigned int> comp_map(3);
  for (const auto & node : getMesh().node_ptr_range())
  {
    // See if the current node is located at one of the extremes
    unsigned int coord_match = 0;

    for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
    {
      if (std::abs((*node)(i)-min[i]) < tol)
      {
        comp_map[i] = MIN;
        ++coord_match;
      }
      else if (std::abs((*node)(i)-max[i]) < tol)
      {
        comp_map[i] = MAX;
        ++coord_match;
      }
    }

    if (coord_match == LIBMESH_DIM) // Found a coordinate at one of the extremes
    {
      _extreme_nodes[comp_map[X] * 4 + comp_map[Y] * 2 + comp_map[Z]] = node;
      extreme_matches[comp_map[X] * 4 + comp_map[Y] * 2 + comp_map[Z]] = true;
    }
  }

  // See if we matched all of the extremes for the mesh dimension
  this->comm().max(extreme_matches);
  if (std::count(extreme_matches.begin(), extreme_matches.end(), true) == (1 << dim))
    _regular_orthogonal_mesh = true;

  // Set the bounds
  _bounds.resize(LIBMESH_DIM);
  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
  {
    _bounds[i].resize(2);
    _bounds[i][MIN] = min[i];
    _bounds[i][MAX] = max[i];
  }

  return _regular_orthogonal_mesh;
}

dimension()

unsigned int MooseMesh::dimension ( ) const

virtualinherited

Returns MeshBase::mesh_dimsension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh mesh object.

Definition at line 2128 of file MooseMesh.C.

Referenced by MooseMesh::addPeriodicVariable(), AddPeriodicBCAction::autoTranslationBoundaries(), FunctionPeriodicBoundary::FunctionPeriodicBoundary(), MooseMesh::getPairedBoundaryMapping(), MooseMesh::isTranslatedPeriodic(), MooseMesh::minPeriodicVector(), AddExtraNodeset::modify(), MooseVariableFE< Real >::MooseVariableFE(), PenetrationLocator::PenetrationLocator(), AddSideSetsBase::setup(), SolutionFunction::SolutionFunction(), and Moose::PetscSupport::storePetscOptions().

{
  return getMesh().mesh_dimension();
}

dimensionWidth()

Real MooseMesh::dimensionWidth ( unsigned int  component ) const

inherited

Returns the width of the requested dimension.

Definition at line 1455 of file MooseMesh.C.

Referenced by MooseMesh::addPeriodicVariable(), AddPeriodicBCAction::autoTranslationBoundaries(), and MooseMesh::effectiveSpatialDimension().

{
  return getMaxInDimension(component) - getMinInDimension(component);
}

effectiveSpatialDimension()

unsigned int MooseMesh::effectiveSpatialDimension ( ) const

virtualinherited

Returns the effective spatial dimension determined by the coordinates actually used by the mesh.

This means that a 1D mesh that has non-zero z or y coordinates is actually a 2D or 3D mesh, respectively. Likewise a 2D mesh that has non-zero z coordinates is actually 3D mesh.

Definition at line 2134 of file MooseMesh.C.

Referenced by Exodus::setOutputDimensionInExodusWriter().

{
  const Real abs_zero = 1e-12;

  // See if the mesh is completely containd in the z and y planes to calculate effective spatial dim
  for (unsigned int dim = LIBMESH_DIM; dim >= 1; --dim)
    if (dimensionWidth(dim - 1) >= abs_zero)
      return dim;

  // If we get here, we have a 1D mesh on the x-axis.
  return 1;
}

elem() [1/2]

Elem * MooseMesh::elem ( const dof_id_type  i )

virtualinherited

Various accessors (pointers/references) for Elem "i".

If the requested elem is a remote element on a distributed mesh, only the query accessors are valid to call, and they return NULL.

Definition at line 2248 of file MooseMesh.C.

Referenced by MooseMesh::addMortarInterface(), MooseMesh::addQuadratureNode(), MooseMesh::buildCoarseningMap(), buildMesh(), RinglebMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), ConcentricCircleMesh::buildMesh(), MooseMesh::buildRefinementAndCoarseningMaps(), MooseMesh::buildRefinementMap(), MooseMesh::cacheInfo(), MooseMesh::changeBoundaryId(), MooseMesh::coarsenedElementChildren(), MooseMesh::detectPairedSidesets(), MooseMesh::findAdaptivityQpMaps(), MooseMesh::getBoundaryIDs(), MooseMesh::getCoarseningMap(), MooseMesh::getQuadratureNode(), MooseMesh::getRefinementMap(), MooseMesh::ghostGhostedBoundaries(), MooseMesh::nodeToActiveSemilocalElemMap(), MooseMesh::nodeToElemMap(), MooseMesh::prepare(), MooseMesh::sideWithBoundaryID(), and MooseMesh::updateActiveSemiLocalNodeRange().

{
  mooseDeprecated("MooseMesh::elem() is deprecated, please use MooseMesh::elemPtr() instead");
  return elemPtr(i);
}

elem() [2/2]

const Elem * MooseMesh::elem ( const dof_id_type  i ) const

virtualinherited

Definition at line 2255 of file MooseMesh.C.

{
  mooseDeprecated("MooseMesh::elem() is deprecated, please use MooseMesh::elemPtr() instead");
  return elemPtr(i);
}

elemPtr() [1/2]

Elem * MooseMesh::elemPtr ( const dof_id_type  i )

virtualinherited

Definition at line 2262 of file MooseMesh.C.

Referenced by FEProblemBase::addGhostedElem(), SystemBase::augmentSendList(), NodalPatchRecovery::compute(), dataLoad(), MooseMesh::elem(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), NearestNodeLocator::findNodes(), NodeElemConstraint::getConnectedDofIndices(), NodeFaceConstraint::getConnectedDofIndices(), FEProblemBase::getDiracElements(), PenetrationThread::getInfoForFacesWithCommonNodes(), DiracKernel::hasPointsOnElem(), SlaveNeighborhoodThread::operator()(), PenetrationThread::operator()(), FEProblemBase::prepare(), FEProblemBase::prepareFace(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemFace(), FEProblemBase::reinitElemPhys(), FEProblemBase::reinitNeighborPhys(), EqualValueEmbeddedConstraint::shouldApply(), and NearestNodeLocator::updatePatch().

{
  return getMesh().elem_ptr(i);
}

elemPtr() [2/2]

const Elem * MooseMesh::elemPtr ( const dof_id_type  i ) const

virtualinherited

Definition at line 2268 of file MooseMesh.C.

{
  return getMesh().elem_ptr(i);
}

enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 96 of file MooseObject.h.

Referenced by EigenKernel::enabled().

{ return _enabled; }

errorIfDistributedMesh()

void MooseMesh::errorIfDistributedMesh ( std::string  name ) const

inherited

Generate a unified error message if the underlying libMesh mesh is a DistributedMesh.

Clients of MooseMesh can use this function to throw an error if they know they don't work with DistributedMesh.

See, for example, the NodalVariableValue class.

Definition at line 2680 of file MooseMesh.C.

Referenced by FEProblemBase::checkProblemIntegrity(), ElementsAlongLine::ElementsAlongLine(), ElementsAlongPlane::ElementsAlongPlane(), IntersectionPointsAlongLine::IntersectionPointsAlongLine(), BreakMeshByBlock::modify(), SideSetsFromPoints::modify(), SideSetsFromNormals::modify(), MeshSideSet::modify(), AddAllSideSetsByNormals::modify(), ParsedAddSideset::modify(), AddSideSetsFromBoundingBox::modify(), MultiAppInterpolationTransfer::MultiAppInterpolationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodeElemConstraint::NodeElemConstraint(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), PatternedMesh::PatternedMesh(), StitchedMesh::StitchedMesh(), and TiledMesh::TiledMesh().

{
  if (_use_distributed_mesh)
    mooseError("Cannot use ",
               name,
               " with DistributedMesh!\n",
               "Consider specifying parallel_type = 'replicated' in your input file\n",
               "to prevent it from being run with DistributedMesh.");
}

exReader()

ExodusII_IO * MooseMesh::exReader ( ) const

virtualinherited

Not implemented – always returns NULL.

Reimplemented in FileMesh.

Definition at line 2576 of file MooseMesh.C.

Referenced by FEProblemBase::initialSetup().

{
  // TODO: Implement or remove
  return nullptr;
}

freeBndElems()

void MooseMesh::freeBndElems ( )

protectedinherited

Definition at line 331 of file MooseMesh.C.

Referenced by MooseMesh::buildBndElemList(), and MooseMesh::~MooseMesh().

{
  // free memory
  for (auto & belem : _bnd_elems)
    delete belem;

  for (auto & it : _bnd_elem_ids)
    it.second.clear();

  _bnd_elem_ids.clear();
}

freeBndNodes()

void MooseMesh::freeBndNodes ( )

protectedinherited

Definition at line 313 of file MooseMesh.C.

Referenced by MooseMesh::buildNodeList(), and MooseMesh::~MooseMesh().

{
  // free memory
  for (auto & bnode : _bnd_nodes)
    delete bnode;

  for (auto & it : _node_set_nodes)
    it.second.clear();

  _node_set_nodes.clear();

  for (auto & it : _bnd_node_ids)
    it.second.clear();

  _bnd_node_ids.clear();
}

getActiveLocalElementRange()

ConstElemRange * MooseMesh::getActiveLocalElementRange ( )

inherited

Return pointers to range objects for various types of ranges (local nodes, boundary elems, etc.).

Definition at line 738 of file MooseMesh.C.

Referenced by NonlinearSystemBase::computeDamping(), AuxiliarySystem::computeElementalVars(), FEProblemBase::computeIndicators(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeMarkers(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjects(), FEProblemBase::createQRules(), LayeredBase::getBounds(), NonlinearSystemBase::init(), FEProblemBase::initialSetup(), MooseMesh::meshChanged(), DOFMapOutput::output(), FEProblemBase::projectSolution(), NonlinearSystemBase::setVariableGlobalDoFs(), PicardSolve::solve(), TransientMultiApp::solveStep(), MooseMesh::updateActiveSemiLocalNodeRange(), Adaptivity::updateErrorVectors(), and SystemBase::zeroVariables().

{
  if (!_active_local_elem_range)
  {
    TIME_SECTION(_get_active_local_element_range_timer);

    _active_local_elem_range = libmesh_make_unique<ConstElemRange>(
        getMesh().active_local_elements_begin(), getMesh().active_local_elements_end(), GRAIN_SIZE);
  }

  return _active_local_elem_range.get();
}

getActiveNodeRange()

NodeRange * MooseMesh::getActiveNodeRange ( )

inherited

Definition at line 752 of file MooseMesh.C.

Referenced by MooseMesh::meshChanged().

{
  if (!_active_node_range)
  {
    TIME_SECTION(_get_active_node_range_timer);

    _active_node_range = libmesh_make_unique<NodeRange>(
        getMesh().active_nodes_begin(), getMesh().active_nodes_end(), GRAIN_SIZE);
  }

  return _active_node_range.get();
}

getActiveSemiLocalNodeRange()

SemiLocalNodeRange * MooseMesh::getActiveSemiLocalNodeRange ( ) const

inherited

Definition at line 766 of file MooseMesh.C.

{
  mooseAssert(_active_semilocal_node_range,
              "_active_semilocal_node_range has not been created yet!");

  return _active_semilocal_node_range.get();
}

getBoundaryElementRange()

ConstBndElemRange * MooseMesh::getBoundaryElementRange ( )

inherited

Definition at line 802 of file MooseMesh.C.

Referenced by AuxiliarySystem::computeElementalVars(), DMMooseGetEmbedding_Private(), GeometricSearchData::generateQuadratureNodes(), MultiAppNearestNodeTransfer::getLocalEntities(), MooseMesh::meshChanged(), and GeometricSearchData::updateQuadratureNodes().

{
  if (!_bnd_elem_range)
  {
    TIME_SECTION(_get_boundary_element_range_timer);
    _bnd_elem_range =
        libmesh_make_unique<ConstBndElemRange>(bndElemsBegin(), bndElemsEnd(), GRAIN_SIZE);
  }

  return _bnd_elem_range.get();
}

getBoundaryID()

BoundaryID MooseMesh::getBoundaryID ( const BoundaryName &  boundary_name ) const

inherited

Get the associated BoundaryID for the boundary name.

Returns

param boundary_name The name of the boundary.

the boundary id from the passed boundary name.

Definition at line 1002 of file MooseMesh.C.

Referenced by AddPeriodicBCAction::act(), MooseMesh::addMortarInterface(), ConstraintWarehouse::addObject(), TiledMesh::buildMesh(), StitchedMesh::buildMesh(), PatternedMesh::buildMesh(), DMSetUp_Moose_Pre(), MultiAppNearestNodeTransfer::getLocalEntities(), GeometricSearchData::getMortarNearestNodeLocator(), GeometricSearchData::getMortarPenetrationLocator(), MultiAppNearestNodeTransfer::getNearestNode(), GeometricSearchData::getNearestNodeLocator(), GeometricSearchData::getPenetrationLocator(), GeometricSearchData::getQuadratureNearestNodeLocator(), GeometricSearchData::getQuadraturePenetrationLocator(), LinearNodalConstraint::LinearNodalConstraint(), BreakBoundaryOnSubdomain::modify(), MeshSideSet::modify(), NodalScalarKernel::NodalScalarKernel(), GeometricSearchData::reinitMortarNodes(), SetupMeshAction::setupMesh(), and EqualValueBoundaryConstraint::updateConstrainedNodes().

{
  if (boundary_name == "ANY_BOUNDARY_ID")
    mooseError("Please use getBoundaryIDs() when passing \"ANY_BOUNDARY_ID\"");

  BoundaryID id = Moose::INVALID_BOUNDARY_ID;
  std::istringstream ss(boundary_name);

  if (!(ss >> id))
    id = getMesh().get_boundary_info().get_id_by_name(boundary_name);

  return id;
}

getBoundaryIDs() [1/3]

std::vector< BoundaryID > MooseMesh::getBoundaryIDs ( const Elem *const  elem, const unsigned short int  side  ) const

inherited

Returns a vector of boundary IDs for the requested element on the requested side.

Definition at line 2148 of file MooseMesh.C.

Referenced by MeshExtruder::changeID(), NonlinearSystemBase::computeJacobianInternal(), BreakMeshByBlockBase::findFreeBoundaryId(), BoundaryRestrictable::hasBoundary(), BoundaryRestrictable::initializeBoundaryRestrictable(), BoundaryRestrictable::meshBoundaryIDs(), BreakBoundaryOnSubdomain::modify(), SideSetsFromNormals::modify(), SideSetsFromPoints::modify(), SideSetsBetweenSubdomains::modify(), AddExtraNodeset::modify(), ElementDeleterBase::modify(), ParsedAddSideset::modify(), SideSetsAroundSubdomain::modify(), BoundingBoxNodeSet::modify(), and AddSideSetsFromBoundingBox::modify().

{
  std::vector<BoundaryID> ids;
  getMesh().get_boundary_info().boundary_ids(elem, side, ids);
  return ids;
}

getBoundaryIDs() [2/3]

const std::set< BoundaryID > & MooseMesh::getBoundaryIDs ( ) const

inherited

Returns a const reference to a set of all user-specified boundary IDs.

On a distributed mesh this will only include boundary IDs which exist on local or ghosted elements; a copy and a call to _communicator.set_union() will be necessary to get the global ID set.

Definition at line 2156 of file MooseMesh.C.

Referenced by MooseMesh::cacheInfo().

{
  return getMesh().get_boundary_info().get_boundary_ids();
}

getBoundaryIDs() [3/3]

std::vector< BoundaryID > MooseMesh::getBoundaryIDs ( const std::vector< BoundaryName > &  boundary_name, bool  generate_unknown = false  ) const

inherited

Get the associated BoundaryID for the boundary names that are passed in.

Returns

param boundary_name The names of the boundaries.

the boundary ids from the passed boundary names.

If the conversion from a name to a number fails, that means that this must be a named boundary. We will look in the complete map for this sideset and create a new name/ID pair if requested.

Definition at line 1017 of file MooseMesh.C.

{
  const BoundaryInfo & boundary_info = getMesh().get_boundary_info();
  const std::map<BoundaryID, std::string> & sideset_map = boundary_info.get_sideset_name_map();
  const std::map<BoundaryID, std::string> & nodeset_map = boundary_info.get_nodeset_name_map();

  std::set<BoundaryID> boundary_ids = boundary_info.get_boundary_ids();

  // On a distributed mesh we may have boundary ids that only exist on
  // other processors.
  if (!this->getMesh().is_replicated())
    _communicator.set_union(boundary_ids);

  BoundaryID max_boundary_id = boundary_ids.empty() ? 0 : *(boundary_ids.rbegin());

  std::vector<BoundaryID> ids(boundary_name.size());
  for (unsigned int i = 0; i < boundary_name.size(); i++)
  {
    if (boundary_name[i] == "ANY_BOUNDARY_ID")
    {
      ids.assign(_mesh_boundary_ids.begin(), _mesh_boundary_ids.end());
      if (i)
        mooseWarning("You passed \"ANY_BOUNDARY_ID\" in addition to other boundary_names.  This "
                     "may be a logic error.");
      break;
    }

    BoundaryID id;
    std::istringstream ss(boundary_name[i]);

    if (!(ss >> id) || !ss.eof())
    {
      if (generate_unknown &&
          !MooseUtils::doesMapContainValue(sideset_map, std::string(boundary_name[i])) &&
          !MooseUtils::doesMapContainValue(nodeset_map, std::string(boundary_name[i])))
        id = ++max_boundary_id;
      else
        id = boundary_info.get_id_by_name(boundary_name[i]);
    }

    ids[i] = id;
  }

  return ids;
}

getBoundaryName()

const std::string & MooseMesh::getBoundaryName ( BoundaryID  boundary_id )

inherited

Return the name of the boundary given the id.

Definition at line 1141 of file MooseMesh.C.

Referenced by MaterialPropertyDebugOutput::printMaterialMap().

{
  BoundaryInfo & boundary_info = getMesh().get_boundary_info();

  std::vector<BoundaryID> side_boundaries;
  boundary_info.build_side_boundary_ids(side_boundaries);

  // We need to figure out if this boundary is a sideset or nodeset
  if (std::find(side_boundaries.begin(), side_boundaries.end(), boundary_id) !=
      side_boundaries.end())
    return boundary_info.get_sideset_name(boundary_id);
  else
    return boundary_info.get_nodeset_name(boundary_id);
}

getBoundaryNodeRange()

ConstBndNodeRange * MooseMesh::getBoundaryNodeRange ( )

inherited

Definition at line 789 of file MooseMesh.C.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), AuxiliarySystem::computeNodalVars(), NonlinearSystemBase::computeResidualInternal(), DMMooseGetEmbedding_Private(), NearestNodeLocator::findNodes(), MultiAppNearestNodeTransfer::getLocalEntities(), MultiAppNearestNodeTransfer::getNearestNode(), MooseMesh::meshChanged(), FEProblemBase::projectSolution(), NonlinearSystemBase::setInitialSolution(), and NearestNodeLocator::updatePatch().

{
  if (!_bnd_node_range)
  {
    TIME_SECTION(_get_boundary_node_range_timer);
    _bnd_node_range =
        libmesh_make_unique<ConstBndNodeRange>(bndNodesBegin(), bndNodesEnd(), GRAIN_SIZE);
  }

  return _bnd_node_range.get();
}

getCheckedPointerParam()

template<typename T >

T MooseObject::getCheckedPointerParam ( const std::string &  name, const std::string &  error_string = ""  ) const

inlineinherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 77 of file MooseObject.h.

  {
    return parameters().getCheckedPointerParam<T>(name, error_string);
  }

getCoarseningMap()

const std::vector< std::pair< unsigned int, QpMap > > & MooseMesh::getCoarseningMap ( const Elem &  elem, int  input_side  )

inherited

Get the coarsening map for a given element type.

This will tell you what quadrature points to copy from and to for stateful material properties on newly created elements from Adaptivity.

Parameters

elem	The element that represents the element type you need the coarsening map for.
input_side	The side to map

Definition at line 1726 of file MooseMesh.C.

Referenced by ProjectMaterialProperties::onBoundary(), and ProjectMaterialProperties::onElement().

{
  std::pair<int, ElemType> the_pair(input_side, elem.type());

  if (_elem_type_to_coarsening_map.find(the_pair) == _elem_type_to_coarsening_map.end())
    mooseError("Could not find a suitable qp refinement map!");

  return _elem_type_to_coarsening_map[the_pair];
}

getFileName()

virtual std::string MooseMesh::getFileName ( ) const

inlinevirtualinherited

Returns the name of the mesh file read to produce this mesh if any or an empty string otherwise.

Reimplemented in FileMesh, and TiledMesh.

Definition at line 852 of file MooseMesh.h.

{ return ""; }

getGhostedBoundaries()

const std::set< unsigned int > & MooseMesh::getGhostedBoundaries ( ) const

inherited

Return a writable reference to the set of ghosted boundary IDs.

Definition at line 2380 of file MooseMesh.C.

{
  return _ghosted_boundaries;
}

getGhostedBoundaryInflation()

const std::vector< Real > & MooseMesh::getGhostedBoundaryInflation ( ) const

inherited

Return a writable reference to the _ghosted_boundaries_inflation vector.

Definition at line 2386 of file MooseMesh.C.

Referenced by NearestNodeLocator::findNodes(), and NearestNodeLocator::updatePatch().

{
  return _ghosted_boundaries_inflation;
}

getGhostingPatchSize()

unsigned int MooseMesh::getGhostingPatchSize ( ) const

inlineinherited

Getter for the ghosting_patch_size parameter.

Definition at line 465 of file MooseMesh.h.

Referenced by NearestNodeLocator::findNodes(), and NearestNodeLocator::updatePatch().

{ return _ghosting_patch_size; };

getInflatedProcessorBoundingBox()

BoundingBox MooseMesh::getInflatedProcessorBoundingBox ( Real  inflation_multiplier = 0.01 ) const

inherited

Get a (slightly inflated) processor bounding box.

Parameters

inflation_multiplier

This amount will be multiplied by the length of the diagonal of the bounding box to find the amount to inflate the bounding box by in all directions.

Definition at line 2539 of file MooseMesh.C.

Referenced by PointSamplerBase::execute().

{
  // Grab a bounding box to speed things up.  Note that
  // local_bounding_box is *not* equivalent to processor_bounding_box
  // with processor_id() except in serial.
  BoundingBox bbox = MeshTools::create_local_bounding_box(getMesh());

  // Inflate the bbox just a bit to deal with roundoff
  // Adding 1% of the diagonal size in each direction on each end
  Real inflation_amount = inflation_multiplier * (bbox.max() - bbox.min()).norm();
  Point inflation(inflation_amount, inflation_amount, inflation_amount);

  bbox.first -= inflation;  // min
  bbox.second += inflation; // max

  return bbox;
}

getLocalNodeRange()

ConstNodeRange * MooseMesh::getLocalNodeRange ( )

inherited

Definition at line 775 of file MooseMesh.C.

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianInternal(), AuxiliarySystem::computeNodalVars(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjects(), NonlinearSystemBase::init(), and MooseMesh::meshChanged().

{
  if (!_local_node_range)
  {
    TIME_SECTION(_get_local_node_range_timer);

    _local_node_range = libmesh_make_unique<ConstNodeRange>(
        getMesh().local_nodes_begin(), getMesh().local_nodes_end(), GRAIN_SIZE);
  }

  return _local_node_range.get();
}

getMaxInDimension()

Real AnnularMesh::getMaxInDimension ( unsigned int  component ) const

overridevirtual

Reimplemented from MooseMesh.

Definition at line 115 of file AnnularMesh.C.

{
  if (_dims_may_have_changed)
    return MooseMesh::getMaxInDimension(component);

  switch (component)
  {
    case 0:
      return _rmax;
    case 1:
      return _rmax;
    case 2:
      return 0.0;
    default:
      mooseError("Invalid component");
  }
}

getMaxLeafSize()

unsigned int MooseMesh::getMaxLeafSize ( ) const

inlineinherited

Getter for the maximum leaf size parameter.

Definition at line 470 of file MooseMesh.h.

Referenced by NearestNodeLocator::findNodes(), and NearestNodeLocator::updatePatch().

{ return _max_leaf_size; };

getMesh() [1/2]

MeshBase & MooseMesh::getMesh ( )

inherited

Accessor for the underlying libMesh Mesh object.

Definition at line 2562 of file MooseMesh.C.

Referenced by MooseMesh::activeLocalElementsBegin(), MooseMesh::activeLocalElementsEnd(), Adaptivity::adaptMesh(), BreakMeshByBlock::addInterfaceBoundary(), MooseMesh::addQuadratureNode(), MooseMesh::addUniqueNode(), GeometricRelationshipManager::attachGeometricFunctorHelper(), RelationshipManager::attachRelationshipManagers(), MooseMesh::buildBndElemList(), TiledMesh::buildMesh(), FileMesh::buildMesh(), buildMesh(), GeneratedMesh::buildMesh(), RinglebMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), DistributedGeneratedMesh::buildMesh(), ConcentricCircleMesh::buildMesh(), StitchedMesh::buildMesh(), PatternedMesh::buildMesh(), ImageMesh::buildMesh2D(), ImageMesh::buildMesh3D(), MooseMesh::buildNodeList(), MooseMesh::buildNodeListFromSideList(), MooseMesh::buildPeriodicNodeMap(), MooseMesh::buildPeriodicNodeSets(), MooseMesh::buildRefinementAndCoarseningMaps(), MooseMesh::buildSideList(), MooseMesh::cacheChangedLists(), MooseMesh::cacheInfo(), MooseMesh::changeBoundaryId(), MeshExtruder::changeID(), FEProblemBase::checkCoordinateSystems(), FEProblemBase::checkProblemIntegrity(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), MooseMesh::detectOrthogonalDimRanges(), MooseMesh::detectPairedSidesets(), MooseMesh::dimension(), DumpObjectsProblem::dumpVariableHelper(), ElementalVariableValue::ElementalVariableValue(), MooseMesh::elemPtr(), NodalNormalsCorner::execute(), MultiAppUserObjectTransfer::execute(), MultiAppInterpolationTransfer::execute(), NodalNormalsPreprocessor::execute(), CentroidMultiApp::fillPositions(), AddSideSetsBase::flood(), MooseMesh::getActiveLocalElementRange(), MooseMesh::getActiveNodeRange(), MooseMesh::getBoundaryID(), MooseMesh::getBoundaryIDs(), MooseMesh::getBoundaryName(), FEProblemBase::getEvaluableElementRange(), MooseMesh::getInflatedProcessorBoundingBox(), MultiAppNearestNodeTransfer::getLocalEntities(), MooseMesh::getLocalNodeRange(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), MultiAppNearestNodeTransfer::getNearestNode(), MooseMesh::getNodeList(), MooseMesh::getPointLocator(), MooseMesh::getSubdomainID(), MooseMesh::getSubdomainIDs(), MooseMesh::getSubdomainName(), MooseMesh::ghostGhostedBoundaries(), UpdateDisplacedMeshThread::init(), MooseMesh::init(), VerifyElementUniqueID::initialize(), VerifyNodalUniqueID::initialize(), OversampleOutput::initOversample(), MooseMesh::localNodesBegin(), MooseMesh::localNodesEnd(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), MooseMesh::maxElemId(), MooseMesh::maxNodeId(), GeometryBase::meshChanged(), Nemesis::meshChanged(), BreakBoundaryOnSubdomain::modify(), BreakMeshByBlock::modify(), SideSetsBetweenSubdomains::modify(), SideSetsFromNormals::modify(), SideSetsFromPoints::modify(), AddExtraNodeset::modify(), MeshExtruder::modify(), MeshSideSet::modify(), LowerDBlockFromSideset::modify(), AssignElementSubdomainID::modify(), SmoothMesh::modify(), AssignSubdomainID::modify(), AddAllSideSetsByNormals::modify(), ElementDeleterBase::modify(), ParsedAddSideset::modify(), SideSetsAroundSubdomain::modify(), ParsedSubdomainMeshModifier::modify(), RenameBlock::modify(), ImageSubdomain::modify(), OrientedSubdomainBoundingBox::modify(), BoundingBoxNodeSet::modify(), AddSideSetsFromBoundingBox::modify(), SubdomainBoundingBox::modify(), MooseMesh::MooseMesh(), MooseMesh::nElem(), MooseMesh::nNodes(), NodalPatchRecovery::NodalPatchRecovery(), NodalVariableValue::NodalVariableValue(), MooseMesh::nodePtr(), MooseMesh::nodeRef(), MooseMesh::nodeToActiveSemilocalElemMap(), MooseMesh::nodeToElemMap(), ComputeNodalUserObjectsThread::onNode(), XDA::output(), ConsoleUtils::outputMeshInformation(), MooseMesh::prepare(), EqualValueEmbeddedConstraint::prepareSlaveToMasterMap(), MooseMesh::printInfo(), MooseMesh::queryElemPtr(), MooseMesh::queryNodePtr(), FileMesh::read(), SubProblem::restrictionBoundaryCheckName(), SubProblem::restrictionSubdomainCheckName(), MooseMesh::setBoundaryName(), NonlinearSystemBase::setConstraintSlaveValues(), XFEMInterface::setDisplacedMesh(), XFEMInterface::setMesh(), Exodus::setOutputDimensionInExodusWriter(), MooseMesh::setSubdomainName(), ImageSampler::setupImageSampler(), SetupMeshAction::setupMesh(), MooseMesh::sideWithBoundaryID(), MultiAppCopyTransfer::transfer(), DisplacedProblem::undisplaceMesh(), MooseMesh::updateActiveSemiLocalNodeRange(), EqualValueBoundaryConstraint::updateConstrainedNodes(), Adaptivity::updateErrorVectors(), RandomData::updateGenerators(), and DisplacedProblem::updateMesh().

{
  mooseAssert(_mesh, "Mesh hasn't been created");
  return *_mesh;
}

getMesh() [2/2]

const MeshBase & MooseMesh::getMesh ( ) const

inherited

Definition at line 2569 of file MooseMesh.C.

{
  mooseAssert(_mesh, "Mesh hasn't been created");
  return *_mesh;
}

getMinInDimension()

Real AnnularMesh::getMinInDimension ( unsigned int  component ) const

overridevirtual

Returns the min or max of the requested dimension respectively.

Reimplemented from MooseMesh.

Definition at line 96 of file AnnularMesh.C.

{
  if (_dims_may_have_changed)
    return MooseMesh::getMinInDimension(component);

  switch (component)
  {
    case 0:
      return -_rmax;
    case 1:
      return -_rmax;
    case 2:
      return 0.0;
    default:
      mooseError("Invalid component");
  }
}

getMooseApp()

MooseApp& MooseObject::getMooseApp ( ) const

inlineinherited

Get the MooseApp this object is associated with.

Definition at line 91 of file MooseObject.h.

Referenced by RestartableDataIO::createBackup(), RestartableDataIO::deserializeRestartableData(), ConsoleUtils::outputMeshInformation(), Resurrector::restartRestartableData(), and RestartableDataIO::restoreBackup().

{ return _app; }

getMortarInterface()

MooseMesh::MortarInterface * MooseMesh::getMortarInterface ( BoundaryID  master, BoundaryID  slave  )

inherited

Definition at line 2701 of file MooseMesh.C.

Referenced by GeometricSearchData::generateMortarNodes().

{
  std::map<std::pair<BoundaryID, BoundaryID>, MortarInterface *>::iterator it =
      _mortar_interface_by_ids.find(std::pair<BoundaryID, BoundaryID>(master, slave));
  if (it != _mortar_interface_by_ids.end())
    return (*it).second;
  else
    mooseError(
        "Requesting non-existing mortar interface (master = ", master, ", slave = ", slave, ").");
}

getMortarInterfaceByName()

MooseMesh::MortarInterface * MooseMesh::getMortarInterfaceByName ( const std::string  name )

inherited

Definition at line 2691 of file MooseMesh.C.

{
  std::map<std::string, MortarInterface *>::iterator it = _mortar_interface_by_name.find(name);
  if (it != _mortar_interface_by_name.end())
    return (*it).second;
  else
    mooseError("Requesting non-existent mortar interface '", name, "'.");
}

getMortarInterfaces()

std::vector<std::unique_ptr<MooseMesh::MortarInterface> >& MooseMesh::getMortarInterfaces ( )

inlineinherited

Definition at line 815 of file MooseMesh.h.

Referenced by FEProblemBase::checkProblemIntegrity(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), GeometricSearchData::reinitMortarNodes(), and GeometricSearchData::updateMortarNodes().

  {
    return _mortar_interface;
  }

getNodeBlockIds()

const std::set< SubdomainID > & MooseMesh::getNodeBlockIds ( const Node &  node ) const

inherited

Return list of blocks to which the given node belongs.

Definition at line 842 of file MooseMesh.C.

Referenced by BreakMeshByBlock::modify(), ComputeNodalUserObjectsThread::onNode(), ComputeNodalAuxVarsThread::onNode(), ComputeNodalKernelsThread::onNode(), ComputeNodalKernelJacobiansThread::onNode(), and TopResidualDebugOutput::printTopResiduals().

{
  std::map<dof_id_type, std::set<SubdomainID>>::const_iterator it =
      _block_node_list.find(node.id());

  if (it == _block_node_list.end())
    mooseError("Unable to find node: ", node.id(), " in any block list.");

  return it->second;
}

getNodeList()

const std::vector< dof_id_type > & MooseMesh::getNodeList ( boundary_id_type  nodeset_id ) const

inherited

Return a writable reference to a vector of node IDs that belong to nodeset_id.

Definition at line 2589 of file MooseMesh.C.

Referenced by LinearNodalConstraint::LinearNodalConstraint(), GeometryBase::meshChanged(), NodalScalarKernel::NodalScalarKernel(), and EqualValueBoundaryConstraint::updateConstrainedNodes().

{
  std::map<boundary_id_type, std::vector<dof_id_type>>::const_iterator it =
      _node_set_nodes.find(nodeset_id);

  if (it == _node_set_nodes.end())
  {
    // On a distributed mesh we might not know about a remote nodeset,
    // so we'll return an empty vector and hope the nodeset exists
    // elsewhere.
    if (!getMesh().is_serial())
    {
      static const std::vector<dof_id_type> empty_vec;
      return empty_vec;
    }
    // On a replicated mesh we should know about every nodeset and if
    // we're asked for one that doesn't exist then it must be a bug.
    else
    {
      mooseError("Unable to nodeset ID: ", nodeset_id, '.');
    }
  }

  return it->second;
}

getNormalByBoundaryID()

const RealVectorValue & MooseMesh::getNormalByBoundaryID ( BoundaryID  id ) const

inherited

Returns the normal vector associated with a given BoundaryID.

It's only valid to call this when AddAllSideSetsByNormals is active.

Definition at line 1948 of file MooseMesh.C.

{
  mooseAssert(_boundary_to_normal_map.get() != nullptr, "Boundary To Normal Map not built!");

  // Note: Boundaries that are not in the map (existing boundaries) will default
  // construct a new RealVectorValue - (x,y,z)=(0, 0, 0)
  return (*_boundary_to_normal_map)[id];
}

getPairedBoundaryMapping()

const std::pair< BoundaryID, BoundaryID > * MooseMesh::getPairedBoundaryMapping ( unsigned int  component )

inherited

This function attempts to return the paired boundary ids for the given component.

For example, in a generated 2D mesh, passing 0 for the "x" component will return (3, 1).

Parameters

component

- An integer representing the desired component (dimension)

Returns

std::pair pointer - The matching boundary pairs for the passed component

Definition at line 1542 of file MooseMesh.C.

Referenced by MooseMesh::addPeriodicVariable(), and AddPeriodicBCAction::autoTranslationBoundaries().

{
  if (!_regular_orthogonal_mesh)
    mooseError("Trying to retrieve automatic paired mapping for a mesh that is not regular and "
               "orthogonal");

  mooseAssert(component < dimension(), "Requested dimension out of bounds");

  if (_paired_boundary.empty())
    detectPairedSidesets();

  if (component < _paired_boundary.size())
    return &_paired_boundary[component];
  else
    return nullptr;
}

getParam()

template<typename T >

const T & MooseObject::getParam ( const std::string &  name ) const

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns

The value of the parameter

Definition at line 188 of file MooseObject.h.

Referenced by FEProblemBase::addMaterialHelper(), ConstraintWarehouse::addObject(), BicubicSplineFunction::BicubicSplineFunction(), Piecewise::buildFromXandY(), MultiApp::createApp(), DerivativeParsedMaterial::DerivativeParsedMaterial(), EigenKernel::EigenKernel(), FEProblemBase::FEProblemBase(), FieldSplitPreconditioner::FieldSplitPreconditioner(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), SideSetsBetweenSubdomainsGenerator::generate(), ExtraNodesetGenerator::generate(), MeshExtruderGenerator::generate(), SideSetsAroundSubdomainGenerator::generate(), GenericConstantRankTwoTensor::GenericConstantRankTwoTensor(), TimeSequenceStepper::init(), AttribThread::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), AdvancedOutput::initialSetup(), SideSetsBetweenSubdomains::modify(), AddExtraNodeset::modify(), MeshExtruder::modify(), SideSetsAroundSubdomain::modify(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterial::ParsedMaterial(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), and VectorOfPostprocessors::VectorOfPostprocessors().

{
  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0));
}

getPatchSize()

unsigned int MooseMesh::getPatchSize ( ) const

inherited

Getter for the patch_size parameter.

Definition at line 2521 of file MooseMesh.C.

Referenced by NearestNodeLocator::findNodes(), and NearestNodeLocator::updatePatch().

{
  return _patch_size;
}

getPatchUpdateStrategy()

const Moose::PatchUpdateType & MooseMesh::getPatchUpdateStrategy ( ) const

inherited

Get the current patch update strategy.

Definition at line 2533 of file MooseMesh.C.

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches().

{
  return _patch_update_strategy;
}

getPointLocator()

std::unique_ptr< PointLocatorBase > MooseMesh::getPointLocator ( ) const

virtualinherited

Proxy function to get a (sub)PointLocator from either the underlying libMesh mesh (default), or to allow derived meshes to return a custom point locator.

Definition at line 2747 of file MooseMesh.C.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), IntersectionPointsAlongLine::execute(), ElementsAlongLine::execute(), FindValueOnLine::initialize(), PointSamplerBase::initialize(), and EqualValueEmbeddedConstraint::prepareSlaveToMasterMap().

{
  return getMesh().sub_point_locator();
}

getQuadratureNode()

Node * MooseMesh::getQuadratureNode ( const Elem *  elem, const unsigned short int  side, const unsigned int  qp  )

inherited

Get a specified quadrature node.

Parameters

elem	The element the quadrature point is on
side	The side the quadrature point is on
qp	The quadrature point number associated with the point

Definition at line 972 of file MooseMesh.C.

Referenced by GapValueAux::computeValue(), NearestNodeDistanceAux::computeValue(), PenetrationAux::computeValue(), MortarConstraint::reinit(), GeometricSearchData::updateMortarNodes(), and GeometricSearchData::updateQuadratureNodes().

{
  mooseAssert(_elem_to_side_to_qp_to_quadrature_nodes.find(elem->id()) !=
                  _elem_to_side_to_qp_to_quadrature_nodes.end(),
              "Elem has no quadrature nodes!");
  mooseAssert(_elem_to_side_to_qp_to_quadrature_nodes[elem->id()].find(side) !=
                  _elem_to_side_to_qp_to_quadrature_nodes[elem->id()].end(),
              "Side has no quadrature nodes!");
  mooseAssert(_elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side].find(qp) !=
                  _elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side].end(),
              "qp not found on side!");

  return _elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side][qp];
}

getRefinementMap()

const std::vector< std::vector< QpMap > > & MooseMesh::getRefinementMap ( const Elem &  elem, int  parent_side, int  child, int  child_side  )

inherited

Get the refinement map for a given element type.

This will tell you what quadrature points to copy from and to for stateful material properties on newly created elements from Adaptivity.

Parameters

elem	The element that represents the element type you need the refinement map for.
parent_side	The side of the parent to map (-1 if not mapping parent sides)
child	The child number (-1 if not mapping child internal sides)
child_side	The side number of the child (-1 if not mapping sides)

TODO: When running with parallel mesh + stateful adaptivty we will need to make sure that each processor has a complete map. This may require parallel communication. This is likely to happen when running on a mixed element mesh.

Definition at line 1662 of file MooseMesh.C.

Referenced by ProjectMaterialProperties::onBoundary(), ProjectMaterialProperties::onElement(), and ProjectMaterialProperties::onInternalSide().

{
  if (child == -1) // Doing volume mapping or parent side mapping
  {
    mooseAssert(parent_side == child_side,
                "Parent side must match child_side if not passing a specific child!");

    std::pair<int, ElemType> the_pair(parent_side, elem.type());

    if (_elem_type_to_refinement_map.find(the_pair) == _elem_type_to_refinement_map.end())
      mooseError("Could not find a suitable qp refinement map!");

    return _elem_type_to_refinement_map[the_pair];
  }
  else // Need to map a child side to parent volume qps
  {
    std::pair<int, int> child_pair(child, child_side);

    if (_elem_type_to_child_side_refinement_map.find(elem.type()) ==
            _elem_type_to_child_side_refinement_map.end() ||
        _elem_type_to_child_side_refinement_map[elem.type()].find(child_pair) ==
            _elem_type_to_child_side_refinement_map[elem.type()].end())
      mooseError("Could not find a suitable qp refinement map!");

    return _elem_type_to_child_side_refinement_map[elem.type()][child_pair];
  }

}

getSubdomainBoundaryIds()

const std::set< BoundaryID > & MooseMesh::getSubdomainBoundaryIds ( SubdomainID  subdomain_id ) const

inherited

Get the list of boundary ids associated with the given subdomain id.

Parameters

subdomain_id

The subdomain ID you want to get the boundary ids for.

Returns

All boundary IDs connected to elements in the give

Definition at line 2616 of file MooseMesh.C.

Referenced by FEProblemBase::prepareMaterials().

{
  std::map<SubdomainID, std::set<BoundaryID>>::const_iterator it =
      _subdomain_boundary_ids.find(subdomain_id);

  if (it == _subdomain_boundary_ids.end())
    mooseError("Unable to find subdomain ID: ", subdomain_id, '.');

  return it->second;
}

getSubdomainID()

SubdomainID MooseMesh::getSubdomainID ( const SubdomainName &  subdomain_name ) const

inherited

Get the associated subdomain ID for the subdomain name.

Parameters

subdomain_name

The name of the subdomain

Returns

The subdomain id from the passed subdomain name.

Definition at line 1070 of file MooseMesh.C.

Referenced by MooseMesh::addMortarInterface(), ConstraintWarehouse::addObject(), and FEProblemBase::setCoordSystem().

{
  if (subdomain_name == "ANY_BLOCK_ID")
    mooseError("Please use getSubdomainIDs() when passing \"ANY_BLOCK_ID\"");

  SubdomainID id = Moose::INVALID_BLOCK_ID;
  std::istringstream ss(subdomain_name);

  if (!(ss >> id) || !ss.eof())
    id = getMesh().get_id_by_name(subdomain_name);

  return id;
}

getSubdomainIDs()

std::vector< SubdomainID > MooseMesh::getSubdomainIDs ( const std::vector< SubdomainName > &  subdomain_name ) const

inherited

Get the associated subdomainIDs for the subdomain names that are passed in.

Parameters

subdomain_name

The names of the subdomains

Returns

The subdomain ids from the passed subdomain name.

Definition at line 1085 of file MooseMesh.C.

Referenced by BlockRestrictable::hasBlocks(), BlockRestrictable::initializeBlockRestrictable(), LayeredBase::LayeredBase(), SideSetsBetweenSubdomains::modify(), SideSetsAroundSubdomain::modify(), RenameBlock::modify(), and LibmeshPartitioner::prepare_blocks_for_subdomain_partitioner().

{
  std::vector<SubdomainID> ids(subdomain_name.size());

  for (unsigned int i = 0; i < subdomain_name.size(); i++)
  {
    if (subdomain_name[i] == "ANY_BLOCK_ID")
    {
      ids.assign(_mesh_subdomains.begin(), _mesh_subdomains.end());
      if (i)
        mooseWarning("You passed \"ANY_BLOCK_ID\" in addition to other block names.  This may be a "
                     "logic error.");
      break;
    }

    SubdomainID id = Moose::INVALID_BLOCK_ID;
    std::istringstream ss(subdomain_name[i]);

    if (!(ss >> id) || !ss.eof())
      id = getMesh().get_id_by_name(subdomain_name[i]);

    ids[i] = id;
  }

  return ids;
}

getSubdomainName()

const std::string & MooseMesh::getSubdomainName ( SubdomainID  subdomain_id )

inherited

Return the name of a block given an id.

Definition at line 1119 of file MooseMesh.C.

Referenced by BreakMeshByBlockBase::generateBoundaryName(), MaterialPropertyDebugOutput::printMaterialMap(), and TopResidualDebugOutput::printTopResiduals().

{
  return getMesh().subdomain_name(subdomain_id);
}

ghostGhostedBoundaries()

void MooseMesh::ghostGhostedBoundaries ( )

inherited

Actually do the ghosting of boundaries that need to be ghosted to this processor.

Definition at line 2450 of file MooseMesh.C.

Referenced by FEProblemBase::ghostGhostedBoundaries(), and SetupMeshAction::setupMesh().

{
  // No need to do this if using a serial mesh
  if (!_use_distributed_mesh)
    return;

  TIME_SECTION(_ghost_ghosted_boundaries_timer);

  DistributedMesh & mesh = dynamic_cast<DistributedMesh &>(getMesh());

  // We would like to clear ghosted elements that were added by
  // previous invocations of this method; however we can't do so
  // simply without also clearing ghosted elements that were added by
  // other code; e.g.  OversampleOutput.  So for now we'll just
  // swallow the inefficiency that can come from leaving unnecessary
  // elements ghosted after AMR.
  //  mesh.clear_extra_ghost_elems();

  std::set<const Elem *, CompareElemsByLevel> boundary_elems_to_ghost;
  std::set<Node *> connected_nodes_to_ghost;

  std::vector<const Elem *> family_tree;

  for (const auto & t : mesh.get_boundary_info().build_side_list())
  {
    auto elem_id = std::get<0>(t);
    auto bc_id = std::get<2>(t);

    if (_ghosted_boundaries.find(bc_id) != _ghosted_boundaries.end())
    {
      Elem * elem = mesh.elem_ptr(elem_id);

#ifdef LIBMESH_ENABLE_AMR
      elem->family_tree(family_tree);
      Elem * parent = elem->parent();
      while (parent)
      {
        family_tree.push_back(parent);
        parent = parent->parent();
      }
#else
      family_tree.clear();
      family_tree.push_back(elem);
#endif
      for (const auto & felem : family_tree)
      {
        boundary_elems_to_ghost.insert(felem);

        // The entries of connected_nodes_to_ghost need to be
        // non-constant, so that they will work in things like
        // UpdateDisplacedMeshThread. The container returned by
        // family_tree contains const Elems even when the Elem
        // it is called on is non-const, so once that interface
        // gets fixed we can remove this const_cast.
        for (unsigned int n = 0; n < felem->n_nodes(); ++n)
          connected_nodes_to_ghost.insert(const_cast<Node *>(felem->node_ptr(n)));
      }
    }
  }

  mesh.comm().allgather_packed_range(&mesh,
                                     connected_nodes_to_ghost.begin(),
                                     connected_nodes_to_ghost.end(),
                                     extra_ghost_elem_inserter<Node>(mesh));
  mesh.comm().allgather_packed_range(&mesh,
                                     boundary_elems_to_ghost.begin(),
                                     boundary_elems_to_ghost.end(),
                                     extra_ghost_elem_inserter<Elem>(mesh));
}

hasSecondOrderElements()

bool MooseMesh::hasSecondOrderElements ( )

inherited

check if the mesh has SECOND order elements

Definition at line 2725 of file MooseMesh.C.

Referenced by Assembly::Assembly().

{
  bool mesh_has_second_order_elements = false;
  for (auto it = activeLocalElementsBegin(), end = activeLocalElementsEnd(); it != end; ++it)
    if ((*it)->default_order() == SECOND)
    {
      mesh_has_second_order_elements = true;
      break;
    }

  // We checked our local elements, so take the max over all processors.
  comm().max(mesh_has_second_order_elements);
  return mesh_has_second_order_elements;
}

init()

void MooseMesh::init ( )

virtualinherited

Initialize the Mesh object.

Most of the time this will turn around and call build_mesh so the child class can build the Mesh object.

However, during Recovery this will read the CPA file...

If the mesh base hasn't been constructed by the time init is called, just do it here. This can happen if somebody builds a mesh outside of the normal Action system. Forcing developers to create, construct the MeshBase, and then init separately is a bit much for casual use but it gives us the ability to run MeshGenerators in-between.

Definition at line 2027 of file MooseMesh.C.

Referenced by GridPartitioner::_do_partition().

{
  if (!_mesh)
    _mesh = buildMeshBaseObject();

  if (_app.isSplitMesh() && _use_distributed_mesh)
    mooseError("You cannot use the mesh splitter capability with DistributedMesh!");

  TIME_SECTION(_init_timer);

  if (_custom_partitioner_requested)
  {
    // Check of partitioner is supplied (not allowed if custom partitioner is used)
    if (!parameters().isParamSetByAddParam("partitioner"))
      mooseError("If partitioner block is provided, partitioner keyword cannot be used!");
    // Set custom partitioner
    if (!_custom_partitioner.get())
      mooseError("Custom partitioner requested but not set!");
    getMesh().partitioner().reset(_custom_partitioner.release());
  }
  else
  {
    // Set standard partitioner
    // Set the partitioner based on partitioner name
    switch (_partitioner_name)
    {
      case -3: // default
        // We'll use the default partitioner, but notify the user of which one is being used...
        if (_use_distributed_mesh)
          _partitioner_name = "parmetis";
        else
          _partitioner_name = "metis";
        break;

      // No need to explicitily create the metis or parmetis partitioners,
      // They are the default for serial and parallel mesh respectively
      case -2: // metis
      case -1: // parmetis
        break;

      case 0: // linear
        getMesh().partitioner().reset(new LinearPartitioner);
        break;
      case 1: // centroid
      {
        if (!isParamValid("centroid_partitioner_direction"))
          mooseError("If using the centroid partitioner you _must_ specify "
                     "centroid_partitioner_direction!");

        MooseEnum direction = getParam<MooseEnum>("centroid_partitioner_direction");

        if (direction == "x")
          getMesh().partitioner().reset(new CentroidPartitioner(CentroidPartitioner::X));
        else if (direction == "y")
          getMesh().partitioner().reset(new CentroidPartitioner(CentroidPartitioner::Y));
        else if (direction == "z")
          getMesh().partitioner().reset(new CentroidPartitioner(CentroidPartitioner::Z));
        else if (direction == "radial")
          getMesh().partitioner().reset(new CentroidPartitioner(CentroidPartitioner::RADIAL));
        break;
      }
      case 2: // hilbert_sfc
        getMesh().partitioner().reset(new HilbertSFCPartitioner);
        break;
      case 3: // morton_sfc
        getMesh().partitioner().reset(new MortonSFCPartitioner);
        break;
    }
  }

  if (_app.isRecovering() && _allow_recovery && _app.isUltimateMaster())
  {
    // Some partitioners are not idempotent.  Some recovery data
    // files require partitioning to match mesh partitioning.  This
    // means that, when recovering, we can't safely repartition.
    const bool skip_partitioning_later = getMesh().skip_partitioning();
    getMesh().skip_partitioning(true);
    const bool allow_renumbering_later = getMesh().allow_renumbering();
    getMesh().allow_renumbering(false);

    // For now, only read the recovery mesh on the Ultimate Master..
    // sub-apps need to just build their mesh like normal
    {
      TIME_SECTION(_read_recovered_mesh_timer);
      getMesh().read(_app.getRecoverFileBase() + "_mesh." + _app.getRecoverFileSuffix());
    }

    getMesh().allow_renumbering(allow_renumbering_later);
    getMesh().skip_partitioning(skip_partitioning_later);
  }
  else // Normally just build the mesh
    buildMesh();
}

isBoundaryElem() [1/2]

bool MooseMesh::isBoundaryElem ( dof_id_type  elem_id ) const

inherited

Returns true if the requested element is in the list of boundary elements, false otherwise.

Definition at line 2654 of file MooseMesh.C.

{
  bool found_elem = false;
  for (const auto & it : _bnd_elem_ids)
  {
    if (it.second.find(elem_id) != it.second.end())
    {
      found_elem = true;
      break;
    }
  }
  return found_elem;
}

isBoundaryElem() [2/2]

bool MooseMesh::isBoundaryElem ( dof_id_type  elem_id, BoundaryID  bnd_id  ) const

inherited

Returns true if the requested element is in the list of boundary elements for the specified boundary, false otherwise.

Definition at line 2669 of file MooseMesh.C.

{
  bool found_elem = false;
  std::map<boundary_id_type, std::set<dof_id_type>>::const_iterator it = _bnd_elem_ids.find(bnd_id);
  if (it != _bnd_elem_ids.end())
    if (it->second.find(elem_id) != it->second.end())
      found_elem = true;
  return found_elem;
}

isBoundaryNode() [1/2]

bool MooseMesh::isBoundaryNode ( dof_id_type  node_id ) const

inherited

Returns true if the requested node is in the list of boundary nodes, false otherwise.

Definition at line 2628 of file MooseMesh.C.

Referenced by NodalNormalsPreprocessor::execute().

{
  bool found_node = false;
  for (const auto & it : _bnd_node_ids)
  {
    if (it.second.find(node_id) != it.second.end())
    {
      found_node = true;
      break;
    }
  }
  return found_node;
}

isBoundaryNode() [2/2]

bool MooseMesh::isBoundaryNode ( dof_id_type  node_id, BoundaryID  bnd_id  ) const

inherited

Returns true if the requested node is in the list of boundary nodes for the specified boundary, false otherwise.

Definition at line 2643 of file MooseMesh.C.

{
  bool found_node = false;
  std::map<boundary_id_type, std::set<dof_id_type>>::const_iterator it = _bnd_node_ids.find(bnd_id);
  if (it != _bnd_node_ids.end())
    if (it->second.find(node_id) != it->second.end())
      found_node = true;
  return found_node;
}

isCustomPartitionerRequested()

bool MooseMesh::isCustomPartitionerRequested ( ) const

inherited

Setter and getter for _custom_partitioner_requested.

Definition at line 2719 of file MooseMesh.C.

{
  return _custom_partitioner_requested;
}

isDistributedMesh()

bool MooseMesh::isDistributedMesh ( ) const

inlineinherited

Returns the final Mesh distribution type.

Definition at line 775 of file MooseMesh.h.

Referenced by RelationshipManager::attachRelationshipManagers(), ElementSideNeighborLayers::attachRelationshipManagersInternal(), ElementPointNeighbors::attachRelationshipManagersInternal(), AddPeriodicBCAction::autoTranslationBoundaries(), VerifyNodalUniqueID::finalize(), VerifyElementUniqueID::finalize(), ConsoleUtils::outputMeshInformation(), and RandomData::updateGenerators().

{ return _use_distributed_mesh; }

isParallelTypeForced()

bool MooseMesh::isParallelTypeForced ( ) const

inlineinherited

Tell the user if the distribution was overriden for any reason.

Definition at line 780 of file MooseMesh.h.

Referenced by ConsoleUtils::outputMeshInformation().

{ return _parallel_type_overridden; }

isParamValid()

bool MooseObject::isParamValid ( const std::string &  name ) const

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 86 of file MooseObject.h.

Referenced by AdvancedOutput::AdvancedOutput(), BicubicSplineFunction::BicubicSplineFunction(), Piecewise::buildFromFile(), Piecewise::buildFromXandY(), DistributedGeneratedMesh::buildMesh(), GeneratedMesh::buildMesh(), CartesianMeshGenerator::CartesianMeshGenerator(), LibmeshPartitioner::clone(), OversampleOutput::cloneMesh(), CSVReader::CSVReader(), MultiAppNearestNodeTransfer::execute(), Exodus::Exodus(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), RenameBoundaryGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementSubdomainIDGenerator::generate(), ExtraNodesetGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MeshSideSetGenerator::generate(), RenameBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainMeshGenerator::generate(), MeshExtruderGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MultiAppNearestNodeTransfer::getLocalEntities(), MeshGenerator::getMesh(), MultiAppNearestNodeTransfer::getNearestNode(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), MooseMesh::init(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), SolutionAux::initialSetup(), MooseParsedVectorFunction::initialSetup(), Console::initialSetup(), Receiver::initialSetup(), SolutionFunction::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), AdvancedOutput::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), BreakBoundaryOnSubdomain::modify(), MeshExtruder::modify(), MeshSideSet::modify(), LowerDBlockFromSideset::modify(), AssignElementSubdomainID::modify(), ParsedSubdomainMeshModifier::modify(), RenameBlock::modify(), SubdomainBoundingBox::modify(), MooseMesh::MooseMesh(), EigenExecutionerBase::normalizeSolution(), Output::Output(), PetscOutput::PetscOutput(), Piecewise::Piecewise(), SolutionUserObject::readExodusII(), RenameBlock::RenameBlock(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), SolutionUserObject::SolutionUserObject(), and TimePeriod::TimePeriod().

{ return _pars.isParamValid(name); }

isPartitionerForced()

bool MooseMesh::isPartitionerForced ( ) const

inlineinherited

Tell the user if the partitioner was overriden for any reason.

Definition at line 790 of file MooseMesh.h.

Referenced by ConsoleUtils::outputMeshInformation().

{ return _partitioner_overridden; }

isRegularOrthogonal()

bool MooseMesh::isRegularOrthogonal ( )

inlineinherited

Getter to query if the mesh was detected to be regular and orthogonal.

Definition at line 837 of file MooseMesh.h.

{ return _regular_orthogonal_mesh; }

isSemiLocal()

bool MooseMesh::isSemiLocal ( Node *  node )

inherited

Returns true if the node is semi-local.

Parameters

node	Node pointer

Returns

true is the node is semi-local, false otherwise

Definition at line 601 of file MooseMesh.C.

{
  return _semilocal_node_list.find(node) != _semilocal_node_list.end();
}

isTranslatedPeriodic()

bool MooseMesh::isTranslatedPeriodic ( unsigned int  nonlinear_var_num, unsigned int  component  ) const

inherited

Returns whether this generated mesh is periodic in the given dimension for the given variable.

Parameters

nonlinear_var_num	- The nonlinear variable number
component	- An integer representing the desired component (dimension)

Definition at line 1500 of file MooseMesh.C.

Referenced by MooseMesh::minPeriodicVector().

{
  mooseAssert(component < dimension(), "Requested dimension out of bounds");

  if (_periodic_dim.find(nonlinear_var_num) != _periodic_dim.end())
    return _periodic_dim.at(nonlinear_var_num)[component];
  else
    return false;
}

localNodesBegin()

MeshBase::const_node_iterator MooseMesh::localNodesBegin ( )

inherited

Calls local_nodes_begin/end() on the underlying libMesh mesh object.

Definition at line 2200 of file MooseMesh.C.

Referenced by MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppNearestNodeTransfer::getNearestNode(), TopResidualDebugOutput::printTopResiduals(), and OversampleOutput::updateOversample().

{
  return getMesh().local_nodes_begin();
}

localNodesEnd()

MeshBase::const_node_iterator MooseMesh::localNodesEnd ( )

inherited

Definition at line 2206 of file MooseMesh.C.

Referenced by MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppNearestNodeTransfer::getNearestNode(), TopResidualDebugOutput::printTopResiduals(), and OversampleOutput::updateOversample().

{
  return getMesh().local_nodes_end();
}

maxElemId()

dof_id_type MooseMesh::maxElemId ( ) const

virtualinherited

Definition at line 2242 of file MooseMesh.C.

Referenced by SolutionUserObject::pointValueGradientWrapper(), and SolutionUserObject::pointValueWrapper().

{
  return getMesh().max_elem_id();
}

maxNodeId()

dof_id_type MooseMesh::maxNodeId ( ) const

virtualinherited

Calls max_node/elem_id() on the underlying libMesh mesh object.

This may be larger than n_nodes/elem() in cases where the id numbering is not contiguous.

Definition at line 2236 of file MooseMesh.C.

{
  return getMesh().max_node_id();
}

meshBoundaryIds()

const std::set< BoundaryID > & MooseMesh::meshBoundaryIds ( ) const

inherited

Returns a read-only reference to the set of boundary IDs currently present in the Mesh.

Definition at line 2317 of file MooseMesh.C.

Referenced by AddPeriodicBCAction::autoTranslationBoundaries(), BoundaryRestrictable::isBoundarySubset(), and AddAllSideSetsByNormals::modify().

{
  return _mesh_boundary_ids;
}

meshChanged()

void MooseMesh::meshChanged ( )

inherited

Declares that the MooseMesh has changed, invalidates cached data and rebuilds caches.

Sets a flag so that clients of the MooseMesh also know when it has changed.

Definition at line 491 of file MooseMesh.C.

Referenced by DisplacedProblem::init(), FEProblemBase::init(), FEProblemBase::initialSetup(), DisplacedProblem::meshChanged(), and FEProblemBase::meshChangedHelper().

{
  TIME_SECTION(_mesh_changed_timer);

  update();

  // Delete all of the cached ranges
  _active_local_elem_range.reset();
  _active_node_range.reset();
  _active_semilocal_node_range.reset();
  _local_node_range.reset();
  _bnd_node_range.reset();
  _bnd_elem_range.reset();

  // Rebuild the ranges
  getActiveLocalElementRange();
  getActiveNodeRange();
  getLocalNodeRange();
  getBoundaryNodeRange();
  getBoundaryElementRange();

  // Call the callback function onMeshChanged
  onMeshChanged();
}

meshNodesetIds()

const std::set< BoundaryID > & MooseMesh::meshNodesetIds ( ) const

inherited

Returns a read-only reference to the set of nodesets currently present in the Mesh.

Definition at line 2329 of file MooseMesh.C.

Referenced by BoundaryRestrictable::initializeBoundaryRestrictable().

{
  return _mesh_nodeset_ids;
}

meshSidesetIds()

const std::set< BoundaryID > & MooseMesh::meshSidesetIds ( ) const

inherited

Returns a read-only reference to the set of sidesets currently present in the Mesh.

Definition at line 2323 of file MooseMesh.C.

Referenced by BoundaryRestrictable::initializeBoundaryRestrictable().

{
  return _mesh_sideset_ids;
}

meshSubdomains()

const std::set< SubdomainID > & MooseMesh::meshSubdomains ( ) const

inherited

Returns a read-only reference to the set of subdomains currently present in the Mesh.

Definition at line 2311 of file MooseMesh.C.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::checkUserObjects(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), MultiApp::getBoundingBox(), BlockRestrictable::initializeBlockRestrictable(), BlockRestrictable::isBlockSubset(), BlockRestrictable::meshBlockIDs(), MooseMesh::MooseMesh(), DOFMapOutput::output(), NonlinearSystemBase::setConstraintSlaveValues(), and FEProblemBase::setCoordSystem().

{
  return _mesh_subdomains;
}

minPeriodicDistance()

Real MooseMesh::minPeriodicDistance ( unsigned int  nonlinear_var_num, Point  p, Point  q  ) const

inherited

This function returns the distance between two points on the mesh taking into account periodicity for the given variable number.

Parameters

nonlinear_var_num	- The nonlinear variable number
p,q	- The points for which to compute a minimum distance

Returns

Real - The L2 distance between p and q

Definition at line 1536 of file MooseMesh.C.

{
  return minPeriodicVector(nonlinear_var_num, p, q).norm();
}

minPeriodicVector()

RealVectorValue MooseMesh::minPeriodicVector ( unsigned int  nonlinear_var_num, Point  p, Point  q  ) const

inherited

This function returns the minimum vector between two points on the mesh taking into account periodicity for the given variable number.

Parameters

nonlinear_var_num	- The nonlinear variable number
p,q	- The points between which to compute a minimum vector

Returns

RealVectorValue - The vector pointing from p to q

Definition at line 1511 of file MooseMesh.C.

Referenced by MooseMesh::minPeriodicDistance().

{
  for (unsigned int i = 0; i < dimension(); ++i)
  {
    // check to see if we're closer in real or periodic space in x, y, and z
    if (isTranslatedPeriodic(nonlinear_var_num, i))
    {
      // Need to test order before differencing
      if (p(i) > q(i))
      {
        if (p(i) - q(i) > _half_range(i))
          p(i) -= _half_range(i) * 2;
      }
      else
      {
        if (q(i) - p(i) > _half_range(i))
          p(i) += _half_range(i) * 2;
      }
    }
  }

  return q - p;
}

mooseDeprecated()

template<typename... Args>

void MooseObject::mooseDeprecated ( Args &&...  args ) const

inlineinherited

Definition at line 158 of file MooseObject.h.

Referenced by FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), FEProblemBase::computeResidual(), Material::declarePropertyOld(), Material::declarePropertyOlder(), MooseMesh::elem(), MultiAppTransfer::execFlags(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::getVectorPostprocessorValue(), FEProblemBase::getVectorPostprocessorValueOld(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), PercentChangePostprocessor::PercentChangePostprocessor(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), and UserForcingFunction::UserForcingFunction().

  {
    moose::internal::mooseDeprecatedStream(_console, false, std::forward<Args>(args)...);
  }

mooseError()

template<typename... Args>

void MooseObject::mooseError ( Args &&...  args ) const

inlineinherited

Definition at line 144 of file MooseObject.h.

Referenced by PetscExternalPartitioner::_do_partition(), GridPartitioner::_do_partition(), FEProblemBase::addConstraint(), FEProblemBase::addInitialCondition(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), FEProblemBase::addOutput(), DiracKernel::addPointWithValidId(), FEProblemBase::addPostprocessor(), MooseMesh::addQuadratureNode(), FEProblemBase::addVectorPostprocessor(), Output::advancedExecuteOn(), AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), DerivativeParsedMaterialHelper::assembleDerivatives(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BicubicSplineFunction::BicubicSplineFunction(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BoundsAux::BoundsAux(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), Piecewise::buildFromFile(), Piecewise::buildFromXandY(), Piecewise::buildFromXY(), TiledMesh::buildMesh(), FileMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), DistributedGeneratedMesh::buildMesh(), GeneratedMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildMeshBaseObject(), MooseMesh::buildRefinementMap(), MooseMesh::buildSideList(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), SubProblem::checkBoundaryMatProps(), FEProblemBase::checkCoordinateSystems(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), Material::checkExecutionStage(), BreakMeshByBlockBase::checkInputParameter(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), ActuallyExplicitEuler::checkLinearConvergence(), FEProblemBase::checkProblemIntegrity(), Material::checkStatefulSanity(), FEProblemBase::checkUserObjects(), LibmeshPartitioner::clone(), MooseMesh::clone(), ComparisonPostprocessor::comparisonIsTrue(), CompositeFunction::CompositeFunction(), ElementLpNormAux::compute(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), KernelBase::computeADOffDiagJacobian(), InterfaceKernel::computeElemNeighJacobian(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), HistogramVectorPostprocessor::computeHistogram(), EqualValueEmbeddedConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), KernelValue::computeQpResidual(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualType(), StatisticsVectorPostprocessor::computeStatValue(), Material::computeSubdomainProperties(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), ActuallyExplicitEuler::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), TimeStepper::constrainStep(), AuxKernel::coupledDot(), AuxKernel::coupledDotDu(), CoupledForce::CoupledForce(), DebugResidualAux::DebugResidualAux(), BicubicSplineFunction::derivative(), DerivativeSumMaterial::DerivativeSumMaterial(), DGKernel::DGKernel(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementQualityAux::ElementQualityAux(), MooseMesh::errorIfDistributedMesh(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), MultiAppPostprocessorTransfer::execute(), DiscreteElementUserObject::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementQualityChecker::execute(), NodalValueSampler::execute(), PointValue::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), TimeExtremeValue::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFit::execute(), LeastSquaresFitHistory::execute(), FEProblemBase::executeControls(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), FileOutput::FileOutput(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), VerifyElementUniqueID::finalize(), VerifyNodalUniqueID::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), Transfer::find_sys(), BreakMeshByBlockBase::findFreeBoundaryId(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase::FunctionMaterialBase(), ParsedMaterialHelper::functionParse(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), GapValueAux::GapValueAux(), ElementSubdomainIDGenerator::generate(), ExtraNodesetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), GeneratedMeshGenerator::generate(), MeshExtruderGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), SpiralAnnularMeshGenerator::generate(), PatternedMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), RandomICBase::generateRandom(), GenericConstantMaterial::GenericConstantMaterial(), GenericFunctionMaterial::GenericFunctionMaterial(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), MooseMesh::getCoarseningMap(), Control::getControllableParameterByName(), FEProblemBase::getCoordSystem(), PiecewiseConstant::getDirection(), FEProblemBase::getDistribution(), ElementGenerator::getElemType(), MultiApp::getExecutioner(), FEProblemBase::getFunction(), SolutionUserObject::getLocalVarIndex(), AuxKernel::getMaterialProperty(), AuxKernel::getMaterialPropertyOld(), AuxKernel::getMaterialPropertyOlder(), SubProblem::getMatrixTagID(), getMaxInDimension(), DistributedGeneratedMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMaxShapeFunctions(), getMinInDimension(), DistributedGeneratedMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MooseMesh::getMortarInterface(), MooseMesh::getMortarInterfaceByName(), MooseMesh::getNodeBlockIds(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearSystem(), MooseMesh::getPairedBoundaryMapping(), ImageMeshGenerator::GetPixelInfo(), ImageMesh::GetPixelInfo(), MaterialStdVectorAux::getRealValue(), MooseMesh::getRefinementMap(), FEProblemBase::getSampler(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), MooseMesh::getSubdomainBoundaryIds(), MooseMesh::getSubdomainID(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), Residual::getValue(), PerformanceData::getValue(), PerfGraphData::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), AdvancedOutput::hasOutputHelper(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), IterationAdaptiveDT::init(), EigenExecutionerBase::init(), Transient::init(), MooseMesh::init(), FEProblemBase::init(), NumPicardIterations::initialize(), FullSolveMultiApp::initialSetup(), PiecewiseBase::initialSetup(), SolutionAux::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), SolutionFunction::initialSetup(), Exodus::initialSetup(), SolutionUserObject::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), Material::initStatefulProperties(), Function::integral(), InterfaceKernel::InterfaceKernel(), InterfaceTimeKernel::InterfaceTimeKernel(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), LayeredSideIntegral::LayeredSideIntegral(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LinearCombinationFunction::LinearCombinationFunction(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), MaterialRealTensorValueAux::MaterialRealTensorValueAux(), MaterialRealVectorValueAux::MaterialRealVectorValueAux(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), SubProblem::meshChanged(), MeshExtruder::MeshExtruder(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshSideSetGenerator::MeshSideSetGenerator(), SideSetsFromNormals::modify(), SideSetsFromPoints::modify(), BreakMeshByBlockBase::modify(), MeshExtruder::modify(), AddExtraNodeset::modify(), SmoothMesh::modify(), AssignElementSubdomainID::modify(), AddAllSideSetsByNormals::modify(), ElementDeleterBase::modify(), RenameBlock::modify(), ParsedSubdomainMeshModifier::modify(), ImageSubdomain::modify(), OrientedSubdomainBoundingBox::modify(), BoundingBoxNodeSet::modify(), AddSideSetsFromBoundingBox::modify(), SubdomainBoundingBox::modify(), MooseMesh::MooseMesh(), MultiAppMeshFunctionTransfer::MultiAppMeshFunctionTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), NearestNodeValueAux::NearestNodeValueAux(), RenameBlockGenerator::newBlockID(), RenameBlock::newBlockID(), RenameBlockGenerator::newBlockName(), RenameBlock::newBlockName(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), NodalScalarKernel::NodalScalarKernel(), NodalVariableValue::NodalVariableValue(), NumDOFs::NumDOFs(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), ElementSideNeighborLayers::operator()(), ElementPointNeighbors::operator()(), RelationshipManager::operator==(), XDA::output(), SolutionHistory::output(), Exodus::output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), MooseObject::paramError(), PiecewiseBilinear::parse(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), PetscExternalPartitioner::PetscExternalPartitioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), Piecewise::Piecewise(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), SolutionUserObject::pointValueGradientWrapper(), SolutionUserObject::pointValueWrapper(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), LStableDirk4::postResidual(), AStableDirk4::postResidual(), ExplicitRK2::postResidual(), Predictor::Predictor(), SolutionUserObject::readExodusII(), SolutionUserObject::readXda(), EqualValueEmbeddedConstraint::reinitConstraint(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), RenameBlock::RenameBlock(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), ScalarComponentIC::ScalarComponentIC(), BicubicSplineFunction::secondDerivative(), FEProblemBase::setCoordSystem(), PiecewiseBase::setData(), EigenProblem::setEigenproblemType(), Sampler::setNumberOfRequiedRandomSeeds(), Exodus::setOutputDimensionInExodusWriter(), Split::setup(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideSetsFromNormals::SideSetsFromNormals(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPoints::SideSetsFromPoints(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObject::SolutionUserObject(), PicardSolve::solve(), ActuallyExplicitEuler::solve(), FullSolveMultiApp::solveStep(), UserObject::spatialValue(), SphericalAverage::SphericalAverage(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), StitchedMesh::StitchedMesh(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), Constraint::subdomainSetup(), Console::systemInfoFlags(), Terminator::Terminator(), TestSetupPostprocessorDataActionFunction::TestSetupPostprocessorDataActionFunction(), ThreadedGeneralUserObject::ThreadedGeneralUserObject(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), TiledMeshGenerator::TiledMeshGenerator(), Function::timeDerivative(), TimeExtremeValue::TimeExtremeValue(), TimePeriod::TimePeriod(), VectorPostprocessorVisualizationAux::timestepSetup(), MultiAppCopyTransfer::transfer(), MultiAppMeshFunctionTransfer::transferVariable(), FEProblemBase::uDotDotOldRequested(), FEProblemBase::uDotOldRequested(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObject::updateExodusBracketingTimeIndices(), Axisymmetric2D3DSolutionFunction::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), MultiAppTransfer::variableIntegrityCheck(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), VectorNodalBC::VectorNodalBC(), VectorOfPostprocessors::VectorOfPostprocessors(), VectorPostprocessorFunction::VectorPostprocessorFunction(), MooseParsedGradFunction::vectorValue(), MooseParsedFunction::vectorValue(), VolumeHistogram::VolumeHistogram(), VTKOutput::VTKOutput(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

                                                      {
    std::ostringstream oss;
    moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
    std::string msg = oss.str();
    callMooseErrorRaw(msg, &_app);
  }

mooseInfo()

template<typename... Args>

void MooseObject::mooseInfo ( Args &&...  args ) const

inlineinherited

Definition at line 164 of file MooseObject.h.

Referenced by DerivativeParsedMaterialHelper::assembleDerivatives(), AStableDirk4::AStableDirk4(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), ParsedMaterialHelper::functionsOptimize(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), and MooseObject::paramInfo().

  {
    moose::internal::mooseInfoStream(_console, std::forward<Args>(args)...);
  }

mooseWarning()

template<typename... Args>

void MooseObject::mooseWarning ( Args &&...  args ) const

inlineinherited

Definition at line 152 of file MooseObject.h.

Referenced by CartesianMeshGenerator::CartesianMeshGenerator(), OversampleOutput::cloneMesh(), GapValueAux::computeValue(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), ElementSubdomainIDGenerator::generate(), MooseMesh::getBoundaryIDs(), FEProblemBase::getMaterial(), MooseMesh::getSubdomainIDs(), DerivativeFunctionMaterialBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), LeastSquaresFit::LeastSquaresFit(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), AssignElementSubdomainID::modify(), MultiAppTransfer::MultiAppTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MooseObject::paramWarning(), Executioner::problem(), Material::resetQpProperties(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), and Checkpoint::updateCheckpointFiles().

  {
    moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
  }

name()

const std::string& MooseObject::name ( ) const

inlineinherited

Get the name of the object.

Returns

The name of the object

Definition at line 56 of file MooseObject.h.

Referenced by GridPartitioner::_do_partition(), FEProblemBase::addADJacobianMaterial(), FEProblemBase::addADResidualMaterial(), Executioner::addAttributeReporter(), DumpObjectsProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarKernel(), DumpObjectsProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), DumpObjectsProblem::addDGKernel(), FEProblemBase::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), FEProblemBase::addIndicator(), DumpObjectsProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), FEProblemBase::addInterfaceKernel(), DumpObjectsProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addMarker(), DumpObjectsProblem::addMaterial(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), MooseMesh::addMortarInterface(), FEProblemBase::addMultiApp(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVectorPostprocessor(), Output::advancedExecuteOn(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), DerivativeParsedMaterialHelper::assembleDerivatives(), AStableDirk4::AStableDirk4(), Function::average(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), FEProblemBase::checkDependMaterialsHelper(), Damper::checkMinDamping(), Material::checkStatefulSanity(), CompositeFunction::CompositeFunction(), Material::computeSubdomainProperties(), VectorPostprocessorVisualizationAux::computeValue(), AuxKernel::coupledCallback(), AuxKernel::coupledDot(), AuxKernel::coupledDotDu(), MultiApp::createApp(), FEProblemBase::declareVectorPostprocessorVector(), DOFMapOutput::demangle(), DerivativeSumMaterial::DerivativeSumMaterial(), DGKernel::DGKernel(), DumpObjectsProblem::dumpObjectHelper(), ElementValueSampler::ElementValueSampler(), MooseMesh::errorIfDistributedMesh(), AB2PredictorCorrector::estimateTimeError(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), StatisticsVectorPostprocessor::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), PointValue::execute(), MultiAppInterpolationTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), HistogramVectorPostprocessor::execute(), MultiAppCopyTransfer::execute(), Exodus::Exodus(), FileOutput::FileOutput(), MultiApp::fillPositions(), PointSamplerBase::finalize(), DerivativeParsedMaterialHelper::findMatPropDerivative(), FunctionDT::FunctionDT(), GeneralUserObject::GeneralUserObject(), LowerDBlockFromSidesetGenerator::generate(), StitchedMeshGenerator::generate(), Material::getADMaterialProperty(), MultiApp::getBoundingBox(), MooseObject::getCheckedPointerParam(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), MultiApp::getExecutioner(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SolutionUserObject::getLocalVarIndex(), Marker::getMarkerValue(), FEProblemBase::getMaterial(), NodalPatchRecovery::getMaterialProperty(), AuxKernel::getMaterialProperty(), Material::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), AuxKernel::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), AuxKernel::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), MeshGenerator::getMesh(), MooseMesh::getMortarInterfaceByName(), OutputWarehouse::getOutput(), MooseObject::getParam(), GeneralUserObject::getPostprocessorValue(), AuxKernel::getPostprocessorValue(), FEProblemBase::getPostprocessorValue(), GeneralUserObject::getPostprocessorValueByName(), AuxKernel::getPostprocessorValueByName(), FEProblemBase::getPostprocessorValueOld(), FEProblemBase::getPostprocessorValueOlder(), FEProblemBase::getSampler(), AuxKernel::getScatterVectorPostprocessorValue(), FEProblemBase::getScatterVectorPostprocessorValue(), AuxKernel::getScatterVectorPostprocessorValueByName(), FEProblemBase::getScatterVectorPostprocessorValueOld(), Transient::getTimeStepperName(), AuxKernel::getUserObject(), InitialConditionBase::getUserObject(), FEProblemBase::getUserObject(), InitialConditionBase::getUserObjectBase(), AuxKernel::getUserObjectBase(), FEProblemBase::getUserObjectBase(), AuxKernel::getUserObjectByName(), InitialConditionBase::getUserObjectByName(), GeneralUserObject::getVectorPostprocessorValue(), AuxKernel::getVectorPostprocessorValue(), FEProblemBase::getVectorPostprocessorValue(), GeneralUserObject::getVectorPostprocessorValueByName(), AuxKernel::getVectorPostprocessorValueByName(), FEProblemBase::getVectorPostprocessorValueOld(), FEProblemBase::hasFunction(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasUserObject(), FEProblemBase::hasVectorPostprocessor(), FEProblemBase::init(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), CSVReader::initialize(), StatisticsVectorPostprocessor::initialize(), HistogramVectorPostprocessor::initialize(), MultiAppProjectionTransfer::initialSetup(), DerivativeFunctionMaterialBase::initialSetup(), SolutionUserObject::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPostprocessorData(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), Material::initStatefulProperties(), FEProblemBase::initVectorPostprocessorData(), Function::integral(), InterfaceKernel::InterfaceKernel(), MooseObject::isParamValid(), LinearCombinationFunction::LinearCombinationFunction(), Marker::Marker(), MatDiffusionBase< Real >::MatDiffusionBase(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshSideSetGenerator::MeshSideSetGenerator(), ElementDeleterBase::modify(), MooseVariableInterface< Real >::MooseVariableInterface(), NearestPointBase< LayeredAverage >::NearestPointBase(), NodalValueSampler::NodalValueSampler(), NodalVariableValue::NodalVariableValue(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), ConsoleUtils::outputOutputInformation(), Nemesis::outputPostprocessors(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), PointSamplerBase::PointSamplerBase(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), Material::resetQpProperties(), Sampler::Sampler(), ScalarComponentIC::ScalarComponentIC(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), MooseMesh::setSubdomainName(), Split::setup(), TransientMultiApp::setupApp(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SideValueSampler::SideValueSampler(), TransientMultiApp::solveStep(), UserObject::spatialValue(), SphericalAverage::SphericalAverage(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), SubProblem::storeSubdomainZeroMatProp(), TaggingInterface::TaggingInterface(), ThreadedGeneralUserObject::ThreadedGeneralUserObject(), Function::timeDerivative(), VectorPostprocessorVisualizationAux::timestepSetup(), TransientMultiApp::TransientMultiApp(), MultiAppTransfer::variableIntegrityCheck(), and AdvancedOutput::wantOutput().

{ return _name; }

needsPrepareForUse()

void MooseMesh::needsPrepareForUse ( )

inherited

If this method is called, we will call libMesh's prepare_for_use method when we call Moose's prepare method.

This should only be set when the mesh structure is changed by MeshModifiers (i.e. Element deletion).

Definition at line 2305 of file MooseMesh.C.

Referenced by LowerDBlockFromSideset::modify(), and ElementDeleterBase::modify().

{
  _needs_prepare_for_use = true;
}

nElem()

dof_id_type MooseMesh::nElem ( ) const

virtualinherited

Definition at line 2230 of file MooseMesh.C.

{
  return getMesh().n_elem();
}

nNodes()

dof_id_type MooseMesh::nNodes ( ) const

virtualinherited

Calls n_nodes/elem() on the underlying libMesh mesh object.

Definition at line 2224 of file MooseMesh.C.

{
  return getMesh().n_nodes();
}

node() [1/2]

const Node & MooseMesh::node ( const dof_id_type  i ) const

virtualinherited

Various accessors (pointers/references) for Node "i".

If the requested node is a remote node on a distributed mesh, only the query accessors are valid to call, and they return NULL.

Definition at line 423 of file MooseMesh.C.

Referenced by MooseMesh::addUniqueNode(), GeneratedMesh::buildMesh(), DistributedGeneratedMesh::buildMesh(), MooseMesh::buildPeriodicNodeMap(), MooseMesh::cacheInfo(), MooseMesh::detectOrthogonalDimRanges(), MooseMesh::getNodeBlockIds(), MooseMesh::isSemiLocal(), and MooseMesh::updateActiveSemiLocalNodeRange().

{
  mooseDeprecated("MooseMesh::node() is deprecated, please use MooseMesh::nodeRef() instead");
  return nodeRef(i);
}

node() [2/2]

Node & MooseMesh::node ( const dof_id_type  i )

virtualinherited

Definition at line 430 of file MooseMesh.C.

{
  mooseDeprecated("MooseMesh::node() is deprecated, please use MooseMesh::nodeRef() instead");
  return nodeRef(i);
}

nodePtr() [1/2]

const Node * MooseMesh::nodePtr ( const dof_id_type  i ) const

virtualinherited

Definition at line 455 of file MooseMesh.C.

Referenced by dataLoad().

{
  if (i > getMesh().max_node_id())
    return (*_quadrature_nodes.find(i)).second;

  return getMesh().node_ptr(i);
}

nodePtr() [2/2]

Node * MooseMesh::nodePtr ( const dof_id_type  i )

virtualinherited

Definition at line 464 of file MooseMesh.C.

{
  if (i > getMesh().max_node_id())
    return _quadrature_nodes[i];

  return getMesh().node_ptr(i);
}

nodeRef() [1/2]

const Node & MooseMesh::nodeRef ( const dof_id_type  i ) const

virtualinherited

Definition at line 437 of file MooseMesh.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NearestNodeLocator::findNodes(), NonlinearSystemBase::getNodeDofs(), LinearNodalConstraint::LinearNodalConstraint(), MooseMesh::node(), ResetDisplacedMeshThread::onNode(), UpdateDisplacedMeshThread::onNode(), NearestNodeThread::operator()(), SlaveNeighborhoodThread::operator()(), PenetrationThread::operator()(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), NonlinearSystemBase::setConstraintSlaveValues(), EqualValueBoundaryConstraint::updateConstrainedNodes(), and NearestNodeLocator::updatePatch().

{
  if (i > getMesh().max_node_id())
    return *(*_quadrature_nodes.find(i)).second;

  return getMesh().node_ref(i);
}

nodeRef() [2/2]

Node & MooseMesh::nodeRef ( const dof_id_type  i )

virtualinherited

Definition at line 446 of file MooseMesh.C.

{
  if (i > getMesh().max_node_id())
    return *_quadrature_nodes[i];

  return getMesh().node_ref(i);
}

nodeToActiveSemilocalElemMap()

const std::map< dof_id_type, std::vector< dof_id_type > > & MooseMesh::nodeToActiveSemilocalElemMap ( )

inherited

If not already created, creates a map from every node to all active semilocal elements to which they are connected.

Semilocal elements include local elements and elements that share at least one node with a local element.

Note

Extra ghosted elements are not included in this map!

Definition at line 713 of file MooseMesh.C.

{
  if (!_node_to_active_semilocal_elem_map_built) // Guard the creation with a double checked lock
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);

    TIME_SECTION(_node_to_active_semilocal_elem_map_timer);

    if (!_node_to_active_semilocal_elem_map_built)
    {
      for (const auto & elem :
           as_range(getMesh().semilocal_elements_begin(), getMesh().semilocal_elements_end()))
        if (elem->active())
          for (unsigned int n = 0; n < elem->n_nodes(); n++)
            _node_to_active_semilocal_elem_map[elem->node_id(n)].push_back(elem->id());

      _node_to_active_semilocal_elem_map_built =
          true; // MUST be set at the end for double-checked locking to work!
    }
  }

  return _node_to_active_semilocal_elem_map;
}

nodeToElemMap()

const std::map< dof_id_type, std::vector< dof_id_type > > & MooseMesh::nodeToElemMap ( )

inherited

If not already created, creates a map from every node to all elements to which they are connected.

Definition at line 691 of file MooseMesh.C.

Referenced by NodalPatchRecovery::compute(), PenetrationLocator::detectPenetration(), DMMooseGetEmbedding_Private(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), NearestNodeLocator::findNodes(), LinearNodalConstraint::LinearNodalConstraint(), BreakMeshByBlock::modify(), EqualValueBoundaryConstraint::updateConstrainedNodes(), RandomData::updateGenerators(), and NearestNodeLocator::updatePatch().

{
  if (!_node_to_elem_map_built) // Guard the creation with a double checked lock
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);

    if (!_node_to_elem_map_built)
    {
      TIME_SECTION(_node_to_elem_map_timer);

      for (const auto & elem : getMesh().active_element_ptr_range())
        for (unsigned int n = 0; n < elem->n_nodes(); n++)
          _node_to_elem_map[elem->node_id(n)].push_back(elem->id());

      _node_to_elem_map_built = true; // MUST be set at the end for double-checked locking to work!
    }
  }

  return _node_to_elem_map;
}

onMeshChanged()

void MooseMesh::onMeshChanged ( )

virtualinherited

Declares a callback function that is executed at the conclusion of meshChanged().

Ther user can implement actions required after changing the mesh here.

Definition at line 517 of file MooseMesh.C.

Referenced by MooseMesh::meshChanged().

{
}

operator const libMesh::MeshBase &()

MooseMesh::operator const libMesh::MeshBase & ( ) const

inherited

Definition at line 2559 of file MooseMesh.C.

{ return getMesh(); }

operator libMesh::MeshBase &()

MooseMesh::operator libMesh::MeshBase & ( )

inherited

Implicit conversion operator from MooseMesh -> libMesh::MeshBase.

Definition at line 2557 of file MooseMesh.C.

{ return getMesh(); }

operator=()

AnnularMesh& AnnularMesh::operator= ( const AnnularMesh &  other_mesh )

delete

paramError()

template<typename... Args>

void MooseObject::paramError ( const std::string &  param, Args...  args  )

inlineinherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 105 of file MooseObject.h.

Referenced by ADIntegratedBCTempl< T, compute_stage >::ADIntegratedBCTempl(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), DGKernel::DGKernel(), ElementValueSampler::ElementValueSampler(), StackGenerator::generate(), StitchedMeshGenerator::generate(), MultiApp::init(), IntegratedBC::IntegratedBC(), Kernel::Kernel(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalValueSampler::NodalValueSampler(), RandomIC::RandomIC(), MultiAppCopyTransfer::transfer(), and TransientMultiApp::TransientMultiApp().

                                                                      {
    auto prefix = param + ": ";
    if (!_pars.inputLocation(param).empty())
      prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
    mooseError(prefix, args...);
  }

parameters()

const InputParameters& MooseObject::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 62 of file MooseObject.h.

Referenced by FEProblemBase::addADJacobianMaterial(), FEProblemBase::addADResidualMaterial(), DumpObjectsProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarKernel(), DumpObjectsProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), DumpObjectsProblem::addDGKernel(), FEProblemBase::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), FEProblemBase::addIndicator(), DumpObjectsProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), FEProblemBase::addInterfaceKernel(), DumpObjectsProblem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), DumpObjectsProblem::addMaterial(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVectorPostprocessor(), AdvancedOutput::AdvancedOutput(), assemble_l2(), Moose::assemble_matrix(), AuxKernel::AuxKernel(), AuxScalarKernel::AuxScalarKernel(), BoundsAux::BoundsAux(), LibmeshPartitioner::clone(), OversampleOutput::cloneMesh(), Moose::compute_bounds(), Moose::compute_jacobian(), Moose::compute_nearnullspace(), Moose::compute_nullspace(), Moose::compute_postcheck(), Moose::compute_transpose_nullspace(), Console::Console(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Executioner::Executioner(), Exodus::Exodus(), FEProblem::FEProblem(), GapValueAux::GapValueAux(), MooseObject::getCheckedPointerParam(), MooseMesh::init(), BlockRestrictable::initializeBlockRestrictable(), FEProblemBase::initNullSpaceVectors(), InterfaceKernel::InterfaceKernel(), isValid(), LayeredSideIntegral::LayeredSideIntegral(), MooseVariableInterface< Real >::MooseVariableInterface(), NearestPointBase< LayeredAverage >::NearestPointBase(), NodeFaceConstraint::NodeFaceConstraint(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), MultiAppProjectionTransfer::projectSolution(), RandomIC::RandomIC(), InputParameterWarehouse::removeInputParameters(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), DumpObjectsProblem::stringifyParameters(), and Transient::Transient().

{ return _pars; }

paramInfo()

template<typename... Args>

void MooseObject::paramInfo ( const std::string &  param, Args...  args  )

inlineinherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 135 of file MooseObject.h.

Referenced by TransientMultiApp::TransientMultiApp().

  {
    auto prefix = param + ": ";
    if (!_pars.inputLocation(param).empty())
      prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
    mooseInfo(prefix, args...);
  }

paramWarning()

template<typename... Args>

void MooseObject::paramWarning ( const std::string &  param, Args...  args  )

inlineinherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 119 of file MooseObject.h.

  {
    auto prefix = param + ": ";
    if (!_pars.inputLocation(param).empty())
      prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
    mooseWarning(prefix, args...);
  }

partitionerName()

const MooseEnum& MooseMesh::partitionerName ( ) const

inlineinherited

Definition at line 785 of file MooseMesh.h.

Referenced by ConsoleUtils::outputMeshInformation().

{ return _partitioner_name; }

prepare()

void MooseMesh::prepare ( bool  force = false )

inherited

Calls prepare_for_use() if force=true on the underlying Mesh object, then communicates various boundary information on parallel meshes.

Also calls update() internally.

Definition at line 344 of file MooseMesh.C.

Referenced by SetupMeshCompleteAction::completeSetup(), and MeshModifier::modifyMeshHelper().

{
  TIME_SECTION(_prepare_timer);

  mooseAssert(_mesh, "The MeshBase has not been constructed");

  if (dynamic_cast<DistributedMesh *>(&getMesh()) && !_is_nemesis)
  {
    // Call prepare_for_use() and don't mess with the renumbering
    // setting
    if (force || _needs_prepare_for_use)
      getMesh().prepare_for_use();
  }
  else
  {
    // Call prepare_for_use() and DO NOT allow renumbering
    getMesh().allow_renumbering(false);
    if (force || _needs_prepare_for_use)
      getMesh().prepare_for_use();
  }

  // Collect (local) subdomain IDs
  _mesh_subdomains.clear();
  for (const auto & elem : getMesh().element_ptr_range())
    _mesh_subdomains.insert(elem->subdomain_id());

  // Make sure nodesets have been generated
  buildNodeListFromSideList();

  // Collect (local) boundary IDs
  const std::set<BoundaryID> & local_bids = getMesh().get_boundary_info().get_boundary_ids();
  _mesh_boundary_ids.insert(local_bids.begin(), local_bids.end());

  const std::set<BoundaryID> & local_node_bids =
      getMesh().get_boundary_info().get_node_boundary_ids();
  _mesh_nodeset_ids.insert(local_node_bids.begin(), local_node_bids.end());

  const std::set<BoundaryID> & local_side_bids =
      getMesh().get_boundary_info().get_side_boundary_ids();
  _mesh_sideset_ids.insert(local_side_bids.begin(), local_side_bids.end());

  // Communicate subdomain and boundary IDs if this is a parallel mesh
  if (!getMesh().is_serial())
  {
    _communicator.set_union(_mesh_subdomains);
    _communicator.set_union(_mesh_boundary_ids);
    _communicator.set_union(_mesh_nodeset_ids);
    _communicator.set_union(_mesh_sideset_ids);
  }

  detectOrthogonalDimRanges();

  update();

  // Prepared has been called
  _is_prepared = true;
  _needs_prepare_for_use = false;
}

prepared() [1/2]

void AnnularMesh::prepared ( bool  state )

overridevirtual

Reimplemented from MooseMesh.

Definition at line 86 of file AnnularMesh.C.

{
  MooseMesh::prepared(state);

  // Fall back on scanning the mesh for coordinates instead of using input parameters for queries
  if (!state)
    _dims_may_have_changed = true;
}

prepared() [2/2]

bool MooseMesh::prepared ( ) const

inherited

Setter/getter for the _is_prepared flag.

Definition at line 2286 of file MooseMesh.C.

Referenced by SetupMeshCompleteAction::completeSetup(), MooseApp::executeMeshModifiers(), MeshExtruder::modify(), DistributedGeneratedMesh::prepared(), GeneratedMesh::prepared(), and prepared().

{
  return _is_prepared;
}

printInfo()

void MooseMesh::printInfo ( std::ostream &  os = libMesh::out ) const

inherited

Calls print_info() on the underlying Mesh.

Definition at line 2583 of file MooseMesh.C.

Referenced by Adaptivity::adaptMesh().

{
  getMesh().print_info(os);
}

queryElemPtr() [1/2]

Elem * MooseMesh::queryElemPtr ( const dof_id_type  i )

virtualinherited

Definition at line 2274 of file MooseMesh.C.

Referenced by EqualValueBoundaryConstraint::updateConstrainedNodes().

{
  return getMesh().query_elem_ptr(i);
}

queryElemPtr() [2/2]

const Elem * MooseMesh::queryElemPtr ( const dof_id_type  i ) const

virtualinherited

Definition at line 2280 of file MooseMesh.C.

{
  return getMesh().query_elem_ptr(i);
}

queryNodePtr() [1/2]

const Node * MooseMesh::queryNodePtr ( const dof_id_type  i ) const

virtualinherited

Definition at line 473 of file MooseMesh.C.

Referenced by NonlinearSystemBase::findImplicitGeometricCouplingEntries(), and EqualValueBoundaryConstraint::updateConstrainedNodes().

{
  if (i > getMesh().max_node_id())
    return (*_quadrature_nodes.find(i)).second;

  return getMesh().query_node_ptr(i);
}

queryNodePtr() [2/2]

Node * MooseMesh::queryNodePtr ( const dof_id_type  i )

virtualinherited

Definition at line 482 of file MooseMesh.C.

{
  if (i > getMesh().max_node_id())
    return _quadrature_nodes[i];

  return getMesh().query_node_ptr(i);
}

refinedElementRange()

ConstElemPointerRange * MooseMesh::refinedElementRange ( ) const

inherited

Return a range that is suitable for threaded execution over elements that were just refined.

Returns

The Parent elements that are now set to be INACTIVE. Their children are the new elements.

Definition at line 540 of file MooseMesh.C.

Referenced by FEProblemBase::meshChangedHelper().

{
  return _refined_elements.get();
}

registerTimedSection()

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level  )

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns

The ID of the section - use when starting timing

Definition at line 50 of file PerfGraphInterface.C.

{
  if (_prefix != "")
    return _perf_graph.registerSection(_prefix + "::" + section_name, level);
  else
    return _perf_graph.registerSection(section_name, level);
}

safeClone()

std::unique_ptr< MooseMesh > AnnularMesh::safeClone ( ) const

overridevirtual

A safer version of the clone() method that hands back an allocated object wrapped in a smart pointer.

This makes it much less likely that the caller will leak the memory in question.

Implements MooseMesh.

Definition at line 134 of file AnnularMesh.C.

{
  return libmesh_make_unique<AnnularMesh>(*this);
}

setBoundaryName()

void MooseMesh::setBoundaryName ( BoundaryID  boundary_id, BoundaryName  name  )

inherited

This method returns a writable reference to a boundary name based on the id parameter.

Definition at line 1125 of file MooseMesh.C.

Referenced by SetupMeshAction::setupMesh().

{
  BoundaryInfo & boundary_info = getMesh().get_boundary_info();

  std::vector<BoundaryID> side_boundaries;
  boundary_info.build_side_boundary_ids(side_boundaries);

  // We need to figure out if this boundary is a sideset or nodeset
  if (std::find(side_boundaries.begin(), side_boundaries.end(), boundary_id) !=
      side_boundaries.end())
    boundary_info.sideset_name(boundary_id) = name;
  else
    boundary_info.nodeset_name(boundary_id) = name;
}

setBoundaryToNormalMap() [1/2]

void MooseMesh::setBoundaryToNormalMap ( std::unique_ptr< std::map< BoundaryID, RealVectorValue >>  boundary_map )

inherited

Sets the mapping between BoundaryID and normal vector Is called by AddAllSideSetsByNormals.

Definition at line 2341 of file MooseMesh.C.

Referenced by AddAllSideSetsByNormals::modify().

{
  _boundary_to_normal_map = std::move(boundary_map);
}

setBoundaryToNormalMap() [2/2]

void MooseMesh::setBoundaryToNormalMap ( std::map< BoundaryID, RealVectorValue > *  boundary_map )

inherited

Definition at line 2348 of file MooseMesh.C.

{
  mooseDeprecated("setBoundaryToNormalMap(std::map<BoundaryID, RealVectorValue> * boundary_map) is "
                  "deprecated, use the unique_ptr version instead");
  _boundary_to_normal_map.reset(boundary_map);
}

setCustomPartitioner()

void MooseMesh::setCustomPartitioner ( Partitioner *  partitioner )

inherited

Setter for custom partitioner.

Definition at line 2713 of file MooseMesh.C.

{
  _custom_partitioner = partitioner->clone();
}

setGhostedBoundaryInflation()

void MooseMesh::setGhostedBoundaryInflation ( const std::vector< Real > &  inflation )

inherited

This sets the inflation amount for the bounding box for each partition for use in ghosting boundaries.

Definition at line 2374 of file MooseMesh.C.

Referenced by SetupMeshAction::setupMesh().

{
  _ghosted_boundaries_inflation = inflation;
}

setIsCustomPartitionerRequested()