MooseMesh Class Reference

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:

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
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 ()
	Destructor. More...
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...
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...
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...
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...
ConstElemRange *	getActiveLocalElementRange ()
	Return pointers to range objects for various types of ranges (local nodes, boundary elems, etc.). More...
NodeRange *	getActiveNodeRange ()
SemiLocalNodeRange *	getActiveSemiLocalNodeRange () const
ConstNodeRange *	getLocalNodeRange ()
StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > *	getBoundaryNodeRange ()
StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > *	getBoundaryElementRange ()
const std::set< SubdomainID > &	meshSubdomains () const
	Returns a read-only reference to the set of subdomains currently present in the Mesh. More...
const std::set< BoundaryID > &	meshBoundaryIds () const
	Returns a read-only reference to the set of boundary IDs currently present in the Mesh. More...
const std::set< BoundaryID > &	meshSidesetIds () const
	Returns a read-only reference to the set of sidesets currently present in the Mesh. More...
const std::set< BoundaryID > &	meshNodesetIds () const
	Returns a read-only reference to the set of nodesets currently present in the Mesh. More...
void	setBoundaryToNormalMap (std::unique_ptr< std::map< BoundaryID, RealVectorValue >> boundary_map)
	Sets the mapping between BoundaryID and normal vector Is called by AddAllSideSetsByNormals. More...
void	setBoundaryToNormalMap (std::map< BoundaryID, RealVectorValue > *boundary_map)
void	setMeshBoundaryIDs (std::set< BoundaryID > boundary_IDs)
	Sets the set of BoundaryIDs Is called by AddAllSideSetsByNormals. More...
const RealVectorValue &	getNormalByBoundaryID (BoundaryID id) const
	Returns the normal vector associated with a given BoundaryID. More...
void	prepare (bool force=false)
	Calls prepare_for_use() if force=true on the underlying Mesh object, then communicates various boundary information on parallel meshes. More...
void	update ()
	Calls buildNodeListFromSideList(), buildNodeList(), and buildBndElemList(). More...
unsigned int	uniformRefineLevel () const
	Returns the level of uniform refinement requested (zero if AMR is disabled). More...
void	setUniformRefineLevel (unsigned int)
	Set uniform refinement level. More...
void	addGhostedBoundary (BoundaryID boundary_id)
	This will add the boundary ids to be ghosted to this processor. More...
void	setGhostedBoundaryInflation (const std::vector< Real > &inflation)
	This sets the inflation amount for the bounding box for each partition for use in ghosting boundaries. More...
const std::set< unsigned int > &	getGhostedBoundaries () const
	Return a writable reference to the set of ghosted boundary IDs. More...
const std::vector< Real > &	getGhostedBoundaryInflation () const
	Return a writable reference to the _ghosted_boundaries_inflation vector. More...
void	ghostGhostedBoundaries ()
	Actually do the ghosting of boundaries that need to be ghosted to this processor. More...
unsigned int	getPatchSize () const
	Getter for the patch_size parameter. More...
unsigned int	getGhostingPatchSize () const
	Getter for the ghosting_patch_size parameter. More...
unsigned int	getMaxLeafSize () const
	Getter for the maximum leaf size parameter. More...
void	setPatchUpdateStrategy (Moose::PatchUpdateType patch_update_strategy)
	Set the patch size update strategy. More...
const Moose::PatchUpdateType &	getPatchUpdateStrategy () const
	Get the current patch update strategy. More...
BoundingBox	getInflatedProcessorBoundingBox (Real inflation_multiplier=0.01) const
	Get a (slightly inflated) processor bounding box. More...
	operator libMesh::MeshBase & ()
	Implicit conversion operator from MooseMesh -> libMesh::MeshBase. More...
	operator const libMesh::MeshBase & () const
MeshBase &	getMesh ()
	Accessor for the underlying libMesh Mesh object. More...
const MeshBase &	getMesh () const
virtual ExodusII_IO *	exReader () const
	Not implemented – always returns NULL. More...
