FileMesh Class Reference

#include <FileMesh.h>

Inheritance diagram for FileMesh:

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

Public Member Functions
	FileMesh (const InputParameters &parameters)
	FileMesh (const FileMesh &other_mesh)
virtual	~FileMesh ()
virtual std::unique_ptr< MooseMesh >	safeClone () const override
	A safer version of the clone() method that hands back an allocated object wrapped in a smart pointer. More...
virtual void	buildMesh () override
	Must be overridden by child classes. More...
void	read (const std::string &file_name)
virtual ExodusII_IO *	exReader () const override
	Not implemented – always returns NULL. More...
void	setFileName (const std::string &file_name)
virtual std::string	getFileName () const override
	Returns the name of the mesh file read to produce this mesh if any or an empty string otherwise. More...
virtual MooseMesh &	clone () const
	Clone method. More...
std::unique_ptr< MeshBase >	buildMeshBaseObject (ParallelType override_type=ParallelType::DEFAULT)
	Method to construct a libMesh::MeshBase object that is normally set and used by the MooseMesh object during the "init()" phase. More...
void	setMeshBase (std::unique_ptr< MeshBase > mesh_base)
	Method to set the mesh_base object. More...
virtual void	init ()
	Initialize the Mesh object. More...
virtual unsigned int	dimension () const
	Returns MeshBase::mesh_dimsension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh mesh object. More...
virtual unsigned int	effectiveSpatialDimension () const
	Returns the effective spatial dimension determined by the coordinates actually used by the mesh. More...
std::vector< BoundaryID >	getBoundaryIDs (const Elem *const elem, const unsigned short int side) const
	Returns a vector of boundary IDs for the requested element on the requested side. More...
const std::set< BoundaryID > &	getBoundaryIDs () const
	Returns a const reference to a set of all user-specified boundary IDs. More...
std::vector< BoundaryID >	getBoundaryIDs (const std::vector< BoundaryName > &boundary_name, bool generate_unknown=false) const
	Get the associated BoundaryID for the boundary names that are passed in. More...
void	buildNodeList ()
	Calls BoundaryInfo::build_node_list()/build_side_list() and makes separate copies of Nodes/Elems in those lists. More...
void	buildBndElemList ()
const std::map< dof_id_type, std::vector< dof_id_type > > &	nodeToElemMap ()
	If not already created, creates a map from every node to all elements to which they are connected. More...
const std::map< dof_id_type, std::vector< dof_id_type > > &	nodeToActiveSemilocalElemMap ()
	If not already created, creates a map from every node to all active semilocal elements to which they are connected. More...
virtual bnd_node_iterator	bndNodesBegin ()
	Return iterators to the beginning/end of the boundary nodes list. More...
virtual bnd_node_iterator	bndNodesEnd ()
virtual bnd_elem_iterator	bndElemsBegin ()
	Return iterators to the beginning/end of the boundary elements list. More...
virtual bnd_elem_iterator	bndElemsEnd ()
void	buildNodeListFromSideList ()
	Calls BoundaryInfo::build_node_list_from_side_list(). More...
void	buildSideList (std::vector< dof_id_type > &el, std::vector< unsigned short int > &sl, std::vector< boundary_id_type > &il)
	Calls BoundaryInfo::build_side_list(). More...
std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	buildSideList ()
	As above, but uses the non-deprecated std::tuple interface. More...
std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	buildActiveSideList ()
	Calls BoundaryInfo::build_active_side_list. More...
unsigned int	sideWithBoundaryID (const Elem *const elem, const BoundaryID boundary_id) const
	Calls BoundaryInfo::side_with_boundary_id(). More...
MeshBase::const_node_iterator	localNodesBegin ()
	Calls local_nodes_begin/end() on the underlying libMesh mesh object. More...
MeshBase::const_node_iterator	localNodesEnd ()
MeshBase::const_element_iterator	activeLocalElementsBegin ()
	Calls active_local_nodes_begin/end() on the underlying libMesh mesh object. More...
const MeshBase::const_element_iterator	activeLocalElementsEnd ()
virtual dof_id_type	nNodes () const
	Calls n_nodes/elem() on the underlying libMesh mesh object. More...
virtual dof_id_type	nElem () const
virtual dof_id_type	maxNodeId () const
	Calls max_node/elem_id() on the underlying libMesh mesh object. More...
virtual dof_id_type	maxElemId () const
virtual const Node &	node (const dof_id_type i) const
	Various accessors (pointers/references) for Node "i". More...
virtual Node &	node (const dof_id_type i)
virtual const Node &	nodeRef (const dof_id_type i) const
virtual Node &	nodeRef (const dof_id_type i)
virtual const Node *	nodePtr (const dof_id_type i) const
virtual Node *	nodePtr (const dof_id_type i)
virtual const Node *	queryNodePtr (const dof_id_type i) const
virtual Node *	queryNodePtr (const dof_id_type i)
virtual Elem *	elem (const dof_id_type i)
	Various accessors (pointers/references) for Elem "i". More...
virtual const Elem *	elem (const dof_id_type i) const
virtual Elem *	elemPtr (const dof_id_type i)
virtual const Elem *	elemPtr (const dof_id_type i) const
virtual Elem *	queryElemPtr (const dof_id_type i)
virtual const Elem *	queryElemPtr (const dof_id_type i) const
bool	prepared () const
	Setter/getter for the _is_prepared flag. More...
virtual void	prepared (bool state)
void	needsPrepareForUse ()
	If this method is called, we will call libMesh's prepare_for_use method when we call Moose's prepare method. More...
void	meshChanged ()
	Declares that the MooseMesh has changed, invalidates cached data and rebuilds caches. More...
virtual void	onMeshChanged ()
	Declares a callback function that is executed at the conclusion of meshChanged(). More...
void	cacheChangedLists ()
	Cache information about what elements were refined and coarsened in the previous step. More...
ConstElemPointerRange *	refinedElementRange () const
	Return a range that is suitable for threaded execution over elements that were just refined. More...
ConstElemPointerRange *	coarsenedElementRange () const
	Return a range that is suitable for threaded execution over elements that were just coarsened. More...
const std::vector< const Elem * > &	coarsenedElementChildren (const Elem *elem) const
	Get the newly removed children element ids for an element that was just coarsened. More...
void	updateActiveSemiLocalNodeRange (std::set< dof_id_type > &ghosted_elems)
	Clears the "semi-local" node list and rebuilds it. More...
bool	isSemiLocal (Node *const node) const
	Returns true if the node is semi-local. More...
const std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > &	getBoundariesToElems () const
	Returns a map of boundaries to elements. More...
const std::set< SubdomainID > &	meshSubdomains () const
	Returns a read-only reference to the set of subdomains currently present in the Mesh. More...
const std::set< BoundaryID > &	meshBoundaryIds () const
	Returns a read-only reference to the set of boundary IDs currently present in the Mesh. More...
const std::set< BoundaryID > &	meshSidesetIds () const
	Returns a read-only reference to the set of sidesets currently present in the Mesh. More...
const std::set< BoundaryID > &	meshNodesetIds () const
	Returns a read-only reference to the set of nodesets currently present in the Mesh. More...
void	setBoundaryToNormalMap (std::unique_ptr< std::map< BoundaryID, RealVectorValue >> boundary_map)
	Sets the mapping between BoundaryID and normal vector Is called by AddAllSideSetsByNormals. More...
void	setBoundaryToNormalMap (std::map< BoundaryID, RealVectorValue > *boundary_map)
void	setMeshBoundaryIDs (std::set< BoundaryID > boundary_IDs)
	Sets the set of BoundaryIDs Is called by AddAllSideSetsByNormals. More...
const RealVectorValue &	getNormalByBoundaryID (BoundaryID id) const
	Returns the normal vector associated with a given BoundaryID. More...
void	prepare (bool force=false)
	Calls prepare_for_use() if force=true on the underlying Mesh object, then communicates various boundary information on parallel meshes. More...
void	update ()
	Calls buildNodeListFromSideList(), buildNodeList(), and buildBndElemList(). More...
unsigned int	uniformRefineLevel () const
	Returns the level of uniform refinement requested (zero if AMR is disabled). More...
void	setUniformRefineLevel (unsigned int)
	Set uniform refinement level. More...
void	addGhostedBoundary (BoundaryID boundary_id)
	This will add the boundary ids to be ghosted to this processor. More...
void	setGhostedBoundaryInflation (const std::vector< Real > &inflation)
	This sets the inflation amount for the bounding box for each partition for use in ghosting boundaries. More...
const std::set< unsigned int > &	getGhostedBoundaries () const
	Return a writable reference to the set of ghosted boundary IDs. More...
const std::vector< Real > &	getGhostedBoundaryInflation () const
	Return a writable reference to the _ghosted_boundaries_inflation vector. More...
void	ghostGhostedBoundaries ()
	Actually do the ghosting of boundaries that need to be ghosted to this processor. More...
unsigned int	getPatchSize () const
	Getter for the patch_size parameter. More...
unsigned int	getGhostingPatchSize () const
	Getter for the ghosting_patch_size parameter. More...
unsigned int	getMaxLeafSize () const
	Getter for the maximum leaf size parameter. More...
void	setPatchUpdateStrategy (Moose::PatchUpdateType patch_update_strategy)
	Set the patch size update strategy. More...
const Moose::PatchUpdateType &	getPatchUpdateStrategy () const
	Get the current patch update strategy. More...
BoundingBox	getInflatedProcessorBoundingBox (Real inflation_multiplier=0.01) const
	Get a (slightly inflated) processor bounding box. More...
	operator libMesh::MeshBase & ()
	Implicit conversion operator from MooseMesh -> libMesh::MeshBase. More...
	operator const libMesh::MeshBase & () const
MeshBase &	getMesh ()
	Accessor for the underlying libMesh Mesh object. More...
const MeshBase &	getMesh () const
void	printInfo (std::ostream &os=libMesh::out) const
	Calls print_info() on the underlying Mesh. More...
const std::set< SubdomainID > &	getNodeBlockIds (const Node &node) const
	Return list of blocks to which the given node belongs. More...
const std::vector< dof_id_type > &	getNodeList (boundary_id_type nodeset_id) const
	Return a writable reference to a vector of node IDs that belong to nodeset_id. More...
const Node *	addUniqueNode (const Point &p, Real tol=1e-6)
	Add a new node to the mesh. More...
Node *	addQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp, BoundaryID bid, const Point &point)
	Adds a fictitious "QuadratureNode". More...
Node *	getQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp)
	Get a specified quadrature node. More...
void	clearQuadratureNodes ()
	Clear out any existing quadrature nodes. More...
BoundaryID	getBoundaryID (const BoundaryName &boundary_name) const
	Get the associated BoundaryID for the boundary name. More...
SubdomainID	getSubdomainID (const SubdomainName &subdomain_name) const
	Get the associated subdomain ID for the subdomain name. More...
std::vector< SubdomainID >	getSubdomainIDs (const std::vector< SubdomainName > &subdomain_name) const
	Get the associated subdomainIDs for the subdomain names that are passed in. More...
void	setSubdomainName (SubdomainID subdomain_id, const SubdomainName &name)
	This method sets the name for subdomain_id to name. 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	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...
void	needsRemoteElemDeletion (bool need_delete)
	Set whether we need to delete remote elements. More...
bool	needsRemoteElemDeletion () const
	Whether we need to delete remote elements. More...
bool	hasMeshBase () const
	Whether mesh base object was constructed or not. More...
const std::string &	type () const
	Get the type of this object. More...
virtual 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 &	getParamTempl (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) const
	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) const
	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) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	mooseError (Args &&... args) const
template<typename... Args>
void	mooseWarning (Args &&... args) const
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseInfo (Args &&... args) const
ConstElemRange *	getActiveLocalElementRange ()
	Return pointers to range objects for various types of ranges (local nodes, boundary elems, etc.). More...
NodeRange *	getActiveNodeRange ()
SemiLocalNodeRange *	getActiveSemiLocalNodeRange () const
ConstNodeRange *	getLocalNodeRange ()
StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > *	getBoundaryNodeRange ()
StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > *	getBoundaryElementRange ()
virtual Real	getMinInDimension (unsigned int component) const
	Returns the min or max of the requested dimension respectively. More...
virtual Real	getMaxInDimension (unsigned int component) const
bool	isCustomPartitionerRequested () const
	Setter and getter for _custom_partitioner_requested. More...
void	setIsCustomPartitionerRequested (bool cpr)

Static Public Member Functions
static InputParameters	validParams ()
static void	setSubdomainName (MeshBase &mesh, SubdomainID subdomain_id, const SubdomainName &name)
	This method sets the name for subdomain_id on the provided mesh to name. More...
