MooseMesh Class Reference

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

#include <MooseMesh.h>

Inheritance diagram for MooseMesh:

Classes
struct	bnd_elem_iterator
	The definition of the bnd_elem_iterator struct. More...
struct	bnd_node_iterator
	The definition of the bnd_node_iterator struct. More...
struct	const_bnd_elem_iterator
	The definition of the const_bnd_elem_iterator struct. More...
struct	const_bnd_node_iterator
	The definition of the const_bnd_node_iterator struct. More...
struct	const_elem_info_iterator
	The definition of the const_elem_info_iterator struct. More...
struct	const_face_info_iterator
	The definition of the const_face_info_iterator struct. More...
struct	elem_info_iterator
	The definition of the elem_info_iterator struct. More...
struct	face_info_iterator
	The definition of the face_info_iterator struct. More...
struct	MeshType
struct	MeshType< libMesh::DistributedMesh >
struct	MeshType< libMesh::ReplicatedMesh >
struct	SubdomainData

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...
using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name. More...

Public Member Functions
	MooseMesh (const InputParameters &parameters)
	MooseMesh (const MooseMesh &other_mesh)
	MooseMesh ()=delete
MooseMesh &	operator= (const MooseMesh &other_mesh)=delete
virtual	~MooseMesh ()
virtual MooseMesh &	clone () const
	Clone method. More...
virtual std::unique_ptr< MooseMesh >	safeClone () const =0
	A safer version of the clone() method that hands back an allocated object wrapped in a smart pointer. More...
void	determineUseDistributedMesh ()
	Determine whether to use a distributed mesh. More...
std::unique_ptr< MeshBase >	buildMeshBaseObject (unsigned int dim=libMesh::invalid_uint)
	Method to construct a libMesh::MeshBase object that is normally set and used by the MooseMesh object during the "init()" phase. More...
template<typename T >
std::unique_ptr< T >	buildTypedMesh (unsigned int dim=libMesh::invalid_uint)
	Shortcut method to construct a unique pointer to a libMesh mesh instance. More...
void	setMeshBase (std::unique_ptr< MeshBase > mesh_base)
	Method to set the mesh_base object. More...
virtual void	init ()
	Initialize the Mesh object. More...
virtual void	buildMesh ()=0
	Must be overridden by child classes. More...
virtual unsigned int	dimension () const
	Returns MeshBase::mesh_dimension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh mesh object. More...
virtual unsigned int	spatialDimension () const
	Returns MeshBase::spatial_dimension. More...
virtual unsigned int	effectiveSpatialDimension () const
	Returns the effective spatial dimension determined by the coordinates actually used by the mesh. More...
unsigned int	getBlocksMaxDimension (const std::vector< SubdomainName > &blocks) const
	Returns the maximum element dimension on the given blocks. 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 Elem *	getLowerDElem (const Elem *, unsigned short int) const
	Returns a const pointer to a lower dimensional element that corresponds to a side of a higher dimensional element. More...
unsigned int	getHigherDSide (const Elem *elem) const
	Returns the local side ID of the interior parent aligned with the lower dimensional element. More...
const std::set< BoundaryID > &	getBoundaryIDs () const
	Returns a const reference to a set of all user-specified boundary IDs. More...
void	buildNodeList ()
	Calls BoundaryInfo::build_node_list()/build_side_list() and makes separate copies of Nodes/Elems in those lists. More...
void	buildBndElemList ()
const std::map< dof_id_type, std::vector< dof_id_type > > &	nodeToElemMap ()
	If not already created, creates a map from every node to all elements to which they are connected. More...
const std::map< dof_id_type, std::vector< dof_id_type > > &	nodeToActiveSemilocalElemMap ()
	If not already created, creates a map from every node to all active semilocal elements to which they are connected. More...
virtual bnd_node_iterator	bndNodesBegin ()
	Return iterators to the beginning/end of the boundary nodes list. More...
virtual bnd_node_iterator	bndNodesEnd ()
virtual bnd_elem_iterator	bndElemsBegin ()
	Return iterators to the beginning/end of the boundary elements list. More...
virtual bnd_elem_iterator	bndElemsEnd ()
void	buildNodeListFromSideList ()
	Calls BoundaryInfo::build_node_list_from_side_list(). More...
std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	buildSideList ()
	Calls BoundaryInfo::build_side_list(), returns a std::vector of (elem-id, side-id, bc-id) tuples. More...
std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	buildActiveSideList () const
	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::node_iterator	localNodesBegin ()
	Calls local_nodes_begin/end() on the underlying libMesh mesh object. More...
MeshBase::node_iterator	localNodesEnd ()
MeshBase::const_node_iterator	localNodesBegin () const
MeshBase::const_node_iterator	localNodesEnd () const
MeshBase::element_iterator	activeLocalElementsBegin ()
	Calls active_local_nodes_begin/end() on the underlying libMesh mesh object. More...
const MeshBase::element_iterator	activeLocalElementsEnd ()
MeshBase::const_element_iterator	activeLocalElementsBegin () const
const MeshBase::const_element_iterator	activeLocalElementsEnd () const
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	nLocalNodes () const
virtual dof_id_type	nActiveElem () const
virtual dof_id_type	nActiveLocalElem () const
virtual SubdomainID	nSubdomains () const
virtual unsigned int	nPartitions () const
virtual bool	skipPartitioning () const
virtual bool	skipNoncriticalPartitioning () 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 whether the mesh is prepared. 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 ids of elements on the boundary. More...
const std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > &	getBoundariesToActiveSemiLocalElemIds () const
	Returns a map of boundaries to ids of elements on the boundary. More...
std::unordered_set< dof_id_type >	getBoundaryActiveSemiLocalElemIds (BoundaryID bid) const
	Return all ids of elements which have a side which is part of a sideset. More...
std::unordered_set< dof_id_type >	getBoundaryActiveNeighborElemIds (BoundaryID bid) const
	Return all ids of neighbors of elements which have a side which is part of a sideset. More...
bool	isBoundaryFullyExternalToSubdomains (BoundaryID bid, const std::set< SubdomainID > &blk_group) const
	Returns whether a boundary (given by its id) is not crossing through a group of blocks, by which we mean that elements on both sides of the boundary are in those blocks. 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...
bool	prepare (const MeshBase *mesh_to_clone)
	Calls prepare_for_use() if the underlying MeshBase object isn't prepared, 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, bool deletion=true)
	Set uniform refinement level. More...
bool	skipDeletionRepartitionAfterRefine () const
	Return a flag indicating whether or not we should skip remote deletion and repartition after uniform refinements. More...
bool	skipRefineWhenUseSplit () const
	Whether or not skip uniform refinements when using a pre-split mesh. 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...
void	needGhostGhostedBoundaries (bool needghost)
	Whether or not we want to ghost ghosted boundaries. 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...
libMesh::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...
MeshBase &	getMesh (const std::string &name)
const MeshBase &	getMesh () const
const MeshBase &	getMesh (const std::string &name) const
const MeshBase *	getMeshPtr () const
const Moose::Kokkos::Mesh *	getKokkosMesh () const
	Accessor for Kokkos mesh object. More...
void	printInfo (std::ostream &os=libMesh::out, const unsigned int verbosity=0) const
	Calls print_info() on the underlying Mesh. More...
const std::set< SubdomainID > &	getNodeBlockIds (const Node &node) const
	Return list of blocks to which the given node belongs. More...
const std::vector< dof_id_type > &	getNodeList (boundary_id_type nodeset_id) const
	Return a writable reference to a vector of node IDs that belong to nodeset_id. More...
const Node *	addUniqueNode (const Point &p, Real tol=1e-6)
	Add a new node to the mesh. More...
Node *	addQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp, BoundaryID bid, const Point &point)
	Adds a fictitious "QuadratureNode". More...
Node *	getQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp)
	Get a specified quadrature node. More...
void	clearQuadratureNodes ()
	Clear out any existing quadrature nodes. More...
BoundaryID	getBoundaryID (const BoundaryName &boundary_name) const
	Get the associated BoundaryID for the boundary name. More...
std::vector< BoundaryID >	getBoundaryIDs (const std::vector< BoundaryName > &boundary_name, bool generate_unknown=false) const
	Get the associated BoundaryID for the boundary names that are passed in. More...
SubdomainID	getSubdomainID (const SubdomainName &subdomain_name) const
	Get the associated subdomain ID for the subdomain name. More...
std::vector< SubdomainID >	getSubdomainIDs (const std::vector< SubdomainName > &subdomain_names) const
	Get the associated subdomainIDs for the subdomain names that are passed in. More...
std::set< SubdomainID >	getSubdomainIDs (const std::set< SubdomainName > &subdomain_names) const
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) const
	Return the name of a block given an id. More...
std::vector< SubdomainName >	getSubdomainNames (const std::vector< SubdomainID > &subdomain_ids) const
	Get the associated subdomainNames for the subdomain ids that are passed in. More...
void	setBoundaryName (BoundaryID boundary_id, BoundaryName name)
	This method sets the boundary name of the boundary based on the id parameter. More...
const std::string &	getBoundaryName (BoundaryID boundary_id) const
	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, libMesh::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, libMesh::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 (const SubdomainID subdomain_id) const
	Get the list of boundary ids associated with the given subdomain id. More...
std::set< BoundaryID >	getSubdomainInterfaceBoundaryIds (const SubdomainID subdomain_id) const
	Get the list of boundaries that contact the given subdomain. More...
std::set< SubdomainID >	getBoundaryConnectedBlocks (const BoundaryID bid) const
	Get the list of subdomains associated with the given boundary. More...
std::set< SubdomainID >	getBoundaryConnectedSecondaryBlocks (const BoundaryID bid) const
	Get the list of subdomains associated with the given boundary of its secondary side. More...
std::set< SubdomainID >	getInterfaceConnectedBlocks (const BoundaryID bid) const
	Get the list of subdomains contacting the given boundary. More...
const std::set< SubdomainID > &	getBlockConnectedBlocks (const SubdomainID subdomain_id) const
	Get the list of subdomains neighboring a given subdomain. 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...
virtual 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...
void	setParallelType (ParallelType parallel_type)
	Allow to change parallel type. More...
ParallelType	getParallelType () const
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 (libMesh::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< libMesh::PointLocatorBase >	getPointLocator () const
	Proxy function to get a (sub)PointLocator from either the underlying libMesh mesh (default), or to allow derived meshes to return a custom point locator. More...
virtual std::string	getFileName () const
	Returns the name of the mesh file read to produce this mesh if any or an empty string otherwise. More...
void	needsRemoteElemDeletion (bool need_delete)
	Set whether we need to delete remote elements. More...
bool	needsRemoteElemDeletion () const
	Whether we need to delete remote elements. More...
void	allowRemoteElementRemoval (bool allow_removal)
	Set whether to allow remote element removal. More...
bool	allowRemoteElementRemoval () const
	Whether we are allow remote element removal. More...
void	deleteRemoteElements ()
	Delete remote elements. More...
bool	hasMeshBase () const
	Whether mesh base object was constructed or not. More...
bool	hasElementID (const std::string &id_name) const
	Whether mesh has an extra element integer with a given name. More...
unsigned int	getElementIDIndex (const std::string &id_name) const
	Return the accessing integer for an extra element integer with its name. More...
dof_id_type	maxElementID (unsigned int elem_id_index) const
	Return the maximum element ID for an extra element integer with its accessing index. More...
dof_id_type	minElementID (unsigned int elem_id_index) const
	Return the minimum element ID for an extra element integer with its accessing index. More...
bool	areElemIDsIdentical (const std::string &id_name1, const std::string &id_name2) const
	Whether or not two extra element integers are identical. More...
std::set< dof_id_type >	getAllElemIDs (unsigned int elem_id_index) const
	Return all the unique element IDs for an extra element integer with its index. More...
std::set< dof_id_type >	getElemIDsOnBlocks (unsigned int elem_id_index, const std::set< SubdomainID > &blks) const
	Return all the unique element IDs for an extra element integer with its index on a set of subdomains. More...
unsigned int	getMaxSidesPerElem () const
	Get the maximum number of sides per element. More...
unsigned int	getMaxNodesPerElem () const
	Get the maximum number of nodes per element. More...
unsigned int	getMaxNodesPerSide () const
	Get the maximum number of nodes per side. More...
std::unordered_map< dof_id_type, std::set< dof_id_type > >	getElemIDMapping (const std::string &from_id_name, const std::string &to_id_name) const
void	cacheFaceInfoVariableOwnership () const
	Cache if variables live on the elements connected by the FaceInfo objects. More...
void	cacheFVElementalDoFs () const
	Cache the DoF indices for FV variables on each element. More...
void	computeFiniteVolumeCoords () const
	Compute the face coordinate value for all FaceInfo and ElemInfo objects. More...
void	isDisplaced (bool is_displaced)
	Set whether this mesh is a displaced mesh. More...
bool	isDisplaced () const
	whether this mesh is a displaced mesh More...
const std::map< boundary_id_type, std::vector< dof_id_type > > &	nodeSetNodes () const
Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) const
	Get the coordinate system type, e.g. More...
Moose::CoordinateSystemType	getUniqueCoordSystem () const
	Get the coordinate system from the mesh, it must be the same in all subdomains otherwise this will error. More...
const std::map< SubdomainID, Moose::CoordinateSystemType > &	getCoordSystem () const
	Get the map from subdomain ID to coordinate system type, e.g. More...
void	setCoordSystem (const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
	Set the coordinate system for the provided blocks to coord_sys. More...
void	setAxisymmetricCoordAxis (const MooseEnum &rz_coord_axis)
	For axisymmetric simulations, set the symmetry coordinate axis. More...
void	setGeneralAxisymmetricCoordAxes (const std::vector< SubdomainName > &blocks, const std::vector< std::pair< Point, RealVectorValue >> &axes)
	Sets the general coordinate axes for axisymmetric blocks. More...
const std::pair< Point, RealVectorValue > &	getGeneralAxisymmetricCoordAxis (SubdomainID subdomain_id) const
	Gets the general axisymmetric coordinate axis for a block. More...
bool	usingGeneralAxisymmetricCoordAxes () const
	Returns true if general axisymmetric coordinate axes are being used. More...
unsigned int	getAxisymmetricRadialCoord () const
	Returns the desired radial direction for RZ coordinate transformation. More...
void	checkCoordinateSystems ()
	Performs a sanity check for every element in the mesh. More...
void	setCoordData (const MooseMesh &other_mesh)
	Set the coordinate system data to that of other_mesh. More...
void	markFiniteVolumeInfoDirty ()
	Mark the finite volume information as dirty. More...
bool	isFiniteVolumeInfoDirty () const
MooseAppCoordTransform &	coordTransform ()
const MooseUnits &	lengthUnit () const
const std::unordered_map< std::pair< const Elem *, unsigned short int >, const Elem * > &	getLowerDElemMap () const
	This function attempts to return the map from a high-order element side to its corresponding lower-d element. More...
bool	isSplit () const
void	buildFiniteVolumeInfo () const
	Builds the face and elem info vectors that store meta-data needed for looping over and doing calculations based on mesh faces and elements in a finite volume setting. More...
void	setupFiniteVolumeMeshData () const
	Sets up the additional data needed for finite volume computations. More...
void	doingPRefinement (bool doing_p_refinement)
	Indicate whether the kind of adaptivity we're doing is p-refinement. More...
bool	doingPRefinement () const
	Query whether we have p-refinement. More...
unsigned int	maxPLevel () const
	Returns the maximum p-refinement level of all elements. More...
unsigned int	maxHLevel () const
	Returns the maximum h-refinement level of all elements. More...
const std::vector< QpMap > &	getPRefinementMap (const Elem &elem) const
	Get the map describing for each volumetric quadrature point (qp) on the refined level which qp on the previous coarser level the fine qp is closest to. More...
const std::vector< QpMap > &	getPRefinementSideMap (const Elem &elem) const
	Get the map describing for each side quadrature point (qp) on the refined level which qp on the previous coarser level the fine qp is closest to. More...
const std::vector< QpMap > &	getPCoarseningMap (const Elem &elem) const
	Get the map describing for each volumetric quadrature point (qp) on the coarse level which qp on the previous finer level the coarse qp is closest to. More...
const std::vector< QpMap > &	getPCoarseningSideMap (const Elem &elem) const
	Get the map describing for each side quadrature point (qp) on the coarse level which qp on the previous finer level the coarse qp is closest to. More...
void	buildPRefinementAndCoarseningMaps (Assembly *assembly)
bool	isLowerD (const SubdomainID subdomain_id) const
bool	hasLowerD () const
const std::set< SubdomainID > &	interiorLowerDBlocks () const
const std::set< SubdomainID > &	boundaryLowerDBlocks () const
bool	getConstructNodeListFromSideList ()
	Return construct node list from side list boolean. More...
bool	getDisplaceNodeListBySideList ()
	Return displace node list by side list boolean. More...
virtual bool	enabled () const
	Return the enabled status of the object. More...
std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group. More...
std::shared_ptr< const MooseObject >	getSharedPtr () const
bool	isKokkosObject () const
	Get whether this object is a Kokkos functor The parameter is set by the Kokkos base classes: More...
MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with. More...
const std::string &	type () const
	Get the type of this class. More...
const std::string &	name () const
	Get the name of the class. More...
std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling. More...
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
MooseObjectName	uniqueName () const
const InputParameters &	parameters () const
	Get the parameters of the object. More...
const hit::Node *	getHitNode () const
bool	hasBase () const
const std::string &	getBase () const
template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object. More...
template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object. More...
template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object. More...
template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed 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...
bool	isParamSetByUser (const std::string &name) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default. More...
void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action. 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	paramWarning (const std::string &param, Args... args) const
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...
std::string	messagePrefix (const bool hit_prefix=true) const
std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used. More...
template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available. More...
template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError(). More...
template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type. More...
template<typename... Args>
void	mooseWarning (Args &&... args) const
template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning(). More...
template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseInfo (Args &&... args) const
void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
	External method for calling moose error with added object context. More...
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
std::string	getDataFileName (const std::string &param) const
	Deprecated method. More...
std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method. More...
std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path. More...
PerfGraph &	perfGraph ()
	Get the PerfGraph. More...
libMesh::ConstElemRange *	getActiveLocalElementRange ()
	Return pointers to range objects for various types of ranges (local nodes, boundary elems, etc.). More...
libMesh::NodeRange *	getActiveNodeRange ()
SemiLocalNodeRange *	getActiveSemiLocalNodeRange () const
libMesh::ConstNodeRange *	getLocalNodeRange ()
libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > *	getBoundaryNodeRange ()
libMesh::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)
unsigned int	nFace () const
	accessors for the FaceInfo objects More...
const std::vector< const FaceInfo * > &	faceInfo () const
	Accessor for local FaceInfo objects. More...
face_info_iterator	ownedFaceInfoBegin ()
	Iterators to owned faceInfo objects. More...
face_info_iterator	ownedFaceInfoEnd ()
elem_info_iterator	ownedElemInfoBegin ()
	Iterators to owned faceInfo objects. More...
elem_info_iterator	ownedElemInfoEnd ()
const FaceInfo *	faceInfo (const Elem *elem, unsigned int side) const
	Accessor for the local FaceInfo object on the side of one element. Returns null if ghosted. More...
const ElemInfo &	elemInfo (const dof_id_type id) const
	Accessor for the elemInfo object for a given element ID. More...
const std::vector< const ElemInfo * > &	elemInfoVector () const
	Accessor for the element info objects owned by this process. More...
const std::vector< FaceInfo > &	allFaceInfo () const
	Accessor for all FaceInfo objects. More...

Static Public Member Functions
static InputParameters	validParams ()
	Typical "Moose-style" constructor and copy constructor. More...
static MooseEnum	partitioning ()
	returns MooseMesh partitioning options so other classes can use it More...
static MooseEnum	elemTypes ()
	returns MooseMesh element type options More...
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...
static void	callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node)
	External method for calling moose error with added object context. More...

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

Static Public Attributes
static const std::string	type_param = "_type"
	The name of the parameter that contains the object type. More...
static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name. More...
static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name. More...
static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp. More...
static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base. More...
static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor. 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 (MeshBase *mesh=nullptr)
template<bool warning>
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
	Set solution invalid mark for the given solution ID. More...
InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const
template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it. More...
template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable". More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable". More...
std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix. More...
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing. More...
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing. More...
std::string	timedSectionName (const std::string &section_name) const

Protected Attributes
std::vector< std::unique_ptr< libMesh::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...
bool	_built_from_other_mesh = false
	Whether or not this mesh was built from another mesh. 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...
std::unique_ptr< Moose::Kokkos::Mesh >	_kokkos_mesh
	Pointer to Kokkos mesh object. More...
MooseEnum	_partitioner_name
	The partitioner used on this mesh. More...
bool	_partitioner_overridden
std::unique_ptr< libMesh::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	_skip_refine_when_use_split
	Whether or not to skip uniform refinements when using a pre-split mesh. More...
bool	_skip_deletion_repartition_after_refine
	Whether or not skip remote deletion and repartition after uniform refinements. 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	_moose_mesh_prepared = false
	True if prepare has been called on the mesh. 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< libMesh::ConstElemRange >	_active_local_elem_range
	A range for use with threading. More...
std::unique_ptr< SemiLocalNodeRange >	_active_semilocal_node_range
std::unique_ptr< libMesh::NodeRange >	_active_node_range
std::unique_ptr< libMesh::ConstNodeRange >	_local_node_range
std::unique_ptr< libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > >	_bnd_node_range
std::unique_ptr< libMesh::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 bool	_is_split
	Whether or not we are using a (pre-)split mesh (automatically DistributedMesh) More...
const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects. More...
MooseApp &	_app
	The MOOSE application this is associated with. More...
Factory &	_factory
	The Factory associated with the MooseApp. More...
ActionFactory &	_action_factory
	Builds Actions. More...
const std::string &	_type
	The type of this class. More...
const std::string &	_name
	The name of this class. More...
const InputParameters &	_pars
	The object's parameters. More...
const Parallel::Communicator &	_communicator
MooseApp &	_restartable_app
	Reference to the application. More...
const std::string	_restartable_system_name
	The system name this object is in. More...
const THREAD_ID	_restartable_tid
	The thread ID for this object. More...
const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData) More...
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...
const 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, libMesh::QBase &qrule, libMesh::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, libMesh::QBase &qrule, libMesh::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, libMesh::QBase &qrule, libMesh::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...
void	buildHRefinementAndCoarseningMaps (Assembly *assembly)
const std::vector< QpMap > &	getPRefinementMapHelper (const Elem &elem, const std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap >> &) const
const std::vector< QpMap > &	getPCoarseningMapHelper (const Elem &elem, const std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap >> &) const
void	updateCoordTransform ()
	Update the coordinate transformation object based on our coordinate system data. More...
void	checkDuplicateSubdomainNames ()
	Loop through all subdomain IDs and check if there is name duplication used for the subdomains with same ID. More...
void	computeMaxPerElemAndSide ()
	Compute the maximum numbers per element and side. More...
void	buildElemIDInfo ()
	Build extra data for faster access to the information of extra element integers. More...
void	buildLowerDMesh ()
	Build lower-d mesh for all sides. More...

Private Attributes
std::unordered_map< dof_id_type, ElemInfo >	_elem_to_elem_info
	Map connecting elems with their corresponding ElemInfo, we use the element ID as the key. More...
std::vector< const ElemInfo * >	_elem_info
	Holds only those ElemInfo objects that have processor_id equal to this process's id, e.g. More...
std::vector< FaceInfo >	_all_face_info
	FaceInfo object storing information for face based loops. More...
std::vector< const FaceInfo * >	_face_info
	Holds only those FaceInfo objects that have processor_id equal to this process's id, e.g. More...
std::unordered_map< std::pair< const Elem *, unsigned int >, FaceInfo * >	_elem_side_to_face_info
	Map from elem-side pair to FaceInfo. More...
bool	_finite_volume_info_dirty = true
bool	_linear_finite_volume_dofs_cached = false
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, libMesh::ElemType >, std::vector< std::vector< QpMap > > >	_elem_type_to_refinement_map
	Holds mappings for volume to volume and parent side to child side Map key: More...
std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap > >	_elem_type_to_p_refinement_map
std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap > >	_elem_type_to_p_refinement_side_map
std::map< libMesh::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, libMesh::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 Map key: More...
std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap > >	_elem_type_to_p_coarsening_map
std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap > >	_elem_type_to_p_coarsening_side_map
std::unordered_map< SubdomainID, SubdomainData >	_sub_to_data
	Holds a map from subdomain ids to associated data. More...
std::unordered_map< SubdomainID, std::set< BoundaryID > >	_neighbor_subdomain_boundary_ids
	Holds a map from neighbor subomdain ids to the boundary ids that are attached to it. More...
std::set< SubdomainID >	_lower_d_interior_blocks
	Mesh blocks for interior lower-d elements in different types. More...
std::set< SubdomainID >	_lower_d_boundary_blocks
	Mesh blocks for boundary lower-d elements in different types. More...
std::unordered_map< std::pair< const Elem *, unsigned short int >, const Elem * >	_higher_d_elem_side_to_lower_d_elem
	Holds a map from a high-order element side to its corresponding lower-d element. More...
std::unordered_map< const Elem *, unsigned short int >	_lower_d_elem_to_higher_d_elem_side
bool	_has_lower_d
	Whether there are any lower-dimensional blocks that are manifolds of higher-dimensional block faces. 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...
bool	_displace_node_list_by_side_list
	Whether or not to displace unrelated nodesets by nodesets constructed from sidesets. More...
bool	_need_delete
	Whether we need to delete remote elements after init'ing the EquationSystems. More...
bool	_allow_remote_element_removal
	Whether to allow removal of remote elements. More...
std::set< Elem * >	_ghost_elems_from_ghost_boundaries
	Set of elements ghosted by ghostGhostedBoundaries. More...
bool	_need_ghost_ghosted_boundaries
	A parallel mesh generator such as DistributedRectilinearMeshGenerator already make everything ready. More...
std::vector< std::unordered_map< SubdomainID, std::set< dof_id_type > > >	_block_id_mapping
	Unique element integer IDs for each subdomain and each extra element integers. More...
std::vector< dof_id_type >	_max_ids
	Maximum integer ID for each extra element integer. More...
std::vector< dof_id_type >	_min_ids
	Minimum integer ID for each extra element integer. More...
std::vector< std::vector< bool > >	_id_identical_flag
	Flags to indicate whether or not any two extra element integers are the same. More...
unsigned int	_max_sides_per_elem
	The maximum number of sides per element. More...
unsigned int	_max_nodes_per_elem
	The maximum number of nodes per element. More...
unsigned int	_max_nodes_per_side
	The maximum number of nodes per side. More...
bool	_is_displaced
	Whether this mesh is displaced. More...
std::map< SubdomainID, Moose::CoordinateSystemType > &	_coord_sys
	Type of coordinate system per subdomain. More...
unsigned int	_rz_coord_axis
	Storage for RZ axis selection. More...
std::unordered_map< SubdomainID, std::pair< Point, RealVectorValue > >	_subdomain_id_to_rz_coord_axis
	Map of subdomain ID to general axisymmetric axis. More...
std::unique_ptr< MooseAppCoordTransform >	_coord_transform
	A coordinate transformation object that describes how to transform this problem's coordinate system into the canonical/reference coordinate system. More...
bool	_coord_system_set
	Whether the coordinate system has been set. More...
std::vector< SubdomainName >	_provided_coord_blocks
	Set for holding user-provided coordinate system type block names. More...
bool	_doing_p_refinement
	Whether we have p-refinement (as opposed to h-refinement) More...
unsigned int	_max_p_level
	Maximum p-refinement level of all elements. More...
unsigned int	_max_h_level
	Maximum h-refinement level of all elements. More...

Detailed Description

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

Definition at line 92 of file MooseMesh.h.

Member Typedef Documentation

bnd_elem_iterator_imp

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

protected

Definition at line 1568 of file MooseMesh.h.

bnd_node_iterator_imp

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

protected

Definition at line 1561 of file MooseMesh.h.

const_bnd_elem_iterator_imp

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

protected

Definition at line 1569 of file MooseMesh.h.

const_bnd_node_iterator_imp

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

protected

Definition at line 1562 of file MooseMesh.h.

DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName

inherited

The parameter type this interface expects for a data file name.

Definition at line 27 of file DataFileInterface.h.

PeriodicNodeInfo

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

Helper type for building periodic node maps.

Definition at line 1077 of file MooseMesh.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

protected

Convenience enums.

Enumerator
X
Y
Z

Definition at line 1471 of file MooseMesh.h.

  {
    X = 0,
    Y,
    Z
  };

anonymous enum

anonymous enum

protected

Enumerator
MIN
MAX

Definition at line 1477 of file MooseMesh.h.

  {
    MIN = 0,
    MAX
  };

ParallelType

enum MooseMesh::ParallelType

strong

Enumerator
DEFAULT
REPLICATED
DISTRIBUTED

Definition at line 108 of file MooseMesh.h.

  {
    DEFAULT,
    REPLICATED,
    DISTRIBUTED
  };

Constructor & Destructor Documentation

MooseMesh() [1/3]

MooseMesh::MooseMesh

(

const InputParameters &

parameters

)

Definition at line 232 of file MooseMesh.C.

  : MooseObject(parameters),
    Restartable(this, "Mesh"),
    PerfGraphInterface(this),
    _parallel_type(getParam<MooseEnum>("parallel_type").getEnum<MooseMesh::ParallelType>()),
    _use_distributed_mesh(false),
    _distribution_overridden(false),
    _parallel_type_overridden(false),
    _mesh(nullptr),
    _partitioner_name(getParam<MooseEnum>("partitioner")),
    _partitioner_overridden(false),
    _custom_partitioner_requested(false),
    _uniform_refine_level(0),
    _skip_refine_when_use_split(getParam<bool>("skip_refine_when_use_split")),
    _skip_deletion_repartition_after_refine(false),
    _is_nemesis(getParam<bool>("nemesis")),
    _node_to_elem_map_built(false),
    _node_to_active_semilocal_elem_map_built(false),
    _patch_size(getParam<unsigned int>("patch_size")),
    _ghosting_patch_size(isParamValid("ghosting_patch_size")
                             ? getParam<unsigned int>("ghosting_patch_size")
                             : 5 * _patch_size),
    _max_leaf_size(getParam<unsigned int>("max_leaf_size")),
    _patch_update_strategy(
        getParam<MooseEnum>("patch_update_strategy").getEnum<Moose::PatchUpdateType>()),
    _regular_orthogonal_mesh(false),
    _is_split(getParam<bool>("_is_split")),
    _has_lower_d(false),
    _allow_recovery(true),
    _construct_node_list_from_side_list(getParam<bool>("construct_node_list_from_side_list")),
    _displace_node_list_by_side_list(getParam<bool>("displace_node_list_by_side_list")),
    _need_delete(false),
    _allow_remote_element_removal(true),
    _need_ghost_ghosted_boundaries(true),
    _is_displaced(false),
    _coord_sys(
        declareRestartableData<std::map<SubdomainID, Moose::CoordinateSystemType>>("coord_sys")),
    _rz_coord_axis(getParam<MooseEnum>("rz_coord_axis")),
    _coord_system_set(false),
    _doing_p_refinement(false)
{
  if (isParamValid("ghosting_patch_size") && (_patch_update_strategy != Moose::Iteration))
    mooseError("Ghosting patch size parameter has to be set in the mesh block "
               "only when 'iteration' patch update strategy is used.");

  if (_displace_node_list_by_side_list && !_construct_node_list_from_side_list)
    paramError("displace_node_list_by_side_list",
               "'Mesh/displace_node_list_by_side_list' is true, but unused when "
               "'Mesh/construct_node_list_from_side_list' is false");

  if (isParamValid("coord_block"))
  {
    if (isParamValid("block"))
      paramWarning("block",
                   "You set both 'Mesh/block' and 'Mesh/coord_block'. The value of "
                   "'Mesh/coord_block' will be used.");

    _provided_coord_blocks = getParam<std::vector<SubdomainName>>("coord_block");
  }
  else if (isParamValid("block"))
    _provided_coord_blocks = getParam<std::vector<SubdomainName>>("block");

  if (getParam<bool>("build_all_side_lowerd_mesh"))
    // Do not initially allow removal of remote elements
    allowRemoteElementRemoval(false);

  determineUseDistributedMesh();

#ifdef MOOSE_KOKKOS_ENABLED
  if (_app.isKokkosAvailable())
    _kokkos_mesh = std::make_unique<Moose::Kokkos::Mesh>(*this);
#endif
}

MooseMesh() [2/3]

MooseMesh::MooseMesh

(

const MooseMesh &

other_mesh

)

Definition at line 306 of file MooseMesh.C.

  : MooseObject(other_mesh._pars),
    Restartable(this, "Mesh"),
    PerfGraphInterface(this, "CopiedMesh"),
    _built_from_other_mesh(true),
    _parallel_type(other_mesh._parallel_type),
    _use_distributed_mesh(other_mesh._use_distributed_mesh),
    _distribution_overridden(other_mesh._distribution_overridden),
    _parallel_type_overridden(other_mesh._parallel_type_overridden),
    _mesh(other_mesh.getMesh().clone()),
    _partitioner_name(other_mesh._partitioner_name),
    _partitioner_overridden(other_mesh._partitioner_overridden),
    _custom_partitioner_requested(other_mesh._custom_partitioner_requested),
    _uniform_refine_level(other_mesh.uniformRefineLevel()),
    _skip_refine_when_use_split(other_mesh._skip_refine_when_use_split),
    _skip_deletion_repartition_after_refine(other_mesh._skip_deletion_repartition_after_refine),
    _is_nemesis(false),
    _node_to_elem_map_built(false),
    _node_to_active_semilocal_elem_map_built(false),
    _patch_size(other_mesh._patch_size),
    _ghosting_patch_size(other_mesh._ghosting_patch_size),
    _max_leaf_size(other_mesh._max_leaf_size),
    _patch_update_strategy(other_mesh._patch_update_strategy),
    _regular_orthogonal_mesh(false),
    _is_split(other_mesh._is_split),
    _lower_d_interior_blocks(other_mesh._lower_d_interior_blocks),
    _lower_d_boundary_blocks(other_mesh._lower_d_boundary_blocks),
    _has_lower_d(other_mesh._has_lower_d),
    _allow_recovery(other_mesh._allow_recovery),
    _construct_node_list_from_side_list(other_mesh._construct_node_list_from_side_list),
    _displace_node_list_by_side_list(other_mesh._displace_node_list_by_side_list),
    _need_delete(other_mesh._need_delete),
    _allow_remote_element_removal(other_mesh._allow_remote_element_removal),
    _need_ghost_ghosted_boundaries(other_mesh._need_ghost_ghosted_boundaries),
    _coord_sys(other_mesh._coord_sys),
    _rz_coord_axis(other_mesh._rz_coord_axis),
    _subdomain_id_to_rz_coord_axis(other_mesh._subdomain_id_to_rz_coord_axis),
    _coord_system_set(other_mesh._coord_system_set),
    _provided_coord_blocks(other_mesh._provided_coord_blocks),
    _doing_p_refinement(other_mesh._doing_p_refinement)
{
  // Note: this calls BoundaryInfo::operator= without changing the
  // ownership semantics of either Mesh's BoundaryInfo object.
  getMesh().get_boundary_info() = other_mesh.getMesh().get_boundary_info();

  const std::set<SubdomainID> & subdomains = other_mesh.meshSubdomains();
  for (const auto & sbd_id : subdomains)
    setSubdomainName(sbd_id, other_mesh.getMesh().subdomain_name(sbd_id));

  // Get references to BoundaryInfo objects to make the code below cleaner...
  const BoundaryInfo & other_boundary_info = other_mesh.getMesh().get_boundary_info();
  BoundaryInfo & boundary_info = getMesh().get_boundary_info();

  // Use the other BoundaryInfo object to build the list of side boundary ids
  std::vector<BoundaryID> side_boundaries;
  other_boundary_info.build_side_boundary_ids(side_boundaries);

  // Assign those boundary ids in our BoundaryInfo object
  for (const auto & side_bnd_id : side_boundaries)
    boundary_info.sideset_name(side_bnd_id) = other_boundary_info.get_sideset_name(side_bnd_id);

  // Do the same thing for node boundary ids
  std::vector<BoundaryID> node_boundaries;
  other_boundary_info.build_node_boundary_ids(node_boundaries);

  for (const auto & node_bnd_id : node_boundaries)
    boundary_info.nodeset_name(node_bnd_id) = other_boundary_info.get_nodeset_name(node_bnd_id);

  _bounds.resize(other_mesh._bounds.size());
  for (std::size_t i = 0; i < _bounds.size(); ++i)
  {
    _bounds[i].resize(other_mesh._bounds[i].size());
    for (std::size_t j = 0; j < _bounds[i].size(); ++j)
      _bounds[i][j] = other_mesh._bounds[i][j];
  }

  updateCoordTransform();

#ifdef MOOSE_KOKKOS_ENABLED
  if (_app.isKokkosAvailable())
    _kokkos_mesh = std::make_unique<Moose::Kokkos::Mesh>(*this);
#endif
}