void	printInfo (std::ostream &os=libMesh::out) const
	Calls print_info() on the underlying Mesh. More...
const std::set< SubdomainID > &	getNodeBlockIds (const Node &node) const
	Return list of blocks to which the given node belongs. More...
const std::vector< dof_id_type > &	getNodeList (boundary_id_type nodeset_id) const
	Return a writable reference to a vector of node IDs that belong to nodeset_id. More...
const Node *	addUniqueNode (const Point &p, Real tol=1e-6)
	Add a new node to the mesh. More...
Node *	addQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp, BoundaryID bid, const Point &point)
	Adds a fictitious "QuadratureNode". More...
Node *	getQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp)
	Get a specified quadrature node. More...
void	clearQuadratureNodes ()
	Clear out any existing quadrature nodes. More...
BoundaryID	getBoundaryID (const BoundaryName &boundary_name) const
	Get the associated BoundaryID for the boundary name. More...
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...
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
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...
MooseEnum	_mesh_parallel_type
	Can be set to DISTRIBUTED, REPLICATED, or DEFAULT. More...
bool	_use_distributed_mesh
	False by default. More...
bool	_distribution_overridden
bool	_parallel_type_overridden
std::unique_ptr< libMesh::MeshBase >	_mesh
	Pointer to underlying libMesh mesh object. More...
MooseEnum	_partitioner_name
	The partitioner used on this mesh. More...
bool	_partitioner_overridden
std::unique_ptr< Partitioner >	_custom_partitioner
	The custom partitioner. More...
bool	_custom_partitioner_requested
unsigned int	_uniform_refine_level
	The level of uniform refinement requested (set to zero if AMR is disabled) More...
bool	_is_changed
	true if mesh is changed (i.e. after adaptivity step) More...
bool	_is_nemesis
	True if a Nemesis Mesh was read in. More...
bool	_is_prepared
	True if prepare has been called on the mesh. More...
bool	_needs_prepare_for_use
	True if prepare_for_use should be called when Mesh is prepared. More...
std::unique_ptr< ConstElemPointerRange >	_refined_elements
	The elements that were just refined. More...
std::unique_ptr< ConstElemPointerRange >	_coarsened_elements
	The elements that were just coarsened. More...
std::map< const Elem *, std::vector< const Elem * > >	_coarsened_element_children
	Map of Parent elements to child elements for elements that were just coarsened. More...
std::set< Node * >	_semilocal_node_list
	Used for generating the semilocal node range. More...
std::unique_ptr< ConstElemRange >	_active_local_elem_range
	A range for use with threading. More...
std::unique_ptr< SemiLocalNodeRange >	_active_semilocal_node_range
std::unique_ptr< NodeRange >	_active_node_range
std::unique_ptr< ConstNodeRange >	_local_node_range
std::unique_ptr< StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > >	_bnd_node_range
std::unique_ptr< StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > >	_bnd_elem_range
std::map< dof_id_type, std::vector< dof_id_type > >	_node_to_elem_map
	A map of all of the current nodes to the elements that they are connected to. More...
bool	_node_to_elem_map_built
std::map< dof_id_type, std::vector< dof_id_type > >	_node_to_active_semilocal_elem_map
	A map of all of the current nodes to the active elements that they are connected to. More...
bool	_node_to_active_semilocal_elem_map_built
std::set< SubdomainID >	_mesh_subdomains
	A set of subdomain IDs currently present in the mesh. More...
std::unique_ptr< std::map< BoundaryID, RealVectorValue > >	_boundary_to_normal_map
	The boundary to normal map - valid only when AddAllSideSetsByNormals is active. More...
std::vector< BndNode * >	_bnd_nodes
	array of boundary nodes More...
std::map< boundary_id_type, std::set< dof_id_type > >	_bnd_node_ids
	Map of sets of node IDs in each boundary. More...
std::vector< BndElement * >	_bnd_elems
	array of boundary elems More...