static void	changeBoundaryId (MeshBase &mesh, 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 for the given mesh. More...
static void	setPartitioner (MeshBase &mesh_base, MooseEnum &partitioner, bool use_distributed_mesh, const InputParameters &params, MooseObject &context_obj)
	Method for setting the partitioner on the passed in mesh_base object. More...

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 ()
void	setPartitionerHelper ()
template<typename T >
T &	declareRestartableDataTempl (const std::string &data_name)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataTempl (const std::string &data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRestartableDataWithContext (const std::string &data_name, void *context)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataWithContext (const 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 &	declareRestartableDataWithPrefixOverrideAndContext (const std::string &data_name, const std::string &prefix, void *context)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRecoverableData (const std::string &data_name)
	Declare a piece of data as "recoverable". More...
template<typename T >
T &	declareRecoverableData (const std::string &data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const 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::string	_file_name
	the file_name from whence this mesh came More...
std::unique_ptr< ExodusII_IO >	_exreader
	Auxiliary object for restart. More...
const unsigned int	_dim
	The requested dimension of the mesh. More...
const PerfID	_read_mesh_timer
	Timers. More...
std::vector< std::unique_ptr< GhostingFunctor > >	_ghosting_functors
	Deprecated (DO NOT USE) More...
std::vector< std::shared_ptr< RelationshipManager > >	_relationship_managers
	The list of active geometric relationship managers (bound to the underlying MeshBase object). More...
ParallelType	_parallel_type
	Can be set to DISTRIBUTED, REPLICATED, or DEFAULT. More...
bool	_use_distributed_mesh
	False by default. More...
bool	_distribution_overridden
bool	_parallel_type_overridden
std::unique_ptr< libMesh::MeshBase >	_mesh
	Pointer to underlying libMesh mesh object. More...
MooseEnum	_partitioner_name
	The partitioner used on this mesh. More...
bool	_partitioner_overridden
std::unique_ptr< Partitioner >	_custom_partitioner
	The custom partitioner. More...
bool	_custom_partitioner_requested
unsigned int	_uniform_refine_level
	The level of uniform refinement requested (set to zero if AMR is disabled) More...
bool	_is_changed
	true if mesh is changed (i.e. after adaptivity step) More...
bool	_is_nemesis
	True if a Nemesis Mesh was read in. More...
bool	_is_prepared
	True if prepare has been called on the mesh. More...
bool	_needs_prepare_for_use
	True if prepare_for_use should be called when Mesh is prepared. More...
std::unique_ptr< ConstElemPointerRange >	_refined_elements
	The elements that were just refined. More...
std::unique_ptr< ConstElemPointerRange >	_coarsened_elements
	The elements that were just coarsened. More...
std::map< const Elem *, std::vector< const Elem * > >	_coarsened_element_children
	Map of Parent elements to child elements for elements that were just coarsened. More...
std::set< Node * >	_semilocal_node_list
	Used for generating the semilocal node range. More...
std::unique_ptr< ConstElemRange >	_active_local_elem_range
	A range for use with threading. More...
std::unique_ptr< SemiLocalNodeRange >	_active_semilocal_node_range
std::unique_ptr< NodeRange >	_active_node_range
std::unique_ptr< ConstNodeRange >	_local_node_range
std::unique_ptr< StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > >	_bnd_node_range
std::unique_ptr< StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > >	_bnd_elem_range
std::map< dof_id_type, std::vector< dof_id_type > >	_node_to_elem_map
	A map of all of the current nodes to the elements that they are connected to. More...
bool	_node_to_elem_map_built
std::map< dof_id_type, std::vector< dof_id_type > >	_node_to_active_semilocal_elem_map
	A map of all of the current nodes to the active elements that they are connected to. More...
bool	_node_to_active_semilocal_elem_map_built
std::set< SubdomainID >	_mesh_subdomains
	A set of subdomain IDs currently present in the mesh. More...
std::unique_ptr< std::map< BoundaryID, RealVectorValue > >	_boundary_to_normal_map
	The boundary to normal map - valid only when AddAllSideSetsByNormals is active. More...
std::vector< BndNode * >	_bnd_nodes
	array of boundary nodes More...
std::map< boundary_id_type, std::set< dof_id_type > >	_bnd_node_ids
	Map of sets of node IDs in each boundary. More...
std::vector< BndElement * >	_bnd_elems
	array of boundary elems More...
std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > >	_bnd_elem_ids
	Map of set of elem IDs connected to each boundary. More...
std::map< dof_id_type, Node * >	_quadrature_nodes
std::map< dof_id_type, std::map< unsigned int, std::map< dof_id_type, Node * > > >	_elem_to_side_to_qp_to_quadrature_nodes
std::vector< BndNode >	_extra_bnd_nodes
std::map< dof_id_type, std::set< SubdomainID > >	_block_node_list
	list of nodes that belongs to a specified block (domain) More...
std::map< boundary_id_type, std::vector< dof_id_type > >	_node_set_nodes
	list of nodes that belongs to a specified nodeset: indexing [nodeset_id] -> [array of node ids] More...
std::set< unsigned int >	_ghosted_boundaries
std::vector< Real >	_ghosted_boundaries_inflation
unsigned int	_patch_size
	The number of nodes to consider in the NearestNode neighborhood. More...
unsigned int	_ghosting_patch_size
	The number of nearest neighbors to consider for ghosting purposes when iteration patch update strategy is used. More...
unsigned int	_max_leaf_size
Moose::PatchUpdateType	_patch_update_strategy
	The patch update strategy. More...
std::vector< Node * >	_node_map
	Vector of all the Nodes in the mesh for determining when to add a new point. More...
bool	_regular_orthogonal_mesh
	Boolean indicating whether this mesh was detected to be regular and orthogonal. More...
std::vector< std::vector< Real > >	_bounds
	The bounds in each dimension of the mesh for regular orthogonal meshes. More...
std::vector< std::pair< BoundaryID, BoundaryID > >	_paired_boundary
	A vector holding the paired boundaries for a regular orthogonal mesh. More...
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...
template<typename... Args>
std::string	paramErrorMsg (const std::string &param, Args... args) const
RestartableDataValue &	registerRestartableDataOnApp (const std::string &name, std::unique_ptr< RestartableDataValue > data, THREAD_ID tid)
	Helper function for actually registering the restartable data. More...
void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	Helper function for actually registering the restartable data. 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
bool	_need_delete
	Whether we need to delete remote elements after init'ing the EquationSystems. More...
std::set< Elem * >	_ghost_elems_from_ghost_boundaries
	Set of elements ghosted by ghostGhostedBoundaries. More...
MooseApp &	_restartable_app
	Reference to the application. More...
std::string	_restartable_name
	The name of the object. More...
std::string	_restartable_system_name
	The system name this object is in. More...
THREAD_ID	_restartable_tid
	The thread ID for this object. More...

Detailed Description

Definition at line 20 of file FileMesh.h.

Member Typedef Documentation

bnd_elem_iterator_imp

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

protectedinherited

Definition at line 1012 of file MooseMesh.h.

bnd_node_iterator_imp

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

protectedinherited

Definition at line 1005 of file MooseMesh.h.

const_bnd_elem_iterator_imp

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

protectedinherited

Definition at line 1013 of file MooseMesh.h.

const_bnd_node_iterator_imp

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

protectedinherited

Definition at line 1006 of file MooseMesh.h.

PeriodicNodeInfo

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

inherited

Helper type for building periodic node maps.

Definition at line 872 of file MooseMesh.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

protectedinherited

Convenience enums.

Enumerator
X
Y
Z

Definition at line 919 of file MooseMesh.h.

  {
    X = 0,
    Y,
    Z
  };

anonymous enum

anonymous enum

protectedinherited

Enumerator
MIN
MAX

Definition at line 925 of file MooseMesh.h.

  {
    MIN = 0,
    MAX
  };

ParallelType

enum MooseMesh::ParallelType

stronginherited

Enumerator
DEFAULT
REPLICATED
DISTRIBUTED

Definition at line 90 of file MooseMesh.h.

  {
    DEFAULT,
    REPLICATED,
    DISTRIBUTED
  };

Constructor & Destructor Documentation

FileMesh() [1/2]

FileMesh::FileMesh

(

const InputParameters &

parameters

)

Definition at line 33 of file FileMesh.C.

  : MooseMesh(parameters),
    _file_name(getParam<MeshFileName>("file")),
    _dim(getParam<MooseEnum>("dim")),
    _read_mesh_timer(registerTimedSection("readMesh", 2))
{
}

FileMesh() [2/2]

FileMesh::FileMesh

(

const FileMesh &

other_mesh

)

Definition at line 41 of file FileMesh.C.

  : MooseMesh(other_mesh),
    _file_name(other_mesh._file_name),
    _dim(other_mesh._dim),
    _read_mesh_timer(other_mesh._read_mesh_timer)
{
}

~FileMesh()

FileMesh::~FileMesh ( )

virtual

Definition at line 49 of file FileMesh.C.

{}

Member Function Documentation

activeLocalElementsBegin()

MeshBase::const_element_iterator MooseMesh::activeLocalElementsBegin ( )

inherited

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

Definition at line 2239 of file MooseMesh.C.

{
  return getMesh().active_local_elements_begin();
}

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

activeLocalElementsEnd()

const MeshBase::const_element_iterator MooseMesh::activeLocalElementsEnd ( )

inherited

Definition at line 2245 of file MooseMesh.C.

{
  return getMesh().active_local_elements_end();
}

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

addGhostedBoundary()

void MooseMesh::addGhostedBoundary ( BoundaryID  boundary_id )

inherited

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

Definition at line 2395 of file MooseMesh.C.

{
  _ghosted_boundaries.insert(boundary_id);
}

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

addPeriodicVariable()

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

inherited

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

Definition at line 1533 of file MooseMesh.C.

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

Referenced by AddPeriodicBCAction::setPeriodicVars().

addQuadratureNode()

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

inherited

Adds a fictitious "QuadratureNode".

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

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

Parameters

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

Definition at line 957 of file MooseMesh.C.

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

Referenced by GeometricSearchData::generateQuadratureNodes().

addUniqueNode()

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

inherited

Add a new node to the mesh.

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

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

Definition at line 923 of file MooseMesh.C.

{
  if (getMesh().n_nodes() != _node_map.size())
  {
    _node_map.clear();
    _node_map.reserve(getMesh().n_nodes());
    for (const auto & node : getMesh().node_ptr_range())
      _node_map.push_back(node);
  }
 
  Node * node = nullptr;
  for (unsigned int i = 0; i < _node_map.size(); ++i)
  {
    if (p.relative_fuzzy_equals(*_node_map[i], tol))
    {
      node = _node_map[i];
      break;
    }
  }
  if (node == nullptr)
  {
    node = getMesh().add_node(new Node(p));
    _node_map.push_back(node);
  }
 
  mooseAssert(node != nullptr, "Node is NULL");
  return node;
}

allowRecovery()

void MooseMesh::allowRecovery ( bool  allow )

inlineinherited

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

Definition at line 829 of file MooseMesh.h.

{ _allow_recovery = allow; }

bndElemsBegin()

MooseMesh::bnd_elem_iterator MooseMesh::bndElemsBegin ( )

virtualinherited

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

Definition at line 908 of file MooseMesh.C.

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

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

bndElemsEnd()

MooseMesh::bnd_elem_iterator MooseMesh::bndElemsEnd ( )

virtualinherited

Definition at line 916 of file MooseMesh.C.

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

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

bndNodesBegin()

MooseMesh::bnd_node_iterator MooseMesh::bndNodesBegin ( )

virtualinherited

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

Definition at line 892 of file MooseMesh.C.

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

Referenced by MooseMesh::getBoundaryNodeRange().

bndNodesEnd()

MooseMesh::bnd_node_iterator MooseMesh::bndNodesEnd ( )

virtualinherited

Definition at line 900 of file MooseMesh.C.

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

Referenced by MooseMesh::getBoundaryNodeRange().

buildActiveSideList()

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

inherited

Calls BoundaryInfo::build_active_side_list.

Returns

A container of active (element, side, id) tuples.

Definition at line 2215 of file MooseMesh.C.

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

Referenced by PenetrationLocator::detectPenetration().

buildBndElemList()

void MooseMesh::buildBndElemList ( )

inherited

Definition at line 685 of file MooseMesh.C.

{
  TIME_SECTION(_build_bnd_elem_list_timer);
  CONSOLE_TIMED_PRINT("Building element lists");
 
  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);
  }
}

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

buildCoarseningMap()

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

privateinherited

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

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

Referenced by MooseMesh::buildRefinementAndCoarseningMaps().

buildMesh()

void FileMesh::buildMesh ( )

overridevirtual

Must be overridden by child classes.

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

Implements MooseMesh.

Definition at line 58 of file FileMesh.C.

{
  TIME_SECTION(_read_mesh_timer);
 
  getMesh().set_mesh_dimension(getParam<MooseEnum>("dim"));
 
  if (_is_nemesis)
  {
    // Nemesis_IO only takes a reference to DistributedMesh, so we can't be quite so short here.
    DistributedMesh & pmesh = cast_ref<DistributedMesh &>(getMesh());
    Nemesis_IO(pmesh).read(_file_name);
 
    getMesh().allow_renumbering(false);
 
    // Even if we want repartitioning when load balancing later, we'll
    // begin with the default partitioning defined by the Nemesis
    // file.
    bool skip_partitioning_later = getMesh().skip_partitioning();
    getMesh().skip_partitioning(true);
    getMesh().prepare_for_use();
    getMesh().skip_partitioning(skip_partitioning_later);
  }
  else // not reading Nemesis files
  {
    // See if the user has requested reading a solution from the file.  If so, we'll need to read
    // the mesh with the exodus reader instead of using mesh.read().  This will read the mesh on
    // every processor
 
    if (_app.setFileRestart() && (_file_name.rfind(".exd") < _file_name.size() ||
                                  _file_name.rfind(".e") < _file_name.size()))
    {
      MooseUtils::checkFileReadable(_file_name);
 
      _exreader = libmesh_make_unique<ExodusII_IO>(getMesh());
      _exreader->read(_file_name);
 
      getMesh().allow_renumbering(false);
      getMesh().prepare_for_use();
    }
    else
    {
      // If we are reading a mesh while restarting, then we might have
      // a solution file that relies on that mesh partitioning and/or
      // numbering.  In that case, we need to turn off repartitioning
      // and renumbering, at least at first.
      _file_name = MooseUtils::convertLatestCheckpoint(_file_name, false);
      bool restarting = _file_name.rfind(".cpa") < _file_name.size() ||
                        _file_name.rfind(".cpr") < _file_name.size();
 
      const bool skip_partitioning_later = restarting && getMesh().skip_partitioning();
      const bool allow_renumbering_later = restarting && getMesh().allow_renumbering();
 
      if (restarting)
      {
        getMesh().skip_partitioning(true);
        getMesh().allow_renumbering(false);
      }
 
      if (!MooseUtils::pathExists(_file_name))
        mooseError("cannot locate mesh file '", _file_name, "'");
      getMesh().read(_file_name);
 
      if (restarting)
      {
        getMesh().allow_renumbering(allow_renumbering_later);
        getMesh().skip_partitioning(skip_partitioning_later);
      }
    }
  }
}

buildMeshBaseObject()

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

inherited

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

Definition at line 2026 of file MooseMesh.C.

{
  switch (_parallel_type)
  {
    case ParallelType::DEFAULT:
      // The user did not specify 'parallel_type = XYZ' in the input file,
      // so we allow the --distributed-mesh command line arg to possibly turn
      // on DistributedMesh.  If the command line arg is not present, we pick ReplicatedMesh.
      if (_app.getDistributedMeshOnCommandLine())
        _use_distributed_mesh = true;
      break;
    case ParallelType::REPLICATED:
      if (_app.getDistributedMeshOnCommandLine() || _is_nemesis || _app.isUseSplit())
        _parallel_type_overridden = true;
      break;
    case ParallelType::DISTRIBUTED:
      _use_distributed_mesh = true;
      break;
  }
 
  // If the user specifies 'nemesis = true' in the Mesh block, or they are using --use-split,
  // we must use DistributedMesh.
  if (_is_nemesis || _app.isUseSplit())
    _use_distributed_mesh = true;
 
  unsigned dim = getParam<MooseEnum>("dim");
 
  std::unique_ptr<MeshBase> mesh;
  if (_use_distributed_mesh)
  {
    if (override_type == ParallelType::REPLICATED)
      mooseError("The requested override_type of \"Replicated\" may not be used when MOOSE is "
                 "running with a DistributedMesh");
 
    mesh = libmesh_make_unique<DistributedMesh>(_communicator, dim);
    if (_partitioner_name != "default" && _partitioner_name != "parmetis")
    {
      _partitioner_name = "parmetis";
      _partitioner_overridden = true;
    }
  }
  else
  {
    if (override_type == ParallelType::DISTRIBUTED)
      mooseError("The requested override_type of \"Distributed\" may not be used when MOOSE is "
                 "running with a ReplicatedMesh");
 
    mesh = libmesh_make_unique<ReplicatedMesh>(_communicator, dim);
  }
 
  if (!getParam<bool>("allow_renumbering"))
    mesh->allow_renumbering(false);
 
  return mesh;
}

Referenced by MooseMesh::init().

buildNodeList()

void MooseMesh::buildNodeList ( )

inherited

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

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

Definition at line 650 of file MooseMesh.C.

{
  TIME_SECTION(_build_node_list_timer);
  CONSOLE_TIMED_PRINT("Building node lists");
 
  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());
}

Referenced by MooseMesh::update().

buildNodeListFromSideList()

void MooseMesh::buildNodeListFromSideList ( )

inherited

Calls BoundaryInfo::build_node_list_from_side_list().

Definition at line 2183 of file MooseMesh.C.

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

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

buildPeriodicNodeMap()

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

inherited

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

Definition at line 1220 of file MooseMesh.C.

{
  TIME_SECTION(_build_periodic_node_map_timer);
 
  // clear existing map
  periodic_node_map.clear();
 
  // get periodic nodes
  std::vector<PeriodicNodeInfo> periodic_nodes;
  for (const auto & t : getMesh().get_boundary_info().build_node_list())
  {
    // unfortunately libMesh does not give us a pointer, so we have to look it up ourselves
    auto node = _mesh->node_ptr(std::get<0>(t));
    mooseAssert(node != nullptr,
                "libMesh::BoundaryInfo::build_node_list() returned an ID for a non-existing node");
    auto bc_id = std::get<1>(t);
    periodic_nodes.emplace_back(node, bc_id);
  }
 
  // sort by boundary id
  std::sort(periodic_nodes.begin(),
            periodic_nodes.end(),
            [](const PeriodicNodeInfo & a, const PeriodicNodeInfo & b) -> bool {
              return a.second > b.second;
            });
 
  // build kd-tree
  using KDTreeType = nanoflann::KDTreeSingleIndexAdaptor<
      nanoflann::L2_Simple_Adaptor<Real, PointListAdaptor<PeriodicNodeInfo>>,
      PointListAdaptor<PeriodicNodeInfo>,
      LIBMESH_DIM>;
  const unsigned int max_leaf_size = 20; // slightly affects runtime
  auto point_list =
      PointListAdaptor<PeriodicNodeInfo>(periodic_nodes.begin(), periodic_nodes.end());
  auto kd_tree = libmesh_make_unique<KDTreeType>(
      LIBMESH_DIM, point_list, nanoflann::KDTreeSingleIndexAdaptorParams(max_leaf_size));
  mooseAssert(kd_tree != nullptr, "KDTree was not properly initialized.");
  kd_tree->buildIndex();
 
  // data structures for kd-tree search
  nanoflann::SearchParams search_params;
  std::vector<std::pair<std::size_t, Real>> ret_matches;
 
  // iterate over periodic nodes (boundary ids are in contiguous blocks)
  PeriodicBoundaryBase * periodic = nullptr;
  BoundaryID current_bc_id = BoundaryInfo::invalid_id;
  for (auto & pair : periodic_nodes)
  {
    // entering a new block of boundary IDs
    if (pair.second != current_bc_id)
    {
      current_bc_id = pair.second;
      periodic = pbs->boundary(current_bc_id);
      if (periodic && !periodic->is_my_variable(var_number))
        periodic = nullptr;
    }
 
    // variable is not periodic at this node, skip
    if (!periodic)
      continue;
 
    // clear result buffer
    ret_matches.clear();
 
    // id of the current node
    const auto id = pair.first->id();
 
    // position where we expect a periodic partner for the current node and boundary
    Point search_point = periodic->get_corresponding_pos(*pair.first);
 
    // search at the expected point
    kd_tree->radiusSearch(&(search_point)(0), libMesh::TOLERANCE, ret_matches, search_params);
    for (auto & match_pair : ret_matches)
    {
      const auto & match = periodic_nodes[match_pair.first];
      // add matched node if the boundary id is the corresponding id in the periodic pair
      if (match.second == periodic->pairedboundary)
        periodic_node_map.emplace(id, match.first->id());
    }
  }
}

buildPeriodicNodeSets()

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

inherited

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

Definition at line 1305 of file MooseMesh.C.

{
  TIME_SECTION(_build_periodic_node_sets_timer);
 
  periodic_node_sets.clear();
 
  // Loop over all the boundary nodes adding the periodic nodes to the appropriate set
  for (const auto & t : getMesh().get_boundary_info().build_node_list())
  {
    auto node_id = std::get<0>(t);
    auto bc_id = std::get<1>(t);
 
    // Is this current node on a known periodic boundary?
    if (periodic_node_sets.find(bc_id) != periodic_node_sets.end())
      periodic_node_sets[bc_id].insert(node_id);
    else // This still might be a periodic node but we just haven't seen this boundary_id yet
    {
      const PeriodicBoundaryBase * periodic = pbs->boundary(bc_id);
      if (periodic && periodic->is_my_variable(var_number))
        periodic_node_sets[bc_id].insert(node_id);
    }
  }
}

buildRefinementAndCoarseningMaps()

void MooseMesh::buildRefinementAndCoarseningMaps ( Assembly *  assembly )

inherited

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

Parameters

assembly

Pointer to the Assembly object for this Mesh.

Definition at line 1614 of file MooseMesh.C.

{
  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);
    auto && qrule = assembly->writeableQRule();
    auto && qrule_face = assembly->writeableQRuleFace();
 
    // 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);
  }
}

Referenced by FEProblemBase::initialSetup().

buildRefinementMap()

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

privateinherited

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

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

Referenced by MooseMesh::buildRefinementAndCoarseningMaps().

buildSideList() [1/2]

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

inherited

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

Definition at line 2209 of file MooseMesh.C.

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

buildSideList() [2/2]

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

inherited

Calls BoundaryInfo::build_side_list().

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

Definition at line 2190 of file MooseMesh.C.

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

Referenced by InterfaceQpValueUserObject::initialize().

cacheChangedLists()

void MooseMesh::cacheChangedLists ( )

inherited

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

Definition at line 538 of file MooseMesh.C.

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

Referenced by FEProblemBase::meshChangedHelper().

cacheInfo()

void MooseMesh::cacheInfo ( )

protectedinherited

Definition at line 848 of file MooseMesh.C.

{
  TIME_SECTION(_cache_info_timer);
  CONSOLE_TIMED_PRINT("Caching mesh information");
 
  _subdomain_boundary_ids.clear();
  _block_node_list.clear();
 
  // 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());
    }
  }
}

Referenced by MooseMesh::update().

changeBoundaryId() [1/2]

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

inherited

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

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

Definition at line 1960 of file MooseMesh.C.

{
  TIME_SECTION(_change_boundary_id_timer);
  changeBoundaryId(getMesh(), old_id, new_id, delete_prev);
}