MooseMesh() [3/3]

MooseMesh::MooseMesh ( )

delete

~MooseMesh()

MooseMesh::~MooseMesh ( )

virtual

Definition at line 390 of file MooseMesh.C.

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

Member Function Documentation

activeLocalElementsBegin() [1/2]

MeshBase::element_iterator MooseMesh::activeLocalElementsBegin

(

)

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

Definition at line 3131 of file MooseMesh.C.

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

{
  return getMesh().active_local_elements_begin();
}

activeLocalElementsBegin() [2/2]

MeshBase::const_element_iterator MooseMesh::activeLocalElementsBegin

(

)

const

Definition at line 3143 of file MooseMesh.C.

{
  return getMesh().active_local_elements_begin();
}

activeLocalElementsEnd() [1/2]

const MeshBase::element_iterator MooseMesh::activeLocalElementsEnd

(

)

Definition at line 3137 of file MooseMesh.C.

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

{
  return getMesh().active_local_elements_end();
}

activeLocalElementsEnd() [2/2]

const MeshBase::const_element_iterator MooseMesh::activeLocalElementsEnd

(

)

const

Definition at line 3149 of file MooseMesh.C.

{
  return getMesh().active_local_elements_end();
}

addGhostedBoundary()

void MooseMesh::addGhostedBoundary

(

BoundaryID

boundary_id

)

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

Definition at line 3309 of file MooseMesh.C.

Referenced by FEProblemBase::addGhostedBoundary().

{
  _ghosted_boundaries.insert(boundary_id);
}

addPeriodicVariable()

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

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

Definition at line 2267 of file MooseMesh.C.

Referenced by AddPeriodicBCAction::setPeriodicVars().

{
  if (!_regular_orthogonal_mesh)
    return;

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

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

  bool component_found = false;
  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;
      component_found = true;
    }
  }
  if (!component_found)
    mooseWarning("Could not find a match between boundary '",
                 getBoundaryName(primary),
                 "' and '",
                 getBoundaryName(secondary),
                 "' to set periodic boundary conditions for variable (index:",
                 var_num,
                 ") in either the X, Y or Z direction. The periodic dimension of the mesh for this "
                 "variable will not be stored.");
}

addQuadratureNode()

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

Adds a fictitious "QuadratureNode".

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

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

Parameters

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

Definition at line 1660 of file MooseMesh.C.

Referenced by GeometricSearchData::generateQuadratureNodes().

{
  Node * qnode;

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

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

    qnode = new Node(point, new_id);

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

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

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

  _extra_bnd_nodes.push_back(*bnode);

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

  return qnode;
}

addUniqueNode()

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

Add a new node to the mesh.

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

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

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

allFaceInfo()

const std::vector< FaceInfo > & MooseMesh::allFaceInfo ( ) const

inline

Accessor for all FaceInfo objects.

Definition at line 2222 of file MooseMesh.h.

{
  return _all_face_info;
}

allowRecovery()

void MooseMesh::allowRecovery ( bool  allow )

inline

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

Definition at line 1034 of file MooseMesh.h.

{ _allow_recovery = allow; }

allowRemoteElementRemoval() [1/2]

void MooseMesh::allowRemoteElementRemoval

(

bool

allow_removal

)

Set whether to allow remote element removal.

Definition at line 3995 of file MooseMesh.C.

{
  _allow_remote_element_removal = allow_remote_element_removal;
  if (_mesh)
    _mesh->allow_remote_element_removal(allow_remote_element_removal);

  if (!allow_remote_element_removal)
    // If we're not allowing remote element removal now, then we will need deletion later after
    // late geoemetric ghosting functors have been added (late geometric ghosting functor addition
    // happens when algebraic ghosting functors are added)
    _need_delete = true;
}

allowRemoteElementRemoval() [2/2]

bool MooseMesh::allowRemoteElementRemoval ( ) const

inline

Whether we are allow remote element removal.

Definition at line 1097 of file MooseMesh.h.

Referenced by MooseMesh().

{ return _allow_remote_element_removal; }

areElemIDsIdentical()

bool MooseMesh::areElemIDsIdentical ( const std::string &  id_name1, const std::string &  id_name2  ) const

inline

Whether or not two extra element integers are identical.

Definition at line 2208 of file MooseMesh.h.

{
  auto id1 = getElementIDIndex(id_name1);
  auto id2 = getElementIDIndex(id_name2);
  return _id_identical_flag[id1][id2];
}

bndElemsBegin()

MooseMesh::bnd_elem_iterator MooseMesh::bndElemsBegin ( )

virtual

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

Definition at line 1611 of file MooseMesh.C.

Referenced by getBoundaryElementRange(), and MeshInfo::possiblyAddSidesetInfo().

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

bndElemsEnd()

MooseMesh::bnd_elem_iterator MooseMesh::bndElemsEnd ( )

virtual

Definition at line 1619 of file MooseMesh.C.

Referenced by getBoundaryElementRange(), and MeshInfo::possiblyAddSidesetInfo().

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

bndNodesBegin()

MooseMesh::bnd_node_iterator MooseMesh::bndNodesBegin ( )

virtual

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

Definition at line 1595 of file MooseMesh.C.

Referenced by getBoundaryNodeRange().

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

bndNodesEnd()

MooseMesh::bnd_node_iterator MooseMesh::bndNodesEnd ( )

virtual

Definition at line 1603 of file MooseMesh.C.

Referenced by getBoundaryNodeRange().

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

boundaryLowerDBlocks()

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

inline

Returns

The set of lower-dimensional blocks for boundary sides

Definition at line 1425 of file MooseMesh.h.

Referenced by FEProblemBase::adaptMesh(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), NonlinearSystemBase::checkKernelCoverage(), HFEMDirichletBC::HFEMDirichletBC(), FEProblemBase::initialAdaptMesh(), and LowerDIntegratedBC::LowerDIntegratedBC().

{ return _lower_d_boundary_blocks; }

buildActiveSideList()

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

(

)

const

Calls BoundaryInfo::build_active_side_list.

Returns

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

Definition at line 3095 of file MooseMesh.C.

Referenced by buildFiniteVolumeInfo().

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

buildBndElemList()

void MooseMesh::buildBndElemList

(

)

Definition at line 1205 of file MooseMesh.C.

Referenced by update().

{
  TIME_SECTION("buildBndElemList", 5, "Building Boundary Elements List");

  freeBndElems();

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

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

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

buildCoarseningMap()

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

private

Build the coarsening map for a given element type.

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

Parameters

elem	The element that represents the element type you need the coarsening map for.
qrule	The quadrature rule in use.
qrule_face	The current face quadrature rule
input_side	The side to map

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

Definition at line 2601 of file MooseMesh.C.

Referenced by buildHRefinementAndCoarseningMaps().

{
  TIME_SECTION("buildCoarseningMap", 5, "Building Coarsening Map");

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

}

buildElemIDInfo()

void MooseMesh::buildElemIDInfo ( )

private

Build extra data for faster access to the information of extra element integers.

Definition at line 1109 of file MooseMesh.C.

Referenced by update().

{
  unsigned int n = getMesh().n_elem_integers() + 1;

  _block_id_mapping.clear();
  _max_ids.clear();
  _min_ids.clear();
  _id_identical_flag.clear();

  _block_id_mapping.resize(n);
  _max_ids.resize(n, std::numeric_limits<dof_id_type>::min());
  _min_ids.resize(n, std::numeric_limits<dof_id_type>::max());
  _id_identical_flag.resize(n, std::vector<bool>(n, true));
  for (const auto & elem : getMesh().active_local_element_ptr_range())
    for (unsigned int i = 0; i < n; ++i)
    {
      auto id = (i == n - 1 ? elem->subdomain_id() : elem->get_extra_integer(i));
      _block_id_mapping[i][elem->subdomain_id()].insert(id);
      if (id > _max_ids[i])
        _max_ids[i] = id;
      if (id < _min_ids[i])
        _min_ids[i] = id;
      for (unsigned int j = 0; j < n; ++j)
      {
        auto idj = (j == n - 1 ? elem->subdomain_id() : elem->get_extra_integer(j));
        if (i != j && _id_identical_flag[i][j] && id != idj)
          _id_identical_flag[i][j] = false;
      }
    }

  for (unsigned int i = 0; i < n; ++i)
  {
    for (auto & blk : meshSubdomains())
      comm().set_union(_block_id_mapping[i][blk]);
    comm().min(_id_identical_flag[i]);
  }
  comm().max(_max_ids);
  comm().min(_min_ids);
}

buildFiniteVolumeInfo()

void MooseMesh::buildFiniteVolumeInfo

(

)

const

Builds the face and elem info vectors that store meta-data needed for looping over and doing calculations based on mesh faces and elements in a finite volume setting.

This should only be called when finite volume variables are used in the problem or when the face and elem info objects are necessary for functor-based evaluations.

Definition at line 3819 of file MooseMesh.C.

Referenced by setupFiniteVolumeMeshData().

{
  mooseAssert(!Threads::in_threads,
              "This routine has not been implemented for threads. Please query this routine before "
              "a threaded region or contact a MOOSE developer to discuss.");
  _finite_volume_info_dirty = false;

  using Keytype = std::pair<const Elem *, unsigned short int>;

  // create a map from elem/side --> boundary ids
  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> side_list =
      buildActiveSideList();
  std::map<Keytype, std::set<boundary_id_type>> side_map;
  for (auto & [elem_id, side, bc_id] : side_list)
  {
    const Elem * elem = _mesh->elem_ptr(elem_id);
    Keytype key(elem, side);
    auto & bc_set = side_map[key];
    bc_set.insert(bc_id);
  }

  _face_info.clear();
  _all_face_info.clear();
  _elem_side_to_face_info.clear();

  _elem_to_elem_info.clear();
  _elem_info.clear();

  // by performing the element ID comparison check in the below loop, we are ensuring that we never
  // double count face contributions. If a face lies along a process boundary, the only process that
  // will contribute to both sides of the face residuals/Jacobians will be the process that owns the
  // element with the lower ID.
  auto begin = getMesh().active_elements_begin();
  auto end = getMesh().active_elements_end();

  // We prepare a map connecting the Elem* and the corresponding ElemInfo
  // for the active elements.
  for (const Elem * elem : as_range(begin, end))
    _elem_to_elem_info.emplace(elem->id(), elem);

  dof_id_type face_index = 0;
  for (const Elem * elem : as_range(begin, end))
  {
    for (unsigned int side = 0; side < elem->n_sides(); ++side)
    {
      // get the neighbor element
      const Elem * neighbor = elem->neighbor_ptr(side);

      // Check if the FaceInfo shall belong to the element. If yes,
      // create and initialize the FaceInfo. We need this to ensure that
      // we do not duplicate FaceInfo-s.
      if (Moose::FV::elemHasFaceInfo(*elem, neighbor))
      {
        mooseAssert(!neighbor || (neighbor->level() < elem->level() ? neighbor->active() : true),
                    "If the neighbor is coarser than the element, we expect that the neighbor must "
                    "be active.");

        // We construct the faceInfo using the elementinfo and side index
        _all_face_info.emplace_back(&_elem_to_elem_info[elem->id()], side, face_index++);

        auto & fi = _all_face_info.back();

        // get all the sidesets that this face is contained in and cache them
        // in the face info.
        std::set<boundary_id_type> & boundary_ids = fi.boundaryIDs();
        boundary_ids.clear();

        // We initialize the weights/other information in faceInfo. If the neighbor does not exist
        // or is remote (so when we are on some sort of mesh boundary), we initialize the ghost
        // cell and use it to compute the weights corresponding to the faceInfo.
        if (!neighbor || neighbor == libMesh::remote_elem)
          fi.computeBoundaryCoefficients();
        else
          fi.computeInternalCoefficients(&_elem_to_elem_info[neighbor->id()]);

        auto lit = side_map.find(Keytype(&fi.elem(), fi.elemSideID()));
        if (lit != side_map.end())
          boundary_ids.insert(lit->second.begin(), lit->second.end());

        if (fi.neighborPtr())
        {
          auto rit = side_map.find(Keytype(fi.neighborPtr(), fi.neighborSideID()));
          if (rit != side_map.end())
            boundary_ids.insert(rit->second.begin(), rit->second.end());
        }
      }
    }
  }

  // Build the local face info and elem_side to face info maps. We need to do this after
  // _all_face_info is finished being constructed because emplace_back invalidates all iterators and
  // references if ever the new size exceeds capacity
  for (auto & fi : _all_face_info)
  {
    const Elem * const elem = &fi.elem();
    const auto side = fi.elemSideID();

#ifndef NDEBUG
    auto pair_it =
#endif
        _elem_side_to_face_info.emplace(std::make_pair(elem, side), &fi);
    mooseAssert(pair_it.second, "We should be adding unique FaceInfo objects.");

    // We will add the faces on processor boundaries to the list of face infos on each
    // associated processor.
    if (fi.elem().processor_id() == this->processor_id() ||
        (fi.neighborPtr() && (fi.neighborPtr()->processor_id() == this->processor_id())))
      _face_info.push_back(&fi);
  }

  for (auto & ei : _elem_to_elem_info)
    if (ei.second.elem()->processor_id() == this->processor_id())
      _elem_info.push_back(&ei.second);
}

buildHRefinementAndCoarseningMaps()

void MooseMesh::buildHRefinementAndCoarseningMaps ( Assembly *  assembly )

private

Definition at line 2361 of file MooseMesh.C.

Referenced by buildRefinementAndCoarseningMaps().

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

buildLowerDMesh()

void MooseMesh::buildLowerDMesh ( )

private

Build lower-d mesh for all sides.

Definition at line 685 of file MooseMesh.C.

Referenced by init().

{
  auto & mesh = getMesh();

  if (!mesh.is_serial())
    mooseError(
        "Hybrid finite element method must use replicated mesh.\nCurrently lower-dimensional mesh "
        "does not support mesh re-partitioning and a debug assertion being hit related with "
        "neighbors of lower-dimensional element, with distributed mesh.");

  // Lower-D element build requires neighboring element information
  if (!mesh.is_prepared())
    mesh.find_neighbors();

  // maximum number of sides of all elements
  unsigned int max_n_sides = 0;

  // remove existing lower-d element first
  std::set<Elem *> deleteable_elems;
  for (auto & elem : mesh.element_ptr_range())
    if (_lower_d_interior_blocks.count(elem->subdomain_id()) ||
        _lower_d_boundary_blocks.count(elem->subdomain_id()))
      deleteable_elems.insert(elem);
    else if (elem->n_sides() > max_n_sides)
      max_n_sides = elem->n_sides();

  for (auto & elem : deleteable_elems)
    mesh.delete_elem(elem);
  for (const auto & id : _lower_d_interior_blocks)
    _mesh_subdomains.erase(id);
  for (const auto & id : _lower_d_boundary_blocks)
    _mesh_subdomains.erase(id);
  _lower_d_interior_blocks.clear();
  _lower_d_boundary_blocks.clear();

  mesh.comm().max(max_n_sides);

  deleteable_elems.clear();

  // get all side types
  std::set<int> interior_side_types;
  std::set<int> boundary_side_types;
  for (const auto & elem : mesh.active_element_ptr_range())
    for (const auto side : elem->side_index_range())
    {
      Elem * neig = elem->neighbor_ptr(side);
      std::unique_ptr<Elem> side_elem(elem->build_side_ptr(side));
      if (neig)
        interior_side_types.insert(side_elem->type());
      else
        boundary_side_types.insert(side_elem->type());
    }
  mesh.comm().set_union(interior_side_types);
  mesh.comm().set_union(boundary_side_types);

  // assign block ids for different side types
  std::map<ElemType, SubdomainID> interior_block_ids;
  std::map<ElemType, SubdomainID> boundary_block_ids;
  // we assume this id is not used by the mesh
  auto id = libMesh::Elem::invalid_subdomain_id - 2;
  for (const auto & tpid : interior_side_types)
  {
    const auto type = ElemType(tpid);
    mesh.subdomain_name(id) = "INTERNAL_SIDE_LOWERD_SUBDOMAIN_" + Utility::enum_to_string(type);
    interior_block_ids[type] = id;
    _lower_d_interior_blocks.insert(id);
    if (_mesh_subdomains.count(id) > 0)
      mooseError("Trying to add a mesh block with id ", id, " that has existed in the mesh");
    _mesh_subdomains.insert(id);
    --id;
  }
  for (const auto & tpid : boundary_side_types)
  {
    const auto type = ElemType(tpid);
    mesh.subdomain_name(id) = "BOUNDARY_SIDE_LOWERD_SUBDOMAIN_" + Utility::enum_to_string(type);
    boundary_block_ids[type] = id;
    _lower_d_boundary_blocks.insert(id);
    if (_mesh_subdomains.count(id) > 0)
      mooseError("Trying to add a mesh block with id ", id, " that has existed in the mesh");
    _mesh_subdomains.insert(id);
    --id;
  }

  dof_id_type max_elem_id = mesh.max_elem_id();
  unique_id_type max_unique_id = mesh.parallel_max_unique_id();

  std::vector<Elem *> side_elems;
  _higher_d_elem_side_to_lower_d_elem.clear();
  for (const auto & elem : mesh.active_element_ptr_range())
  {
    // skip existing lower-d elements
    if (elem->interior_parent())
      continue;

    for (const auto side : elem->side_index_range())
    {
      Elem * neig = elem->neighbor_ptr(side);

      bool build_side = false;
      if (!neig)
        build_side = true;
      else
      {
        mooseAssert(!neig->is_remote(), "We error if the mesh is not serial");
        if (!neig->active())
          build_side = true;
        else if (neig->level() == elem->level() && elem->id() < neig->id())
          build_side = true;
      }

      if (build_side)
      {
        std::unique_ptr<Elem> side_elem(elem->build_side_ptr(side));

        // The side will be added with the same processor id as the parent.
        side_elem->processor_id() = elem->processor_id();

        // Add subdomain ID
        if (neig)
          side_elem->subdomain_id() = interior_block_ids.at(side_elem->type());
        else
          side_elem->subdomain_id() = boundary_block_ids.at(side_elem->type());

        // set ids consistently across processors (these ids will be temporary)
        side_elem->set_id(max_elem_id + elem->id() * max_n_sides + side);
        side_elem->set_unique_id(max_unique_id + elem->id() * max_n_sides + side);

        // Also assign the side's interior parent, so it is always
        // easy to figure out the Elem we came from.
        // Note: the interior parent could be a ghost element.
        side_elem->set_interior_parent(elem);

        side_elems.push_back(side_elem.release());

        // add link between higher d element to lower d element
        auto pair = std::make_pair(elem, side);
        auto link = std::make_pair(pair, side_elems.back());
        auto ilink = std::make_pair(side_elems.back(), side);
        _lower_d_elem_to_higher_d_elem_side.insert(ilink);
        _higher_d_elem_side_to_lower_d_elem.insert(link);
      }
    }
  }

  // finally, add the lower-dimensional element to the mesh
  // Note: lower-d interior element will exist on a processor if its associated interior
  //       parent exists on a processor whether or not being a ghost. Lower-d elements will
  //       get its interior parent's processor id.
  for (auto & elem : side_elems)
    mesh.add_elem(elem);

  // we do all the stuff in prepare_for_use such as renumber_nodes_and_elements(),
  // update_parallel_id_counts(), cache_elem_dims(), etc. except partitioning here.
  const bool skip_partitioning_old = mesh.skip_partitioning();
  mesh.skip_partitioning(true);
  // Finding neighbors is ambiguous for lower-dimensional elements on interior faces
  mesh.allow_find_neighbors(false);
  mesh.prepare_for_use();
  mesh.skip_partitioning(skip_partitioning_old);
}

buildMesh()

virtual void MooseMesh::buildMesh ( )

pure virtual

Must be overridden by child classes.

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

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

Referenced by init().

buildMeshBaseObject()

std::unique_ptr< MeshBase > MooseMesh::buildMeshBaseObject

(

unsigned int

dim = libMesh::invalid_uint

)

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

If the parameter dim is not provided, then its value will be taken from the input file mesh block.

Definition at line 2906 of file MooseMesh.C.

Referenced by MeshGenerator::buildMeshBaseObject(), and init().

{
  std::unique_ptr<MeshBase> mesh;
  if (_use_distributed_mesh)
    mesh = buildTypedMesh<DistributedMesh>(dim);
  else
    mesh = buildTypedMesh<ReplicatedMesh>(dim);

  return mesh;
}

buildNodeList()

void MooseMesh::buildNodeList

(

)

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

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

Definition at line 1052 of file MooseMesh.C.

Referenced by update().

{
  TIME_SECTION("buildNodeList", 5, "Building Node List");

  freeBndNodes();

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

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

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

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

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

buildNodeListFromSideList()

void MooseMesh::buildNodeListFromSideList

(

)

Calls BoundaryInfo::build_node_list_from_side_list().

Definition at line 3035 of file MooseMesh.C.

Referenced by prepare(), and update().

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

  if (_construct_node_list_from_side_list)
  {
    const std::set<boundary_id_type> & side_bcids = boundary_info.get_side_boundary_ids();

    if (_displace_node_list_by_side_list)
    {
      // Don't want to use auto here - the rbegin trick relies on a
      // sorted set and we want the compiler to scream if libMesh ever
      // switches type
      const std::set<boundary_id_type> & node_bcids = boundary_info.get_node_boundary_ids();

      // If we've got a reasonable largest BC id, we can just use the
      // subsequent unused ones
      boundary_id_type next_bcid = 0;
      if (!node_bcids.empty())
        next_bcid = std::max(next_bcid, cast_int<boundary_id_type>(*node_bcids.rbegin() + 1));
      if (!side_bcids.empty())
        next_bcid = std::max(next_bcid, cast_int<boundary_id_type>(*side_bcids.rbegin() + 1));

      // If we've got an unreasonable largest BC id, we should
      // probably just search for unused ones with moderate values, so we
      // don't risk wrapping.
      if (next_bcid > 1000 || next_bcid <= 0)
        next_bcid = 1000;

      // If any side bcid is already a node bcid with a different name,
      // that's a different boundary condition that we need to reassign
      // rather than overwrite or merge to.
      for (auto bcid : side_bcids)
        if (node_bcids.count(bcid) &&
            (boundary_info.get_sideset_name(bcid) != boundary_info.get_nodeset_name(bcid)))
        {
          boundary_info.renumber_node_id(bcid, next_bcid);
          do
          {
            ++next_bcid;
          } while (node_bcids.count(next_bcid) || side_bcids.count(next_bcid));
        }
    }

    // If any side bcid isn't already a node bcid, we should make
    // sure that our new node bcid is given the same name.
    for (auto bcid : side_bcids)
      boundary_info.nodeset_name(bcid) = boundary_info.get_sideset_name(bcid);

    boundary_info.build_node_list_from_side_list();
  }
}

buildPeriodicNodeMap()

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

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

Definition at line 1863 of file MooseMesh.C.

{
  TIME_SECTION("buildPeriodicNodeMap", 5);

  // 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>, Real, std::size_t>,
      PointListAdaptor<PeriodicNodeInfo>,
      LIBMESH_DIM,
      std::size_t>;
  const unsigned int max_leaf_size = 20; // slightly affects runtime
  auto point_list =
      PointListAdaptor<PeriodicNodeInfo>(periodic_nodes.begin(), periodic_nodes.end());
  auto kd_tree = std::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::SearchParameters search_params;
  std::vector<nanoflann::ResultItem<std::size_t, Real>> ret_matches;

  // iterate over periodic nodes (boundary ids are in contiguous blocks)
  libMesh::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,
		libMesh::PeriodicBoundaries *	pbs
	)		const

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

Definition at line 1948 of file MooseMesh.C.

{
  TIME_SECTION("buildPeriodicNodeSets", 5);

  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 libMesh::PeriodicBoundaryBase * periodic = pbs->boundary(bc_id);
      if (periodic && periodic->is_my_variable(var_number))
        periodic_node_sets[bc_id].insert(node_id);
    }
  }
}

buildPRefinementAndCoarseningMaps()

void MooseMesh::buildPRefinementAndCoarseningMaps

(

Assembly *

assembly

)

Definition at line 2418 of file MooseMesh.C.

Referenced by buildRefinementAndCoarseningMaps(), and FEProblemBase::meshChanged().

{
  _elem_type_to_p_refinement_map.clear();
  _elem_type_to_p_refinement_side_map.clear();
  _elem_type_to_p_coarsening_map.clear();
  _elem_type_to_p_coarsening_side_map.clear();

  std::map<ElemType, std::pair<Elem *, unsigned int>> elems_and_max_p_level;

  for (const auto & elem : getMesh().active_element_ptr_range())
  {
    const auto type = elem->type();
    auto & [picked_elem, max_p_level] = elems_and_max_p_level[type];
    if (!picked_elem)
      picked_elem = elem;
    max_p_level = std::max(max_p_level, elem->p_level());
  }

  // The only requirement on the FEType is that it can be arbitrarily p-refined
  const FEType p_refinable_fe_type(CONSTANT, libMesh::MONOMIAL);
  std::vector<Point> volume_ref_points_coarse, volume_ref_points_fine, face_ref_points_coarse,
      face_ref_points_fine;
  std::vector<unsigned int> p_levels;

  for (auto & [elem_type, elem_p_level_pair] : elems_and_max_p_level)
  {
    auto & [moose_elem, max_p_level] = elem_p_level_pair;
    const auto dim = moose_elem->dim();
    // Need to do this just once to get the right qrules put in place
    assembly->setCurrentSubdomainID(moose_elem->subdomain_id());
    assembly->reinit(moose_elem);
    assembly->reinit(moose_elem, 0);
    auto & qrule = assembly->writeableQRule();
    auto & qrule_face = assembly->writeableQRuleFace();

    libMesh::Parallel::Communicator self_comm{};
    ReplicatedMesh mesh(self_comm);
    mesh.set_mesh_dimension(dim);
    for (const auto & nd : moose_elem->node_ref_range())
      mesh.add_point(nd);

    Elem * const elem = mesh.add_elem(Elem::build(elem_type).release());
    for (const auto i : elem->node_index_range())
      elem->set_node(i, mesh.node_ptr(i));

    std::unique_ptr<FEBase> fe_face(FEBase::build(dim, p_refinable_fe_type));
    fe_face->get_phi();
    const auto & face_phys_points = fe_face->get_xyz();
    fe_face->attach_quadrature_rule(qrule_face);

    qrule->init(*elem);
    volume_ref_points_coarse = qrule->get_points();
    fe_face->reinit(elem, (unsigned int)0);
    libMesh::FEMap::inverse_map(dim, elem, face_phys_points, face_ref_points_coarse);

    p_levels.resize(max_p_level + 1);
    std::iota(p_levels.begin(), p_levels.end(), 0);
    libMesh::MeshRefinement mesh_refinement(mesh);

    for (const auto p_level : p_levels)
    {
      mesh_refinement.uniformly_p_refine(1);
      qrule->init(*elem);
      volume_ref_points_fine = qrule->get_points();
      fe_face->reinit(elem, (unsigned int)0);
      libMesh::FEMap::inverse_map(dim, elem, face_phys_points, face_ref_points_fine);

      const auto map_key = std::make_pair(elem_type, p_level);
      auto & volume_refine_map = _elem_type_to_p_refinement_map[map_key];
      auto & face_refine_map = _elem_type_to_p_refinement_side_map[map_key];
      auto & volume_coarsen_map = _elem_type_to_p_coarsening_map[map_key];
      auto & face_coarsen_map = _elem_type_to_p_coarsening_side_map[map_key];

      auto fill_maps = [this](const auto & coarse_ref_points,
                              const auto & fine_ref_points,
                              auto & coarsen_map,
                              auto & refine_map)
      {
        mapPoints(fine_ref_points, coarse_ref_points, refine_map);
        mapPoints(coarse_ref_points, fine_ref_points, coarsen_map);
      };

      fill_maps(
          volume_ref_points_coarse, volume_ref_points_fine, volume_coarsen_map, volume_refine_map);
      fill_maps(face_ref_points_coarse, face_ref_points_fine, face_coarsen_map, face_refine_map);

      // With this level's maps filled our fine points now become our coarse points
      volume_ref_points_fine.swap(volume_ref_points_coarse);
      face_ref_points_fine.swap(face_ref_points_coarse);
    }
  }
}

buildRefinementAndCoarseningMaps()

void MooseMesh::buildRefinementAndCoarseningMaps

(

Assembly *

assembly

)

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

Parameters

assembly

Pointer to the Assembly object for this Mesh.

Definition at line 2512 of file MooseMesh.C.

Referenced by FEProblemBase::initialSetup().

{
  TIME_SECTION("buildRefinementAndCoarseningMaps", 5, "Building Refinement And Coarsening Maps");
  if (doingPRefinement())
    buildPRefinementAndCoarseningMaps(assembly);
  else
    buildHRefinementAndCoarseningMaps(assembly);
}

buildRefinementMap()

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

private

Build the refinement map for a given element type.

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

Parameters

elem	The element that represents the element type you need the refinement map for.
qrule	The quadrature rule in use.
qrule_face	The current face quadrature rule
parent_side	The side of the parent to map (-1 if not mapping parent sides)
child	The child number (-1 if not mapping child internal sides)
child_side	The side number of the child (-1 if not mapping sides)

Definition at line 2522 of file MooseMesh.C.

Referenced by buildHRefinementAndCoarseningMaps().

{
  TIME_SECTION("buildRefinementMap", 5, "Building Refinement Map");

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

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

    if (_elem_type_to_refinement_map.find(the_pair) != _elem_type_to_refinement_map.end())
      mooseError("Already built a qp refinement map!");

    std::vector<std::pair<unsigned int, QpMap>> coarsen_map;
    std::vector<std::vector<QpMap>> & refinement_map = _elem_type_to_refinement_map[the_pair];
    findAdaptivityQpMaps(
        &elem, qrule, qrule_face, refinement_map, coarsen_map, parent_side, child, child_side);
  }
  else // Need to map a child side to parent volume qps
  {
    std::pair<int, int> child_pair(child, child_side);

    if (_elem_type_to_child_side_refinement_map.find(elem.type()) !=
            _elem_type_to_child_side_refinement_map.end() &&
        _elem_type_to_child_side_refinement_map[elem.type()].find(child_pair) !=
            _elem_type_to_child_side_refinement_map[elem.type()].end())
      mooseError("Already built a qp refinement map!");

    std::vector<std::pair<unsigned int, QpMap>> coarsen_map;
    std::vector<std::vector<QpMap>> & refinement_map =
        _elem_type_to_child_side_refinement_map[elem.type()][child_pair];
    findAdaptivityQpMaps(
        &elem, qrule, qrule_face, refinement_map, coarsen_map, parent_side, child, child_side);
  }
}

buildSideList()

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

(

)

Calls BoundaryInfo::build_side_list(), returns a std::vector of (elem-id, side-id, bc-id) tuples.

Definition at line 3089 of file MooseMesh.C.

Referenced by InterfaceQpUserObjectBase::initialSetup().

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

buildTypedMesh()

template<typename T >

std::unique_ptr< T > MooseMesh::buildTypedMesh

(

unsigned int

dim = libMesh::invalid_uint

)

Shortcut method to construct a unique pointer to a libMesh mesh instance.

The created derived-from-MeshBase object will have its allow_remote_element_removal flag set to whatever our value is. We will also attach any geometric RelationshipManagers that have been requested by our simulation objects to the MeshBase object. If the parameter dim is not provided, then its value will be taken from the input file mesh block.

Definition at line 2133 of file MooseMesh.h.

Referenced by MeshGenerator::buildDistributedMesh(), and MeshGenerator::buildReplicatedMesh().

{
  // If the requested mesh type to build doesn't match our current value for _use_distributed_mesh,
  // then we need to make sure to make our state consistent because other objects, like the periodic
  // boundary condition action, will be querying isDistributedMesh()
  if (_use_distributed_mesh != std::is_same<T, libMesh::DistributedMesh>::value)
  {
    if (getMeshPtr())
      mooseError("A MooseMesh object is being asked to build a libMesh mesh that is a different "
                 "parallel type than the libMesh mesh that it wraps. This is not allowed. Please "
                 "create another MooseMesh object to wrap the new libMesh mesh");
    setParallelType(MeshType<T>::value);
  }

  if (dim == libMesh::invalid_uint)
  {
    if (isParamValid("dim"))
      dim = getParam<MooseEnum>("dim");
    else
      // Legacy selection of the default for the 'dim' parameter
      dim = 1;
  }

  auto mesh = std::make_unique<T>(_communicator, dim);

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

  mesh->allow_remote_element_removal(_allow_remote_element_removal);
  _app.attachRelationshipManagers(*mesh, *this);

  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!");
    mesh->partitioner() = _custom_partitioner->clone();
  }
  else
    setPartitionerHelper(mesh.get());

  return mesh;
}

cacheChangedLists()

void MooseMesh::cacheChangedLists

(

)

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

Definition at line 940 of file MooseMesh.C.

Referenced by FEProblemBase::meshChanged().

{
  TIME_SECTION("cacheChangedLists", 5, "Caching Changed Lists");

  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 = std::make_unique<ConstElemPointerRange>(cclt._refined_elements.begin(),
                                                              cclt._refined_elements.end());
  _coarsened_elements = std::make_unique<ConstElemPointerRange>(cclt._coarsened_elements.begin(),
                                                                cclt._coarsened_elements.end());
  _coarsened_element_children = cclt._coarsened_element_children;
}

cacheFaceInfoVariableOwnership()

void MooseMesh::cacheFaceInfoVariableOwnership

(

)

const

Cache if variables live on the elements connected by the FaceInfo objects.

The following paragraph of code assigns the VarFaceNeighbors

1. The face is an internal face of this variable if it is defined on the elem and neighbor subdomains
2. The face is an invalid face of this variable if it is neither defined on the elem nor the neighbor subdomains
3. If not 1. or 2. then this is a boundary for this variable and the else clause applies

Definition at line 4021 of file MooseMesh.C.

Referenced by setupFiniteVolumeMeshData().

