MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and storing more state. More...

#include <MooseMesh.h>

Inheritance diagram for MooseMesh:

[legend]

Classes
struct	bnd_elem_iterator
	The definition of the bnd_elem_iterator struct. More...

struct	bnd_node_iterator
	The definition of the bnd_node_iterator struct. More...

struct	const_bnd_elem_iterator
	The definition of the const_bnd_elem_iterator struct. More...

struct	const_bnd_node_iterator
	The definition of the const_bnd_node_iterator struct. More...

class	MortarInterface

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
	MooseMesh (const InputParameters &parameters)
	Typical "Moose-style" constructor and copy constructor. More...

	MooseMesh (const MooseMesh &other_mesh)

virtual	~MooseMesh ()

virtual MooseMesh &	clone () const
	Clone method. More...

virtual std::unique_ptr< MooseMesh >	safeClone () const =0
	A safer version of the clone() method that hands back an allocated object wrapped in a smart pointer. 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 void	buildMesh ()=0
	Must be overridden by child classes. 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...

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

virtual void	prepared (bool state)

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

const std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > &	getBoundariesToElems () const
	Returns a map of boundaries to elements. More...

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

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

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

void	needsRemoteElemDeletion (bool need_delete)
	Set whether we need to delete remote elements. More...

bool	needsRemoteElemDeletion () const
	Whether we need to delete remote elements. 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


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 ()


virtual Real	getMinInDimension (unsigned int component) const
	Returns the min or max of the requested dimension respectively. More...

virtual Real	getMaxInDimension (unsigned int component) 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
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::unordered_map< boundary_id_type, std::unordered_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