Referenced by MeshExtruder::changeID().

changeBoundaryId() [2/2]

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

staticinherited

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

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

Definition at line 1969 of file MooseMesh.C.

{
  // Get a reference to our BoundaryInfo object, we will use it several times below...
  BoundaryInfo & boundary_info = mesh.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(mesh.level_elements_begin(0), mesh.level_elements_end(0)))
  {
    unsigned int n_sides = elem->n_sides();
    for (unsigned int s = 0; s != n_sides; ++s)
    {
      boundary_info.boundary_ids(elem, s, old_ids);
      if (std::find(old_ids.begin(), old_ids.end(), old_id) != old_ids.end())
      {
        std::vector<boundary_id_type> new_ids(old_ids);
        std::replace(new_ids.begin(), new_ids.end(), old_id, new_id);
        if (delete_prev)
        {
          boundary_info.remove_side(elem, s);
          boundary_info.add_side(elem, s, new_ids);
        }
        else
          boundary_info.add_side(elem, s, new_ids);
      }
    }
  }
 
  // Remove any remaining references to the old ID from the
  // BoundaryInfo object.  This prevents things like empty sidesets
  // from showing up when printing information, etc.
  if (delete_prev)
    boundary_info.remove_id(old_id);
}

clearQuadratureNodes()

void MooseMesh::clearQuadratureNodes ( )

inherited

Clear out any existing quadrature nodes.

Most likely called before re-adding them.

Definition at line 1027 of file MooseMesh.C.

{
  // 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();
}

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

clone()

MooseMesh & MooseMesh::clone ( ) const

virtualinherited

Clone method.

Allocates memory you are responsible to clean up.

Definition at line 2020 of file MooseMesh.C.

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

Referenced by TiledMesh::buildMesh().

coarsenedElementChildren()

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

inherited

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

Parameters

elem	Pointer to the parent element that was coarsened to.

Returns

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

Definition at line 568 of file MooseMesh.C.

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

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

coarsenedElementRange()

ConstElemPointerRange * MooseMesh::coarsenedElementRange ( ) const

inherited

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

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

Definition at line 562 of file MooseMesh.C.

{
  return _coarsened_elements.get();
}

Referenced by FEProblemBase::meshChangedHelper().

declareRecoverableData() [1/2]

template<typename T >

T & Restartable::declareRecoverableData ( const 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 295 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, nullptr);
}

declareRecoverableData() [2/2]

template<typename T >

T & Restartable::declareRecoverableData ( const 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 306 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
}

declareRestartableDataTempl() [1/2]

template<typename T >

T & Restartable::declareRestartableDataTempl ( const 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 222 of file Restartable.h.

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

declareRestartableDataTempl() [2/2]

template<typename T >

T & Restartable::declareRestartableDataTempl ( const 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 229 of file Restartable.h.

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

declareRestartableDataWithContext() [1/2]

template<typename T >

T & Restartable::declareRestartableDataWithContext ( const 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 250 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
 
  // Here we will create the RestartableData even though we may not use this instance.
  // If it's already in use, the App will return a reference to the existing instance and we'll
  // return that one instead. We might refactor this to have the app create the RestartableData
  // at a later date.
  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
  auto & restartable_data_ref = static_cast<RestartableData<T> &>(
      registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid));
 
  restartable_data_ref.set() = init_value;
  return restartable_data_ref.get();
}

declareRestartableDataWithContext() [2/2]

template<typename T >

T & Restartable::declareRestartableDataWithContext ( const 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 236 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);
 
  // See comment in overloaded version of this function with "init_value"
  auto & restartable_data_ref = static_cast<RestartableData<T> &>(
      registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid));
 
  return restartable_data_ref.get();
}

declareRestartableDataWithObjectName()

template<typename T >

T & Restartable::declareRestartableDataWithObjectName ( const std::string &  data_name, const 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 270 of file Restartable.h.

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

declareRestartableDataWithObjectNameWithContext()

template<typename T >

T & Restartable::declareRestartableDataWithObjectNameWithContext ( const std::string &  data_name, const 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 278 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;
}

declareRestartableDataWithPrefixOverrideAndContext()

template<typename T >

T& Restartable::declareRestartableDataWithPrefixOverrideAndContext ( const std::string &  data_name, const std::string &  prefix, 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)
prefix	The prefix to prepend to the data_name, to retrieve data from another object.
context	Context pointer that will be passed to the load and store functions

detectOrthogonalDimRanges()

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

inherited

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

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

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

Definition at line 1332 of file MooseMesh.C.

{
  TIME_SECTION(_detect_orthogonal_dim_ranges_timer);
 
  if (_regular_orthogonal_mesh)
    return true;
 
  std::vector<Real> min(3, std::numeric_limits<Real>::max());
  std::vector<Real> max(3, std::numeric_limits<Real>::min());
  unsigned int dim = getMesh().mesh_dimension();
 
  // Find the bounding box of our mesh
  for (const auto & node : getMesh().node_ptr_range())
    // Check all coordinates, we don't know if this mesh might be lying in a higher dim even if the
    // mesh dimension is lower.
    for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
    {
      if ((*node)(i) < min[i])
        min[i] = (*node)(i);
      if ((*node)(i) > max[i])
        max[i] = (*node)(i);
    }
 
  this->comm().max(max);
  this->comm().min(min);
 
  _extreme_nodes.resize(8); // 2^LIBMESH_DIM
  // Now make sure that there are actual nodes at all of the extremes
  std::vector<bool> extreme_matches(8, false);
  std::vector<unsigned int> comp_map(3);
  for (const auto & node : getMesh().node_ptr_range())
  {
    // See if the current node is located at one of the extremes
    unsigned int coord_match = 0;
 
    for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
    {
      if (std::abs((*node)(i)-min[i]) < tol)
      {
        comp_map[i] = MIN;
        ++coord_match;
      }
      else if (std::abs((*node)(i)-max[i]) < tol)
      {
        comp_map[i] = MAX;
        ++coord_match;
      }
    }
 
    if (coord_match == LIBMESH_DIM) // Found a coordinate at one of the extremes
    {
      _extreme_nodes[comp_map[X] * 4 + comp_map[Y] * 2 + comp_map[Z]] = node;
      extreme_matches[comp_map[X] * 4 + comp_map[Y] * 2 + comp_map[Z]] = true;
    }
  }
 
  // See if we matched all of the extremes for the mesh dimension
  this->comm().max(extreme_matches);
  if (std::count(extreme_matches.begin(), extreme_matches.end(), true) == (1 << dim))
    _regular_orthogonal_mesh = true;
 
  // Set the bounds
  _bounds.resize(LIBMESH_DIM);
  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
  {
    _bounds[i].resize(2);
    _bounds[i][MIN] = min[i];
    _bounds[i][MAX] = max[i];
  }
 
  return _regular_orthogonal_mesh;
}

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

detectPairedSidesets()

void MooseMesh::detectPairedSidesets ( )

privateinherited

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

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

Referenced by MooseMesh::getPairedBoundaryMapping().

dimension()

unsigned int MooseMesh::dimension ( ) const

virtualinherited

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

Definition at line 2148 of file MooseMesh.C.

{
  return getMesh().mesh_dimension();
}

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

dimensionWidth()

Real MooseMesh::dimensionWidth ( unsigned int  component ) const

inherited

Returns the width of the requested dimension.

Definition at line 1509 of file MooseMesh.C.

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

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

effectiveSpatialDimension()

unsigned int MooseMesh::effectiveSpatialDimension ( ) const

virtualinherited

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

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

Definition at line 2154 of file MooseMesh.C.

{
  const Real abs_zero = 1e-12;
 
  // See if the mesh is completely containd in the z and y planes to calculate effective spatial
  // dim
  for (unsigned int dim = LIBMESH_DIM; dim >= 1; --dim)
    if (dimensionWidth(dim - 1) >= abs_zero)
      return dim;
 
  // If we get here, we have a 1D mesh on the x-axis.
  return 1;
}

Referenced by Exodus::setOutputDimensionInExodusWriter().

elem() [1/2]

Elem * MooseMesh::elem ( const dof_id_type  i )

virtualinherited

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

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

Definition at line 2275 of file MooseMesh.C.

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

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

elem() [2/2]

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

virtualinherited

Definition at line 2282 of file MooseMesh.C.

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

elemPtr() [1/2]

Elem * MooseMesh::elemPtr ( const dof_id_type  i )

virtualinherited

Definition at line 2289 of file MooseMesh.C.

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

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

elemPtr() [2/2]

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

virtualinherited

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

{ return _enabled; }

Referenced by EigenKernel::enabled().

errorIfDistributedMesh()

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

inherited

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

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

See, for example, the NodalVariableValue class.

Definition at line 2717 of file MooseMesh.C.

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

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

exReader()

virtual ExodusII_IO* FileMesh::exReader ( ) const

inlineoverridevirtual

Not implemented – always returns NULL.

Reimplemented from MooseMesh.

Definition at line 34 of file FileMesh.h.

{ return _exreader.get(); }

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  )

privateinherited

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

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

Referenced by MooseMesh::buildCoarseningMap(), and MooseMesh::buildRefinementMap().

freeBndElems()

void MooseMesh::freeBndElems ( )

protectedinherited

Definition at line 341 of file MooseMesh.C.

{
  // free memory
  for (auto & belem : _bnd_elems)
    delete belem;
 
  for (auto & it : _bnd_elem_ids)
    it.second.clear();
 
  _bnd_elem_ids.clear();
}

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

freeBndNodes()

void MooseMesh::freeBndNodes ( )

protectedinherited

Definition at line 323 of file MooseMesh.C.

{
  // 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();
}

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

getActiveLocalElementRange()

ConstElemRange * MooseMesh::getActiveLocalElementRange ( )

inherited

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

Definition at line 758 of file MooseMesh.C.

{
  if (!_active_local_elem_range)
  {
    TIME_SECTION(_get_active_local_element_range_timer);
    CONSOLE_TIMED_PRINT("Caching active local element range");
 
    _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();
}

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

getActiveNodeRange()

NodeRange * MooseMesh::getActiveNodeRange ( )

inherited

Definition at line 773 of file MooseMesh.C.

{
  if (!_active_node_range)
  {
    TIME_SECTION(_get_active_node_range_timer);
    CONSOLE_TIMED_PRINT("Caching active node range");
 
    _active_node_range = libmesh_make_unique<NodeRange>(
        getMesh().active_nodes_begin(), getMesh().active_nodes_end(), GRAIN_SIZE);
  }
 
  return _active_node_range.get();
}

Referenced by MooseMesh::meshChanged().

getActiveSemiLocalNodeRange()

SemiLocalNodeRange * MooseMesh::getActiveSemiLocalNodeRange ( ) const

inherited

Definition at line 788 of file MooseMesh.C.

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

getBoundariesToElems()

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

inherited

Returns a map of boundaries to elements.

Definition at line 842 of file MooseMesh.C.

{
  return _bnd_elem_ids;
}

getBoundaryElementRange()

ConstBndElemRange * MooseMesh::getBoundaryElementRange ( )

inherited

Definition at line 827 of file MooseMesh.C.

{
  if (!_bnd_elem_range)
  {
    TIME_SECTION(_get_boundary_element_range_timer);
    CONSOLE_TIMED_PRINT("Caching boundary element range");
 
    _bnd_elem_range =
        libmesh_make_unique<ConstBndElemRange>(bndElemsBegin(), bndElemsEnd(), GRAIN_SIZE);
  }
 
  return _bnd_elem_range.get();
}

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

getBoundaryID()

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

inherited

Get the associated BoundaryID for the boundary name.

Returns

param boundary_name The name of the boundary.

the boundary id from the passed boundary name.

Definition at line 1039 of file MooseMesh.C.

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

Referenced by AddPeriodicBCAction::act(), ConstraintWarehouse::addObject(), TiledMesh::buildMesh(), StitchedMesh::buildMesh(), PatternedMesh::buildMesh(), DMSetUp_Moose_Pre(), MultiAppNearestNodeTransfer::getLocalEntities(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MultiAppNearestNodeTransfer::getNearestNode(), GeometricSearchData::getNearestNodeLocator(), GeometricSearchData::getPenetrationLocator(), GeometricSearchData::getQuadratureNearestNodeLocator(), GeometricSearchData::getQuadraturePenetrationLocator(), LinearNodalConstraint::LinearNodalConstraint(), LowerBoundNodalKernel::LowerBoundNodalKernel(), BreakBoundaryOnSubdomain::modify(), MeshSideSet::modify(), NodalScalarKernel::NodalScalarKernel(), AugmentSparsityOnInterface::operator()(), SetupMeshAction::setupMesh(), EqualValueBoundaryConstraint::updateConstrainedNodes(), and UpperBoundNodalKernel::UpperBoundNodalKernel().

getBoundaryIDs() [1/3]

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

inherited

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

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

Definition at line 2177 of file MooseMesh.C.

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

Referenced by MooseMesh::cacheInfo().

getBoundaryIDs() [2/3]

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

inherited

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

Definition at line 2169 of file MooseMesh.C.

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

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

getBoundaryIDs() [3/3]

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

inherited

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

Returns

param boundary_name The names of the boundaries.

the boundary ids from the passed boundary names.

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

Definition at line 1054 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();
 
  BoundaryID max_boundary_local_id = 0;
  /* It is required to generate a new ID for a given name. It is used often in mesh modifiers such
   * as SideSetsBetweenSubdomains. Then we need to check the current boundary ids since they are
   * changing during "mesh modify()", and figure out the right max boundary ID. Most of mesh
   * modifiers are running in serial, and we won't involve a global communication.
   */
  if (generate_unknown)
  {
    const std::set<BoundaryID> & local_bids = getMesh().get_boundary_info().get_boundary_ids();
    max_boundary_local_id = local_bids.empty() ? 0 : *(local_bids.rbegin());
    /* We should not hit this often */
    if (!getMesh().is_serial())
      _communicator.max(max_boundary_local_id);
  }
 
  BoundaryID max_boundary_id = _mesh_boundary_ids.empty() ? 0 : *(_mesh_boundary_ids.rbegin());
 
  max_boundary_id =
      max_boundary_id > max_boundary_local_id ? max_boundary_id : max_boundary_local_id;
 
  std::vector<BoundaryID> ids(boundary_name.size());
  for (unsigned int i = 0; i < boundary_name.size(); i++)
  {
    if (boundary_name[i] == "ANY_BOUNDARY_ID")
    {
      ids.assign(_mesh_boundary_ids.begin(), _mesh_boundary_ids.end());
      if (i)
        mooseWarning("You passed \"ANY_BOUNDARY_ID\" in addition to other boundary_names.  This "
                     "may be a logic error.");
      break;
    }
 
    BoundaryID id;
    std::istringstream ss(boundary_name[i]);
 
    if (!(ss >> id) || !ss.eof())
    {
      if (generate_unknown &&
          !MooseUtils::doesMapContainValue(sideset_map, std::string(boundary_name[i])) &&
          !MooseUtils::doesMapContainValue(nodeset_map, std::string(boundary_name[i])))
        id = ++max_boundary_id;
      else
        id = boundary_info.get_id_by_name(boundary_name[i]);
    }
 
    ids[i] = id;
  }
 
  return ids;
}

getBoundaryName()

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

inherited

Return the name of the boundary given the id.

Definition at line 1195 of file MooseMesh.C.

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

Referenced by MaterialPropertyDebugOutput::printMaterialMap().

getBoundaryNodeRange()

ConstBndNodeRange * MooseMesh::getBoundaryNodeRange ( )

inherited

Definition at line 812 of file MooseMesh.C.

{
  if (!_bnd_node_range)
  {
    TIME_SECTION(_get_boundary_node_range_timer);
    CONSOLE_TIMED_PRINT("Caching boundary node range");
 
    _bnd_node_range =
        libmesh_make_unique<ConstBndNodeRange>(bndNodesBegin(), bndNodesEnd(), GRAIN_SIZE);
  }
 
  return _bnd_node_range.get();
}

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

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

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

getCoarseningMap()

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

inherited

Get the coarsening map for a given element type.

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

Parameters

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

Definition at line 1780 of file MooseMesh.C.

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

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

getFileName()

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

inlineoverridevirtual

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

Reimplemented from MooseMesh.

Definition at line 38 of file FileMesh.h.

{ return _file_name; }

getGhostedBoundaries()

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

inherited

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

Definition at line 2407 of file MooseMesh.C.

{
  return _ghosted_boundaries;
}

getGhostedBoundaryInflation()

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

inherited

Return a writable reference to the _ghosted_boundaries_inflation vector.

Definition at line 2413 of file MooseMesh.C.

{
  return _ghosted_boundaries_inflation;
}

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

getGhostingPatchSize()

unsigned int MooseMesh::getGhostingPatchSize ( ) const

inlineinherited

Getter for the ghosting_patch_size parameter.

Definition at line 484 of file MooseMesh.h.

{ return _ghosting_patch_size; };

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

getInflatedProcessorBoundingBox()

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

inherited

Get a (slightly inflated) processor bounding box.

Parameters

inflation_multiplier

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

Definition at line 2576 of file MooseMesh.C.

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

Referenced by PointSamplerBase::execute().

getLocalNodeRange()

ConstNodeRange * MooseMesh::getLocalNodeRange ( )

inherited

Definition at line 797 of file MooseMesh.C.

{
  if (!_local_node_range)
  {
    TIME_SECTION(_get_local_node_range_timer);
    CONSOLE_TIMED_PRINT("Caching local node range");
 
    _local_node_range = libmesh_make_unique<ConstNodeRange>(
        getMesh().local_nodes_begin(), getMesh().local_nodes_end(), GRAIN_SIZE);
  }
 
  return _local_node_range.get();
}

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianInternal(), AuxiliarySystem::computeNodalVarsHelper(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjectsInternal(), WorkBalance::execute(), FEProblemBase::initialSetup(), and MooseMesh::meshChanged().

getMaxInDimension()

Real MooseMesh::getMaxInDimension ( unsigned int  component ) const

virtualinherited

Reimplemented in AnnularMesh, DistributedGeneratedMesh, and GeneratedMesh.

Definition at line 1524 of file MooseMesh.C.

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

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

getMaxLeafSize()

unsigned int MooseMesh::getMaxLeafSize ( ) const

inlineinherited

Getter for the maximum leaf size parameter.

Definition at line 489 of file MooseMesh.h.

{ return _max_leaf_size; };

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

getMesh() [1/2]

MeshBase & MooseMesh::getMesh ( )

inherited

Accessor for the underlying libMesh Mesh object.

Definition at line 2599 of file MooseMesh.C.

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

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

getMesh() [2/2]

const MeshBase & MooseMesh::getMesh ( ) const

inherited

Definition at line 2606 of file MooseMesh.C.

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

getMinInDimension()

Real MooseMesh::getMinInDimension ( unsigned int  component ) const

virtualinherited

Returns the min or max of the requested dimension respectively.

Reimplemented in AnnularMesh, DistributedGeneratedMesh, and GeneratedMesh.

Definition at line 1515 of file MooseMesh.C.

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

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

getMooseApp()

MooseApp& MooseObject::getMooseApp ( ) const

inlineinherited

Get the MooseApp this object is associated with.

Definition at line 105 of file MooseObject.h.

{ return _app; }

Referenced by MortarData::createMortarInterface(), Executioner::Executioner(), and ConsoleUtils::outputMeshInformation().

getNodeBlockIds()

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

inherited

Return list of blocks to which the given node belongs.

Definition at line 879 of file MooseMesh.C.

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

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

getNodeList()

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

inherited

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

Definition at line 2626 of file MooseMesh.C.

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

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

getNormalByBoundaryID()

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

inherited

Returns the normal vector associated with a given BoundaryID.

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

Definition at line 2010 of file MooseMesh.C.

{
  mooseAssert(_boundary_to_normal_map.get() != nullptr, "Boundary To Normal Map not built!");
 
  // Note: Boundaries that are not in the map (existing boundaries) will default
  // construct a new RealVectorValue - (x,y,z)=(0, 0, 0)
  return (*_boundary_to_normal_map)[id];
}

getPairedBoundaryMapping()

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

inherited

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

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

Parameters

component

- An integer representing the desired component (dimension)

Returns

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

Definition at line 1596 of file MooseMesh.C.

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

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

getParamTempl()

template<typename T >

const T & MooseObject::getParamTempl ( 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 208 of file MooseObject.h.

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

Referenced by FEProblemBase::addMaterialHelper(), ConstraintWarehouse::addObject(), EigenKernel::EigenKernel(), AttribThread::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), ConsoleUtils::outputExecutionInformation(), and TimePeriod::TimePeriod().

getPatchSize()

unsigned int MooseMesh::getPatchSize ( ) const

inherited

Getter for the patch_size parameter.

Definition at line 2558 of file MooseMesh.C.

{
  return _patch_size;
}

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

getPatchUpdateStrategy()

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

inherited

Get the current patch update strategy.

Definition at line 2570 of file MooseMesh.C.

{
  return _patch_update_strategy;
}

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches().

getPointLocator()

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

virtualinherited

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

Definition at line 2823 of file MooseMesh.C.

{
  return getMesh().sub_point_locator();
}

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

getQuadratureNode()

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

inherited

Get a specified quadrature node.

Parameters

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

Definition at line 1009 of file MooseMesh.C.

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

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

getRefinementMap()

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

inherited

Get the refinement map for a given element type.

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

Parameters

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

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

Definition at line 1716 of file MooseMesh.C.

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

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

getSubdomainBoundaryIds()

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

inherited

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

Parameters

subdomain_id

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

Returns

All boundary IDs connected to elements in the give

Definition at line 2653 of file MooseMesh.C.

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

Referenced by FEProblemBase::prepareMaterials().

getSubdomainID()

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

inherited

Get the associated subdomain ID for the subdomain name.

Parameters

subdomain_name

The name of the subdomain

Returns

The subdomain id from the passed subdomain name.

Definition at line 1118 of file MooseMesh.C.

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

Referenced by ConstraintWarehouse::addObject(), SystemBase::addVariable(), AugmentSparsityOnInterface::operator()(), and FEProblemBase::setCoordSystem().

getSubdomainIDs()

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

inherited

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

Parameters

subdomain_name

The names of the subdomains

Returns

The subdomain ids from the passed subdomain name.

Definition at line 1133 of file MooseMesh.C.

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

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

getSubdomainName()

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

inherited

Return the name of a block given an id.

Definition at line 1173 of file MooseMesh.C.

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

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

ghostGhostedBoundaries()

void MooseMesh::ghostGhostedBoundaries ( )

inherited

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

Definition at line 2477 of file MooseMesh.C.

{
  // 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 clear ghosted elements that were added by previous invocations of this
  // method but leave ghosted elements that were added by other code, e.g.
  // OversampleOutput, untouched
  mesh.clear_extra_ghost_elems(_ghost_elems_from_ghost_boundaries);
  _ghost_elems_from_ghost_boundaries.clear();
 
  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)));
      }
    }
  }
 
  // We really do want to store this by value instead of by reference
  const auto prior_ghost_elems = mesh.extra_ghost_elems();
 
  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));
 
  const auto & current_ghost_elems = mesh.extra_ghost_elems();
 
  std::set_difference(current_ghost_elems.begin(),
                      current_ghost_elems.end(),
                      prior_ghost_elems.begin(),
                      prior_ghost_elems.end(),
                      std::inserter(_ghost_elems_from_ghost_boundaries,
                                    _ghost_elems_from_ghost_boundaries.begin()));
}

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