{
  mooseAssert(
      !Threads::in_threads,
      "Performing writes to faceInfo variable association maps. This must be done unthreaded!");

  const unsigned int num_eqs = _app.feProblem().es().n_systems();

  auto face_lambda = [this](const SubdomainID elem_subdomain_id,
                            const SubdomainID neighbor_subdomain_id,
                            SystemBase & sys,
                            std::vector<std::vector<FaceInfo::VarFaceNeighbors>> & face_type_vector)
  {
    face_type_vector[sys.number()].resize(sys.nVariables(), FaceInfo::VarFaceNeighbors::NEITHER);
    const auto & variables = sys.getVariables(0);

    for (const auto & var : variables)
    {
      const unsigned int var_num = var->number();
      const unsigned int sys_num = var->sys().number();
      std::set<SubdomainID> var_subdomains = var->blockIDs();
      bool var_defined_elem = var_subdomains.find(elem_subdomain_id) != var_subdomains.end();
      bool var_defined_neighbor =
          var_subdomains.find(neighbor_subdomain_id) != var_subdomains.end();
      if (var_defined_elem && var_defined_neighbor)
        face_type_vector[sys_num][var_num] = FaceInfo::VarFaceNeighbors::BOTH;
      else if (!var_defined_elem && !var_defined_neighbor)
        face_type_vector[sys_num][var_num] = FaceInfo::VarFaceNeighbors::NEITHER;
      else
      {
        // this is a boundary face for this variable, set elem or neighbor
        if (var_defined_elem)
          face_type_vector[sys_num][var_num] = FaceInfo::VarFaceNeighbors::ELEM;
        else if (var_defined_neighbor)
          face_type_vector[sys_num][var_num] = FaceInfo::VarFaceNeighbors::NEIGHBOR;
        else
          mooseError("Should never get here");
      }
    }
  };

  // We loop through the faces and check if they are internal, boundary or external to
  // the variables in the problem
  for (FaceInfo & face : _all_face_info)
  {
    const SubdomainID elem_subdomain_id = face.elemSubdomainID();
    const SubdomainID neighbor_subdomain_id = face.neighborSubdomainID();

    auto & face_type_vector = face.faceType();

    face_type_vector.clear();
    face_type_vector.resize(num_eqs);

    // First, we check the variables in the solver systems (linear/nonlinear)
    for (const auto i : make_range(_app.feProblem().numSolverSystems()))
      face_lambda(elem_subdomain_id,
                  neighbor_subdomain_id,
                  _app.feProblem().getSolverSystem(i),
                  face_type_vector);

    // Then we check the variables in the auxiliary system
    face_lambda(elem_subdomain_id,
                neighbor_subdomain_id,
                _app.feProblem().getAuxiliarySystem(),
                face_type_vector);
  }
}

cacheFVElementalDoFs()

void MooseMesh::cacheFVElementalDoFs

(

)

const

Cache the DoF indices for FV variables on each element.

These indices are used to speed up the setup loops of finite volume systems.

Definition at line 4099 of file MooseMesh.C.

Referenced by setupFiniteVolumeMeshData().

{
  mooseAssert(!Threads::in_threads,
              "Performing writes to elemInfo dof indices. This must be done unthreaded!");

  auto elem_lambda = [](const ElemInfo & elem_info,
                        SystemBase & sys,
                        std::vector<std::vector<dof_id_type>> & dof_vector)
  {
    if (sys.nFVVariables())
    {
      dof_vector[sys.number()].resize(sys.nVariables(), libMesh::DofObject::invalid_id);
      const auto & variables = sys.getVariables(0);

      for (const auto & var : variables)
        if (var->isFV())
        {
          const auto & var_subdomains = var->blockIDs();

          // We will only cache for FV variables and if they live on the current subdomain
          if (var_subdomains.find(elem_info.subdomain_id()) != var_subdomains.end())
          {
            std::vector<dof_id_type> indices;
            var->dofMap().dof_indices(elem_info.elem(), indices, var->number());
            mooseAssert(indices.size() == 1, "We expect to have only one dof per element!");
            dof_vector[sys.number()][var->number()] = indices[0];
          }
        }
    }
  };

  const unsigned int num_eqs = _app.feProblem().es().n_systems();

  // We loop through the elements in the mesh and cache the dof indices
  // for the corresponding variables.
  for (auto & ei_pair : _elem_to_elem_info)
  {
    auto & elem_info = ei_pair.second;
    auto & dof_vector = elem_info.dofIndices();

    dof_vector.clear();
    dof_vector.resize(num_eqs);

    // First, we cache the dof indices for the variables in the solver systems (linear, nonlinear)
    for (const auto i : make_range(_app.feProblem().numSolverSystems()))
      elem_lambda(elem_info, _app.feProblem().getSolverSystem(i), dof_vector);

    // Then we cache the dof indices for the auxvariables
    elem_lambda(elem_info, _app.feProblem().getAuxiliarySystem(), dof_vector);
  }
}

cacheInfo()

void MooseMesh::cacheInfo ( )

protected

Definition at line 1457 of file MooseMesh.C.

Referenced by update().

{
  TIME_SECTION("cacheInfo", 3);

  _has_lower_d = false;
  _sub_to_data.clear();
  _neighbor_subdomain_boundary_ids.clear();
  _block_node_list.clear();
  _higher_d_elem_side_to_lower_d_elem.clear();
  _lower_d_elem_to_higher_d_elem_side.clear();
  _lower_d_interior_blocks.clear();
  _lower_d_boundary_blocks.clear();

  auto & mesh = getMesh();

  // TODO: Thread this!
  for (const auto & elem : mesh.element_ptr_range())
  {
    const Elem * ip_elem = elem->interior_parent();

    if (ip_elem)
    {
      if (elem->active())
        _sub_to_data[elem->subdomain_id()].is_lower_d = true;
      unsigned int ip_side = ip_elem->which_side_am_i(elem);

      // For some grid sequencing tests: ip_side == libMesh::invalid_uint
      if (ip_side != libMesh::invalid_uint)
      {
        auto pair = std::make_pair(ip_elem, ip_side);
        _higher_d_elem_side_to_lower_d_elem.insert(
            std::pair<std::pair<const Elem *, unsigned short int>, const Elem *>(pair, elem));
        _lower_d_elem_to_higher_d_elem_side.insert(
            std::pair<const Elem *, unsigned short int>(elem, ip_side));

        auto id = elem->subdomain_id();
        if (ip_elem->neighbor_ptr(ip_side))
        {
          if (mesh.subdomain_name(id).find("INTERNAL_SIDE_LOWERD_SUBDOMAIN_") != std::string::npos)
            _lower_d_interior_blocks.insert(id);
        }
        else
        {
          if (mesh.subdomain_name(id).find("BOUNDARY_SIDE_LOWERD_SUBDOMAIN_") != std::string::npos)
            _lower_d_boundary_blocks.insert(id);
        }
      }
    }

    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());
    }
  }
  _communicator.set_union(_lower_d_interior_blocks);
  _communicator.set_union(_lower_d_boundary_blocks);

  for (const auto & elem : mesh.active_local_element_ptr_range())
  {
    SubdomainID subdomain_id = elem->subdomain_id();
    auto & sub_data = _sub_to_data[subdomain_id];
    for (unsigned int side = 0; side < elem->n_sides(); side++)
    {
      std::vector<BoundaryID> boundary_ids = getBoundaryIDs(elem, side);
      sub_data.boundary_ids.insert(boundary_ids.begin(), boundary_ids.end());

      Elem * neig = elem->neighbor_ptr(side);
      if (neig)
      {
        _neighbor_subdomain_boundary_ids[neig->subdomain_id()].insert(boundary_ids.begin(),
                                                                      boundary_ids.end());
        SubdomainID neighbor_subdomain_id = neig->subdomain_id();
        if (neighbor_subdomain_id != subdomain_id)
          sub_data.neighbor_subs.insert(neighbor_subdomain_id);
      }
    }
  }

  for (const auto blk_id : _mesh_subdomains)
  {
    auto & sub_data = _sub_to_data[blk_id];
    _communicator.set_union(sub_data.neighbor_subs);
    _communicator.set_union(sub_data.boundary_ids);
    _communicator.max(sub_data.is_lower_d);
    if (sub_data.is_lower_d)
      _has_lower_d = true;
    _communicator.set_union(_neighbor_subdomain_boundary_ids[blk_id]);
  }
}

callMooseError() [1/2]

void MooseBase::callMooseError ( std::string  msg, const bool  with_prefix, const hit::Node *  node = nullptr  ) const

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix

Definition at line 105 of file MooseBase.C.

Referenced by InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

{
  callMooseError(&_app, _pars, msg, with_prefix, node);
}

callMooseError() [2/2]

void MooseBase::callMooseError ( MooseApp *const  app, const InputParameters &  params, std::string  msg, const bool  with_prefix, const hit::Node *  node  )

staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters

app	The app pointer (if available); adds multiapp context and clears the console
params	The parameters, needed to obtain object information
msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix

Definition at line 113 of file MooseBase.C.

{
  if (!node)
    node = MooseBase::getHitNode(params);

  std::string multiapp_prefix = "";
  if (app)
  {
    if (!app->isUltimateMaster())
      multiapp_prefix = app->name();
    app->getOutputWarehouse().mooseConsole();
  }

  if (with_prefix)
    // False here because the hit context will get processed by the node
    msg = messagePrefix(params, false) + msg;

  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node);
}

changeBoundaryId() [1/2]

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

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

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

Definition at line 2812 of file MooseMesh.C.

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

changeBoundaryId() [2/2]

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

static

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.

checkCoordinateSystems()

void MooseMesh::checkCoordinateSystems

(

)

Performs a sanity check for every element in the mesh.

If an element dimension is 3 and the corresponding coordinate system is RZ, then this will error. If an element dimension is greater than 1 and the corresponding system is RPSHERICAL then this will error

Definition at line 4387 of file MooseMesh.C.

Referenced by FEProblemBase::checkCoordinateSystems().

{
  for (const auto & elem : getMesh().element_ptr_range())
  {
    SubdomainID sid = elem->subdomain_id();
    if (_coord_sys[sid] == Moose::COORD_RZ && elem->dim() == 3)
      mooseError("An RZ coordinate system was requested for subdomain " + Moose::stringify(sid) +
                 " which contains 3D elements.");
    if (_coord_sys[sid] == Moose::COORD_RSPHERICAL && elem->dim() > 1)
      mooseError("An RSPHERICAL coordinate system was requested for subdomain " +
                 Moose::stringify(sid) + " which contains 2D or 3D elements.");
  }
}

checkDuplicateSubdomainNames()

void MooseMesh::checkDuplicateSubdomainNames ( )

private

Loop through all subdomain IDs and check if there is name duplication used for the subdomains with same ID.

Throw out an error if any name duplication is found.

Definition at line 4417 of file MooseMesh.C.

Referenced by prepare().

{
  std::map<SubdomainName, SubdomainID> subdomain;
  for (const auto & sbd_id : _mesh_subdomains)
  {
    std::string sub_name = getSubdomainName(sbd_id);
    if (!sub_name.empty() && subdomain.count(sub_name) > 0)
      mooseError("The subdomain name ",
                 sub_name,
                 " is used for both subdomain with ID=",
                 subdomain[sub_name],
                 " and ID=",
                 sbd_id,
                 ", Please rename one of them!");
    else
      subdomain[sub_name] = sbd_id;
  }
}

clearQuadratureNodes()

void MooseMesh::clearQuadratureNodes

(

)

Clear out any existing quadrature nodes.

Most likely called before re-adding them.

Definition at line 1730 of file MooseMesh.C.

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

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

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

clone()

MooseMesh & MooseMesh::clone ( ) const

virtual

Clone method.

Allocates memory you are responsible to clean up.

Definition at line 2872 of file MooseMesh.C.

Referenced by TiledMesh::buildMesh().

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

coarsenedElementChildren()

const std::vector< const Elem * > & MooseMesh::coarsenedElementChildren

(

const Elem *

elem

)

const

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

Parameters

elem	Pointer to the parent element that was coarsened to.

Returns

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

Definition at line 970 of file MooseMesh.C.

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

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

coarsenedElementRange()

ConstElemPointerRange * MooseMesh::coarsenedElementRange

(

)

const

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

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

Definition at line 964 of file MooseMesh.C.

Referenced by FEProblemBase::meshChanged().

{
  return _coarsened_elements.get();
}

computeFiniteVolumeCoords()

void MooseMesh::computeFiniteVolumeCoords

(

)

const

Compute the face coordinate value for all FaceInfo and ElemInfo objects.

'Coordinate' here means a coordinate value associated with the coordinate system. For Cartesian coordinate systems, 'coordinate' is simply '1'; in RZ, '2*pi*r', and in spherical, '4*pi*r^2'

Definition at line 3957 of file MooseMesh.C.

Referenced by setupFiniteVolumeMeshData().

{
  if (_finite_volume_info_dirty)
    mooseError("Trying to compute face- and elem-info coords when the information is dirty");

  for (auto & fi : _all_face_info)
  {
    // get elem & neighbor elements, and set subdomain ids
    const SubdomainID elem_subdomain_id = fi.elemSubdomainID();
    const SubdomainID neighbor_subdomain_id = fi.neighborSubdomainID();

    coordTransformFactor(
        *this, elem_subdomain_id, fi.faceCentroid(), fi.faceCoord(), neighbor_subdomain_id);
  }

  for (auto & ei : _elem_to_elem_info)
    coordTransformFactor(
        *this, ei.second.subdomain_id(), ei.second.centroid(), ei.second.coordFactor());
}

computeMaxPerElemAndSide()

void MooseMesh::computeMaxPerElemAndSide ( )

private

Compute the maximum numbers per element and side.

Definition at line 1086 of file MooseMesh.C.

Referenced by init().

{
  auto & mesh = getMesh();

  _max_sides_per_elem = 0;
  _max_nodes_per_elem = 0;
  _max_nodes_per_side = 0;

  for (auto & elem : as_range(mesh.local_elements_begin(), mesh.local_elements_end()))
  {
    _max_sides_per_elem = std::max(_max_sides_per_elem, elem->n_sides());
    _max_nodes_per_elem = std::max(_max_nodes_per_elem, elem->n_nodes());

    for (unsigned int side = 0; side < elem->n_sides(); ++side)
      _max_nodes_per_side = std::max(_max_nodes_per_side, elem->side_ptr(side)->n_nodes());
  }

  mesh.comm().max(_max_sides_per_elem);
  mesh.comm().max(_max_nodes_per_elem);
  mesh.comm().max(_max_nodes_per_side);
}

connectControllableParams()

void MooseBase::connectControllableParams ( const std::string &  parameter, const std::string &  object_type, const std::string &  object_name, const std::string &  object_parameter  ) const

inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters

parameter	Name of the controllable parameter of this action
object_type	Type of the object added by this action.
object_name	Name of the object added by this action.
object_parameter	Name of the parameter of the object.

Definition at line 77 of file MooseBase.C.

{
  auto & factory = _app.getFactory();
  auto & ip_warehouse = _app.getInputParameterWarehouse();

  MooseObjectParameterName primary_name(uniqueName(), parameter);
  const auto base_type = factory.getValidParams(object_type).getBase();
  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);

  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
  for (const auto & tag : tags)
  {
    if (!tag.empty())
    {
      // Only adds the parameter with the different control tags if the derived class
      // properly registers the parameter to its own syntax
      MooseObjectParameterName tagged_name(tag, name(), parameter);
      ip_warehouse.addControllableParameterConnection(
          tagged_name, secondary_name, /*error_on_empty=*/false);
    }
  }
}

coordTransform()

MooseAppCoordTransform & MooseMesh::coordTransform ( )

inline

Returns

the coordinate transformation object that describes how to transform this problem's coordinate system into the canonical/reference coordinate system

Definition at line 1931 of file MooseMesh.h.

Referenced by FEProblemBase::checkProblemIntegrity(), and FEProblemBase::coordTransform().

{
  mooseAssert(_coord_transform, "The coordinate transformation object is null.");
  return *_coord_transform;
}

declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protectedinherited

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 283 of file Restartable.h.

{
  auto & data_ptr =
      declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
  return Restartable::ManagedValue<T>(data_ptr);
}

declareRecoverableData()

template<typename T , typename... Args>

T & Restartable::declareRecoverableData ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "recoverable" 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)
args	Arguments to forward to the constructor of the data

Definition at line 358 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);

  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);

  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableData()

template<typename T , typename... Args>

T & Restartable::declareRestartableData ( const std::string &  data_name, Args &&...  args  )

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)
args	Arguments to forward to the constructor of the data

Definition at line 276 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

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)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 301 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
}

declareRestartableDataWithObjectName()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectName ( const std::string &  data_name, const std::string &  object_name, Args &&...  args  )

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.
args	Arguments to forward to the constructor of the data

Definition at line 330 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(
      data_name, object_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectNameWithContext ( const std::string &  data_name, const std::string &  object_name, void *  context, Args &&...  args  )

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
args	Arguments to forward to the constructor of the data

Definition at line 340 of file Restartable.h.

{
  std::string old_name = _restartable_name;

  _restartable_name = object_name;

  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);

  _restartable_name = old_name;

  return value;
}

deleteRemoteElements()

void MooseMesh::deleteRemoteElements

(

)

Delete remote elements.

Definition at line 4009 of file MooseMesh.C.

{
  _allow_remote_element_removal = true;
  if (!_mesh)
    mooseError("Cannot delete remote elements because we have not yet attached a MeshBase");

  _mesh->allow_remote_element_removal(true);

  _mesh->delete_remote_elements();
}

detectOrthogonalDimRanges()

bool MooseMesh::detectOrthogonalDimRanges

(

Real

tol = 1e-6

)

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

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

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

Definition at line 1975 of file MooseMesh.C.

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

{
  TIME_SECTION("detectOrthogonalDimRanges", 5);

  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 (const auto i : make_range(Moose::dim))
    {
      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 (const auto i : make_range(Moose::dim))
    {
      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 (const auto i : make_range(Moose::dim))
  {
    _bounds[i].resize(2);
    _bounds[i][MIN] = min[i];
    _bounds[i][MAX] = max[i];
  }

  return _regular_orthogonal_mesh;
}

detectPairedSidesets()

void MooseMesh::detectPairedSidesets ( )

private

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

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

Definition at line 2049 of file MooseMesh.C.

Referenced by getPairedBoundaryMapping().

{
  TIME_SECTION("detectPairedSidesets", 5);

  // 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<libMesh::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<libMesh::QGauss>(new libMesh::QGauss(side_dim, CONSTANT));

    // A first-order Lagrange FE for the face.
    fe_faces[side_dim] = FEBase::build(side_dim + 1, FEType(FIRST, libMesh::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 a distributed mesh, boundaries may be distributed as well. We therefore collect information
  // from everyone. If the mesh is already serial, then there is no need to do an allgather. Note
  // that this is just going to gather information about what the periodic bc ids are. We are not
  // gathering any remote elements or anything like that. It's just that the GhostPointNeighbors
  // ghosting functor currently relies on the fact that every process agrees on whether we have
  // periodic boundaries; every process that thinks there are periodic boundaries will call
  // MeshBase::sub_point_locator which makes a parallel_object_only() assertion (right or wrong). So
  // we all need to go there (or not go there)
  if (_use_distributed_mesh && !_mesh->is_serial())
  {
    // Pack all data together so that we send them via one communication
    // pair: boundary side --> boundary ids.
    std::vector<std::pair<boundary_id_type, boundary_id_type>> vecdata;
    //  We check boundaries on all dimensions
    for (unsigned side_dim = 0; side_dim < dim; ++side_dim)
    {
      // "6" means: we have at most 6 boundaries. It is true for generated simple mesh
      // "detectPairedSidesets" is designed for only simple meshes
      for (auto bd = minus_x_ids[side_dim].begin(); bd != minus_x_ids[side_dim].end(); bd++)
        vecdata.emplace_back(side_dim * 6 + 0, *bd);

      for (auto bd = plus_x_ids[side_dim].begin(); bd != plus_x_ids[side_dim].end(); bd++)
        vecdata.emplace_back(side_dim * 6 + 1, *bd);

      for (auto bd = minus_y_ids[side_dim].begin(); bd != minus_y_ids[side_dim].end(); bd++)
        vecdata.emplace_back(side_dim * 6 + 2, *bd);

      for (auto bd = plus_y_ids[side_dim].begin(); bd != plus_y_ids[side_dim].end(); bd++)
        vecdata.emplace_back(side_dim * 6 + 3, *bd);

      for (auto bd = minus_z_ids[side_dim].begin(); bd != minus_z_ids[side_dim].end(); bd++)
        vecdata.emplace_back(side_dim * 6 + 4, *bd);

      for (auto bd = plus_z_ids[side_dim].begin(); bd != plus_z_ids[side_dim].end(); bd++)
        vecdata.emplace_back(side_dim * 6 + 5, *bd);
    }

    _communicator.allgather(vecdata, false);

    // Unpack data, and add them into minus/plus_x/y_ids
    for (auto pair = vecdata.begin(); pair != vecdata.end(); pair++)
    {
      // Convert data from the long vector, and add data to separated sets
      auto side_dim = pair->first / 6;
      auto side = pair->first % 6;

      switch (side)
      {
        case 0:
          minus_x_ids[side_dim].insert(pair->second);
          break;
        case 1:
          plus_x_ids[side_dim].insert(pair->second);
          break;
        case 2:
          minus_y_ids[side_dim].insert(pair->second);
          break;
        case 3:
          plus_y_ids[side_dim].insert(pair->second);
          break;
        case 4:
          minus_z_ids[side_dim].insert(pair->second);
          break;
        case 5:
          plus_z_ids[side_dim].insert(pair->second);
          break;
        default:
          mooseError("Unknown boundary side ", side);
      }
    }

  } // end if (_use_distributed_mesh && !_need_ghost_ghosted_boundaries)

  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())));
    else
      mooseInfoRepeated(
          "For side dimension " + std::to_string(side_dim) +
          " we did not find paired boundaries (sidesets) in X due to the presence of " +
          std::to_string(minus_x_ids[side_dim].size()) + " -X normal and " +
          std::to_string(plus_x_ids[side_dim].size()) + " +X normal boundaries.");

    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())));
    else
      mooseInfoRepeated(
          "For side dimension " + std::to_string(side_dim) +
          " we did not find paired boundaries (sidesets) in Y due to the presence of " +
          std::to_string(minus_y_ids[side_dim].size()) + " -Y normal and " +
          std::to_string(plus_y_ids[side_dim].size()) + " +Y normal boundaries.");

    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())));
    else
      mooseInfoRepeated(
          "For side dimension " + std::to_string(side_dim) +
          " we did not find paired boundaries (sidesets) in Z due to the presence of " +
          std::to_string(minus_z_ids[side_dim].size()) + " -Z normal and " +
          std::to_string(plus_z_ids[side_dim].size()) + " +Z normal boundaries.");
  }
}

determineUseDistributedMesh()

void MooseMesh::determineUseDistributedMesh

(

)

Determine whether to use a distributed mesh.

Should be called during construction

Definition at line 2878 of file MooseMesh.C.

Referenced by MooseMesh(), and setParallelType().

{
  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 || _is_split)
        _parallel_type_overridden = true;
      _use_distributed_mesh = false;
      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 || _is_split)
    _use_distributed_mesh = true;
}

dimension()

unsigned int MooseMesh::dimension ( ) const

virtual

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

Reimplemented in MFEMMesh.

Definition at line 2980 of file MooseMesh.C.

Referenced by addPeriodicVariable(), AddPeriodicBCAction::autoTranslationBoundaries(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), NodalPatchRecoveryBase::evaluateBasisFunctions(), ElementSubdomainModifierBase::extrapolatePolynomial(), FunctionPeriodicBoundary::FunctionPeriodicBoundary(), getPairedBoundaryMapping(), PointVariableSamplerBase::initialize(), BlockRestrictable::initializeBlockRestrictable(), SystemBase::initialSetup(), isTranslatedPeriodic(), minPeriodicVector(), PenetrationLocator::PenetrationLocator(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), SidesetInfoVectorPostprocessor::SidesetInfoVectorPostprocessor(), and Moose::PetscSupport::storePetscOptions().

{
  return getMesh().mesh_dimension();
}

dimensionWidth()

Real MooseMesh::dimensionWidth

(

unsigned int

component

)

const

Returns the width of the requested dimension.

Definition at line 2243 of file MooseMesh.C.

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

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

doingPRefinement() [1/2]

void MooseMesh::doingPRefinement ( bool  doing_p_refinement )

inline

Indicate whether the kind of adaptivity we're doing is p-refinement.

Definition at line 1365 of file MooseMesh.h.

Referenced by SubProblem::doingPRefinement(), Adaptivity::init(), FEProblemBase::init(), ProjectMaterialProperties::onBoundary(), CacheChangedListsThread::onElement(), and ProjectMaterialProperties::onElement().

{ _doing_p_refinement = doing_p_refinement; }

doingPRefinement() [2/2]

bool MooseMesh::doingPRefinement ( ) const

inline

Query whether we have p-refinement.

Definition at line 1370 of file MooseMesh.h.

Referenced by buildRefinementAndCoarseningMaps().

{ return _doing_p_refinement; }

effectiveSpatialDimension()

unsigned int MooseMesh::effectiveSpatialDimension ( ) const

virtual

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

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

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

elem() [1/2]

Elem * MooseMesh::elem ( const dof_id_type  i )

virtual

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

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

Definition at line 3179 of file MooseMesh.C.

Referenced by addQuadratureNode(), buildCoarseningMap(), buildElemIDInfo(), buildFiniteVolumeInfo(), buildHRefinementAndCoarseningMaps(), buildLowerDMesh(), ConcentricCircleMesh::buildMesh(), AnnularMesh::buildMesh(), RinglebMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), buildPRefinementAndCoarseningMaps(), buildRefinementMap(), cacheInfo(), checkCoordinateSystems(), coarsenedElementChildren(), computeMaxPerElemAndSide(), detectPairedSidesets(), findAdaptivityQpMaps(), getBlocksMaxDimension(), getCoarseningMap(), getElemIDMapping(), getHigherDSide(), getLowerDElem(), getPCoarseningMap(), getPCoarseningMapHelper(), getPCoarseningSideMap(), getPRefinementMap(), getPRefinementMapHelper(), getPRefinementSideMap(), getQuadratureNode(), getRefinementMap(), ghostGhostedBoundaries(), nodeToActiveSemilocalElemMap(), nodeToElemMap(), prepare(), sideWithBoundaryID(), update(), and updateActiveSemiLocalNodeRange().

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

elem() [2/2]

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

virtual

Definition at line 3186 of file MooseMesh.C.

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

elemInfo()

const ElemInfo & MooseMesh::elemInfo

(

const dof_id_type

id

)

const

Accessor for the elemInfo object for a given element ID.

Definition at line 3951 of file MooseMesh.C.

Referenced by MooseLinearVariableFV< Real >::evaluate(), and MooseLinearVariableFV< Real >::evaluateGradient().

{
  return libmesh_map_find(_elem_to_elem_info, id);
}

elemInfoVector()

const std::vector<const ElemInfo *>& MooseMesh::elemInfoVector ( ) const

inline

Accessor for the element info objects owned by this process.

Definition at line 1199 of file MooseMesh.h.

{ return _elem_info; }

elemPtr() [1/2]

Elem * MooseMesh::elemPtr ( const dof_id_type  i )

virtual

Definition at line 3193 of file MooseMesh.C.

Referenced by FEProblemBase::addGhostedElem(), SystemBase::augmentSendList(), NodalPatchRecoveryAuxBase::blockRestrictElements(), NodalPatchRecovery::compute(), BoundaryMarker::computeElementMarker(), ProjectionAux::computeValue(), NodalPatchRecoveryAuxBase::computeValue(), elem(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), ActivateElementsUserObjectBase::execute(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), NearestNodeLocator::findNodes(), ElementSubdomainModifierBase::findReinitializedElemsAndNodes(), ElementSubdomainModifierBase::gatherMovingBoundaryChanges(), ElementSubdomainModifierBase::gatherPatchElements(), NodalPatchRecoveryBase::gatherRequestList(), NodalPatchRecoveryBase::getCoefficients(), NodeElemConstraint::getConnectedDofIndices(), NodeFaceConstraint::getConnectedDofIndices(), FEProblemBase::getDiracElements(), PenetrationThread::getInfoForFacesWithCommonNodes(), ActivateElementsUserObjectBase::getNewlyActivatedElementRange(), ActivateElementsUserObjectBase::getNewlyActivatedNodeRange(), DiracKernelBase::hasPointsOnElem(), ActivateElementsUserObjectBase::isNewlyActivated(), Moose::Mortar::loopOverMortarSegments(), ElementSubdomainModifierBase::nodeIsNewlyReinitialized(), SecondaryNeighborhoodThread::operator()(), PenetrationThread::operator()(), FEProblemBase::prepareFace(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemFaceRef(), FEProblemBase::reinitElemNeighborAndLowerD(), ElementSubdomainModifierBase::reinitializedElemRange(), FEProblemBase::reinitLowerDElem(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNeighborFaceRef(), NonlinearSystemBase::reinitNodeFace(), FEProblemBase::setCurrentLowerDElem(), ElementSubdomainModifierBase::storeOverriddenDofValues(), and NearestNodeLocator::updatePatch().

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

elemPtr() [2/2]

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

virtual

Definition at line 3199 of file MooseMesh.C.

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

elemTypes()

MooseEnum MooseMesh::elemTypes ( )

static

returns MooseMesh element type options

Definition at line 3986 of file MooseMesh.C.

{
  MooseEnum elemTypes(
      "EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 "
      "PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14");
  return elemTypes;
}

enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

Referenced by EigenKernel::enabled().

{ return _enabled; }

errorIfDistributedMesh()

void MooseMesh::errorIfDistributedMesh

(

std::string

name

)

const

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

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

See, for example, the NodalVariableValue class.

Definition at line 3697 of file MooseMesh.C.

Referenced by BoundaryPreservedMarker::BoundaryPreservedMarker(), ElementsAlongLine::ElementsAlongLine(), ElementsAlongPlane::ElementsAlongPlane(), FunctorPositions::initialize(), FunctorTimes::initialize(), IntersectionPointsAlongLine::IntersectionPointsAlongLine(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodeElemConstraintBase::NodeElemConstraintBase(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), PatternedMesh::PatternedMesh(), StitchedMesh::StitchedMesh(), and TiledMesh::TiledMesh().

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

errorPrefix()

std::string MooseBase::errorPrefix ( const std::string &  ) const

inlineinherited

Deprecated message prefix; the error type is no longer used.

Definition at line 264 of file MooseBase.h.

{ return messagePrefix(); }

faceInfo() [1/2]

const std::vector< const FaceInfo * > & MooseMesh::faceInfo ( ) const

inline

Accessor for local FaceInfo objects.

Definition at line 2216 of file MooseMesh.h.

Referenced by LayeredSideDiffusiveFluxAverage::computeQpIntegral(), SideIntegralVariableUserObject::computeQpIntegral(), ParsedAux::computeValue(), InterfaceUserObject::execute(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), SideUserObject::getFaceInfos(), and InternalSideUserObject::getFaceInfos().

{
  return _face_info;
}

faceInfo() [2/2]

const FaceInfo* MooseMesh::faceInfo	(	const Elem *	elem,
		unsigned int	side
	)		const

Accessor for the local FaceInfo object on the side of one element. Returns null if ghosted.

findAdaptivityQpMaps()

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

private

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

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

There are 3 cases here:

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

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

Parameters

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

Definition at line 2671 of file MooseMesh.C.

Referenced by buildCoarseningMap(), and buildRefinementMap().

{
  TIME_SECTION("findAdaptivityQpMaps", 5);

  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 (locations in *physical* space)
  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;

  libMesh::FEMap::inverse_map(elem->dim(), elem, *q_points, parent_ref_points);
  libMesh::MeshRefinement mesh_refinement(mesh);
  mesh_refinement.uniformly_refine(1);

  // A map from the child element index to the locations of all the child's quadrature points in
  // *reference* space. Note that we use a map here instead of a vector because the caller can
  // pass an explicit child index. We are not guaranteed to have a sequence from [0, n_children)
  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;

    libMesh::FEMap::inverse_map(elem->dim(), 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;
      }
    }
  }
}

flagInvalidSolutionInternal()

template<bool warning>

template void SolutionInvalidInterface::flagInvalidSolutionInternal< false > ( const InvalidSolutionID  invalid_solution_id ) const

protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

{
  mooseAssert(
      warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
      "Inconsistent warning flag");
  auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
  if constexpr (!warning)
    if (!_si_problem || _si_problem->immediatelyPrintInvalidSolution())
      solution_invalidity.printDebug(invalid_solution_id);
  return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
}

freeBndElems()

void MooseMesh::freeBndElems ( )

protected

Definition at line 417 of file MooseMesh.C.

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

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

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

  _bnd_elem_ids.clear();
  _bnd_elem_range.reset();
}

freeBndNodes()

void MooseMesh::freeBndNodes ( )

protected

Definition at line 398 of file MooseMesh.C.

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

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

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

  _node_set_nodes.clear();

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

  _bnd_node_ids.clear();
  _bnd_node_range.reset();
}

getActiveLocalElementRange()

ConstElemRange * MooseMesh::getActiveLocalElementRange

(

)

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

Definition at line 1288 of file MooseMesh.C.

Referenced by AuxiliarySystem::computeElementalVarsHelper(), FEProblemBase::computeIndicators(), FEProblemBase::computeMarkers(), FEProblemBase::computeUserObjectsInternal(), PointwiseRenormalizeVector::execute(), ElementSubdomainModifierBase::gatherPatchElements(), FEProblemBase::getCurrentAlgebraicElementRange(), FEProblemBase::initialSetup(), meshChanged(), DOFMapOutput::output(), MeshInfo::possiblyAddSubdomainInfo(), FEProblemBase::projectSolution(), SystemBase::setVariableGlobalDoFs(), FixedPointSolve::solve(), TransientMultiApp::solveStep(), ElementSubdomainModifierBase::storeOverriddenDofValues(), updateActiveSemiLocalNodeRange(), Adaptivity::updateErrorVectors(), FEProblemBase::updateMaxQps(), and SystemBase::zeroVariables().

{
  if (!_active_local_elem_range)
  {
    TIME_SECTION("getActiveLocalElementRange", 5);

    _active_local_elem_range = std::make_unique<ConstElemRange>(
        getMesh().active_local_elements_begin(), getMesh().active_local_elements_end(), GRAIN_SIZE);
  }

  return _active_local_elem_range.get();
}

getActiveNodeRange()

NodeRange * MooseMesh::getActiveNodeRange

(

)

Definition at line 1302 of file MooseMesh.C.

Referenced by VariableCondensationPreconditioner::getDofToCondense(), and meshChanged().

{
  if (!_active_node_range)
  {
    TIME_SECTION("getActiveNodeRange", 5);

    _active_node_range = std::make_unique<NodeRange>(
        getMesh().active_nodes_begin(), getMesh().active_nodes_end(), GRAIN_SIZE);
  }

  return _active_node_range.get();
}

getActiveSemiLocalNodeRange()

SemiLocalNodeRange * MooseMesh::getActiveSemiLocalNodeRange

(

)

const

Definition at line 1316 of file MooseMesh.C.

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

  return _active_semilocal_node_range.get();
}

getAllElemIDs()

std::set< dof_id_type > MooseMesh::getAllElemIDs

(

unsigned int

elem_id_index

)

const

Return all the unique element IDs for an extra element integer with its index.

Definition at line 1179 of file MooseMesh.C.

Referenced by getElemIDMapping().

{
  std::set<dof_id_type> unique_ids;
  for (auto & pair : _block_id_mapping[elem_id_index])
    for (auto & id : pair.second)
      unique_ids.insert(id);
  return unique_ids;
}

getAxisymmetricRadialCoord()

unsigned int MooseMesh::getAxisymmetricRadialCoord

(

)

const

Returns the desired radial direction for RZ coordinate transformation.

Returns

The coordinate direction for the radial direction

Definition at line 4374 of file MooseMesh.C.

Referenced by SubProblem::getAxisymmetricRadialCoord(), and ComputeLinearFVGreenGaussGradientVolumeThread::operator()().