std::map< boundary_id_type, std::set< dof_id_type > >	_bnd_elem_ids
	Map of set of elem IDs connected to each boundary. More...
std::map< dof_id_type, Node * >	_quadrature_nodes
std::map< dof_id_type, std::map< unsigned int, std::map< dof_id_type, Node * > > >	_elem_to_side_to_qp_to_quadrature_nodes
std::vector< BndNode >	_extra_bnd_nodes
std::map< dof_id_type, std::set< SubdomainID > >	_block_node_list
	list of nodes that belongs to a specified block (domain) More...
std::map< boundary_id_type, std::vector< dof_id_type > >	_node_set_nodes
	list of nodes that belongs to a specified nodeset: indexing [nodeset_id] -> [array of node ids] More...
std::set< unsigned int >	_ghosted_boundaries
std::vector< Real >	_ghosted_boundaries_inflation
unsigned int	_patch_size
	The number of nodes to consider in the NearestNode neighborhood. More...
unsigned int	_ghosting_patch_size
	The number of nearest neighbors to consider for ghosting purposes when iteration patch update strategy is used. More...
unsigned int	_max_leaf_size
Moose::PatchUpdateType	_patch_update_strategy
	The patch update strategy. More...
std::vector< Node * >	_node_map
	Vector of all the Nodes in the mesh for determining when to add a new point. More...
bool	_regular_orthogonal_mesh
	Boolean indicating whether this mesh was detected to be regular and orthogonal. More...
std::vector< std::vector< Real > >	_bounds
	The bounds in each dimension of the mesh for regular orthogonal meshes. More...
std::vector< std::pair< BoundaryID, BoundaryID > >	_paired_boundary
	A vector holding the paired boundaries for a regular orthogonal mesh. More...
std::map< std::string, MortarInterface * >	_mortar_interface_by_name
	Mortar interfaces mapped through their names. More...
std::vector< std::unique_ptr< MortarInterface > >	_mortar_interface
std::map< std::pair< BoundaryID, BoundaryID >, MortarInterface * >	_mortar_interface_by_ids
	Mortar interfaces mapped though master, slave IDs pairs. More...
const InputParameters &	_pars
	Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...
MooseApp &	_app
	The MooseApp this object is associated with. More...
const std::string &	_type
	The type of this object (the Class name) More...
const std::string &	_name
	The name of this object, reference to value stored in InputParameters. More...
const bool &	_enabled
	Reference to the "enable" InputParaemters, used by Controls for toggling on/off MooseObjects. More...
const InputParameters *	_pg_params
	Params. More...
PerfGraph &	_perf_graph
	The performance graph to add to. More...
std::string	_prefix
	A prefix to use for all sections. More...
std::set< BoundaryID >	_mesh_boundary_ids
	A set of boundary IDs currently present in the mesh. More...
std::set< BoundaryID >	_mesh_sideset_ids
std::set< BoundaryID >	_mesh_nodeset_ids

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

Detailed Description

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

Definition at line 72 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 955 of file MooseMesh.h.

bnd_node_iterator_imp

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

protected

Definition at line 948 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 956 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 949 of file MooseMesh.h.

PeriodicNodeInfo

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

Helper type for building periodic node maps.

Definition at line 830 of file MooseMesh.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

protected

Convenience enums.

Enumerator
X
Y
Z

Definition at line 862 of file MooseMesh.h.

  {
    X = 0,
    Y,
    Z
  };

anonymous enum

anonymous enum

protected

Enumerator
MIN
MAX

Definition at line 868 of file MooseMesh.h.

  {
    MIN = 0,
    MAX
  };

Constructor & Destructor Documentation

MooseMesh() [1/2]

MooseMesh::MooseMesh

(

const InputParameters &

parameters

)

Typical "Moose-style" constructor and copy constructor.