hasMeshBase()

bool MooseMesh::hasMeshBase ( ) const

inlineinherited

Whether mesh base object was constructed or not.

Definition at line 887 of file MooseMesh.h.

{ return _mesh.get() != nullptr; }

Referenced by MeshGeneratorMesh::buildMesh().

hasSecondOrderElements()

bool MooseMesh::hasSecondOrderElements ( )

inherited

check if the mesh has SECOND order elements

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

Referenced by Assembly::Assembly().

init()

void MooseMesh::init ( )

virtualinherited

Initialize the Mesh object.

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

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

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

Definition at line 2089 of file MooseMesh.C.

{
  if (!_mesh)
    _mesh = buildMeshBaseObject();
 
  if (_app.isSplitMesh() && _use_distributed_mesh)
    mooseError("You cannot use the mesh splitter capability with DistributedMesh!");
 
  TIME_SECTION(_init_timer);
 
  if (_custom_partitioner_requested)
  {
    // Check of partitioner is supplied (not allowed if custom partitioner is used)
    if (!parameters().isParamSetByAddParam("partitioner"))
      mooseError("If partitioner block is provided, partitioner keyword cannot be used!");
    // Set custom partitioner
    if (!_custom_partitioner.get())
      mooseError("Custom partitioner requested but not set!");
    getMesh().partitioner().reset(_custom_partitioner.release());
  }
  else
    setPartitionerHelper();
 
  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);
      CONSOLE_TIMED_PRINT("Rcovering mesh");
      getMesh().read(_app.getRestartRecoverFileBase() + "_mesh." +
                     _app.getRestartRecoverFileSuffix());
    }
 
    getMesh().allow_renumbering(allow_renumbering_later);
    getMesh().skip_partitioning(skip_partitioning_later);
  }
  else // Normally just build the mesh
  {
    CONSOLE_TIMED_PRINT("Building mesh");
    buildMesh();
  }
}

Referenced by GridPartitioner::_do_partition().

isBoundaryElem() [1/2]

bool MooseMesh::isBoundaryElem ( dof_id_type  elem_id ) const

inherited

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

Definition at line 2691 of file MooseMesh.C.

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

isBoundaryElem() [2/2]

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

inherited

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

Definition at line 2706 of file MooseMesh.C.

{
  bool found_elem = false;
  auto it = _bnd_elem_ids.find(bnd_id);
  if (it != _bnd_elem_ids.end())
    if (it->second.find(elem_id) != it->second.end())
      found_elem = true;
  return found_elem;
}

isBoundaryNode() [1/2]

bool MooseMesh::isBoundaryNode ( dof_id_type  node_id ) const

inherited

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

Definition at line 2665 of file MooseMesh.C.

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

Referenced by LowerBoundNodalKernel::computeQpJacobian(), UpperBoundNodalKernel::computeQpJacobian(), LowerBoundNodalKernel::computeQpOffDiagJacobian(), UpperBoundNodalKernel::computeQpOffDiagJacobian(), LowerBoundNodalKernel::computeQpResidual(), UpperBoundNodalKernel::computeQpResidual(), and NodalNormalsPreprocessor::execute().

isBoundaryNode() [2/2]

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

inherited

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

Definition at line 2680 of file MooseMesh.C.

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

isCustomPartitionerRequested()

bool MooseMesh::isCustomPartitionerRequested ( ) const

inherited

Setter and getter for _custom_partitioner_requested.

Definition at line 2795 of file MooseMesh.C.

{
  return _custom_partitioner_requested;
}

isDistributedMesh()

bool MooseMesh::isDistributedMesh ( ) const

inlineinherited

Returns the final Mesh distribution type.

Definition at line 809 of file MooseMesh.h.

{ return _use_distributed_mesh; }

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

isParallelTypeForced()

bool MooseMesh::isParallelTypeForced ( ) const

inlineinherited

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

Definition at line 814 of file MooseMesh.h.

{ return _parallel_type_overridden; }

Referenced by ConsoleUtils::outputMeshInformation().

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

{ return _pars.isParamValid(name); }

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

isPartitionerForced()

bool MooseMesh::isPartitionerForced ( ) const

inlineinherited

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

Definition at line 824 of file MooseMesh.h.

{ return _partitioner_overridden; }

Referenced by ConsoleUtils::outputMeshInformation().

isRegularOrthogonal()

bool MooseMesh::isRegularOrthogonal ( )

inlineinherited

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

Definition at line 854 of file MooseMesh.h.

{ return _regular_orthogonal_mesh; }

isSemiLocal()

bool MooseMesh::isSemiLocal ( Node *const  node ) const

inherited

Returns true if the node is semi-local.

Parameters

node	Node pointer

Returns

true is the node is semi-local, false otherwise

Definition at line 617 of file MooseMesh.C.

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

isTranslatedPeriodic()

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

inherited

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

Parameters

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

Definition at line 1554 of file MooseMesh.C.

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

Referenced by MooseMesh::minPeriodicVector().

localNodesBegin()

MeshBase::const_node_iterator MooseMesh::localNodesBegin ( )

inherited

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

Definition at line 2227 of file MooseMesh.C.

{
  return getMesh().local_nodes_begin();
}

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

localNodesEnd()

MeshBase::const_node_iterator MooseMesh::localNodesEnd ( )

inherited

Definition at line 2233 of file MooseMesh.C.

{
  return getMesh().local_nodes_end();
}

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

mapPoints()

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

privateinherited

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

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

Referenced by MooseMesh::findAdaptivityQpMaps().

maxElemId()

dof_id_type MooseMesh::maxElemId ( ) const

virtualinherited

Definition at line 2269 of file MooseMesh.C.

{
  return getMesh().max_elem_id();
}

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

maxNodeId()

dof_id_type MooseMesh::maxNodeId ( ) const

virtualinherited

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

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

Definition at line 2263 of file MooseMesh.C.

{
  return getMesh().max_node_id();
}

meshBoundaryIds()

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

inherited

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

Definition at line 2344 of file MooseMesh.C.

{
  return _mesh_boundary_ids;
}

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

meshChanged()

void MooseMesh::meshChanged ( )

inherited

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

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

Definition at line 507 of file MooseMesh.C.

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

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

meshNodesetIds()

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

inherited

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

Definition at line 2356 of file MooseMesh.C.

{
  return _mesh_nodeset_ids;
}

Referenced by BoundaryRestrictable::initializeBoundaryRestrictable().

meshSidesetIds()

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

inherited

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

Definition at line 2350 of file MooseMesh.C.

{
  return _mesh_sideset_ids;
}

Referenced by DGKernelBase::DGKernelBase(), and BoundaryRestrictable::initializeBoundaryRestrictable().

meshSubdomains()

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

inherited

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

Definition at line 2338 of file MooseMesh.C.

{
  return _mesh_subdomains;
}

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

minPeriodicDistance()

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

inherited

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

Parameters

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

Returns

Real - The L2 distance between p and q

Definition at line 1590 of file MooseMesh.C.

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

minPeriodicVector()

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

inherited

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

Parameters

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

Returns

RealVectorValue - The vector pointing from p to q

Definition at line 1565 of file MooseMesh.C.

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

Referenced by MooseMesh::minPeriodicDistance().

mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 156 of file MooseObject.h.

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