{
  if (usingGeneralAxisymmetricCoordAxes())
    mooseError("getAxisymmetricRadialCoord() should not be called if "
               "setGeneralAxisymmetricCoordAxes() has been called.");

  if (_rz_coord_axis == 0)
    return 1; // if the rotation axis is x (0), then the radial direction is y (1)
  else
    return 0; // otherwise the radial direction is assumed to be x, i.e., the rotation axis is y
}

getBase()

const std::string& MooseBase::getBase ( ) const

inlineinherited

Returns

The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

{ return _pars.getBase(); }

getBlockConnectedBlocks()

const std::set< SubdomainID > & MooseMesh::getBlockConnectedBlocks

(

const SubdomainID

subdomain_id

)

const

Get the list of subdomains neighboring a given subdomain.

Parameters

subdomain_id

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

Returns

All subdomain IDs neighboring a given subdomain

Definition at line 3634 of file MooseMesh.C.

{
  const auto it = _sub_to_data.find(subdomain_id);

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

  return it->second.neighbor_subs;
}

getBlocksMaxDimension()

unsigned int MooseMesh::getBlocksMaxDimension

(

const std::vector< SubdomainName > &

blocks

)

const

Returns the maximum element dimension on the given blocks.

Definition at line 3001 of file MooseMesh.C.

Referenced by BlockRestrictable::initializeBlockRestrictable().

{
  const auto & mesh = getMesh();

  // Take a shortcut if possible
  if (const auto & elem_dims = mesh.elem_dimensions(); mesh.is_prepared() && elem_dims.size() == 1)
    return *elem_dims.begin();

  unsigned short dim = 0;
  const auto subdomain_ids = getSubdomainIDs(blocks);
  const std::set<SubdomainID> subdomain_ids_set(subdomain_ids.begin(), subdomain_ids.end());
  for (const auto & elem : mesh.active_subdomain_set_elements_ptr_range(subdomain_ids_set))
    dim = std::max(dim, elem->dim());

  // Get the maximumal globally
  _communicator.max(dim);
  return dim;
}

getBoundariesToActiveSemiLocalElemIds()

const std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > & MooseMesh::getBoundariesToActiveSemiLocalElemIds

(

)

const

Returns a map of boundaries to ids of elements on the boundary.

Definition at line 1375 of file MooseMesh.C.

Referenced by getBoundariesToElems().

{
  return _bnd_elem_ids;
}

getBoundariesToElems()

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

(

)

const

Returns a map of boundaries to ids of elements on the boundary.

Definition at line 1367 of file MooseMesh.C.

{
  mooseDeprecated("MooseMesh::getBoundariesToElems is deprecated, "
                  "use MooseMesh::getBoundariesToActiveSemiLocalElemIds");
  return getBoundariesToActiveSemiLocalElemIds();
}

getBoundaryActiveNeighborElemIds()

std::unordered_set< dof_id_type > MooseMesh::getBoundaryActiveNeighborElemIds

(

BoundaryID

bid

)

const

Return all ids of neighbors of elements which have a side which is part of a sideset.

Note that boundaries are sided, this is on the neighbor side. For the sideset side, use getBoundariesActiveLocalElemIds. Note that while the element is local and active, the neighbor is not guaranteed to be local, it could be ghosted. Note that if the neighbor is not ghosted, is a remote_elem, then it will not be included

Parameters

bid	the id of the sideset of interest

Definition at line 1392 of file MooseMesh.C.

{
  // Vector of boundary elems is updated every mesh update
  std::unordered_set<dof_id_type> neighbor_elems;
  for (const auto & bnd_elem : _bnd_elems)
  {
    const auto & [elem_ptr, elem_side, elem_bid] = *bnd_elem;
    if (elem_bid == bid)
    {
      const auto * neighbor = elem_ptr->neighbor_ptr(elem_side);
      // Dont add fully remote elements, ghosted is fine
      if (neighbor && neighbor != libMesh::remote_elem)
      {
        // handle mesh refinement, only return active elements near the boundary
        if (neighbor->active())
          neighbor_elems.insert(neighbor->id());
        else
        {
          std::vector<const Elem *> family;
          neighbor->active_family_tree_by_neighbor(family, elem_ptr);
          for (const auto & child_neighbor : family)
            neighbor_elems.insert(child_neighbor->id());
        }
      }
    }
  }

  return neighbor_elems;
}

getBoundaryActiveSemiLocalElemIds()

std::unordered_set< dof_id_type > MooseMesh::getBoundaryActiveSemiLocalElemIds

(

BoundaryID

bid

)

const

Return all ids of elements which have a side which is part of a sideset.

Note that boundaries are sided.

Parameters

bid	the id of the sideset of interest

Definition at line 1381 of file MooseMesh.C.

{
  // The boundary to element map is computed on every mesh update
  const auto it = _bnd_elem_ids.find(bid);
  if (it == _bnd_elem_ids.end())
    // Boundary is not local to this domain, return an empty set
    return std::unordered_set<dof_id_type>{};
  return it->second;
}

getBoundaryConnectedBlocks()

std::set< SubdomainID > MooseMesh::getBoundaryConnectedBlocks

(

const BoundaryID

bid

)

const

Get the list of subdomains associated with the given boundary.

Parameters

bid	The boundary ID you want to get the subdomain IDs for.

Returns

All subdomain IDs associated with given boundary ID

Definition at line 3601 of file MooseMesh.C.

Referenced by DomainUserObject::DomainUserObject(), getInterfaceConnectedBlocks(), and NodeFaceConstraint::getSecondaryConnectedBlocks().

{
  std::set<SubdomainID> subdomain_ids;
  for (const auto & [sub_id, data] : _sub_to_data)
    if (data.boundary_ids.find(bid) != data.boundary_ids.end())
      subdomain_ids.insert(sub_id);

  return subdomain_ids;
}

getBoundaryConnectedSecondaryBlocks()

std::set< SubdomainID > MooseMesh::getBoundaryConnectedSecondaryBlocks

(

const BoundaryID

bid

)

const

Get the list of subdomains associated with the given boundary of its secondary side.

Parameters

bid	The boundary ID you want to get the subdomain IDs for.

Returns

All subdomain IDs associated with given boundary ID

Definition at line 3612 of file MooseMesh.C.

Referenced by DomainUserObject::DomainUserObject().

{
  std::set<SubdomainID> subdomain_ids;
  for (const auto & it : _neighbor_subdomain_boundary_ids)
    if (it.second.find(bid) != it.second.end())
      subdomain_ids.insert(it.first);

  return subdomain_ids;
}

getBoundaryElementRange()

ConstBndElemRange * MooseMesh::getBoundaryElementRange

(

)

Definition at line 1353 of file MooseMesh.C.

Referenced by AuxiliarySystem::computeElementalVarsHelper(), DMMooseGetEmbedding_Private(), GeometricSearchData::generateQuadratureNodes(), FEProblemBase::initialSetup(), meshChanged(), and GeometricSearchData::updateQuadratureNodes().

{
  if (!_bnd_elem_range)
  {
    TIME_SECTION("getBoundaryElementRange", 5);

    _bnd_elem_range =
        std::make_unique<ConstBndElemRange>(bndElemsBegin(), bndElemsEnd(), GRAIN_SIZE);
  }

  return _bnd_elem_range.get();
}

getBoundaryID()

BoundaryID MooseMesh::getBoundaryID

(

const BoundaryName &

boundary_name

)

const

Get the associated BoundaryID for the boundary name.

Parameters

boundary_name

The name of the boundary.

Returns

the boundary id from the passed boundary name.

Definition at line 1742 of file MooseMesh.C.

Referenced by AddPeriodicBCAction::act(), TiledMesh::buildMesh(), StitchedMesh::buildMesh(), PatternedMesh::buildMesh(), DMSetUp_Moose_Pre(), GeometricSearchData::getNearestNodeLocator(), GeometricSearchData::getPenetrationLocator(), GeometricSearchData::getQuadratureNearestNodeLocator(), GeometricSearchData::getQuadraturePenetrationLocator(), LinearNodalConstraint::LinearNodalConstraint(), LowerBoundNodalKernel::LowerBoundNodalKernel(), NodalScalarKernel::NodalScalarKernel(), prepare(), EqualValueBoundaryConstraint::updateConstrainedNodes(), and UpperBoundNodalKernel::UpperBoundNodalKernel().

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

  return MooseMeshUtils::getBoundaryID(boundary_name, getMesh());
}

getBoundaryIDs() [1/3]

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

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

Referenced by NonlinearSystemBase::computeJacobianInternal(), DGKernelBase::DGKernelBase(), DGKernelBase::excludeBoundary(), MultiAppUserObjectTransfer::execute(), BoundaryRestrictable::hasBoundary(), BoundaryRestrictable::initializeBoundaryRestrictable(), ElementSubdomainModifierBase::initialSetup(), KokkosBoundNodalKernel< KokkosUpperBoundNodalKernel >::KokkosBoundNodalKernel(), BoundaryRestrictable::meshBoundaryIDs(), GhostBoundary::operator()(), and ActivateElementsUserObjectBase::setNewBoundayName().

getBoundaryIDs() [2/3]

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

(

)

const

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

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

Definition at line 3029 of file MooseMesh.C.

Referenced by cacheInfo().

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

getBoundaryIDs() [3/3]

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

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

Parameters

boundary_name

The names of the boundaries.

Returns

the boundary ids from the passed boundary names.

Definition at line 1773 of file MooseMesh.C.

{
  return MooseMeshUtils::getBoundaryIDs(
      getMesh(), boundary_name, generate_unknown, _mesh_boundary_ids);
}

getBoundaryName()

const std::string & MooseMesh::getBoundaryName

(

BoundaryID

boundary_id

)

const

Return the name of the boundary given the id.

Definition at line 1842 of file MooseMesh.C.

Referenced by addPeriodicVariable(), FEProblemBase::initialSetup(), and NonlinearThread::printBoundaryExecutionInformation().

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

  // We need to figure out if this boundary is a sideset or nodeset
  if (boundary_info.get_side_boundary_ids().count(boundary_id))
    return boundary_info.get_sideset_name(boundary_id);
  else
    return boundary_info.get_nodeset_name(boundary_id);
}

getBoundaryNodeRange()

ConstBndNodeRange * MooseMesh::getBoundaryNodeRange

(

)

Definition at line 1339 of file MooseMesh.C.

Referenced by AuxiliarySystem::computeMortarNodalVars(), AuxiliarySystem::computeNodalVarsHelper(), DMMooseGetEmbedding_Private(), NearestNodeLocator::findNodes(), FEProblemBase::getCurrentAlgebraicBndNodeRange(), ActivateElementsUserObjectBase::getNewlyActivatedBndNodeRange(), FEProblemBase::initialSetup(), meshChanged(), FEProblemBase::projectSolution(), ElementSubdomainModifierBase::reinitializedBndNodeRange(), and NearestNodeLocator::updatePatch().

{
  if (!_bnd_node_range)
  {
    TIME_SECTION("getBoundaryNodeRange", 5);

    _bnd_node_range =
        std::make_unique<ConstBndNodeRange>(bndNodesBegin(), bndNodesEnd(), GRAIN_SIZE);
  }

  return _bnd_node_range.get();
}

getCheckedPointerParam()

template<typename T >

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

inherited

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 432 of file MooseBase.h.

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

getCoarseningMap()

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

Get the coarsening map for a given element type.

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

Parameters

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

Definition at line 2629 of file MooseMesh.C.

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

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

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

  return _elem_type_to_coarsening_map[the_pair];
}

getConstructNodeListFromSideList()

bool MooseMesh::getConstructNodeListFromSideList ( )

inline

Return construct node list from side list boolean.

Definition at line 1428 of file MooseMesh.h.

Referenced by SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater().

{ return _construct_node_list_from_side_list; }

getCoordSystem() [1/2]

Moose::CoordinateSystemType MooseMesh::getCoordSystem

(

SubdomainID

sid

)

const

Get the coordinate system type, e.g.

xyz, rz, or r-spherical, for the provided subdomain id sid

Definition at line 4255 of file MooseMesh.C.

Referenced by SubProblem::getCoordSystem(), and ComputeLinearFVGreenGaussGradientVolumeThread::operator()().

{
  auto it = _coord_sys.find(sid);
  if (it != _coord_sys.end())
    return (*it).second;
  else
    mooseError("Requested subdomain ", sid, " does not exist.");
}

getCoordSystem() [2/2]

const std::map< SubdomainID, Moose::CoordinateSystemType > & MooseMesh::getCoordSystem

(

)

const

Get the map from subdomain ID to coordinate system type, e.g.

xyz, rz, or r-spherical

Definition at line 4287 of file MooseMesh.C.

Referenced by setGeneralAxisymmetricCoordAxes().

{
  return _coord_sys;
}

getDataFileName()

std::string DataFileInterface::getDataFileName ( const std::string &  param ) const

inherited

Deprecated method.

The data file paths are now automatically set within the InputParameters object, so using getParam<DataFileName>("param_name") is now sufficient.

Definition at line 21 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
                          "within the InputParameters.\nUse getParam<DataFileName>(\"",
                          param,
                          "\") instead.");
  return _parent.getParam<DataFileName>(param);
}

getDataFileNameByName()

std::string DataFileInterface::getDataFileNameByName ( const std::string &  relative_path ) const

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
                          relative_path,
                          "\") instead.");
  return getDataFilePath(relative_path);
}

getDataFilePath()

std::string DataFileInterface::getDataFilePath ( const std::string &  relative_path ) const

inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName

Definition at line 40 of file DataFileInterface.C.

Referenced by DataFileInterface::getDataFileNameByName().

{
  // This should only ever be used with relative paths. There is no point to
  // use this search path with an absolute path.
  if (std::filesystem::path(relative_path).is_absolute())
    _parent.mooseWarning("While using getDataFilePath(\"",
                         relative_path,
                         "\"): This API should not be used for absolute paths.");

  // This will search the data paths for this relative path
  std::optional<std::string> error;
  Moose::DataFileUtils::Path found_path;
  {
    // Throw on error so that if getPath() fails, we can throw an error
    // with the context of _parent.mooseError()
    Moose::ScopedThrowOnError scoped_throw_on_error;

    try
    {
      found_path = Moose::DataFileUtils::getPath(relative_path);
    }
    catch (std::exception & e)
    {
      error = e.what();
    }
  }

  if (error)
    _parent.mooseError(*error);

  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
              "Should only ever obtain data");
  mooseAssert(found_path.data_name, "Should be set");

  const std::string msg =
      "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
  _parent.mooseInfo(msg);

  return found_path.path;
}

getDisplaceNodeListBySideList()

bool MooseMesh::getDisplaceNodeListBySideList ( )

inline

Return displace node list by side list boolean.

Definition at line 1431 of file MooseMesh.h.

{ return _displace_node_list_by_side_list; }

getElementIDIndex()

unsigned int MooseMesh::getElementIDIndex ( const std::string &  id_name ) const

inline

Return the accessing integer for an extra element integer with its name.

Definition at line 2200 of file MooseMesh.h.

Referenced by areElemIDsIdentical().

{
  if (!hasElementID(id_name))
    mooseError("Mesh does not have element ID for ", id_name);
  return getMesh().get_elem_integer_index(id_name);
}

getElemIDMapping()

std::unordered_map< dof_id_type, std::set< dof_id_type > > MooseMesh::getElemIDMapping	(	const std::string &	from_id_name,
		const std::string &	to_id_name
	)		const

Definition at line 1150 of file MooseMesh.C.

{
  auto & mesh_base = getMesh();

  if (!mesh_base.has_elem_integer(from_id_name))
    mooseError("Mesh does not have the element integer name '", from_id_name, "'");
  if (!mesh_base.has_elem_integer(to_id_name))
    mooseError("Mesh does not have the element integer name '", to_id_name, "'");

  const auto id1 = mesh_base.get_elem_integer_index(from_id_name);
  const auto id2 = mesh_base.get_elem_integer_index(to_id_name);

  std::unordered_map<dof_id_type, std::set<dof_id_type>> id_map;
  for (const auto id : getAllElemIDs(id1))
    id_map[id] = std::set<dof_id_type>();

  for (const auto & elem : mesh_base.active_local_element_ptr_range())
    id_map[elem->get_extra_integer(id1)].insert(elem->get_extra_integer(id2));

  for (auto & [id, ids] : id_map)
  {
    libmesh_ignore(id); // avoid overzealous gcc 9.4 unused var warning
    comm().set_union(ids);
  }

  return id_map;
}

getElemIDsOnBlocks()

std::set< dof_id_type > MooseMesh::getElemIDsOnBlocks	(	unsigned int	elem_id_index,
		const std::set< SubdomainID > &	blks
	)		const

Return all the unique element IDs for an extra element integer with its index on a set of subdomains.

Definition at line 1189 of file MooseMesh.C.

{
  std::set<dof_id_type> unique_ids;
  for (auto & blk : blks)
  {
    auto it = _block_id_mapping[elem_id_index].find(blk);
    if (it == _block_id_mapping[elem_id_index].end())
      mooseError("Block ", blk, " is not available on the mesh");

    for (auto & mid : it->second)
      unique_ids.insert(mid);
  }
  return unique_ids;
}

getFileName()

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

inlinevirtual

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

Reimplemented in FileMesh, and TiledMesh.

Definition at line 1074 of file MooseMesh.h.

{ return ""; }

getGeneralAxisymmetricCoordAxis()

const std::pair< Point, RealVectorValue > & MooseMesh::getGeneralAxisymmetricCoordAxis

(

SubdomainID

subdomain_id

)

const

Gets the general axisymmetric coordinate axis for a block.

Parameters

[in]

subdomain_id

Subdomain ID for which to get axisymmetric coordinate axis

Definition at line 4349 of file MooseMesh.C.

{
  auto it = _subdomain_id_to_rz_coord_axis.find(subdomain_id);
  if (it != _subdomain_id_to_rz_coord_axis.end())
    return (*it).second;
  else
    mooseError("Requested subdomain ", subdomain_id, " does not exist.");
}

getGhostedBoundaries()

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

(

)

const

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

Definition at line 3321 of file MooseMesh.C.

{
  return _ghosted_boundaries;
}

getGhostedBoundaryInflation()

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

(

)

const

Return a writable reference to the _ghosted_boundaries_inflation vector.

Definition at line 3327 of file MooseMesh.C.

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

{
  return _ghosted_boundaries_inflation;
}

getGhostingPatchSize()

unsigned int MooseMesh::getGhostingPatchSize ( ) const

inline

Getter for the ghosting_patch_size parameter.

Definition at line 622 of file MooseMesh.h.

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

{ return _ghosting_patch_size; }

getHigherDSide()

unsigned int MooseMesh::getHigherDSide

(

const Elem *

elem

)

const

Returns the local side ID of the interior parent aligned with the lower dimensional element.

Definition at line 1762 of file MooseMesh.C.

{
  auto it = _lower_d_elem_to_higher_d_elem_side.find(elem);

  if (it != _lower_d_elem_to_higher_d_elem_side.end())
    return it->second;
  else
    return libMesh::invalid_uint;
}

getHitNode()

const hit::Node* MooseBase::getHitNode ( ) const

inlineinherited

Returns

The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MooseBase::callMooseError(), MooseBase::getHitNode(), and MooseBase::messagePrefix().

{ return getHitNode(_pars); }

getInflatedProcessorBoundingBox()

BoundingBox MooseMesh::getInflatedProcessorBoundingBox

(

Real

inflation_multiplier = 0.01

)

const

Get a (slightly inflated) processor bounding box.

Parameters

inflation_multiplier

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

Definition at line 3499 of file MooseMesh.C.

Referenced by PositionsFunctorValueSampler::execute(), PointVariableSamplerBase::execute(), CartesianGridDivision::initialize(), and RadialAverage::updateCommunicationLists().

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

getInterfaceConnectedBlocks()

std::set< SubdomainID > MooseMesh::getInterfaceConnectedBlocks

(

const BoundaryID

bid

)

const

Get the list of subdomains contacting the given boundary.

Parameters

bid	The boundary ID you want to get the subdomain IDs for.

Returns

All subdomain IDs contacting given boundary ID

Definition at line 3623 of file MooseMesh.C.

{
  std::set<SubdomainID> subdomain_ids = getBoundaryConnectedBlocks(bid);
  for (const auto & it : _neighbor_subdomain_boundary_ids)
    if (it.second.find(bid) != it.second.end())
      subdomain_ids.insert(it.first);

  return subdomain_ids;
}

getKokkosMesh()

const Moose::Kokkos::Mesh* MooseMesh::getKokkosMesh ( ) const

inline

Accessor for Kokkos mesh object.

Definition at line 666 of file MooseMesh.h.

Referenced by BlockRestrictable::initializeBlockRestrictable().

{ return _kokkos_mesh.get(); }

getLocalNodeRange()

ConstNodeRange * MooseMesh::getLocalNodeRange

(

)

Definition at line 1325 of file MooseMesh.C.

Referenced by AuxiliarySystem::computeNodalVarsHelper(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::getCurrentAlgebraicNodeRange(), FEProblemBase::initialSetup(), and meshChanged().

{
  if (!_local_node_range)
  {
    TIME_SECTION("getLocalNodeRange", 5);

    _local_node_range = std::make_unique<ConstNodeRange>(
        getMesh().local_nodes_begin(), getMesh().local_nodes_end(), GRAIN_SIZE);
  }

  return _local_node_range.get();
}

getLowerDElem()

const Elem * MooseMesh::getLowerDElem	(	const Elem *	,
		unsigned short	int
	)		const

Returns a const pointer to a lower dimensional element that corresponds to a side of a higher dimensional element.

This relationship is established through an internal_parent; if there is no lowerDElem, nullptr is returned.

Definition at line 1751 of file MooseMesh.C.

Referenced by GhostLowerDElems::operator()(), DisplacedProblem::reinitElemNeighborAndLowerD(), and FEProblemBase::reinitElemNeighborAndLowerD().

{
  auto it = _higher_d_elem_side_to_lower_d_elem.find(std::make_pair(elem, side));

  if (it != _higher_d_elem_side_to_lower_d_elem.end())
    return it->second;
  else
    return nullptr;
}

getLowerDElemMap()

const std::unordered_map< std::pair< const Elem *, unsigned short int >, const Elem * > & MooseMesh::getLowerDElemMap ( ) const

inline

This function attempts to return the map from a high-order element side to its corresponding lower-d element.

Definition at line 2234 of file MooseMesh.h.

{
  return _higher_d_elem_side_to_lower_d_elem;
}

getMaxInDimension()

Real MooseMesh::getMaxInDimension ( unsigned int  component ) const

virtual

Reimplemented in AnnularMesh, and GeneratedMesh.

Definition at line 2258 of file MooseMesh.C.

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

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

  return _bounds[component][MAX];
}

getMaxLeafSize()

unsigned int MooseMesh::getMaxLeafSize ( ) const

inline

Getter for the maximum leaf size parameter.

Definition at line 627 of file MooseMesh.h.

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

{ return _max_leaf_size; }

getMaxNodesPerElem()

unsigned int MooseMesh::getMaxNodesPerElem ( ) const

inline

Get the maximum number of nodes per element.

Definition at line 1154 of file MooseMesh.h.

{ return _max_nodes_per_elem; }

getMaxNodesPerSide()

unsigned int MooseMesh::getMaxNodesPerSide ( ) const

inline

Get the maximum number of nodes per side.

Definition at line 1159 of file MooseMesh.h.

{ return _max_nodes_per_side; }

getMaxSidesPerElem()

unsigned int MooseMesh::getMaxSidesPerElem ( ) const

inline

Get the maximum number of sides per element.

Definition at line 1149 of file MooseMesh.h.

{ return _max_sides_per_elem; }

getMesh() [1/4]

MeshBase & MooseMesh::getMesh

(

)

Accessor for the underlying libMesh Mesh object.

Definition at line 3528 of file MooseMesh.C.

Referenced by CopyMeshPartitioner::_do_partition(), AddPeriodicBCAction::act(), activeLocalElementsBegin(), activeLocalElementsEnd(), Adaptivity::adaptMesh(), FEProblemBase::addAnyRedistributers(), addQuadratureNode(), addUniqueNode(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), NonlinearSystemBase::assembleScalingVector(), Assembly::Assembly(), AuxKernelBase::AuxKernelBase(), buildActiveSideList(), buildBndElemList(), MFEMMesh::buildDummyMooseMesh(), buildElemIDInfo(), buildFiniteVolumeInfo(), buildHRefinementAndCoarseningMaps(), buildLowerDMesh(), TiledMesh::buildMesh(), FileMesh::buildMesh(), AnnularMesh::buildMesh(), RinglebMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), ConcentricCircleMesh::buildMesh(), GeneratedMesh::buildMesh(), StitchedMesh::buildMesh(), PatternedMesh::buildMesh(), ImageMesh::buildMesh2D(), ImageMesh::buildMesh3D(), buildNodeList(), buildNodeListFromSideList(), buildPeriodicNodeMap(), buildPeriodicNodeSets(), buildPRefinementAndCoarseningMaps(), buildSideList(), cacheChangedLists(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), cacheInfo(), changeBoundaryId(), checkCoordinateSystems(), computeMaxPerElemAndSide(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), PenetrationThread::createInfoForElem(), MortarInterfaceWarehouse::createMortarInterface(), detectOrthogonalDimRanges(), detectPairedSidesets(), dimension(), ExtraElementIntegerDivision::divisionIndex(), FunctorBinnedValuesDivision::divisionIndex(), SubdomainsDivision::divisionIndex(), DumpObjectsProblem::dumpVariableHelper(), ElementalVariableValue::ElementalVariableValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), elemPtr(), ElemSideNeighborLayersTester::execute(), NodalNormalsCorner::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppUserObjectTransfer::execute(), NodalNormalsPreprocessor::execute(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), SidesetAroundSubdomainUpdater::finalize(), ActivateElementsUserObjectBase::finalize(), ElementSubdomainModifierBase::gatherMovingBoundaryChanges(), ElementSubdomainModifierBase::gatherMovingBoundaryChangesHelper(), getActiveLocalElementRange(), getActiveNodeRange(), getBlocksMaxDimension(), getBoundaryID(), getBoundaryIDs(), getBoundaryName(), getElementIDIndex(), getElemIDMapping(), FEProblemBase::getEvaluableElementRange(), getInflatedProcessorBoundingBox(), getLocalNodeRange(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), getNodeList(), FEProblemBase::getNonlinearEvaluableElementRange(), getPointLocator(), getSubdomainID(), getSubdomainIDs(), getSubdomainName(), ghostGhostedBoundaries(), Exodus::handleExodusIOMeshRenumbering(), hasElementID(), init(), DisplacedProblem::UpdateDisplacedMeshThread::init(), VerifyElementUniqueID::initialize(), VerifyNodalUniqueID::initialize(), ExtraElementIntegerDivision::initialize(), ElementCentroidPositions::initialize(), ElementGroupCentroidPositions::initialize(), FunctorPositions::initialize(), FunctorTimes::initialize(), NodePositions::initialize(), QuadraturePointsPositions::initialize(), FunctorExtremaPositions::initialize(), ParsedDownSelectionPositions::initialize(), MultiAppDofCopyTransfer::initialSetup(), NodalVariableValue::initialSetup(), FEProblemBase::initialSetup(), SampledOutput::initSample(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), LinearNodalConstraint::LinearNodalConstraint(), localNodesBegin(), localNodesEnd(), Moose::Mortar::loopOverMortarSegments(), maxElemId(), maxNodeId(), GhostingUserObject::meshChanged(), RadialAverage::meshChanged(), DisplacedProblem::meshChanged(), FEProblemBase::meshChanged(), MooseMesh(), NearestNodeLocator::nearestNode(), nElem(), nNodes(), NodalPatchRecovery::NodalPatchRecovery(), NodalVariableValue::NodalVariableValue(), nodeToActiveSemilocalElemMap(), nodeToElemMap(), ComputeNodalUserObjectsThread::onNode(), ProxyRelationshipManager::operator()(), MortarUserObjectThread::operator()(), PenetrationThread::operator()(), ComputeMortarFunctor::operator()(), XDA::output(), Exodus::outputEmptyTimestep(), Exodus::outputNodalVariables(), prepare(), BoundaryPreservedMarker::preserveBoundary(), printInfo(), queryElemPtr(), queryNodePtr(), FileMesh::read(), PropertyReadFile::readData(), RedistributeProperties::redistribute(), SubProblem::restrictionBoundaryCheckName(), SubProblem::restrictionSubdomainCheckName(), setBoundaryName(), NonlinearSystemBase::setConstraintSecondaryValues(), XFEMInterface::setDisplacedMesh(), ActivateElementsUserObjectBase::setNewBoundayName(), setPartitionerHelper(), setSubdomainName(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), sideWithBoundaryID(), MoveNodesToGeometryModifierBase::snapNodes(), MultiAppDofCopyTransfer::transfer(), DisplacedProblem::undisplaceMesh(), update(), updateActiveSemiLocalNodeRange(), EqualValueBoundaryConstraint::updateConstrainedNodes(), Adaptivity::updateErrorVectors(), RandomData::updateGenerators(), DisplacedProblem::updateMesh(), SampledOutput::updateSample(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

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

getMesh() [2/4]

MeshBase& MooseMesh::getMesh

(

const std::string &

name

)

getMesh() [3/4]

const MeshBase & MooseMesh::getMesh

(

)

const

Definition at line 3535 of file MooseMesh.C.

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

getMesh() [4/4]

const MeshBase& MooseMesh::getMesh

(

const std::string &

name

)

const

getMeshPtr()

const MeshBase * MooseMesh::getMeshPtr

(

)

const

Definition at line 3522 of file MooseMesh.C.

Referenced by buildTypedMesh(), RelationshipManager::init(), and GhostBoundary::operator()().

{
  return _mesh.get();
}

getMinInDimension()

Real MooseMesh::getMinInDimension ( unsigned int  component ) const

virtual

Returns the min or max of the requested dimension respectively.

Reimplemented in AnnularMesh, and GeneratedMesh.

Definition at line 2249 of file MooseMesh.C.

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

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

  return _bounds[component][MIN];
}

getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), DefaultConvergenceBase::getSharedExecutionerParam(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

{ return _app; }

getNodeBlockIds()

const std::set< SubdomainID > & MooseMesh::getNodeBlockIds

(

const Node &

node

)

const

Return list of blocks to which the given node belongs.

Definition at line 1549 of file MooseMesh.C.

Referenced by ComputeNodalUserObjectsThread::onNode(), ComputeNodalKernelsThread::onNode(), ComputeNodalKernelJacobiansThread::onNode(), ComputeInitialConditionThread::operator()(), and MoveNodesToGeometryModifierBase::snapNodes().

{
  auto it = _block_node_list.find(node.id());

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

  return it->second;
}

getNodeList()

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

(

boundary_id_type

nodeset_id

)

const

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

Definition at line 3550 of file MooseMesh.C.

Referenced by LinearNodalConstraint::LinearNodalConstraint(), NodalScalarKernel::NodalScalarKernel(), MoveNodesToGeometryModifierBase::snapNodes(), and EqualValueBoundaryConstraint::updateConstrainedNodes().

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

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

  return it->second;
}

getNormalByBoundaryID()

const RealVectorValue & MooseMesh::getNormalByBoundaryID

(

BoundaryID

id

)

const

Returns the normal vector associated with a given BoundaryID.

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

Definition at line 2862 of file MooseMesh.C.

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

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

getPairedBoundaryMapping()

const std::pair< BoundaryID, BoundaryID > * MooseMesh::getPairedBoundaryMapping

(

unsigned int

component

)

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

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

Parameters

component

- An integer representing the desired component (dimension)

Returns

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

Definition at line 2343 of file MooseMesh.C.

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

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

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

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

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

getParallelType()

ParallelType MooseMesh::getParallelType ( ) const

inline

Returns

The parallel type

Definition at line 1019 of file MooseMesh.h.

Referenced by MultiAppDofCopyTransfer::initialSetup().

{ return _parallel_type; }

getParam() [1/2]

template<typename T >

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

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns

The value of the parameter

Definition at line 388 of file MooseBase.h.