Definition at line 151 of file MooseMesh.C.

  : MooseObject(parameters),
    Restartable(this, "Mesh"),
    PerfGraphInterface(this),
    _mesh_parallel_type(getParam<MooseEnum>("parallel_type")),
    _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")),
    _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))
{
  MooseEnum temp_patch_update_strategy = getParam<MooseEnum>("patch_update_strategy");
  if (temp_patch_update_strategy == "never")
    _patch_update_strategy = Moose::Never;
  else if (temp_patch_update_strategy == "always")
    _patch_update_strategy = Moose::Always;
  else if (temp_patch_update_strategy == "auto")
    _patch_update_strategy = Moose::Auto;
  else if (temp_patch_update_strategy == "iteration")
    _patch_update_strategy = Moose::Iteration;
  else
    mooseError("Patch update strategy should be never, always, auto or iteration.");

  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.");

  switch (_mesh_parallel_type)
  {
    case 0: // PARALLEL
      _use_distributed_mesh = true;
      break;
    case 1: // SERIAL
      if (_app.getDistributedMeshOnCommandLine() || _is_nemesis || _app.isUseSplit())
        _parallel_type_overridden = true;
      break;
    case 2: // 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;
      // No default switch needed for MooseEnum
  }

  // 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");

  if (_use_distributed_mesh)
  {
    _mesh = libmesh_make_unique<DistributedMesh>(_communicator, dim);
    if (_partitioner_name != "default" && _partitioner_name != "parmetis")
    {
      _partitioner_name = "parmetis";
      _partitioner_overridden = true;
    }
  }
  else
    _mesh = libmesh_make_unique<ReplicatedMesh>(_communicator, dim);

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

MooseMesh() [2/2]

MooseMesh::MooseMesh

(

const MooseMesh &

other_mesh

)

Definition at line 267 of file MooseMesh.C.

  : MooseObject(other_mesh._pars),
    Restartable(this, "Mesh"),
    PerfGraphInterface(this, "CopiedMesh"),
    _mesh_parallel_type(other_mesh._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);
}

~MooseMesh()

MooseMesh::~MooseMesh ( )

virtual

Destructor.

Definition at line 348 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 2169 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 2175 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 2318 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 2703 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 1522 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 961 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 927 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 770 of file MooseMesh.h.

{ _allow_recovery = allow; }

bndElemsBegin()

MooseMesh::bnd_elem_iterator MooseMesh::bndElemsBegin ( )

virtual

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

Definition at line 912 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 920 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 896 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 904 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 709 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 1741 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().

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 675 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 2119 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 1207 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 1292 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 1603 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 1662 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 2126 of file MooseMesh.C.

Referenced by PenetrationLocator::detectPenetration().

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

buildSideList() [2/2]

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

(

)

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

Definition at line 2145 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 563 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 856 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 1949 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 1031 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 2001 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 593 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 587 of file MooseMesh.C.

Referenced by FEProblemBase::meshChangedHelper().

{
  return _coarsened_elements.get();
}

declareRecoverableData() [1/2]

template<typename T >

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

protectedinherited

Declare a piece of data as "recoverable".

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

Note - this data will NOT be restored on Restart!

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

Parameters

data_name

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

Definition at line 269 of file Restartable.h.

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

  registerRecoverableDataOnApp(full_name);

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

declareRecoverableData() [2/2]

template<typename T >

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

protectedinherited

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

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

Note - this data will NOT be restored on Restart!

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

Parameters

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

Definition at line 280 of file Restartable.h.

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

  registerRecoverableDataOnApp(full_name);

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

declareRestartableData() [1/2]

template<typename T >

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

data_name

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

Definition at line 202 of file Restartable.h.

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

declareRestartableData() [2/2]

template<typename T >

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

protectedinherited

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

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

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

Parameters

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

Definition at line 209 of file Restartable.h.

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

declareRestartableDataWithContext() [1/2]

template<typename T >

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

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

Definition at line 216 of file Restartable.h.

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

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

  return restartable_data_ref;
}

declareRestartableDataWithContext() [2/2]

template<typename T >

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

protectedinherited

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

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

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

Parameters

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

Definition at line 229 of file Restartable.h.

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

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

  return restartable_data_ref;
}