Referenced by FEProblemBase::addArrayVariable(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addScalarVariable(), FEProblemBase::addVariable(), ADFunctionPresetBC< compute_stage >::ADFunctionPresetBC(), ADPresetBC< compute_stage >::ADPresetBC(), ADPresetNodalBC< compute_stage >::ADPresetNodalBC(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), FEProblemBase::computeResidual(), MaterialBase::declarePropertyOlderTempl(), MaterialBase::declarePropertyOldTempl(), MooseMesh::elem(), MultiAppTransfer::execFlags(), UserForcingFunction::f(), FaceFaceConstraint< compute_stage >::FaceFaceConstraint(), FunctionDT::FunctionDT(), FunctionPresetBC::FunctionPresetBC(), RandomICBase::generateRandom(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), Sampler::getSamples(), FEProblemBase::getUserObjects(), FEProblemBase::getVectorPostprocessorValue(), FEProblemBase::getVectorPostprocessorValueOld(), MatDiffusionBase< Real >::MatDiffusionBase(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), PercentChangePostprocessor::PercentChangePostprocessor(), PresetBC::PresetBC(), PresetNodalBC::PresetNodalBC(), Sampler::rand(), ReferenceResidualProblem::ReferenceResidualProblem(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), and UserForcingFunction::UserForcingFunction().

mooseError()

template<typename... Args>

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

inlineinherited

Definition at line 141 of file MooseObject.h.

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

Referenced by GridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), FEProblemBase::addConstraint(), ADDGKernel< compute_stage >::ADDGKernel(), FEProblemBase::addInitialCondition(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), FEProblemBase::addOutput(), DiracKernel::addPointWithValidId(), FEProblemBase::addPostprocessor(), MooseMesh::addQuadratureNode(), FEProblemBase::addVectorPostprocessor(), MultiAppConservativeTransfer::adjustTransferedSolution(), MultiAppConservativeTransfer::adjustTransferedSolutionNearestPoint(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), ADPiecewiseLinearInterpolationMaterial< compute_stage >::ADPiecewiseLinearInterpolationMaterial(), Output::advancedExecuteOn(), MooseVariableBase::allDofIndices(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BicubicSplineFunction::BicubicSplineFunction(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BoundsAux::BoundsAux(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), PiecewiseBase::buildFromFile(), PiecewiseBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), TiledMesh::buildMesh(), buildMesh(), DistributedGeneratedMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildMeshBaseObject(), MooseMesh::buildRefinementMap(), MooseMesh::buildSideList(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), SubProblem::checkBoundaryMatProps(), FEProblemBase::checkCoordinateSystems(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), MaterialBase::checkExecutionStage(), BreakMeshByBlockBase::checkInputParameter(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), ExplicitTimeIntegrator::checkLinearConvergence(), FEProblemBase::checkProblemIntegrity(), MaterialBase::checkStatefulSanity(), FEProblemBase::checkUserObjects(), MultiAppTransfer::checkVariable(), LibmeshPartitioner::clone(), MooseMesh::clone(), ComparisonPostprocessor::comparisonIsTrue(), CompositeFunction::CompositeFunction(), ElementLpNormAux::compute(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), KernelBase::computeADOffDiagJacobian(), BlockWeightedPartitioner::computeElementWeight(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), HistogramVectorPostprocessor::computeHistogram(), ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), ArrayIntegratedBC::computeJacobianBlock(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayKernel::computeOffDiagJacobian(), MaterialBase::computeProperties(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), KernelValue::computeQpResidual(), ArrayKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualType(), StatisticsVectorPostprocessor::computeStatValue(), MaterialBase::computeSubdomainProperties(), ActuallyExplicitEuler::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), CoupledForce::CoupledForce(), CoupledForceNodalKernel::CoupledForceNodalKernel(), SidesetInfoVectorPostprocessor::dataHelper(), DebugResidualAux::DebugResidualAux(), FunctorRelationshipManager::delete_remote_elements(), BicubicSplineFunction::derivative(), DerivativeSumMaterial::DerivativeSumMaterial(), DGKernel::DGKernel(), FunctorRelationshipManager::dofmap_reinit(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementIntegerAux::ElementIntegerAux(), ElementQualityAux::ElementQualityAux(), MooseMesh::errorIfDistributedMesh(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), MultiAppPostprocessorTransfer::execute(), DiscreteElementUserObject::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementQualityChecker::execute(), NodalValueSampler::execute(), GreaterThanLessThanPostprocessor::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), InterfaceQpValueUserObject::execute(), PointValue::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), TimeExtremeValue::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFit::execute(), LeastSquaresFitHistory::execute(), FEProblemBase::executeControls(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), FileOutput::FileOutput(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), VerifyElementUniqueID::finalize(), VerifyNodalUniqueID::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), Transfer::find_sys(), BreakMeshByBlockBase::findFreeBoundaryId(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase::FunctionMaterialBase(), ParsedMaterialHelper::functionParse(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), GapValueAux::GapValueAux(), WorkBalance::gather(), ExtraNodesetGenerator::generate(), RenameBoundaryGenerator::generate(), RenameBlockGenerator::generate(), ElementSubdomainIDGenerator::generate(), GeneratedMeshGenerator::generate(), CombinerGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), MeshExtruderGenerator::generate(), StackGenerator::generate(), SpiralAnnularMeshGenerator::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), RandomICBase::generateRandom(), GenericConstantMaterial::GenericConstantMaterial(), GenericFunctionMaterial::GenericFunctionMaterial(), DisplacedProblem::getArrayVariable(), FEProblemBase::getArrayVariable(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), MooseMesh::getCoarseningMap(), Control::getControllableParameterByName(), FEProblemBase::getCoordSystem(), PiecewiseConstant::getDirection(), FEProblemBase::getDistribution(), GhostingUserObject::getElementalValue(), ElementGenerator::getElemType(), MultiApp::getExecutioner(), FEProblemBase::getFunction(), SolutionUserObject::getLocalVarIndex(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), DistributedGeneratedMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMaxShapeFunctions(), AnnularMesh::getMinInDimension(), DistributedGeneratedMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MooseMesh::getNodeBlockIds(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearSystem(), MooseMesh::getPairedBoundaryMapping(), ImageMesh::GetPixelInfo(), ImageMeshGenerator::GetPixelInfo(), InterfaceQpValueUserObject::getQpValue(), MaterialStdVectorAux::getRealValue(), MooseMesh::getRefinementMap(), FEProblemBase::getSampler(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), MooseMesh::getSubdomainBoundaryIds(), MooseMesh::getSubdomainID(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getUserObjectBase(), FEProblemBase::getUserObjectTempl(), NumRelationshipManagers::getValue(), PerformanceData::getValue(), Residual::getValue(), PerfGraphData::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingAux::GhostingAux(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), AdvancedOutput::hasOutputHelper(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), Transient::init(), MooseMesh::init(), Sampler::init(), FEProblemBase::init(), NumPicardIterations::initialize(), PiecewiseLinearBase::initialSetup(), ReferenceResidualProblem::initialSetup(), MultiAppConservativeTransfer::initialSetup(), FullSolveMultiApp::initialSetup(), SolutionScalarAux::initialSetup(), SolutionAux::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), Exodus::initialSetup(), SolutionFunction::initialSetup(), SolutionUserObject::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceTimeKernel::InterfaceTimeKernel(), AugmentSparsityOnInterface::internalInit(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), LayeredSideIntegral::LayeredSideIntegral(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LinearCombinationFunction::LinearCombinationFunction(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), LowerBoundNodalKernel::LowerBoundNodalKernel(), PNGOutput::makePNG(), MaterialRealTensorValueAux::MaterialRealTensorValueAux(), MaterialRealVectorValueAux::MaterialRealVectorValueAux(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), SubProblem::meshChanged(), MeshExtruder::MeshExtruder(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshSideSetGenerator::MeshSideSetGenerator(), SideSetsFromNormals::modify(), SideSetsFromPoints::modify(), AddExtraNodeset::modify(), BreakMeshByBlockBase::modify(), MeshExtruder::modify(), AssignElementSubdomainID::modify(), SmoothMesh::modify(), AddAllSideSetsByNormals::modify(), ElementDeleterBase::modify(), ParsedSubdomainMeshModifier::modify(), RenameBlock::modify(), ImageSubdomain::modify(), OrientedSubdomainBoundingBox::modify(), BoundingBoxNodeSet::modify(), AddSideSetsFromBoundingBox::modify(), SubdomainBoundingBox::modify(), MooseGhostPointNeighbors::MooseGhostPointNeighbors(), MooseMesh::MooseMesh(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), 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(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), XDA::output(), SolutionHistory::output(), Exodus::output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), MooseObject::paramError(), PiecewiseBilinear::parse(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PiecewiseBase::PiecewiseBase(), 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(), Eigenvalue::postSolve(), Predictor::Predictor(), Transient::preExecute(), SolutionUserObject::readExodusII(), SolutionUserObject::readXda(), DerivativeParsedMaterialHelper::recurseDerivative(), FunctorRelationshipManager::redistribute(), ReferenceResidualProblem::ReferenceResidualProblem(), EqualValueEmbeddedConstraint::reinitConstraint(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), RenameBlock::RenameBlock(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), ScalarComponentIC::ScalarComponentIC(), BicubicSplineFunction::secondDerivative(), FEProblemBase::setCoordSystem(), PiecewiseBase::setData(), EigenProblem::setEigenproblemType(), FEProblemSolve::setInnerSolve(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), Split::setup(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideSetsFromNormals::SideSetsFromNormals(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPoints::SideSetsFromPoints(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObject::SolutionUserObject(), PicardSolve::solve(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), NearestPointIntegralVariablePostprocessor::spatialValue(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), StitchedMesh::StitchedMesh(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), Constraint::subdomainSetup(), MaterialBase::subdomainSetup(), Console::systemInfoFlags(), TagMatrixAux::TagMatrixAux(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TestSetupPostprocessorDataActionFunction::TestSetupPostprocessorDataActionFunction(), ThreadedGeneralUserObject::ThreadedGeneralUserObject(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), TiledMeshGenerator::TiledMeshGenerator(), Function::timeDerivative(), TimeExtremeValue::TimeExtremeValue(), TimePeriod::TimePeriod(), VectorPostprocessorVisualizationAux::timestepSetup(), MultiAppFieldTransfer::transfer(), MultiAppMeshFunctionTransfer::transferVariable(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObject::updateExodusBracketingTimeIndices(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointIntegralVariablePostprocessor::userObjectValue(), BoundingBoxIC::value(), 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().

mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 162 of file MooseObject.h.

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

Referenced by AStableDirk4::AStableDirk4(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), ParsedMaterialHelper::functionsOptimize(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), MooseObject::paramInfo(), DerivativeParsedMaterialHelper::recurseDerivative(), ReferenceResidualProblem::ReferenceResidualProblem(), and FEProblemBase::setRestartFile().

mooseWarning()

template<typename... Args>

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

inlineinherited

Definition at line 150 of file MooseObject.h.

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

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

name()

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

inlinevirtualinherited

Get the name of the object.

Returns

The name of the object TODO:MooseVariableToMooseObject (see #10601)

Reimplemented in MooseVariableBase.

Definition at line 70 of file MooseObject.h.

{ return _name; }

Referenced by GridPartitioner::_do_partition(), FEProblemBase::addADJacobianInterfaceMaterial(), FEProblemBase::addADJacobianMaterial(), FEProblemBase::addADKernel(), FEProblemBase::addADResidualInterfaceMaterial(), FEProblemBase::addADResidualMaterial(), Executioner::addAttributeReporter(), DumpObjectsProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), DumpObjectsProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), DumpObjectsProblem::addDGKernel(), FEProblemBase::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), ADDGKernel< compute_stage >::ADDGKernel(), FEProblemBase::addIndicator(), DumpObjectsProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), DumpObjectsProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addMarker(), DumpObjectsProblem::addMaterial(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), Output::advancedExecuteOn(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), DerivativeParsedMaterialHelper::assembleDerivatives(), AStableDirk4::AStableDirk4(), Function::average(), MultiApp::backup(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), FEProblemBase::checkDependMaterialsHelper(), Damper::checkMinDamping(), MaterialBase::checkStatefulSanity(), CoarsenedPiecewiseLinear::CoarsenedPiecewiseLinear(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), MaterialBase::computeSubdomainProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MultiApp::createApp(), MeshGenerator::declareMeshProperty(), FEProblemBase::declareVectorPostprocessorVector(), DOFMapOutput::demangle(), DerivativeSumMaterial::DerivativeSumMaterial(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DumpObjectsProblem::dumpObjectHelper(), ElementValueSampler::ElementValueSampler(), MooseMesh::errorIfDistributedMesh(), AB2PredictorCorrector::estimateTimeError(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), MultiAppPostprocessorTransfer::execute(), StatisticsVectorPostprocessor::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), PointValue::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppNearestNodeTransfer::execute(), HistogramVectorPostprocessor::execute(), MultiAppProjectionTransfer::execute(), Exodus::Exodus(), FancyExtruderGenerator::FancyExtruderGenerator(), MultiApp::fillPositions(), PointSamplerBase::finalize(), FunctionDT::FunctionDT(), FunctionPresetBC::FunctionPresetBC(), GeneralUserObject::GeneralUserObject(), LowerDBlockFromSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), StitchedMeshGenerator::generate(), Material::getADMaterialPropertyTempl(), MultiApp::getBoundingBox(), MooseObject::getCheckedPointerParam(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), MultiApp::getExecutioner(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), FEProblemBase::getInterfaceMaterial(), SolutionUserObject::getLocalVarIndex(), Marker::getMarkerValue(), FEProblemBase::getMaterial(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), Material::getMaterialPropertyOlderTempl(), InterfaceMaterial::getMaterialPropertyOlderTempl(), NodalPatchRecovery::getMaterialPropertyOlderTempl(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOlderTempl(), Material::getMaterialPropertyOldTempl(), InterfaceMaterial::getMaterialPropertyOldTempl(), NodalPatchRecovery::getMaterialPropertyOldTempl(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOldTempl(), Material::getMaterialPropertyTempl(), InterfaceMaterial::getMaterialPropertyTempl(), NodalPatchRecovery::getMaterialPropertyTempl(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyTempl(), MeshGenerator::getMesh(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), InterfaceMaterial::getNeighborMaterialPropertyTempl(), OutputWarehouse::getOutput(), MooseObject::getParamTempl(), GeneralUserObject::getPostprocessorValue(), FEProblemBase::getPostprocessorValue(), GeneralUserObject::getPostprocessorValueByName(), FEProblemBase::getPostprocessorValueOld(), FEProblemBase::getPostprocessorValueOlder(), FEProblemBase::getSampler(), FEProblemBase::getScatterVectorPostprocessorValue(), FEProblemBase::getScatterVectorPostprocessorValueOld(), Transient::getTimeStepperName(), InitialConditionBase::getUserObjectBase(), FEProblemBase::getUserObjectBase(), InitialConditionBase::getUserObjectByNameTempl(), InitialConditionBase::getUserObjectTempl(), FEProblemBase::getUserObjectTempl(), GeneralUserObject::getVectorPostprocessorValue(), FEProblemBase::getVectorPostprocessorValue(), GeneralUserObject::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(), SolutionScalarAux::initialSetup(), MultiAppProjectionTransfer::initialSetup(), DerivativeFunctionMaterialBase::initialSetup(), MultiApp::initialSetup(), SolutionUserObject::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPostprocessorData(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), FEProblemBase::initVectorPostprocessorData(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), Registry::isADObj(), MooseObject::isParamValid(), Registry::isRegisteredObj(), LinearCombinationFunction::LinearCombinationFunction(), Marker::Marker(), MatDiffusionBase< Real >::MatDiffusionBase(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), MaterialOutputAction::materialOutputHelper(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshSideSetGenerator::MeshSideSetGenerator(), ElementDeleterBase::modify(), MooseVariableInterface< Real >::MooseVariableInterface(), NodalValueSampler::NodalValueSampler(), NodalVariableValue::NodalVariableValue(), Registry::objData(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), ConsoleUtils::outputOutputInformation(), Nemesis::outputPostprocessors(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputScalarVariables(), OversampleOutput::outputStep(), Output::outputStep(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), PointSamplerBase::PointSamplerBase(), MultiAppConservativeTransfer::postExecute(), PresetBC::PresetBC(), PresetNodalBC::PresetNodalBC(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), MooseMesh::setSubdomainName(), Split::setup(), TransientMultiApp::setupApp(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SideValueSampler::SideValueSampler(), TransientMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialValue(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), SubProblem::storeSubdomainZeroMatProp(), MaterialBase::subdomainSetup(), TaggingInterface::TaggingInterface(), ThreadedGeneralUserObject::ThreadedGeneralUserObject(), Function::timeDerivative(), VectorPostprocessorVisualizationAux::timestepSetup(), TransientMultiApp::TransientMultiApp(), MultiAppTransfer::variableIntegrityCheck(), and AdvancedOutput::wantOutput().

needsPrepareForUse()

void MooseMesh::needsPrepareForUse ( )

inherited

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

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

Definition at line 2332 of file MooseMesh.C.

{
  _needs_prepare_for_use = true;
}

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

needsRemoteElemDeletion() [1/2]

bool MooseMesh::needsRemoteElemDeletion ( ) const

inlineinherited

Whether we need to delete remote elements.

Definition at line 882 of file MooseMesh.h.

{ return _need_delete; }

needsRemoteElemDeletion() [2/2]

void MooseMesh::needsRemoteElemDeletion ( bool  need_delete )

inlineinherited

Set whether we need to delete remote elements.

Definition at line 877 of file MooseMesh.h.

{ _need_delete = need_delete; }

nElem()

dof_id_type MooseMesh::nElem ( ) const

virtualinherited

Definition at line 2257 of file MooseMesh.C.

{
  return getMesh().n_elem();
}

nNodes()

dof_id_type MooseMesh::nNodes ( ) const

virtualinherited

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

Definition at line 2251 of file MooseMesh.C.

{
  return getMesh().n_nodes();
}

node() [1/2]

Node & MooseMesh::node ( const dof_id_type  i )

virtualinherited

Definition at line 446 of file MooseMesh.C.

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

node() [2/2]

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

virtualinherited

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

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

Definition at line 439 of file MooseMesh.C.

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

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

nodePtr() [1/2]

Node * MooseMesh::nodePtr ( const dof_id_type  i )

virtualinherited

Definition at line 480 of file MooseMesh.C.

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

nodePtr() [2/2]

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

virtualinherited

Definition at line 471 of file MooseMesh.C.

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

Referenced by dataLoad().

nodeRef() [1/2]

Node & MooseMesh::nodeRef ( const dof_id_type  i )

virtualinherited

Definition at line 462 of file MooseMesh.C.

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

nodeRef() [2/2]

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

virtualinherited

Definition at line 453 of file MooseMesh.C.

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

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

nodeToActiveSemilocalElemMap()

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

inherited

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

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

Note

Extra ghosted elements are not included in this map!

Definition at line 732 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);
    CONSOLE_TIMED_PRINT("Building active semilocal element map");
 
    if (!_node_to_active_semilocal_elem_map_built)
    {
      for (const auto & elem :
           as_range(getMesh().semilocal_elements_begin(), getMesh().semilocal_elements_end()))
        if (elem->active())
          for (unsigned int n = 0; n < elem->n_nodes(); n++)
            _node_to_active_semilocal_elem_map[elem->node_id(n)].push_back(elem->id());
 
      _node_to_active_semilocal_elem_map_built =
          true; // MUST be set at the end for double-checked locking to work!
    }
  }
 
  return _node_to_active_semilocal_elem_map;
}

nodeToElemMap()

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

inherited

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

Definition at line 709 of file MooseMesh.C.

{
  if (!_node_to_elem_map_built) // Guard the creation with a double checked lock
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
 
    if (!_node_to_elem_map_built)
    {
      TIME_SECTION(_node_to_elem_map_timer);
      CONSOLE_TIMED_PRINT("Building node to element map");
 
      for (const auto & elem : getMesh().active_element_ptr_range())
        for (unsigned int n = 0; n < elem->n_nodes(); n++)
          _node_to_elem_map[elem->node_id(n)].push_back(elem->id());
 
      _node_to_elem_map_built = true; // MUST be set at the end for double-checked locking to work!
    }
  }
 
  return _node_to_elem_map;
}

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

onMeshChanged()

void MooseMesh::onMeshChanged ( )

virtualinherited

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

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

Definition at line 533 of file MooseMesh.C.

{
}

Referenced by MooseMesh::meshChanged().

operator const libMesh::MeshBase &()

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

inherited

Definition at line 2596 of file MooseMesh.C.

{ return getMesh(); }

operator libMesh::MeshBase &()

MooseMesh::operator libMesh::MeshBase & ( )

inherited

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

Definition at line 2594 of file MooseMesh.C.

{ return getMesh(); }

paramError()

template<typename... Args>

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

inherited

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

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

Definition at line 215 of file MooseObject.h.

{
  Moose::show_trace = false;
  mooseError(paramErrorMsg(param, std::forward<Args>(args)...));
  Moose::show_trace = true;
}

Referenced by ADDGKernel< compute_stage >::ADDGKernel(), ADIntegratedBCTempl< T, compute_stage >::ADIntegratedBCTempl(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), ADVectorFunctionDirichletBC< compute_stage >::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayDGKernel::ArrayDGKernel(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), BlockWeightedPartitioner::BlockWeightedPartitioner(), checkComponent(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CombinerGenerator::CombinerGenerator(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), Coupleable::Coupleable(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), Eigenvalue::Eigenvalue(), ElementValueSampler::ElementValueSampler(), Executioner::Executioner(), FancyExtruderGenerator::FancyExtruderGenerator(), RenameBoundaryGenerator::generate(), MeshCollectionGenerator::generate(), StackGenerator::generate(), StitchedMeshGenerator::generate(), CombinerGenerator::generate(), Sampler::getGlobalSamples(), Sampler::getLocalSamples(), Sampler::getNextLocalRow(), MultiApp::init(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), IntegratedBC::IntegratedBC(), InversePowerMethod::InversePowerMethod(), Kernel::Kernel(), PNGOutput::makeMeshFunc(), MeshCollectionGenerator::MeshCollectionGenerator(), MultiAppConservativeTransfer::MultiAppConservativeTransfer(), MultiAppInterpolationTransfer::MultiAppInterpolationTransfer(), MultiAppMeshFunctionTransfer::MultiAppMeshFunctionTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalValueSampler::NodalValueSampler(), PatchMeshGenerator::PatchMeshGenerator(), PatternedMeshGenerator::PatternedMeshGenerator(), PiecewiseFunctionTabulate::PiecewiseFunctionTabulate(), PlaneDeletionGenerator::PlaneDeletionGenerator(), RandomIC::RandomIC(), MooseMesh::setPartitioner(), MultiAppFieldTransfer::transfer(), Transfer::Transfer(), TransientMultiApp::TransientMultiApp(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), and VectorFunctionIC::VectorFunctionIC().

paramErrorMsg()

template<typename... Args>

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

inlineprivateinherited

Definition at line 185 of file MooseObject.h.

  {
    auto prefix = paramErrorPrefix(_pars, param);
    std::ostringstream oss;
    moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
    std::string msg = oss.str();
 
    // Wrap error message to a separate line from prefix if it is about to
    // blow past 100 chars.  But only wrap if the prefix is long enough (12
    // chars) for the wrap to buy us much extra length.
    if ((prefix.size() > 12 && msg.size() + prefix.size() > 99) ||
        msg.find("\n") != std::string::npos)
    {
      if (prefix.size() > 0 && prefix[prefix.size() - 1] != ':')
        prefix += ":";
      return prefix + "\n    " + MooseUtils::replaceAll(msg, "\n", "\n    ");
    }
    return prefix + " " + msg;
  }

Referenced by MooseObject::paramError(), MooseObject::paramInfo(), and MooseObject::paramWarning().

parameters()

const InputParameters& MooseObject::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 76 of file MooseObject.h.

{ return _pars; }

Referenced by FEProblemBase::addADJacobianInterfaceMaterial(), FEProblemBase::addADJacobianMaterial(), FEProblemBase::addADKernel(), FEProblemBase::addADResidualInterfaceMaterial(), FEProblemBase::addADResidualMaterial(), DumpObjectsProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), 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(), FEProblemBase::addInterfaceMaterial(), DumpObjectsProblem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), DumpObjectsProblem::addMaterial(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial< compute_stage >::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC< compute_stage >::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), assemble_l2(), Moose::assemble_matrix(), AuxKernelTempl< ComputeValueType >::AuxKernelTempl(), AuxScalarKernel::AuxScalarKernel(), BoundsAux::BoundsAux(), LibmeshPartitioner::clone(), OversampleOutput::cloneMesh(), Moose::compute_bounds(), Moose::compute_jacobian(), Moose::compute_nearnullspace(), Moose::compute_nullspace(), Moose::compute_postcheck(), Moose::compute_transpose_nullspace(), Console::Console(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Exodus::Exodus(), FEProblem::FEProblem(), GapValueAux::GapValueAux(), MooseObject::getCheckedPointerParam(), GhostingUserObject::GhostingUserObject(), MooseMesh::init(), BlockRestrictable::initializeBlockRestrictable(), FEProblemBase::initNullSpaceVectors(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), isValid(), LayeredSideIntegral::LayeredSideIntegral(), MooseVariableInterface< Real >::MooseVariableInterface(), NodeFaceConstraint::NodeFaceConstraint(), PatchMeshGenerator::PatchMeshGenerator(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), MultiAppProjectionTransfer::projectSolution(), RandomIC::RandomIC(), InputParameterWarehouse::removeInputParameters(), EigenProblem::scaleEigenvector(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), DumpObjectsProblem::stringifyParameters(), Transient::Transient(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), and VectorFunctionIC::VectorFunctionIC().

paramInfo()

template<typename... Args>

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

inherited

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

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

Definition at line 231 of file MooseObject.h.

{
  mooseInfo(paramErrorMsg(param, std::forward<Args>(args)...));
}

Referenced by TransientMultiApp::TransientMultiApp().

paramWarning()

template<typename... Args>

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

inherited

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

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

Definition at line 224 of file MooseObject.h.

{
  mooseWarning(paramErrorMsg(param, std::forward<Args>(args)...));
}

Referenced by Executioner::Executioner().

partitionerName()

const MooseEnum& MooseMesh::partitionerName ( ) const

inlineinherited

Definition at line 819 of file MooseMesh.h.

{ return _partitioner_name; }

Referenced by ConsoleUtils::outputMeshInformation().

prepare()

void MooseMesh::prepare ( bool  force = false )

inherited

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

Also calls update() internally.

Definition at line 354 of file MooseMesh.C.

{
  TIME_SECTION(_prepare_timer);
 
  mooseAssert(_mesh, "The MeshBase has not been constructed");
 
  if (dynamic_cast<DistributedMesh *>(&getMesh()) && !_is_nemesis)
  {
    // Call prepare_for_use() and don't mess with the renumbering
    // setting
    if (force || _needs_prepare_for_use)
    {
      CONSOLE_TIMED_PRINT("Preparing for use");
 
      getMesh().prepare_for_use();
    }
  }
  else
  {
    CONSOLE_TIMED_PRINT("Preparing for use");
 
    // Call prepare_for_use() and DO NOT allow renumbering
    getMesh().allow_renumbering(false);
    if (force || _needs_prepare_for_use)
      getMesh().prepare_for_use();
  }
 
  // Collect (local) subdomain IDs
  _mesh_subdomains.clear();
  for (const auto & elem : getMesh().element_ptr_range())
    _mesh_subdomains.insert(elem->subdomain_id());
 
  // Make sure nodesets have been generated
  buildNodeListFromSideList();
 
  // Collect (local) boundary IDs
  const std::set<BoundaryID> & local_bids = getMesh().get_boundary_info().get_boundary_ids();
  _mesh_boundary_ids.insert(local_bids.begin(), local_bids.end());
 
  const std::set<BoundaryID> & local_node_bids =
      getMesh().get_boundary_info().get_node_boundary_ids();
  _mesh_nodeset_ids.insert(local_node_bids.begin(), local_node_bids.end());
 
  const std::set<BoundaryID> & local_side_bids =
      getMesh().get_boundary_info().get_side_boundary_ids();
  _mesh_sideset_ids.insert(local_side_bids.begin(), local_side_bids.end());
 
  // Communicate subdomain and boundary IDs if this is a parallel mesh
  if (!getMesh().is_serial())
  {
    _communicator.set_union(_mesh_subdomains);
    _communicator.set_union(_mesh_boundary_ids);
    _communicator.set_union(_mesh_nodeset_ids);
    _communicator.set_union(_mesh_sideset_ids);
  }
 
  detectOrthogonalDimRanges();
 
  update();
 
  // Prepared has been called
  _is_prepared = true;
  _needs_prepare_for_use = false;
}

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

prepared() [1/2]

bool MooseMesh::prepared ( ) const

inherited

Setter/getter for the _is_prepared flag.

Definition at line 2313 of file MooseMesh.C.

{
  return _is_prepared;
}

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

prepared() [2/2]

void MooseMesh::prepared ( bool  state )

virtualinherited

If we are explicitly setting the mesh to not prepared, then we've likely modified the mesh and can no longer make assumptions about orthogonality. We really should recheck.

Reimplemented in AnnularMesh, DistributedGeneratedMesh, and GeneratedMesh.

Definition at line 2319 of file MooseMesh.C.

{
  _is_prepared = state;
 
  if (!state)
    _regular_orthogonal_mesh = false;
}

printInfo()

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

inherited

Calls print_info() on the underlying Mesh.

Definition at line 2620 of file MooseMesh.C.

{
  getMesh().print_info(os);
}

Referenced by Adaptivity::adaptMesh().

queryElemPtr() [1/2]

Elem * MooseMesh::queryElemPtr ( const dof_id_type  i )

virtualinherited

Definition at line 2301 of file MooseMesh.C.

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

Referenced by EqualValueBoundaryConstraint::updateConstrainedNodes().

queryElemPtr() [2/2]

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

virtualinherited

Definition at line 2307 of file MooseMesh.C.

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

queryNodePtr() [1/2]

Node * MooseMesh::queryNodePtr ( const dof_id_type  i )

virtualinherited

Definition at line 498 of file MooseMesh.C.

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

queryNodePtr() [2/2]

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

virtualinherited

Definition at line 489 of file MooseMesh.C.

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

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

read()

void FileMesh::read

(

const std::string &

file_name

)

Definition at line 130 of file FileMesh.C.

{
  if (dynamic_cast<DistributedMesh *>(&getMesh()) && !_is_nemesis)
    getMesh().read(file_name, /*mesh_data=*/NULL, /*skip_renumber=*/false);
  else
    getMesh().read(file_name, /*mesh_data=*/NULL, /*skip_renumber=*/true);
}

refinedElementRange()

ConstElemPointerRange * MooseMesh::refinedElementRange ( ) const

inherited

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

Returns

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

Definition at line 556 of file MooseMesh.C.

{
  return _refined_elements.get();
}

Referenced by FEProblemBase::meshChangedHelper().

registerRestartableDataOnApp()

RestartableDataValue & Restartable::registerRestartableDataOnApp ( const std::string &  name, std::unique_ptr< RestartableDataValue >  data, THREAD_ID  tid  )

privateinherited

Helper function for actually registering the restartable data.

Definition at line 48 of file Restartable.C.

{
  return _restartable_app.registerRestartableData(name, std::move(data), tid, false, false);
}

Referenced by Restartable::declareRestartableDataWithContext().

registerRestartableNameWithFilterOnApp()

void Restartable::registerRestartableNameWithFilterOnApp ( const std::string &  name, Moose::RESTARTABLE_FILTER  filter  )

privateinherited

Helper function for actually registering the restartable data.

Definition at line 56 of file Restartable.C.

{
  _restartable_app.registerRestartableNameWithFilter(name, filter);
}

Referenced by Restartable::declareRecoverableData().

registerTimedSection()

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

protectedinherited

Call to register a named section for timing.

Parameters

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

Returns

The ID of the section - use when starting timing

Definition at line 51 of file PerfGraphInterface.C.

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

safeClone()

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

overridevirtual

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

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

Implements MooseMesh.

Definition at line 52 of file FileMesh.C.

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

setBoundaryName()

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

inherited

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

Definition at line 1179 of file MooseMesh.C.

{
  BoundaryInfo & boundary_info = getMesh().get_boundary_info();
 
  std::vector<BoundaryID> side_boundaries;
  boundary_info.build_side_boundary_ids(side_boundaries);
 
  // We need to figure out if this boundary is a sideset or nodeset
  if (std::find(side_boundaries.begin(), side_boundaries.end(), boundary_id) !=
      side_boundaries.end())
    boundary_info.sideset_name(boundary_id) = name;
  else
    boundary_info.nodeset_name(boundary_id) = name;
}

Referenced by SetupMeshAction::setupMesh().

setBoundaryToNormalMap() [1/2]

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

inherited

Definition at line 2375 of file MooseMesh.C.

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

setBoundaryToNormalMap() [2/2]

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

inherited

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

Definition at line 2368 of file MooseMesh.C.

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

Referenced by AddAllSideSetsByNormals::modify().

setCustomPartitioner()

void MooseMesh::setCustomPartitioner ( Partitioner *  partitioner )

inherited

Setter for custom partitioner.

Definition at line 2789 of file MooseMesh.C.

{
  _custom_partitioner = partitioner->clone();
}

setFileName()

void FileMesh::setFileName ( const std::string &  file_name )

inline

Definition at line 37 of file FileMesh.h.

{ _file_name = file_name; }

setGhostedBoundaryInflation()

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

inherited

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

Definition at line 2401 of file MooseMesh.C.

{
  _ghosted_boundaries_inflation = inflation;
}

Referenced by SetupMeshAction::setupMesh().

setIsCustomPartitionerRequested()

void MooseMesh::setIsCustomPartitionerRequested ( bool  cpr )

inherited

Definition at line 2817 of file MooseMesh.C.

{
  _custom_partitioner_requested = cpr;
}

setMeshBase()

void MooseMesh::setMeshBase ( std::unique_ptr< MeshBase >  mesh_base )

inherited

Method to set the mesh_base object.

If this method is NOT called prior to calling init(), a MeshBase object will be automatically constructed and set.

Definition at line 2083 of file MooseMesh.C.

{
  _mesh = std::move(mesh_base);
}

setMeshBoundaryIDs()

void MooseMesh::setMeshBoundaryIDs ( std::set< BoundaryID >  boundary_IDs )

inherited

Sets the set of BoundaryIDs Is called by AddAllSideSetsByNormals.

Definition at line 2362 of file MooseMesh.C.

{
  _mesh_boundary_ids = boundary_IDs;
}

Referenced by AddAllSideSetsByNormals::modify().

setPartitioner()

void MooseMesh::setPartitioner ( MeshBase &  mesh_base, MooseEnum &  partitioner, bool  use_distributed_mesh, const InputParameters &  params, MooseObject &  context_obj  )

staticinherited

Method for setting the partitioner on the passed in mesh_base object.

Definition at line 2734 of file MooseMesh.C.

{
  // Set the partitioner based on partitioner name
  switch (partitioner)
  {
    case -3: // default
      // We'll use the default partitioner, but notify the user of which one is being used...
      if (use_distributed_mesh)
        partitioner = "parmetis";
      else
        partitioner = "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
      mesh_base.partitioner().reset(new LinearPartitioner);
      break;
    case 1: // centroid
    {
      if (!params.isParamValid("centroid_partitioner_direction"))
        context_obj.paramError(
            "centroid_partitioner_direction",
            "If using the centroid partitioner you _must_ specify centroid_partitioner_direction!");
 
      MooseEnum direction = params.get<MooseEnum>("centroid_partitioner_direction");
 
      if (direction == "x")
        mesh_base.partitioner().reset(new CentroidPartitioner(CentroidPartitioner::X));
      else if (direction == "y")
        mesh_base.partitioner().reset(new CentroidPartitioner(CentroidPartitioner::Y));
      else if (direction == "z")
        mesh_base.partitioner().reset(new CentroidPartitioner(CentroidPartitioner::Z));
      else if (direction == "radial")
        mesh_base.partitioner().reset(new CentroidPartitioner(CentroidPartitioner::RADIAL));
      break;
    }
    case 2: // hilbert_sfc
      mesh_base.partitioner().reset(new HilbertSFCPartitioner);
      break;
    case 3: // morton_sfc
      mesh_base.partitioner().reset(new MortonSFCPartitioner);
      break;
  }
}

Referenced by MooseMesh::setPartitionerHelper().

setPartitionerHelper()

void MooseMesh::setPartitionerHelper ( )

protectedinherited

Definition at line 2728 of file MooseMesh.C.

{
  setPartitioner(getMesh(), _partitioner_name, _use_distributed_mesh, _pars, *this);
}

Referenced by MooseMesh::init().

setPatchUpdateStrategy()

void MooseMesh::setPatchUpdateStrategy ( Moose::PatchUpdateType  patch_update_strategy )

inherited

Set the patch size update strategy.

Definition at line 2564 of file MooseMesh.C.

{
  _patch_update_strategy = patch_update_strategy;
}

setSubdomainName() [1/2]

void MooseMesh::setSubdomainName ( MeshBase &  mesh, SubdomainID  subdomain_id, const SubdomainName &  name  )

staticinherited

This method sets the name for subdomain_id on the provided mesh to name.

Definition at line 1167 of file MooseMesh.C.

{
  mesh.subdomain_name(subdomain_id) = name;
}

setSubdomainName() [2/2]

void MooseMesh::setSubdomainName ( SubdomainID  subdomain_id, const SubdomainName &  name  )

inherited

This method sets the name for subdomain_id to name.

Definition at line 1161 of file MooseMesh.C.

{
  getMesh().subdomain_name(subdomain_id) = name;
}

Referenced by MooseMesh::MooseMesh(), and SetupMeshAction::setupMesh().

setUniformRefineLevel()

void MooseMesh::setUniformRefineLevel ( unsigned int  level )

inherited

Set uniform refinement level.

Definition at line 2389 of file MooseMesh.C.

{
  _uniform_refine_level = level;
}

Referenced by SetupMeshAction::setupMesh().

sideWithBoundaryID()

unsigned int MooseMesh::sideWithBoundaryID ( const Elem *const  elem, const BoundaryID  boundary_id  ) const

inherited

Calls BoundaryInfo::side_with_boundary_id().

Definition at line 2221 of file MooseMesh.C.

{
  return getMesh().get_boundary_info().side_with_boundary_id(elem, boundary_id);
}

type()

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

inlineinherited

Get the type of this object.

Returns

the name of the type of this object

Definition at line 63 of file MooseObject.h.

{ return _type; }

Referenced by FEProblemBase::addArrayVariable(), FEProblemBase::addAuxArrayVariable(), DumpObjectsProblem::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), DumpObjectsProblem::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), DumpObjectsProblem::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), DumpObjectsProblem::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), DumpObjectsProblem::addKernel(), DumpObjectsProblem::addMaterial(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addPredictor(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarVariable(), PhysicsBasedPreconditioner::addSystem(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addVariable(), FEProblemBase::advanceMultiApps(), FEProblemBase::backupMultiApps(), MooseMesh::buildRefinementAndCoarseningMaps(), FEProblemBase::computeAuxiliaryKernels(), DGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighJacobian(), DGKernel::computeElemNeighResidual(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), FEProblemBase::computeMultiAppsDT(), DGKernel::computeOffDiagElemNeighJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), DGConvection::computeQpJacobian(), ArrayDGDiffusion::computeQpJacobian(), InterfaceReaction::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), DGDiffusion::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), DGConvection::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), InterfaceReaction::computeQpResidual(), TiedValueConstraint::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), DGDiffusion::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), EqualValueEmbeddedConstraint::computeQpResidual(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), DisplacedProblem::createQRules(), FEProblemBase::createQRules(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), FEProblemBase::finishMultiAppStep(), ElementSubdomainIDGenerator::generate(), ElementGenerator::getElemType(), FEProblemBase::getInterfaceMaterial(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), FEProblemBase::getTransfers(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), AdvancedOutput::initAvailableLists(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), AssignElementSubdomainID::modify(), ControlOutput::output(), Gnuplot::output(), CSV::output(), Exodus::output(), Console::output(), Nemesis::output(), AdvancedOutput::output(), OversampleOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), FEProblemBase::restoreMultiApps(), FEProblemBase::setCoupling(), PerfGraphOutput::shouldOutput(), FileOutput::shouldOutput(), Output::shouldOutput(), AdvancedOutput::shouldOutput(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), and AdvancedOutput::wantOutput().