Referenced by CreateDisplacedProblemAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FEProblemBase::addOutput(), DiffusionPhysicsBase::addPostprocessors(), ArrayParsedAux::ArrayParsedAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), ComponentPhysicsInterface::ComponentPhysicsInterface(), FunctorAux::computeValue(), Console::Console(), FEProblemBase::createTagSolutions(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), AccumulateReporter::declareLateValues(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), FEProblemSolve::FEProblemSolve(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), ParsedSubdomainGeneratorBase::functionInitialize(), FVInterfaceKernel::FVInterfaceKernel(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), GeneratedMeshGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), MeshExtruderGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), GhostingUserObject::GhostingUserObject(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), IterationAdaptiveDT::init(), AdvancedOutput::init(), AttribThread::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MultiSystemSolveObject::MultiSystemSolveObject(), NEML2ModelExecutor::NEML2ModelExecutor(), NestedDivision::NestedDivision(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedVectorReporter::ParsedVectorReporter(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseConstantByBlockMaterialTempl< is_ad >::PiecewiseConstantByBlockMaterialTempl(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), Output::setWallTimeIntervalFromCommandLineParam(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

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

getParam() [2/2]

template<typename T1 , typename T2 >

std::vector< std::pair< T1, T2 > > MooseBase::getParam ( const std::string &  param1, const std::string &  param2  ) const

inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters

param1	The name of first parameter
param2	The name of second parameter

Returns

Vector of pairs of first and second parameters

Definition at line 425 of file MooseBase.h.

{
  return _pars.get<T1, T2>(param1, param2);
}

getPatchSize()

unsigned int MooseMesh::getPatchSize

(

)

const

Getter for the patch_size parameter.

Definition at line 3481 of file MooseMesh.C.

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

{
  return _patch_size;
}

getPatchUpdateStrategy()

const Moose::PatchUpdateType & MooseMesh::getPatchUpdateStrategy

(

)

const

Get the current patch update strategy.

Definition at line 3493 of file MooseMesh.C.

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches().

{
  return _patch_update_strategy;
}

getPCoarseningMap()

const std::vector< QpMap > & MooseMesh::getPCoarseningMap

(

const Elem &

elem

)

const

Get the map describing for each volumetric quadrature point (qp) on the coarse level which qp on the previous finer level the coarse qp is closest to.

Definition at line 4470 of file MooseMesh.C.

Referenced by ProjectMaterialProperties::onElement().

{
  return getPCoarseningMapHelper(elem, _elem_type_to_p_coarsening_map);
}

getPCoarseningMapHelper()

const std::vector< QpMap > & MooseMesh::getPCoarseningMapHelper ( const Elem &  elem, const std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap >> &    ) const

private

Definition at line 4448 of file MooseMesh.C.

Referenced by getPCoarseningMap(), and getPCoarseningSideMap().

{
  mooseAssert(elem.active() && elem.p_refinement_flag() == Elem::JUST_COARSENED,
              "These are the conditions that should be met for requesting a coarsening map");
  return libmesh_map_find(map, std::make_pair(elem.type(), elem.p_level()));
}

getPCoarseningSideMap()

const std::vector< QpMap > & MooseMesh::getPCoarseningSideMap

(

const Elem &

elem

)

const

Get the map describing for each side quadrature point (qp) on the coarse level which qp on the previous finer level the coarse qp is closest to.

Definition at line 4476 of file MooseMesh.C.

Referenced by ProjectMaterialProperties::onBoundary().

{
  return getPCoarseningMapHelper(elem, _elem_type_to_p_coarsening_side_map);
}

getPointLocator()

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

virtual

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

Definition at line 3813 of file MooseMesh.C.

Referenced by CopyMeshPartitioner::_do_partition(), PenetrationLocator::detectPenetration(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), IntersectionPointsAlongLine::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementsAlongLine::execute(), FindValueOnLine::initialize(), PointSamplerBase::initialize(), PiecewiseConstantFromCSV::initialSetup(), ReporterPointMarker::markerSetup(), and PenetrationThread::operator()().

{
  return getMesh().sub_point_locator();
}

getPRefinementMap()

const std::vector< QpMap > & MooseMesh::getPRefinementMap

(

const Elem &

elem

)

const

Get the map describing for each volumetric quadrature point (qp) on the refined level which qp on the previous coarser level the fine qp is closest to.

Definition at line 4458 of file MooseMesh.C.

Referenced by ProjectMaterialProperties::onElement().

{
  return getPRefinementMapHelper(elem, _elem_type_to_p_refinement_map);
}

getPRefinementMapHelper()

const std::vector< QpMap > & MooseMesh::getPRefinementMapHelper ( const Elem &  elem, const std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap >> &    ) const

private

Definition at line 4437 of file MooseMesh.C.

Referenced by getPRefinementMap(), and getPRefinementSideMap().

{
  // We are actually seeking the map stored with the p_level - 1 key, e.g. the refinement map that
  // maps from the previous p_level to this element's p_level
  return libmesh_map_find(map,
                          std::make_pair(elem.type(), cast_int<unsigned int>(elem.p_level() - 1)));
}

getPRefinementSideMap()

const std::vector< QpMap > & MooseMesh::getPRefinementSideMap

(

const Elem &

elem

)

const

Get the map describing for each side quadrature point (qp) on the refined level which qp on the previous coarser level the fine qp is closest to.

Definition at line 4464 of file MooseMesh.C.

Referenced by ProjectMaterialProperties::onBoundary().

{
  return getPRefinementMapHelper(elem, _elem_type_to_p_refinement_side_map);
}

getQuadratureNode()

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

Get a specified quadrature node.

Parameters

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

Definition at line 1712 of file MooseMesh.C.

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

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

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

getRefinementMap()

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

Get the refinement map for a given element type.

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

Parameters

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

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

Definition at line 2565 of file MooseMesh.C.

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

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

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

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

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

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

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

}

getRenamedParam()

template<typename T >

const T & MooseBase::getRenamedParam ( const std::string &  old_name, const std::string &  new_name  ) const

inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters

old_name	the old name for the parameter
new_name	the new name for the parameter

Definition at line 402 of file MooseBase.h.

{
  // Most important: accept new parameter
  if (isParamSetByUser(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Second most: accept old parameter
  if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return getParam<T>(old_name);
  // Third most: accept default for new parameter
  if (isParamValid(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Refuse: no default, no value passed
  if (!isParamValid(old_name) && !isParamValid(new_name))
    mooseError("parameter '" + new_name +
               "' is being retrieved without being set.\nDid you misspell it?");
  // Refuse: both old and new parameters set by user
  else
    mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
               old_name + "'");
}

getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string &  data_name ) const

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

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

Parameters

data_name

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

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

getSharedPtr() [1/2]

std::shared_ptr< MooseObject > MooseObject::getSharedPtr ( )

inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 72 of file MooseObject.C.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), MFEMProblem::addMFEMSolver(), and WebServerControl::addServerAction().

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

getSharedPtr() [2/2]

std::shared_ptr< const MooseObject > MooseObject::getSharedPtr ( ) const

inherited

Definition at line 85 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

getSubdomainBoundaryIds()

const std::set< BoundaryID > & MooseMesh::getSubdomainBoundaryIds

(

const SubdomainID

subdomain_id

)

const

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

Parameters

subdomain_id

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

Returns

All boundary IDs connected to elements in the give

Definition at line 3577 of file MooseMesh.C.

Referenced by getSubdomainInterfaceBoundaryIds(), and FEProblemBase::prepareMaterials().

{
  const auto it = _sub_to_data.find(subdomain_id);

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

  return it->second.boundary_ids;
}

getSubdomainID()

SubdomainID MooseMesh::getSubdomainID

(

const SubdomainName &

subdomain_name

)

const

Get the associated subdomain ID for the subdomain name.

Parameters

subdomain_name

The name of the subdomain

Returns

The subdomain id from the passed subdomain name.

Definition at line 1781 of file MooseMesh.C.

Referenced by SystemBase::addVariable(), FEProblemBase::checkProblemIntegrity(), FVInterfaceKernel::FVInterfaceKernel(), TimedSubdomainModifier::getSubdomainIDAndCheck(), SolutionIC::initialSetup(), ElementSubdomainModifierBase::initialSetup(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseConstantByBlockMaterialTempl< is_ad >::PiecewiseConstantByBlockMaterialTempl(), prepare(), setCoordSystem(), and setGeneralAxisymmetricCoordAxes().

{
  return MooseMeshUtils::getSubdomainID(subdomain_name, getMesh());
}

getSubdomainIDs() [1/2]

std::vector< SubdomainID > MooseMesh::getSubdomainIDs

(

const std::vector< SubdomainName > &

subdomain_names

)

const

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

Parameters

subdomain_names

The names of the subdomains

Returns

The subdomain ids from the passed subdomain names.

Definition at line 1787 of file MooseMesh.C.

Referenced by FEProblemBase::addAuxVariable(), FEProblemBase::addVariable(), MultiAppUserObjectTransfer::execute(), getBlocksMaxDimension(), BlockRestrictable::hasBlocks(), SubdomainsDivision::initialize(), BlockRestrictable::initializeBlockRestrictable(), MultiAppDofCopyTransfer::initialSetup(), ElementSubdomainModifierBase::initialSetup(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), and LayeredBase::LayeredBase().

{
  return MooseMeshUtils::getSubdomainIDs(getMesh(), subdomain_name);
}

getSubdomainIDs() [2/2]

std::set< SubdomainID > MooseMesh::getSubdomainIDs

(

const std::set< SubdomainName > &

subdomain_names

)

const

Definition at line 1793 of file MooseMesh.C.

{
  return MooseMeshUtils::getSubdomainIDs(getMesh(), subdomain_name);
}

getSubdomainInterfaceBoundaryIds()

std::set< BoundaryID > MooseMesh::getSubdomainInterfaceBoundaryIds

(

const SubdomainID

subdomain_id

)

const

Get the list of boundaries that contact the given subdomain.

Parameters

subdomain_id

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

Returns

All boundary IDs connected to elements in the given subdomain

Definition at line 3588 of file MooseMesh.C.

{
  const auto & bnd_ids = getSubdomainBoundaryIds(subdomain_id);
  std::set<BoundaryID> boundary_ids(bnd_ids.begin(), bnd_ids.end());
  std::unordered_map<SubdomainID, std::set<BoundaryID>>::const_iterator it =
      _neighbor_subdomain_boundary_ids.find(subdomain_id);

  boundary_ids.insert(it->second.begin(), it->second.end());

  return boundary_ids;
}

getSubdomainName()

const std::string & MooseMesh::getSubdomainName

(

SubdomainID

subdomain_id

)

const

Return the name of a block given an id.

Definition at line 1813 of file MooseMesh.C.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), FEProblemBase::checkDependMaterialsHelper(), checkDuplicateSubdomainNames(), DomainUserObject::checkVariable(), DGLowerDKernel::DGLowerDKernel(), FEProblemBase::duplicateVariableCheck(), getSubdomainNames(), HFEMDirichletBC::HFEMDirichletBC(), LowerDIntegratedBC::LowerDIntegratedBC(), MooseVariableBase::MooseVariableBase(), ComputeLinearFVElementalThread::printBlockExecutionInformation(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), NonlinearThread::printBlockExecutionInformation(), and setGeneralAxisymmetricCoordAxes().

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

getSubdomainNames()

std::vector< SubdomainName > MooseMesh::getSubdomainNames

(

const std::vector< SubdomainID > &

subdomain_ids

)

const

Get the associated subdomainNames for the subdomain ids that are passed in.

Parameters

subdomain_ids

The ids of the subdomains

Returns

The subdomain names from the passed subdomain ids.

Definition at line 1819 of file MooseMesh.C.

Referenced by NonlinearSystemBase::checkKernelCoverage(), FEProblemBase::checkProblemIntegrity(), SampledOutput::cloneMesh(), BlockRestrictable::initializeBlockRestrictable(), and SolutionIC::initialSetup().

{
  std::vector<SubdomainName> names(subdomain_ids.size());

  for (unsigned int i = 0; i < subdomain_ids.size(); i++)
    names[i] = getSubdomainName(subdomain_ids[i]);

  return names;
}

getUniqueCoordSystem()

Moose::CoordinateSystemType MooseMesh::getUniqueCoordSystem

(

)

const

Get the coordinate system from the mesh, it must be the same in all subdomains otherwise this will error.

Definition at line 4265 of file MooseMesh.C.

Referenced by HDGKernel::HDGKernel().

{
  const auto unique_system = _coord_sys.find(*meshSubdomains().begin())->second;
  // Check that it is actually unique
  bool result = std::all_of(
      std::next(_coord_sys.begin()),
      _coord_sys.end(),
      [unique_system](
          typename std::unordered_map<SubdomainID, Moose::CoordinateSystemType>::const_reference
              item) { return (item.second == unique_system); });
  if (!result)
    mooseError("The unique coordinate system of the mesh was requested by the mesh contains "
               "multiple blocks with different coordinate systems");

  if (usingGeneralAxisymmetricCoordAxes())
    mooseError("General axisymmetric coordinate axes are being used, and it is currently "
               "conservatively assumed that in this case there is no unique coordinate system.");

  return unique_system;
}

ghostGhostedBoundaries()

void MooseMesh::ghostGhostedBoundaries

(

)

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

Definition at line 3394 of file MooseMesh.C.

Referenced by FEProblemBase::ghostGhostedBoundaries().

{
  // No need to do this if using a serial mesh
  // We do not need to ghost boundary elements when _need_ghost_ghosted_boundaries
  // is not true. _need_ghost_ghosted_boundaries can be set by a mesh generator
  // where boundaries are already ghosted accordingly
  if (!_use_distributed_mesh || !_need_ghost_ghosted_boundaries)
    return;

  TIME_SECTION("GhostGhostedBoundaries", 3);

  parallel_object_only();

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

hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns

Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

{ return _pars.hasBase(); }

hasElementID()

bool MooseMesh::hasElementID ( const std::string &  id_name ) const

inline

Whether mesh has an extra element integer with a given name.

Definition at line 2194 of file MooseMesh.h.

Referenced by getElementIDIndex().

{
  return getMesh().has_elem_integer(id_name);
}

hasLowerD()

bool MooseMesh::hasLowerD ( ) const

inline

Returns

Whether there are any lower-dimensional blocks that are manifolds of higher-dimensional block faces

Definition at line 1416 of file MooseMesh.h.

Referenced by GhostLowerDElems::operator()().

{ return _has_lower_d; }

hasMeshBase()

bool MooseMesh::hasMeshBase ( ) const

inline

Whether mesh base object was constructed or not.

Definition at line 1107 of file MooseMesh.h.

Referenced by MeshGeneratorMesh::buildMesh().

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

hasSecondOrderElements()

bool MooseMesh::hasSecondOrderElements

(

)

check if the mesh has SECOND order elements

Definition at line 3791 of file MooseMesh.C.

Referenced by Assembly::adCurvatures(), Assembly::Assembly(), Assembly::havePRefinement(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), and SolutionUserObjectBase::SolutionUserObjectBase().

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

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

init()

void MooseMesh::init ( )

virtual

Initialize the Mesh object.

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

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

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

Definition at line 2925 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", 2);

  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("readRecoveredMesh", 2);
      getMesh().read(_app.getRestartRecoverFileBase() + MooseApp::checkpointSuffix());
    }

    getMesh().allow_renumbering(allow_renumbering_later);
    getMesh().skip_partitioning(skip_partitioning_later);
  }
  else // Normally just build the mesh
  {
    // Don't allow partitioning during building
    if (_app.isSplitMesh())
      getMesh().skip_partitioning(true);
    buildMesh();

    // Re-enable partitioning so the splitter can partition!
    if (_app.isSplitMesh())
      getMesh().skip_partitioning(false);

    if (getParam<bool>("build_all_side_lowerd_mesh"))
      buildLowerDMesh();
  }

  computeMaxPerElemAndSide();
}

interiorLowerDBlocks()

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

inline

Returns

The set of lower-dimensional blocks for interior sides

Definition at line 1421 of file MooseMesh.h.

Referenced by FEProblemBase::adaptMesh(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), NonlinearSystemBase::checkKernelCoverage(), BlockRestrictable::checkVariable(), ComputeFullJacobianThread::computeOnInternalFace(), DGLowerDKernel::DGLowerDKernel(), FEProblemBase::initialAdaptMesh(), DisplacedProblem::reinitElemNeighborAndLowerD(), and FEProblemBase::reinitElemNeighborAndLowerD().

{ return _lower_d_interior_blocks; }

isBoundaryElem() [1/2]

bool MooseMesh::isBoundaryElem

(

dof_id_type

elem_id

)

const

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

Definition at line 3671 of file MooseMesh.C.

Referenced by BoundaryMarker::computeElementMarker().

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

isBoundaryElem() [2/2]

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

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

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

isBoundaryFullyExternalToSubdomains()

bool MooseMesh::isBoundaryFullyExternalToSubdomains	(	BoundaryID	bid,
		const std::set< SubdomainID > &	blk_group
	)		const

Returns whether a boundary (given by its id) is not crossing through a group of blocks, by which we mean that elements on both sides of the boundary are in those blocks.

Parameters

bid	the id of the boundary of interest
blk_group	the group of blocks potentially traversed

Returns

whether the boundary does not cross between the subdomains in the group

Definition at line 1423 of file MooseMesh.C.

{
  mooseAssert(_bnd_elem_range, "Boundary element range is not initialized");

  // Loop over all side elements of the mesh, select those on the boundary
  for (const auto & bnd_elem : *_bnd_elem_range)
  {
    const auto & [elem_ptr, elem_side, elem_bid] = *bnd_elem;
    if (elem_bid == bid)
    {
      // If an element is internal to the group of subdomain, check the neighbor
      if (blk_group.find(elem_ptr->subdomain_id()) != blk_group.end())
      {
        const auto * const neighbor = elem_ptr->neighbor_ptr(elem_side);

        // If we did not ghost the neighbor, we cannot decide
        if (neighbor == libMesh::remote_elem)
          mooseError("Insufficient level of geometrical ghosting to determine "
                     "if a boundary is internal to the mesh");
        // If the neighbor does not exist, then we are on the edge of the mesh
        if (!neighbor)
          continue;
        // If the neighbor is also in the group of subdomain,
        // then the boundary cuts the subdomains
        if (blk_group.find(neighbor->subdomain_id()) != blk_group.end())
          return false;
      }
    }
  }
  return true;
}

isBoundaryNode() [1/2]

bool MooseMesh::isBoundaryNode

(

dof_id_type

node_id

)

const

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

Definition at line 3645 of file MooseMesh.C.

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

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

isBoundaryNode() [2/2]

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

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

Definition at line 3660 of file MooseMesh.C.

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

isCustomPartitionerRequested()

bool MooseMesh::isCustomPartitionerRequested

(

)

const

Setter and getter for _custom_partitioner_requested.

Definition at line 3785 of file MooseMesh.C.

{
  return _custom_partitioner_requested;
}

isDisplaced() [1/2]

void MooseMesh::isDisplaced ( bool  is_displaced )

inline

Set whether this mesh is a displaced mesh.

Definition at line 1226 of file MooseMesh.h.

{ _is_displaced = is_displaced; }

isDisplaced() [2/2]

bool MooseMesh::isDisplaced ( ) const

inline

whether this mesh is a displaced mesh

Definition at line 1231 of file MooseMesh.h.

{ return _is_displaced; }

isDistributedMesh()

virtual bool MooseMesh::isDistributedMesh ( ) const

inlinevirtual

Returns the final Mesh distribution type.

Reimplemented in MFEMMesh.

Definition at line 1004 of file MooseMesh.h.

Referenced by AddPeriodicBCAction::autoTranslationBoundaries(), BoundaryMarker::BoundaryMarker(), VerifyElementUniqueID::finalize(), VerifyNodalUniqueID::finalize(), ElementSubdomainModifierBase::gatherPatchElements(), Checkpoint::updateCheckpointFiles(), and RandomData::updateGenerators().

{ return _use_distributed_mesh; }

isFiniteVolumeInfoDirty()

bool MooseMesh::isFiniteVolumeInfoDirty ( ) const

inline

Returns

whether the finite volume information is dirty

Definition at line 1322 of file MooseMesh.h.

Referenced by SideIntegralPostprocessor::initialSetup(), and FEProblemBase::meshChanged().

{ return _finite_volume_info_dirty; }

isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

Get whether this object is a Kokkos functor The parameter is set by the Kokkos base classes:

• Moose::Kokkos::ResidualObject in KokkosResidualObject.K
• Moose::Kokkos::MaterialBase in KokkosMaterialBase.K

Definition at line 65 of file MooseObject.h.

Referenced by BlockRestrictable::initializeBlockRestrictable(), and BoundaryRestrictable::initializeBoundaryRestrictable().

{ return parameters().isParamValid(MooseBase::kokkos_object_param); }

isLowerD()

bool MooseMesh::isLowerD ( const SubdomainID  subdomain_id ) const

inline

Returns

Whether the subdomain indicated by subdomain_id is a lower-dimensional manifold of some higher-dimensional subdomain, or in implementation speak, whether the elements of this subdomain have non-null interior parents

Definition at line 2240 of file MooseMesh.h.

Referenced by ProjectionAux::computeValue(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), MooseVariableBase::MooseVariableBase(), and ProjectionAux::ProjectionAux().

{
  return libmesh_map_find(_sub_to_data, subdomain_id).is_lower_d;
}

isParallelTypeForced()

bool MooseMesh::isParallelTypeForced ( ) const

inline

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

Definition at line 1009 of file MooseMesh.h.

{ return _parallel_type_overridden; }

isParamSetByUser()

bool MooseBase::isParamSetByUser ( const std::string &  name ) const

inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

Referenced by SetupDebugAction::act(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), MFEMDomainSubMesh::buildSubMesh(), MFEMBoundarySubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::runInputFile(), MooseApp::runInputs(), MFEMSolverBase::setPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

  {
    return _pars.isParamSetByUser(name);
  }

isParamValid()

bool MooseBase::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 199 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), CopyNodalVarsAction::act(), SetupMeshAction::act(), SetupDebugAction::act(), ComposeTimeStepperAction::act(), AddVariableAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), CommonOutputAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), DiffusionPhysicsBase::addPostprocessors(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), TimedSubdomainModifier::buildFromFile(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinerGenerator::CombinerGenerator(), FunctorAux::computeValue(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), FEProblemSolve::convergenceSetup(), CopyMeshPartitioner::CopyMeshPartitioner(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByLevelSetGeneratorBase::CutMeshByLevelSetGeneratorBase(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), Eigenvalue::Eigenvalue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), Exodus::Exodus(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FVInterfaceKernel::FVInterfaceKernel(), FVMassMatrix::FVMassMatrix(), AddMetaDataGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), GeneratedMeshGenerator::generate(), BlockDeletionGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), SideSetsFromNodeSetsGenerator::generate(), MeshExtruderGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYZDelaunayGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), ParsedConvergence::initialSetup(), SolutionScalarAux::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionAux::initialSetup(), Console::initialSetup(), MooseParsedVectorFunction::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableFV< Real >::MooseVariableFV(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ParsedCurveGenerator::ParsedCurveGenerator(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), prepare(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusII(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), setCoordSystem(), FileOutput::setFileBase(), FileOutput::setFileBaseInternal(), Split::setup(), SideSetsGeneratorBase::setup(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObjectBase::SolutionUserObjectBase(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

{ return _pars.isParamValid(name); }

isPartitionerForced()

bool MooseMesh::isPartitionerForced ( ) const

inline

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

Definition at line 1029 of file MooseMesh.h.

{ return _partitioner_overridden; }

isRegularOrthogonal()

bool MooseMesh::isRegularOrthogonal ( )

inline

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

Definition at line 1059 of file MooseMesh.h.

Referenced by AddPeriodicBCAction::setPeriodicVars().

{ return _regular_orthogonal_mesh; }

isSemiLocal()

bool MooseMesh::isSemiLocal

(

Node *const

node

)

const

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

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

isSplit()

bool MooseMesh::isSplit ( ) const

inline

Returns

Whether or not this mesh comes from a split mesh

Definition at line 1345 of file MooseMesh.h.

{ return _is_split; }

isTranslatedPeriodic()

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

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

Parameters

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

Definition at line 2301 of file MooseMesh.C.

Referenced by minPeriodicVector().

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

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

lengthUnit()

const MooseUnits & MooseMesh::lengthUnit

(

)

const

Returns

the length unit of this mesh provided through the coordinate transformation object

Definition at line 4410 of file MooseMesh.C.

{
  mooseAssert(_coord_transform, "This must be non-null");
  return _coord_transform->lengthUnit();
}

localNodesBegin() [1/2]

MeshBase::node_iterator MooseMesh::localNodesBegin

(

)

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

Definition at line 3107 of file MooseMesh.C.

{
  return getMesh().local_nodes_begin();
}

localNodesBegin() [2/2]

MeshBase::const_node_iterator MooseMesh::localNodesBegin

(

)

const

Definition at line 3119 of file MooseMesh.C.

{
  return getMesh().local_nodes_begin();
}

localNodesEnd() [1/2]

MeshBase::node_iterator MooseMesh::localNodesEnd

(

)

Definition at line 3113 of file MooseMesh.C.

{
  return getMesh().local_nodes_end();
}

localNodesEnd() [2/2]

MeshBase::const_node_iterator MooseMesh::localNodesEnd

(

)

const

Definition at line 3125 of file MooseMesh.C.

{
  return getMesh().local_nodes_end();
}

mapPoints()

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

private

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

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

Parameters

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

Definition at line 2640 of file MooseMesh.C.

Referenced by buildPRefinementAndCoarseningMaps(), and findAdaptivityQpMaps().

{
  unsigned int n_from = from.size();
  unsigned int n_to = to.size();

  qp_map.resize(n_from);

  for (unsigned int i = 0; i < n_from; ++i)
  {
    const Point & from_point = from[i];

    QpMap & current_map = qp_map[i];

    for (unsigned int j = 0; j < n_to; ++j)
    {
      const Point & to_point = to[j];
      Real distance = (from_point - to_point).norm();

      if (distance < current_map._distance)
      {
        current_map._distance = distance;
        current_map._from = i;
        current_map._to = j;
      }
    }
  }
}

markFiniteVolumeInfoDirty()

void MooseMesh::markFiniteVolumeInfoDirty ( )

inline

Mark the finite volume information as dirty.

Definition at line 1317 of file MooseMesh.h.

{ _finite_volume_info_dirty = true; }

maxElementID()

dof_id_type MooseMesh::maxElementID ( unsigned int  elem_id_index ) const

inline

Return the maximum element ID for an extra element integer with its accessing index.

Definition at line 1122 of file MooseMesh.h.

{ return _max_ids[elem_id_index]; }

maxElemId()

dof_id_type MooseMesh::maxElemId ( ) const

virtual

Definition at line 3173 of file MooseMesh.C.

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

{
  return getMesh().max_elem_id();
}

maxHLevel()

unsigned int MooseMesh::maxHLevel ( ) const

inline

Returns the maximum h-refinement level of all elements.

Definition at line 1380 of file MooseMesh.h.

{ return _max_h_level; }

maxNodeId()

dof_id_type MooseMesh::maxNodeId ( ) const

virtual

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

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

Definition at line 3167 of file MooseMesh.C.

{
  return getMesh().max_node_id();
}

maxPLevel()

unsigned int MooseMesh::maxPLevel ( ) const

inline

Returns the maximum p-refinement level of all elements.

Definition at line 1375 of file MooseMesh.h.

{ return _max_p_level; }

meshBoundaryIds()

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

(

)

const

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

Definition at line 3257 of file MooseMesh.C.

Referenced by BoundaryRestrictable::isBoundarySubset().

{
  return _mesh_boundary_ids;
}

meshChanged()

void MooseMesh::meshChanged

(

)

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

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

Definition at line 909 of file MooseMesh.C.

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

{
  TIME_SECTION("meshChanged", 3, "Updating Because Mesh Changed");

  update();

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

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

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

meshNodesetIds()

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

(

)

const

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

Definition at line 3269 of file MooseMesh.C.

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

{
  return _mesh_nodeset_ids;
}

meshSidesetIds()

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

(

)

const

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

Definition at line 3263 of file MooseMesh.C.

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

{
  return _mesh_sideset_ids;
}

meshSubdomains()

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

(

)

const

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

Definition at line 3251 of file MooseMesh.C.

Referenced by BlockRestrictable::blockIDs(), buildElemIDInfo(), FEProblemBase::checkUserObjects(), SampledOutput::cloneMesh(), VariableValueElementSubdomainModifier::computeSubdomainID(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), FEProblemBase::duplicateVariableCheck(), getUniqueCoordSystem(), BlockRestrictable::initializeBlockRestrictable(), MultiAppDofCopyTransfer::initialSetup(), ElementSubdomainModifierBase::initialSetup(), BlockRestrictable::isBlockSubset(), BlockRestrictable::meshBlockIDs(), MooseMesh(), DOFMapOutput::output(), NonlinearSystemBase::setConstraintSecondaryValues(), setCoordSystem(), setGeneralAxisymmetricCoordAxes(), and SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater().

{
  return _mesh_subdomains;
}

messagePrefix()

std::string MooseBase::messagePrefix ( const bool  hit_prefix = true ) const

inlineinherited

Returns

A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 256 of file MooseBase.h.

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

  {
    return messagePrefix(_pars, hit_prefix);
  }

minElementID()

dof_id_type MooseMesh::minElementID ( unsigned int  elem_id_index ) const

inline

Return the minimum element ID for an extra element integer with its accessing index.

Definition at line 1127 of file MooseMesh.h.

{ return _min_ids[elem_id_index]; }

minPeriodicDistance()

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

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

Parameters

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

Returns

Real - The L2 distance between p and q

Definition at line 2337 of file MooseMesh.C.

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

minPeriodicVector()

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

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

Parameters

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

Returns

RealVectorValue - The vector pointing from p to q

Definition at line 2312 of file MooseMesh.C.

Referenced by minPeriodicDistance().

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

  return q - p;
}

mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), getBoundariesToElems(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Residual::Residual(), setBoundaryToNormalMap(), Exodus::setOutputDimension(), TagVectorAux::TagVectorAux(), UserForcingFunction::UserForcingFunction(), and VariableResidual::VariableResidual().

  {
    _si_moose_base.MooseBase::mooseDeprecated(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": deprecation");
  }

mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 314 of file MooseBase.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), MooseApp::getRecoverFileBase(), MooseApp::hasRecoverFileBase(), and MooseApp::setupOptions().

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

mooseDocumentedError()

template<typename... Args>

void MooseBase::mooseDocumentedError ( const std::string &  repo_name, const unsigned int  issue_num, Args &&...  args  ) const

inlineinherited

Definition at line 277 of file MooseBase.h.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), DGLowerDKernel::DGLowerDKernel(), HFEMDirichletBC::HFEMDirichletBC(), and LowerDIntegratedBC::LowerDIntegratedBC().

  {
    callMooseError(moose::internal::formatMooseDocumentedError(
                       repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
                   /* with_prefix = */ true);
  }

mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 271 of file MooseBase.h.

Referenced by CopyMeshPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), AutoCheckpointAction::act(), SetupMeshCompleteAction::act(), CheckIntegrityAction::act(), CreateExecutionerAction::act(), AddBoundsVectorsAction::act(), AddMeshGeneratorAction::act(), AddFVICAction::act(), AddICAction::act(), AddVectorPostprocessorAction::act(), InitProblemAction::act(), CheckFVBCAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), ChainControlSetupAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), AddMFEMSubMeshAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::adaptMesh(), ADArrayReaction::ADArrayReaction(), MooseVariableFV< Real >::adCurlSln(), MooseVariableFV< Real >::adCurlSlnNeighbor(), AddActionComponentAction::AddActionComponentAction(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DiffusionCG::addBoundaryConditionsFromComponents(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), FEProblemBase::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFVInitialCondition(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInitialCondition(), PhysicsComponentInterface::addInitialConditionsFromComponents(), FEProblemBase::addInterfaceKernel(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), MFEMProblem::addMaterial(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DiracKernelBase::addPoint(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), addQuadratureNode(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addScalarKernel(), WebServerControl::addServerAction(), AddVariableAction::addVariable(), FEProblemBase::addVectorPostprocessor(), SubProblem::addVectorTag(), MooseLinearVariableFV< Real >::adError(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), AdvectiveFluxAux::AdvectiveFluxAux(), MooseVariableBase::allDofIndices(), NEML2ModelExecutor::applyPredictor(), MooseApp::appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), MooseApp::attachRelationshipManagers(), AddPeriodicBCAction::autoTranslationBoundaries(), AuxKernelBase::AuxKernelBase(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), PiecewiseTabularInterface::buildFromFile(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularInterface::buildFromJSON(), TimedSubdomainModifier::buildFromParameters(), PiecewiseTabularInterface::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), buildLowerDMesh(), TiledMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), buildRefinementMap(), MaterialBase::buildRequiredMaterials(), buildTypedMesh(), cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), SubProblem::checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), checkDuplicateSubdomainNames(), FEProblemBase::checkExceptionAndStopSolve(), NEML2ModelExecutor::checkExecutionStage(), MaterialBase::checkExecutionStage(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), DefaultMultiAppFixedPointConvergence::checkIterationType(), DefaultNonlinearConvergence::checkIterationType(), DefaultSteadyStateConvergence::checkIterationType(), ExplicitTimeIntegrator::checkLinearConvergence(), MooseApp::checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), Sampler::checkReinitStatus(), MooseApp::checkReservedCapability(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppMFEMCopyTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppTransfer::checkSiblingsTransferSupported(), MFEMSolverBase::checkSpectralEquivalence(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), FEProblemBase::checkUserObjects(), Moose::PetscSupport::checkUserProvidedPetscOption(), DomainUserObject::checkVariable(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), LibmeshPartitioner::clone(), clone(), CombinerGenerator::CombinerGenerator(), ComparisonPostprocessor::comparisonIsTrue(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), FEProblemBase::computeBounds(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), InternalSideIntegralPostprocessor::computeFaceInfoIntegral(), SideIntegralPostprocessor::computeFaceInfoIntegral(), MooseVariableFieldBase::computeFaceValues(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), computeFiniteVolumeCoords(), HistogramVectorPostprocessor::computeHistogram(), ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), FVFluxKernel::computeJacobian(), NodalConstraint::computeJacobian(), FEProblemBase::computeJacobianTags(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), EigenProblem::computeMatricesTags(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayKernel::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), FVElementalKernel::computeOffDiagJacobian(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), MaterialBase::computeProperties(), SideFVFluxBCIntegral::computeQpIntegral(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), NodalEqualValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), NodeElemConstraint::computeQpJacobian(), ADArrayNodalKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), MassMatrix::computeQpResidual(), HDGKernel::computeQpResidual(), DiffusionLHDGDirichletBC::computeQpResidual(), DiffusionLHDGPrescribedGradientBC::computeQpResidual(), NodalEqualValueConstraint::computeQpResidual(), IPHDGBC::computeQpResidual(), KernelValue::computeQpResidual(), TorchScriptMaterial::computeQpValues(), InterfaceQpValueUserObject::computeRealValue(), ArrayKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), FVFluxBC::computeResidual(), FVFluxKernel::computeResidual(), NodalConstraint::computeResidual(), FVFluxKernel::computeResidualAndJacobian(), ResidualObject::computeResidualAndJacobian(), FEProblemBase::computeResidualAndJacobian(), HDGKernel::computeResidualAndJacobianOnSide(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualTags(), FEProblemBase::computeResidualType(), KernelScalarBase::computeScalarOffDiagJacobian(), ADKernelScalarBase::computeScalarQpResidual(), ADMortarScalarBase::computeScalarQpResidual(), MortarScalarBase::computeScalarQpResidual(), KernelScalarBase::computeScalarQpResidual(), TimeStepper::computeStep(), ActuallyExplicitEuler::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CentralDifference::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), MultiAppGeometricInterpolationTransfer::computeTransformation(), BuildArrayVariableAux::computeValue(), TagVectorArrayVariableAux::computeValue(), NearestNodeValueAux::computeValue(), ProjectionAux::computeValue(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), MooseApp::copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), CoupledForceNodalKernel::CoupledForceNodalKernel(), MultiApp::createApp(), MooseApp::createExecutors(), AddVariableAction::createInitialConditionAction(), MooseApp::createRMFromTemplateAndInit(), Function::curl(), MooseVariableFV< Real >::curlPhi(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), SidesetInfoVectorPostprocessor::dataHelper(), ReporterTransferInterface::declareClone(), Moose::Kokkos::MaterialBase::declareKokkosPropertyByName(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), DefaultSteadyStateConvergence::DefaultSteadyStateConvergence(), FunctorRelationshipManager::delete_remote_elements(), deleteRemoteElements(), BicubicSplineFunction::derivative(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), detectPairedSidesets(), MooseApp::determineLibtorchDeviceType(), FEProblemBase::determineSolverSystem(), DGKernel::DGKernel(), MeshDiagnosticsGenerator::diagnosticsLog(), DistributedPositions::DistributedPositions(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), MooseVariableFV< Real >::divPhi(), FunctorRelationshipManager::dofmap_reinit(), EigenProblem::doFreeNonlinearPowerIterations(), FEProblemBase::duplicateVariableCheck(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementIntegerAux::ElementIntegerAux(), ElementMaterialSampler::ElementMaterialSampler(), ElementQualityAux::ElementQualityAux(), ElementUOAux::ElementUOAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), DistributedRectilinearMeshGenerator::elemId(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), EigenKernel::enabled(), MooseApp::errorCheck(), errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), SideIntegralPostprocessor::errorNoFaceInfo(), SideIntegralFunctorPostprocessorTempl< false >::errorNoFaceInfo(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), FixedPointSolve::examineFixedPointConvergence(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), RealToBoolChainControl::execute(), RestartableDataReporter::execute(), DiscreteElementUserObject::execute(), PositionsFunctorValueSampler::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), NodalValueSampler::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppPostprocessorTransfer::execute(), ElementQualityChecker::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), InterfaceQpUserObjectBase::execute(), TransientBase::execute(), LeastSquaresFit::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFitHistory::execute(), WebServerControl::execute(), Eigenvalue::execute(), TimeExtremeValue::execute(), DomainUserObject::execute(), FEProblemBase::execute(), FEProblemBase::executeControls(), MooseApp::executeExecutioner(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), NEML2ModelExecutor::extractOutputs(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), NEML2ModelExecutor::fillInputs(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), VerifyNodalUniqueID::finalize(), ParsedVectorReporter::finalize(), VerifyElementUniqueID::finalize(), ParsedVectorVectorRealReductionReporter::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), DiscreteVariableResidualNorm::finalize(), NearestPointAverage::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), MooseApp::finalizeRestore(), Transfer::find_sys(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVMassMatrix::FVMassMatrix(), FVMatAdvection::FVMatAdvection(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), GapValueAux::GapValueAux(), WorkBalance::gather(), ElementSubdomainModifierBase::gatherPatchElements(), Boundary2DDelaunayGenerator::General2DDelaunay(), ElementOrderConversionGenerator::generate(), MoveNodeGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), SideSetsFromNormalsGenerator::generate(), SmoothMeshGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), MeshRepairGenerator::generate(), SideSetsFromPointsGenerator::generate(), StitchMeshGenerator::generate(), GeneratedMeshGenerator::generate(), FlipSidesetGenerator::generate(), CoarsenBlockGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BreakMeshByBlockGenerator::generate(), MeshDiagnosticsGenerator::generate(), ParsedGenerateNodeset::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), AdvancedExtruderGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), SpiralAnnularMeshGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), CutMeshByLevelSetGeneratorBase::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), MeshGenerator::generateCSG(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), RandomICBase::generateRandom(), GenericConstantMaterialTempl< is_ad >::GenericConstantMaterialTempl(), GenericConstantVectorMaterialTempl< is_ad >::GenericConstantVectorMaterialTempl(), GenericFunctionMaterialTempl< is_ad >::GenericFunctionMaterialTempl(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), DisplacedProblem::getActualFieldVariable(), FEProblemBase::getActualFieldVariable(), DisplacedProblem::getArrayVariable(), FEProblemBase::getArrayVariable(), getAxisymmetricRadialCoord(), NEML2BatchIndexGenerator::getBatchIndex(), getBlockConnectedBlocks(), VariableOldValueBounds::getBound(), getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), WebServerControl::getClientInfo(), getCoarseningMap(), NodalPatchRecoveryBase::getCoefficients(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), FEProblemBase::getConvergence(), getCoordSystem(), PhysicsBase::getCoupledPhysics(), PropertyReadFile::getData(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), FEProblemBase::getDistribution(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), GhostingUserObject::getElementalValue(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), PropertyReadFile::getElementData(), getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), getElemIDMapping(), getElemIDsOnBlocks(), MultiAppFieldTransfer::getEquationSystem(), WebServerControl::Response::getError(), MultiApp::getExecutioner(), MooseApp::getExecutor(), MFEMVectorFESpace::getFECName(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVMatsAndDependencies(), getGeneralAxisymmetricCoordAxis(), MaterialPropertyInterface::getGenericMaterialPropertyByName(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), FEProblemBase::getKokkosFunction(), FunctionInterface::getKokkosFunctionByName(), MaterialPropertyInterface::getKokkosMaterialPropertyByName(), FEProblemBase::getLinearConvergenceNames(), SolutionUserObjectBase::getLocalVarIndex(), Material::getMaterialByName(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), FEProblemBase::getMultiAppFixedPointConvergenceName(), DistributedRectilinearMeshGenerator::getNeighbors(), Times::getNextTime(), getNodeBlockIds(), PropertyReadFile::getNodeData(), getNodeList(), FEProblemBase::getNonlinearConvergenceNames(), EigenProblem::getNonlinearEigenSystem(), FEProblemBase::getNonlinearSystem(), NEML2ModelExecutor::getOutput(), NEML2ModelExecutor::getOutputDerivative(), NEML2ModelExecutor::getOutputParameterDerivative(), getPairedBoundaryMapping(), MaterialOutputAction::getParams(), ImageMeshGenerator::GetPixelInfo(), ImageMesh::GetPixelInfo(), PlaneIDMeshGenerator::getPlaneID(), Positions::getPosition(), Positions::getPositions(), FEProblemBase::getPositionsObject(), Positions::getPositionsVector2D(), Positions::getPositionsVector3D(), Positions::getPositionsVector4D(), PostprocessorInterface::getPostprocessorValueByNameInternal(), Times::getPreviousTime(), ComponentMaterialPropertyInterface::getPropertyValue(), InterfaceQpUserObjectBase::getQpValue(), getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), MooseApp::getRMClone(), FEProblemBase::getSampler(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), MooseObject::getSharedPtr(), InterfaceQpUserObjectBase::getSideAverageValue(), PhysicsBase::getSolverSystem(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), FEProblemBase::getSteadyStateConvergenceName(), getSubdomainBoundaryIds(), TimedSubdomainModifier::getSubdomainIDAndCheck(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), Times::getTimeAtIndex(), FEProblemBase::getTimeFromStateArg(), TransientBase::getTimeIntegratorNames(), Times::getTimes(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), getUniqueCoordSystem(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), VectorPostprocessorComponent::getValue(), NumRelationshipManagers::getValue(), Residual::getValue(), SideAverageValue::getValue(), JSONFileReader::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), JSONFileReader::getVector(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingFromUOAux::GhostingFromUOAux(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), Function::gradient(), FEProblemBase::handleException(), Terminator::handleMessage(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), HDGKernel::HDGKernel(), TransientBase::incrementStepOrReject(), FixedPointIterationAdaptiveDT::init(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), EigenExecutionerBase::init(), ExplicitTimeIntegrator::init(), TransientBase::init(), FEProblem::init(), AddAuxVariableAction::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AddVariableAction::init(), init(), Sampler::init(), FEProblemBase::init(), MultiApp::init(), FEProblemBase::initialAdaptMesh(), NestedDivision::initialize(), ReporterPositions::initialize(), DistributedPositions::initialize(), TransformedPositions::initialize(), ElementGroupCentroidPositions::initialize(), FunctorPositions::initialize(), ReporterTimes::initialize(), FunctorTimes::initialize(), ParsedDownSelectionPositions::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SteffensenSolve::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), ChainControlDataPostprocessor::initialSetup(), MultiAppConservativeTransfer::initialSetup(), PiecewiseLinearBase::initialSetup(), FullSolveMultiApp::initialSetup(), PiecewiseLinear::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), CoarsenedPiecewiseLinear::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), LinearFVAdvection::initialSetup(), SolutionScalarAux::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVDiffusion::initialSetup(), ExplicitTimeIntegrator::initialSetup(), SolutionAux::initialSetup(), ReferenceResidualConvergence::initialSetup(), NodalVariableValue::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), ElementSubdomainModifierBase::initialSetup(), Exodus::initialSetup(), CSV::initialSetup(), MooseParsedFunction::initialSetup(), SolutionUserObjectBase::initialSetup(), FEProblemBase::initialSetup(), SubProblem::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), Function::integral(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceTimeKernel::InterfaceTimeKernel(), InternalSideIndicatorBase::InternalSideIndicatorBase(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), Sampler::isAdaptiveSamplingCompleted(), isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), MooseApp::libNameToAppName(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), MooseApp::loadLibraryAndDependencies(), MultiAppGeneralFieldTransfer::locatePointReceivers(), LowerBoundNodalKernel::LowerBoundNodalKernel(), MooseLinearVariableFV< Real >::lowerDError(), PNGOutput::makePNG(), ReporterPointMarker::markerSetup(), SubProblem::markFamilyPRefinement(), MassMatrix::MassMatrix(), Material::Material(), MaterialRealTensorValueAuxTempl< is_ad >::MaterialRealTensorValueAuxTempl(), MaterialRealVectorValueAuxTempl< T, is_ad, is_functor >::MaterialRealVectorValueAuxTempl(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), MFEMCrossProductAux::MFEMCrossProductAux(), MFEMDotProductAux::MFEMDotProductAux(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableConstMonomial::MooseVariableConstMonomial(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), FEProblemBase::needsPreviousNewtonIteration(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), MooseVariableFV< Real >::nodalDofIndex(), MooseVariableFV< Real >::nodalDofIndexNeighbor(), MooseLinearVariableFV< Real >::nodalError(), MooseVariableFV< Real >::nodalMatrixTagValue(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalScalarKernel::NodalScalarKernel(), MooseVariableFV< Real >::nodalValueArray(), MooseVariableFV< Real >::nodalValueOldArray(), MooseVariableFV< Real >::nodalValueOlderArray(), NodalVariableValue::NodalVariableValue(), MooseVariableFV< Real >::nodalVectorTagValue(), DistributedRectilinearMeshGenerator::nodeId(), MooseVariableFV< Real >::numberOfDofsNeighbor(), NumDOFs::NumDOFs(), NumFailedTimeSteps::NumFailedTimeSteps(), DistributedRectilinearMeshGenerator::numNeighbors(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), XDA::output(), SolutionHistory::output(), Exodus::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), MooseApp::outputMachineReadableData(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), Exodus::outputSetup(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), DistributedRectilinearMeshGenerator::paritionSquarely(), PiecewiseBilinear::parse(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), MultiAppConservativeTransfer::performAdjustment(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), MooseVariableFV< Real >::phiLowerSize(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), PiecewiseTabularBase::PiecewiseTabularBase(), PiecewiseTabularInterface::PiecewiseTabularInterface(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), SolutionUserObjectBase::pointValueGradientWrapper(), SolutionUserObjectBase::pointValueWrapper(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), AStableDirk4::postResidual(), LStableDirk4::postResidual(), ExplicitRK2::postResidual(), EigenProblem::postScaleEigenVector(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), ADKernelValueTempl< T >::precomputeQpJacobian(), FunctorKernel::precomputeQpResidual(), Predictor::Predictor(), TransientBase::preExecute(), prepare(), prepared(), ElementSubdomainModifierBase::prepareVariableForReinitialization(), FixedPointSolve::printFixedPointConvergenceReason(), PseudoTimestep::PseudoTimestep(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusII(), SolutionUserObjectBase::readXda(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), MFEMTransient::relativeSolutionDifferenceNorm(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), MooseApp::run(), MooseApp::runInputs(), PiecewiseMultiInterpolation::sample(), ScalarComponentIC::ScalarComponentIC(), MortarScalarBase::scalarVariable(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), BicubicSplineFunction::secondDerivative(), MooseVariableFV< Real >::secondPhi(), MooseVariableFV< Real >::secondPhiFace(), MooseVariableFV< Real >::secondPhiFaceNeighbor(), MooseVariableFV< Real >::secondPhiNeighbor(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), setCoordSystem(), FEProblemBase::setCoupling(), PiecewiseBase::setData(), FileOutput::setFileBaseInternal(), setGeneralAxisymmetricCoordAxes(), FEProblemSolve::setInnerSolve(), MeshGenerator::setMeshProperty(), MooseApp::setMFEMDevice(), FVPointValueConstraint::setMyElem(), FEProblemBase::setNonlocalCouplingMatrix(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), AddPeriodicBCAction::setPeriodicVars(), MFEMSolverBase::setPreconditioner(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), Split::setup(), TransientMultiApp::setupApp(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), TimePeriodBase::setupTimes(), IntegratedBCBase::shouldApply(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SideAdvectiveFluxIntegralTempl< is_ad >::SideAdvectiveFluxIntegralTempl(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), MooseVariableBase::sizeMatrixTagData(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObjectBase::SolutionUserObjectBase(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), TimeIntegrator::solve(), FEProblemBase::solverSysNum(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialPoints(), NearestPointAverage::spatialValue(), NearestPointIntegralVariablePostprocessor::spatialValue(), MeshDivisionFunctorReductionVectorPostprocessor::spatialValue(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), MultiAppGeometricInterpolationTransfer::subdomainIDsNode(), Constraint::subdomainSetup(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), MaterialBase::subdomainSetup(), FEProblemBase::swapBackMaterialsNeighbor(), DisplacedProblem::systemBaseLinear(), Console::systemInfoFlags(), FEProblemBase::systemNumForVariable(), TerminateChainControl::terminate(), Terminator::Terminator(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), Function::timeDerivative(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeExtremeValue::TimeExtremeValue(), Function::timeIntegral(), MooseLinearVariableFV< Real >::timeIntegratorError(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriodBase::TimePeriodBase(), VectorPostprocessorVisualizationAux::timestepSetup(), MultiAppDofCopyTransfer::transfer(), MultiAppMFEMCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransformedPositions::TransformedPositions(), FEProblemBase::trustUserCouplingMatrix(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), MooseBase::uniqueName(), Positions::unrollMultiDPositions(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), Checkpoint::updateCheckpointFiles(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObjectBase::updateExodusBracketingTimeIndices(), FEProblemBase::updateMaxQps(), MFEMHypreAMS::updateSolver(), MFEMHypreADS::updateSolver(), MFEMHyprePCG::updateSolver(), MFEMHypreFGMRES::updateSolver(), MFEMGMRESSolver::updateSolver(), MFEMCGSolver::updateSolver(), MFEMHypreGMRES::updateSolver(), MFEMSuperLU::updateSolver(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointAverage::userObjectValue(), NearestPointIntegralVariablePostprocessor::userObjectValue(), BoundingBoxIC::value(), PiecewiseConstantFromCSV::value(), IntegralPreservingFunctionIC::value(), Axisymmetric2D3DSolutionFunction::value(), Function::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), AddVariableAction::variableType(), VariableValueVolumeHistogram::VariableValueVolumeHistogram(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), VectorNodalBC::VectorNodalBC(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), MooseParsedGradFunction::vectorValue(), MooseParsedFunction::vectorValue(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), VTKOutput::VTKOutput(), WebServerControl::WebServerControl(), MooseApp::writeRestartableMetaData(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
  }

mooseErrorNonPrefixed()

template<typename... Args>

void MooseBase::mooseErrorNonPrefixed ( Args &&...  args ) const

inlineinherited

Emits an error without the prefixing included in mooseError().

Definition at line 290 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
  }

mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 321 of file MooseBase.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramInfo(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), MooseApp::setupOptions(), SolutionUserObjectBase::SolutionUserObjectBase(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

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

mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), MFEMProblem::addFunction(), addPeriodicVariable(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), SampledOutput::cloneMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), VariableValueElementSubdomainModifier::computeSubdomainID(), GapValueAux::computeValue(), MultiApp::createApp(), DebugResidualAux::DebugResidualAux(), MeshDiagnosticsGenerator::diagnosticsLog(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), CartesianGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), MFEMVectorFESpace::getFECName(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), SphericalGridDivision::initialize(), CylindricalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), CartesianGridDivision::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MaterialOutputAction::outputHelper(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

  {
    _si_moose_base.MooseBase::mooseWarning(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

Referenced by DataFileInterface::getDataFilePath(), MooseApp::loadLibraryAndDependencies(), and MooseBase::paramWarning().

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

mooseWarningNonPrefixed() [1/2]

template<typename... Args>

void SolutionInvalidInterface::mooseWarningNonPrefixed ( Args &&...  args ) const

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

mooseWarningNonPrefixed() [2/2]

template<typename... Args>

void MooseBase::mooseWarningNonPrefixed ( Args &&...  args ) const

inlineinherited

Emits a warning without the prefixing included in mooseWarning().

Definition at line 308 of file MooseBase.h.

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

nActiveElem()

virtual dof_id_type MooseMesh::nActiveElem ( ) const

inlinevirtual

Reimplemented in MFEMMesh.

Definition at line 321 of file MooseMesh.h.

{ return _mesh->n_active_elem(); }

nActiveLocalElem()

virtual dof_id_type MooseMesh::nActiveLocalElem ( ) const

inlinevirtual

Reimplemented in MFEMMesh.

Definition at line 322 of file MooseMesh.h.

{ return _mesh->n_active_local_elem(); }

name()

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

inlineinherited

Get the name of the class.

Returns

The name of the class

Definition at line 103 of file MooseBase.h.

Referenced by AddElementalFieldAction::act(), CopyNodalVarsAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), SetupTimeIntegratorAction::act(), AddActionComponentAction::act(), SetupResidualDebugAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), Registry::addDataFilePath(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), SubProblem::addFunctor(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), DiffusionLHDGKernel::additionalROVariables(), IPHDGAssemblyHelper::additionalROVariables(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMPreconditioner(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), InitialConditionWarehouse::addObject(), FEProblemBase::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), InitialConditionBase::addPostprocessorDependencyHelper(), AuxKernelBase::addPostprocessorDependencyHelper(), UserObject::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), InitialConditionBase::addUserObjectDependencyHelper(), AuxKernelBase::addUserObjectDependencyHelper(), UserObject::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), AuxKernelBase::addVectorPostprocessorDependencyHelper(), UserObject::addVectorPostprocessorDependencyHelper(), MooseLinearVariableFV< Real >::adError(), Output::advancedExecuteOn(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MooseVariableBase::allDofIndices(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), Registry::appNameFromAppPath(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), AuxKernelBase::AuxKernelBase(), Function::average(), MultiApp::backup(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), MFEMFESpace::buildFEC(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromXY(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), ParsedConvergence::checkConvergence(), DefaultNonlinearConvergence::checkConvergence(), FEProblemBase::checkDependMaterialsHelper(), SamplerBase::checkForStandardFieldVariableType(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Moose::Kokkos::Material::checkMaterialProperty(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), DomainUserObject::checkVariable(), BlockRestrictable::checkVariable(), Coupleable::checkWritableVar(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MooseBase::connectControllableParams(), ConstantPostprocessor::ConstantPostprocessor(), Coupleable::coupledName(), CommonOutputAction::create(), MultiApp::createApp(), MooseApp::createExecutors(), MeshGeneratorSystem::createMeshGeneratorOrder(), MooseApp::createRecoverablePerfGraph(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), DebugResidualAux::DebugResidualAux(), MaterialBase::declareADProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), Registry::determineDataFilePath(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), errorIfDistributedMesh(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), SideValueSampler::execute(), RestartableDataReporter::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), WebServerControl::execute(), MultiAppGeneralFieldTransfer::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionArrayAux::FunctionArrayAux(), FunctionDT::FunctionDT(), FunctionIC::functionName(), FVFunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), GapValueAux::GapValueAux(), MooseServer::gatherDocumentSymbols(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), SideSetsFromNodeSetsGenerator::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), MeshGenerator::getCSGBase(), MeshGenerator::getCSGBasesByName(), Registry::getDataFilePath(), UserObject::getDependObjects(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), MooseApp::getExecutor(), FEProblemBase::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), AuxKernelTempl< Real >::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), MFEMProblem::getGridFunction(), FEProblemBase::getKokkosFunction(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), AuxKernelTempl< Real >::getMaterialProperty(), Material::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), AuxKernelTempl< Real >::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), AuxKernelTempl< Real >::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), MFEMGeneralUserObject::getMatrixCoefficient(), MFEMGeneralUserObject::getMatrixCoefficientByName(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), ActionWarehouse::getMooseAppName(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), MooseServer::getObjectParameters(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), OutputWarehouse::getOutput(), MooseBase::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMGeneralUserObject::getScalarCoefficient(), MFEMGeneralUserObject::getScalarCoefficientByName(), TimedSubdomainModifier::getSubdomainIDAndCheck(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMGeneralUserObject::getVectorCoefficient(), MFEMGeneralUserObject::getVectorCoefficientByName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), MooseApp::hasMeshGenerator(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), IterationAdaptiveDT::init(), AddVariableAction::init(), AdvancedOutput::init(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), BoundaryRestrictable::initializeBoundaryRestrictable(), JSONOutput::initialSetup(), SideFVFluxBCIntegral::initialSetup(), SolutionScalarAux::initialSetup(), MultiAppProjectionTransfer::initialSetup(), NodalVariableValue::initialSetup(), Console::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MeshGenerator::isChildMeshGenerator(), DerivativeMaterialInterface< JvarMapKernelInterface< GenericKernelGrad< is_ad > > >::isNotObjectVariable(), MeshGenerator::isNullMeshName(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), MooseLinearVariableFV< Real >::lowerDError(), Marker::Marker(), MaterialBase::markMatPropRequested(), Material::Material(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshGenerator::meshPropertyPrefix(), MooseBase::messagePrefix(), OutputWarehouse::mooseConsole(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< Real >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MooseLinearVariableFV< Real >::nodalError(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), Registry::objData(), MeshGenerator::Comparator::operator()(), ProgressOutput::output(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), MaterialOutputAction::outputHelper(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), SolutionInvalidInterface::paramWarning(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), MooseApp::possiblyLoadRestartableMetaData(), PhysicsBase::prefix(), prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), FEProblemBase::projectInitialConditionOnCustomRange(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), AppFactory::reg(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), MooseApp::registerRestartableDataMapName(), MooseApp::registerRestartableNameWithFilter(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), FEProblemBase::setAuxKernelParamsAndLog(), setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), FEProblemBase::setPostprocessorValueByName(), FEProblemBase::setResidualObjectParamsAndLog(), setSubdomainName(), NodeSetsGeneratorBase::setup(), Split::setup(), SideSetsGeneratorBase::setup(), TransientMultiApp::setupApp(), FullSolveMultiApp::showStatusMessage(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), MaterialBase::storeBoundaryZeroMatProp(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), MaterialBase::storeSubdomainZeroMatProp(), SubProblem::storeSubdomainZeroMatProp(), ConstraintWarehouse::subdomainsCovered(), MaterialBase::subdomainSetup(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< Real >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransientMultiApp::TransientMultiApp(), MooseServer::traverseParseTreeAndFillSymbols(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVFluxBC::uOnGhost(), FVFluxBC::uOnUSub(), UserObject::UserObject(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and MooseApp::writeRestartableMetaData().

  {
    mooseAssert(_name.size(), "Empty name");
    return _name;
  }

needGhostGhostedBoundaries()

void MooseMesh::needGhostGhostedBoundaries ( bool  needghost )

inline

Whether or not we want to ghost ghosted boundaries.

Definition at line 612 of file MooseMesh.h.

Referenced by DistributedRectilinearMeshGenerator::generate().

{ _need_ghost_ghosted_boundaries = needghost; }

needsPrepareForUse()

void MooseMesh::needsPrepareForUse

(

)

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

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

Definition at line 3245 of file MooseMesh.C.

{
  prepared(false);
}

needsRemoteElemDeletion() [1/2]

void MooseMesh::needsRemoteElemDeletion ( bool  need_delete )

inline

Set whether we need to delete remote elements.

Definition at line 1082 of file MooseMesh.h.

{ _need_delete = need_delete; }

needsRemoteElemDeletion() [2/2]

bool MooseMesh::needsRemoteElemDeletion ( ) const

inline

Whether we need to delete remote elements.

Definition at line 1087 of file MooseMesh.h.

{ return _need_delete; }

nElem()

dof_id_type MooseMesh::nElem ( ) const

virtual

Definition at line 3161 of file MooseMesh.C.

Referenced by PropertyReadFile::getElementData(), and PropertyReadFile::readData().

{
  return getMesh().n_elem();
}

nFace()

unsigned int MooseMesh::nFace ( ) const

inline

accessors for the FaceInfo objects

Definition at line 1165 of file MooseMesh.h.

{ return _face_info.size(); }

nLocalNodes()

virtual dof_id_type MooseMesh::nLocalNodes ( ) const

inlinevirtual

Definition at line 320 of file MooseMesh.h.

{ return _mesh->n_local_nodes(); }

nNodes()

dof_id_type MooseMesh::nNodes ( ) const

virtual

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

Definition at line 3155 of file MooseMesh.C.

Referenced by PropertyReadFile::getNodeData(), and PropertyReadFile::readData().

{
  return getMesh().n_nodes();
}

node() [1/2]

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

virtual

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

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

Definition at line 847 of file MooseMesh.C.

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

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

node() [2/2]

Node & MooseMesh::node ( const dof_id_type  i )

virtual

Definition at line 854 of file MooseMesh.C.

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

nodePtr() [1/2]

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

virtual

Definition at line 875 of file MooseMesh.C.

Referenced by ElementSubdomainModifierBase::reinitializedNodeRange().

{
  return &nodeRef(i);
}

nodePtr() [2/2]

Node * MooseMesh::nodePtr ( const dof_id_type  i )

virtual

Definition at line 881 of file MooseMesh.C.

{
  return &nodeRef(i);
}

nodeRef() [1/2]

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

virtual

Definition at line 861 of file MooseMesh.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NearestNodeLocator::findNodes(), NonlinearSystemBase::getNodeDofs(), NodePositions::initialize(), node(), nodePtr(), nodeRef(), ResetDisplacedMeshThread::onNode(), DisplacedProblem::UpdateDisplacedMeshThread::onNode(), NearestNodeThread::operator()(), SecondaryNeighborhoodThread::operator()(), PenetrationThread::operator()(), NonlinearSystemBase::overwriteNodeFace(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), NonlinearSystemBase::setConstraintSecondaryValues(), EqualValueBoundaryConstraint::updateConstrainedNodes(), and NearestNodeLocator::updatePatch().

{
  const auto node_ptr = queryNodePtr(i);
  mooseAssert(node_ptr, "Missing node");
  return *node_ptr;
}

nodeRef() [2/2]

Node & MooseMesh::nodeRef ( const dof_id_type  i )

virtual

Definition at line 869 of file MooseMesh.C.

{
  return const_cast<Node &>(const_cast<const MooseMesh *>(this)->nodeRef(i));
}

nodeSetNodes()

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

inline

Returns

A map from nodeset ids to the vector of node ids in the nodeset

Definition at line 2228 of file MooseMesh.h.

{
  return _node_set_nodes;
}

nodeToActiveSemilocalElemMap()

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

(

)

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

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

Note

Extra ghosted elements are not included in this map!

Definition at line 1256 of file MooseMesh.C.

Referenced by FEProblemBase::initialSetup().

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

    // This is allowing the timing to be run even with threads
    // This is safe because all threads will be waiting on this section when it runs
    // NOTE: Do not copy this construction to other places without thinking REALLY hard about it
    // The PerfGraph is NOT threadsafe and will cause all kinds of havok if care isn't taken
    auto in_threads = Threads::in_threads;
    Threads::in_threads = false;
    TIME_SECTION("nodeToActiveSemilocalElemMap", 5, "Building SemiLocalElemMap");
    Threads::in_threads = in_threads;

    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

(

)

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

Definition at line 1228 of file MooseMesh.C.

Referenced by NodalPatchRecovery::compute(), NodalPatchRecoveryAuxBase::computeValue(), ProjectionAux::computeValue(), PenetrationLocator::detectPenetration(), DMMooseGetEmbedding_Private(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), NearestNodeLocator::findNodes(), ElementSubdomainModifierBase::findReinitializedElemsAndNodes(), ElementSubdomainModifierBase::gatherPatchElements(), NodePositions::initialize(), ActivateElementsUserObjectBase::isNewlyActivated(), LinearNodalConstraint::LinearNodalConstraint(), ElementSubdomainModifierBase::nodeIsNewlyReinitialized(), GhostHigherDLowerDPointNeighbors::operator()(), EqualValueBoundaryConstraint::updateConstrainedNodes(), RandomData::updateGenerators(), and NearestNodeLocator::updatePatch().

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

    if (!_node_to_elem_map_built)
    {
      // This is allowing the timing to be run even with threads
      // This is safe because all threads will be waiting on this section when it runs
      // NOTE: Do not copy this construction to other places without thinking REALLY hard about it
      // The PerfGraph is NOT threadsafe and will cause all kinds of havok if care isn't taken
      auto in_threads = Threads::in_threads;
      Threads::in_threads = false;
      TIME_SECTION("nodeToElemMap", 5, "Building Node To Elem Map");
      Threads::in_threads = in_threads;

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

nPartitions()

virtual unsigned int MooseMesh::nPartitions ( ) const

inlinevirtual

Definition at line 324 of file MooseMesh.h.

{ return _mesh->n_partitions(); }

nSubdomains()

virtual SubdomainID MooseMesh::nSubdomains ( ) const

inlinevirtual

Reimplemented in MFEMMesh.

Definition at line 323 of file MooseMesh.h.

{ return _mesh->n_subdomains(); }

onMeshChanged()

void MooseMesh::onMeshChanged ( )

virtual

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

Referenced by meshChanged().

{
}

operator const libMesh::MeshBase &()

MooseMesh::operator const libMesh::MeshBase &

(

)

const

Definition at line 3519 of file MooseMesh.C.

{ return getMesh(); }

operator libMesh::MeshBase &()

MooseMesh::operator libMesh::MeshBase &

(

)

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

Definition at line 3517 of file MooseMesh.C.

{ return getMesh(); }

operator=()

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

delete

ownedElemInfoBegin()

MooseMesh::elem_info_iterator MooseMesh::ownedElemInfoBegin

(

)

Iterators to owned faceInfo objects.

These faceInfo-s are required for the face loops and to filter out the faceInfo-s that are not owned by this processor in case we have a distributed mesh and we included FaceInfo objects that are on processor boundaries

Definition at line 1578 of file MooseMesh.C.

Referenced by LinearSystem::computeGradients(), LinearSystem::computeLinearSystemInternal(), and FEProblemBase::projectSolution().

{
  return elem_info_iterator(_elem_info.begin(),
                            _elem_info.end(),
                            Predicates::NotNull<std::vector<const ElemInfo *>::iterator>());
}

ownedElemInfoEnd()

MooseMesh::elem_info_iterator MooseMesh::ownedElemInfoEnd

(

)

Definition at line 1586 of file MooseMesh.C.

Referenced by LinearSystem::computeGradients(), LinearSystem::computeLinearSystemInternal(), and FEProblemBase::projectSolution().

{
  return elem_info_iterator(_elem_info.end(),
                            _elem_info.end(),
                            Predicates::NotNull<std::vector<const ElemInfo *>::iterator>());
}

ownedFaceInfoBegin()

MooseMesh::face_info_iterator MooseMesh::ownedFaceInfoBegin

(

)

Iterators to owned faceInfo objects.

These faceInfo-s are required for the face loops and to filter out the faceInfo-s that are not owned by this processor in case we have a distributed mesh and we included FaceInfo objects that are on processor boundaries

Definition at line 1560 of file MooseMesh.C.

Referenced by LinearSystem::computeGradients(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

{
  return face_info_iterator(
      _face_info.begin(),
      _face_info.end(),
      libMesh::Predicates::pid<std::vector<const FaceInfo *>::iterator>(this->processor_id()));
}

ownedFaceInfoEnd()

MooseMesh::face_info_iterator MooseMesh::ownedFaceInfoEnd

(

)

Definition at line 1569 of file MooseMesh.C.

Referenced by LinearSystem::computeGradients(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

{
  return face_info_iterator(
      _face_info.end(),
      _face_info.end(),
      libMesh::Predicates::pid<std::vector<const FaceInfo *>::iterator>(this->processor_id()));
}

paramError()

template<typename... Args>

void MooseBase::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 439 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), SetupDebugAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayReactionNodalKernelTempl< is_ad >::ArrayReactionNodalKernelTempl(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelBase::AuxKernelBase(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), MFEMMesh::buildMesh(), CartesianGridDivision::CartesianGridDivision(), checkComponent(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), FunctorAux::computeValue(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CylindricalGridDivision::CylindricalGridDivision(), DebugResidualAux::DebugResidualAux(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), ReporterPointSource::fillPoint(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), ForcingFunctionAux::ForcingFunctionAux(), FullSolveMultiApp::FullSolveMultiApp(), FunctionArrayAux::FunctionArrayAux(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorAux::FunctorAux(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), FunctorCoordinatesFunctionAux::FunctorCoordinatesFunctionAux(), FunctorElementalGradientAuxTempl< is_ad >::FunctorElementalGradientAuxTempl(), FunctorExtremaPositions::FunctorExtremaPositions(), FunctorIC::FunctorIC(), FunctorPositions::FunctorPositions(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), Boundary2DDelaunayGenerator::General2DDelaunay(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ExtraNodesetGenerator::generate(), AddMetaDataGenerator::generate(), BlockToMeshConverterGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementsToTetrahedronsConverter::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BlockDeletionGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryElementConversionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), AdvancedExtruderGenerator::generate(), BreakMeshByElementGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), GenericConstantStdVectorMaterialTempl< is_ad >::GenericConstantStdVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), PropertyReadFile::getBlockData(), ComponentBoundaryConditionInterface::getBoundaryCondition(), MultiApp::getCommandLineArgs(), PropertyReadFile::getData(), PropertyReadFile::getFileNames(), Sampler::getGlobalSamples(), ComponentInitialConditionInterface::getInitialCondition(), NEML2Action::getInputParameterMapping(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), Sampler::getNextLocalRow(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), JSONOutput::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), ElementSubdomainModifierBase::initialSetup(), SampledOutput::initSample(), AddMetaDataGenerator::inputChecker(), IntegratedBC::IntegratedBC(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceValueUserObjectAux::InterfaceValueUserObjectAux(), InternalSideIndicatorBase::InternalSideIndicatorBase(), InterpolatedStatefulMaterialTempl< T >::InterpolatedStatefulMaterialTempl(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), MultiApp::keepSolutionDuringRestore(), Kernel::Kernel(), KokkosBoundNodalKernel< KokkosUpperBoundNodalKernel >::KokkosBoundNodalKernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMDotProductAux::MFEMDotProductAux(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMSumAux::MFEMSumAux(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseMesh(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NearestNodeValueAux::NearestNodeValueAux(), NEML2Action::NEML2Action(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), ParsedVectorRealReductionReporter::ParsedVectorRealReductionReporter(), ParsedVectorReporter::ParsedVectorReporter(), ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshGenerator::PolyLineMeshGenerator(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectionAux::ProjectionAux(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusII(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), setPartitioner(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupParameterDerivativeMappings(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), TimeSequenceStepperBase::updateSequence(), UserObject::UserObject(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), ParsedMaterialBase::validateVectorNames(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

parameters()

const InputParameters& MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 131 of file MooseBase.h.

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), SetupDebugAction::act(), CSGOnlyAction::act(), AddActionComponentAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), MFEMProblem::addAuxVariable(), DisplacedProblem::addAuxVariable(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), MFEMProblem::addGridFunction(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::addMFEMPreconditioner(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), MFEMProblem::addSubMesh(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), MFEMProblem::addVariable(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), MooseMeshUtils::copyIntoMesh(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementMaterialSampler::ElementMaterialSampler(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), ElementSubdomainModifierBase::extrapolatePolynomial(), FEProblem::FEProblem(), FixedPointSolve::FixedPointSolve(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GapValueAux::GapValueAux(), ParsedSubdomainGeneratorBase::generate(), ActionWarehouse::getCurrentActionName(), ExecutorInterface::getExecutor(), Material::getMaterial(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), AuxKernelBase::getVariableHelper(), VectorPostprocessorInterface::getVectorPostprocessorName(), GhostingUserObject::GhostingUserObject(), MeshGeneratorSystem::hasDataDrivenAllowed(), AttribSystem::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MooseObject::isKokkosObject(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MFEMCGSolver::MFEMCGSolver(), MFEMGMRESSolver::MFEMGMRESSolver(), MFEMHypreADS::MFEMHypreADS(), MFEMHypreAMS::MFEMHypreAMS(), MFEMHypreBoomerAMG::MFEMHypreBoomerAMG(), MFEMHypreFGMRES::MFEMHypreFGMRES(), MFEMHypreGMRES::MFEMHypreGMRES(), MFEMHyprePCG::MFEMHyprePCG(), MFEMOperatorJacobiSmoother::MFEMOperatorJacobiSmoother(), MFEMSuperLU::MFEMSuperLU(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), ConsoleUtils::outputLegacyInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MooseServer::parseDocumentForDiagnostics(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), NEML2Action::printSummary(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), FEProblemBase::setResidualObjectParamsAndLog(), SideSetsGeneratorBase::setup(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), Moose::PetscSupport::storePetscOptions(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), and MooseApp::~MooseApp().

{ return _pars; }

paramInfo()

template<typename... Args>

void MooseBase::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 453 of file MooseBase.h.

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

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

paramWarning() [1/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

Referenced by GridPartitioner::_do_partition(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), MooseMeshUtils::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

  {
    _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
                                            param + "'");
  }

paramWarning() [2/2]

template<typename... Args>

void MooseBase::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 446 of file MooseBase.h.

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

partitionerName()

const MooseEnum& MooseMesh::partitionerName ( ) const

inline

Definition at line 1024 of file MooseMesh.h.

{ return _partitioner_name; }

partitioning()

MooseEnum MooseMesh::partitioning ( )

static

returns MooseMesh partitioning options so other classes can use it

Definition at line 3978 of file MooseMesh.C.

{
  MooseEnum partitioning("default=-3 metis=-2 parmetis=-1 linear=0 centroid hilbert_sfc morton_sfc",
                         "default");
  return partitioning;
}

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), and PerfGraphOutput::output().

{
  return _pg_moose_app.perfGraph();
}

prepare()

bool MooseMesh::prepare

(

const MeshBase *

mesh_to_clone

)

Calls prepare_for_use() if the underlying MeshBase object isn't prepared, then communicates various boundary information on parallel meshes.

Also calls update() internally. Instead of calling prepare_for_use on the currently held MeshBase object, a mesh_to_clone can be provided. If it is provided (e.g. this method is given a non-null argument), then _mesh will be assigned a clone of the mesh_to_clone. The provided mesh_to_clone must already be prepared

Parameters

mesh_to_clone

If nonnull, we will clone this mesh instead of preparing our current one

Returns

Whether the libMesh mesh was prepared. This should really only be relevant in MOOSE framework contexts where we need to make a decision about what to do with the displaced mesh. If the reference mesh base object has prepare_for_use called (e.g. this method returns true when called for the reference mesh), then we must pass the reference mesh base object into this method when we call this for the displaced mesh. This is because the displaced mesh must be an exact clone of the reference mesh. We have seen that prepare_for_use called on two previously identical meshes can result in two different meshes even with Metis partitioning

Definition at line 431 of file MooseMesh.C.

{
  TIME_SECTION("prepare", 2, "Preparing Mesh", true);

  bool called_prepare_for_use = false;

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

  if (!dynamic_cast<DistributedMesh *>(&getMesh()) || _is_nemesis)
    // For whatever reason we do not want to allow renumbering here nor ever in the future?
    getMesh().allow_renumbering(false);

  if (mesh_to_clone)
  {
    mooseAssert(mesh_to_clone->is_prepared(),
                "The mesh we wish to clone from must already be prepared");
    _mesh = mesh_to_clone->clone();
    _moose_mesh_prepared = false;
  }
  else if (!_mesh->is_prepared())
  {
    _mesh->prepare_for_use();
    _moose_mesh_prepared = false;
    called_prepare_for_use = true;
  }

  if (_moose_mesh_prepared)
    return called_prepare_for_use;

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

  // add explicitly requested subdomains
  if (isParamValid("add_subdomain_ids") && !isParamValid("add_subdomain_names"))
  {
    // only subdomain ids are explicitly given
    const auto & add_subdomain_id = getParam<std::vector<SubdomainID>>("add_subdomain_ids");
    _mesh_subdomains.insert(add_subdomain_id.begin(), add_subdomain_id.end());
  }
  else if (isParamValid("add_subdomain_ids") && isParamValid("add_subdomain_names"))
  {
    const auto add_subdomain =
        getParam<SubdomainID, SubdomainName>("add_subdomain_ids", "add_subdomain_names");
    for (const auto & [sub_id, sub_name] : add_subdomain)
    {
      // add subdomain id
      _mesh_subdomains.insert(sub_id);
      // set name of the subdomain just added
      setSubdomainName(sub_id, sub_name);
    }
  }
  else if (isParamValid("add_subdomain_names"))
  {
    // the user has defined add_subdomain_names, but not add_subdomain_ids
    const auto & add_subdomain_names = getParam<std::vector<SubdomainName>>("add_subdomain_names");

    // to define subdomain ids, we need the largest subdomain id defined yet.
    subdomain_id_type offset = 0;
    if (!_mesh_subdomains.empty())
      offset = *_mesh_subdomains.rbegin();

    // add all subdomains (and auto-assign ids)
    for (const SubdomainName & sub_name : add_subdomain_names)
    {
      // to avoid two subdomains with the same ID (notably on recover)
      if (getSubdomainID(sub_name) != libMesh::Elem::invalid_subdomain_id)
        continue;
      const auto sub_id = ++offset;
      // add subdomain id
      _mesh_subdomains.insert(sub_id);
      // set name of the subdomain just added
      setSubdomainName(sub_id, sub_name);
    }
  }

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

  // Add explicitly requested sidesets/nodesets
  // This is done *after* the side boundaries (e.g. "right", ...) have been generated.
  auto add_sets = [this](const bool sidesets, auto & set_ids)
  {
    const std::string type = sidesets ? "sideset" : "nodeset";
    const std::string id_param = "add_" + type + "_ids";
    const std::string name_param = "add_" + type + "_names";

    if (isParamValid(id_param))
    {
      const auto & add_ids = getParam<std::vector<BoundaryID>>(id_param);
      _mesh_boundary_ids.insert(add_ids.begin(), add_ids.end());
      set_ids.insert(add_ids.begin(), add_ids.end());
      if (isParamValid(name_param))
      {
        const auto & add_names = getParam<std::vector<BoundaryName>>(name_param);
        mooseAssert(add_names.size() == add_ids.size(),
                    "Id and name sets must be the same size when adding.");
        for (const auto i : index_range(add_ids))
          setBoundaryName(add_ids[i], add_names[i]);
      }
    }
    else if (isParamValid(name_param))
    {
      // the user has defined names, but not ids
      const auto & add_names = getParam<std::vector<BoundaryName>>(name_param);

      auto & mesh_ids = sidesets ? _mesh_sideset_ids : _mesh_nodeset_ids;

      // to define ids, we need the largest id defined yet.
      boundary_id_type offset = 0;
      if (!mesh_ids.empty())
        offset = *mesh_ids.rbegin();
      if (!_mesh_boundary_ids.empty())
        offset = std::max(offset, *_mesh_boundary_ids.rbegin());

      // add all sidesets/nodesets (and auto-assign ids)
      for (const auto & name : add_names)
      {
        // to avoid two sets with the same ID (notably on recover)
        if (getBoundaryID(name) != Moose::INVALID_BOUNDARY_ID)
          continue;
        const auto id = ++offset;
        // add sideset id
        _mesh_boundary_ids.insert(id);
        set_ids.insert(id);
        // set name of the sideset just added
        setBoundaryName(id, name);
      }
    }
  };

  add_sets(true, _mesh_sideset_ids);
  add_sets(false, _mesh_nodeset_ids);

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

  if (!_built_from_other_mesh)
  {
    if (!_coord_system_set)
      setCoordSystem(_provided_coord_blocks, getParam<MultiMooseEnum>("coord_type"));
    else if (_pars.isParamSetByUser("coord_type"))
      mooseError(
          "Trying to set coordinate system type information based on the user input file, but "
          "the coordinate system type information has already been set programmatically! "
          "Either remove your coordinate system type information from the input file, or contact "
          "your application developer");
  }

  // Set general axisymmetric axes if provided
  if (isParamValid("rz_coord_blocks") && isParamValid("rz_coord_origins") &&
      isParamValid("rz_coord_directions"))
  {
    const auto rz_coord_blocks = getParam<std::vector<SubdomainName>>("rz_coord_blocks");
    const auto rz_coord_origins = getParam<std::vector<Point>>("rz_coord_origins");
    const auto rz_coord_directions = getParam<std::vector<RealVectorValue>>("rz_coord_directions");
    if (rz_coord_origins.size() == rz_coord_blocks.size() &&
        rz_coord_directions.size() == rz_coord_blocks.size())
    {
      std::vector<std::pair<Point, RealVectorValue>> rz_coord_axes;
      for (unsigned int i = 0; i < rz_coord_origins.size(); ++i)
        rz_coord_axes.push_back(std::make_pair(rz_coord_origins[i], rz_coord_directions[i]));

      setGeneralAxisymmetricCoordAxes(rz_coord_blocks, rz_coord_axes);

      if (isParamSetByUser("rz_coord_axis"))
        mooseError("The parameter 'rz_coord_axis' may not be provided if 'rz_coord_blocks', "
                   "'rz_coord_origins', and 'rz_coord_directions' are provided.");
    }
    else
      mooseError("The parameters 'rz_coord_blocks', 'rz_coord_origins', and "
                 "'rz_coord_directions' must all have the same size.");
  }
  else if (isParamValid("rz_coord_blocks") || isParamValid("rz_coord_origins") ||
           isParamValid("rz_coord_directions"))
    mooseError("If any of the parameters 'rz_coord_blocks', 'rz_coord_origins', and "
               "'rz_coord_directions' are provided, then all must be provided.");

  detectOrthogonalDimRanges();

  update();

  // Check if there is subdomain name duplication for the same subdomain ID
  checkDuplicateSubdomainNames();

  _moose_mesh_prepared = true;

  return called_prepare_for_use;
}

prepared() [1/2]

bool MooseMesh::prepared

(

)

const

Setter/getter for whether the mesh is prepared.

Definition at line 3217 of file MooseMesh.C.

Referenced by needsPrepareForUse(), GeneratedMesh::prepared(), and AnnularMesh::prepared().

{
  return _mesh->is_prepared() && _moose_mesh_prepared;
}

prepared() [2/2]

void MooseMesh::prepared ( bool  state )

virtual

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, and GeneratedMesh.

Definition at line 3223 of file MooseMesh.C.

{
  if (state)
    mooseError("We don't have any right to tell the libmesh mesh that it *is* prepared. Only a "
               "call to prepare_for_use should tell us that");

  // Some people may call this even before we have a MeshBase object. This isn't dangerous really
  // because when the MeshBase object is born, it knows it's in an unprepared state
  if (_mesh)
    _mesh->set_isnt_prepared();

  // If the libMesh mesh isn't preparead, then our MooseMesh wrapper is also no longer prepared
  _moose_mesh_prepared = false;

  _regular_orthogonal_mesh = false;
}

printInfo()

void MooseMesh::printInfo	(	std::ostream &	os = libMesh::out,
		const unsigned int	verbosity = 0
	)		const

Calls print_info() on the underlying Mesh.

Definition at line 3542 of file MooseMesh.C.

Referenced by Adaptivity::adaptMesh().

{
  os << '\n';
  getMesh().print_info(os, verbosity);
  os << std::flush;
}

queryElemPtr() [1/2]

Elem * MooseMesh::queryElemPtr ( const dof_id_type  i )

virtual

Definition at line 3205 of file MooseMesh.C.

Referenced by PointSamplerBase::getLocalElemContainingPoint(), NodePositions::initialize(), ElementalVariableValue::initialSetup(), DisplacedProblem::reinitElemPhys(), FEProblemBase::reinitElemPhys(), and EqualValueBoundaryConstraint::updateConstrainedNodes().

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

queryElemPtr() [2/2]

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

virtual

Definition at line 3211 of file MooseMesh.C.

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

queryNodePtr() [1/2]

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

virtual

Definition at line 887 of file MooseMesh.C.

Referenced by NonlinearSystemBase::findImplicitGeometricCouplingEntries(), NodePositions::initialize(), nodeRef(), queryNodePtr(), and EqualValueBoundaryConstraint::updateConstrainedNodes().

{
  if (i > getMesh().max_node_id())
  {
    auto it = _quadrature_nodes.find(i);
    if (it == _quadrature_nodes.end())
      return nullptr;
    auto & node_ptr = it->second;
    mooseAssert(node_ptr, "Uninitialized quadrature node");
    return node_ptr;
  }

  return getMesh().query_node_ptr(i);
}

queryNodePtr() [2/2]

Node * MooseMesh::queryNodePtr ( const dof_id_type  i )

virtual

Definition at line 903 of file MooseMesh.C.

{
  return const_cast<Node *>(const_cast<const MooseMesh *>(this)->queryNodePtr(i));
}

queryParam()

template<typename T >

const T * MooseBase::queryParam ( const std::string &  name ) const

inherited

Query a parameter for the object.

If the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns

A pointer to the parameter value, if it exists

Definition at line 395 of file MooseBase.h.

{
  return isParamValid(name) ? &getParam<T>(name) : nullptr;
}

refinedElementRange()

ConstElemPointerRange * MooseMesh::refinedElementRange

(

)

const

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

Referenced by FEProblemBase::meshChanged().

{
  return _refined_elements.get();
}

registerInvalidSolutionInternal()

InvalidSolutionID SolutionInvalidInterface::registerInvalidSolutionInternal ( const std::string &  message, const bool  warning  ) const

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

{
  return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
      _si_moose_base.type(), message, warning);
}

registerTimedSection() [1/2]

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

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 53 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level, const std::string &  live_message, const bool  print_dots = true  ) const

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)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns

The ID of the section - use when starting timing

Definition at line 64 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

restartableName()

std::string Restartable::restartableName ( const std::string &  data_name ) const

protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 78 of file Restartable.C.

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

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

safeClone()

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

pure virtual

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.

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

Referenced by SetupMeshAction::act(), and SampledOutput::cloneMesh().

setAxisymmetricCoordAxis()

void MooseMesh::setAxisymmetricCoordAxis

(

const MooseEnum &

rz_coord_axis

)

For axisymmetric simulations, set the symmetry coordinate axis.

For r in the x-direction, z in the y-direction the coordinate axis would be y

Definition at line 4293 of file MooseMesh.C.

Referenced by FEProblemBase::setAxisymmetricCoordAxis().

{
  _rz_coord_axis = rz_coord_axis;

  updateCoordTransform();
}

setBoundaryName()

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

This method sets the boundary name of the boundary based on the id parameter.

Definition at line 1830 of file MooseMesh.C.

Referenced by prepare(), and ActivateElementsUserObjectBase::setNewBoundayName().

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

  // We need to figure out if this boundary is a sideset or nodeset
  if (boundary_info.get_side_boundary_ids().count(boundary_id))
    boundary_info.sideset_name(boundary_id) = name;
  else
    boundary_info.nodeset_name(boundary_id) = name;
}

setBoundaryToNormalMap() [1/2]

void MooseMesh::setBoundaryToNormalMap

(

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

boundary_map

)

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

Definition at line 3281 of file MooseMesh.C.

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

setBoundaryToNormalMap() [2/2]

void MooseMesh::setBoundaryToNormalMap

(

std::map< BoundaryID, RealVectorValue > *

boundary_map

)

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

setCoordData()

void MooseMesh::setCoordData

(

const MooseMesh &

other_mesh

)

Set the coordinate system data to that of other_mesh.

Definition at line 4402 of file MooseMesh.C.

Referenced by DisplacedProblem::DisplacedProblem().

{
  _coord_sys = other_mesh._coord_sys;
  _rz_coord_axis = other_mesh._rz_coord_axis;
  _subdomain_id_to_rz_coord_axis = other_mesh._subdomain_id_to_rz_coord_axis;
}

setCoordSystem()

void MooseMesh::setCoordSystem	(	const std::vector< SubdomainName > &	blocks,
		const MultiMooseEnum &	coord_sys
	)

Set the coordinate system for the provided blocks to coord_sys.

Definition at line 4161 of file MooseMesh.C.

Referenced by prepare(), and FEProblemBase::setCoordSystem().

{
  TIME_SECTION("setCoordSystem", 5, "Setting Coordinate System");
  if (!_provided_coord_blocks.empty() && (_provided_coord_blocks != blocks))
  {
    const std::string param_name = isParamValid("coord_block") ? "coord_block" : "block";
    mooseWarning("Supplied blocks in the 'setCoordSystem' method do not match the value of the "
                 "'Mesh/",
                 param_name,
                 "' parameter. Did you provide different parameter values for 'Mesh/",
                 param_name,
                 "' and 'Problem/block'?. We will honor the parameter value from 'Mesh/",
                 param_name,
                 "'");
    mooseAssert(_coord_system_set,
                "If we are arriving here due to a bad specification in the Problem block, then we "
                "should have already set our coordinate system subdomains from the Mesh block");
    return;
  }
  if (_pars.isParamSetByUser("coord_type") && getParam<MultiMooseEnum>("coord_type") != coord_sys)
    mooseError("Supplied coordinate systems in the 'setCoordSystem' method do not match the value "
               "of the 'Mesh/coord_type' parameter. Did you provide different parameter values for "
               "'coord_type' to 'Mesh' and 'Problem'?");

  // If blocks contain ANY_BLOCK_ID, it should be the only block specified, and coord_sys should
  // have one and only one entry. In that case, the same coordinate system will be set for all
  // subdomains.
  if (blocks.size() == 1 && blocks[0] == "ANY_BLOCK_ID")
  {
    if (coord_sys.size() > 1)
      mooseError("If you specify ANY_BLOCK_ID as the only block, you must also specify a single "
                 "coordinate system for it.");
    if (!_mesh->is_prepared())
      mooseError(
          "You cannot set the coordinate system for ANY_BLOCK_ID before the mesh is prepared. "
          "Please call this method after the mesh is prepared.");
    const auto coord_type = coord_sys.size() == 0
                                ? Moose::COORD_XYZ
                                : Moose::stringToEnum<Moose::CoordinateSystemType>(coord_sys[0]);
    for (const auto sid : meshSubdomains())
      _coord_sys[sid] = coord_type;
    return;
  }

  // If multiple blocks are specified, but one of them is ANY_BLOCK_ID, let's emit a helpful error
  if (std::find(blocks.begin(), blocks.end(), "ANY_BLOCK_ID") != blocks.end())
    mooseError("You cannot specify ANY_BLOCK_ID together with other blocks in the "
               "setCoordSystem() method. If you want to set the same coordinate system for all "
               "blocks, use ANY_BLOCK_ID as the only block.");

  auto subdomains = meshSubdomains();
  // It's possible that a user has called this API before the mesh is prepared and consequently we
  // don't yet have the subdomains in meshSubdomains()
  for (const auto & sub_name : blocks)
  {
    const auto sub_id = getSubdomainID(sub_name);
    subdomains.insert(sub_id);
  }

  if (coord_sys.size() <= 1)
  {
    // We will specify the same coordinate system for all blocks
    const auto coord_type = coord_sys.size() == 0
                                ? Moose::COORD_XYZ
                                : Moose::stringToEnum<Moose::CoordinateSystemType>(coord_sys[0]);
    for (const auto sid : subdomains)
      _coord_sys[sid] = coord_type;
  }
  else
  {
    if (blocks.size() != coord_sys.size())
      mooseError("Number of blocks and coordinate systems does not match.");

    for (const auto i : index_range(blocks))
    {
      SubdomainID sid = getSubdomainID(blocks[i]);
      Moose::CoordinateSystemType coord_type =
          Moose::stringToEnum<Moose::CoordinateSystemType>(coord_sys[i]);
      _coord_sys[sid] = coord_type;
    }

    for (const auto & sid : subdomains)
      if (_coord_sys.find(sid) == _coord_sys.end())
        mooseError("Subdomain '" + Moose::stringify(sid) +
                   "' does not have a coordinate system specified.");
  }

  _coord_system_set = true;

  updateCoordTransform();
}

setCustomPartitioner()

void MooseMesh::setCustomPartitioner

(

libMesh::Partitioner *

partitioner

)

Setter for custom partitioner.

Definition at line 3779 of file MooseMesh.C.

{
  _custom_partitioner = partitioner->clone();
}

setGeneralAxisymmetricCoordAxes()

void MooseMesh::setGeneralAxisymmetricCoordAxes	(	const std::vector< SubdomainName > &	blocks,
		const std::vector< std::pair< Point, RealVectorValue >> &	axes
	)

Sets the general coordinate axes for axisymmetric blocks.

This method must be used if any of the following are true:

• There are multiple axisymmetric coordinate systems
• Any axisymmetric coordinate system axis/direction is not the +X or +Y axis
• Any axisymmetric coordinate system does not start at (0,0,0)

Parameters

[in]	blocks	Subdomain names
[in]	axes	Pair of values defining the axisymmetric coordinate axis for each subdomain. The first value is the point on the axis corresponding to the origin. The second value is the direction vector of the axis (normalization not necessary).

Definition at line 4301 of file MooseMesh.C.

Referenced by prepare().

{
  // Set the axes for the given blocks
  mooseAssert(blocks.size() == axes.size(), "Blocks and axes vectors must be the same length.");
  for (const auto i : index_range(blocks))
  {
    const auto subdomain_id = getSubdomainID(blocks[i]);
    const auto it = _coord_sys.find(subdomain_id);
    if (it == _coord_sys.end())
      mooseError("The block '",
                 blocks[i],
                 "' has not set a coordinate system. Make sure to call setCoordSystem() before "
                 "setGeneralAxisymmetricCoordAxes().");
    else
    {
      if (it->second == Moose::COORD_RZ)
      {
        const auto direction = axes[i].second;
        if (direction.is_zero())
          mooseError("Only nonzero vectors may be supplied for RZ directions.");

        _subdomain_id_to_rz_coord_axis[subdomain_id] =
            std::make_pair(axes[i].first, direction.unit());
      }
      else
        mooseError("The block '",
                   blocks[i],
                   "' was provided in setGeneralAxisymmetricCoordAxes(), but the coordinate system "
                   "for this block is not 'RZ'.");
    }
  }

  // Make sure there are no RZ blocks that still do not have axes
  const auto all_subdomain_ids = meshSubdomains();
  for (const auto subdomain_id : all_subdomain_ids)
    if (getCoordSystem(subdomain_id) == Moose::COORD_RZ &&
        !_subdomain_id_to_rz_coord_axis.count(subdomain_id))
      mooseError("The block '",
                 getSubdomainName(subdomain_id),
                 "' was specified to use the 'RZ' coordinate system but was not given in "
                 "setGeneralAxisymmetricCoordAxes().");

  updateCoordTransform();
}

setGhostedBoundaryInflation()

void MooseMesh::setGhostedBoundaryInflation

(

const std::vector< Real > &

inflation

)

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

Definition at line 3315 of file MooseMesh.C.

{
  _ghosted_boundaries_inflation = inflation;
}

setIsCustomPartitionerRequested()

void MooseMesh::setIsCustomPartitionerRequested

(

bool

cpr

)

Definition at line 3807 of file MooseMesh.C.

{
  _custom_partitioner_requested = cpr;
}

setMeshBase()

void MooseMesh::setMeshBase

(

std::unique_ptr< MeshBase >

mesh_base

)

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

{
  _mesh = std::move(mesh_base);
  _mesh->allow_remote_element_removal(_allow_remote_element_removal);
}

setMeshBoundaryIDs()

void MooseMesh::setMeshBoundaryIDs

(

std::set< BoundaryID >

boundary_IDs

)

Sets the set of BoundaryIDs Is called by AddAllSideSetsByNormals.

Definition at line 3275 of file MooseMesh.C.

{
  _mesh_boundary_ids = boundary_IDs;
}

setParallelType()

void MooseMesh::setParallelType ( ParallelType  parallel_type )

inline

Allow to change parallel type.

Definition at line 2187 of file MooseMesh.h.

Referenced by buildTypedMesh().

{
  _parallel_type = parallel_type;
  determineUseDistributedMesh();
}

setPartitioner()

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

static

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

Definition at line 3720 of file MooseMesh.C.

Referenced by setPartitionerHelper().

{
  // 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 libMesh::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 libMesh::CentroidPartitioner(libMesh::CentroidPartitioner::X));
      else if (direction == "y")
        mesh_base.partitioner().reset(
            new libMesh::CentroidPartitioner(libMesh::CentroidPartitioner::Y));
      else if (direction == "z")
        mesh_base.partitioner().reset(
            new libMesh::CentroidPartitioner(libMesh::CentroidPartitioner::Z));
      else if (direction == "radial")
        mesh_base.partitioner().reset(
            new libMesh::CentroidPartitioner(libMesh::CentroidPartitioner::RADIAL));
      break;
    }
    case 2: // hilbert_sfc
      mesh_base.partitioner().reset(new libMesh::HilbertSFCPartitioner);
      break;
    case 3: // morton_sfc
      mesh_base.partitioner().reset(new libMesh::MortonSFCPartitioner);
      break;
  }
}

setPartitionerHelper()

void MooseMesh::setPartitionerHelper ( MeshBase *  mesh = nullptr )

protected

Definition at line 3708 of file MooseMesh.C.

Referenced by buildTypedMesh().

{
  if (_use_distributed_mesh && (_partitioner_name != "default" && _partitioner_name != "parmetis"))
  {
    _partitioner_name = "parmetis";
    _partitioner_overridden = true;
  }

  setPartitioner(mesh ? *mesh : getMesh(), _partitioner_name, _use_distributed_mesh, _pars, *this);
}

setPatchUpdateStrategy()

void MooseMesh::setPatchUpdateStrategy

(

Moose::PatchUpdateType

patch_update_strategy

)

Set the patch size update strategy.

Definition at line 3487 of file MooseMesh.C.

{
  _patch_update_strategy = patch_update_strategy;
}

setSubdomainName() [1/2]

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

This method sets the name for subdomain_id to name.

Definition at line 1799 of file MooseMesh.C.

Referenced by MooseMesh(), and prepare().

{
  mooseAssert(name != "ANY_BLOCK_ID", "Cannot set subdomain name to 'ANY_BLOCK_ID'");
  getMesh().subdomain_name(subdomain_id) = name;
}

setSubdomainName() [2/2]

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

static

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

setUniformRefineLevel()

void MooseMesh::setUniformRefineLevel	(	unsigned int	level,
		bool	deletion = true
	)

Set uniform refinement level.

Definition at line 3302 of file MooseMesh.C.

{
  _uniform_refine_level = level;
  _skip_deletion_repartition_after_refine = deletion;
}

setupFiniteVolumeMeshData()

void MooseMesh::setupFiniteVolumeMeshData

(

)

const

Sets up the additional data needed for finite volume computations.

This involves building FaceInfo and ElemInfo objects, caching variable associations and elemental DoF indices for FV variables.

Definition at line 4152 of file MooseMesh.C.

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

{
  buildFiniteVolumeInfo();
  computeFiniteVolumeCoords();
  cacheFaceInfoVariableOwnership();
  cacheFVElementalDoFs();
}

sideWithBoundaryID()

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

Calls BoundaryInfo::side_with_boundary_id().

Definition at line 3101 of file MooseMesh.C.

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

skipDeletionRepartitionAfterRefine()

bool MooseMesh::skipDeletionRepartitionAfterRefine ( ) const

inline

Return a flag indicating whether or not we should skip remote deletion and repartition after uniform refinements.

If the flag is true, uniform refinements will run more efficiently, but at the same time, there might be extra ghosting elements. The number of layers of additional ghosting elements depends on the number of uniform refinement levels. This flag should be used only when you have a "fine enough" coarse mesh and want to refine the mesh by a few levels. Otherwise, it might introduce an unbalanced workload and too large ghosting domain.

Definition at line 2181 of file MooseMesh.h.

{
  return _skip_deletion_repartition_after_refine;
}

skipNoncriticalPartitioning()

bool MooseMesh::skipNoncriticalPartitioning ( ) const

virtual

Definition at line 4482 of file MooseMesh.C.

{
  return _mesh->skip_noncritical_partitioning();
}

skipPartitioning()

virtual bool MooseMesh::skipPartitioning ( ) const

inlinevirtual

Definition at line 325 of file MooseMesh.h.

{ return _mesh->skip_partitioning(); }

skipRefineWhenUseSplit()

bool MooseMesh::skipRefineWhenUseSplit ( ) const

inline

Whether or not skip uniform refinements when using a pre-split mesh.

Definition at line 581 of file MooseMesh.h.

{ return _skip_refine_when_use_split; }

spatialDimension()

virtual unsigned int MooseMesh::spatialDimension ( ) const

inlinevirtual

Returns MeshBase::spatial_dimension.

Reimplemented in MFEMMesh.

Definition at line 186 of file MooseMesh.h.

{ return _mesh->spatial_dimension(); }

timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name ) const

protectedinherited

Returns

The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

type()

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

inlineinherited

Get the type of this class.

Returns

the name of the type of this class

Definition at line 93 of file MooseBase.h.

Referenced by CreateProblemDefaultAction::act(), SetupDebugAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addConvergence(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addObject(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), MooseServer::addValuesToList(), DisplacedProblem::addVectorTag(), SubProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), AuxKernelBase::AuxKernelBase(), FEProblemBase::backupMultiApps(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BoundaryPreservedMarker::BoundaryPreservedMarker(), DistributedRectilinearMeshGenerator::buildCube(), buildHRefinementAndCoarseningMaps(), buildLowerDMesh(), buildPRefinementAndCoarseningMaps(), PhysicsBase::checkComponentType(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), ADDGKernel::computeElemNeighJacobian(), DGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), ADDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), LowerDIntegratedBC::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDJacobian(), DGLowerDKernel::computeLowerDJacobian(), ArrayDGLowerDKernel::computeLowerDJacobian(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayHFEMDirichletBC::computeLowerDQpJacobian(), ArrayHFEMDiffusion::computeLowerDQpJacobian(), HFEMDirichletBC::computeLowerDQpJacobian(), HFEMDiffusion::computeLowerDQpJacobian(), ArrayHFEMDirichletBC::computeLowerDQpOffDiagJacobian(), HFEMDirichletBC::computeLowerDQpOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDQpOffDiagJacobian(), ArrayDGLowerDKernel::computeLowerDQpOffDiagJacobian(), FEProblemBase::computeMultiAppsDT(), ADDGKernel::computeOffDiagElemNeighJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), DGConvection::computeQpJacobian(), ScalarKernel::computeQpJacobian(), InterfaceDiffusion::computeQpJacobian(), InterfaceReaction::computeQpJacobian(), ArrayDGDiffusion::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), DGDiffusion::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), HFEMTestJump::computeQpOffDiagJacobian(), HFEMTrialJump::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), ArrayHFEMDiffusion::computeQpResidual(), DGConvection::computeQpResidual(), HFEMDiffusion::computeQpResidual(), ScalarKernel::computeQpResidual(), InterfaceDiffusion::computeQpResidual(), ADMatInterfaceReaction::computeQpResidual(), InterfaceReaction::computeQpResidual(), ADDGAdvection::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), TiedValueConstraint::computeQpResidual(), DGDiffusion::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), ADDGDiffusion::computeQpResidual(), HFEMTrialJump::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), HFEMTestJump::computeQpResidual(), FEProblemBase::computeSystems(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), DisplacedProblem::createQRules(), FEProblemBase::createQRules(), MooseApp::createRecoverablePerfGraph(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), SteadyBase::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), FEProblemBase::finishMultiAppStep(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), MooseServer::gatherDocumentReferencesLocations(), Boundary2DDelaunayGenerator::General2DDelaunay(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), Boundary2DDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MultiAppTransfer::getAppInfo(), TransfiniteMeshGenerator::getEdge(), ElementGenerator::getElemType(), MooseServer::getInputLookupDefinitionNodes(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), MaterialOutputAction::getParams(), ReporterData::getReporterInfo(), FEProblemBase::getTransfers(), DisplacedProblem::getVectorTags(), SubProblem::getVectorTags(), CommonOutputAction::hasConsole(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), AdvancedOutput::initAvailableLists(), FunctorPositions::initialize(), FunctorTimes::initialize(), MultiAppConservativeTransfer::initialSetup(), LinearFVAdvection::initialSetup(), LinearFVDiffusion::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), ArrayDGDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), FEProblemBase::logAdd(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MFEMProblem::mesh(), MooseObject::MooseObject(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), DisplacedProblem::numVectorTags(), SubProblem::numVectorTags(), Console::output(), AdvancedOutput::output(), ConsoleUtils::outputExecutionInformation(), SampledOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), MooseServer::parseDocumentForDiagnostics(), prepare(), ProjectedStatefulMaterialStorageAction::processProperty(), MooseApp::recursivelyCreateExecutors(), SolutionInvalidInterface::registerInvalidSolutionInternal(), FEProblemBase::restoreMultiApps(), MeshRepairGenerator::separateSubdomainsByElementType(), FEProblemBase::setCoupling(), MooseApp::setupOptions(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), Reporter::store(), MooseBase::typeAndName(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), UserObjectInterface::userObjectType(), and AdvancedOutput::wantOutput().

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns

The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

Referenced by FEProblemBase::addPostprocessor(), MaterialPropertyStorage::addProperty(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), ReporterData::getReporterInfo(), and WebServerControl::outputMessage().

{
  return type() + std::string(" \"") + name() + std::string("\"");
}

uniformRefineLevel()

unsigned int MooseMesh::uniformRefineLevel

(

)

const

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

Definition at line 3296 of file MooseMesh.C.

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

{
  return _uniform_refine_level;
}

uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

Returns

The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

{
  if (!_pars.have_parameter<std::string>(unique_name_param))
    mooseError("uniqueName(): Object does not have a unique name");
  return MooseObjectName(_pars.get<std::string>(unique_name_param));
}

uniqueParameterName()

MooseObjectParameterName MooseBase::uniqueParameterName ( const std::string &  parameter_name ) const

inherited

Returns

The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

{
  return MooseObjectParameterName(getBase(), name(), parameter_name);
}

update()

void MooseMesh::update

(

)

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

Definition at line 641 of file MooseMesh.C.

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

{
  TIME_SECTION("update", 3, "Updating Mesh", true);

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

  // this will make moose mesh aware of p-refinement added by mesh generators including
  // a file mesh generator loading a restart checkpoint file
  _max_p_level = 0;
  _max_h_level = 0;
  for (const auto & elem : getMesh().active_local_element_ptr_range())
  {
    if (elem->p_level() > _max_p_level)
      _max_p_level = elem->p_level();
    if (elem->level() > _max_h_level)
      _max_h_level = elem->level();
  }
  comm().max(_max_p_level);
  comm().max(_max_h_level);

  // the flag might have been set by calling doingPRefinement(true)
  _doing_p_refinement = _doing_p_refinement || (_max_p_level > 0);

#ifdef MOOSE_KOKKOS_ENABLED
  if (_app.hasKokkosObjects() || (_app.getExecutioner() && _app.feProblem().hasKokkosObjects()))
    _kokkos_mesh->update();
#endif

  _finite_volume_info_dirty = true;
}