declareRestartableDataWithObjectName()

template<typename T >

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

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

Definition at line 245 of file Restartable.h.

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

declareRestartableDataWithObjectNameWithContext()

template<typename T >

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

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

Definition at line 252 of file Restartable.h.

{
  std::string old_name = _restartable_name;

  _restartable_name = object_name;

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

  _restartable_name = old_name;

  return value;
}

detectOrthogonalDimRanges()

bool MooseMesh::detectOrthogonalDimRanges

(

Real

tol = 1e-6

)

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 1319 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())
    for (unsigned int i = 0; i < 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 < 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 == 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 < dim; ++i)
  {
    _bounds[i].resize(2);
    _bounds[i][MIN] = min[i];
    _bounds[i][MAX] = max[i];
  }
  for (unsigned int i = dim; i < LIBMESH_DIM; ++i)
  {
    _bounds[i].resize(2);
    _bounds[i][MIN] = 0;
    _bounds[i][MAX] = 0;
  }

  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 1397 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 2099 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 1500 of file MooseMesh.C.

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

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

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 2205 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 2212 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 2219 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 2225 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 91 of file MooseObject.h.

Referenced by EigenKernel::enabled().

{ return _enabled; }

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

Referenced by FEProblemBase::checkProblemIntegrity(), ElementsAlongLine::ElementsAlongLine(), ElementsAlongPlane::ElementsAlongPlane(), IntersectionPointsAlongLine::IntersectionPointsAlongLine(), BreakMeshByBlock::modify(), SideSetsFromPoints::modify(), SideSetsFromNormals::modify(), MeshSideSet::modify(), ParsedAddSideset::modify(), AddAllSideSetsByNormals::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 2526 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:

1. Volume to volume (parent_side = -1, child = -1, child_side = -1)
2. Parent side to child side (parent_side = 0+, child = -1, child_side = 0+)
3. 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 1811 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 374 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 356 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 779 of file MooseMesh.C.

Referenced by NonlinearSystemBase::computeDamping(), AuxiliarySystem::computeElementalVars(), FEProblemBase::computeIndicators(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeMarkers(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjects(), FEProblemBase::createQRules(), LayeredBase::getBounds(), NonlinearSystemBase::init(), FEProblemBase::initialSetup(), meshChanged(), DOFMapOutput::output(), FEProblemBase::projectSolution(), NonlinearSystemBase::setVariableGlobalDoFs(), TransientMultiApp::solveStep(), Transient::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 793 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 807 of file MooseMesh.C.

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

  return _active_semilocal_node_range.get();
}

getBoundaryElementRange()

ConstBndElemRange * MooseMesh::getBoundaryElementRange

(

)

Definition at line 843 of file MooseMesh.C.

Referenced by AuxiliarySystem::computeElementalVars(), 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 1043 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 2105 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(), ParsedAddSideset::modify(), SideSetsAroundSubdomain::modify(), ElementDeleterBase::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 2113 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 1058 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 1182 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 830 of file MooseMesh.C.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), AuxiliarySystem::computeNodalVars(), 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 72 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 1769 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 827 of file MooseMesh.h.

{ return ""; }

getGhostedBoundaries()

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

(

)

const

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

Definition at line 2330 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 2336 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 440 of file MooseMesh.h.

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

{ return _ghosting_patch_size; };

getInflatedProcessorBoundingBox()

BoundingBox MooseMesh::getInflatedProcessorBoundingBox

(

Real

inflation_multiplier = 0.01

)