uniformRefineLevel()

unsigned int MooseMesh::uniformRefineLevel ( ) const

inherited

Returns the level of uniform refinement requested (zero if AMR is disabled).

Definition at line 2383 of file MooseMesh.C.

{
  return _uniform_refine_level;
}

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::initialSetup(), Adaptivity::uniformRefine(), and Adaptivity::uniformRefineWithProjection().

update()

void MooseMesh::update ( )

inherited

Calls buildNodeListFromSideList(), buildNodeList(), and buildBndElemList().

Definition at line 420 of file MooseMesh.C.

{
  TIME_SECTION(_update_timer);
 
  // Rebuild the boundary conditions
  buildNodeListFromSideList();
 
  // Update the node to elem map
  _node_to_elem_map.clear();
  _node_to_elem_map_built = false;
  _node_to_active_semilocal_elem_map.clear();
  _node_to_active_semilocal_elem_map_built = false;
 
  buildNodeList();
  buildBndElemList();
  cacheInfo();
}

Referenced by MooseMesh::meshChanged(), MooseMesh::prepare(), and EqualValueBoundaryConstraint::updateConstrainedNodes().

updateActiveSemiLocalNodeRange()

void MooseMesh::updateActiveSemiLocalNodeRange ( std::set< dof_id_type > &  ghosted_elems )