updateActiveSemiLocalNodeRange()

void MooseMesh::updateActiveSemiLocalNodeRange

(

std::set< dof_id_type > &

ghosted_elems

)

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

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

{
  TIME_SECTION("updateActiveSemiLocalNodeRange", 5, "Updating ActiveSemiLocalNode Range");

  _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 = std::make_unique<SemiLocalNodeRange>(_semilocal_node_list.begin(),
                                                                      _semilocal_node_list.end());
}

updateCoordTransform()

void MooseMesh::updateCoordTransform ( )

private

Update the coordinate transformation object based on our coordinate system data.

The coordinate transformation will be created if it hasn't been already

Definition at line 4365 of file MooseMesh.C.

Referenced by MooseMesh(), setAxisymmetricCoordAxis(), setCoordSystem(), and setGeneralAxisymmetricCoordAxes().

{
  if (!_coord_transform)
    _coord_transform = std::make_unique<MooseAppCoordTransform>(*this);
  else
    _coord_transform->setCoordinateSystem(*this);
}

usingGeneralAxisymmetricCoordAxes()

bool MooseMesh::usingGeneralAxisymmetricCoordAxes

(

)

const

Returns true if general axisymmetric coordinate axes are being used.

Definition at line 4359 of file MooseMesh.C.

Referenced by getAxisymmetricRadialCoord(), and getUniqueCoordSystem().

{
  return _subdomain_id_to_rz_coord_axis.size() > 0;
}

validParams()

InputParameters MooseMesh::validParams ( )

static

Typical "Moose-style" constructor and copy constructor.

Definition at line 82 of file MooseMesh.C.

Referenced by FileMesh::validParams(), TiledMesh::validParams(), SpiralAnnularMesh::validParams(), GeneratedMesh::validParams(), RinglebMesh::validParams(), AnnularMesh::validParams(), ConcentricCircleMesh::validParams(), MeshGeneratorMesh::validParams(), StitchedMesh::validParams(), and PatternedMesh::validParams().