const

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

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianInternal(), AuxiliarySystem::computeNodalVars(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjects(), 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 1514 of file MooseMesh.C.

Referenced by dimensionWidth().

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

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

{ return _max_leaf_size; };

getMesh() [1/2]

MeshBase & MooseMesh::getMesh

(

)

Accessor for the underlying libMesh Mesh object.

Definition at line 2512 of file MooseMesh.C.

Referenced by activeLocalElementsBegin(), activeLocalElementsEnd(), Adaptivity::adaptMesh(), BreakMeshByBlock::addInterfaceBoundary(), addQuadratureNode(), addUniqueNode(), GeometricRelationshipManager::attachGeometricFunctorHelper(), RelationshipManager::attachRelationshipManagers(), buildBndElemList(), TiledMesh::buildMesh(), FileMesh::buildMesh(), RinglebMesh::buildMesh(), DistributedGeneratedMesh::buildMesh(), GeneratedMesh::buildMesh(), AnnularMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), ConcentricCircleMesh::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(), FileMesh::FileMesh(), 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(), VerifyElementUniqueID::initialize(), VerifyNodalUniqueID::initialize(), OversampleOutput::initOversample(), localNodesBegin(), localNodesEnd(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), maxElemId(), maxNodeId(), GeometryBase::meshChanged(), Nemesis::meshChanged(), BreakBoundaryOnSubdomain::modify(), BreakMeshByBlock::modify(), SideSetsBetweenSubdomains::modify(), SideSetsFromNormals::modify(), SideSetsFromPoints::modify(), AddExtraNodeset::modify(), MeshExtruder::modify(), MeshSideSet::modify(), LowerDBlockFromSideset::modify(), AssignSubdomainID::modify(), SmoothMesh::modify(), AssignElementSubdomainID::modify(), SideSetsAroundSubdomain::modify(), ParsedAddSideset::modify(), AddAllSideSetsByNormals::modify(), ElementDeleterBase::modify(), ParsedSubdomainMeshModifier::modify(), RenameBlock::modify(), ImageSubdomain::modify(), BoundingBoxNodeSet::modify(), OrientedSubdomainBoundingBox::modify(), AddSideSetsFromBoundingBox::modify(), SubdomainBoundingBox::modify(), MooseMesh(), nElem(), nNodes(), NodalPatchRecovery::NodalPatchRecovery(), NodalVariableValue::NodalVariableValue(), nodePtr(), nodeRef(), nodeToActiveSemilocalElemMap(), nodeToElemMap(), ComputeNodalUserObjectsThread::onNode(), XDA::output(), ConsoleUtils::outputMeshInformation(), PatternedMesh::PatternedMesh(), prepare(), EqualValueEmbeddedConstraint::prepareSlaveToMasterMap(), printInfo(), queryElemPtr(), queryNodePtr(), FileMesh::read(), SubProblem::restrictionBoundaryCheckName(), SubProblem::restrictionSubdomainCheckName(), setBoundaryName(), NonlinearSystemBase::setConstraintSlaveValues(), XFEMInterface::setDisplacedMesh(), XFEMInterface::setMesh(), setSubdomainName(), ImageSampler::setupImageSampler(), SetupMeshAction::setupMesh(), sideWithBoundaryID(), StitchedMesh::StitchedMesh(), 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 2519 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 1506 of file MooseMesh.C.

Referenced by dimensionWidth().

{
  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 86 of file MooseObject.h.

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

{ return _app; }

getMortarInterface()

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

Definition at line 2651 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 2641 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 790 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 883 of file MooseMesh.C.

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

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

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

  return it->second;
}

getNodeList()

const std::vector< dof_id_type > & MooseMesh::getNodeList

(

boundary_id_type

nodeset_id

)

const

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

Definition at line 2539 of file MooseMesh.C.

Referenced by AutoPositionsMultiApp::fillPositions(), 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 1991 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 1585 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 185 of file MooseObject.h.

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

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

getPatchSize()

unsigned int MooseMesh::getPatchSize

(

)

const

Getter for the patch_size parameter.

Definition at line 2471 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 2483 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 2697 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 1013 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 1705 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 2566 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 1111 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 1126 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 1160 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 2400 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 2675 of file MooseMesh.C.

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

Definition at line 2007 of file MooseMesh.C.

Referenced by GridPartitioner::_do_partition().