inherited

Clears the "semi-local" node list and rebuilds it.

Semi-local nodes consist of all nodes that belong to local and ghost elements.

Definition at line 576 of file MooseMesh.C.

{
  TIME_SECTION(_update_active_semi_local_node_range_timer);
 
  _semilocal_node_list.clear();
 
  // First add the nodes connected to local elems
  ConstElemRange * active_local_elems = getActiveLocalElementRange();
  for (const auto & elem : *active_local_elems)
  {
    for (unsigned int n = 0; n < elem->n_nodes(); ++n)
    {
      // Since elem is const here but we require a non-const Node * to
      // store in the _semilocal_node_list (otherwise things like
      // UpdateDisplacedMeshThread don't work), we are using a
      // const_cast. A more long-term fix would be to have
      // getActiveLocalElementRange return a non-const ElemRange.
      Node * node = const_cast<Node *>(elem->node_ptr(n));
 
      _semilocal_node_list.insert(node);
    }
  }
 
  // Now add the nodes connected to ghosted_elems
  for (const auto & ghost_elem_id : ghosted_elems)
  {
    Elem * elem = getMesh().elem_ptr(ghost_elem_id);
    for (unsigned int n = 0; n < elem->n_nodes(); n++)
    {
      Node * node = elem->node_ptr(n);
 
      _semilocal_node_list.insert(node);
    }
  }
 
  // Now create the actual range
  _active_semilocal_node_range = libmesh_make_unique<SemiLocalNodeRange>(
      _semilocal_node_list.begin(), _semilocal_node_list.end());
}

Referenced by FEProblemBase::initialSetup(), FEProblemBase::meshChangedHelper(), and FEProblemBase::possiblyRebuildGeomSearchPatches().

validParams()

InputParameters FileMesh::validParams ( )

static

Definition at line 25 of file FileMesh.C.

{
  InputParameters params = MooseMesh::validParams();
  params.addRequiredParam<MeshFileName>("file", "The name of the mesh file to read");
  params.addClassDescription("Read a mesh from a file.");
  return params;
}

Referenced by SetupMeshAction::modifyParamsForUseSplit().

Member Data Documentation

_active_local_elem_range

std::unique_ptr<ConstElemRange> MooseMesh::_active_local_elem_range

protectedinherited

A range for use with threading.

We do this so that it doesn't have to get rebuilt all the time (which takes time).

Definition at line 966 of file MooseMesh.h.

Referenced by MooseMesh::getActiveLocalElementRange(), and MooseMesh::meshChanged().

_active_node_range

std::unique_ptr<NodeRange> MooseMesh::_active_node_range

protectedinherited

Definition at line 969 of file MooseMesh.h.

Referenced by MooseMesh::getActiveNodeRange(), and MooseMesh::meshChanged().

_active_semilocal_node_range

std::unique_ptr<SemiLocalNodeRange> MooseMesh::_active_semilocal_node_range

protectedinherited

Definition at line 968 of file MooseMesh.h.

Referenced by MooseMesh::getActiveSemiLocalNodeRange(), MooseMesh::meshChanged(), and MooseMesh::updateActiveSemiLocalNodeRange().

_allow_recovery

bool MooseMesh::_allow_recovery

privateinherited

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

Definition at line 1170 of file MooseMesh.h.

Referenced by MooseMesh::allowRecovery(), and MooseMesh::init().

_app

MooseApp& MooseObject::_app

protectedinherited

The MooseApp this object is associated with.

Definition at line 172 of file MooseObject.h.

Referenced by GridPartitioner::_do_partition(), AB2PredictorCorrector::AB2PredictorCorrector(), Executioner::addAttributeReporter(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addOutput(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), buildMesh(), MeshGeneratorMesh::buildMesh(), MooseMesh::buildMeshBaseObject(), FEProblemBase::checkNonlinearConvergence(), OversampleOutput::cloneMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), MultiApp::createApp(), MeshGenerator::declareMeshProperty(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), NonlinearEigen::execute(), InversePowerMethod::execute(), Transient::execute(), Steady::execute(), FileOutput::FileOutput(), FEProblemBase::forceOutput(), MeshGenerator::getMesh(), MeshGenerator::getMeshByName(), MooseObject::getMooseApp(), NumRelationshipManagers::getValue(), GhostingUserObject::GhostingUserObject(), NonlinearEigen::init(), InversePowerMethod::init(), Transient::init(), Steady::init(), MooseMesh::init(), NumPicardIterations::initialize(), TimePeriod::initialSetup(), Console::initialSetup(), MultiApp::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutput(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), ElementSideNeighborLayers::internalInit(), MeshGeneratorMesh::MeshGeneratorMesh(), MooseObject::mooseError(), EigenExecutionerBase::normalizeSolution(), AugmentSparsityOnInterface::operator()(), PerfGraphOutput::output(), Tecplot::output(), Exodus::output(), Nemesis::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), OversampleOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), Console::outputSystemInformation(), MultiApp::parentOutputPositionChanged(), PerformanceData::PerformanceData(), PetscOutput::petscLinearOutput(), PetscOutput::petscNonlinearOutput(), Eigenvalue::postSolve(), Transient::preExecute(), FEProblemBase::projectSolution(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimePeriod::TimePeriod(), FEProblemBase::timestepSetup(), Transient::Transient(), and Console::write().

_block_node_list

std::map<dof_id_type, std::set<SubdomainID> > MooseMesh::_block_node_list

protectedinherited

list of nodes that belongs to a specified block (domain)

Definition at line 1024 of file MooseMesh.h.

Referenced by MooseMesh::cacheInfo(), and MooseMesh::getNodeBlockIds().

_bnd_elem_ids

std::unordered_map<boundary_id_type, std::unordered_set<dof_id_type> > MooseMesh::_bnd_elem_ids

protectedinherited

Map of set of elem IDs connected to each boundary.

Definition at line 1016 of file MooseMesh.h.

Referenced by MooseMesh::buildBndElemList(), MooseMesh::freeBndElems(), MooseMesh::getBoundariesToElems(), and MooseMesh::isBoundaryElem().

_bnd_elem_range

std::unique_ptr<StoredRange<MooseMesh::const_bnd_elem_iterator, const BndElement *> > MooseMesh::_bnd_elem_range

protectedinherited

Definition at line 973 of file MooseMesh.h.

Referenced by MooseMesh::getBoundaryElementRange(), and MooseMesh::meshChanged().

_bnd_elems

std::vector<BndElement *> MooseMesh::_bnd_elems

protectedinherited

array of boundary elems

Definition at line 1011 of file MooseMesh.h.

Referenced by MooseMesh::bndElemsBegin(), MooseMesh::bndElemsEnd(), MooseMesh::buildBndElemList(), and MooseMesh::freeBndElems().

_bnd_node_ids

std::map<boundary_id_type, std::set<dof_id_type> > MooseMesh::_bnd_node_ids

protectedinherited

Map of sets of node IDs in each boundary.

Definition at line 1008 of file MooseMesh.h.

Referenced by MooseMesh::addQuadratureNode(), MooseMesh::buildNodeList(), MooseMesh::freeBndNodes(), and MooseMesh::isBoundaryNode().

_bnd_node_range

std::unique_ptr<StoredRange<MooseMesh::const_bnd_node_iterator, const BndNode *> > MooseMesh::_bnd_node_range

protectedinherited

Definition at line 971 of file MooseMesh.h.

Referenced by MooseMesh::addQuadratureNode(), MooseMesh::getBoundaryNodeRange(), and MooseMesh::meshChanged().

_bnd_nodes

std::vector<BndNode *> MooseMesh::_bnd_nodes

protectedinherited

array of boundary nodes

Definition at line 1004 of file MooseMesh.h.

Referenced by MooseMesh::addQuadratureNode(), MooseMesh::bndNodesBegin(), MooseMesh::bndNodesEnd(), MooseMesh::buildNodeList(), and MooseMesh::freeBndNodes().

_boundary_to_normal_map

std::unique_ptr<std::map<BoundaryID, RealVectorValue> > MooseMesh::_boundary_to_normal_map

protectedinherited

The boundary to normal map - valid only when AddAllSideSetsByNormals is active.

Definition at line 1001 of file MooseMesh.h.

Referenced by MooseMesh::getNormalByBoundaryID(), and MooseMesh::setBoundaryToNormalMap().

_bounds

std::vector<std::vector<Real> > MooseMesh::_bounds

protectedinherited

The bounds in each dimension of the mesh for regular orthogonal meshes.

Definition at line 1051 of file MooseMesh.h.

Referenced by MooseMesh::detectOrthogonalDimRanges(), MooseMesh::getMaxInDimension(), MooseMesh::getMinInDimension(), and MooseMesh::MooseMesh().

_build_bnd_elem_list_timer

PerfID MooseMesh::_build_bnd_elem_list_timer

privateinherited

Definition at line 1182 of file MooseMesh.h.

Referenced by MooseMesh::buildBndElemList().

_build_coarsening_map_timer

PerfID MooseMesh::_build_coarsening_map_timer

privateinherited

Definition at line 1196 of file MooseMesh.h.

Referenced by MooseMesh::buildCoarseningMap().

_build_node_list_timer

PerfID MooseMesh::_build_node_list_timer

privateinherited

Definition at line 1181 of file MooseMesh.h.

Referenced by MooseMesh::buildNodeList().

_build_periodic_node_map_timer

PerfID MooseMesh::_build_periodic_node_map_timer

privateinherited

Definition at line 1191 of file MooseMesh.h.

Referenced by MooseMesh::buildPeriodicNodeMap().

_build_periodic_node_sets_timer

PerfID MooseMesh::_build_periodic_node_sets_timer

privateinherited

Definition at line 1192 of file MooseMesh.h.

Referenced by MooseMesh::buildPeriodicNodeSets().

_build_refinement_and_coarsening_maps_timer

PerfID MooseMesh::_build_refinement_and_coarsening_maps_timer

privateinherited

Definition at line 1198 of file MooseMesh.h.

Referenced by MooseMesh::buildRefinementAndCoarseningMaps().

_build_refinement_map_timer

PerfID MooseMesh::_build_refinement_map_timer

privateinherited

Definition at line 1195 of file MooseMesh.h.

Referenced by MooseMesh::buildRefinementMap().

_cache_changed_lists_timer

PerfID MooseMesh::_cache_changed_lists_timer

privateinherited

Definition at line 1179 of file MooseMesh.h.

Referenced by MooseMesh::cacheChangedLists().

_cache_info_timer

PerfID MooseMesh::_cache_info_timer

privateinherited

Definition at line 1190 of file MooseMesh.h.

Referenced by MooseMesh::cacheInfo().

_change_boundary_id_timer

PerfID MooseMesh::_change_boundary_id_timer

privateinherited

Definition at line 1199 of file MooseMesh.h.

Referenced by MooseMesh::changeBoundaryId().

_coarsened_element_children

std::map<const Elem *, std::vector<const Elem *> > MooseMesh::_coarsened_element_children

protectedinherited

Map of Parent elements to child elements for elements that were just coarsened.

NOTE: the child element pointers ARE PROBABLY INVALID. Only use them for indexing!

Definition at line 957 of file MooseMesh.h.

Referenced by MooseMesh::cacheChangedLists(), and MooseMesh::coarsenedElementChildren().

_coarsened_elements

std::unique_ptr<ConstElemPointerRange> MooseMesh::_coarsened_elements

protectedinherited

The elements that were just coarsened.

Definition at line 950 of file MooseMesh.h.

Referenced by MooseMesh::cacheChangedLists(), and MooseMesh::coarsenedElementRange().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), SimplePredictor::apply(), MultiApp::backup(), FEProblemBase::backupMultiApps(), ReferenceResidualProblem::checkNonlinearConvergence(), FEProblemBase::checkProblemIntegrity(), CoarsenedPiecewiseLinear::CoarsenedPiecewiseLinear(), IterationAdaptiveDT::computeAdaptiveDT(), Transient::computeConstrainedDT(), NonlinearSystemBase::computeDamping(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeResidualTags(), NonlinearSystem::computeScaling(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), Steady::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MultiApp::globalAppToLocal(), InversePowerMethod::init(), NonlinearEigen::init(), Steady::init(), FEProblemBase::initialAdaptMesh(), FEProblemBase::initialSetup(), EigenExecutionerBase::inversePowerIteration(), Transient::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseObject::mooseDeprecated(), MooseObject::mooseInfo(), MooseObject::mooseWarning(), PerfGraphOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), MultiAppConservativeTransfer::postExecute(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), EigenExecutionerBase::printEigenvalue(), MaterialPropertyDebugOutput::printMaterialMap(), AutomaticMortarGeneration::projectMasterNodesSinglePair(), AutomaticMortarGeneration::projectSlaveNodesSinglePair(), SolutionTimeAdaptiveDT::rejectStep(), DT2::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), SimplePredictor::shouldApply(), PicardSolve::solve(), NonlinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), PicardSolve::solveStep(), DT2::step(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), Transient::takeStep(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_construct_node_list_from_side_list

bool MooseMesh::_construct_node_list_from_side_list

privateinherited

Whether or not to allow generation of nodesets from sidesets.

Definition at line 1173 of file MooseMesh.h.

Referenced by MooseMesh::buildNodeListFromSideList().

_custom_partitioner

std::unique_ptr<Partitioner> MooseMesh::_custom_partitioner

protectedinherited

The custom partitioner.

Definition at line 915 of file MooseMesh.h.

Referenced by MooseMesh::init(), and MooseMesh::setCustomPartitioner().

_custom_partitioner_requested

bool MooseMesh::_custom_partitioner_requested

protectedinherited

Definition at line 916 of file MooseMesh.h.

Referenced by MooseMesh::init(), MooseMesh::isCustomPartitionerRequested(), and MooseMesh::setIsCustomPartitionerRequested().

_detect_orthogonal_dim_ranges_timer

PerfID MooseMesh::_detect_orthogonal_dim_ranges_timer

privateinherited

Definition at line 1193 of file MooseMesh.h.

Referenced by MooseMesh::detectOrthogonalDimRanges().

_detect_paired_sidesets_timer

PerfID MooseMesh::_detect_paired_sidesets_timer

privateinherited

Definition at line 1194 of file MooseMesh.h.

Referenced by MooseMesh::detectPairedSidesets().

_dim

const unsigned int FileMesh::_dim

protected

The requested dimension of the mesh.

For some file meshes, this is not required may be implied from the element type(s).

Definition at line 49 of file FileMesh.h.

_distribution_overridden

bool MooseMesh::_distribution_overridden

protectedinherited

Definition at line 904 of file MooseMesh.h.

_elem_to_side_to_qp_to_quadrature_nodes

std::map<dof_id_type, std::map<unsigned int, std::map<dof_id_type, Node *> > > MooseMesh::_elem_to_side_to_qp_to_quadrature_nodes

protectedinherited

Definition at line 1020 of file MooseMesh.h.

Referenced by MooseMesh::addQuadratureNode(), MooseMesh::clearQuadratureNodes(), and MooseMesh::getQuadratureNode().

_elem_type_to_child_side_refinement_map

std::map<ElemType, std::map<std::pair<int, int>, std::vector<std::vector<QpMap> > > > MooseMesh::_elem_type_to_child_side_refinement_map

privateinherited

Holds mappings for "internal" child sides to parent volume. The second key is (child, child_side).

Definition at line 1160 of file MooseMesh.h.

Referenced by MooseMesh::buildRefinementMap(), and MooseMesh::getRefinementMap().

_elem_type_to_coarsening_map

std::map<std::pair<int, ElemType>, std::vector<std::pair<unsigned int, QpMap> > > MooseMesh::_elem_type_to_coarsening_map

privateinherited

Holds mappings for volume to volume and parent side to child side.

Definition at line 1164 of file MooseMesh.h.

Referenced by MooseMesh::buildCoarseningMap(), and MooseMesh::getCoarseningMap().

_elem_type_to_refinement_map

std::map<std::pair<int, ElemType>, std::vector<std::vector<QpMap> > > MooseMesh::_elem_type_to_refinement_map

privateinherited

Holds mappings for volume to volume and parent side to child side.

Definition at line 1156 of file MooseMesh.h.

Referenced by MooseMesh::buildRefinementMap(), and MooseMesh::getRefinementMap().

_enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 181 of file MooseObject.h.

Referenced by MooseObject::enabled().

_exreader

std::unique_ptr<ExodusII_IO> FileMesh::_exreader

protected

Auxiliary object for restart.

Definition at line 45 of file FileMesh.h.

Referenced by buildMesh(), and exReader().

_extra_bnd_nodes

std::vector<BndNode> MooseMesh::_extra_bnd_nodes

protectedinherited

Definition at line 1021 of file MooseMesh.h.

Referenced by MooseMesh::addQuadratureNode(), MooseMesh::buildNodeList(), and MooseMesh::clearQuadratureNodes().

_extreme_nodes

std::vector<Node *> MooseMesh::_extreme_nodes

privateinherited

A vector containing the nodes at the corners of a regular orthogonal mesh.

Definition at line 1074 of file MooseMesh.h.

Referenced by MooseMesh::detectOrthogonalDimRanges().

_file_name

std::string FileMesh::_file_name

protected

the file_name from whence this mesh came

Definition at line 42 of file FileMesh.h.

Referenced by buildMesh(), getFileName(), and setFileName().

_find_adaptivity_qp_maps_timer

PerfID MooseMesh::_find_adaptivity_qp_maps_timer

privateinherited

Definition at line 1197 of file MooseMesh.h.

Referenced by MooseMesh::findAdaptivityQpMaps().

_get_active_local_element_range_timer

PerfID MooseMesh::_get_active_local_element_range_timer

privateinherited

Definition at line 1185 of file MooseMesh.h.

Referenced by MooseMesh::getActiveLocalElementRange().

_get_active_node_range_timer

PerfID MooseMesh::_get_active_node_range_timer

privateinherited

Definition at line 1186 of file MooseMesh.h.

Referenced by MooseMesh::getActiveNodeRange().

_get_boundary_element_range_timer

PerfID MooseMesh::_get_boundary_element_range_timer

privateinherited

Definition at line 1189 of file MooseMesh.h.

Referenced by MooseMesh::getBoundaryElementRange().

_get_boundary_node_range_timer

PerfID MooseMesh::_get_boundary_node_range_timer

privateinherited

Definition at line 1188 of file MooseMesh.h.

Referenced by MooseMesh::getBoundaryNodeRange().

_get_local_node_range_timer

PerfID MooseMesh::_get_local_node_range_timer

privateinherited

Definition at line 1187 of file MooseMesh.h.

Referenced by MooseMesh::getLocalNodeRange().

_ghost_elems_from_ghost_boundaries

std::set<Elem *> MooseMesh::_ghost_elems_from_ghost_boundaries

privateinherited

Set of elements ghosted by ghostGhostedBoundaries.

Definition at line 1208 of file MooseMesh.h.

Referenced by MooseMesh::ghostGhostedBoundaries().

_ghost_ghosted_boundaries_timer

PerfID MooseMesh::_ghost_ghosted_boundaries_timer

privateinherited

Definition at line 1202 of file MooseMesh.h.

Referenced by MooseMesh::ghostGhostedBoundaries().

_ghosted_boundaries

std::set<unsigned int> MooseMesh::_ghosted_boundaries

protectedinherited

Definition at line 1029 of file MooseMesh.h.

Referenced by MooseMesh::addGhostedBoundary(), MooseMesh::getGhostedBoundaries(), and MooseMesh::ghostGhostedBoundaries().

_ghosted_boundaries_inflation

std::vector<Real> MooseMesh::_ghosted_boundaries_inflation

protectedinherited

Definition at line 1030 of file MooseMesh.h.

Referenced by MooseMesh::getGhostedBoundaryInflation(), and MooseMesh::setGhostedBoundaryInflation().

_ghosting_functors

std::vector<std::unique_ptr<GhostingFunctor> > MooseMesh::_ghosting_functors

protectedinherited

Deprecated (DO NOT USE)

Definition at line 891 of file MooseMesh.h.

_ghosting_patch_size

unsigned int MooseMesh::_ghosting_patch_size

protectedinherited

The number of nearest neighbors to consider for ghosting purposes when iteration patch update strategy is used.

Definition at line 1036 of file MooseMesh.h.

Referenced by MooseMesh::getGhostingPatchSize().

_half_range

RealVectorValue MooseMesh::_half_range

privateinherited

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

Definition at line 1071 of file MooseMesh.h.

Referenced by MooseMesh::addPeriodicVariable(), and MooseMesh::minPeriodicVector().

_init_timer

PerfID MooseMesh::_init_timer

privateinherited

Definition at line 1200 of file MooseMesh.h.

Referenced by MooseMesh::init().

_is_changed

bool MooseMesh::_is_changed

protectedinherited

true if mesh is changed (i.e. after adaptivity step)

Definition at line 935 of file MooseMesh.h.

_is_nemesis

bool MooseMesh::_is_nemesis

protectedinherited

True if a Nemesis Mesh was read in.

Definition at line 938 of file MooseMesh.h.

Referenced by buildMesh(), MooseMesh::buildMeshBaseObject(), MooseMesh::prepare(), and read().

_is_prepared

bool MooseMesh::_is_prepared

protectedinherited

True if prepare has been called on the mesh.

Definition at line 941 of file MooseMesh.h.

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

_local_node_range

std::unique_ptr<ConstNodeRange> MooseMesh::_local_node_range

protectedinherited

Definition at line 970 of file MooseMesh.h.

Referenced by MooseMesh::getLocalNodeRange(), and MooseMesh::meshChanged().

_max_leaf_size

unsigned int MooseMesh::_max_leaf_size

protectedinherited

Definition at line 1039 of file MooseMesh.h.

Referenced by MooseMesh::getMaxLeafSize().

_mesh

std::unique_ptr<libMesh::MeshBase> MooseMesh::_mesh

protectedinherited

Pointer to underlying libMesh mesh object.

Definition at line 908 of file MooseMesh.h.

Referenced by MeshGeneratorMesh::buildMesh(), MooseMesh::buildPeriodicNodeMap(), MooseMesh::getMaxInDimension(), MooseMesh::getMesh(), MooseMesh::getMinInDimension(), MooseMesh::hasMeshBase(), MooseMesh::init(), MooseMesh::prepare(), and MooseMesh::setMeshBase().

_mesh_boundary_ids

std::set<BoundaryID> MooseMesh::_mesh_boundary_ids

protectedinherited

A set of boundary IDs currently present in the mesh.

In serial, this is equivalent to the values returned by _mesh.get_boundary_info().get_boundary_ids(). In parallel, it will contain off-processor boundary IDs as well.

Definition at line 995 of file MooseMesh.h.

Referenced by MooseMesh::getBoundaryIDs(), MooseMesh::meshBoundaryIds(), MooseMesh::prepare(), and MooseMesh::setMeshBoundaryIDs().

_mesh_changed_timer

PerfID MooseMesh::_mesh_changed_timer

privateinherited

Definition at line 1178 of file MooseMesh.h.

Referenced by MooseMesh::meshChanged().

_mesh_nodeset_ids

std::set<BoundaryID> MooseMesh::_mesh_nodeset_ids

protectedinherited

Definition at line 997 of file MooseMesh.h.

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

_mesh_sideset_ids

std::set<BoundaryID> MooseMesh::_mesh_sideset_ids

protectedinherited

Definition at line 996 of file MooseMesh.h.

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

_mesh_subdomains

std::set<SubdomainID> MooseMesh::_mesh_subdomains

protectedinherited

A set of subdomain IDs currently present in the mesh.

For parallel meshes, includes subdomains defined on other processors as well.

Definition at line 987 of file MooseMesh.h.

Referenced by MooseMesh::getSubdomainIDs(), MooseMesh::meshSubdomains(), and MooseMesh::prepare().

_name

const std::string& MooseObject::_name

protectedinherited

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

Definition at line 178 of file MooseObject.h.

Referenced by ADPiecewiseLinearInterpolationMaterial< compute_stage >::ADPiecewiseLinearInterpolationMaterial(), PiecewiseBase::buildFromFile(), PiecewiseBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), MooseObject::name(), PiecewiseBilinear::parse(), PiecewiseBase::PiecewiseBase(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), DerivativeParsedMaterialHelper::recurseDerivative(), PiecewiseBase::setData(), Split::setup(), and VectorPostprocessorFunction::VectorPostprocessorFunction().