Private Member Functions
void	detectPairedSidesets ()
	This routine detects paired sidesets of a regular orthogonal mesh (.i.e. More...

void	buildRefinementMap (const Elem &elem, QBase &qrule, QBase &qrule_face, int parent_side, int child, int child_side)
	Build the refinement map for a given element type. More...

void	buildCoarseningMap (const Elem &elem, QBase &qrule, QBase &qrule_face, int input_side)
	Build the coarsening map for a given element type. More...

void	mapPoints (const std::vector< Point > &from, const std::vector< Point > &to, std::vector< QpMap > &qp_map)
	Find the closest points that map "from" to "to" and fill up "qp_map". More...

void	findAdaptivityQpMaps (const Elem *template_elem, QBase &qrule, QBase &qrule_face, std::vector< std::vector< QpMap >> &refinement_map, std::vector< std::pair< unsigned int, QpMap >> &coarsen_map, int parent_side, int child, int child_side)
	Given an elem type, get maps that tell us what qp's are closest to each other between a parent and it's children. More...

Private Attributes
std::map< unsigned int, std::vector< bool > >	_periodic_dim
	A map of vectors indicating which dimensions are periodic in a regular orthogonal mesh for the specified variable numbers. More...

RealVectorValue	_half_range
	A convenience vector used to hold values in each dimension representing half of the range. More...

std::vector< Node * >	_extreme_nodes
	A vector containing the nodes at the corners of a regular orthogonal mesh. More...

std::map< std::pair< int, ElemType >, std::vector< std::vector< QpMap > > >	_elem_type_to_refinement_map
	Holds mappings for volume to volume and parent side to child side. More...

std::map< ElemType, std::map< std::pair< int, int >, std::vector< std::vector< QpMap > > > >	_elem_type_to_child_side_refinement_map
	Holds mappings for "internal" child sides to parent volume. The second key is (child, child_side). More...

std::map< std::pair< int, ElemType >, std::vector< std::pair< unsigned int, QpMap > > >	_elem_type_to_coarsening_map
	Holds mappings for volume to volume and parent side to child side. More...

std::map< SubdomainID, std::set< BoundaryID > >	_subdomain_boundary_ids
	Holds a map from subomdain ids to the boundary ids that are attached to it. More...

bool	_allow_recovery
	Whether or not this Mesh is allowed to read a recovery file. More...

bool	_construct_node_list_from_side_list
	Whether or not to allow generation of nodesets from sidesets. More...

PerfID	_prepare_timer
	Timers. More...

PerfID	_update_timer

PerfID	_mesh_changed_timer

PerfID	_cache_changed_lists_timer

PerfID	_update_active_semi_local_node_range_timer

PerfID	_build_node_list_timer

PerfID	_build_bnd_elem_list_timer

PerfID	_node_to_elem_map_timer

PerfID	_node_to_active_semilocal_elem_map_timer

PerfID	_get_active_local_element_range_timer

PerfID	_get_active_node_range_timer

PerfID	_get_local_node_range_timer

PerfID	_get_boundary_node_range_timer

PerfID	_get_boundary_element_range_timer

PerfID	_cache_info_timer

PerfID	_build_periodic_node_map_timer

PerfID	_build_periodic_node_sets_timer

PerfID	_detect_orthogonal_dim_ranges_timer

PerfID	_detect_paired_sidesets_timer

PerfID	_build_refinement_map_timer

PerfID	_build_coarsening_map_timer

PerfID	_find_adaptivity_qp_maps_timer

PerfID	_build_refinement_and_coarsening_maps_timer

PerfID	_change_boundary_id_timer

PerfID	_init_timer

PerfID	_read_recovered_mesh_timer

PerfID	_ghost_ghosted_boundaries_timer

PerfID	_add_mortar_interface_timer

bool	_need_delete
	Whether we need to delete remote elements after init'ing the EquationSystems. More...

Detailed Description

MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and storing more state.

Definition at line 75 of file MooseMesh.h.

Member Typedef Documentation

◆ bnd_elem_iterator_imp

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

protected

Definition at line 1000 of file MooseMesh.h.

◆ bnd_node_iterator_imp

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

protected

Definition at line 993 of file MooseMesh.h.

◆ const_bnd_elem_iterator_imp

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

protected

Definition at line 1001 of file MooseMesh.h.

◆ const_bnd_node_iterator_imp

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

protected

Definition at line 994 of file MooseMesh.h.

◆ PeriodicNodeInfo

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

Helper type for building periodic node maps.

Definition at line 865 of file MooseMesh.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

protected

Convenience enums.

Enumerator
X
Y
Z

Definition at line 907 of file MooseMesh.h.

   {
     X = 0,
     Y,
     Z
   };

◆ anonymous enum

anonymous enum

protected

Enumerator
MIN
MAX

Definition at line 913 of file MooseMesh.h.

   {
     MIN = 0,
     MAX
   };

◆ ParallelType

enum MooseMesh::ParallelType

strong

Enumerator
DEFAULT
REPLICATED
DISTRIBUTED

Definition at line 87 of file MooseMesh.h.

   {
     DEFAULT,
     REPLICATED,
     DISTRIBUTED
   };

Constructor & Destructor Documentation

◆ MooseMesh() [1/2]

MooseMesh::MooseMesh ( const InputParameters & parameters )

Typical "Moose-style" constructor and copy constructor.

Definition at line 152 of file MooseMesh.C.

   : MooseObject(parameters),
     Restartable(this, "Mesh"),
     PerfGraphInterface(this),
     _parallel_type(getParam<MooseEnum>("parallel_type").getEnum<MooseMesh::ParallelType>()),
     _use_distributed_mesh(false),
     _distribution_overridden(false),
     _parallel_type_overridden(false),
     _partitioner_name(getParam<MooseEnum>("partitioner")),
     _partitioner_overridden(false),
     _custom_partitioner_requested(false),
     _uniform_refine_level(0),
     _is_nemesis(getParam<bool>("nemesis")),
     _is_prepared(false),
     _needs_prepare_for_use(false),
     _node_to_elem_map_built(false),
     _node_to_active_semilocal_elem_map_built(false),
     _patch_size(getParam<unsigned int>("patch_size")),
     _ghosting_patch_size(isParamValid("ghosting_patch_size")
                              ? getParam<unsigned int>("ghosting_patch_size")
                              : 5 * _patch_size),
     _max_leaf_size(getParam<unsigned int>("max_leaf_size")),
     _patch_update_strategy(
         getParam<MooseEnum>("patch_update_strategy").getEnum<Moose::PatchUpdateType>()),
     _regular_orthogonal_mesh(false),
     _allow_recovery(true),
     _construct_node_list_from_side_list(getParam<bool>("construct_node_list_from_side_list")),
     _prepare_timer(registerTimedSection("prepare", 2)),
     _update_timer(registerTimedSection("update", 3)),
     _mesh_changed_timer(registerTimedSection("meshChanged", 3)),
     _cache_changed_lists_timer(registerTimedSection("cacheChangedLists", 5)),
     _update_active_semi_local_node_range_timer(
         registerTimedSection("updateActiveSemiLocalNodeRange", 5)),
     _build_node_list_timer(registerTimedSection("buildNodeList", 5)),
     _build_bnd_elem_list_timer(registerTimedSection("buildBndElemList", 5)),
     _node_to_elem_map_timer(registerTimedSection("nodeToElemMap", 5)),
     _node_to_active_semilocal_elem_map_timer(
         registerTimedSection("nodeToActiveSemilocalElemMap", 5)),
     _get_active_local_element_range_timer(registerTimedSection("getActiveLocalElementRange", 5)),
     _get_active_node_range_timer(registerTimedSection("getActiveNodeRange", 5)),
     _get_local_node_range_timer(registerTimedSection("getLocalNodeRange", 5)),
     _get_boundary_node_range_timer(registerTimedSection("getBoundaryNodeRange", 5)),
     _get_boundary_element_range_timer(registerTimedSection("getBoundaryElementRange", 5)),
     _cache_info_timer(registerTimedSection("cacheInfo", 3)),
     _build_periodic_node_map_timer(registerTimedSection("buildPeriodicNodeMap", 5)),
     _build_periodic_node_sets_timer(registerTimedSection("buildPeriodicNodeSets", 5)),
     _detect_orthogonal_dim_ranges_timer(registerTimedSection("detectOrthogonalDimRanges", 5)),
     _detect_paired_sidesets_timer(registerTimedSection("detectPairedSidesets", 5)),
     _build_refinement_map_timer(registerTimedSection("buildRefinementMap", 5)),
     _build_coarsening_map_timer(registerTimedSection("buildCoarseningMap", 5)),
     _find_adaptivity_qp_maps_timer(registerTimedSection("findAdaptivityQpMaps", 5)),
     _build_refinement_and_coarsening_maps_timer(
         registerTimedSection("buildRefinementAndCoarseningMaps", 5)),
     _change_boundary_id_timer(registerTimedSection("changeBoundaryId", 6)),
     _init_timer(registerTimedSection("init", 2)),
     _read_recovered_mesh_timer(registerTimedSection("readRecoveredMesh", 2)),
     _ghost_ghosted_boundaries_timer(registerTimedSection("GhostGhostedBoundaries", 3)),
     _add_mortar_interface_timer(registerTimedSection("addMortarInterface", 5)),
     _need_delete(false)
 {
   if (isParamValid("ghosting_patch_size") && (_patch_update_strategy != Moose::Iteration))
     mooseError("Ghosting patch size parameter has to be set in the mesh block "
                "only when 'iteration' patch update strategy is used.");
 }

◆ MooseMesh() [2/2]

MooseMesh::MooseMesh ( const MooseMesh & other_mesh )

Definition at line 217 of file MooseMesh.C.

   : MooseObject(other_mesh._pars),
     Restartable(this, "Mesh"),
     PerfGraphInterface(this, "CopiedMesh"),
     _parallel_type(other_mesh._parallel_type),
     _use_distributed_mesh(other_mesh._use_distributed_mesh),
     _distribution_overridden(other_mesh._distribution_overridden),
     _mesh(other_mesh.getMesh().clone()),
     _partitioner_name(other_mesh._partitioner_name),
     _partitioner_overridden(other_mesh._partitioner_overridden),
     _uniform_refine_level(other_mesh.uniformRefineLevel()),
     _is_nemesis(false),
     _is_prepared(false),
     _needs_prepare_for_use(false),
     _node_to_elem_map_built(false),
     _patch_size(other_mesh._patch_size),
     _ghosting_patch_size(other_mesh._ghosting_patch_size),
     _max_leaf_size(other_mesh._max_leaf_size),
     _patch_update_strategy(other_mesh._patch_update_strategy),
     _regular_orthogonal_mesh(false),
     _construct_node_list_from_side_list(other_mesh._construct_node_list_from_side_list),
     _prepare_timer(registerTimedSection("prepare", 2)),
     _update_timer(registerTimedSection("update", 2)),
     _mesh_changed_timer(registerTimedSection("meshChanged", 3)),
     _cache_changed_lists_timer(registerTimedSection("cacheChangedLists", 5)),
     _update_active_semi_local_node_range_timer(
         registerTimedSection("updateActiveSemiLocalNodeRange", 5)),
     _build_node_list_timer(registerTimedSection("buildNodeList", 5)),
     _build_bnd_elem_list_timer(registerTimedSection("buildBndElemList", 5)),
     _node_to_elem_map_timer(registerTimedSection("nodeToElemMap", 5)),
     _node_to_active_semilocal_elem_map_timer(
         registerTimedSection("nodeToActiveSemilocalElemMap", 5)),
     _get_active_local_element_range_timer(registerTimedSection("getActiveLocalElementRange", 5)),
     _get_active_node_range_timer(registerTimedSection("getActiveNodeRange", 5)),
     _get_local_node_range_timer(registerTimedSection("getLocalNodeRange", 5)),
     _get_boundary_node_range_timer(registerTimedSection("getBoundaryNodeRange", 5)),
     _get_boundary_element_range_timer(registerTimedSection("getBoundaryElementRange", 5)),
     _cache_info_timer(registerTimedSection("cacheInfo", 3)),
     _build_periodic_node_map_timer(registerTimedSection("buildPeriodicNodeMap", 5)),
     _build_periodic_node_sets_timer(registerTimedSection("buildPeriodicNodeSets", 5)),
     _detect_orthogonal_dim_ranges_timer(registerTimedSection("detectOrthogonalDimRanges", 5)),
     _detect_paired_sidesets_timer(registerTimedSection("detectPairedSidesets", 5)),
     _build_refinement_map_timer(registerTimedSection("buildRefinementMap", 5)),
     _build_coarsening_map_timer(registerTimedSection("buildCoarseningMap", 5)),
     _find_adaptivity_qp_maps_timer(registerTimedSection("findAdaptivityQpMaps", 5)),
     _build_refinement_and_coarsening_maps_timer(
         registerTimedSection("buildRefinementAndCoarseningMaps", 5)),
     _change_boundary_id_timer(registerTimedSection("changeBoundaryId", 5)),
     _init_timer(registerTimedSection("init", 2)),
     _read_recovered_mesh_timer(registerTimedSection("readRecoveredMesh", 2)),
     _ghost_ghosted_boundaries_timer(registerTimedSection("GhostGhostedBoundaries", 3)),
     _add_mortar_interface_timer(registerTimedSection("addMortarInterface", 5))
 {
   // Note: this calls BoundaryInfo::operator= without changing the
   // ownership semantics of either Mesh's BoundaryInfo object.
   getMesh().get_boundary_info() = other_mesh.getMesh().get_boundary_info();
 
   const std::set<SubdomainID> & subdomains = other_mesh.meshSubdomains();
   for (const auto & sbd_id : subdomains)
     setSubdomainName(sbd_id, other_mesh.getMesh().subdomain_name(sbd_id));
 
   // Get references to BoundaryInfo objects to make the code below cleaner...
   const BoundaryInfo & other_boundary_info = other_mesh.getMesh().get_boundary_info();
   BoundaryInfo & boundary_info = getMesh().get_boundary_info();
 
   // Use the other BoundaryInfo object to build the list of side boundary ids
   std::vector<BoundaryID> side_boundaries;
   other_boundary_info.build_side_boundary_ids(side_boundaries);
 
   // Assign those boundary ids in our BoundaryInfo object
   for (const auto & side_bnd_id : side_boundaries)
     boundary_info.sideset_name(side_bnd_id) = other_boundary_info.get_sideset_name(side_bnd_id);
 
   // Do the same thing for node boundary ids
   std::vector<BoundaryID> node_boundaries;
   other_boundary_info.build_node_boundary_ids(node_boundaries);
 
   for (const auto & node_bnd_id : node_boundaries)
     boundary_info.nodeset_name(node_bnd_id) = other_boundary_info.get_nodeset_name(node_bnd_id);
 
   _bounds.resize(other_mesh._bounds.size());
   for (std::size_t i = 0; i < _bounds.size(); ++i)
   {
     _bounds[i].resize(other_mesh._bounds[i].size());
     for (std::size_t j = 0; j < _bounds[i].size(); ++j)
       _bounds[i][j] = other_mesh._bounds[i][j];
   }
 }

◆ ~MooseMesh()

MooseMesh::~MooseMesh ( )

virtual

Definition at line 306 of file MooseMesh.C.

 {
   freeBndNodes();
   freeBndElems();
   clearQuadratureNodes();
 }

Member Function Documentation

◆ activeLocalElementsBegin()

MeshBase::const_element_iterator MooseMesh::activeLocalElementsBegin ( )

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

Definition at line 2219 of file MooseMesh.C.

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

 {
   return getMesh().active_local_elements_begin();
 }

◆ activeLocalElementsEnd()

const MeshBase::const_element_iterator MooseMesh::activeLocalElementsEnd ( )

Definition at line 2225 of file MooseMesh.C.

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

 {
   return getMesh().active_local_elements_end();
 }

◆ addGhostedBoundary()

void MooseMesh::addGhostedBoundary ( BoundaryID boundary_id )

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

Definition at line 2375 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
	)