{
  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 2604 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 2619 of file MooseMesh.C.

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

isBoundaryNode() [1/2]

bool MooseMesh::isBoundaryNode

(

dof_id_type

node_id

)

const

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

Definition at line 2578 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 2593 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 2669 of file MooseMesh.C.

{
  return _custom_partitioner_requested;
}

isDistributedMesh()

bool MooseMesh::isDistributedMesh ( ) const

inline

Returns the final Mesh distribution type.

Definition at line 750 of file MooseMesh.h.

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

{ return _use_distributed_mesh; }

isParallelTypeForced()

bool MooseMesh::isParallelTypeForced ( ) const

inline

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

Definition at line 755 of file MooseMesh.h.

Referenced by ConsoleUtils::outputMeshInformation().

{ return _parallel_type_overridden; }

isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 81 of file MooseObject.h.

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

{ return _pars.isParamValid(name); }

isPartitionerForced()

bool MooseMesh::isPartitionerForced ( ) const

inline

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

Definition at line 765 of file MooseMesh.h.

Referenced by ConsoleUtils::outputMeshInformation().

{ return _partitioner_overridden; }

isRegularOrthogonal()

bool MooseMesh::isRegularOrthogonal ( )

inline

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

Definition at line 812 of file MooseMesh.h.

{ return _regular_orthogonal_mesh; }

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 642 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 1543 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 2157 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 2163 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 1780 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 2199 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 2193 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 2267 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 532 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 2279 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 2273 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 2261 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 1579 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 1554 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 155 of file MooseObject.h.

Referenced by FEProblemBase::advanceMultiApps(), MultiApp::advanceStep(), MultiApp::appProblem(), buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), FEProblemBase::computeResidual(), Material::declarePropertyOld(), Material::declarePropertyOlder(), elem(), MultiAppTransfer::execFlags(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), Control::getExecuteOptions(), Output::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::getVectorPostprocessorValue(), FEProblemBase::getVectorPostprocessorValueOld(), NodalScalarKernel::NodalScalarKernel(), node(), PercentChangePostprocessor::PercentChangePostprocessor(), setBoundaryToNormalMap(), 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 140 of file MooseObject.h.

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

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

mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 161 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 149 of file MooseObject.h.

Referenced by OversampleOutput::cloneMesh(), GapValueAux::computeValue(), PerflogDumper::execute(), 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 51 of file MooseObject.h.

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

{ return _name; }

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

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

{
  _needs_prepare_for_use = true;
}

nElem()

dof_id_type MooseMesh::nElem ( ) const

virtual

Definition at line 2187 of file MooseMesh.C.

{
  return getMesh().n_elem();
}

nNodes()

dof_id_type MooseMesh::nNodes ( ) const

virtual

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

Definition at line 2181 of file MooseMesh.C.

{
  return getMesh().n_nodes();
}

node() [1/2]

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

virtual

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

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

Definition at line 464 of file MooseMesh.C.

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

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

node() [2/2]

Node & MooseMesh::node ( const dof_id_type  i )

virtual

Definition at line 471 of file MooseMesh.C.

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

nodePtr() [1/2]

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

virtual

Definition at line 496 of file MooseMesh.C.

Referenced by dataLoad().

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

  return getMesh().node_ptr(i);
}

nodePtr() [2/2]

Node * MooseMesh::nodePtr ( const dof_id_type  i )

virtual

Definition at line 505 of file MooseMesh.C.

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

  return getMesh().node_ptr(i);
}

nodeRef() [1/2]

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

virtual

Definition at line 478 of file MooseMesh.C.

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

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

  return getMesh().node_ref(i);
}

nodeRef() [2/2]

Node & MooseMesh::nodeRef ( const dof_id_type  i )

virtual

Definition at line 487 of file MooseMesh.C.

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

  return getMesh().node_ref(i);
}

nodeToActiveSemilocalElemMap()

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

(

)

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

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

Note

Extra ghosted elements are not included in this map!

Definition at line 754 of file MooseMesh.C.

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

    TIME_SECTION(_node_to_active_semilocal_elem_map_timer);

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

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

  return _node_to_active_semilocal_elem_map;
}