_need_delete

bool MooseMesh::_need_delete

privateinherited

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

Definition at line 1205 of file MooseMesh.h.

Referenced by MooseMesh::needsRemoteElemDeletion().

_needs_prepare_for_use

bool MooseMesh::_needs_prepare_for_use

protectedinherited

True if prepare_for_use should be called when Mesh is prepared.

Definition at line 944 of file MooseMesh.h.

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

_node_map

std::vector<Node *> MooseMesh::_node_map

protectedinherited

Vector of all the Nodes in the mesh for determining when to add a new point.

Definition at line 1045 of file MooseMesh.h.

Referenced by MooseMesh::addUniqueNode().

_node_set_nodes

std::map<boundary_id_type, std::vector<dof_id_type> > MooseMesh::_node_set_nodes

protectedinherited

list of nodes that belongs to a specified nodeset: indexing [nodeset_id] -> [array of node ids]

Definition at line 1027 of file MooseMesh.h.

Referenced by MooseMesh::buildNodeList(), MooseMesh::freeBndNodes(), and MooseMesh::getNodeList().

_node_to_active_semilocal_elem_map

std::map<dof_id_type, std::vector<dof_id_type> > MooseMesh::_node_to_active_semilocal_elem_map

protectedinherited

A map of all of the current nodes to the active elements that they are connected to.

Definition at line 980 of file MooseMesh.h.

Referenced by MooseMesh::addQuadratureNode(), MooseMesh::nodeToActiveSemilocalElemMap(), and MooseMesh::update().

_node_to_active_semilocal_elem_map_built

bool MooseMesh::_node_to_active_semilocal_elem_map_built

protectedinherited

Definition at line 981 of file MooseMesh.h.

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

_node_to_active_semilocal_elem_map_timer

PerfID MooseMesh::_node_to_active_semilocal_elem_map_timer

privateinherited

Definition at line 1184 of file MooseMesh.h.

Referenced by MooseMesh::nodeToActiveSemilocalElemMap().

_node_to_elem_map

std::map<dof_id_type, std::vector<dof_id_type> > MooseMesh::_node_to_elem_map

protectedinherited

A map of all of the current nodes to the elements that they are connected to.

Definition at line 976 of file MooseMesh.h.

Referenced by MooseMesh::addQuadratureNode(), MooseMesh::nodeToElemMap(), and MooseMesh::update().

_node_to_elem_map_built

bool MooseMesh::_node_to_elem_map_built

protectedinherited

Definition at line 977 of file MooseMesh.h.

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

_node_to_elem_map_timer

PerfID MooseMesh::_node_to_elem_map_timer

privateinherited

Definition at line 1183 of file MooseMesh.h.

Referenced by MooseMesh::nodeToElemMap().

_paired_boundary

std::vector<std::pair<BoundaryID, BoundaryID> > MooseMesh::_paired_boundary

protectedinherited

A vector holding the paired boundaries for a regular orthogonal mesh.

Definition at line 1054 of file MooseMesh.h.

Referenced by MooseMesh::detectPairedSidesets(), and MooseMesh::getPairedBoundaryMapping().

_parallel_type

ParallelType MooseMesh::_parallel_type

protectedinherited

Can be set to DISTRIBUTED, REPLICATED, or DEFAULT.

Determines whether the underlying libMesh mesh is a ReplicatedMesh or DistributedMesh.

Definition at line 898 of file MooseMesh.h.

Referenced by MooseMesh::buildMeshBaseObject().

_parallel_type_overridden

bool MooseMesh::_parallel_type_overridden

protectedinherited

Definition at line 905 of file MooseMesh.h.

Referenced by MooseMesh::buildMeshBaseObject(), and MooseMesh::isParallelTypeForced().

_pars

const InputParameters& MooseObject::_pars

protectedinherited

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

Definition at line 169 of file MooseObject.h.

Referenced by GridPartitioner::_do_partition(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PNGOutput::calculateRescalingValues(), BreakMeshByBlockBase::checkInputParameter(), RandomPartitioner::clone(), PetscExternalPartitioner::clone(), BlockWeightedPartitioner::clone(), GridPartitioner::clone(), Console::Console(), Eigenvalue::execute(), Executioner::Executioner(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase::FunctionMaterialBase(), ParsedMaterialHelper::functionParse(), ExtraNodesetGenerator::generate(), MooseObject::getParamTempl(), GeneralUserObject::getPostprocessorValue(), InitialConditionBase::getUserObjectBase(), InitialConditionBase::getUserObjectTempl(), GeneralUserObject::getVectorPostprocessorValue(), Transient::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseObject::isParamValid(), AddExtraNodeset::modify(), MooseObject::paramErrorMsg(), MooseObject::parameters(), MooseMesh::setPartitionerHelper(), and Transient::setupTimeIntegrator().

_partitioner_name

MooseEnum MooseMesh::_partitioner_name

protectedinherited

The partitioner used on this mesh.

Definition at line 911 of file MooseMesh.h.

Referenced by MooseMesh::buildMeshBaseObject(), MooseMesh::partitionerName(), and MooseMesh::setPartitionerHelper().

_partitioner_overridden

bool MooseMesh::_partitioner_overridden

protectedinherited

Definition at line 912 of file MooseMesh.h.

Referenced by MooseMesh::buildMeshBaseObject(), and MooseMesh::isPartitionerForced().

_patch_size

unsigned int MooseMesh::_patch_size

protectedinherited

The number of nodes to consider in the NearestNode neighborhood.

Definition at line 1033 of file MooseMesh.h.

Referenced by MooseMesh::getPatchSize().

_patch_update_strategy

Moose::PatchUpdateType MooseMesh::_patch_update_strategy

protectedinherited

The patch update strategy.

Definition at line 1042 of file MooseMesh.h.

Referenced by MooseMesh::getPatchUpdateStrategy(), MooseMesh::MooseMesh(), and MooseMesh::setPatchUpdateStrategy().

_perf_graph

PerfGraph& PerfGraphInterface::_perf_graph

protectedinherited

The performance graph to add to.

Definition at line 67 of file PerfGraphInterface.h.

Referenced by PerfGraphData::getValue(), and PerfGraphInterface::registerTimedSection().

_periodic_dim

std::map<unsigned int, std::vector<bool> > MooseMesh::_periodic_dim

privateinherited

A map of vectors indicating which dimensions are periodic in a regular orthogonal mesh for the specified variable numbers.

This data structure is populated by addPeriodicVariable.

Definition at line 1066 of file MooseMesh.h.

Referenced by MooseMesh::addPeriodicVariable(), and MooseMesh::isTranslatedPeriodic().

_pg_params

const InputParameters* PerfGraphInterface::_pg_params

protectedinherited

Params.

Definition at line 64 of file PerfGraphInterface.h.

_prefix

std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 70 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::registerTimedSection().

_prepare_timer

PerfID MooseMesh::_prepare_timer

privateinherited

Timers.

Definition at line 1176 of file MooseMesh.h.

Referenced by MooseMesh::prepare().

_quadrature_nodes

std::map<dof_id_type, Node *> MooseMesh::_quadrature_nodes

protectedinherited

Definition at line 1018 of file MooseMesh.h.

Referenced by MooseMesh::addQuadratureNode(), MooseMesh::clearQuadratureNodes(), MooseMesh::nodePtr(), MooseMesh::nodeRef(), and MooseMesh::queryNodePtr().

_read_mesh_timer

const PerfID FileMesh::_read_mesh_timer

protected

Timers.

Definition at line 52 of file FileMesh.h.

Referenced by buildMesh().

_read_recovered_mesh_timer

PerfID MooseMesh::_read_recovered_mesh_timer

privateinherited

Definition at line 1201 of file MooseMesh.h.

Referenced by MooseMesh::init().

_refined_elements

std::unique_ptr<ConstElemPointerRange> MooseMesh::_refined_elements

protectedinherited

The elements that were just refined.

Definition at line 947 of file MooseMesh.h.

Referenced by MooseMesh::cacheChangedLists(), and MooseMesh::refinedElementRange().

_regular_orthogonal_mesh

bool MooseMesh::_regular_orthogonal_mesh

protectedinherited

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

Definition at line 1048 of file MooseMesh.h.

Referenced by MooseMesh::addPeriodicVariable(), MooseMesh::detectOrthogonalDimRanges(), DistributedGeneratedMesh::DistributedGeneratedMesh(), GeneratedMesh::GeneratedMesh(), MooseMesh::getPairedBoundaryMapping(), MooseMesh::isRegularOrthogonal(), and MooseMesh::prepared().

_relationship_managers

std::vector<std::shared_ptr<RelationshipManager> > MooseMesh::_relationship_managers

protectedinherited

The list of active geometric relationship managers (bound to the underlying MeshBase object).

Definition at line 894 of file MooseMesh.h.

_restartable_app

MooseApp& Restartable::_restartable_app

privateinherited

Reference to the application.

Definition at line 208 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

_restartable_name

std::string Restartable::_restartable_name

privateinherited

The name of the object.

Definition at line 211 of file Restartable.h.

Referenced by Restartable::declareRecoverableData(), Restartable::declareRestartableDataWithContext(), and Restartable::declareRestartableDataWithObjectNameWithContext().

_restartable_system_name

std::string Restartable::_restartable_system_name

privateinherited

The system name this object is in.

Definition at line 214 of file Restartable.h.

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataWithContext().

_restartable_tid

THREAD_ID Restartable::_restartable_tid

privateinherited

The thread ID for this object.

Definition at line 217 of file Restartable.h.

Referenced by Restartable::declareRestartableDataWithContext().

_semilocal_node_list

std::set<Node *> MooseMesh::_semilocal_node_list

protectedinherited

Used for generating the semilocal node range.

Definition at line 960 of file MooseMesh.h.

Referenced by MooseMesh::isSemiLocal(), and MooseMesh::updateActiveSemiLocalNodeRange().

_subdomain_boundary_ids

std::map<SubdomainID, std::set<BoundaryID> > MooseMesh::_subdomain_boundary_ids

privateinherited

Holds a map from subomdain ids to the boundary ids that are attached to it.

Definition at line 1167 of file MooseMesh.h.

Referenced by MooseMesh::cacheInfo(), and MooseMesh::getSubdomainBoundaryIds().

_type

const std::string& MooseObject::_type

protectedinherited

The type of this object (the Class name)

Definition at line 175 of file MooseObject.h.

Referenced by FEProblemBase::init(), and MooseObject::type().

_uniform_refine_level

unsigned int MooseMesh::_uniform_refine_level

protectedinherited

The level of uniform refinement requested (set to zero if AMR is disabled)

Definition at line 932 of file MooseMesh.h.

Referenced by MooseMesh::setUniformRefineLevel(), and MooseMesh::uniformRefineLevel().

_update_active_semi_local_node_range_timer

PerfID MooseMesh::_update_active_semi_local_node_range_timer

privateinherited

Definition at line 1180 of file MooseMesh.h.

Referenced by MooseMesh::updateActiveSemiLocalNodeRange().

_update_timer

PerfID MooseMesh::_update_timer

privateinherited

Definition at line 1177 of file MooseMesh.h.

Referenced by MooseMesh::update().

_use_distributed_mesh

bool MooseMesh::_use_distributed_mesh

protectedinherited

False by default.

Final value is determined by several factors including the 'distribution' setting in the input file, and whether or not the Mesh file is a Nemesis file.

Definition at line 903 of file MooseMesh.h.

Referenced by MooseMesh::buildMeshBaseObject(), MooseMesh::errorIfDistributedMesh(), MooseMesh::ghostGhostedBoundaries(), MooseMesh::init(), MooseMesh::isDistributedMesh(), and MooseMesh::setPartitionerHelper().

---

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

• include/mesh/FileMesh.h
• src/mesh/FileMesh.C