{
  InputParameters params = MooseObject::validParams();

  MooseEnum parallel_type("DEFAULT REPLICATED DISTRIBUTED", "DEFAULT");
  params.addParam<MooseEnum>("parallel_type",
                             parallel_type,
                             "DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is "
                             "specified on the command line "
                             "REPLICATED: Always use libMesh::ReplicatedMesh "
                             "DISTRIBUTED: Always use libMesh::DistributedMesh");

  params.addParam<bool>(
      "allow_renumbering",
      true,
      "If allow_renumbering=false, node and element numbers are kept fixed until deletion");

  // TODO: this parameter does not belong here, it's only for FileMesh
  params.addParam<bool>("nemesis",
                        false,
                        "If nemesis=true and file=foo.e, actually reads "
                        "foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, "
                        "where N = # CPUs, with NemesisIO.");

  params.addParam<MooseEnum>(
      "partitioner",
      partitioning(),
      "Specifies a mesh partitioner to use when splitting the mesh for a parallel computation.");
  MooseEnum direction("x y z radial");
  params.addParam<MooseEnum>("centroid_partitioner_direction",
                             direction,
                             "Specifies the sort direction if using the centroid partitioner. "
                             "Available options: x, y, z, radial");

  MooseEnum patch_update_strategy("never always auto iteration", "never");
  params.addParam<MooseEnum>(
      "patch_update_strategy",
      patch_update_strategy,
      "How often to update the geometric search 'patch'.  The default is to "
      "never update it (which is the most efficient but could be a problem "
      "with lots of relative motion). 'always' will update the patch for all "
      "secondary nodes at the beginning of every timestep which might be time "
      "consuming. 'auto' will attempt to determine at the start of which "
      "timesteps the patch for all secondary nodes needs to be updated automatically."
      "'iteration' updates the patch at every nonlinear iteration for a "
      "subset of secondary nodes for which penetration is not detected. If there "
      "can be substantial relative motion between the primary and secondary surfaces "
      "during the nonlinear iterations within a timestep, it is advisable to use "
      "'iteration' option to ensure accurate contact detection.");

  // Note: This parameter is named to match 'construct_side_list_from_node_list' in SetupMeshAction
  params.addParam<bool>(
      "construct_node_list_from_side_list",
      true,
      "Whether or not to generate nodesets from the sidesets (currently often required).");
  params.addParam<bool>(
      "displace_node_list_by_side_list",
      false,
      "Whether to renumber existing nodesets with ids matching sidesets that "
      "lack names matching sidesets, when constructing nodesets from sidesets via the default "
      "'construct_node_list_from_side_list' option, rather than to merge them with the sideset.");
  params.addParam<unsigned int>(
      "patch_size", 40, "The number of nodes to consider in the NearestNode neighborhood.");
  params.addParam<unsigned int>("ghosting_patch_size",
                                "The number of nearest neighbors considered "
                                "for ghosting purposes when 'iteration' "
                                "patch update strategy is used. Default is "
                                "5 * patch_size.");
  params.addParam<unsigned int>("max_leaf_size",
                                10,
                                "The maximum number of points in each leaf of the KDTree used in "
                                "the nearest neighbor search. As the leaf size becomes larger,"
                                "KDTree construction becomes faster but the nearest neighbor search"
                                "becomes slower.");

  params.addParam<bool>("build_all_side_lowerd_mesh",
                        false,
                        "True to build the lower-dimensional mesh for all sides.");

  params.addParam<bool>("skip_refine_when_use_split",
                        true,
                        "True to skip uniform refinements when using a pre-split mesh.");

  params.addParam<std::vector<SubdomainID>>(
      "add_subdomain_ids",
      "The listed subdomain ids will be assumed valid for the mesh. This permits setting up "
      "subdomain restrictions for subdomains initially containing no elements, which can occur, "
      "for example, in additive manufacturing simulations which dynamically add and remove "
      "elements. Names for this subdomains may be provided using add_subdomain_names. In this case "
      "this list and add_subdomain_names must contain the same number of items.");
  params.addParam<std::vector<SubdomainName>>(
      "add_subdomain_names",
      "The listed subdomain names will be assumed valid for the mesh. This permits setting up "
      "subdomain restrictions for subdomains initially containing no elements, which can occur, "
      "for example, in additive manufacturing simulations which dynamically add and remove "
      "elements. IDs for this subdomains may be provided using add_subdomain_ids. Otherwise IDs "
      "are automatically assigned. In case add_subdomain_ids is set too, both lists must contain "
      "the same number of items.");

  params.addParam<std::vector<BoundaryID>>(
      "add_sideset_ids",
      "The listed sideset ids will be assumed valid for the mesh. This permits setting up boundary "
      "restrictions for sidesets initially containing no sides. Names for this sidesets may be "
      "provided using add_sideset_names. In this case this list and add_sideset_names must contain "
      "the same number of items.");
  params.addParam<std::vector<BoundaryName>>(
      "add_sideset_names",
      "The listed sideset names will be assumed valid for the mesh. This permits setting up "
      "boundary restrictions for sidesets initially containing no sides. Ids for this sidesets may "
      "be provided using add_sideset_ids. In this case this list and add_sideset_ids must contain "
      "the same number of items.");

  params.addParam<std::vector<BoundaryID>>(
      "add_nodeset_ids",
      "The listed nodeset ids will be assumed valid for the mesh. This permits setting up boundary "
      "restrictions for node initially containing no sides. Names for this nodesets may be "
      "provided using add_nodeset_names. In this case this list and add_nodeset_names must contain "
      "the same number of items.");
  params.addParam<std::vector<BoundaryName>>(
      "add_nodeset_names",
      "The listed nodeset names will be assumed valid for the mesh. This permits setting up "
      "boundary restrictions for nodesets initially containing no sides. Ids for this nodesets may "
      "be provided using add_nodesets_ids. In this case this list and add_nodesets_ids must "
      "contain the same number of items.");

  params += MooseAppCoordTransform::validParams();

  // This indicates that the derived mesh type accepts a MeshGenerator, and should be set to true in
  // derived types that do so.
  params.addPrivateParam<bool>("_mesh_generator_mesh", false);

  // Whether or not the mesh is pre split
  params.addPrivateParam<bool>("_is_split", false);

  params.registerBase("MooseMesh");

  // groups
  params.addParamNamesToGroup("patch_update_strategy patch_size max_leaf_size", "Geometric search");
  params.addParamNamesToGroup("nemesis", "Advanced");
  params.addParamNamesToGroup("add_subdomain_ids add_subdomain_names add_sideset_ids "
                              "add_sideset_names add_nodeset_ids add_nodeset_names",
                              "Pre-declaration of future mesh sub-entities");
  params.addParamNamesToGroup("construct_node_list_from_side_list build_all_side_lowerd_mesh "
                              "displace_node_list_by_side_list",
                              "Automatic definition of mesh element sides entities");
  params.addParamNamesToGroup("partitioner centroid_partitioner_direction", "Partitioning");

  return params;
}

Member Data Documentation

_action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

_active_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> MooseMesh::_active_local_elem_range

protected

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

Referenced by getActiveLocalElementRange(), and meshChanged().

_active_node_range

std::unique_ptr<libMesh::NodeRange> MooseMesh::_active_node_range

protected

Definition at line 1524 of file MooseMesh.h.

Referenced by getActiveNodeRange(), and meshChanged().

_active_semilocal_node_range

std::unique_ptr<SemiLocalNodeRange> MooseMesh::_active_semilocal_node_range

protected

Definition at line 1523 of file MooseMesh.h.

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

_all_face_info

std::vector<FaceInfo> MooseMesh::_all_face_info

mutableprivate

FaceInfo object storing information for face based loops.

This container holds all the FaceInfo objects accessible from this process

Definition at line 1631 of file MooseMesh.h.

Referenced by allFaceInfo(), buildFiniteVolumeInfo(), cacheFaceInfoVariableOwnership(), and computeFiniteVolumeCoords().

_allow_recovery

bool MooseMesh::_allow_recovery

private

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

Definition at line 1846 of file MooseMesh.h.

Referenced by allowRecovery(), and init().

_allow_remote_element_removal

bool MooseMesh::_allow_remote_element_removal

private

Whether to allow removal of remote elements.

Definition at line 1859 of file MooseMesh.h.

Referenced by allowRemoteElementRemoval(), buildTypedMesh(), deleteRemoteElements(), and setMeshBase().

_app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 357 of file MooseBase.h.

_block_id_mapping

std::vector<std::unordered_map<SubdomainID, std::set<dof_id_type> > > MooseMesh::_block_id_mapping

private

Unique element integer IDs for each subdomain and each extra element integers.

Definition at line 1871 of file MooseMesh.h.

Referenced by buildElemIDInfo(), getAllElemIDs(), and getElemIDsOnBlocks().

_block_node_list

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

protected

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

Definition at line 1580 of file MooseMesh.h.

Referenced by cacheInfo(), and getNodeBlockIds().

_bnd_elem_ids

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

protected

Map of set of elem IDs connected to each boundary.

Definition at line 1572 of file MooseMesh.h.

Referenced by buildBndElemList(), freeBndElems(), getBoundariesToActiveSemiLocalElemIds(), getBoundaryActiveSemiLocalElemIds(), and isBoundaryElem().

_bnd_elem_range

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

protected

Definition at line 1529 of file MooseMesh.h.

Referenced by freeBndElems(), getBoundaryElementRange(), isBoundaryFullyExternalToSubdomains(), and meshChanged().

_bnd_elems

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

protected

array of boundary elems

Definition at line 1567 of file MooseMesh.h.

Referenced by bndElemsBegin(), bndElemsEnd(), buildBndElemList(), freeBndElems(), and getBoundaryActiveNeighborElemIds().

_bnd_node_ids

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

protected

Map of sets of node IDs in each boundary.

Definition at line 1564 of file MooseMesh.h.

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

_bnd_node_range

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

protected

Definition at line 1527 of file MooseMesh.h.

Referenced by addQuadratureNode(), freeBndNodes(), getBoundaryNodeRange(), and meshChanged().

_bnd_nodes

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

protected

array of boundary nodes

Definition at line 1560 of file MooseMesh.h.

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

_boundary_to_normal_map

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

protected

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

Definition at line 1557 of file MooseMesh.h.

Referenced by getNormalByBoundaryID(), and setBoundaryToNormalMap().

_bounds

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

protected

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

Definition at line 1607 of file MooseMesh.h.

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

_built_from_other_mesh

bool MooseMesh::_built_from_other_mesh = false

protected

Whether or not this mesh was built from another mesh.

Definition at line 1441 of file MooseMesh.h.

Referenced by prepare().

_coarsened_element_children

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

protected

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

Referenced by cacheChangedLists(), and coarsenedElementChildren().

_coarsened_elements

std::unique_ptr<ConstElemPointerRange> MooseMesh::_coarsened_elements

protected

The elements that were just coarsened.

Definition at line 1505 of file MooseMesh.h.

Referenced by cacheChangedLists(), and 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(), MeshOnlyAction::act(), SetupDebugAction::act(), MaterialOutputAction::act(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkRelativeConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), LinearSystem::computeLinearSystemTags(), FEProblemBase::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MFEMSteady::execute(), MessageFromInput::execute(), SteadyBase::execute(), Eigenvalue::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), ElementQualityChecker::finalize(), SidesetAroundSubdomainUpdater::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), CoarsenBlockGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), NonlinearEigen::init(), InversePowerMethod::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseBase::mooseDeprecated(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), ReporterDebugOutput::output(), PerfGraphOutput::output(), SolutionInvalidityOutput::output(), MaterialPropertyDebugOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), PicardSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), EigenProblem::solve(), FEProblemSolve::solve(), FixedPointSolve::solve(), NonlinearSystem::solve(), LinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), FixedPointSolve::solveStep(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), MFEMTransient::takeStep(), TransientBase::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_construct_node_list_from_side_list

bool MooseMesh::_construct_node_list_from_side_list

private

Whether or not to allow generation of nodesets from sidesets.

Definition at line 1849 of file MooseMesh.h.

Referenced by buildNodeListFromSideList(), getConstructNodeListFromSideList(), and MooseMesh().

_coord_sys

std::map<SubdomainID, Moose::CoordinateSystemType>& MooseMesh::_coord_sys

private

Type of coordinate system per subdomain.

Definition at line 1901 of file MooseMesh.h.

Referenced by checkCoordinateSystems(), getCoordSystem(), getUniqueCoordSystem(), setCoordData(), setCoordSystem(), and setGeneralAxisymmetricCoordAxes().

_coord_system_set

bool MooseMesh::_coord_system_set

private

Whether the coordinate system has been set.

Definition at line 1914 of file MooseMesh.h.

Referenced by prepare(), and setCoordSystem().

_coord_transform

std::unique_ptr<MooseAppCoordTransform> MooseMesh::_coord_transform

private

A coordinate transformation object that describes how to transform this problem's coordinate system into the canonical/reference coordinate system.

Definition at line 1911 of file MooseMesh.h.

Referenced by coordTransform(), lengthUnit(), and updateCoordTransform().

_custom_partitioner

std::unique_ptr<libMesh::Partitioner> MooseMesh::_custom_partitioner

protected

The custom partitioner.

Definition at line 1467 of file MooseMesh.h.

Referenced by buildTypedMesh(), and setCustomPartitioner().

_custom_partitioner_requested

bool MooseMesh::_custom_partitioner_requested

protected

Definition at line 1468 of file MooseMesh.h.

Referenced by buildTypedMesh(), isCustomPartitionerRequested(), and setIsCustomPartitionerRequested().

_displace_node_list_by_side_list

bool MooseMesh::_displace_node_list_by_side_list

private

Whether or not to displace unrelated nodesets by nodesets constructed from sidesets.

Definition at line 1853 of file MooseMesh.h.

Referenced by buildNodeListFromSideList(), getDisplaceNodeListBySideList(), and MooseMesh().

_distribution_overridden

bool MooseMesh::_distribution_overridden

protected

Definition at line 1451 of file MooseMesh.h.

_doing_p_refinement

bool MooseMesh::_doing_p_refinement

private

Whether we have p-refinement (as opposed to h-refinement)

Definition at line 1920 of file MooseMesh.h.

Referenced by doingPRefinement(), and update().

_elem_info

std::vector<const ElemInfo *> MooseMesh::_elem_info

mutableprivate

Holds only those ElemInfo objects that have processor_id equal to this process's id, e.g.

the local ElemInfo objects

Definition at line 1627 of file MooseMesh.h.

Referenced by buildFiniteVolumeInfo(), elemInfoVector(), ownedElemInfoBegin(), and ownedElemInfoEnd().

_elem_side_to_face_info

std::unordered_map<std::pair<const Elem *, unsigned int>, FaceInfo *> MooseMesh::_elem_side_to_face_info

mutableprivate

Map from elem-side pair to FaceInfo.

Definition at line 1639 of file MooseMesh.h.

Referenced by buildFiniteVolumeInfo().

_elem_to_elem_info

std::unordered_map<dof_id_type, ElemInfo> MooseMesh::_elem_to_elem_info

mutableprivate

Map connecting elems with their corresponding ElemInfo, we use the element ID as the key.

Definition at line 1623 of file MooseMesh.h.

Referenced by buildFiniteVolumeInfo(), cacheFVElementalDoFs(), computeFiniteVolumeCoords(), and elemInfo().

_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

protected

Definition at line 1576 of file MooseMesh.h.

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

_elem_type_to_child_side_refinement_map

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

private

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

Definition at line 1789 of file MooseMesh.h.

Referenced by buildRefinementMap(), and getRefinementMap().

_elem_type_to_coarsening_map

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

private

Holds mappings for volume to volume and parent side to child side Map key:

• first member corresponds to element side. It's -1 for volume quadrature points
• second member correponds to the element type Map value:
• Vector is sized based on the number of quadrature points in the parent (e.g. coarser) element.
• For each parent quadrature point we store a pair
  • The first member of the pair identifies which child holds the closest refined-level quadrature point
  • The second member of the pair is the QpMap. The _from data member will correspond to the parent quadrature point index. The _to data member will correspond to which child element quadrature point is closest to the parent quadrature point. And _distance is the distance between the two

Definition at line 1806 of file MooseMesh.h.

Referenced by buildCoarseningMap(), and getCoarseningMap().

_elem_type_to_p_coarsening_map

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

private

Definition at line 1809 of file MooseMesh.h.

Referenced by buildPRefinementAndCoarseningMaps(), and getPCoarseningMap().

_elem_type_to_p_coarsening_side_map

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

private

Definition at line 1811 of file MooseMesh.h.

Referenced by buildPRefinementAndCoarseningMaps(), and getPCoarseningSideMap().

_elem_type_to_p_refinement_map

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

private

Definition at line 1783 of file MooseMesh.h.

Referenced by buildPRefinementAndCoarseningMaps(), and getPRefinementMap().

_elem_type_to_p_refinement_side_map

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

private

Definition at line 1785 of file MooseMesh.h.

Referenced by buildPRefinementAndCoarseningMaps(), and getPRefinementSideMap().

_elem_type_to_refinement_map

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

private

Holds mappings for volume to volume and parent side to child side Map key:

• first member corresponds to element side. It's -1 for volume quadrature points
• second member correponds to the element type Map value:
• Outermost index is the child element index
• Once we have indexed by the child element index, we have a std::vector of QpMaps. This vector is sized by the number of reference points in the child element. Then for each reference point in the child element we have a QpMap whose _from index corresponds to the child element reference point, a _to index which corresponds to the reference point on the parent element that the child element reference point is closest to, and a _distance member which is the distance between the mapped child and parent reference quadrature points

Definition at line 1780 of file MooseMesh.h.

Referenced by buildRefinementMap(), and getRefinementMap().

_enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 73 of file MooseObject.h.

Referenced by MooseObject::enabled().

_extra_bnd_nodes

std::vector<BndNode> MooseMesh::_extra_bnd_nodes

protected

Definition at line 1577 of file MooseMesh.h.

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

_extreme_nodes

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

private

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

Definition at line 1661 of file MooseMesh.h.

Referenced by detectOrthogonalDimRanges().

_face_info

std::vector<const FaceInfo *> MooseMesh::_face_info

mutableprivate

Holds only those FaceInfo objects that have processor_id equal to this process's id, e.g.

the local FaceInfo objects

Definition at line 1635 of file MooseMesh.h.

Referenced by buildFiniteVolumeInfo(), faceInfo(), nFace(), ownedFaceInfoBegin(), and ownedFaceInfoEnd().

_factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

Referenced by ElementIDOutputAction::act(), AutoCheckpointAction::act(), CreateExecutionerAction::act(), PartitionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), AdaptivityAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), SetupDebugAction::act(), ComposeTimeStepperAction::act(), SetupPreconditionerAction::act(), SetupResidualDebugAction::act(), MaterialDerivativeTestAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), DisplayGhostingAction::act(), AddControlAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), AddNodalNormalsAction::act(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), SampledOutput::cloneMesh(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), ActionComponent::getFactory(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), and ProjectedStatefulMaterialStorageAction::processProperty().

_finite_volume_info_dirty

bool MooseMesh::_finite_volume_info_dirty = true

mutableprivate

Definition at line 1642 of file MooseMesh.h.

Referenced by buildFiniteVolumeInfo(), computeFiniteVolumeCoords(), isFiniteVolumeInfoDirty(), markFiniteVolumeInfoDirty(), and update().

_ghost_elems_from_ghost_boundaries

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

private

Set of elements ghosted by ghostGhostedBoundaries.

Definition at line 1862 of file MooseMesh.h.

Referenced by ghostGhostedBoundaries().

_ghosted_boundaries

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

protected

Definition at line 1585 of file MooseMesh.h.

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

_ghosted_boundaries_inflation

std::vector<Real> MooseMesh::_ghosted_boundaries_inflation

protected

Definition at line 1586 of file MooseMesh.h.

Referenced by getGhostedBoundaryInflation(), and setGhostedBoundaryInflation().

_ghosting_functors

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

protected

Deprecated (DO NOT USE)

Definition at line 1435 of file MooseMesh.h.

_ghosting_patch_size

unsigned int MooseMesh::_ghosting_patch_size

protected

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

Definition at line 1592 of file MooseMesh.h.

Referenced by getGhostingPatchSize().

_half_range

RealVectorValue MooseMesh::_half_range

private

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

Definition at line 1658 of file MooseMesh.h.

Referenced by addPeriodicVariable(), and minPeriodicVector().

_has_lower_d

bool MooseMesh::_has_lower_d

private

Whether there are any lower-dimensional blocks that are manifolds of higher-dimensional block faces.

Definition at line 1843 of file MooseMesh.h.

Referenced by cacheInfo(), and hasLowerD().

_higher_d_elem_side_to_lower_d_elem

std::unordered_map<std::pair<const Elem *, unsigned short int>, const Elem *> MooseMesh::_higher_d_elem_side_to_lower_d_elem

private

Holds a map from a high-order element side to its corresponding lower-d element.

Definition at line 1838 of file MooseMesh.h.

Referenced by buildLowerDMesh(), cacheInfo(), getLowerDElem(), and getLowerDElemMap().

_id_identical_flag

std::vector<std::vector<bool> > MooseMesh::_id_identical_flag

private

Flags to indicate whether or not any two extra element integers are the same.

Definition at line 1877 of file MooseMesh.h.

Referenced by areElemIDsIdentical(), and buildElemIDInfo().

_is_changed

bool MooseMesh::_is_changed

protected

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

Definition at line 1493 of file MooseMesh.h.

_is_displaced

bool MooseMesh::_is_displaced

private

Whether this mesh is displaced.

Definition at line 1892 of file MooseMesh.h.

Referenced by isDisplaced().

_is_nemesis

bool MooseMesh::_is_nemesis

protected

True if a Nemesis Mesh was read in.

Definition at line 1496 of file MooseMesh.h.

Referenced by FileMesh::buildMesh(), determineUseDistributedMesh(), prepare(), and FileMesh::read().

_is_split

const bool MooseMesh::_is_split

protected

Whether or not we are using a (pre-)split mesh (automatically DistributedMesh)

Definition at line 1613 of file MooseMesh.h.

Referenced by determineUseDistributedMesh(), and isSplit().

_kokkos_mesh

std::unique_ptr<Moose::Kokkos::Mesh> MooseMesh::_kokkos_mesh

protected

Pointer to Kokkos mesh object.

Definition at line 1459 of file MooseMesh.h.

Referenced by getKokkosMesh(), MooseMesh(), and update().

_linear_finite_volume_dofs_cached

bool MooseMesh::_linear_finite_volume_dofs_cached = false

mutableprivate

Definition at line 1647 of file MooseMesh.h.

_local_node_range

std::unique_ptr<libMesh::ConstNodeRange> MooseMesh::_local_node_range

protected

Definition at line 1525 of file MooseMesh.h.

Referenced by getLocalNodeRange(), and meshChanged().

_lower_d_boundary_blocks

std::set<SubdomainID> MooseMesh::_lower_d_boundary_blocks

private

Mesh blocks for boundary lower-d elements in different types.

Definition at line 1835 of file MooseMesh.h.

Referenced by boundaryLowerDBlocks(), buildLowerDMesh(), and cacheInfo().

_lower_d_elem_to_higher_d_elem_side

std::unordered_map<const Elem *, unsigned short int> MooseMesh::_lower_d_elem_to_higher_d_elem_side

private

Definition at line 1839 of file MooseMesh.h.

Referenced by buildLowerDMesh(), cacheInfo(), and getHigherDSide().

_lower_d_interior_blocks

std::set<SubdomainID> MooseMesh::_lower_d_interior_blocks

private

Mesh blocks for interior lower-d elements in different types.

Definition at line 1833 of file MooseMesh.h.

Referenced by buildLowerDMesh(), cacheInfo(), and interiorLowerDBlocks().

_max_h_level

unsigned int MooseMesh::_max_h_level

private

Maximum h-refinement level of all elements.

Definition at line 1924 of file MooseMesh.h.

Referenced by maxHLevel(), and update().

_max_ids

std::vector<dof_id_type> MooseMesh::_max_ids

private

Maximum integer ID for each extra element integer.

Definition at line 1873 of file MooseMesh.h.

Referenced by buildElemIDInfo(), and maxElementID().

_max_leaf_size

unsigned int MooseMesh::_max_leaf_size

protected

Definition at line 1595 of file MooseMesh.h.

Referenced by getMaxLeafSize().

_max_nodes_per_elem

unsigned int MooseMesh::_max_nodes_per_elem

private

The maximum number of nodes per element.

Definition at line 1883 of file MooseMesh.h.

Referenced by computeMaxPerElemAndSide(), and getMaxNodesPerElem().

_max_nodes_per_side

unsigned int MooseMesh::_max_nodes_per_side

private

The maximum number of nodes per side.

Definition at line 1886 of file MooseMesh.h.

Referenced by computeMaxPerElemAndSide(), and getMaxNodesPerSide().

_max_p_level

unsigned int MooseMesh::_max_p_level

private

Maximum p-refinement level of all elements.

Definition at line 1922 of file MooseMesh.h.

Referenced by maxPLevel(), and update().

_max_sides_per_elem

unsigned int MooseMesh::_max_sides_per_elem

private

The maximum number of sides per element.

Definition at line 1880 of file MooseMesh.h.

Referenced by computeMaxPerElemAndSide(), and getMaxSidesPerElem().

_mesh

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

protected

Pointer to underlying libMesh mesh object.

Definition at line 1455 of file MooseMesh.h.

Referenced by allowRemoteElementRemoval(), buildFiniteVolumeInfo(), buildPeriodicNodeMap(), deleteRemoteElements(), detectPairedSidesets(), getMaxInDimension(), getMesh(), getMeshPtr(), getMinInDimension(), hasMeshBase(), init(), nActiveElem(), nActiveLocalElem(), nLocalNodes(), nPartitions(), nSubdomains(), prepare(), prepared(), setCoordSystem(), setMeshBase(), skipNoncriticalPartitioning(), skipPartitioning(), and spatialDimension().

_mesh_boundary_ids

std::set<BoundaryID> MooseMesh::_mesh_boundary_ids

protected

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

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

_mesh_nodeset_ids

std::set<BoundaryID> MooseMesh::_mesh_nodeset_ids

protected

Definition at line 1553 of file MooseMesh.h.

Referenced by meshNodesetIds(), and prepare().

_mesh_sideset_ids

std::set<BoundaryID> MooseMesh::_mesh_sideset_ids

protected

Definition at line 1552 of file MooseMesh.h.

Referenced by meshSidesetIds(), and prepare().

_mesh_subdomains

std::set<SubdomainID> MooseMesh::_mesh_subdomains

protected

A set of subdomain IDs currently present in the mesh.

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

Definition at line 1543 of file MooseMesh.h.

Referenced by buildLowerDMesh(), cacheInfo(), checkDuplicateSubdomainNames(), meshSubdomains(), and prepare().

_min_ids

std::vector<dof_id_type> MooseMesh::_min_ids

private

Minimum integer ID for each extra element integer.

Definition at line 1875 of file MooseMesh.h.

Referenced by buildElemIDInfo(), and minElementID().

_moose_mesh_prepared

bool MooseMesh::_moose_mesh_prepared = false

protected

True if prepare has been called on the mesh.

Definition at line 1499 of file MooseMesh.h.

Referenced by prepare(), and prepared().

_name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 363 of file MooseBase.h.

Referenced by AddBCAction::act(), AddConstraintAction::act(), AddFVInitialConditionAction::act(), AddPostprocessorAction::act(), AddVectorPostprocessorAction::act(), AddKernelAction::act(), AddMultiAppAction::act(), PartitionerAction::act(), AddInterfaceKernelAction::act(), AddNodalKernelAction::act(), AddDiracKernelAction::act(), AddDGKernelAction::act(), AddMarkerAction::act(), AddIndicatorAction::act(), AddInitialConditionAction::act(), AddMeshGeneratorAction::act(), AddDamperAction::act(), AddFVInterfaceKernelAction::act(), AddMaterialAction::act(), AddScalarKernelAction::act(), AddTransferAction::act(), AddFunctorMaterialAction::act(), AddUserObjectAction::act(), ReadExecutorParamsAction::act(), AddPositionsAction::act(), AddReporterAction::act(), AddTimesAction::act(), AddFieldSplitAction::act(), AddFVKernelAction::act(), AddFVBCAction::act(), AddFunctionAction::act(), AddConvergenceAction::act(), AddMeshDivisionAction::act(), AddHDGKernelAction::act(), AddTimeStepperAction::act(), AddDistributionAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddOutputAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddCorrectorAction::act(), AddMeshModifiersAction::act(), AddSamplerAction::act(), AddControlAction::act(), AddMFEMFESpaceAction::act(), AddMFEMSubMeshAction::act(), AddMFEMPreconditionerAction::act(), AddMFEMSolverAction::act(), AddPeriodicBCAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), PiecewiseLinearBase::buildInterpolation(), CombinerGenerator::CombinerGenerator(), Executor::Executor(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::name(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseBase::setData(), and AddVariableAction::varName().

_need_delete

bool MooseMesh::_need_delete

private

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

Definition at line 1856 of file MooseMesh.h.

Referenced by allowRemoteElementRemoval(), and needsRemoteElemDeletion().

_need_ghost_ghosted_boundaries

bool MooseMesh::_need_ghost_ghosted_boundaries

private

A parallel mesh generator such as DistributedRectilinearMeshGenerator already make everything ready.

We do not need to gather all boundaries to every single processor. In general, we should avoid using ghostGhostedBoundaries when possible since it is not scalable

Definition at line 1868 of file MooseMesh.h.

Referenced by ghostGhostedBoundaries(), and needGhostGhostedBoundaries().

_neighbor_subdomain_boundary_ids

std::unordered_map<SubdomainID, std::set<BoundaryID> > MooseMesh::_neighbor_subdomain_boundary_ids

private

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

Definition at line 1830 of file MooseMesh.h.

Referenced by cacheInfo(), getBoundaryConnectedSecondaryBlocks(), getInterfaceConnectedBlocks(), and getSubdomainInterfaceBoundaryIds().

_node_map

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

protected

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

Definition at line 1601 of file MooseMesh.h.

Referenced by addUniqueNode().

_node_set_nodes

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

protected

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

Definition at line 1583 of file MooseMesh.h.

Referenced by buildNodeList(), freeBndNodes(), getNodeList(), and nodeSetNodes().

_node_to_active_semilocal_elem_map

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

protected

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

Definition at line 1536 of file MooseMesh.h.

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

_node_to_active_semilocal_elem_map_built

bool MooseMesh::_node_to_active_semilocal_elem_map_built

protected

Definition at line 1537 of file MooseMesh.h.

Referenced by nodeToActiveSemilocalElemMap(), and update().

_node_to_elem_map

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

protected

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

Definition at line 1532 of file MooseMesh.h.

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

_node_to_elem_map_built

bool MooseMesh::_node_to_elem_map_built

protected

Definition at line 1533 of file MooseMesh.h.

Referenced by nodeToElemMap(), and update().

_paired_boundary

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

protected

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

Definition at line 1610 of file MooseMesh.h.

Referenced by detectPairedSidesets(), and getPairedBoundaryMapping().

_parallel_type

ParallelType MooseMesh::_parallel_type

protected

Can be set to DISTRIBUTED, REPLICATED, or DEFAULT.

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

Definition at line 1445 of file MooseMesh.h.

Referenced by determineUseDistributedMesh(), getParallelType(), and setParallelType().

_parallel_type_overridden

bool MooseMesh::_parallel_type_overridden

protected

Definition at line 1452 of file MooseMesh.h.

Referenced by determineUseDistributedMesh(), and isParallelTypeForced().

_pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 366 of file MooseBase.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), prepare(), Eigenvalue::prepareSolverOptions(), setCoordSystem(), setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

_partitioner_name

MooseEnum MooseMesh::_partitioner_name

protected

The partitioner used on this mesh.

Definition at line 1463 of file MooseMesh.h.

Referenced by partitionerName(), and setPartitionerHelper().

_partitioner_overridden

bool MooseMesh::_partitioner_overridden

protected

Definition at line 1464 of file MooseMesh.h.

Referenced by isPartitionerForced(), and setPartitionerHelper().

_patch_size

unsigned int MooseMesh::_patch_size

protected

The number of nodes to consider in the NearestNode neighborhood.

Definition at line 1589 of file MooseMesh.h.

Referenced by getPatchSize().

_patch_update_strategy

Moose::PatchUpdateType MooseMesh::_patch_update_strategy

protected

The patch update strategy.

Definition at line 1598 of file MooseMesh.h.

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

_periodic_dim

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

private

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

Referenced by addPeriodicVariable(), and isTranslatedPeriodic().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_provided_coord_blocks

std::vector<SubdomainName> MooseMesh::_provided_coord_blocks

private

Set for holding user-provided coordinate system type block names.

Definition at line 1917 of file MooseMesh.h.

Referenced by MooseMesh(), prepare(), and setCoordSystem().

_quadrature_nodes

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

protected

Definition at line 1574 of file MooseMesh.h.

Referenced by addQuadratureNode(), clearQuadratureNodes(), and queryNodePtr().

_refined_elements

std::unique_ptr<ConstElemPointerRange> MooseMesh::_refined_elements

protected

The elements that were just refined.

Definition at line 1502 of file MooseMesh.h.

Referenced by cacheChangedLists(), and refinedElementRange().

_regular_orthogonal_mesh

bool MooseMesh::_regular_orthogonal_mesh

protected

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

Definition at line 1604 of file MooseMesh.h.

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

_relationship_managers

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

protected

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

Definition at line 1438 of file MooseMesh.h.

_restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 234 of file Restartable.h.

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

_restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 243 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

_restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 237 of file Restartable.h.

Referenced by Restartable::restartableName().

_restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 240 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

_rz_coord_axis

unsigned int MooseMesh::_rz_coord_axis

private

Storage for RZ axis selection.

Definition at line 1904 of file MooseMesh.h.

Referenced by getAxisymmetricRadialCoord(), setAxisymmetricCoordAxis(), and setCoordData().

_semilocal_node_list

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

protected

Used for generating the semilocal node range.

Definition at line 1515 of file MooseMesh.h.

Referenced by isSemiLocal(), and updateActiveSemiLocalNodeRange().

_skip_deletion_repartition_after_refine

bool MooseMesh::_skip_deletion_repartition_after_refine

protected

Whether or not skip remote deletion and repartition after uniform refinements.

Definition at line 1490 of file MooseMesh.h.

Referenced by setUniformRefineLevel(), and skipDeletionRepartitionAfterRefine().

_skip_refine_when_use_split

bool MooseMesh::_skip_refine_when_use_split

protected

Whether or not to skip uniform refinements when using a pre-split mesh.

Definition at line 1487 of file MooseMesh.h.

Referenced by skipRefineWhenUseSplit().

_sub_to_data

std::unordered_map<SubdomainID, SubdomainData> MooseMesh::_sub_to_data

private

Holds a map from subdomain ids to associated data.

Definition at line 1827 of file MooseMesh.h.

Referenced by cacheInfo(), getBlockConnectedBlocks(), getBoundaryConnectedBlocks(), getSubdomainBoundaryIds(), and isLowerD().

_subdomain_id_to_rz_coord_axis

std::unordered_map<SubdomainID, std::pair<Point, RealVectorValue> > MooseMesh::_subdomain_id_to_rz_coord_axis

private

Map of subdomain ID to general axisymmetric axis.

Definition at line 1907 of file MooseMesh.h.

Referenced by getGeneralAxisymmetricCoordAxis(), setCoordData(), setGeneralAxisymmetricCoordAxes(), and usingGeneralAxisymmetricCoordAxes().

_type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 360 of file MooseBase.h.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), ExplicitTimeIntegrator::init(), FEProblemBase::init(), MooseBase::MooseBase(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), FEProblemBase::solverTypeString(), and MooseBase::type().

_uniform_refine_level

unsigned int MooseMesh::_uniform_refine_level

protected

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

Definition at line 1484 of file MooseMesh.h.

Referenced by setUniformRefineLevel(), and uniformRefineLevel().

_use_distributed_mesh

bool MooseMesh::_use_distributed_mesh

protected

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

Referenced by buildMeshBaseObject(), buildTypedMesh(), detectPairedSidesets(), determineUseDistributedMesh(), errorIfDistributedMesh(), ghostGhostedBoundaries(), init(), isDistributedMesh(), and setPartitionerHelper().

app_param

const std::string MooseBase::app_param = "_moose_app"

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), Factory::getValidParams(), ActionFactory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"

staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by AddBCAction::act(), AddKernelAction::act(), AddNodalKernelAction::act(), AddMaterialAction::act(), AddFunctionAction::act(), MooseObject::isKokkosObject(), and MooseApp::setupOptions().

moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"

staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

name_param

const std::string MooseBase::name_param = "_object_name"

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), MooseObjectUnitTest::buildObjects(), ActionFactory::create(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

type_param

const std::string MooseBase::type_param = "_type"

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"

staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings

inherited

Definition at line 69 of file MooseObject.h.

---

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

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