Definition at line 2760 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
	)

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 1486 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
	)

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 927 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`
	)

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 893 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 )

inline

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

Definition at line 805 of file MooseMesh.h.

805 { _allow_recovery = allow; }

MooseMesh::_allow_recovery

bool _allow_recovery

Whether or not this Mesh is allowed to read a recovery file.

Definition: MooseMesh.h:1163

◆ bndElemsBegin()

MooseMesh::bnd_elem_iterator MooseMesh::bndElemsBegin ( )

virtual

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

Definition at line 878 of file MooseMesh.C.

Referenced by 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 ( )

virtual

Definition at line 886 of file MooseMesh.C.

Referenced by 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 ( )

virtual

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

Definition at line 862 of file MooseMesh.C.

Referenced by 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 ( )

virtual

Definition at line 870 of file MooseMesh.C.

Referenced by getBoundaryNodeRange().

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

◆ buildBndElemList()

void MooseMesh::buildBndElemList ( )

Definition at line 669 of file MooseMesh.C.

Referenced by MeshSideSet::modify(), and 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);
   }
 }

◆ buildCoarseningMap()

void MooseMesh::buildCoarseningMap	(	const Elem &	elem,
		QBase &	qrule,
		QBase &	qrule_face,
		int	input_side
	)

private

Build 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.
qrule	The quadrature rule in use.
qrule_face	The current face quadrature rule
input_side	The side to map

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 1705 of file MooseMesh.C.

Referenced by buildRefinementAndCoarseningMaps().

 {
   TIME_SECTION(_build_coarsening_map_timer);
 
   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("Already built a qp coarsening map!");
 
   std::vector<std::vector<QpMap>> refinement_map;
   std::vector<std::pair<unsigned int, QpMap>> & coarsen_map =
       _elem_type_to_coarsening_map[the_pair];
 
   // The -1 here is for a specific child.  We don't do that for coarsening maps
   // Also note that we're always mapping the same side to the same side (which is guaranteed by
   // libMesh).
   findAdaptivityQpMaps(
       &elem, qrule, qrule_face, refinement_map, coarsen_map, input_side, -1, input_side);
 
 }

◆ buildMesh()

virtual void MooseMesh::buildMesh ( )

pure virtual

Must be overridden by child classes.

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

Implemented in PatternedMesh, StitchedMesh, ConcentricCircleMesh, MeshGeneratorMesh, AnnularMesh, DistributedGeneratedMesh, GeneratedMesh, RinglebMesh, SpiralAnnularMesh, ImageMesh, FileMesh, and TiledMesh.

Referenced by init().

◆ buildMeshBaseObject()

std::unique_ptr< MeshBase > MooseMesh::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.

Definition at line 1971 of file MooseMesh.C.

Referenced by 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 ( )

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 635 of file MooseMesh.C.

Referenced by 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 ( )

Calls BoundaryInfo::build_node_list_from_side_list().

Definition at line 2169 of file MooseMesh.C.

Referenced by prepare(), and 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

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

Definition at line 1173 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

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

Definition at line 1258 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 )

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 1567 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);
   }
 }

◆ buildRefinementMap()

void MooseMesh::buildRefinementMap	(	const Elem &	elem,
		QBase &	qrule,
		QBase &	qrule_face,
		int	parent_side,
		int	child,
		int	child_side
	)

private

Build 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.
qrule	The quadrature rule in use.
qrule_face	The current face quadrature rule
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)

Definition at line 1626 of file MooseMesh.C.

Referenced by buildRefinementAndCoarseningMaps().

 {
   TIME_SECTION(_build_refinement_map_timer);
 
   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("Already built a qp refinement map!");
 
     std::vector<std::pair<unsigned int, QpMap>> coarsen_map;
     std::vector<std::vector<QpMap>> & refinement_map = _elem_type_to_refinement_map[the_pair];
     findAdaptivityQpMaps(
         &elem, qrule, qrule_face, refinement_map, coarsen_map, parent_side, child, child_side);
   }
   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("Already built a qp refinement map!");
 
     std::vector<std::pair<unsigned int, QpMap>> coarsen_map;
     std::vector<std::vector<QpMap>> & refinement_map =
         _elem_type_to_child_side_refinement_map[elem.type()][child_pair];
     findAdaptivityQpMaps(
         &elem, qrule, qrule_face, refinement_map, coarsen_map, parent_side, child, 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
	)

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 2176 of file MooseMesh.C.

Referenced by PenetrationLocator::detectPenetration(), and InterfaceQpValueUserObject::initialize().

 {
 #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 ( )

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

Definition at line 2195 of file MooseMesh.C.

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

◆ cacheChangedLists()

void MooseMesh::cacheChangedLists ( )

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

Definition at line 523 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 ( )

protected

Definition at line 822 of file MooseMesh.C.

Referenced by 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
	)

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 1913 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 ( )

Clear out any existing quadrature nodes.

Most likely called before re-adding them.

Definition at line 997 of file MooseMesh.C.

Referenced by GeometricSearchData::reinit(), and ~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

virtual

Clone method.

Allocates memory you are responsible to clean up.

Definition at line 1965 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

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 553 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

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 547 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 271 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 282 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 204 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 211 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 218 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 231 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 247 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 254 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 )

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 1285 of file MooseMesh.C.

Referenced by AddPeriodicBCAction::autoTranslationBoundaries(), and 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;
 }

◆ detectPairedSidesets()

void MooseMesh::detectPairedSidesets ( )

private

This routine detects paired sidesets of a regular orthogonal mesh (.i.e.

parallel sidesets "across" from one and other). The _paired_boundary datastructure is populated with this information.

Definition at line 1359 of file MooseMesh.C.

Referenced by getPairedBoundaryMapping().

 {
   TIME_SECTION(_detect_paired_sidesets_timer);
 
   // Loop over level-0 elements (since boundary condition information
   // is only directly stored for them) and find sidesets with normals
   // that point in the -x, +x, -y, +y, and -z, +z direction.  If there
   // is a unique sideset id for each direction, then the paired
   // sidesets consist of (-x,+x), (-y,+y), (-z,+z).  If there are
   // multiple sideset ids for a given direction, then we can't pick a
   // single pair for that direction.  In that case, we'll just return
   // as was done in the original algorithm.
 
   // Points used for direction comparison
   const Point minus_x(-1, 0, 0), plus_x(1, 0, 0), minus_y(0, -1, 0), plus_y(0, 1, 0),
       minus_z(0, 0, -1), plus_z(0, 0, 1);
 
   // we need to test all element dimensions from dim down to 1
   const unsigned int dim = getMesh().mesh_dimension();
 
   // boundary id sets for elements of different dimensions
   std::vector<std::set<BoundaryID>> minus_x_ids(dim), plus_x_ids(dim), minus_y_ids(dim),
       plus_y_ids(dim), minus_z_ids(dim), plus_z_ids(dim);
 
   std::vector<std::unique_ptr<FEBase>> fe_faces(dim);
   std::vector<std::unique_ptr<QGauss>> qfaces(dim);
   for (unsigned side_dim = 0; side_dim < dim; ++side_dim)
   {
     // Face is assumed to be flat, therefore normal is assumed to be
     // constant over the face, therefore only compute it at 1 qp.
     qfaces[side_dim] = std::unique_ptr<QGauss>(new QGauss(side_dim, CONSTANT));
 
     // A first-order Lagrange FE for the face.
     fe_faces[side_dim] = FEBase::build(side_dim + 1, FEType(FIRST, LAGRANGE));
     fe_faces[side_dim]->attach_quadrature_rule(qfaces[side_dim].get());
   }
 
   // We need this to get boundary ids for each boundary face we encounter.
   BoundaryInfo & boundary_info = getMesh().get_boundary_info();
   std::vector<boundary_id_type> face_ids;
 
   for (auto & elem : as_range(getMesh().level_elements_begin(0), getMesh().level_elements_end(0)))
   {
     // dimension of the current element and its normals
     unsigned int side_dim = elem->dim() - 1;
     const std::vector<Point> & normals = fe_faces[side_dim]->get_normals();
 
     // loop over element sides
     for (unsigned int s = 0; s < elem->n_sides(); s++)
     {
       // If side is on the boundary
       if (elem->neighbor_ptr(s) == nullptr)
       {
         std::unique_ptr<Elem> side = elem->build_side_ptr(s);
 
         fe_faces[side_dim]->reinit(elem, s);
 
         // Get the boundary ID(s) for this side.  If there is more
         // than 1 boundary id, then we already can't determine a
         // unique pairing of sides in this direction, but we'll just
         // keep going to keep the logic simple.
         boundary_info.boundary_ids(elem, s, face_ids);
 
         // x-direction faces
         if (normals[0].absolute_fuzzy_equals(minus_x))
           minus_x_ids[side_dim].insert(face_ids.begin(), face_ids.end());
         else if (normals[0].absolute_fuzzy_equals(plus_x))
           plus_x_ids[side_dim].insert(face_ids.begin(), face_ids.end());
 
         // y-direction faces
         else if (normals[0].absolute_fuzzy_equals(minus_y))
           minus_y_ids[side_dim].insert(face_ids.begin(), face_ids.end());
         else if (normals[0].absolute_fuzzy_equals(plus_y))
           plus_y_ids[side_dim].insert(face_ids.begin(), face_ids.end());
 
         // z-direction faces
         else if (normals[0].absolute_fuzzy_equals(minus_z))
           minus_z_ids[side_dim].insert(face_ids.begin(), face_ids.end());
         else if (normals[0].absolute_fuzzy_equals(plus_z))
           plus_z_ids[side_dim].insert(face_ids.begin(), face_ids.end());
       }
     }
   }
 
   for (unsigned side_dim = 0; side_dim < dim; ++side_dim)
   {
     // If unique pairings were found, fill up the _paired_boundary data
     // structure with that information.
     if (minus_x_ids[side_dim].size() == 1 && plus_x_ids[side_dim].size() == 1)
       _paired_boundary.emplace_back(
           std::make_pair(*(minus_x_ids[side_dim].begin()), *(plus_x_ids[side_dim].begin())));
 
     if (minus_y_ids[side_dim].size() == 1 && plus_y_ids[side_dim].size() == 1)
       _paired_boundary.emplace_back(
           std::make_pair(*(minus_y_ids[side_dim].begin()), *(plus_y_ids[side_dim].begin())));
 
     if (minus_z_ids[side_dim].size() == 1 && plus_z_ids[side_dim].size() == 1)
       _paired_boundary.emplace_back(
           std::make_pair(*(minus_z_ids[side_dim].begin()), *(plus_z_ids[side_dim].begin())));
   }
 }

◆ dimension()

unsigned int MooseMesh::dimension ( ) const

virtual

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

Definition at line 2135 of file MooseMesh.C.

Referenced by addPeriodicVariable(), AddPeriodicBCAction::autoTranslationBoundaries(), FunctionPeriodicBoundary::FunctionPeriodicBoundary(), getPairedBoundaryMapping(), isTranslatedPeriodic(), 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

Returns the width of the requested dimension.

Definition at line 1462 of file MooseMesh.C.

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

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

◆ effectiveSpatialDimension()

unsigned int MooseMesh::effectiveSpatialDimension ( ) const

virtual

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 2141 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 )

virtual

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 2255 of file MooseMesh.C.

Referenced by addMortarInterface(), addQuadratureNode(), buildCoarseningMap(), AnnularMesh::buildMesh(), RinglebMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), ConcentricCircleMesh::buildMesh(), buildRefinementAndCoarseningMaps(), buildRefinementMap(), cacheInfo(), changeBoundaryId(), coarsenedElementChildren(), detectPairedSidesets(), findAdaptivityQpMaps(), getBoundaryIDs(), getCoarseningMap(), getQuadratureNode(), getRefinementMap(), ghostGhostedBoundaries(), nodeToActiveSemilocalElemMap(), nodeToElemMap(), prepare(), sideWithBoundaryID(), and 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

virtual

Definition at line 2262 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 )

virtual

Definition at line 2269 of file MooseMesh.C.

Referenced by FEProblemBase::addGhostedElem(), SystemBase::augmentSendList(), NodalPatchRecovery::compute(), dataLoad(), 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

virtual

Definition at line 2275 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().

96 { return _enabled; }

MooseObject::_enabled

const bool & _enabled

Reference to the "enable" InputParaemters, used by Controls for toggling on/off MooseObjects.

Definition: MooseObject.h:183

◆ errorIfDistributedMesh()

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

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 2687 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

virtual

Not implemented – always returns NULL.

Reimplemented in FileMesh.

Definition at line 2583 of file MooseMesh.C.

Referenced by FEProblemBase::initialSetup().

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

◆ findAdaptivityQpMaps()

void MooseMesh::findAdaptivityQpMaps	(	const Elem *	template_elem,
		QBase &	qrule,
		QBase &	qrule_face,
		std::vector< std::vector< QpMap >> &	refinement_map,
		std::vector< std::pair< unsigned int, QpMap >> &	coarsen_map,
		int	parent_side,
		int	child,
		int	child_side
	)

private

Given an elem type, get maps that tell us what qp's are closest to each other between a parent and it's children.

This is mainly used for mapping stateful material properties during adaptivity.

There are 3 cases here:

Volume to volume (parent_side = -1, child = -1, child_side = -1)
Parent side to child side (parent_side = 0+, child = -1, child_side = 0+)
Child side to parent volume (parent_side = -1, child = 0+, child_side = 0+)

Case 3 only happens under refinement (need to invent data at internal child sides).

Parameters

template_elem	An element of the type that we need to find the maps for
qrule	The quadrature rule that we need to find the maps for
qrule_face	The face quadrature rule that we need to find the maps for
refinement_map	The map to use when an element gets split
coarsen_map	The map to use when an element is coarsened.
parent_side	- the id of the parent's side
child	- the id of the child element
child_side	- The id of the child's side

Definition at line 1775 of file MooseMesh.C.

Referenced by buildCoarseningMap(), and buildRefinementMap().

 {
   TIME_SECTION(_find_adaptivity_qp_maps_timer);
 
   ReplicatedMesh mesh(_communicator);
   mesh.skip_partitioning(true);
 
   unsigned int dim = template_elem->dim();
   mesh.set_mesh_dimension(dim);
 
   for (unsigned int i = 0; i < template_elem->n_nodes(); ++i)
     mesh.add_point(template_elem->point(i));
 
   Elem * elem = mesh.add_elem(Elem::build(template_elem->type()).release());
 
   for (unsigned int i = 0; i < template_elem->n_nodes(); ++i)
     elem->set_node(i) = mesh.node_ptr(i);
 
   std::unique_ptr<FEBase> fe(FEBase::build(dim, FEType()));
   fe->get_phi();
   const std::vector<Point> & q_points_volume = fe->get_xyz();
 
   std::unique_ptr<FEBase> fe_face(FEBase::build(dim, FEType()));
   fe_face->get_phi();
   const std::vector<Point> & q_points_face = fe_face->get_xyz();
 
   fe->attach_quadrature_rule(&qrule);
   fe_face->attach_quadrature_rule(&qrule_face);
 
   // The current q_points
   const std::vector<Point> * q_points;
 
   if (parent_side != -1)
   {
     fe_face->reinit(elem, parent_side);
     q_points = &q_points_face;
   }
   else
   {
     fe->reinit(elem);
     q_points = &q_points_volume;
   }
 
   std::vector<Point> parent_ref_points;
 
   FEInterface::inverse_map(elem->dim(), FEType(), elem, *q_points, parent_ref_points);
   MeshRefinement mesh_refinement(mesh);
   mesh_refinement.uniformly_refine(1);
 
   std::map<unsigned int, std::vector<Point>> child_to_ref_points;
 
   unsigned int n_children = elem->n_children();
 
   refinement_map.resize(n_children);
 
   std::vector<unsigned int> children;
 
   if (child != -1) // Passed in a child explicitly
     children.push_back(child);
   else
   {
     children.resize(n_children);
     for (unsigned int child = 0; child < n_children; ++child)
       children[child] = child;
   }
 
   for (unsigned int i = 0; i < children.size(); ++i)
   {
     unsigned int child = children[i];
 
     if ((parent_side != -1 && !elem->is_child_on_side(child, parent_side)))
       continue;
 
     const Elem * child_elem = elem->child_ptr(child);
 
     if (child_side != -1)
     {
       fe_face->reinit(child_elem, child_side);
       q_points = &q_points_face;
     }
     else
     {
       fe->reinit(child_elem);
       q_points = &q_points_volume;
     }
 
     std::vector<Point> child_ref_points;
 
     FEInterface::inverse_map(elem->dim(), FEType(), elem, *q_points, child_ref_points);
     child_to_ref_points[child] = child_ref_points;
 
     std::vector<QpMap> & qp_map = refinement_map[child];
 
     // Find the closest parent_qp to each child_qp
     mapPoints(child_ref_points, parent_ref_points, qp_map);
   }
 
   coarsen_map.resize(parent_ref_points.size());
 
   // For each parent qp find the closest child qp
   for (unsigned int child = 0; child < n_children; child++)
   {
     if (parent_side != -1 && !elem->is_child_on_side(child, child_side))
       continue;
 
     std::vector<Point> & child_ref_points = child_to_ref_points[child];
 
     std::vector<QpMap> qp_map;
 
     // Find all of the closest points from parent_qp to _THIS_ child's qp
     mapPoints(parent_ref_points, child_ref_points, qp_map);
 
     // Check those to see if they are closer than what we currently have for each point
     for (unsigned int parent_qp = 0; parent_qp < parent_ref_points.size(); ++parent_qp)
     {
       std::pair<unsigned int, QpMap> & child_and_map = coarsen_map[parent_qp];
       unsigned int & closest_child = child_and_map.first;
       QpMap & closest_map = child_and_map.second;
 
       QpMap & current_map = qp_map[parent_qp];
 
       if (current_map._distance < closest_map._distance)
       {
         closest_child = child;
         closest_map = current_map;
       }
     }
   }
 }

◆ freeBndElems()

void MooseMesh::freeBndElems ( )

protected

Definition at line 332 of file MooseMesh.C.

Referenced by buildBndElemList(), and ~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 ( )

protected

Definition at line 314 of file MooseMesh.C.

Referenced by buildNodeList(), and ~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 ( )

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

Definition at line 739 of file MooseMesh.C.

Referenced by NonlinearSystemBase::computeDamping(), AuxiliarySystem::computeElementalVarsHelper(), FEProblemBase::computeIndicators(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeMarkers(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjects(), FEProblemBase::createQRules(), LayeredBase::getBounds(), NonlinearSystemBase::init(), FEProblemBase::initialSetup(), meshChanged(), DOFMapOutput::output(), FEProblemBase::projectSolution(), NonlinearSystemBase::setVariableGlobalDoFs(), PicardSolve::solve(), TransientMultiApp::solveStep(), 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 ( )

Definition at line 753 of file MooseMesh.C.

Referenced by 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

Definition at line 767 of file MooseMesh.C.

 {
   mooseAssert(_active_semilocal_node_range,
               "_active_semilocal_node_range has not been created yet!");
 
   return _active_semilocal_node_range.get();
 }

◆ getBoundariesToElems()

const std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > & MooseMesh::getBoundariesToElems ( ) const

Returns a map of boundaries to elements.

Definition at line 816 of file MooseMesh.C.

 {
   return _bnd_elem_ids;
 }

◆ getBoundaryElementRange()

ConstBndElemRange * MooseMesh::getBoundaryElementRange ( )

Definition at line 803 of file MooseMesh.C.

Referenced by AuxiliarySystem::computeElementalVarsHelper(), DMMooseGetEmbedding_Private(), GeometricSearchData::generateQuadratureNodes(), MultiAppNearestNodeTransfer::getLocalEntities(), 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

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 1009 of file MooseMesh.C.

Referenced by AddPeriodicBCAction::act(), 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

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

Definition at line 2155 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

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 2163 of file MooseMesh.C.

Referenced by 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

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 1024 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 )

Return the name of the boundary given the id.

Definition at line 1148 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 ( )

Definition at line 790 of file MooseMesh.C.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), AuxiliarySystem::computeNodalVarsHelper(), NonlinearSystemBase::computeResidualInternal(), DMMooseGetEmbedding_Private(), NearestNodeLocator::findNodes(), MultiAppNearestNodeTransfer::getLocalEntities(), MultiAppNearestNodeTransfer::getNearestNode(), 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
	)

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 1733 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

inlinevirtual

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 862 of file MooseMesh.h.

862 { return ""; }

◆ getGhostedBoundaries()

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

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

Definition at line 2387 of file MooseMesh.C.

 {
   return _ghosted_boundaries;
 }

◆ getGhostedBoundaryInflation()

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

Return a writable reference to the _ghosted_boundaries_inflation vector.

Definition at line 2393 of file MooseMesh.C.

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

 {
   return _ghosted_boundaries_inflation;
 }

◆ getGhostingPatchSize()

unsigned int MooseMesh::getGhostingPatchSize ( ) const

inline

Getter for the ghosting_patch_size parameter.

Definition at line 475 of file MooseMesh.h.

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

475 { return _ghosting_patch_size; };

MooseMesh::_ghosting_patch_size

unsigned int _ghosting_patch_size

The number of nearest neighbors to consider for ghosting purposes when iteration patch update strateg...

Definition: MooseMesh.h:1024

◆ getInflatedProcessorBoundingBox()

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

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 2546 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 ( )

Definition at line 776 of file MooseMesh.C.

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianInternal(), AuxiliarySystem::computeNodalVarsHelper(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjects(), NonlinearSystemBase::init(), and 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 MooseMesh::getMaxInDimension ( unsigned int component ) const

virtual

Reimplemented in AnnularMesh, DistributedGeneratedMesh, and GeneratedMesh.

Definition at line 1477 of file MooseMesh.C.

Referenced by dimensionWidth(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), and DistributedGeneratedMesh::getMaxInDimension().

 {
   mooseAssert(_mesh, "The MeshBase has not been constructed");
   mooseAssert(component < _bounds.size(), "Requested dimension out of bounds");
 
   return _bounds[component][MAX];
 }

◆ getMaxLeafSize()

unsigned int MooseMesh::getMaxLeafSize ( ) const

inline

Getter for the maximum leaf size parameter.

Definition at line 480 of file MooseMesh.h.

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

480 { return _max_leaf_size; };

MooseMesh::_max_leaf_size

unsigned int _max_leaf_size

Definition: MooseMesh.h:1027

◆ getMesh() [1/2]

MeshBase & MooseMesh::getMesh ( )

Accessor for the underlying libMesh Mesh object.

Definition at line 2569 of file MooseMesh.C.

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

Definition at line 2576 of file MooseMesh.C.

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

◆ getMinInDimension()

Real MooseMesh::getMinInDimension ( unsigned int component ) const

virtual

Returns the min or max of the requested dimension respectively.

Reimplemented in AnnularMesh, DistributedGeneratedMesh, and GeneratedMesh.

Definition at line 1468 of file MooseMesh.C.

Referenced by dimensionWidth(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), and DistributedGeneratedMesh::getMinInDimension().

 {
   mooseAssert(_mesh, "The MeshBase has not been constructed");
   mooseAssert(component < _bounds.size(), "Requested dimension out of bounds");
 
   return _bounds[component][MIN];
 }

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

91 { return _app; }

MooseObject::_app

MooseApp & _app

The MooseApp this object is associated with.

Definition: MooseObject.h:174

◆ getMortarInterface()

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

Definition at line 2708 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 )

Definition at line 2698 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 ( )

inline

Definition at line 825 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

Return list of blocks to which the given node belongs.

Definition at line 849 of file MooseMesh.C.

Referenced by BreakMeshByBlock::modify(), ComputeNodalUserObjectsThread::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

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

Definition at line 2596 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

Returns the normal vector associated with a given BoundaryID.

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

Definition at line 1955 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 )

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 1549 of file MooseMesh.C.

Referenced by 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(), GhostingUserObject::GhostingUserObject(), 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

Getter for the patch_size parameter.

Definition at line 2528 of file MooseMesh.C.

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

 {
   return _patch_size;
 }

◆ getPatchUpdateStrategy()

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

Get the current patch update strategy.

Definition at line 2540 of file MooseMesh.C.

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches().

 {
   return _patch_update_strategy;
 }

◆ getPointLocator()

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

virtual

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 2754 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
	)

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 979 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
	)

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 1669 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

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 2623 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

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 1077 of file MooseMesh.C.

Referenced by 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

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 1092 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 )

Return the name of a block given an id.

Definition at line 1126 of file MooseMesh.C.

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

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

◆ ghostGhostedBoundaries()

void MooseMesh::ghostGhostedBoundaries ( )

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

Definition at line 2457 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 ( )

check if the mesh has SECOND order elements

Definition at line 2732 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 ( )

virtual

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 2034 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

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

Definition at line 2661 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

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

Definition at line 2676 of file MooseMesh.C.

 {
   bool found_elem = false;
   auto 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

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

Definition at line 2635 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

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

Definition at line 2650 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

Setter and getter for _custom_partitioner_requested.

Definition at line 2726 of file MooseMesh.C.

 {
   return _custom_partitioner_requested;
 }

◆ isDistributedMesh()

bool MooseMesh::isDistributedMesh ( ) const

inline

Returns the final Mesh distribution type.

Definition at line 785 of file MooseMesh.h.

Referenced by AddPeriodicBCAction::autoTranslationBoundaries(), VerifyNodalUniqueID::finalize(), VerifyElementUniqueID::finalize(), ConsoleUtils::outputMeshInformation(), and RandomData::updateGenerators().

785 { return _use_distributed_mesh; }

MooseMesh::_use_distributed_mesh

bool _use_distributed_mesh

False by default.

Definition: MooseMesh.h:891

◆ isParallelTypeForced()

bool MooseMesh::isParallelTypeForced ( ) const

inline

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

Definition at line 790 of file MooseMesh.h.

Referenced by ConsoleUtils::outputMeshInformation().

790 { return _parallel_type_overridden; }

MooseMesh::_parallel_type_overridden

bool _parallel_type_overridden

Definition: MooseMesh.h:893

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

86 { return _pars.isParamValid(name); }

MooseObject::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseObject.h:171

MooseObject::name

const std::string & name() const

Get the name of the object.

Definition: MooseObject.h:56

InputParameters::isParamValid

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

This method returns parameters that have been initialized in one fashion or another, i.e.

Definition: InputParameters.C:257

◆ isPartitionerForced()

bool MooseMesh::isPartitionerForced ( ) const

inline

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

Definition at line 800 of file MooseMesh.h.

Referenced by ConsoleUtils::outputMeshInformation().

800 { return _partitioner_overridden; }

MooseMesh::_partitioner_overridden

bool _partitioner_overridden

Definition: MooseMesh.h:900

◆ isRegularOrthogonal()

bool MooseMesh::isRegularOrthogonal ( )

inline

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

Definition at line 847 of file MooseMesh.h.

847 { return _regular_orthogonal_mesh; }

MooseMesh::_regular_orthogonal_mesh

bool _regular_orthogonal_mesh

Boolean indicating whether this mesh was detected to be regular and orthogonal.

Definition: MooseMesh.h:1036

◆ isSemiLocal()

bool MooseMesh::isSemiLocal ( Node * node )

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 602 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

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 1507 of file MooseMesh.C.

Referenced by 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 ( )

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

Definition at line 2207 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 ( )

Definition at line 2213 of file MooseMesh.C.

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

 {
   return getMesh().local_nodes_end();
 }

◆ mapPoints()

void MooseMesh::mapPoints	(	const std::vector< Point > &	from,
		const std::vector< Point > &	to,
		std::vector< QpMap > &	qp_map
	)

private

Find the closest points that map "from" to "to" and fill up "qp_map".

Essentially, for each point in "from" find the closest point in "to".

Parameters

from	The reference positions in the parent of the the points we're mapping from
to	The reference positions in the parent of the the points we're mapping to
qp_map	This will be filled with QpMap objects holding the mappings.

Definition at line 1744 of file MooseMesh.C.

Referenced by findAdaptivityQpMaps().

 {
   unsigned int n_from = from.size();
   unsigned int n_to = to.size();
 
   qp_map.resize(n_from);
 
   for (unsigned int i = 0; i < n_from; ++i)
   {
     const Point & from_point = from[i];
 
     QpMap & current_map = qp_map[i];
 
     for (unsigned int j = 0; j < n_to; ++j)
     {
       const Point & to_point = to[j];
       Real distance = (from_point - to_point).norm();
 
       if (distance < current_map._distance)
       {
         current_map._distance = distance;
         current_map._from = i;
         current_map._to = j;
       }
     }
   }
 }

◆ maxElemId()

dof_id_type MooseMesh::maxElemId ( ) const

virtual

Definition at line 2249 of file MooseMesh.C.

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

 {
   return getMesh().max_elem_id();
 }

◆ maxNodeId()

dof_id_type MooseMesh::maxNodeId ( ) const

virtual

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 2243 of file MooseMesh.C.

 {
   return getMesh().max_node_id();
 }

◆ meshBoundaryIds()

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

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

Definition at line 2324 of file MooseMesh.C.

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

 {
   return _mesh_boundary_ids;
 }

◆ meshChanged()

void MooseMesh::meshChanged ( )

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 492 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

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

Definition at line 2336 of file MooseMesh.C.

Referenced by BoundaryRestrictable::initializeBoundaryRestrictable().

 {
   return _mesh_nodeset_ids;
 }

◆ meshSidesetIds()

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

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

Definition at line 2330 of file MooseMesh.C.

Referenced by BoundaryRestrictable::initializeBoundaryRestrictable().

 {
   return _mesh_sideset_ids;
 }

◆ meshSubdomains()

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

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

Definition at line 2318 of file MooseMesh.C.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::checkUserObjects(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), MultiApp::getBoundingBox(), BlockRestrictable::initializeBlockRestrictable(), BlockRestrictable::isBlockSubset(), BlockRestrictable::meshBlockIDs(), 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

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 1543 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

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 1518 of file MooseMesh.C.

Referenced by 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(), buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), FEProblemBase::computeResidual(), Material::declarePropertyOld(), Material::declarePropertyOlder(), elem(), MultiAppTransfer::execFlags(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::getVectorPostprocessorValue(), FEProblemBase::getVectorPostprocessorValueOld(), NodalScalarKernel::NodalScalarKernel(), node(), PercentChangePostprocessor::PercentChangePostprocessor(), 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.

                                                       {
     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(), getBoundaryIDs(), FEProblemBase::getMaterial(), 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.

56 { return _name; }

MooseObject::_name

const std::string & _name

The name of this object, reference to value stored in InputParameters.

Definition: MooseObject.h:180

◆ needsPrepareForUse()

void MooseMesh::needsPrepareForUse ( )

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 2312 of file MooseMesh.C.

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

 {
   _needs_prepare_for_use = true;
 }

◆ needsRemoteElemDeletion() [1/2]

void MooseMesh::needsRemoteElemDeletion ( bool need_delete )

inline

Set whether we need to delete remote elements.

Definition at line 870 of file MooseMesh.h.

870 { _need_delete = need_delete; }

MooseMesh::_need_delete

bool _need_delete

Whether we need to delete remote elements after init'ing the EquationSystems.

Definition: MooseMesh.h:1199

◆ needsRemoteElemDeletion() [2/2]

bool MooseMesh::needsRemoteElemDeletion ( ) const

inline

Whether we need to delete remote elements.

Definition at line 875 of file MooseMesh.h.

875 { return _need_delete; }

MooseMesh::_need_delete

bool _need_delete

Whether we need to delete remote elements after init'ing the EquationSystems.

Definition: MooseMesh.h:1199

◆ nElem()

dof_id_type MooseMesh::nElem ( ) const

virtual

Definition at line 2237 of file MooseMesh.C.

 {
   return getMesh().n_elem();
 }

◆ nNodes()

dof_id_type MooseMesh::nNodes ( ) const

virtual

Calls n_nodes/elem() on the underlying

Classes

Public Types

Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ bnd_elem_iterator_imp

◆ bnd_node_iterator_imp

◆ const_bnd_elem_iterator_imp

◆ const_bnd_node_iterator_imp

◆ PeriodicNodeInfo

Member Enumeration Documentation

◆ anonymous enum

◆ anonymous enum

◆ ParallelType

Constructor & Destructor Documentation

◆ MooseMesh() [1/2]

◆ MooseMesh() [2/2]

◆ ~MooseMesh()

Member Function Documentation

◆ activeLocalElementsBegin()

◆ activeLocalElementsEnd()

◆ addGhostedBoundary()

◆ addMortarInterface()

◆ addPeriodicVariable()

◆ addQuadratureNode()

◆ addUniqueNode()

◆ allowRecovery()

◆ bndElemsBegin()

◆ bndElemsEnd()

◆ bndNodesBegin()

◆ bndNodesEnd()

◆ buildBndElemList()

◆ buildCoarseningMap()

◆ buildMesh()

◆ buildMeshBaseObject()

◆ buildNodeList()

◆ buildNodeListFromSideList()

◆ buildPeriodicNodeMap()

◆ buildPeriodicNodeSets()

◆ buildRefinementAndCoarseningMaps()

◆ buildRefinementMap()

◆ buildSideList() [1/2]

◆ buildSideList() [2/2]

◆ cacheChangedLists()

◆ cacheInfo()

◆ changeBoundaryId()

◆ clearQuadratureNodes()

◆ clone()

◆ coarsenedElementChildren()

◆ coarsenedElementRange()

◆ declareRecoverableData() [1/2]

◆ declareRecoverableData() [2/2]

◆ declareRestartableData() [1/2]

◆ declareRestartableData() [2/2]

◆ declareRestartableDataWithContext() [1/2]

◆ declareRestartableDataWithContext() [2/2]

◆ declareRestartableDataWithObjectName()

◆ declareRestartableDataWithObjectNameWithContext()

◆ detectOrthogonalDimRanges()

◆ detectPairedSidesets()

◆ dimension()

◆ dimensionWidth()

◆ effectiveSpatialDimension()

◆ elem() [1/2]

◆ elem() [2/2]

◆ elemPtr() [1/2]

◆ elemPtr() [2/2]

◆ enabled()

◆ errorIfDistributedMesh()

◆ exReader()

◆ findAdaptivityQpMaps()

◆ freeBndElems()

◆ freeBndNodes()

◆ getActiveLocalElementRange()