ImageMesh Class Reference

A 2D GeneratedMesh where xmin, xmax, etc. More...

#include <ImageMesh.h>

Inheritance diagram for ImageMesh:

Public Types
enum class	ParallelType { DEFAULT , REPLICATED , DISTRIBUTED }
using	PeriodicNodeInfo = std::pair< const Node *, BoundaryID >
	Helper type for building periodic node maps.
using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name.

Public Member Functions
	ImageMesh (const InputParameters &parameters)
	ImageMesh (const ImageMesh &other_mesh)
virtual std::unique_ptr< MooseMesh >	safeClone () const override
	A safer version of the clone() method that hands back an allocated object wrapped in a smart pointer.
virtual void	buildMesh () override
	Must be overridden by child classes.
virtual Real	getMinInDimension (unsigned int component) const override
	Returns the min or max of the requested dimension respectively.
virtual Real	getMaxInDimension (unsigned int component) const override
virtual void	prepared (bool state) override
bool	prepared () const
	Setter/getter for whether the mesh is prepared.
virtual MooseMesh &	clone () const
	Clone method.
void	determineUseDistributedMesh ()
	Determine whether to use a distributed mesh.
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.
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.
void	setMeshBase (std::unique_ptr< MeshBase > mesh_base)
	Method to set the mesh_base object.
virtual void	init ()
	Initialize the Mesh object.
virtual std::vector< std::filesystem::path >	writeRecoveryFiles (const std::filesystem::path &file_base)
	Write the mesh files needed for recovery/checkpointing.
virtual unsigned int	dimension () const
	Returns MeshBase::mesh_dimension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh mesh object.
virtual unsigned int	spatialDimension () const
	Returns MeshBase::spatial_dimension.
virtual unsigned int	effectiveSpatialDimension () const
	Returns the effective spatial dimension determined by the coordinates actually used by the mesh.
unsigned int	getBlocksMaxDimension (const std::vector< SubdomainName > &blocks) const
	Returns the maximum element dimension on the given blocks.
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.
std::vector< std::vector< BoundaryID > >	getBoundaryIDs (const Elem *const elem) const
	Returns a vector of vector of boundary IDs for the requested element on each of its sides.
const std::set< BoundaryID > &	getBoundaryIDs () const
	Returns a const reference to a set of all user-specified boundary IDs.
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.
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.
unsigned int	getHigherDSide (const Elem *elem) const
	Returns the local side ID of the interior parent aligned with the lower dimensional element.
void	buildNodeList ()
	Calls BoundaryInfo::build_node_list()/build_side_list() and makes separate copies of Nodes/Elems in those lists.
void	buildBndElemList ()
const std::unordered_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.
virtual bnd_node_iterator	bndNodesBegin ()
	Return iterators to the beginning/end of the boundary nodes list.
virtual bnd_node_iterator	bndNodesEnd ()
virtual bnd_elem_iterator	bndElemsBegin ()
	Return iterators to the beginning/end of the boundary elements list.
virtual bnd_elem_iterator	bndElemsEnd ()
void	buildNodeListFromSideList ()
	Calls BoundaryInfo::build_node_list_from_side_list().
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.
std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	buildActiveSideList () const
	Calls BoundaryInfo::build_active_side_list.
unsigned int	sideWithBoundaryID (const Elem *const elem, const BoundaryID boundary_id) const
	Calls BoundaryInfo::side_with_boundary_id().
MeshBase::node_iterator	localNodesBegin ()
	Calls local_nodes_begin/end() on the underlying libMesh mesh object.
MeshBase::const_node_iterator	localNodesBegin () const
MeshBase::node_iterator	localNodesEnd ()
MeshBase::const_node_iterator	localNodesEnd () const
MeshBase::element_iterator	activeLocalElementsBegin ()
	Calls active_local_nodes_begin/end() on the underlying libMesh mesh object.
MeshBase::const_element_iterator	activeLocalElementsBegin () const
const MeshBase::element_iterator	activeLocalElementsEnd ()
const MeshBase::const_element_iterator	activeLocalElementsEnd () const
virtual dof_id_type	nNodes () const
	Calls n_nodes/elem() on the underlying libMesh mesh object.
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.
virtual dof_id_type	maxElemId () const
virtual const Node &	node (const dof_id_type i) const
	Various accessors (pointers/references) for Node "i".
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".
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
void	needsPrepareForUse ()
	If this method is called, we will call libMesh's prepare_for_use method when we call Moose's prepare method.
void	meshChanged ()
	Declares that the MooseMesh has changed, invalidates cached data and rebuilds caches.
virtual void	onMeshChanged ()
	Declares a callback function that is executed at the conclusion of meshChanged().
void	cacheChangedLists ()
	Cache information about what elements were refined and coarsened in the previous step.
ConstElemPointerRange *	refinedElementRange () const
	Return a range that is suitable for threaded execution over elements that were just refined.
ConstElemPointerRange *	coarsenedElementRange () const
	Return a range that is suitable for threaded execution over elements that were just coarsened.
const std::vector< const Elem * > &	coarsenedElementChildren (const Elem *elem) const
	Get the newly removed children element ids for an element that was just coarsened.
void	updateActiveSemiLocalNodeRange (std::set< dof_id_type > &ghosted_elems)
	Clears the "semi-local" node list and rebuilds it.
bool	isSemiLocal (Node *const node) const
	Returns true if the node is semi-local.
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.
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.
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.
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.
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.
const std::set< SubdomainID > &	meshSubdomains () const
	Returns a read-only reference to the set of subdomains currently present in the Mesh.
const std::set< BoundaryID > &	meshBoundaryIds () const
	Returns a read-only reference to the set of boundary IDs currently present in the Mesh.
const std::set< BoundaryID > &	meshSidesetIds () const
	Returns a read-only reference to the set of sidesets currently present in the Mesh.
const std::set< BoundaryID > &	meshNodesetIds () const
	Returns a read-only reference to the set of nodesets currently present in the Mesh.
void	setBoundaryToNormalMap (std::unique_ptr< std::map< BoundaryID, RealVectorValue > > boundary_map)
	Sets the mapping between BoundaryID and normal vector Is called by AddAllSideSetsByNormals.
void	setBoundaryToNormalMap (std::map< BoundaryID, RealVectorValue > *boundary_map)
void	setMeshBoundaryIDs (std::set< BoundaryID > boundary_IDs)
	Sets the set of BoundaryIDs Is called by AddAllSideSetsByNormals.
const RealVectorValue &	getNormalByBoundaryID (BoundaryID id) const
	Returns the normal vector associated with a given BoundaryID.
void	prepare ()
	Calls prepare_for_use() if the underlying MeshBase object isn't prepared, then communicates various boundary information on parallel meshes.
void	prepare (const MeshBase *mesh_to_clone)
	Deprecated method; mesh_to_clone is no longer supported and must be null.
void	update ()
	Calls buildNodeListFromSideList(), buildNodeList(), and buildBndElemList().
unsigned int	uniformRefineLevel () const
	Returns the level of uniform refinement requested (zero if AMR is disabled).
void	setUniformRefineLevel (unsigned int, bool deletion=true)
	Set uniform refinement level.
bool	skipDeletionRepartitionAfterRefine () const
	Return a flag indicating whether or not we should skip remote deletion and repartition after uniform refinements.
bool	skipRefineWhenUseSplit () const
	Whether or not skip uniform refinements when using a pre-split mesh.
void	addGhostedBoundary (BoundaryID boundary_id)
	This will add the boundary ids to be ghosted to this processor.
void	setGhostedBoundaryInflation (const std::vector< Real > &inflation)
	This sets the inflation amount for the bounding box for each partition for use in ghosting boundaries.
const std::set< unsigned int > &	getGhostedBoundaries () const
	Return a writable reference to the set of ghosted boundary IDs.
const std::vector< Real > &	getGhostedBoundaryInflation () const
	Return a writable reference to the _ghosted_boundaries_inflation vector.
void	ghostGhostedBoundaries ()
	Actually do the ghosting of boundaries that need to be ghosted to this processor.
void	needGhostGhostedBoundaries (bool needghost)
	Whether or not we want to ghost ghosted boundaries.
unsigned int	getPatchSize () const
	Getter for the patch_size parameter.
unsigned int	getGhostingPatchSize () const
	Getter for the ghosting_patch_size parameter.
unsigned int	getMaxLeafSize () const
	Getter for the maximum leaf size parameter.
void	setPatchUpdateStrategy (Moose::PatchUpdateType patch_update_strategy)
	Set the patch size update strategy.
const Moose::PatchUpdateType &	getPatchUpdateStrategy () const
	Get the current patch update strategy.
libMesh::BoundingBox	getInflatedProcessorBoundingBox (Real inflation_multiplier=0.01) const
	Get a (slightly inflated) processor bounding box.
	operator libMesh::MeshBase & ()
	Implicit conversion operator from MooseMesh -> libMesh::MeshBase.
	operator const libMesh::MeshBase & () const
MeshBase &	getMesh ()
	Accessor for the underlying libMesh Mesh object.
MeshBase &	getMesh (const std::string &name)
const MeshBase &	getMesh () const
const MeshBase &	getMesh (const std::string &name) const
const MeshBase *	getMeshPtr () const
Moose::Kokkos::Mesh *	getKokkosMesh ()
	Accessor for Kokkos mesh object.
const Moose::Kokkos::Mesh *	getKokkosMesh () const
void	printInfo (std::ostream &os=libMesh::out, const unsigned int verbosity=0) const
	Calls print_info() on the underlying Mesh.
const std::set< SubdomainID > &	getNodeBlockIds (const Node &node) const
	Return list of blocks to which the given node belongs.
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.
const Node *	addUniqueNode (const Point &p, Real tol=1e-6)
	Add a new node to the mesh.
Node *	addQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp, BoundaryID bid, const Point &point)
	Adds a fictitious "QuadratureNode".
Node *	getQuadratureNode (const Elem *elem, const unsigned short int side, const unsigned int qp)
	Get a specified quadrature node.
void	clearQuadratureNodes ()
	Clear out any existing quadrature nodes.
BoundaryID	getBoundaryID (const BoundaryName &boundary_name) const
	Get the associated BoundaryID for the boundary name.
SubdomainID	getSubdomainID (const SubdomainName &subdomain_name) const
	Get the associated subdomain ID for the subdomain name.
std::vector< SubdomainID >	getSubdomainIDs (const std::vector< SubdomainName > &subdomain_names) const
	Get the associated subdomainIDs for the subdomain names that are passed in.
std::set< SubdomainID >	getSubdomainIDs (const std::set< SubdomainName > &subdomain_names) const
void	setSubdomainName (SubdomainID subdomain_id, const SubdomainName &name, const bool synchronous=false)
	This method sets the name for subdomain_id to name.
const std::string &	getSubdomainName (SubdomainID subdomain_id) const
	Return the name of a block given an id.
std::vector< SubdomainName >	getSubdomainNames (const std::vector< SubdomainID > &subdomain_ids) const
	Get the associated subdomainNames for the subdomain ids that are passed in.
void	setBoundaryName (BoundaryID boundary_id, BoundaryName name)
	This method sets the boundary name of the boundary based on the id parameter.
const std::string &	getBoundaryName (const BoundaryID boundary_id) const
	Return the name of the boundary given the id.
std::string	getBoundaryString (const BoundaryID boundary_id) const
	Return the name of the boundary given the id, if it exists.
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.
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.
Real	dimensionWidth (unsigned int component) const
	Returns the width of the requested dimension.
bool	detectOrthogonalDimRanges (Real tol=1e-6)
	This routine determines whether the Mesh is a regular orthogonal mesh (i.e.
void	addPeriodicVariable (const unsigned int sys_num, const unsigned int var_num, const BoundaryID primary, const 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.
const std::array< bool, 3 > &	queryPeriodicDimensions (const unsigned int sys_num, const unsigned int var_num) const
	Query the translated periodic dimension flags for the given variable on the given system.
const std::array< bool, 3 > &	queryPeriodicDimensions (const MooseVariableBase &var) const
	Query the translated periodic dimension flags for the given variable.
bool	isTranslatedPeriodic (const unsigned int sys_num, const unsigned int var_num, const unsigned int component) const
	Returns whether this generated mesh is periodic in the given dimension for the given variable on the given system.
bool	isTranslatedPeriodic (const MooseVariableBase &var, const unsigned int component) const
	Returns whether this generated mesh is periodic in the given dimension for the given variable.
bool	isTranslatedPeriodic (const unsigned int var_num, const unsigned int component) const
	Returns whether this generated mesh is periodic in the given dimension for the given variable.
RealVectorValue	minPeriodicVector (const unsigned int sys_num, const unsigned int var_num, Point p, Point q) const
	Returns the minimum vector between two points on the mesh taking into account periodicity for the given variable on the given system.
RealVectorValue	minPeriodicVector (const MooseVariableBase &var, const Point &p, const Point &q) const
	Returns the minimum vector between two points on the mesh taking into account periodicity for the given variable.
RealVectorValue	minPeriodicVector (const unsigned int var_num, const Point &p, const Point &q) const
	Returns the minimum vector between two points on the mesh taking into account periodicity for the given variable on the given system.
Real	minPeriodicDistance (const unsigned int sys_num, const unsigned int var_num, const Point &p, const Point &q) const
	Returns the distance between two points on the mesh taking into account periodicity for the given variable on the given system.
Real	minPeriodicDistance (const MooseVariableBase &var, const Point &p, const Point &q) const
	Returns the distance between two points on the mesh taking into account periodicity for the given variable.
Real	minPeriodicDistance (const unsigned int var_num, const Point &p, const Point &q) const
	Returns the distance between two points on the mesh taking into account periodicity for the given variable.
void	detectPairedSidesets ()
	This routine detects paired sidesets of a regular orthogonal mesh (.i.e.
bool	hasDetectedPairedSidesets () const
	Whether or not detectedPairedSidesets() has been called.
const std::pair< BoundaryID, BoundaryID > *	getPairedBoundaryMapping (unsigned int component) const
	This function attempts to return the paired boundary ids for the given component.
void	buildRefinementAndCoarseningMaps (Assembly *assembly)
	Create the refinement and coarsening maps necessary for projection of stateful material properties when using adaptivity.
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.
const std::vector< std::pair< unsigned int, QpMap > > &	getCoarseningMap (const Elem &elem, int input_side)
	Get the coarsening map for a given element type.
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.
const std::set< BoundaryID > &	getSubdomainBoundaryIds (const SubdomainID subdomain_id) const
	Get the list of boundary ids associated with the given subdomain id.
std::set< BoundaryID >	getSubdomainInterfaceBoundaryIds (const SubdomainID subdomain_id) const
	Get the list of boundaries that contact the given subdomain.
std::set< SubdomainID >	getBoundaryConnectedBlocks (const BoundaryID bid) const
	Get the list of subdomains associated with the given boundary.
std::set< SubdomainID >	getBoundaryConnectedSecondaryBlocks (const BoundaryID bid) const
	Get the list of subdomains associated with the given boundary of its secondary side.
std::set< SubdomainID >	getInterfaceConnectedBlocks (const BoundaryID bid) const
	Get the list of subdomains contacting the given boundary.
const std::set< SubdomainID > &	getBlockConnectedBlocks (const SubdomainID subdomain_id) const
	Get the list of subdomains neighboring a given subdomain.
bool	isBoundaryNode (dof_id_type node_id) const
	Returns true if the requested node is in the list of boundary nodes, false otherwise.
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.
bool	isBoundaryElem (dof_id_type elem_id) const
	Returns true if the requested element is in the list of boundary elements, false otherwise.
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.
void	errorIfDistributedMesh (std::string name) const
	Generate a unified error message if the underlying libMesh mesh is a DistributedMesh.
virtual bool	isDistributedMesh () const
	Returns the final Mesh distribution type.
bool	isParallelTypeForced () const
	Tell the user if the distribution was overriden for any reason.
void	setParallelType (ParallelType parallel_type)
	Allow to change parallel type.
ParallelType	getParallelType () const
const MooseEnum &	partitionerName () const
bool	isPartitionerForced () const
	Tell the user if the partitioner was overriden for any reason.
void	allowRecovery (bool allow)
	Set whether or not this mesh is allowed to read a recovery file.
void	setCustomPartitioner (libMesh::Partitioner *partitioner)
	Setter for custom partitioner.
bool	isRegularOrthogonal ()
	Getter to query if the mesh was detected to be regular and orthogonal.
bool	hasSecondOrderElements ()
	check if the mesh has SECOND order elements
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.
virtual std::string	getFileName () const
	Returns the name of the mesh file read to produce this mesh if any or an empty string otherwise.
void	needsRemoteElemDeletion (bool need_delete)
	Set whether we need to delete remote elements.
bool	needsRemoteElemDeletion () const
	Whether we need to delete remote elements.
void	allowRemoteElementRemoval (bool allow_removal)
	Set whether to allow remote element removal.
bool	allowRemoteElementRemoval () const
	Whether we are allow remote element removal.
void	deleteRemoteElements ()
	Delete remote elements.
bool	hasMeshBase () const
	Whether mesh base object was constructed or not.
bool	hasElementID (const std::string &id_name) const
	Whether mesh has an extra element integer with a given name.
unsigned int	getElementIDIndex (const std::string &id_name) const
	Return the accessing integer for an extra element integer with its name.
dof_id_type	maxElementID (unsigned int elem_id_index) const
	Return the maximum element ID for an extra element integer with its accessing index.
dof_id_type	minElementID (unsigned int elem_id_index) const
	Return the minimum element ID for an extra element integer with its accessing index.
bool	areElemIDsIdentical (const std::string &id_name1, const std::string &id_name2) const
	Whether or not two extra element integers are identical.
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.
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.
unsigned int	getMaxSidesPerElem () const
	Get the maximum number of sides per element.
unsigned int	getMaxNodesPerElem () const
	Get the maximum number of nodes per element.
unsigned int	getMaxNodesPerSide () const
	Get the maximum number of nodes per side.
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.
void	cacheFVElementalDoFs () const
	Cache the DoF indices for FV variables on each element.
void	computeFiniteVolumeCoords () const
	Compute the face coordinate value for all FaceInfo and ElemInfo objects.
void	isDisplaced (bool is_displaced)
	Set whether this mesh is a displaced mesh.
bool	isDisplaced () const
	whether this mesh is a displaced mesh
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.
const std::map< SubdomainID, Moose::CoordinateSystemType > &	getCoordSystem () const
	Get the map from subdomain ID to coordinate system type, e.g.
Moose::CoordinateSystemType	getUniqueCoordSystem () const
	Get the coordinate system from the mesh, it must be the same in all subdomains otherwise this will error.
void	setCoordSystem (const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
	Set the coordinate system for the provided blocks to coord_sys.
void	setAxisymmetricCoordAxis (const MooseEnum &rz_coord_axis)
	For axisymmetric simulations, set the symmetry coordinate axis.
void	setGeneralAxisymmetricCoordAxes (const std::vector< SubdomainName > &blocks, const std::vector< std::pair< Point, RealVectorValue > > &axes)
	Sets the general coordinate axes for axisymmetric blocks.
const std::pair< Point, RealVectorValue > &	getGeneralAxisymmetricCoordAxis (SubdomainID subdomain_id) const
	Gets the general axisymmetric coordinate axis for a block.
bool	usingGeneralAxisymmetricCoordAxes () const
	Returns true if general axisymmetric coordinate axes are being used.
unsigned int	getAxisymmetricRadialCoord () const
	Returns the desired radial direction for RZ coordinate transformation.
void	checkCoordinateSystems ()
	Performs a sanity check for every element in the mesh.
void	setCoordData (const MooseMesh &other_mesh)
	Set the coordinate system data to that of other_mesh.
void	markFiniteVolumeInfoDirty ()
	Mark the finite volume information as dirty.
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.
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.
void	setupFiniteVolumeMeshData () const
	Sets up the additional data needed for finite volume computations.
void	doingPRefinement (bool doing_p_refinement)
	Indicate whether the kind of adaptivity we're doing includes p-refinement.
bool	doingPRefinement () const
	Query whether the kind of adaptivity we're doing includes p-refinement.
unsigned int	maxPLevel () const
	Returns the maximum p-refinement level of all elements.
unsigned int	maxHLevel () const
	Returns the maximum h-refinement level of all elements.
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.
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.
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.
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.
void	buildPRefinementAndCoarseningMaps (Assembly *assembly)
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.
bool	getDisplaceNodeListBySideList ()
	Return displace node list by side list boolean.
bool	possiblyRebuildNodeToElemMap ()
	rebuild the node to element map if it's been requsted previously
virtual bool	enabled () const
	Return the enabled status of the object.
std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group.
std::shared_ptr< const MooseObject >	getSharedPtr () const
bool	isKokkosObject () const
	Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.
MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with.
const std::string &	type () const
	Get the type of this class.
const std::string &	name () const
	Get the name of the class.
std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling.
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
MooseObjectName	uniqueName () const
const InputParameters &	parameters () const
	Get the parameters of the object.
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.
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.
template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object.
template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object.
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.
bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid.
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.
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.
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.
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.
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.
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.
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.
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().
template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type.
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().
template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and a stack trace.
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseDeprecatedNoTrace (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and no stack trace.
template<typename... Args>
void	mooseInfo (Args &&... args) const
void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
	External method for calling moose error with added object context.
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.
std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method.
std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path.
PerfGraph &	perfGraph ()
	Get the PerfGraph.
std::string	fileSuffix ()
const std::vector< std::string > &	filenames ()
const libMesh::ConstElemRange *	getActiveLocalElementRange ()
	Return pointers to range objects for various types of ranges (local nodes, boundary elems, etc.).
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 ()
bool	isCustomPartitionerRequested () const
	Setter and getter for _custom_partitioner_requested.
void	setIsCustomPartitionerRequested (bool cpr)
unsigned int	nFace () const
	accessors for the FaceInfo objects
const std::vector< const FaceInfo * > &	faceInfo () const
	Accessor for local FaceInfo objects.
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.
face_info_iterator	ownedFaceInfoBegin ()
	Iterators to owned faceInfo objects.
face_info_iterator	ownedFaceInfoEnd ()
elem_info_iterator	ownedElemInfoBegin ()
	Iterators to owned faceInfo objects.
elem_info_iterator	ownedElemInfoEnd ()
const ElemInfo &	elemInfo (const dof_id_type id) const
	Accessor for the elemInfo object for a given element ID.
const std::vector< const ElemInfo * > &	elemInfoVector () const
	Accessor for the element info objects owned by this process.
const std::vector< FaceInfo > &	allFaceInfo () const
	Accessor for all FaceInfo objects.

Static Public Member Functions
static InputParameters	validParams ()
static MooseEnum	partitioning ()
	returns MooseMesh partitioning options so other classes can use it
static MooseEnum	elemTypes ()
	returns MooseMesh element type options
static void	setSubdomainName (MeshBase &mesh, SubdomainID subdomain_id, const SubdomainName &name, const bool synchronous=false)
	This method sets the name for subdomain_id on the provided mesh to name.
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.
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.
static void	callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
	External method for calling moose error with added object context.

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

Static Public Attributes
static const std::array< bool, 3 >	periodic_dim_default {false, false, false}
	Default value for the automatically detected paired boundaries for each unit dimension, in which the value for each unit dimension is false (not detected).
static const std::string	type_param = "_type"
	The name of the parameter that contains the object type.
static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name.
static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name.
static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp.
static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base.
static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor.

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	buildMesh2D (const std::string &filename)
	buildMesh() calls this helper function to build 2D ImageMeshes.
void	buildMesh3D (const std::vector< std::string > &filenames)
	buildMesh() calls this helper function to build 3D ImageMeshes from stacks of images.
void	GetPixelInfo (std::string filename, int &xpixels, int &ypixels)
	Process a single image with the 'file' command to find out the number of pixels in the x and y directions.
bool	allowRecovery () const
	Returns whether this mesh is allowed to read a recovery file.
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.
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.
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.
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.
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.
template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it.
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".
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".
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.
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.
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.
std::string	timedSectionName (const std::string &section_name) const
void	errorCheck ()

Protected Attributes
const bool	_scale_to_one
	If true, forces the maximum width (height) of the mesh to be 1.0 while retaining the original aspect ratio of the image.
const Real &	_cells_per_pixel
	A number <= 1.0 which determines the number of cells in the mesh per pixel in each direction.
MooseEnum	_dim
	The dimension of the mesh.
unsigned int	_nx
	Number of elements in x, y, z direction.
unsigned int	_ny
unsigned int	_nz
Real	_xmin
	The min/max values for x,y,z component.
Real	_xmax
Real	_ymin
Real	_ymax
Real	_zmin
Real	_zmax
bool	_gauss_lobatto_grid
	All of the libmesh build_line/square/cube routines support an option to grade the mesh into the boundaries according to the spacing of the Gauss-Lobatto quadrature points.
Real	_bias_x
	The amount by which to bias the cells in the x,y,z directions.
Real	_bias_y
Real	_bias_z
bool	_dims_may_have_changed
	Boolean to indicate that dimensions may have changed.
std::vector< std::unique_ptr< libMesh::GhostingFunctor > >	_ghosting_functors
	Deprecated (DO NOT USE)
std::vector< std::shared_ptr< RelationshipManager > >	_relationship_managers
	The list of active geometric relationship managers (bound to the underlying MeshBase object).
bool	_built_from_other_mesh = false
	Whether or not this mesh was built from another mesh.
ParallelType	_parallel_type
	Can be set to DISTRIBUTED, REPLICATED, or DEFAULT.
bool	_use_distributed_mesh
	False by default.
bool	_distribution_overridden
bool	_parallel_type_overridden
std::unique_ptr< libMesh::MeshBase >	_mesh
	Pointer to underlying libMesh mesh object.
std::unique_ptr< Moose::Kokkos::Mesh >	_kokkos_mesh
	Pointer to Kokkos mesh object.
MooseEnum	_partitioner_name
	The partitioner used on this mesh.
bool	_partitioner_overridden
std::unique_ptr< libMesh::Partitioner >	_custom_partitioner
	The custom partitioner.
bool	_custom_partitioner_requested
unsigned int	_uniform_refine_level
	The level of uniform refinement requested (set to zero if AMR is disabled)
bool	_skip_refine_when_use_split
	Whether or not to skip uniform refinements when using a pre-split mesh.
bool	_skip_deletion_repartition_after_refine
	Whether or not skip remote deletion and repartition after uniform refinements.
bool	_is_changed
	true if mesh is changed (i.e. after adaptivity step)
bool	_is_nemesis
	True if a Nemesis Mesh was read in.
bool	_moose_mesh_prepared = false
	True if prepare has been called on the mesh.
std::unique_ptr< ConstElemPointerRange >	_refined_elements
	The elements that were just refined.
std::unique_ptr< ConstElemPointerRange >	_coarsened_elements
	The elements that were just coarsened.
std::map< const Elem *, std::vector< const Elem * > >	_coarsened_element_children
	Map of Parent elements to child elements for elements that were just coarsened.
std::set< Node * >	_semilocal_node_list
	Used for generating the semilocal node range.
std::unique_ptr< SemiLocalNodeRange >	_active_semilocal_node_range
	Ranges for use with threading, cached so they don't have to get rebuilt all the time (which takes time).
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::unordered_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.
bool	_node_to_elem_map_built = false
	Whether _node_to_elem_map has been built.
std::set< SubdomainID >	_mesh_subdomains
	A set of subdomain IDs currently present in the mesh.
std::unique_ptr< std::map< BoundaryID, RealVectorValue > >	_boundary_to_normal_map
	The boundary to normal map - valid only when AddAllSideSetsByNormals is active.
std::vector< BndNode * >	_bnd_nodes
	array of boundary nodes
std::map< boundary_id_type, std::set< dof_id_type > >	_bnd_node_ids
	Map of sets of node IDs in each boundary.
std::vector< BndElement * >	_bnd_elems
	array of boundary elems
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.
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)
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]
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.
unsigned int	_ghosting_patch_size
	The number of nearest neighbors to consider for ghosting purposes when iteration patch update strategy is used.
unsigned int	_max_leaf_size
Moose::PatchUpdateType	_patch_update_strategy
	The patch update strategy.
std::vector< Node * >	_node_map
	Vector of all the Nodes in the mesh for determining when to add a new point.
bool	_regular_orthogonal_mesh
	Boolean indicating whether this mesh was detected to be regular and orthogonal.
std::vector< std::vector< Real > >	_bounds
	The bounds in each dimension of the mesh for regular orthogonal meshes.
std::optional< std::vector< std::pair< BoundaryID, BoundaryID > > >	_paired_boundary
	A vector holding the paired boundaries for a regular orthogonal mesh.
const bool	_is_split
	Whether or not we are using a (pre-)split mesh (automatically DistributedMesh)
const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.
MooseApp &	_app
	The MOOSE application this is associated with.
Factory &	_factory
	The Factory associated with the MooseApp.
ActionFactory &	_action_factory
	Builds Actions.
const std::string &	_type
	The type of this class.
const std::string &	_name
	The name of this class.
const InputParameters &	_pars
	The object's parameters.
const Parallel::Communicator &	_communicator
MooseApp &	_restartable_app
	Reference to the application.
const std::string	_restartable_system_name
	The system name this object is in.
const THREAD_ID	_restartable_tid
	The thread ID for this object.
const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData)
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.
const std::string	_prefix
	A prefix to use for all sections.
int	_status
std::string	_file_suffix
std::vector< std::string >	_filenames
std::set< BoundaryID >	_mesh_boundary_ids
	A set of boundary IDs currently present in the mesh.
std::set< BoundaryID >	_mesh_sideset_ids
std::set< BoundaryID >	_mesh_nodeset_ids

Private Member Functions
std::unordered_map< dof_id_type, std::vector< dof_id_type > > &	internalNodeToElemMap ()
	If not already created, creates a map from every node to all elements to which they are connected.
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.
void	buildCoarseningMap (const Elem &elem, libMesh::QBase &qrule, libMesh::QBase &qrule_face, int input_side)
	Build the coarsening map for a given element type.
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".
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.
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.
void	checkDuplicateSubdomainNames ()
	Loop through all subdomain IDs and check if there is name duplication used for the subdomains with same ID.
void	computeMaxPerElemAndSide ()
	Compute the maximum numbers per element and side.
void	buildElemIDInfo ()
	Build extra data for faster access to the information of extra element integers.
void	buildLowerDMesh ()
	Build lower-d mesh for all sides.
RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
	Helper function for actually registering the restartable data.
void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	Helper function for actually registering the restartable data.
template<typename T , typename... Args>
RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const
	Helper function for declaring restartable data.

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)
	Internal method for getting a hit node (if available) given a set of parameters.
static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)
	Internal method for getting the message prefix for an object (object type, name, etc).

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.
std::vector< const ElemInfo * >	_elem_info
	Holds only those ElemInfo objects that have processor_id equal to this process's id, e.g.
std::vector< FaceInfo >	_all_face_info
	FaceInfo object storing information for face based loops.
std::vector< const FaceInfo * >	_face_info
	Holds only those FaceInfo objects that have processor_id equal to this process's id, e.g.
std::unordered_map< std::pair< const Elem *, unsigned int >, FaceInfo * >	_elem_side_to_face_info
	Map from elem-side pair to FaceInfo.
bool	_finite_volume_info_dirty = true
bool	_linear_finite_volume_dofs_cached = false
std::map< std::pair< unsigned int, unsigned int >, std::array< bool, 3 > >	_periodic_dim
	A map from (system number, vector number) to which dimensions are periodic in a regular orthogonal mesh.
RealVectorValue	_half_range
	A convenience vector used to hold values in each dimension representing half of the range.
std::vector< Node * >	_extreme_nodes
	A vector containing the nodes at the corners of a regular orthogonal mesh.
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:
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).
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:
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.
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.
std::set< SubdomainID >	_lower_d_interior_blocks
	Mesh blocks for interior lower-d elements in different types.
std::set< SubdomainID >	_lower_d_boundary_blocks
	Mesh blocks for boundary lower-d elements in different types.
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.
std::unordered_map< const Elem *, unsigned short int >	_lower_d_elem_to_higher_d_elem_side
bool	_allow_recovery
	Whether or not this Mesh is allowed to read a recovery file.
bool	_construct_node_list_from_side_list
	Whether or not to allow generation of nodesets from sidesets.
bool	_displace_node_list_by_side_list
	Whether or not to displace unrelated nodesets by nodesets constructed from sidesets.
bool	_need_delete
	Whether we need to delete remote elements after init'ing the EquationSystems.
bool	_allow_remote_element_removal
	Whether to allow removal of remote elements.
std::set< Elem * >	_ghost_elems_from_ghost_boundaries
	Set of elements ghosted by ghostGhostedBoundaries.
bool	_need_ghost_ghosted_boundaries
	A parallel mesh generator such as DistributedRectilinearMeshGenerator already make everything ready.
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.
std::vector< dof_id_type >	_max_ids
	Maximum integer ID for each extra element integer.
std::vector< dof_id_type >	_min_ids
	Minimum integer ID for each extra element integer.
std::vector< std::vector< bool > >	_id_identical_flag
	Flags to indicate whether or not any two extra element integers are the same.
unsigned int	_max_sides_per_elem
	The maximum number of sides per element.
unsigned int	_max_nodes_per_elem
	The maximum number of nodes per element.
unsigned int	_max_nodes_per_side
	The maximum number of nodes per side.
bool	_is_displaced
	Whether this mesh is displaced.
std::map< SubdomainID, Moose::CoordinateSystemType > &	_coord_sys
	Type of coordinate system per subdomain.
unsigned int	_rz_coord_axis
	Storage for RZ axis selection.
std::unordered_map< SubdomainID, std::pair< Point, RealVectorValue > >	_subdomain_id_to_rz_coord_axis
	Map of subdomain ID to general axisymmetric axis.
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.
bool	_coord_system_set
	Whether the coordinate system has been set.
std::vector< SubdomainName >	_provided_coord_blocks
	Set for holding user-provided coordinate system type block names.
bool	_doing_p_refinement
	Whether we have p-refinement (whether exclusively p- or hp-refinement)
unsigned int	_max_p_level
	Maximum p-refinement level of all elements.
unsigned int	_max_h_level
	Maximum h-refinement level of all elements.
const ParallelParamObject &	_parent
const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.
const FEProblemBase *	_si_problem
	A pointer to FEProblem base.
const RestartableDataMapName	_metaname
	Restartable metadata name.
std::string	_restartable_name
	The name of the object.

Detailed Description

A 2D GeneratedMesh where xmin, xmax, etc.

are determined from an input image file.

Definition at line 18 of file ImageMesh.h.

Member Typedef Documentation

bnd_elem_iterator_imp

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

protectedinherited

Definition at line 1705 of file MooseMesh.h.

bnd_node_iterator_imp

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

protectedinherited

Definition at line 1698 of file MooseMesh.h.

const_bnd_elem_iterator_imp

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

protectedinherited

Definition at line 1706 of file MooseMesh.h.

const_bnd_node_iterator_imp

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

protectedinherited

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

inherited

Helper type for building periodic node maps.

Definition at line 1214 of file MooseMesh.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

protectedinherited

Convenience enums.

Enumerator
X
Y
Z

Definition at line 1612 of file MooseMesh.h.

  {
    X = 0,
    Y,
    Z
  };

anonymous enum

anonymous enum

protectedinherited

Enumerator
MIN
MAX

Definition at line 1618 of file MooseMesh.h.

  {
    MIN = 0,
    MAX
  };

ParallelType

enum class MooseMesh::ParallelType

stronginherited

Enumerator
DEFAULT
REPLICATED
DISTRIBUTED

Definition at line 117 of file MooseMesh.h.

  {
    DEFAULT,
    REPLICATED,
    DISTRIBUTED
  };

Constructor & Destructor Documentation

ImageMesh() [1/2]

ImageMesh::ImageMesh

(

const InputParameters &

parameters

)

Definition at line 43 of file ImageMesh.C.

  : GeneratedMesh(parameters),
    FileRangeBuilder(parameters),
    _scale_to_one(getParam<bool>("scale_to_one")),
    _cells_per_pixel(getParam<Real>("cells_per_pixel"))
{
  // Failure is not an option
  errorCheck();
}

ImageMesh() [2/2]

ImageMesh::ImageMesh

(

const ImageMesh &

other_mesh

)

Definition at line 53 of file ImageMesh.C.

  : GeneratedMesh(other_mesh),
    FileRangeBuilder(other_mesh.parameters()),
    _scale_to_one(getParam<bool>("scale_to_one")),
    _cells_per_pixel(getParam<Real>("cells_per_pixel"))
{
}

Member Function Documentation

activeLocalElementsBegin() [1/2]

MeshBase::element_iterator MooseMesh::activeLocalElementsBegin ( )

inherited

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

Definition at line 3160 of file MooseMesh.C.

{
  return getMesh().active_local_elements_begin();
}

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

activeLocalElementsBegin() [2/2]

MeshBase::const_element_iterator MooseMesh::activeLocalElementsBegin ( ) const

inherited

Definition at line 3172 of file MooseMesh.C.

{
  return getMesh().active_local_elements_begin();
}

activeLocalElementsEnd() [1/2]

const MeshBase::element_iterator MooseMesh::activeLocalElementsEnd ( )

inherited

Definition at line 3166 of file MooseMesh.C.

{
  return getMesh().active_local_elements_end();
}

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

activeLocalElementsEnd() [2/2]

const MeshBase::const_element_iterator MooseMesh::activeLocalElementsEnd ( ) const

inherited

Definition at line 3178 of file MooseMesh.C.

{
  return getMesh().active_local_elements_end();
}

addGhostedBoundary()

void MooseMesh::addGhostedBoundary ( BoundaryID  boundary_id )

inherited

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

Definition at line 3338 of file MooseMesh.C.

{
  _ghosted_boundaries.insert(boundary_id);
}

Referenced by FEProblemBase::addGhostedBoundary().

addPeriodicVariable()

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

inherited

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

Definition at line 2203 of file MooseMesh.C.

{
  if (!_regular_orthogonal_mesh)
    return;
 
  const auto key = std::make_pair(sys_num, var_num);
  auto & entry = _periodic_dim.try_emplace(key, periodic_dim_default).first->second;
 
  _half_range = Point(dimensionWidth(0) / 2.0, dimensionWidth(1) / 2.0, dimensionWidth(2) / 2.0);
 
  bool component_found = false;
  for (const auto component : make_range(dimension()))
  {
    const std::pair<BoundaryID, BoundaryID> * boundary_ids = getPairedBoundaryMapping(component);
 
    if (boundary_ids && ((boundary_ids->first == primary && boundary_ids->second == secondary) ||
                         (boundary_ids->first == secondary && boundary_ids->second == primary)))
    {
      entry[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.");
}

Referenced by AddPeriodicBCAction::onSetupPeriodicBoundary().

addQuadratureNode()

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

inherited

Adds a fictitious "QuadratureNode".

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

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

Parameters

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

Definition at line 1603 of file MooseMesh.C.

{
  Node * qnode;
 
  if (_elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side].find(qp) ==
      _elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side].end())
  {
    // Create a new node id starting from the max node id and counting down.  This will be the least
    // likely to collide with an existing node id.
    // Note that we are using numeric_limits<unsigned>::max even
    // though max_id is stored as a dof_id_type.  I tried this with
    // numeric_limits<dof_id_type>::max and it broke several tests in
    // MOOSE.  So, this is some kind of a magic number that we will
    // just continue to use...
    dof_id_type max_id = std::numeric_limits<unsigned int>::max() - 100;
    dof_id_type new_id = max_id - _quadrature_nodes.size();
 
    if (new_id <= getMesh().max_node_id())
      mooseError("Quadrature node id collides with existing node id!");
 
    qnode = new Node(point, new_id);
 
    // Keep track of this new node in two different ways for easy lookup
    _quadrature_nodes[new_id] = qnode;
    _elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side][qp] = qnode;
 
    if (elem->active())
      internalNodeToElemMap()[new_id].push_back(elem->id());
  }
  else
    qnode = _elem_to_side_to_qp_to_quadrature_nodes[elem->id()][side][qp];
 
  BndNode * bnode = new BndNode(qnode, bid);
  _bnd_nodes.push_back(bnode);
  _bnd_node_ids[bid].insert(qnode->id());
 
  _extra_bnd_nodes.push_back(*bnode);
 
  // Do this so the range will be regenerated next time it is accessed
  _bnd_node_range.reset();
 
  return qnode;
}

Referenced by GeometricSearchData::generateQuadratureNodes().

addUniqueNode()

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

inherited

Add a new node to the mesh.

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

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

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

inlineinherited

Accessor for all FaceInfo objects.

Definition at line 2353 of file MooseMesh.h.

{
  return _all_face_info;
}

allowRecovery() [1/2]

bool MooseMesh::allowRecovery ( ) const

inlineprotectedinherited

Returns whether this mesh is allowed to read a recovery file.

Definition at line 1573 of file MooseMesh.h.

{ return _allow_recovery; }

Referenced by MFEMMesh::init().

allowRecovery() [2/2]

void MooseMesh::allowRecovery ( bool  allow )

inlineinherited

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

Definition at line 1171 of file MooseMesh.h.

{ _allow_recovery = allow; }

Referenced by SampledOutput::cloneMesh().

allowRemoteElementRemoval() [1/2]

bool MooseMesh::allowRemoteElementRemoval ( ) const

inlineinherited

Whether we are allow remote element removal.

Definition at line 1234 of file MooseMesh.h.

{ return _allow_remote_element_removal; }

Referenced by MooseMesh::MooseMesh().

allowRemoteElementRemoval() [2/2]

void MooseMesh::allowRemoteElementRemoval ( bool  allow_removal )

inherited

Set whether to allow remote element removal.

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

Referenced by MooseApp::attachRelationshipManagers(), and XYTriangleBoundaryLayerGenerator::generate().

areElemIDsIdentical()

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

inlineinherited

Whether or not two extra element integers are identical.

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

virtualinherited

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

Definition at line 1554 of file MooseMesh.C.

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

Referenced by MooseMesh::getBoundaryElementRange().

bndElemsEnd()

MooseMesh::bnd_elem_iterator MooseMesh::bndElemsEnd ( )

virtualinherited

Definition at line 1562 of file MooseMesh.C.

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

Referenced by MooseMesh::getBoundaryElementRange().

bndNodesBegin()

MooseMesh::bnd_node_iterator MooseMesh::bndNodesBegin ( )

virtualinherited

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

Definition at line 1538 of file MooseMesh.C.

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

Referenced by MooseMesh::getBoundaryNodeRange().

bndNodesEnd()

MooseMesh::bnd_node_iterator MooseMesh::bndNodesEnd ( )

virtualinherited

Definition at line 1546 of file MooseMesh.C.

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

Referenced by MooseMesh::getBoundaryNodeRange().

boundaryLowerDBlocks()

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

inlineinherited

Returns

The set of lower-dimensional blocks for boundary sides

Definition at line 1554 of file MooseMesh.h.

{ return _lower_d_boundary_blocks; }

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

buildActiveSideList()

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

inherited

Calls BoundaryInfo::build_active_side_list.

Returns

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

Definition at line 3124 of file MooseMesh.C.

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

Referenced by MooseMesh::buildFiniteVolumeInfo().

buildBndElemList()

void MooseMesh::buildBndElemList ( )

inherited

Definition at line 1187 of file MooseMesh.C.

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

Referenced by MooseMesh::update().

buildCoarseningMap()

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

privateinherited

Build the coarsening map for a given element type.

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

Parameters

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

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

Definition at line 2610 of file MooseMesh.C.

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

Referenced by MooseMesh::buildHRefinementAndCoarseningMaps().

buildElemIDInfo()

void MooseMesh::buildElemIDInfo ( )

privateinherited

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

Definition at line 1091 of file MooseMesh.C.

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

Referenced by MooseMesh::update().

buildFiniteVolumeInfo()

void MooseMesh::buildFiniteVolumeInfo ( ) const

inherited

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

{
  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.
  _elem_to_elem_info.reserve(nActiveLocalElem());
  unsigned int num_sides = 0;
  for (const Elem * elem : as_range(begin, end))
  {
    _elem_to_elem_info.emplace(elem->id(), elem);
    num_sides += elem->n_sides();
  }
 
  // Used to speed up FaceInfo creation:
  // - element side builder that caches per type of element
  libMesh::ElemSideBuilder side_builder;
 
  _all_face_info.reserve(num_sides / 2);
  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
        mooseAssert(elem->default_order() < 4, "Did not expect such high element orders in FV");
        _all_face_info.emplace_back(
            &_elem_to_elem_info[elem->id()], side, face_index++, side_builder);
 
        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
  _elem_side_to_face_info.reserve(_all_face_info.size());
  // heuristic to avoid resizing too much
  _face_info.reserve(_all_face_info.size());
  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);
  }
 
  _elem_info.reserve(nActiveLocalElem());
  for (auto & ei : _elem_to_elem_info)
    if (ei.second.elem()->processor_id() == this->processor_id())
      _elem_info.push_back(&ei.second);
}

Referenced by MooseMesh::setupFiniteVolumeMeshData().

buildHRefinementAndCoarseningMaps()

void MooseMesh::buildHRefinementAndCoarseningMaps ( Assembly *  assembly )

privateinherited

Definition at line 2370 of file MooseMesh.C.

{
  std::map<ElemType, Elem *> canonical_elems;
 
  // First, loop over all elements and find a canonical element for each type
  // Doing it this way guarantees that this is going to work in parallel
  for (const auto & elem : getMesh().element_ptr_range()) // TODO: Thread this
  {
    ElemType type = elem->type();
 
    if (canonical_elems.find(type) ==
        canonical_elems.end()) // If we haven't seen this type of elem before save it
      canonical_elems[type] = elem;
    else
    {
      Elem * stored = canonical_elems[type];
      if (elem->id() < stored->id()) // Arbitrarily keep the one with a lower id
        canonical_elems[type] = elem;
    }
  }
  // Now build the maps using these templates
  // Note: This MUST be done NOT threaded!
  for (const auto & can_it : canonical_elems)
  {
    Elem * elem = can_it.second;
 
    // Need to do this just once to get the right qrules put in place
    assembly->setCurrentSubdomainID(elem->subdomain_id());
    assembly->reinit(elem);
    assembly->reinit(elem, 0);
    auto && qrule = assembly->writeableQRule();
    auto && qrule_face = assembly->writeableQRuleFace();
 
    // Volume to volume projection for refinement
    buildRefinementMap(*elem, *qrule, *qrule_face, -1, -1, -1);
 
    // Volume to volume projection for coarsening
    buildCoarseningMap(*elem, *qrule, *qrule_face, -1);
 
    // Map the sides of children
    for (unsigned int side = 0; side < elem->n_sides(); side++)
    {
      // Side to side for sides that match parent's sides
      buildRefinementMap(*elem, *qrule, *qrule_face, side, -1, side);
      buildCoarseningMap(*elem, *qrule, *qrule_face, side);
    }
 
    // Child side to parent volume mapping for "internal" child sides
    for (unsigned int child = 0; child < elem->n_children(); ++child)
      for (unsigned int side = 0; side < elem->n_sides();
           ++side)                                // Assume children have the same number of sides!
        if (!elem->is_child_on_side(child, side)) // Otherwise we already computed that map
          buildRefinementMap(*elem, *qrule, *qrule_face, -1, child, side);
  }
}

Referenced by MooseMesh::buildRefinementAndCoarseningMaps().

buildLowerDMesh()

void MooseMesh::buildLowerDMesh ( )

privateinherited

Build lower-d mesh for all sides.

Definition at line 666 of file MooseMesh.C.

{
  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.set_subdomain_name(
        id, "INTERNAL_SIDE_LOWERD_SUBDOMAIN_" + Utility::enum_to_string(type), true);
    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.set_subdomain_name(
        id, "BOUNDARY_SIDE_LOWERD_SUBDOMAIN_" + Utility::enum_to_string(type), true);
    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);
}

Referenced by MooseMesh::init().

buildMesh()

void ImageMesh::buildMesh ( )

overridevirtual

Must be overridden by child classes.

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

Reimplemented from GeneratedMesh.

Definition at line 68 of file ImageMesh.C.

{
  // A list of filenames of length 1 means we are building a 2D mesh
  if (_filenames.size() == 1)
    buildMesh2D(_filenames[0]);
 
  else
    buildMesh3D(_filenames);
}

buildMesh2D()

void ImageMesh::buildMesh2D ( const std::string &  filename )

protected

buildMesh() calls this helper function to build 2D ImageMeshes.

Definition at line 149 of file ImageMesh.C.

{
  int xpixels = 0, ypixels = 0;
 
  // Extract the number of pixels from the image using the file command
  GetPixelInfo(filename, xpixels, ypixels);
 
  // Set the maximum dimension to 1.0 while scaling the other
  // direction to maintain the aspect ratio.
  _xmax = xpixels;
  _ymax = ypixels;
 
  if (_scale_to_one)
  {
    Real max = std::max(_xmax, _ymax);
    _xmax /= max;
    _ymax /= max;
  }
 
  // Compute the number of cells in the x and y direction based on
  // the user's cells_per_pixel parameter.  Note: we use ints here
  // because the GeneratedMesh params object uses ints for these...
  _nx = static_cast<int>(_cells_per_pixel * xpixels);
  _ny = static_cast<int>(_cells_per_pixel * ypixels);
 
  // Actually build the Mesh
  MeshTools::Generation::build_square(dynamic_cast<UnstructuredMesh &>(getMesh()),
                                      _nx,
                                      _ny,
                                      /*xmin=*/0.,
                                      /*xmax=*/_xmax,
                                      /*ymin=*/0.,
                                      /*ymax=*/_ymax,
                                      QUAD4);
}

Referenced by buildMesh().

buildMesh3D()

void ImageMesh::buildMesh3D ( const std::vector< std::string > &  filenames )

protected

buildMesh() calls this helper function to build 3D ImageMeshes from stacks of images.

Definition at line 79 of file ImageMesh.C.

{
  // If the user gave us a "stack" with 0 or 1 files in it, we can't
  // really create a 3D Mesh from that
  if (filenames.size() <= 1)
    mooseError("ImageMesh error: Cannot create a 3D ImageMesh from an image stack with ",
               filenames.size(),
               " images.");
 
  // For each file in the stack, process it using the 'file' command.
  // We want to be sure that all the images in the stack are the same
  // size, for example...
  int xpixels = 0, ypixels = 0, zpixels = filenames.size();
 
  // Take pixel info from the first image in the stack to determine the aspect ratio
  GetPixelInfo(filenames[0], xpixels, ypixels);
 
  // TODO: Check that all images are the same aspect ratio and have
  // the same number of pixels?  ImageFunction does not currently do
  // this...
  // for (const auto & filename : filenames)
  // {
  //   // Extract the number of pixels from the image using the file command
  //   GetPixelInfo(filename, xpixels, ypixels);
  //
  //   // Moose::out << "Image " << filename << " has size: " << xpixels << " by " << ypixels <<
  //   std::endl;
  // }
 
  // Use the number of x and y pixels and the number of images to
  // determine the the x, y, and z dimensions of the mesh.  We assume
  // that there is 1 pixel in the z-direction for each image in the
  // stack.
 
  // Set the maximum dimension to 1.0 while scaling the other
  // directions to maintain the aspect ratio.
  _xmax = xpixels;
  _ymax = ypixels;
  _zmax = zpixels;
 
  if (_scale_to_one)
  {
    Real max = std::max(std::max(_xmax, _ymax), _zmax);
    _xmax /= max;
    _ymax /= max;
    _zmax /= max;
  }
 
  // Compute the number of cells in the x and y direction based on
  // the user's cells_per_pixel parameter.  Note: we use ints here
  // because the GeneratedMesh params object uses ints for these...
  _nx = static_cast<int>(_cells_per_pixel * xpixels);
  _ny = static_cast<int>(_cells_per_pixel * ypixels);
  _nz = static_cast<int>(_cells_per_pixel * zpixels);
 
  // Actually build the Mesh
  MeshTools::Generation::build_cube(dynamic_cast<UnstructuredMesh &>(getMesh()),
                                    _nx,
                                    _ny,
                                    _nz,
                                    /*xmin=*/0.,
                                    /*xmax=*/_xmax,
                                    /*ymin=*/0.,
                                    /*ymax=*/_ymax,
                                    /*zmin=*/0.,
                                    /*zmax=*/_zmax,
                                    HEX8);
}

Referenced by buildMesh().

buildMeshBaseObject()

std::unique_ptr< MeshBase > MooseMesh::buildMeshBaseObject ( unsigned int  dim = libMesh::invalid_uint )

inherited

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

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

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

buildNodeList()

void MooseMesh::buildNodeList ( )

inherited

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

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

Definition at line 1034 of file MooseMesh.C.

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

Referenced by MooseMesh::update().

buildNodeListFromSideList()

void MooseMesh::buildNodeListFromSideList ( )

inherited

Calls BoundaryInfo::build_node_list_from_side_list().

Definition at line 3057 of file MooseMesh.C.

{
  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));
 
      // We need all processors to agree on the id to use, even when
      // each only sees the bcids on their own portions of a
      // distributed mesh.
      _communicator.max(next_bcid);
 
      // If we've got an unreasonably high 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));
        }
    }
 
    // For any side bcid that has a name, make sure that our new node
    // bcid is given the same name.  We need to iterate over the
    // actual name map (which is global) here, not over side_bcids
    // (which only includes local ids on a distributed mesh).
    for (auto & [id, name] : boundary_info.get_sideset_name_map())
      boundary_info.nodeset_name(id) = name;
 
    boundary_info.build_node_list_from_side_list();
  }
}

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

buildPeriodicNodeMap()

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

inherited

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

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

inherited

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

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

inherited

Definition at line 2427 of file MooseMesh.C.

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

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

buildRefinementAndCoarseningMaps()

void MooseMesh::buildRefinementAndCoarseningMaps ( Assembly *  assembly )

inherited

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

Parameters

assembly

Pointer to the Assembly object for this Mesh.

Definition at line 2521 of file MooseMesh.C.

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

privateinherited

Build the refinement map for a given element type.

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

Parameters

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

Definition at line 2531 of file MooseMesh.C.

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

Referenced by MooseMesh::buildHRefinementAndCoarseningMaps().

buildSideList()

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

inherited

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

Definition at line 3118 of file MooseMesh.C.

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

Referenced by InterfaceQpUserObjectBase::initialSetup().

buildTypedMesh()

template<typename T >

std::unique_ptr< T > MooseMesh::buildTypedMesh ( unsigned int  dim = libMesh::invalid_uint )

inherited

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

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

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

cacheChangedLists()

void MooseMesh::cacheChangedLists ( )

inherited

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

Definition at line 922 of file MooseMesh.C.

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

Referenced by FEProblemBase::meshChanged().

cacheFaceInfoVariableOwnership()

void MooseMesh::cacheFaceInfoVariableOwnership ( ) const

inherited

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

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

Referenced by MooseMesh::setupFiniteVolumeMeshData().

cacheFVElementalDoFs()

void MooseMesh::cacheFVElementalDoFs ( ) const

inherited

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

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

Referenced by MooseMesh::setupFiniteVolumeMeshData().

cacheInfo()

void MooseMesh::cacheInfo ( )

protectedinherited

Definition at line 1404 of file MooseMesh.C.

{
  TIME_SECTION("cacheInfo", 3);
 
  _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();
 
  const auto & mesh = getMesh();
 
  // Cache higher and lowerD element information
  for (const auto & elem : mesh.element_ptr_range())
  {
    const Elem * ip_elem = elem->interior_parent();
 
    if (ip_elem)
    {
      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)
    {
      const 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);
 
  // Cache the boundaries next to each subdomain
  for (const auto & elem : mesh.active_local_element_ptr_range())
  {
    SubdomainID subdomain_id = elem->subdomain_id();
    auto & sub_data = _sub_to_data[subdomain_id];
    const auto elem_boundary_ids = getBoundaryIDs(elem);
    for (unsigned int side = 0; side < elem->n_sides(); side++)
    {
      const auto & boundary_ids = elem_boundary_ids[side];
      sub_data.boundary_ids.insert(boundary_ids.begin(), boundary_ids.end());
 
      const 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.set_union(_neighbor_subdomain_boundary_ids[blk_id]);
  }
}

Referenced by MooseMesh::update().

callMooseError() [1/2]

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

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
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 114 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, show_trace);
}

callMooseError() [2/2]

void MooseBase::callMooseError ( std::string  msg, const bool  with_prefix, const hit::Node *  node = nullptr, const bool  show_trace = true  ) 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
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

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

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

changeBoundaryId() [1/2]

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

inherited

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

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

Definition at line 2821 of file MooseMesh.C.

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

Referenced by MooseMesh::changeBoundaryId().

changeBoundaryId() [2/2]

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

staticinherited

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

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

Definition at line 2830 of file MooseMesh.C.

{
  // Get a reference to our BoundaryInfo object, we will use it several times below...
  BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
  // Container to catch ids passed back from BoundaryInfo
  std::vector<boundary_id_type> old_ids;
 
  // Only level-0 elements store BCs.  Loop over them.
  for (auto & elem : as_range(mesh.level_elements_begin(0), mesh.level_elements_end(0)))
  {
    unsigned int n_sides = elem->n_sides();
    for (unsigned int s = 0; s != n_sides; ++s)
    {
      boundary_info.boundary_ids(elem, s, old_ids);
      if (std::find(old_ids.begin(), old_ids.end(), old_id) != old_ids.end())
      {
        std::vector<boundary_id_type> new_ids(old_ids);
        std::replace(new_ids.begin(), new_ids.end(), old_id, new_id);
        if (delete_prev)
        {
          boundary_info.remove_side(elem, s);
          boundary_info.add_side(elem, s, new_ids);
        }
        else
          boundary_info.add_side(elem, s, new_ids);
      }
    }
  }
 
  // Remove any remaining references to the old ID from the
  // BoundaryInfo object.  This prevents things like empty sidesets
  // from showing up when printing information, etc.
  if (delete_prev)
    boundary_info.remove_id(old_id);
 
  // The cached boundary id sets will need re-preparation
  mesh.unset_has_boundary_id_sets();
}

checkCoordinateSystems()

void MooseMesh::checkCoordinateSystems ( )

inherited

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

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

Referenced by FEProblemBase::checkCoordinateSystems().

checkDuplicateSubdomainNames()

void MooseMesh::checkDuplicateSubdomainNames ( )

privateinherited

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

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

Referenced by MooseMesh::prepare().

clearQuadratureNodes()

void MooseMesh::clearQuadratureNodes ( )

inherited

Clear out any existing quadrature nodes.

Most likely called before re-adding them.

Definition at line 1670 of file MooseMesh.C.

{
  // Delete all the quadrature nodes
  for (auto & it : _quadrature_nodes)
    delete it.second;
 
  _quadrature_nodes.clear();
  _elem_to_side_to_qp_to_quadrature_nodes.clear();
  _extra_bnd_nodes.clear();
 
  // NOTE: this does not clear them from the nodeToElem map
}

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

clone()

MooseMesh & MooseMesh::clone ( ) const

virtualinherited

Clone method.

Allocates memory you are responsible to clean up.

Definition at line 2884 of file MooseMesh.C.

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

Referenced by TiledMesh::buildMesh().

coarsenedElementChildren()

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

inherited

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

Parameters

elem	Pointer to the parent element that was coarsened to.

Returns

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

Definition at line 952 of file MooseMesh.C.

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

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

coarsenedElementRange()

ConstElemPointerRange * MooseMesh::coarsenedElementRange ( ) const

inherited

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

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

Definition at line 946 of file MooseMesh.C.

{
  return _coarsened_elements.get();
}

Referenced by FEProblemBase::meshChanged().

computeFiniteVolumeCoords()

void MooseMesh::computeFiniteVolumeCoords ( ) const

inherited

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

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

Referenced by MooseMesh::setupFiniteVolumeMeshData().

computeMaxPerElemAndSide()

void MooseMesh::computeMaxPerElemAndSide ( )

privateinherited

Compute the maximum numbers per element and side.

Definition at line 1068 of file MooseMesh.C.

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

Referenced by MooseMesh::update().

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

inlineinherited

Returns

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

Definition at line 2062 of file MooseMesh.h.

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

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

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

declareRestartableDataHelper()

template<typename T , typename... Args>

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

privateinherited

Helper function for declaring restartable data.

We use this function to reduce code duplication when returning const/nonconst references to the data.

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 310 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  // Here we will create the RestartableData even though we may not use this instance.
  // If it's already in use, the App will return a reference to the existing instance and we'll
  // return that one instead. We might refactor this to have the app create the RestartableData
  // at a later date.
  auto data_ptr =
      std::make_unique<RestartableData<T>>(full_name, context, std::forward<Args>(args)...);
  auto & restartable_data_ref = cast_ref<RestartableData<T> &>(
      registerRestartableDataOnApp(std::move(data_ptr), _restartable_tid));
 
  return restartable_data_ref;
}

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

inherited

Delete remote elements.

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

inherited

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

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

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

Definition at line 1928 of file MooseMesh.C.

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

Referenced by MooseMesh::prepare().

detectPairedSidesets()

void MooseMesh::detectPairedSidesets ( )

inherited

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

{
  TIME_SECTION("detectPairedSidesets", 5);
 
  _paired_boundary = std::vector<std::pair<BoundaryID, BoundaryID>>();
 
  // 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.
 
  // we need to test all element dimensions from dim down to 1
  const unsigned int mesh_dim = getMesh().mesh_dimension();
 
  // Helper for iterating through unit dimensions (0=x, 1=y, 2=z)
  static constexpr std::array<std::size_t, 3> unit_dims{0, 1, 2};
  // Helper for mapping from unit dim -> name
  static const std::array<std::string, 3> unit_dim_names{"x", "y", "z"};
 
  // Boundary id sets for elements of different dimensions
  // First index: side dimension; 0=1D, 1=2D, 2=3D
  // Second index: unit dimension; 0=x, 1=y, 2=z
  // Third index: false for minus, true for plus
  std::array<std::array<std::array<std::set<BoundaryID>, 2>, 3>, 3> ids{};
 
  // Build quadrature needed to evaluate side normals
  std::array<std::unique_ptr<FEBase>, 3> fe_faces{};
  std::array<std::unique_ptr<libMesh::QGauss>, 3> qfaces{};
  for (const auto side_dim : make_range(mesh_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());
    fe_faces[side_dim]->get_normals();
  }
 
  // Get boundary IDs for each dimension that are in the unit normal
  const auto & boundary_info = getMesh().get_boundary_info();
  // Temporary for evaluating boundary_ids
  std::vector<boundary_id_type> face_ids;
  // The side dimensions we've come across, so that we only report
  // warnings for side dimensions that we have
  std::set<unsigned int> side_dims;
  // Normal dimensions that we found that were nonzero; lets us
  // skip warnings for dimensions that we don't have
  std::array<bool, 3> nonzero_dims = periodic_dim_default;
  for (auto & elem : as_range(getMesh().level_elements_begin(0), getMesh().level_elements_end(0)))
  {
    // If not on the boundary, nothing to do
    if (!elem->on_boundary())
      continue;
 
    const auto side_dim = elem->dim() - 1;
    side_dims.insert(side_dim);
 
    // Check for unit normals on each boundary side
    for (const auto s : elem->side_index_range())
      if (!elem->neighbor_ptr(s))
      {
        // Reinit to get the normal
        fe_faces[side_dim]->reinit(elem, s);
        const auto & normal = fe_faces[side_dim]->get_normals()[0];
 
        // 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);
 
        bool found = false;
        for (const auto unit_dim : unit_dims)
        {
          if (libMesh::absolute_fuzzy_equals(normal(unit_dim), 0.0))
            continue;
          nonzero_dims[unit_dim] = true;
          if (!found)
            for (const auto plus : {false, true})
            {
              if (libMesh::absolute_fuzzy_equals(normal(unit_dim), plus ? 1.0 : -1.0))
              {
                ids[side_dim][unit_dim][plus].insert(face_ids.begin(), face_ids.end());
                found = true;
                break;
              }
            }
        }
      }
  }
 
  // 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())
  {
    // Communicate id data by packing as [side dim, unit dim, plus (as a char), boundary id]
    std::vector<std::tuple<unsigned int, unsigned int, unsigned char, boundary_id_type>> id_data;
    for (const auto side_dim : side_dims)
      for (const auto unit_dim : unit_dims)
        for (const auto plus : {false, true})
          for (const auto bd : ids[side_dim][unit_dim][plus])
            id_data.emplace_back(side_dim, unit_dim, plus, bd);
    _communicator.allgather(id_data, false);
    for (const auto & [side_dim, unit_dim, plus_char, bd] : id_data)
      ids[side_dim][unit_dim][bool(plus_char)].insert(bd);
 
    // Gather true-ness of nonzero_dims
    for (auto & entry : nonzero_dims)
      _communicator.max(entry);
 
    // Gather found side dimensions
    _communicator.set_union(side_dims);
  } // end if (_use_distributed_mesh && !_need_ghost_ghosted_boundaries)
 
  // Find pairings that have exactly one boundary on each side
  std::ostringstream oss_found, oss_missing;
  for (const auto side_dim : side_dims)
  {
    for (const auto unit_dim : unit_dims)
      if (nonzero_dims[unit_dim])
      {
        const auto & unit_name = unit_dim_names[unit_dim];
        const auto & minus = ids[side_dim][unit_dim][false];
        const auto & plus = ids[side_dim][unit_dim][true];
 
        if (minus.size() == 1 && plus.size() == 1)
        {
          const auto get_boundary_name = [this](const auto id)
          {
            const auto & name = getBoundaryName(id);
            return name.size() ? name : std::to_string(id);
          };
 
          oss_found << "\n  " << side_dim + 1 << "D " << unit_name
                    << "-direction: " << get_boundary_name(*minus.begin()) << " <-> "
                    << get_boundary_name(*plus.begin());
          _paired_boundary->emplace_back(std::make_pair(*minus.begin(), *plus.begin()));
        }
        else
          oss_missing << "\n  " << side_dim + 1 << "D -" << unit_name << "/+" << unit_name
                      << ": Found " << minus.size() << " -" << unit_name << " boundaries and "
                      << plus.size() << " +" << unit_name << " boundaries";
      }
  }
 
  std::ostringstream oss;
  const auto found = oss_found.str();
  const auto missing = oss_missing.str();
  if (found.size())
    oss << "The following paired boundaries were automatically detected for periodicity:\n"
        << found << "\n";
  if (missing.size())
  {
    if (found.size())
      oss << "\n";
    oss << "Paired boundaries were not automatically detected for the following:\n"
        << missing
        << "\n\nAutomatic detection requires that exactly one boundary is found in each unit "
           "direction.\n";
  }
 
  mooseInfoRepeated(oss.str());
}

Referenced by Moose::PeriodicBCHelper::setupPeriodicBoundaries().

determineUseDistributedMesh()

void MooseMesh::determineUseDistributedMesh ( )

inherited

Determine whether to use a distributed mesh.

Should be called during construction

Definition at line 2890 of file MooseMesh.C.

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

Referenced by FileMesh::FileMesh(), MooseMesh::MooseMesh(), and MooseMesh::setParallelType().

dimension()

unsigned int MooseMesh::dimension ( ) const

virtualinherited

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

Reimplemented in MFEMMesh.

Definition at line 2994 of file MooseMesh.C.

{
  return getMesh().mesh_dimension();
}

Referenced by MooseMesh::addPeriodicVariable(), NodalPatchRecoveryBase::evaluateBasisFunctions(), ElementSubdomainModifierBase::extrapolatePolynomial(), FunctionPeriodicBoundary::FunctionPeriodicBoundary(), MooseMesh::getPairedBoundaryMapping(), PointVariableSamplerBase::initialize(), BlockRestrictable::initializeBlockRestrictable(), MooseMesh::isTranslatedPeriodic(), MooseMesh::minPeriodicVector(), PenetrationLocator::PenetrationLocator(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), SidesetInfoVectorPostprocessor::SidesetInfoVectorPostprocessor(), and Moose::PetscSupport::storePetscOptions().

dimensionWidth()

Real MooseMesh::dimensionWidth ( unsigned int  component ) const

inherited

Returns the width of the requested dimension.

Definition at line 2179 of file MooseMesh.C.

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

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

doingPRefinement() [1/2]

bool MooseMesh::doingPRefinement ( ) const

inlineinherited

Query whether the kind of adaptivity we're doing includes p-refinement.

Definition at line 1507 of file MooseMesh.h.

{ return _doing_p_refinement; }

Referenced by MooseMesh::buildRefinementAndCoarseningMaps().

doingPRefinement() [2/2]

void MooseMesh::doingPRefinement ( bool  doing_p_refinement )

inlineinherited

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

Definition at line 1502 of file MooseMesh.h.

{ _doing_p_refinement = doing_p_refinement; }

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

effectiveSpatialDimension()

unsigned int MooseMesh::effectiveSpatialDimension ( ) const

virtualinherited

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

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

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

virtualinherited

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

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

Definition at line 3208 of file MooseMesh.C.

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

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

elem() [2/2]

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

virtualinherited

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

inherited

Accessor for the elemInfo object for a given element ID.

Definition at line 4000 of file MooseMesh.C.

{
  return libmesh_map_find(_elem_to_elem_info, id);
}

Referenced by MooseLinearVariableFV< OutputType >::evaluate(), MooseLinearVariableFV< OutputType >::evaluate(), MooseLinearVariableFV< OutputType >::evaluate(), MooseLinearVariableFV< OutputType >::evaluateGradient(), MooseLinearVariableFV< OutputType >::evaluateGradient(), and ComputeLinearFVLimitedGradientThread::operator()().

elemInfoVector()

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

inlineinherited

Accessor for the element info objects owned by this process.

Definition at line 1336 of file MooseMesh.h.

{ return _elem_info; }

elemPtr() [1/2]

Elem * MooseMesh::elemPtr ( const dof_id_type  i )

virtualinherited

Definition at line 3222 of file MooseMesh.C.

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

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

elemPtr() [2/2]

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

virtualinherited

Definition at line 3228 of file MooseMesh.C.

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

elemTypes()

MooseEnum MooseMesh::elemTypes ( )

staticinherited

returns MooseMesh element type options

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

Referenced by MooseMesh::elemTypes(), and SphereMeshGenerator::validParams().

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.

{ return _enabled; }

Referenced by EigenKernel::enabled(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), and NodeFaceConstraint::validParams().

errorCheck()

void FileRangeBuilder::errorCheck ( )

protectedinherited

Definition at line 159 of file FileRangeBuilder.C.

{
  switch (_status)
  {
    case 0:
      return;
    case 1:
      mooseError("Cannot provide both file and file_base parameters");
      break;
    case 2:
      mooseError("You must provide a valid value for either the 'file' parameter or the "
                 "'file_base' parameter.");
      break;
    case 3:
      mooseError(
          "If you provide a 'file_base', you must also provide a valid 'file_suffix', e.g. 'png'.");
      break;
    default:
      mooseError("Unknown error code!");
  }
}

Referenced by ImageMesh().

errorIfDistributedMesh()

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

inherited

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

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

See, for example, the NodalVariableValue class.

Definition at line 3726 of file MooseMesh.C.

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

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

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

inlineinherited

Accessor for local FaceInfo objects.

Definition at line 2347 of file MooseMesh.h.

{
  return _face_info;
}

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

faceInfo() [2/2]

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

inherited

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

Definition at line 3984 of file MooseMesh.C.

{
  auto it = _elem_side_to_face_info.find(std::make_pair(elem, side));
 
  if (it == _elem_side_to_face_info.end())
    return nullptr;
  else
  {
    mooseAssert(it->second,
                "For some reason, the FaceInfo object is NULL! Try calling "
                "`buildFiniteVolumeInfo()` before using this accessor!");
    return it->second;
  }
}

filenames()

const std::vector< std::string > & FileRangeBuilder::filenames ( )

inlineinherited

Definition at line 43 of file FileRangeBuilder.h.

{ return _filenames; }

Referenced by buildMesh3D(), ImageMeshGenerator::buildMesh3D(), MeshBaseImageSampler::setupImageSampler(), and ImageSampler::setupImageSampler().

fileSuffix()

std::string FileRangeBuilder::fileSuffix ( )

inlineinherited

Definition at line 42 of file FileRangeBuilder.h.

{ return _file_suffix; }

Referenced by MeshBaseImageSampler::setupImageSampler(), and ImageSampler::setupImageSampler().

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  )

privateinherited

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

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

There are 3 cases here:

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

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

Parameters

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

Definition at line 2680 of file MooseMesh.C.

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

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

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

protectedinherited

Definition at line 383 of file MooseMesh.C.

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

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

freeBndNodes()

void MooseMesh::freeBndNodes ( )

protectedinherited

Definition at line 364 of file MooseMesh.C.

{
  // free memory
  for (auto & bnode : _bnd_nodes)
    delete bnode;
 
  for (auto & it : _node_set_nodes)
    it.second.clear();
 
  _node_set_nodes.clear();
 
  for (auto & it : _bnd_node_ids)
    it.second.clear();
 
  _bnd_node_ids.clear();
  _bnd_node_range.reset();
}

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

getActiveLocalElementRange()

const ConstElemRange * MooseMesh::getActiveLocalElementRange ( )

inherited

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

Definition at line 1245 of file MooseMesh.C.

{
  return &getMesh().active_local_element_stored_range();
}

Referenced by AuxiliarySystem::computeElementalVarsHelper(), PointwiseRenormalizeVector::execute(), ElementSubdomainModifierBase::gatherPatchElements(), FEProblemBase::getCurrentAlgebraicElementRange(), MooseMesh::meshChanged(), DOFMapOutput::output(), SystemBase::setVariableGlobalDoFs(), FixedPointSolve::solve(), TransientMultiApp::solveStep(), ElementSubdomainModifierBase::storeOverriddenDofValues(), MooseMesh::updateActiveSemiLocalNodeRange(), Adaptivity::updateErrorVectors(), and SystemBase::zeroVariables().

getActiveNodeRange()

NodeRange * MooseMesh::getActiveNodeRange ( )

inherited

Definition at line 1251 of file MooseMesh.C.

{
  if (!_active_node_range)
  {
    TIME_SECTION("getActiveNodeRange", 5);
 
    _active_node_range =
        std::make_unique<NodeRange>(getMesh().active_nodes_begin(), getMesh().active_nodes_end());
  }
 
  return _active_node_range.get();
}

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

getActiveSemiLocalNodeRange()

SemiLocalNodeRange * MooseMesh::getActiveSemiLocalNodeRange ( ) const

inherited

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

inherited

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

Definition at line 1161 of file MooseMesh.C.

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

Referenced by MooseMesh::getElemIDMapping().

getAxisymmetricRadialCoord()

unsigned int MooseMesh::getAxisymmetricRadialCoord ( ) const

inherited

Returns the desired radial direction for RZ coordinate transformation.

Returns

The coordinate direction for the radial direction

Definition at line 4423 of file MooseMesh.C.

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

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

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.

{ return _pars.getBase(); }

Referenced by MooseBase::uniqueParameterName().

getBlockConnectedBlocks()

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

inherited

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

inherited

Returns the maximum element dimension on the given blocks.

Definition at line 3015 of file MooseMesh.C.

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

Referenced by BlockRestrictable::initializeBlockRestrictable().

getBoundariesToActiveSemiLocalElemIds()

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

inherited

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

Definition at line 1322 of file MooseMesh.C.

{
  return _bnd_elem_ids;
}

Referenced by MooseMesh::getBoundariesToElems().

getBoundariesToElems()

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

inherited

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

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

inherited

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

inherited

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

inherited

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

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

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

getBoundaryConnectedSecondaryBlocks()

std::set< SubdomainID > MooseMesh::getBoundaryConnectedSecondaryBlocks ( const BoundaryID  bid ) const

inherited

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

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

Referenced by DomainUserObject::DomainUserObject().

getBoundaryElementRange()

ConstBndElemRange * MooseMesh::getBoundaryElementRange ( )

inherited

Definition at line 1301 of file MooseMesh.C.

{
  if (!_bnd_elem_range)
  {
    TIME_SECTION("getBoundaryElementRange", 5);
 
    _bnd_elem_range = std::make_unique<ConstBndElemRange>(bndElemsBegin(), bndElemsEnd());
  }
 
  return _bnd_elem_range.get();
}

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

getBoundaryID()

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

inherited

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

{
  if (boundary_name == "ANY_BOUNDARY_ID")
    mooseError("Please use getBoundaryIDs() when passing \"ANY_BOUNDARY_ID\"");
 
  return MooseMeshUtils::getBoundaryID(boundary_name, getMesh());
}

Referenced by PatternedMesh::buildMesh(), StitchedMesh::buildMesh(), TiledMesh::buildMesh(), DMSetUp_Moose_Pre(), GeometricSearchData::getNearestNodeLocator(), GeometricSearchData::getPenetrationLocator(), GeometricSearchData::getQuadratureNearestNodeLocator(), GeometricSearchData::getQuadraturePenetrationLocator(), LinearNodalConstraint::LinearNodalConstraint(), LowerBoundNodalKernel::LowerBoundNodalKernel(), NodalScalarKernel::NodalScalarKernel(), GhostPrimaryFace::operator()(), EqualValueBoundaryConstraint::populateSecondaryNodes(), MooseMesh::prepare(), and UpperBoundNodalKernel::UpperBoundNodalKernel().

getBoundaryIDs() [1/4]

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

inherited

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

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

Definition at line 3051 of file MooseMesh.C.

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

Referenced by MooseMesh::cacheInfo().

getBoundaryIDs() [2/4]

std::vector< std::vector< BoundaryID > > MooseMesh::getBoundaryIDs ( const Elem *const  elem ) const

inherited

Returns a vector of vector of boundary IDs for the requested element on each of its sides.

Definition at line 3043 of file MooseMesh.C.

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

getBoundaryIDs() [3/4]

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

inherited

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

Definition at line 3035 of file MooseMesh.C.

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

Referenced by NonlinearSystemBase::computeNodalBCsJacobian(), DGKernelBase::DGKernelBase(), DGKernelBase::excludeBoundary(), MultiAppUserObjectTransfer::execute(), BoundaryRestrictable::hasBoundary(), BoundaryRestrictable::hasBoundary(), BoundaryRestrictable::initializeBoundaryRestrictable(), ElementSubdomainModifierBase::initialSetup(), BoundaryRestrictable::meshBoundaryIDs(), NonlinearThread::onExternalSide(), GhostBoundary::operator()(), and ActivateElementsUserObjectBase::setNewBoundayName().

getBoundaryIDs() [4/4]

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

inherited

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

Parameters

boundary_name

The names of the boundaries.

Returns

the boundary ids from the passed boundary names.

Definition at line 1715 of file MooseMesh.C.

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

getBoundaryName()

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

inherited

Return the name of the boundary given the id.

Definition at line 1788 of file MooseMesh.C.

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

Referenced by MooseMesh::addPeriodicVariable(), BoundaryLinearFVFluxIntegral::computeFaceInfoIntegral(), MooseMesh::detectPairedSidesets(), MooseMesh::getBoundaryString(), BoundaryLinearFVFluxIntegral::initialSetup(), BoundaryNodeIntegrityCheckThread::onNode(), and NonlinearThread::printBoundaryExecutionInformation().

getBoundaryNodeRange()

ConstBndNodeRange * MooseMesh::getBoundaryNodeRange ( )

inherited

Definition at line 1288 of file MooseMesh.C.

{
  if (!_bnd_node_range)
  {
    TIME_SECTION("getBoundaryNodeRange", 5);
 
    _bnd_node_range = std::make_unique<ConstBndNodeRange>(bndNodesBegin(), bndNodesEnd());
  }
 
  return _bnd_node_range.get();
}

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

getBoundaryString()

std::string MooseMesh::getBoundaryString ( const BoundaryID  boundary_id ) const

inherited

Return the name of the boundary given the id, if it exists.

Otherwise, return the id as a string.

Definition at line 1800 of file MooseMesh.C.

{
  const auto name = getBoundaryName(boundary_id);
  return name.size() ? name : std::to_string(boundary_id);
}

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

inherited

Get the coarsening map for a given element type.

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

Parameters

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

Definition at line 2638 of file MooseMesh.C.

{
  std::pair<int, ElemType> the_pair(input_side, elem.type());
 
  if (_elem_type_to_coarsening_map.find(the_pair) == _elem_type_to_coarsening_map.end())
    mooseError("Could not find a suitable qp refinement map!");
 
  return _elem_type_to_coarsening_map[the_pair];
}

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

getConstructNodeListFromSideList()

bool MooseMesh::getConstructNodeListFromSideList ( )

inlineinherited

Return construct node list from side list boolean.

Definition at line 1557 of file MooseMesh.h.

{ return _construct_node_list_from_side_list; }

Referenced by SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater().

getCoordSystem() [1/2]

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

inherited

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

xyz, rz, or r-spherical

Definition at line 4336 of file MooseMesh.C.

{
  return _coord_sys;
}

Referenced by MooseMesh::setGeneralAxisymmetricCoordAxes().

getCoordSystem() [2/2]

Moose::CoordinateSystemType MooseMesh::getCoordSystem ( SubdomainID  sid ) const

inherited

Get the coordinate system type, e.g.

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

Definition at line 4304 of file MooseMesh.C.

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

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

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.

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

Referenced by DataFileInterface::getDataFileNameByName().

getDisplaceNodeListBySideList()

bool MooseMesh::getDisplaceNodeListBySideList ( )

inlineinherited

Return displace node list by side list boolean.

Definition at line 1560 of file MooseMesh.h.

{ return _displace_node_list_by_side_list; }

getElementIDIndex()

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

inlineinherited

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

Definition at line 2331 of file MooseMesh.h.

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

Referenced by MooseMesh::areElemIDsIdentical().

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

inherited

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

inherited

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

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

inlinevirtualinherited

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

Reimplemented in FileMesh, and TiledMesh.

Definition at line 1211 of file MooseMesh.h.

{ return ""; }

getGeneralAxisymmetricCoordAxis()

const std::pair< Point, RealVectorValue > & MooseMesh::getGeneralAxisymmetricCoordAxis ( SubdomainID  subdomain_id ) const

inherited

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

inherited

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

Definition at line 3350 of file MooseMesh.C.

{
  return _ghosted_boundaries;
}

getGhostedBoundaryInflation()

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

inherited

Return a writable reference to the _ghosted_boundaries_inflation vector.

Definition at line 3356 of file MooseMesh.C.

{
  return _ghosted_boundaries_inflation;
}

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

getGhostingPatchSize()

unsigned int MooseMesh::getGhostingPatchSize ( ) const

inlineinherited

Getter for the ghosting_patch_size parameter.

Definition at line 634 of file MooseMesh.h.

{ return _ghosting_patch_size; }

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

getHigherDSide()

unsigned int MooseMesh::getHigherDSide ( const Elem *  elem ) const

inherited

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

Definition at line 1704 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() [1/2]

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.

{ return getHitNode(_pars); }

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

getHitNode() [2/2]

const hit::Node * MooseBase::getHitNode ( const InputParameters &  params )

staticprivateinherited

Internal method for getting a hit node (if available) given a set of parameters.

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 167 of file MooseBase.C.

{
  if (const auto hit_node = params.getHitNode())
    if (!hit_node->isRoot())
      return hit_node;
  return nullptr;
}

getInflatedProcessorBoundingBox()

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

inherited

Get a (slightly inflated) processor bounding box.

Parameters

inflation_multiplier

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

Definition at line 3528 of file MooseMesh.C.

{
  // Grab a bounding box to speed things up.  Note that
  // local_bounding_box is *not* equivalent to processor_bounding_box
  // with processor_id() except in serial.
  BoundingBox bbox = MeshTools::create_local_bounding_box(getMesh());
 
  // Inflate the bbox just a bit to deal with roundoff
  // Adding 1% of the diagonal size in each direction on each end
  Real inflation_amount = inflation_multiplier * (bbox.max() - bbox.min()).norm();
  Point inflation(inflation_amount, inflation_amount, inflation_amount);
 
  bbox.first -= inflation;  // min
  bbox.second += inflation; // max
 
  return bbox;
}

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

getInterfaceConnectedBlocks()

std::set< SubdomainID > MooseMesh::getInterfaceConnectedBlocks ( const BoundaryID  bid ) const

inherited

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 3652 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() [1/2]

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

inlineinherited

Accessor for Kokkos mesh object.

Definition at line 678 of file MooseMesh.h.

{ return _kokkos_mesh.get(); }

getKokkosMesh() [2/2]

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

inlineinherited

Definition at line 679 of file MooseMesh.h.

{ return _kokkos_mesh.get(); }

getLocalNodeRange()

ConstNodeRange * MooseMesh::getLocalNodeRange ( )

inherited

Definition at line 1274 of file MooseMesh.C.

{
  if (!_local_node_range)
  {
    TIME_SECTION("getLocalNodeRange", 5);
 
    _local_node_range = std::make_unique<ConstNodeRange>(getMesh().local_nodes_begin(),
                                                         getMesh().local_nodes_end());
  }
 
  return _local_node_range.get();
}

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

getLowerDElem()

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

inherited

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

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

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

getLowerDElemMap()

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

inlineinherited

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

Definition at line 2365 of file MooseMesh.h.

{
  return _higher_d_elem_side_to_lower_d_elem;
}

getMaxInDimension()

Real GeneratedMesh::getMaxInDimension ( unsigned int  component ) const

overridevirtualinherited

Reimplemented from MooseMesh.

Definition at line 133 of file GeneratedMesh.C.

{
  if (_dims_may_have_changed)
    return MooseMesh::getMaxInDimension(component);
 
  switch (component)
  {
    case 0:
      return _xmax;
    case 1:
      return _dim > 1 ? _ymax : 0;
    case 2:
      return _dim > 2 ? _zmax : 0;
    default:
      mooseError("Invalid component");
  }
}

getMaxLeafSize()

unsigned int MooseMesh::getMaxLeafSize ( ) const

inlineinherited

Getter for the maximum leaf size parameter.

Definition at line 639 of file MooseMesh.h.

{ return _max_leaf_size; }

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

getMaxNodesPerElem()

unsigned int MooseMesh::getMaxNodesPerElem ( ) const

inlineinherited

Get the maximum number of nodes per element.

Definition at line 1291 of file MooseMesh.h.

{ return _max_nodes_per_elem; }

getMaxNodesPerSide()

unsigned int MooseMesh::getMaxNodesPerSide ( ) const

inlineinherited

Get the maximum number of nodes per side.

Definition at line 1296 of file MooseMesh.h.

{ return _max_nodes_per_side; }

getMaxSidesPerElem()

unsigned int MooseMesh::getMaxSidesPerElem ( ) const

inlineinherited

Get the maximum number of sides per element.

Definition at line 1286 of file MooseMesh.h.

{ return _max_sides_per_elem; }

getMesh() [1/4]

MeshBase & MooseMesh::getMesh ( )

inherited

Accessor for the underlying libMesh Mesh object.

Definition at line 3557 of file MooseMesh.C.

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

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

getMesh() [2/4]

const MeshBase & MooseMesh::getMesh ( ) const

inherited

Definition at line 3564 of file MooseMesh.C.

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

getMesh() [3/4]

MeshBase & MooseMesh::getMesh ( const std::string &  name )

inherited

getMesh() [4/4]

const MeshBase & MooseMesh::getMesh ( const std::string &  name ) const

inherited

getMeshPtr()

const MeshBase * MooseMesh::getMeshPtr ( ) const

inherited

Definition at line 3551 of file MooseMesh.C.

{
  return _mesh.get();
}

Referenced by MooseApp::attachRelationshipManagers(), MooseMesh::buildTypedMesh(), RelationshipManager::init(), GhostPrimaryFace::operator()(), and GhostBoundary::operator()().

getMinInDimension()

Real GeneratedMesh::getMinInDimension ( unsigned int  component ) const

overridevirtualinherited

Returns the min or max of the requested dimension respectively.

Reimplemented from MooseMesh.

Definition at line 114 of file GeneratedMesh.C.

{
  if (_dims_may_have_changed)
    return MooseMesh::getMinInDimension(component);
 
  switch (component)
  {
    case 0:
      return _xmin;
    case 1:
      return _dim > 1 ? _ymin : 0;
    case 2:
      return _dim > 2 ? _zmin : 0;
    default:
      mooseError("Invalid component");
  }
}

Referenced by GeneratedMesh::buildMesh().

getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

{ return _app; }

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(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), LinearFVGradientInterface::resolveFVGradientMethod(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

getNodeBlockIds()

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

inherited

Return list of blocks to which the given node belongs.

Definition at line 1492 of file MooseMesh.C.

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

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

getNodeList()

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

inherited

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

Definition at line 3579 of file MooseMesh.C.

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

Referenced by LinearNodalConstraint::LinearNodalConstraint(), MoveNodesByParsedExpressionModifier::moveNodes(), NodalScalarKernel::NodalScalarKernel(), EqualValueBoundaryConstraint::populateSecondaryNodes(), and MoveNodesToGeometryModifierBase::snapNodes().

getNormalByBoundaryID()

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

inherited

Returns the normal vector associated with a given BoundaryID.

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

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

inherited

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

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

Must have called detectPairedSidesets() prior to using.

Parameters

component

- An integer representing the desired component (dimension)

Returns

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

Definition at line 2351 of file MooseMesh.C.

{
  if (!_regular_orthogonal_mesh)
    mooseError("Trying to retrieve automatic paired mapping for a mesh that is not regular and "
               "orthogonal");
 
  mooseAssert(component < dimension(), "Requested dimension out of bounds");
 
  if (!hasDetectedPairedSidesets())
    mooseError("MooseMesh::getPairedBoundaryMapping(): Paired boundaries not built; must call "
               "detectPairedSidesets() first");
 
  if (component < _paired_boundary->size())
    return &(*_paired_boundary)[component];
  else
    return nullptr;
}

Referenced by MooseMesh::addPeriodicVariable().

getParallelType()

ParallelType MooseMesh::getParallelType ( ) const

inlineinherited

Returns

The parallel type

Definition at line 1156 of file MooseMesh.h.

{ return _parallel_type; }

Referenced by MultiAppDofCopyTransfer::initialSetup().

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

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

Referenced by CommonOutputAction::act(), CreateDisplacedProblemAction::act(), CylinderComponent::addMeshGenerators(), FEProblemBase::addOutput(), ArrayParsedAux::ArrayParsedAux(), BicubicSplineFunction::BicubicSplineFunction(), Console::Console(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), MFEMEigenvaluesPostprocessor::execute(), FEProblemSolve::FEProblemSolve(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), ParsedSubdomainGeneratorBase::functionInitialize(), BlockDeletionGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FileMeshGenerator::generate(), MeshExtruderGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), XYDelaunayGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), AdvancedOutput::init(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), AdvancedOutput::initAvailableLists(), AttribThread::initFrom(), AttribExecutionOrderGroup::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseVariableBase::MooseVariableBase(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), 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(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), ReferenceResidualInterface::ReferenceResidualInterface(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), PetscOutput::solveSetup(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

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

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

getPatchSize()

unsigned int MooseMesh::getPatchSize ( ) const

inherited

Getter for the patch_size parameter.

Definition at line 3510 of file MooseMesh.C.

{
  return _patch_size;
}

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

getPatchUpdateStrategy()

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

inherited

Get the current patch update strategy.

Definition at line 3522 of file MooseMesh.C.

{
  return _patch_update_strategy;
}

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches().

getPCoarseningMap()

const std::vector< QpMap > & MooseMesh::getPCoarseningMap ( const Elem &  elem ) const

inherited

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

{
  return getPCoarseningMapHelper(elem, _elem_type_to_p_coarsening_map);
}

Referenced by ProjectMaterialProperties::onElement().

getPCoarseningMapHelper()

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

privateinherited

Definition at line 4497 of file MooseMesh.C.

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

Referenced by MooseMesh::getPCoarseningMap(), and MooseMesh::getPCoarseningSideMap().

getPCoarseningSideMap()

const std::vector< QpMap > & MooseMesh::getPCoarseningSideMap ( const Elem &  elem ) const

inherited

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

{
  return getPCoarseningMapHelper(elem, _elem_type_to_p_coarsening_side_map);
}

Referenced by ProjectMaterialProperties::onBoundary().

GetPixelInfo()

void ImageMesh::GetPixelInfo ( std::string  filename, int &  xpixels, int &  ypixels  )

protected

Process a single image with the 'file' command to find out the number of pixels in the x and y directions.

Definition at line 186 of file ImageMesh.C.

{
  // For reporting possible error messages
  std::string error_message = "";
 
  // A template for creating a temporary file.
  char temp_file[] = "file_command_output.XXXXXX";
 
  // Use a do-loop so we can break out under various error conditions
  // while still cleaning up temporary files.  Basically use goto
  // statements without actually using them.
  do
  {
    // mkstemp is not in namespace std for whatever reason...
    int fd = mkstemp(temp_file);
 
    // If mkstemp fails, we failed.
    if (fd == -1)
    {
      error_message = "Error creating temporary file in ImageMesh::buildMesh()";
      break;
    }
 
    // Construct the command string
    std::ostringstream command;
    command << "file " << filename << " 2>/dev/null 1>" << temp_file;
 
    // Make the system call, catch the return code
    int exit_status = std::system(command.str().c_str());
 
    // If the system command returned a non-zero status, we failed.
    if (exit_status != 0)
    {
      error_message = "Error calling 'file' command in ImageMesh::buildMesh()";
      break;
    }
 
    // Open the file which contains the result of the system command
    std::ifstream fin(temp_file);
 
    // Read the contents of the output file into a string
    std::string command_result;
    std::getline(fin, command_result);
 
    // A regular expression which matches "NNN x NNN" , i.e. any number
    // of digits, a space, an 'x', a space, and any number of digits.
    // The parentheses define capture groups which are stored into the
    // xsize and ysize integers.
    // Here's an example string:
    // sixteenth_image001_cropped3_closing_298.png: PNG image data, 115 x 99, 16-bit/color RGB,
    // non-interlaced
    xpixels = 0, ypixels = 0;
    pcrecpp::RE re("(\\d+) x (\\d+)");
    re.PartialMatch(command_result, &xpixels, &ypixels);
 
    // Detect failure of the regex
    if ((xpixels == 0) || (ypixels == 0))
    {
      error_message = "Regex failed to find a match in " + command_result;
      break;
    }
  } while (false);
 
  // Remove the temporary file.  This will still work even if the file was never created...
  std::remove(temp_file);
 
  // Report and exit if there was an error
  if (error_message != "")
    mooseError(error_message);
}

Referenced by buildMesh2D(), and buildMesh3D().

getPointLocator()

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

virtualinherited

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

Definition at line 3846 of file MooseMesh.C.

{
  return getMesh().sub_point_locator();
}

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

getPRefinementMap()

const std::vector< QpMap > & MooseMesh::getPRefinementMap ( const Elem &  elem ) const

inherited

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

{
  return getPRefinementMapHelper(elem, _elem_type_to_p_refinement_map);
}

Referenced by ProjectMaterialProperties::onElement().

getPRefinementMapHelper()

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

privateinherited

Definition at line 4486 of file MooseMesh.C.

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

Referenced by MooseMesh::getPRefinementMap(), and MooseMesh::getPRefinementSideMap().

getPRefinementSideMap()

const std::vector< QpMap > & MooseMesh::getPRefinementSideMap ( const Elem &  elem ) const

inherited

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

{
  return getPRefinementMapHelper(elem, _elem_type_to_p_refinement_side_map);
}

Referenced by ProjectMaterialProperties::onBoundary().

getQuadratureNode()

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

inherited

Get a specified quadrature node.

Parameters

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

Definition at line 1652 of file MooseMesh.C.

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

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

getRefinementMap()

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

inherited

Get the refinement map for a given element type.

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

Parameters

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

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

Definition at line 2574 of file MooseMesh.C.

{
  if (child == -1) // Doing volume mapping or parent side mapping
  {
    mooseAssert(parent_side == child_side,
                "Parent side must match child_side if not passing a specific child!");
 
    std::pair<int, ElemType> the_pair(parent_side, elem.type());
 
    if (_elem_type_to_refinement_map.find(the_pair) == _elem_type_to_refinement_map.end())
      mooseError("Could not find a suitable qp refinement map!");
 
    return _elem_type_to_refinement_map[the_pair];
  }
  else // Need to map a child side to parent volume qps
  {
    std::pair<int, int> child_pair(child, child_side);
 
    if (_elem_type_to_child_side_refinement_map.find(elem.type()) ==
            _elem_type_to_child_side_refinement_map.end() ||
        _elem_type_to_child_side_refinement_map[elem.type()].find(child_pair) ==
            _elem_type_to_child_side_refinement_map[elem.type()].end())
      mooseError("Could not find a suitable qp refinement map!");
 
    return _elem_type_to_child_side_refinement_map[elem.type()][child_pair];
  }
 
}

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

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 420 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 70 of file MooseObject.C.

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

Referenced by MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), and WebServerControl::addServerAction().

getSharedPtr() [2/2]

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

inherited

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

inherited

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

Parameters

subdomain_id

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

Returns

All boundary IDs connected to elements in the give

Definition at line 3606 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.boundary_ids;
}

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

getSubdomainID()

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

inherited

Get the associated subdomain ID for the subdomain name.

Parameters

subdomain_name

The name of the subdomain

Returns

The subdomain id from the passed subdomain name.

Definition at line 1723 of file MooseMesh.C.

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

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

getSubdomainIDs() [1/2]

std::set< SubdomainID > MooseMesh::getSubdomainIDs ( const std::set< SubdomainName > &  subdomain_names ) const

inherited

Definition at line 1735 of file MooseMesh.C.

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

getSubdomainIDs() [2/2]

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

inherited

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

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

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

getSubdomainInterfaceBoundaryIds()

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

inherited

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

inherited

Return the name of a block given an id.

Definition at line 1759 of file MooseMesh.C.

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

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

getSubdomainNames()

std::vector< SubdomainName > MooseMesh::getSubdomainNames ( const std::vector< SubdomainID > &  subdomain_ids ) const

inherited

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

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

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

getUniqueCoordSystem()

Moose::CoordinateSystemType MooseMesh::getUniqueCoordSystem ( ) const

inherited

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

Definition at line 4314 of file MooseMesh.C.

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

Referenced by HDGKernel::HDGKernel().

ghostGhostedBoundaries()

void MooseMesh::ghostGhostedBoundaries ( )

inherited

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

Definition at line 3423 of file MooseMesh.C.

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

Referenced by FEProblemBase::ghostGhostedBoundaries().

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

hasDetectedPairedSidesets()

bool MooseMesh::hasDetectedPairedSidesets ( ) const

inlineinherited

Whether or not detectedPairedSidesets() has been called.

Definition at line 1000 of file MooseMesh.h.

{ return _paired_boundary.has_value(); }

Referenced by MooseMesh::getPairedBoundaryMapping(), and Moose::PeriodicBCHelper::setupPeriodicBoundaries().

hasElementID()

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

inlineinherited

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

Definition at line 2325 of file MooseMesh.h.

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

Referenced by MooseMesh::getElementIDIndex().

hasLowerD()

bool MooseMesh::hasLowerD ( ) const

inlineinherited

Returns

Whether there are any lower-dimensional blocks

Definition at line 1545 of file MooseMesh.h.

{ return getMesh().elem_dimensions().size() > 1; }

Referenced by GhostLowerDElems::operator()().

hasMeshBase()

bool MooseMesh::hasMeshBase ( ) const

inlineinherited

Whether mesh base object was constructed or not.

Definition at line 1244 of file MooseMesh.h.

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

Referenced by MeshGeneratorMesh::buildMesh(), and MFEMMeshGeneratorMesh::buildSerialMFEMMesh().

hasSecondOrderElements()

bool MooseMesh::hasSecondOrderElements ( )

inherited

check if the mesh has SECOND order elements

Definition at line 3824 of file MooseMesh.C.

{
  bool mesh_has_second_order_elements = false;
  for (auto it = activeLocalElementsBegin(), end = activeLocalElementsEnd(); it != end; ++it)
    if ((*it)->default_order() == SECOND)
    {
      mesh_has_second_order_elements = true;
      break;
    }
 
  // We checked our local elements, so take the max over all processors.
  comm().max(mesh_has_second_order_elements);
  return mesh_has_second_order_elements;
}

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

init()

void MooseMesh::init ( )

virtualinherited

Initialize the Mesh object.

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

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

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

Reimplemented in MFEMMesh.

Definition at line 2937 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();
 
    if (getParam<bool>("build_all_side_lowerd_mesh"))
      buildLowerDMesh();
  }
}

Referenced by MFEMMesh::init().

interiorLowerDBlocks()

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

inlineinherited

Returns

The set of lower-dimensional blocks for interior sides

Definition at line 1550 of file MooseMesh.h.

{ return _lower_d_interior_blocks; }

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

internalNodeToElemMap()

std::unordered_map< dof_id_type, std::vector< dof_id_type > > & MooseMesh::internalNodeToElemMap ( )

privateinherited

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

Definition at line 1210 of file MooseMesh.C.

{
  if (!_node_to_elem_map_built) // Guard the creation with a double checked lock
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
 
    if (!_node_to_elem_map_built)
    {
      // 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;
 
      mooseAssert(_node_to_elem_map.empty(), "Expected empty map before building");
      for (const auto & elem : getMesh().active_element_ptr_range())
        for (unsigned int n = 0; n < elem->n_nodes(); n++)
          _node_to_elem_map[elem->node_id(n)].push_back(elem->id());
 
      _node_to_elem_map_built = true; // MUST be set at the end for double-checked locking to work!
    }
  }
  return _node_to_elem_map;
}

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

isBoundaryElem() [1/2]

bool MooseMesh::isBoundaryElem ( dof_id_type  elem_id ) const

inherited

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

Definition at line 3700 of file MooseMesh.C.

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

Referenced by BoundaryMarker::computeElementMarker().

isBoundaryElem() [2/2]

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

inherited

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

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

inherited

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

inherited

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

Definition at line 3674 of file MooseMesh.C.

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

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

isBoundaryNode() [2/2]

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

inherited

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

Definition at line 3689 of file MooseMesh.C.

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

isCustomPartitionerRequested()

bool MooseMesh::isCustomPartitionerRequested ( ) const

inherited

Setter and getter for _custom_partitioner_requested.

Definition at line 3818 of file MooseMesh.C.

{
  return _custom_partitioner_requested;
}

isDisplaced() [1/2]

bool MooseMesh::isDisplaced ( ) const

inlineinherited

whether this mesh is a displaced mesh

Definition at line 1368 of file MooseMesh.h.

{ return _is_displaced; }

isDisplaced() [2/2]

void MooseMesh::isDisplaced ( bool  is_displaced )

inlineinherited

Set whether this mesh is a displaced mesh.

Definition at line 1363 of file MooseMesh.h.

{ _is_displaced = is_displaced; }

isDistributedMesh()

virtual bool MooseMesh::isDistributedMesh ( ) const

inlinevirtualinherited

Returns the final Mesh distribution type.

Reimplemented in MFEMMesh.

Definition at line 1141 of file MooseMesh.h.

{ return _use_distributed_mesh; }

Referenced by BoundaryMarker::BoundaryMarker(), VerifyElementUniqueID::finalize(), VerifyNodalUniqueID::finalize(), ElementSubdomainModifierBase::gatherPatchElements(), SolutionUserObjectBase::initialSetup(), SolutionUserObjectBase::readExodusIIOrNemesis(), Checkpoint::updateCheckpointFiles(), and RandomData::updateGenerators().

isFiniteVolumeInfoDirty()

bool MooseMesh::isFiniteVolumeInfoDirty ( ) const

inlineinherited

Returns

whether the finite volume information is dirty

Definition at line 1459 of file MooseMesh.h.

{ return _finite_volume_info_dirty; }

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

isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

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

Definition at line 63 of file MooseObject.h.

{ return parameters().isKokkosObject(); }

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

isParallelTypeForced()

bool MooseMesh::isParallelTypeForced ( ) const

inlineinherited

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

Definition at line 1146 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.

  {
    return _pars.isParamSetByUser(name);
  }

Referenced by DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), MeshDiagnosticsGenerator::generate(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMVariable::MFEMVariable(), MortarConstraintBase::MortarConstraintBase(), MoveNodesByParsedExpressionModifier::moveNodes(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::run(), MooseApp::runInputFile(), MooseApp::runInputs(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

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.

{ return _pars.isParamValid(name); }

Referenced by GridPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), AddVariableAction::act(), AutoCheckpointAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CopyNodalVarsAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshCompleteAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), TimedSubdomainModifier::buildFromFile(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentJunction::ComponentJunction(), ConservativeAdvectionBCTempl< is_ad >::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(), EigenProblemSolve::EigenProblemSolve(), ElementGenerator::ElementGenerator(), 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(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AddMetaDataGenerator::generate(), BlockDeletionGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), BSplineCurveGenerator::generate(), ConcentricCircleMeshGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), ElementGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ManifoldSubdomainGenerator::generate(), MeshExtruderGenerator::generate(), OrientSurfaceMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), SphereMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainPerElementGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), AddPeriodicBCAction::getVariables(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), AdvancedOutput::initAvailableLists(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), SolutionAux::initialSetup(), SolutionScalarAux::initialSetup(), PIDTransientControl::initialSetup(), ParsedConvergence::initialSetup(), EigenProblemSolve::initialSetup(), MooseParsedFunction::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedVectorFunction::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionIC::initialSetup(), Console::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), PNGOutput::makePNG(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), EqualValueBoundaryConstraint::pickPrimaryNode(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), MooseMesh::prepare(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusIIOrNemesis(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), MooseMesh::setCoordSystem(), FileOutput::setFileBaseInternal(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), Split::setup(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, T >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObjectBase::SolutionUserObjectBase(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), PIDTransientControl::timestepSetup(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

isPartitionerForced()

bool MooseMesh::isPartitionerForced ( ) const

inlineinherited

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

Definition at line 1166 of file MooseMesh.h.

{ return _partitioner_overridden; }

isRegularOrthogonal()

bool MooseMesh::isRegularOrthogonal ( )

inlineinherited

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

Definition at line 1196 of file MooseMesh.h.

{ return _regular_orthogonal_mesh; }

Referenced by AddPeriodicBCAction::act(), and AddPeriodicBCAction::onSetupPeriodicBoundary().

isSemiLocal()

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

inherited

Returns true if the node is semi-local.

Parameters

node	Node pointer

Returns

true is the node is semi-local, false otherwise

Definition at line 1001 of file MooseMesh.C.

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

isSplit()

bool MooseMesh::isSplit ( ) const

inlineinherited

Returns

Whether or not this mesh comes from a split mesh

Definition at line 1482 of file MooseMesh.h.

{ return _is_split; }

isTranslatedPeriodic() [1/3]

bool MooseMesh::isTranslatedPeriodic ( const MooseVariableBase &  var, const unsigned int  component  ) const

inherited

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

Parameters

var	- The variable
component	- An integer representing the desired component (dimension)

Definition at line 2265 of file MooseMesh.C.

{
  return isTranslatedPeriodic(var.sys().number(), var.number(), component);
}

isTranslatedPeriodic() [2/3]

bool MooseMesh::isTranslatedPeriodic ( const unsigned int  sys_num, const unsigned int  var_num, const unsigned int  component  ) const

inherited

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

Parameters

sys_num	- The number of the system the variable is on
var_num	- The variable number
component	- An integer representing the desired component (dimension)

Definition at line 2256 of file MooseMesh.C.

{
  mooseAssert(component < dimension(), "Requested dimension out of bounds");
  return queryPeriodicDimensions(sys_num, var_num)[component];
}

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

isTranslatedPeriodic() [3/3]

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

inherited

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

Deprecated method; assumes the system number is 0. Use the method that additionally takes the system number or the MooseVariableBase instead.

Parameters

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

Definition at line 2271 of file MooseMesh.C.

{
  mooseDoOnce(mooseDeprecated(
      "MooseMesh::isTranslatedPeriodic(const unsigned int, const unsigned int) is deprecated. Use "
      "the method that additionally takes the system number or the MooseVariableBase instead."));
  return isTranslatedPeriodic(0, var_num, component);
}

lengthUnit()

const MooseUnits & MooseMesh::lengthUnit ( ) const

inherited

Returns

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

Definition at line 4459 of file MooseMesh.C.

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

localNodesBegin() [1/2]

MeshBase::node_iterator MooseMesh::localNodesBegin ( )

inherited

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

Definition at line 3136 of file MooseMesh.C.

{
  return getMesh().local_nodes_begin();
}

localNodesBegin() [2/2]

MeshBase::const_node_iterator MooseMesh::localNodesBegin ( ) const

inherited

Definition at line 3148 of file MooseMesh.C.

{
  return getMesh().local_nodes_begin();
}

localNodesEnd() [1/2]

MeshBase::node_iterator MooseMesh::localNodesEnd ( )

inherited

Definition at line 3142 of file MooseMesh.C.

{
  return getMesh().local_nodes_end();
}

localNodesEnd() [2/2]

MeshBase::const_node_iterator MooseMesh::localNodesEnd ( ) const

inherited

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

privateinherited

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

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

Parameters

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

Definition at line 2649 of file MooseMesh.C.

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

Referenced by MooseMesh::buildPRefinementAndCoarseningMaps(), and MooseMesh::findAdaptivityQpMaps().

markFiniteVolumeInfoDirty()

void MooseMesh::markFiniteVolumeInfoDirty ( )

inlineinherited

Mark the finite volume information as dirty.

Definition at line 1454 of file MooseMesh.h.

{ _finite_volume_info_dirty = true; }

maxElementID()

dof_id_type MooseMesh::maxElementID ( unsigned int  elem_id_index ) const

inlineinherited

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

Definition at line 1259 of file MooseMesh.h.

{ return _max_ids[elem_id_index]; }

maxElemId()

dof_id_type MooseMesh::maxElemId ( ) const

virtualinherited

Definition at line 3202 of file MooseMesh.C.

{
  return getMesh().max_elem_id();
}

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

maxHLevel()

unsigned int MooseMesh::maxHLevel ( ) const

inlineinherited

Returns the maximum h-refinement level of all elements.

Definition at line 1517 of file MooseMesh.h.

{ return _max_h_level; }

maxNodeId()

dof_id_type MooseMesh::maxNodeId ( ) const

virtualinherited

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

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

Definition at line 3196 of file MooseMesh.C.

{
  return getMesh().max_node_id();
}

maxPLevel()

unsigned int MooseMesh::maxPLevel ( ) const

inlineinherited

Returns the maximum p-refinement level of all elements.

Definition at line 1512 of file MooseMesh.h.

{ return _max_p_level; }

meshBoundaryIds()

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

inherited

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

Definition at line 3286 of file MooseMesh.C.

{
  return _mesh_boundary_ids;
}

Referenced by BoundaryRestrictable::isBoundarySubset().

meshChanged()

void MooseMesh::meshChanged ( )

inherited

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

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

Definition at line 892 of file MooseMesh.C.

{
  TIME_SECTION("meshChanged", 3, "Updating Because Mesh Changed");
 
  update();
 
  // Delete all of the cached ranges
  _active_node_range.reset();
  _active_semilocal_node_range.reset();
  _local_node_range.reset();
  _bnd_node_range.reset();
  _bnd_elem_range.reset();
 
  // Rebuild the ranges
  getActiveLocalElementRange();
  getActiveNodeRange();
  getLocalNodeRange();
  getBoundaryNodeRange();
  getBoundaryElementRange();
 
  // Call the callback function onMeshChanged
  onMeshChanged();
}

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

meshNodesetIds()

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

inherited

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

Definition at line 3298 of file MooseMesh.C.

{
  return _mesh_nodeset_ids;
}

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

meshSidesetIds()

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

inherited

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

Definition at line 3292 of file MooseMesh.C.

{
  return _mesh_sideset_ids;
}

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

meshSubdomains()

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

inherited

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

Definition at line 3280 of file MooseMesh.C.

{
  return _mesh_subdomains;
}

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

messagePrefix() [1/2]

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.

  {
    return messagePrefix(_pars, hit_prefix);
  }

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

messagePrefix() [2/2]

std::string MooseBase::messagePrefix ( const InputParameters &  params, const bool  hit_prefix  )

staticprivateinherited

Internal method for getting the message prefix for an object (object type, name, etc).

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 140 of file MooseBase.C.

{
  std::string prefix = "";
 
  if (hit_prefix)
    if (const auto node = MooseBase::getHitNode(params))
      prefix += Moose::hitMessagePrefix(*node);
 
  // Don't have context without type and name
  if (!params.isMooseBaseObject())
    return prefix;
 
  const auto & name = params.getObjectName();
  const std::string base = params.hasBase() ? params.getBase() : "object";
  const bool is_main_app = base == "Application" && name == AppFactory::main_app_name;
  prefix += "The following occurred in the ";
  if (is_main_app)
    prefix += "main " + base;
  else
    prefix += base;
  if (base != params.getObjectName() && name.size() && !is_main_app)
    prefix += " '" + name + "'";
  prefix += " of type " + params.getObjectType() + ".";
  return prefix + "\n\n";
}

minElementID()

dof_id_type MooseMesh::minElementID ( unsigned int  elem_id_index ) const

inlineinherited

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

Definition at line 1264 of file MooseMesh.h.

{ return _min_ids[elem_id_index]; }

minPeriodicDistance() [1/3]

Real MooseMesh::minPeriodicDistance ( const MooseVariableBase &  var, const Point &  p, const Point &  q  ) const

inherited

Returns the distance between two points on the mesh taking into account periodicity for the given variable.

Parameters

var	- The variable
p,q	- The points for which to compute a minimum distance

Returns

Real - The L2 distance between p and q

Definition at line 2334 of file MooseMesh.C.

{
  return minPeriodicDistance(var.sys().number(), var.number(), p, q);
}

minPeriodicDistance() [2/3]

Real MooseMesh::minPeriodicDistance ( const unsigned int  sys_num, const unsigned int  var_num, const Point &  p, const Point &  q  ) const

inherited

Returns the distance between two points on the mesh taking into account periodicity for the given variable on the given system.

Parameters

sys_num	- The number of the system the variable is on
var_num	- The 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 2325 of file MooseMesh.C.

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

Referenced by MooseMesh::minPeriodicDistance(), and MooseMesh::minPeriodicDistance().

minPeriodicDistance() [3/3]

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

inherited

Returns the distance between two points on the mesh taking into account periodicity for the given variable.

Deprecated method; assumes the system number is 0. Use the method that additionally takes the system number or the MooseVariableBase instead.

Parameters

var_num	- The 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 2342 of file MooseMesh.C.

{
  mooseDoOnce(mooseDeprecated("MooseMesh::minPeriodicDistance(const unsigned int, const Point &, "
                              "const Point &) is deprecated. Use the method that additionally "
                              "takes the system number or the MooseVariableBase instead."));
  return minPeriodicDistance(0, var_num, p, q);
}

minPeriodicVector() [1/3]

RealVectorValue MooseMesh::minPeriodicVector ( const MooseVariableBase &  var, const Point &  p, const Point &  q  ) const

inherited

Returns the minimum vector between two points on the mesh taking into account periodicity for the given variable.

Parameters

var	- The variable
p,q	- The points between which to compute a minimum vector

Returns

RealVectorValue - The vector pointing from p to q

Definition at line 2310 of file MooseMesh.C.

{
  return minPeriodicVector(var.sys().number(), var.number(), p, q);
}

minPeriodicVector() [2/3]

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

inherited

Returns the minimum vector between two points on the mesh taking into account periodicity for the given variable on the given system.

Parameters

sys_num	- The number of the system the variable is on
var_num	- The 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 2280 of file MooseMesh.C.

{
  const auto & periodic_dims = queryPeriodicDimensions(sys_num, var_num);
 
  for (const auto i : make_range(dimension()))
  {
    // check to see if we're closer in real or periodic space in x, y, and z
    if (periodic_dims[i])
    {
      // Need to test order before differencing
      if (p(i) > q(i))
      {
        if (p(i) - q(i) > _half_range(i))
          p(i) -= _half_range(i) * 2;
      }
      else
      {
        if (q(i) - p(i) > _half_range(i))
          p(i) += _half_range(i) * 2;
      }
    }
  }
 
  return q - p;
}

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

minPeriodicVector() [3/3]

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

inherited

Returns the minimum vector between two points on the mesh taking into account periodicity for the given variable on the given system.

Deprecated method; assumes the system number is 0. Use the method that additionally takes the system number or the MooseVariableBase instead.

Parameters

var_num	- The 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 2316 of file MooseMesh.C.

{
  mooseDoOnce(mooseDeprecated("MooseMesh::minPeriodicVector(const unsigned int, const Point &, "
                              "const Point &) is deprecated. Use the method that additionally "
                              "takes the system number or the MooseVariableBase instead."));
  return minPeriodicVector(0, var_num, p, q);
}

mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and a stack trace.

Definition at line 317 of file MooseBase.h.

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

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

mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

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

Referenced by MultiApp::appProblem(), AddVariableAction::determineType(), MooseMesh::elem(), MooseMesh::elem(), FunctionDT::FunctionDT(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), MooseMesh::isTranslatedPeriodic(), MooseMesh::minPeriodicDistance(), MooseMesh::minPeriodicVector(), MooseMesh::node(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), and MooseMesh::setBoundaryToNormalMap().

mooseDeprecatedNoTrace()

template<typename... Args>

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

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and no stack trace.

Definition at line 327 of file MooseBase.h.

  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, false, 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.

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

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

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.

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

Referenced by CopyMeshPartitioner::_do_partition(), GridPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), AdaptivityAction::act(), AddBoundsVectorsAction::act(), AddFVICAction::act(), AddICAction::act(), AddMeshGeneratorAction::act(), AddPeriodicBCAction::act(), AddTimeStepperAction::act(), AddVectorPostprocessorAction::act(), ChainControlSetupAction::act(), CheckFVBCAction::act(), CheckIntegrityAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), InitProblemAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), SplitMeshAction::act(), Action::Action(), AddActionComponentAction::AddActionComponentAction(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), MooseApp::addCapabilityInternal(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), SubProblem::addFunctor(), PhysicsComponentInterface::addInitialConditionsFromComponents(), ComponentJunction::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), AddActionComponentAction::addRelationshipManagers(), WebServerControl::addServerAction(), AddVariableAction::addVariable(), SubProblem::addVectorTag(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), MooseVariableBase::allDofIndices(), MooseApp::appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), MooseApp::attachRelationshipManagers(), MooseApp::attachRelationshipManagers(), FEProblemBase::automaticScaling(), Function::average(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromJSON(), PiecewiseTabularInterface::buildFromXY(), MooseMesh::buildLowerDMesh(), GeneratedMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), TiledMesh::buildMesh(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), SubProblem::checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), MooseMesh::checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), MooseMesh::checkDuplicateSubdomainNames(), MaterialBase::checkExecutionStage(), FVFluxBC::checkFaceIntegrity(), FVInterfaceKernel::checkFaceIntegrity(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), ExplicitTimeIntegrator::checkLinearConvergence(), MooseApp::checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), Moose::PeriodicBCHelper::checkPeriodicParams(), Sampler::checkReinitStatus(), MultiAppTransfer::checkSiblingsTransferSupported(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Moose::PetscSupport::checkUserProvidedPetscOption(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), MooseMesh::clone(), LibmeshPartitioner::clone(), CombinerGenerator::CombinerGenerator(), MooseVariableFieldBase::componentName(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), MooseVariableFieldBase::computeFaceValues(), TimeStepper::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MaterialBase::computeProperties(), ResidualObject::computeResidualAndJacobian(), TimeStepper::computeStep(), AStableDirk4::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), MooseApp::copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MooseApp::createExecutors(), AddVariableAction::createInitialConditionAction(), MooseApp::createRMFromTemplateAndInit(), Function::curl(), ReporterTransferInterface::declareClone(), Moose::Kokkos::MaterialBase::declareKokkosPropertyInternal(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), MooseApp::determineLibtorchDeviceType(), MeshDiagnosticsGenerator::diagnosticsLog(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), FunctorRelationshipManager::dofmap_reinit(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), DistributedRectilinearMeshGenerator::elemId(), MooseApp::errorCheck(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), FixedPointSolve::examineFixedPointConvergence(), Eigenvalue::execute(), TransientBase::execute(), WebServerControl::execute(), MooseApp::executeExecutioner(), FVInterfaceKernel::faceArg1(), FVInterfaceKernel::faceArg2(), MultiApp::fillPositions(), MooseApp::finalizeRestore(), Transfer::find_sys(), DiracKernelInfo::findPoint(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), LinearFVBoundaryCondition::functorFaceArg(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), AdvancedExtruderGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), CoarsenBlockGenerator::generate(), CombinerGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), DistributedRectilinearMeshGenerator::generate(), ElementOrderConversionGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MeshCollectionGenerator::generate(), MeshDiagnosticsGenerator::generate(), MeshExtruderGenerator::generate(), MeshRepairGenerator::generate(), MoveNodeGenerator::generate(), PlaneIDMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SmoothMeshGenerator::generate(), SpiralAnnularMeshGenerator::generate(), StackGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateCSG(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), MooseMesh::getAxisymmetricRadialCoord(), MooseMesh::getBlockConnectedBlocks(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), WebServerControl::getClientInfo(), MooseMesh::getCoarseningMap(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), PhysicsBase::getCoupledPhysics(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), EigenExecutionerBase::getEigenSystemConvergence(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), WebServerControl::Response::getError(), MultiApp::getExecutioner(), MooseApp::getExecutor(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), SubProblem::getFunctor(), MooseMesh::getGeneralAxisymmetricCoordAxis(), MaterialPropertyInterface::getGenericMaterialPropertyByName(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), MaterialPropertyInterface::getKokkosBlockMaterialProperty(), FunctionInterface::getKokkosFunctionByName(), MaterialPropertyInterface::getKokkosMaterialPropertyByName(), Material::getMaterialByName(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), DistributedRectilinearMeshGenerator::getNeighbors(), MooseMesh::getNodeBlockIds(), MooseMesh::getNodeList(), MooseMesh::getPairedBoundaryMapping(), MaterialOutputAction::getParams(), PlaneIDMeshGenerator::getPlaneID(), PostprocessorInterface::getPostprocessorValueByNameInternal(), ComponentMaterialPropertyInterface::getPropertyValue(), MooseMesh::getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), MooseApp::getRMClone(), MooseObject::getSharedPtr(), MooseObject::getSharedPtr(), PhysicsBase::getSolverSystem(), MooseMesh::getSubdomainBoundaryIds(), TransientBase::getTimeIntegratorNames(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), AddPeriodicBCAction::getVariables(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), MultiApp::globalAppToLocal(), Function::gradient(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), TransientBase::incrementStepOrReject(), NEML2Action::inferMOOSEIOType(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), EigenExecutionerBase::init(), TransientBase::init(), MFEMMesh::init(), CrankNicolson::init(), ExplicitTimeIntegrator::init(), FixedPointIterationAdaptiveDT::init(), IterationAdaptiveDT::init(), MultiApp::init(), NestedDivision::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SubProblem::initialSetup(), AuxKernelBase::initialSetup(), SolutionScalarAux::initialSetup(), FullSolveMultiApp::initialSetup(), ExplicitTimeIntegrator::initialSetup(), Function::integral(), InternalSideIndicatorBase::InternalSideIndicatorBase(), EigenExecutionerBase::inversePowerIteration(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LibmeshPartitioner::LibmeshPartitioner(), MooseApp::libNameToAppName(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LineSearch::lineSearch(), MooseApp::loadLibraryAndDependencies(), ReporterPointMarker::markerSetup(), SubProblem::markFamilyPRefinement(), Material::Material(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableBase::MooseVariableBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppTransfer::MultiAppTransfer(), NewmarkBeta::NewmarkBeta(), DistributedRectilinearMeshGenerator::nodeId(), DistributedRectilinearMeshGenerator::numNeighbors(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), MortarNodalGeometryOutput::output(), Output::Output(), MooseApp::outputMachineReadableData(), DistributedRectilinearMeshGenerator::paritionSquarely(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularInterface::PiecewiseTabularInterface(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), ProjectSideSetOntoLevelSetGenerator::pointPairLevelSetInterception(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), AStableDirk4::postResidual(), ExplicitRK2::postResidual(), ExplicitTVDRK2::postResidual(), ImplicitMidpoint::postResidual(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), LStableDirk4::postResidual(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), FixedPointSolve::printFixedPointConvergenceReason(), MultiApp::readCommandLineArguments(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), MooseApp::run(), MooseApp::runInputs(), ScalarComponentIC::ScalarComponentIC(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), MooseMesh::setGeneralAxisymmetricCoordAxes(), MeshGenerator::setMeshProperty(), MooseApp::setMFEMDevice(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), Split::setup(), TransientMultiApp::setupApp(), Moose::PeriodicBCHelper::setupAutoPeriodicBoundaries(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), MooseVariableBase::sizeMatrixTagData(), SmoothMeshGenerator::SmoothMeshGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), Moose::MFEM::LinearSolverBase::Solve(), TimeIntegrator::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), FullSolveMultiApp::solveStep(), UserObject::spatialPoints(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), MeshRepairGenerator::splitNonConvexPolygons(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), MaterialBase::subdomainSetup(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), Action::timedAct(), Function::timeDerivative(), Function::timeIntegral(), ParsedCurveGenerator::tSectionSpaceDefiner(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), MooseVariableScalar::uDotOld(), MooseBase::uniqueName(), AuxScalarKernel::uOld(), ScalarKernelBase::uOld(), Function::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), AddVariableAction::variableType(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), WebServerControl::WebServerControl(), MFEMMesh::writeRecoveryFiles(), and MooseApp::writeRestartableMetaData().

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

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

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), PIDTransientControl::execute(), Executioner::Executioner(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), ManifoldSubdomainGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), MultiAppTransfer::mapBackWithoutCollapsing(), SolutionInvalidityOutput::output(), MooseBase::paramInfo(), MooseApp::setupOptions(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

mooseWarning() [1/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.

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

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

mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

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

Referenced by CopyMeshPartitioner::_do_partition(), AddFunctionAction::act(), AddKernelAction::act(), CommonOutputAction::act(), MaterialOutputAction::act(), MeshOnlyAction::act(), MooseMesh::addPeriodicVariable(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkPolygons(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), MultiApp::createApp(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), Postprocessor::evaluateDotWarning(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), BSplineCurveGenerator::generate(), RenumberBySubdomainGenerator::generate(), SubdomainPerElementGenerator::generate(), SurfaceMeshGeneratorBase::get2DElemNormal(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), IndicatorMarker::IndicatorMarker(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MFEMRefinementMarker::MFEMRefinementMarker(), NewmarkBeta::NewmarkBeta(), Output::Output(), MaterialOutputAction::outputHelper(), Executioner::problem(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), MooseMesh::setCoordSystem(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

mooseWarningNonPrefixed() [1/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)...);
  }

mooseWarningNonPrefixed() [2/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");
  }

nActiveElem()

virtual dof_id_type MooseMesh::nActiveElem ( ) const

inlinevirtualinherited

Reimplemented in MFEMMesh.

Definition at line 337 of file MooseMesh.h.

{ return _mesh->n_active_elem(); }

nActiveLocalElem()

virtual dof_id_type MooseMesh::nActiveLocalElem ( ) const

inlinevirtualinherited

Reimplemented in MFEMMesh.

Definition at line 338 of file MooseMesh.h.

{ return _mesh->n_active_local_elem(); }

Referenced by MooseMesh::buildFiniteVolumeInfo().

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.

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

Referenced by AdaptivityAction::act(), AddActionComponentAction::act(), AddElementalFieldAction::act(), AddPeriodicBCAction::act(), AddTimeStepperAction::act(), CommonOutputAction::act(), CopyNodalVarsAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), SetupResidualDebugAction::act(), SetupTimeIntegratorAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), FEProblemBase::addAuxKernel(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), MFEMProblem::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFunctorMaterial(), MFEMProblem::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVGradientMethod(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), FEProblemBase::addIndicator(), MFEMProblem::addIndicator(), FEProblemBase::addInitialCondition(), MFEMProblem::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), ElementAndTraceScalarHDGAssemblyHelper::additionalROVariables(), BoundaryIntegralValueConstraint::additionalROVariables(), DiffusionLHDGKernel::additionalROVariables(), ADKernelScalarBase::additionalROVariables(), FEProblemBase::addKernel(), MFEMProblem::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), MFEMProblem::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMProblemComposer(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), InitialConditionWarehouse::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), UserObjectBase::addPostprocessorDependencyHelper(), AuxKernelBase::addPostprocessorDependencyHelper(), InitialConditionBase::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MFEMProblem::addQuadratureFunction(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), AddActionComponentAction::addRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), MFEMProblem::addTransfer(), PhysicsBase::addUserObject(), FEProblemBase::addUserObject(), UserObjectBase::addUserObjectDependencyHelper(), AuxKernelBase::addUserObjectDependencyHelper(), InitialConditionBase::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), MFEMProblem::addVectorPostprocessor(), UserObjectBase::addVectorPostprocessorDependencyHelper(), AuxKernelBase::addVectorPostprocessorDependencyHelper(), MooseLinearVariableFV< OutputType >::adError(), Output::advancedExecuteOn(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), NEML2ModelExecutor::advanceState(), MooseVariableBase::allDofIndices(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), Function::average(), MultiApp::backup(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromXY(), MFEMGeometricMultigridSolver::BuildMultigrid(), MooseMesh::buildNodeListFromSideList(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), DefaultNonlinearConvergence::checkConvergence(), ParsedConvergence::checkConvergence(), FEProblemBase::checkDependMaterialsHelper(), FVFluxBC::checkFaceIntegrity(), FVInterfaceKernel::checkFaceIntegrity(), TaggingInterface::checkForNans(), SamplerBase::checkForStandardFieldVariableType(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), NonlinearSystemBase::checkKernelCoverage(), Moose::Kokkos::Material::checkMaterialProperty(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), FEProblemBase::checkUserObjectNameCollision(), BlockRestrictable::checkVariable(), DomainUserObject::checkVariable(), Coupleable::checkWritableVar(), CoarsenSurfaceMeshAlongSidesetGenerator::coarsenAlongSidesets(), 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(), MFEMComplexVariable::declareCoefficients(), MFEMVariable::declareCoefficients(), MeshInfo::declareHelper(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), MFEMCoordinateTransformations::declareRZCoefficients(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementDamper::ElementDamper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), RestartableDataReporter::execute(), MultiAppGeneralFieldTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), SideValueSampler::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FVInterfaceKernel::faceArg1(), FVInterfaceKernel::faceArg2(), FEProblemBase::FEProblemBase(), NEML2ModelExecutor::fillInputs(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionArrayAux::FunctionArrayAux(), FunctionDT::FunctionDT(), FVFunctionIC::functionName(), FunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), GapValueAux::GapValueAux(), BoundaryDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ManifoldSubdomainGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MooseMesh::getBoundaryString(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), MFEMProblem::getComplexGridFunction(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), MeshGenerator::getCSGBase(), MeshGenerator::getCSGBasesByName(), UserObjectBase::getDependObjects(), FEProblemBase::getDistribution(), DistributionInterface::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), FEProblemBase::getExecutor(), MooseApp::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVAdvectedInterpolationMethod(), FEProblemBase::getFVFaceInterpolationMethod(), FEProblemBase::getFVGradientMethod(), FEProblemBase::getFVInterpolationMethod(), AuxKernelTempl< ComputeValueType >::getGenericMaterialProperty(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), MFEMProblem::getGridFunction(), FEProblemBase::getKokkosFunction(), FEProblemBase::getKokkosUserObject(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), AuxKernelTempl< ComputeValueType >::getMaterialProperty(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), Material::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOlder(), NodalPatchRecovery::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), MFEMObject::getMatrixCoefficient(), MFEMObject::getMatrixCoefficientByName(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MFEMProblem::getMFEMObject(), ActionWarehouse::getMooseAppName(), NEML2FEInterpolation::getMOOSEVariable(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), MooseBase::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MFEMExecutedObject::getRequestedItems(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMObject::getScalarCoefficient(), MFEMObject::getScalarCoefficientByName(), TimedSubdomainModifier::getSubdomainIDAndCheck(), MFEMExecutedObject::getSuppliedItems(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMObject::getVectorCoefficient(), MFEMObject::getVectorCoefficientByName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasDistribution(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), FEProblemBase::hasFVGradientMethod(), FEProblemBase::hasFVInterpolationMethod(), MeshInfo::hasItem(), MooseApp::hasMeshGenerator(), MFEMProblem::hasMFEMObject(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), NEML2Action::inferMOOSEIOType(), AddVariableAction::init(), AdvancedOutput::init(), IterationAdaptiveDT::init(), AdvancedOutput::initAvailableLists(), MeshInfo::initCombinedInfos(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), BoundaryRestrictable::initializeBoundaryRestrictable(), AuxKernelBase::initialSetup(), SolutionScalarAux::initialSetup(), Console::initialSetup(), JSONOutput::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), NodalVariableValue::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppGeneralFieldFunctorTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), BoundaryMeshBuilder::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MeshGenerator::isChildMeshGenerator(), DerivativeMaterialInterface< T >::isNotObjectVariable(), MeshGenerator::isNullMeshName(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), MooseLinearVariableFV< OutputType >::lowerDError(), Marker::Marker(), MaterialBase::markMatPropRequested(), Material::Material(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), NEML2ModelExecutor::meshChanged(), MeshGenerator::meshPropertyPrefix(), MooseBase::messagePrefix(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMScalarQuadratureFunction::MFEMScalarQuadratureFunction(), MFEMTransient::MFEMTransient(), MFEMVectorQuadratureFunction::MFEMVectorQuadratureFunction(), OutputWarehouse::mooseConsole(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< T >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NEML2PreKernel::NEML2PreKernel(), NodalDamper::NodalDamper(), MooseLinearVariableFV< OutputType >::nodalError(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), MeshGenerator::Comparator::operator()(), DOFMapOutput::output(), ProgressOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), MaterialOutputAction::outputHelper(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), Exodus::outputPostprocessors(), Nemesis::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), SolutionInvalidInterface::paramWarning(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseFunction::PiecewiseFunction(), PointInUnionCheckUO::PointInUnionCheckUO(), MooseApp::possiblyLoadRestartableMetaData(), MFEMExecutedObject::postprocessorDependencyKey(), PhysicsBase::prefix(), MooseMesh::prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), FEProblemBase::projectInitialConditionOnCustomRange(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), FEProblemBase::registerRandomInterface(), MooseApp::registerRestartableDataMapName(), MooseApp::registerRestartableNameWithFilter(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), FEProblemBase::setAuxKernelParamsAndLog(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), FEProblemBase::setPostprocessorValueByName(), FEProblemBase::setResidualObjectParamsAndLog(), MooseMesh::setSubdomainName(), MooseMesh::setSubdomainName(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), Split::setup(), TransientMultiApp::setupApp(), MoveNodesByParsedExpressionModifier::setupNodalOutputVariables(), NEML2Action::setupOutputMappings(), 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(), SumPostprocessor::SumPostprocessor(), MFEMPostprocessor::suppliedPostprocessorName(), MFEMVectorPostprocessor::suppliedVectorPostprocessorName(), BoundaryMeshBuilder::surfaceElementSet(), NEML2FEInterpolation::syncWithMainThread(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< OutputType >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), MultiAppMFEMCopyTransfer::transferVariables(), MultiAppMFEMShapeEvaluationTransfer::transferVariables(), TransientMultiApp::TransientMultiApp(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVQpFluxBC::uOnGhost(), FVQpFluxBC::uOnUSub(), UserObjectBase::UserObjectBase(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), MeshInfo::validParams(), MFEMExecutedObject::variableDependencyKey(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), MFEMExecutedObject::vectorPostprocessorDependencyKey(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and MooseApp::writeRestartableMetaData().

needGhostGhostedBoundaries()

void MooseMesh::needGhostGhostedBoundaries ( bool  needghost )

inlineinherited

Whether or not we want to ghost ghosted boundaries.

Definition at line 624 of file MooseMesh.h.

{ _need_ghost_ghosted_boundaries = needghost; }

Referenced by DistributedRectilinearMeshGenerator::generate().

needsPrepareForUse()

void MooseMesh::needsPrepareForUse ( )

inherited

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

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

Definition at line 3274 of file MooseMesh.C.

{
  prepared(false);
}

needsRemoteElemDeletion() [1/2]

bool MooseMesh::needsRemoteElemDeletion ( ) const

inlineinherited

Whether we need to delete remote elements.

Definition at line 1224 of file MooseMesh.h.

{ return _need_delete; }

needsRemoteElemDeletion() [2/2]

void MooseMesh::needsRemoteElemDeletion ( bool  need_delete )

inlineinherited

Set whether we need to delete remote elements.

Definition at line 1219 of file MooseMesh.h.

{ _need_delete = need_delete; }

nElem()

dof_id_type MooseMesh::nElem ( ) const

virtualinherited

Definition at line 3190 of file MooseMesh.C.

{
  return getMesh().n_elem();
}

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

nFace()

unsigned int MooseMesh::nFace ( ) const

inlineinherited

accessors for the FaceInfo objects

Definition at line 1302 of file MooseMesh.h.

{ return _face_info.size(); }

nLocalNodes()

virtual dof_id_type MooseMesh::nLocalNodes ( ) const

inlinevirtualinherited

Definition at line 336 of file MooseMesh.h.

{ return _mesh->n_local_nodes(); }

nNodes()

dof_id_type MooseMesh::nNodes ( ) const

virtualinherited

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

Definition at line 3184 of file MooseMesh.C.

{
  return getMesh().n_nodes();
}

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

node() [1/2]

Node & MooseMesh::node ( const dof_id_type  i )

virtualinherited

Definition at line 837 of file MooseMesh.C.

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

node() [2/2]

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

virtualinherited

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

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

Definition at line 830 of file MooseMesh.C.

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

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

nodePtr() [1/2]

Node * MooseMesh::nodePtr ( const dof_id_type  i )

virtualinherited

Definition at line 864 of file MooseMesh.C.

{
  return &nodeRef(i);
}

nodePtr() [2/2]

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

virtualinherited

Definition at line 858 of file MooseMesh.C.

{
  return &nodeRef(i);
}

Referenced by ElementSubdomainModifierBase::reinitializedNodeRange().

nodeRef() [1/2]

Node & MooseMesh::nodeRef ( const dof_id_type  i )

virtualinherited

Definition at line 852 of file MooseMesh.C.

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

nodeRef() [2/2]

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

virtualinherited

Definition at line 844 of file MooseMesh.C.

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

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

nodeSetNodes()

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

inlineinherited

Returns

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

Definition at line 2359 of file MooseMesh.h.

{
  return _node_set_nodes;
}

nodeToElemMap()

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

inherited

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

Definition at line 1239 of file MooseMesh.C.

{
  return internalNodeToElemMap();
}

Referenced by MultiAppGeneralFieldFunctorTransfer::buildKDTrees(), NodalPatchRecovery::compute(), NodalPatchRecoveryAuxBase::computeValue(), ProjectionAux::computeValue(), PenetrationLocator::detectPenetration(), DMMooseGetEmbedding_Private(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), NearestNodeLocator::findNodes(), ElementSubdomainModifierBase::findReinitializedElemsAndNodes(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), ElementSubdomainModifierBase::gatherPatchElements(), NodePositions::initialize(), ActivateElementsUserObjectBase::isNewlyActivated(), LinearNodalConstraint::LinearNodalConstraint(), ElementSubdomainModifierBase::nodeIsNewlyReinitialized(), GhostAllPointNeighbors::operator()(), GhostHigherDLowerDPointNeighbors::operator()(), RandomData::updateGenerators(), and NearestNodeLocator::updatePatch().

nPartitions()

virtual unsigned int MooseMesh::nPartitions ( ) const

inlinevirtualinherited

Definition at line 341 of file MooseMesh.h.

{ return _mesh->n_partitions(); }

nSubdomains()

virtual SubdomainID MooseMesh::nSubdomains ( ) const

inlinevirtualinherited

Reimplemented in MFEMMesh.

Definition at line 340 of file MooseMesh.h.

{ return _mesh->n_subdomains(); }

onMeshChanged()

void MooseMesh::onMeshChanged ( )

virtualinherited

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

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

Definition at line 917 of file MooseMesh.C.

{
}

Referenced by MooseMesh::meshChanged().

operator const libMesh::MeshBase &()

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

inherited

Definition at line 3548 of file MooseMesh.C.

{ return getMesh(); }

operator libMesh::MeshBase &()

MooseMesh::operator libMesh::MeshBase & ( )

inherited

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

Definition at line 3546 of file MooseMesh.C.

{ return getMesh(); }

ownedElemInfoBegin()

MooseMesh::elem_info_iterator MooseMesh::ownedElemInfoBegin ( )

inherited

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

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

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

ownedElemInfoEnd()

MooseMesh::elem_info_iterator MooseMesh::ownedElemInfoEnd ( )

inherited

Definition at line 1529 of file MooseMesh.C.

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

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

ownedFaceInfoBegin()

MooseMesh::face_info_iterator MooseMesh::ownedFaceInfoBegin ( )

inherited

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

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

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

ownedFaceInfoEnd()

MooseMesh::face_info_iterator MooseMesh::ownedFaceInfoEnd ( )

inherited

Definition at line 1512 of file MooseMesh.C.

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

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

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

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), CommonOutputAction::act(), SetupDebugAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayCoupledForce::ArrayCoupledForce(), 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(), BoundaryIntegralValueConstraint::BoundaryIntegralValueConstraint(), BoundaryLinearFVFluxIntegral::BoundaryLinearFVFluxIntegral(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), MFEMFESpaceHierarchy::buildHierarchy(), MFEMMesh::buildMesh(), MFEMGeometricMultigridSolver::BuildMultigrid(), TimeSequenceStepperBase::buildSequence(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), checkComponent(), Moose::Kokkos::ParsedObjectBase::checkDuplicateSymbols(), SamplerBase::checkForStandardFieldVariableType(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentJunction::ComponentJunction(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), MultiAppGeneralFieldTransfer::correctSolutionVectorValues(), 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(), EigenProblemSolve::EigenProblemSolve(), ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementGenerator::ElementGenerator(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ElementNormalAux::ElementNormalAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), FunctorNodalCorrector::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), 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(), FunctorNodalCorrector::FunctorNodalCorrector(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AddMetaDataGenerator::generate(), AdvancedExtruderGenerator::generate(), BlockDeletionGenerator::generate(), BlockToMeshConverterGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryDeletionGenerator::generate(), BoundaryElementConversionGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), BreakMeshByElementGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CoarsenBlockGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), CombinerGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), ElementsToTetrahedronsConverter::generate(), ExtraNodesetGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ManifoldSubdomainGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), PlaneIDMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), StackGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), SurfaceSubdomainsDelaunayRemesher::generate(), UniqueExtraIDMeshGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), BoundaryLayerUtils::generateOffsetPolyline(), 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(), AddPeriodicBCAction::getVariables(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MFEMTransient::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), SolutionIC::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), ElementSubdomainModifierBase::initialSetup(), MFEMScalarCoefficientPointValueSampler::initialSetup(), FullSolveMultiApp::initialSetup(), JSONOutput::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeneralFieldKDTreeTransferBase::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), PointInPolyhedronCheckUO::initialSetup(), HistogramVectorPostprocessor::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(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatReactionTempl< is_ad >::MatReactionTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MeshInfo::MeshInfo(), MFEMComplexSumAux::MFEMComplexSumAux(), MFEMFunctorMaterial::MFEMFunctorMaterial(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMMultiAppTransfer::MFEMMultiAppTransfer(), MFEMNDtoRTAux::MFEMNDtoRTAux(), MFEMSumAux::MFEMSumAux(), MFEMVariable::MFEMVariable(), MooseLinearVariableFV< OutputType >::MooseLinearVariableFV(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), 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(), NEML2PreKernel::NEML2PreKernel(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), NumDOFs::NumDOFs(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), ParsedVectorRealReductionReporter::ParsedVectorRealReductionReporter(), ParsedVectorReporter::ParsedVectorReporter(), ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointInPolyhedronBaseUO::PointInPolyhedronBaseUO(), PointInSignedFunctionCheckUO::PointInSignedFunctionCheckUO(), PointInUnionCheckUO::PointInUnionCheckUO(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), RankTwoTensorFromComponentProperties::RankTwoTensorFromComponentProperties(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusIIOrNemesis(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), CylinderComponent::setupComponent(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupInputMappings(), MultiSystemSolveObject::setupMultiSystemFixedPointRelaxationFactors(), MoveNodesByParsedExpressionModifier::setupNodalOutputVariables(), NEML2Action::setupParameterDerivativeMappings(), NEML2Action::setupParameterMappings(), SetupQuadratureAction::SetupQuadratureAction(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), CylinderComponent::translation(), MeshTriangulationUtils::triangulateWithDelaunay(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), UserObjectBase::UserObjectBase(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), MFEMProblem::validateVariableNumericType(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

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.

{ return _pars; }

Referenced by AddActionComponentAction::act(), CommonOutputAction::act(), CSGOnlyAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), SplitMeshAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxKernel(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), MFEMProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addFunctorMaterial(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVGradientMethod(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addFVKernel(), MFEMProblem::addGridFunction(), FEProblemBase::addHDGKernel(), MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), FEProblemBase::addIndicator(), MFEMProblem::addIndicator(), FEProblemBase::addInitialCondition(), MFEMProblem::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), FEProblemBase::addKernel(), MFEMProblem::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), MFEMProblem::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::addMFEMProblemComposer(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), MFEMProblem::addQuadratureFunction(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), MFEMProblem::addSubMesh(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), MFEMProblem::addTransfer(), FEProblemBase::addUserObject(), DisplacedProblem::addVariable(), MFEMEigenproblem::addVariable(), MFEMProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), MFEMProblem::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), assemble_l2(), Moose::assemble_matrix(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), MeshGenerator::checkGetMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), Moose::compute_bounds(), Moose::compute_jacobian(), Moose::compute_nearnullspace(), Moose::compute_nullspace(), Moose::compute_postcheck(), Moose::compute_transpose_nullspace(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), MooseMeshUtils::copyIntoMesh(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), EigenProblemSolve::EigenProblemSolve(), 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(), Moose::PeriodicBCHelper::getParams(), 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(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< T >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), ConsoleUtils::outputLegacyInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), 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(), FEProblemBase::setInputParametersFEProblem(), FEProblem::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(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

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

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

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

paramWarning() [1/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 464 of file MooseBase.h.

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

paramWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
                                            param + "'");
  }

Referenced by GridPartitioner::_do_partition(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), MooseMeshUtils::copyIntoMesh(), CylindricalGridDivision::CylindricalGridDivision(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ReferenceResidualConvergence::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), MultiAppTransfer::MultiAppTransfer(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

partitionerName()

const MooseEnum & MooseMesh::partitionerName ( ) const

inlineinherited

Definition at line 1161 of file MooseMesh.h.

{ return _partitioner_name; }

partitioning()

MooseEnum MooseMesh::partitioning ( )

staticinherited

returns MooseMesh partitioning options so other classes can use it

Definition at line 4027 of file MooseMesh.C.

{
  MooseEnum partitioning(
      "default=-3 metis=-2 parmetis=-1 linear=0 centroid hilbert_sfc morton_sfc custom", "default");
  return partitioning;
}

Referenced by MooseMesh::partitioning(), and MooseMesh::validParams().

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

possiblyRebuildNodeToElemMap()

bool MooseMesh::possiblyRebuildNodeToElemMap ( )

inherited

rebuild the node to element map if it's been requsted previously

Returns

Whether the map was re-built, or equivalently whether the map had been requested previously

Definition at line 606 of file MooseMesh.C.

{
  // *Rebuild* the node to element map. I emphasize rebuild because if it has not been built
  // previously we won't do anything
  if (!_node_to_elem_map_built)
  {
    mooseAssert(_node_to_elem_map.empty(), "If it hasn't been built, it better well be empty");
    return false;
  }
 
  _node_to_elem_map.clear();
  _node_to_elem_map_built = false;
  internalNodeToElemMap();
  return true;
}

Referenced by MooseMesh::update().

prepare() [1/2]

void MooseMesh::prepare ( )

inherited

Calls prepare_for_use() if the underlying MeshBase object isn't prepared, then communicates various boundary information on parallel meshes.

Also calls update() internally.

Definition at line 397 of file MooseMesh.C.

{
  TIME_SECTION("prepare", 2, "Preparing Mesh", true);
 
  parallel_object_only();
 
  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->is_prepared())
  {
    _mesh->complete_preparation();
    _moose_mesh_prepared = false;
  }
 
  if (_moose_mesh_prepared)
    return;
 
  // 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, true);
    }
  }
  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, true);
    }
  }
 
  // 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;
}

Referenced by MooseApp::restore(), and TransientMultiApp::setupApp().

prepare() [2/2]

void MooseMesh::prepare ( const MeshBase *  mesh_to_clone )

inherited

Deprecated method; mesh_to_clone is no longer supported and must be null.

Use the no-argument prepare() instead.

Parameters

mesh_to_clone

Must be null; mesh cloning is handled elsewhere now

prepared() [1/2]

bool MooseMesh::prepared ( ) const

inherited

Setter/getter for whether the mesh is prepared.

Definition at line 3246 of file MooseMesh.C.

{
  return _mesh->is_prepared() && _moose_mesh_prepared;
}

Referenced by MooseMesh::needsPrepareForUse(), AnnularMesh::prepared(), and GeneratedMesh::prepared().

prepared() [2/2]

void GeneratedMesh::prepared ( bool  state )

overridevirtualinherited

Reimplemented from MooseMesh.

Definition at line 104 of file GeneratedMesh.C.

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

printInfo()

void MooseMesh::printInfo ( std::ostream &  os = libMesh::out, const unsigned int  verbosity = 0  ) const

inherited

Calls print_info() on the underlying Mesh.

Definition at line 3571 of file MooseMesh.C.

{
  os << '\n';
  getMesh().print_info(os, verbosity);
  os << std::flush;
}

Referenced by Adaptivity::adaptMesh().

queryElemPtr() [1/2]

Elem * MooseMesh::queryElemPtr ( const dof_id_type  i )

virtualinherited

Definition at line 3234 of file MooseMesh.C.

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

Referenced by PointSamplerBase::getLocalElemContainingPoint(), NodePositions::initialize(), ElementalVariableValue::initialSetup(), DisplacedProblem::reinitElemPhys(), FEProblemBase::reinitElemPhys(), DisplacedProblem::reinitNeighborPhys(), FEProblemBase::reinitNeighborPhys(), DisplacedProblem::reinitNeighborPhys(), and FEProblemBase::reinitNeighborPhys().

queryElemPtr() [2/2]

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

virtualinherited

Definition at line 3240 of file MooseMesh.C.

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

queryNodePtr() [1/2]

Node * MooseMesh::queryNodePtr ( const dof_id_type  i )

virtualinherited

Definition at line 886 of file MooseMesh.C.

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

queryNodePtr() [2/2]

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

virtualinherited

Definition at line 870 of file MooseMesh.C.

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

Referenced by NonlinearSystemBase::findImplicitGeometricCouplingEntries(), NodePositions::initialize(), MooseMesh::nodeRef(), EqualValueBoundaryConstraint::populateSecondaryNodes(), and MooseMesh::queryNodePtr().

queryParam()

template<typename T >

const T * MooseBase::queryParam ( const std::string &  name ) const

inherited

Query a parameter for the object.

If a parameter of the given name and type does not exist or 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 413 of file MooseBase.h.

{
  return _pars.queryParam<T>(name);
}

Referenced by MFEMExecutedObject::getRequestedItems(), and MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver().

queryPeriodicDimensions() [1/2]

const std::array< bool, 3 > & MooseMesh::queryPeriodicDimensions ( const MooseVariableBase &  var ) const

inherited

Query the translated periodic dimension flags for the given variable.

\

Query here means that it will not error if a variable isn't found to be periodic, instead the default value is returned (false for each dimension)

Parameters

var	- The variable

Definition at line 2250 of file MooseMesh.C.

{
  return queryPeriodicDimensions(var.sys().number(), var.number());
}

queryPeriodicDimensions() [2/2]

const std::array< bool, 3 > & MooseMesh::queryPeriodicDimensions ( const unsigned int  sys_num, const unsigned int  var_num  ) const

inherited

Query the translated periodic dimension flags for the given variable on the given system.

Query here means that it will not error if a variable isn't found to be periodic, instead the default value is returned (false for each dimension)

Parameters

sys_num	- The number of the system the variable is on
var_num	- The variable number

Definition at line 2241 of file MooseMesh.C.

{
  const auto key = std::make_pair(sys_num, var_num);
  if (const auto it = _periodic_dim.find(key); it != _periodic_dim.end())
    return it->second;
  return periodic_dim_default;
}

Referenced by MooseMesh::isTranslatedPeriodic(), MooseMesh::minPeriodicVector(), and MooseMesh::queryPeriodicDimensions().

refinedElementRange()

ConstElemPointerRange * MooseMesh::refinedElementRange ( ) const

inherited

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

Returns

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

Definition at line 940 of file MooseMesh.C.

{
  return _refined_elements.get();
}

Referenced by FEProblemBase::meshChanged().

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

registerRestartableDataOnApp()

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

privateinherited

Helper function for actually registering the restartable data.

Definition at line 63 of file Restartable.C.

{
  return _restartable_app.registerRestartableData(
      std::move(data), tid, _restartable_read_only, _metaname);
}

Referenced by Restartable::declareRestartableDataHelper().

registerRestartableNameWithFilterOnApp()

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

privateinherited

Helper function for actually registering the restartable data.

Definition at line 71 of file Restartable.C.

{
  _restartable_app.registerRestartableNameWithFilter(name, filter);
}

Referenced by Restartable::declareRecoverableData().

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

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

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

safeClone()

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

overridevirtual

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

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

Reimplemented from GeneratedMesh.

Definition at line 62 of file ImageMesh.C.

{
  return _app.getFactory().copyConstruct(*this);
}

setAxisymmetricCoordAxis()

void MooseMesh::setAxisymmetricCoordAxis ( const MooseEnum &  rz_coord_axis )

inherited

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

{
  _rz_coord_axis = rz_coord_axis;
 
  updateCoordTransform();
}

Referenced by FEProblemBase::setAxisymmetricCoordAxis().

setBoundaryName()

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

inherited

This method sets the boundary name of the boundary based on the id parameter.

Definition at line 1776 of file MooseMesh.C.

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

Referenced by MooseMesh::prepare(), and ActivateElementsUserObjectBase::setNewBoundayName().

setBoundaryToNormalMap() [1/2]

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

inherited

Definition at line 3317 of file MooseMesh.C.

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

setBoundaryToNormalMap() [2/2]

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

inherited

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

Definition at line 3310 of file MooseMesh.C.

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

setCoordData()

void MooseMesh::setCoordData ( const MooseMesh &  other_mesh )

inherited

Set the coordinate system data to that of other_mesh.

Definition at line 4451 of file MooseMesh.C.

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

Referenced by DisplacedProblem::DisplacedProblem().

setCoordSystem()

void MooseMesh::setCoordSystem ( const std::vector< SubdomainName > &  blocks, const MultiMooseEnum &  coord_sys  )

inherited

Set the coordinate system for the provided blocks to coord_sys.

Definition at line 4210 of file MooseMesh.C.

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

Referenced by MooseMesh::prepare(), and FEProblemBase::setCoordSystem().

setCustomPartitioner()

void MooseMesh::setCustomPartitioner ( libMesh::Partitioner *  partitioner )

inherited

Setter for custom partitioner.

Definition at line 3808 of file MooseMesh.C.

{
  _custom_partitioner = partitioner->clone();
  setIsCustomPartitionerRequested(true);
  if (_mesh)
    _mesh->partitioner() = _custom_partitioner->clone();
  _partitioner_name = "custom";
}

setGeneralAxisymmetricCoordAxes()

void MooseMesh::setGeneralAxisymmetricCoordAxes ( const std::vector< SubdomainName > &  blocks, const std::vector< std::pair< Point, RealVectorValue > > &  axes  )

inherited

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

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

Referenced by MooseMesh::prepare().

setGhostedBoundaryInflation()

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

inherited

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

Definition at line 3344 of file MooseMesh.C.

{
  _ghosted_boundaries_inflation = inflation;
}

setIsCustomPartitionerRequested()

void MooseMesh::setIsCustomPartitionerRequested ( bool  cpr )

inherited

Definition at line 3840 of file MooseMesh.C.

{
  _custom_partitioner_requested = cpr;
}

Referenced by MooseMesh::setCustomPartitioner().

setMeshBase()

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

inherited

Method to set the mesh_base object.

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

Definition at line 2930 of file MooseMesh.C.

{
  _mesh = std::move(mesh_base);
  _mesh->allow_remote_element_removal(_allow_remote_element_removal);
}

Referenced by ActionUnitTest::buildMinimalObjects(), and MooseObjectUnitTest::buildObjects().

setMeshBoundaryIDs()

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

inherited

Sets the set of BoundaryIDs Is called by AddAllSideSetsByNormals.

Definition at line 3304 of file MooseMesh.C.

{
  _mesh_boundary_ids = boundary_IDs;
}

setParallelType()

void MooseMesh::setParallelType ( ParallelType  parallel_type )

inlineinherited

Allow to change parallel type.

Definition at line 2318 of file MooseMesh.h.

{
  _parallel_type = parallel_type;
  determineUseDistributedMesh();
}

Referenced by MFEMMesh::buildDummyMooseMesh(), and MooseMesh::buildTypedMesh().

setPartitioner()

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

staticinherited

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

Definition at line 3749 of file MooseMesh.C.

{
  // Set the partitioner based on partitioner name
  switch (partitioner)
  {
    case -3: // default
      // We'll use the default partitioner, but notify the user of which one is being used...
      if (use_distributed_mesh)
        partitioner = "parmetis";
      else
        partitioner = "metis";
      break;
 
    // No need to explicitily create the metis or parmetis partitioners,
    // They are the default for serial and parallel mesh respectively
    case -2: // metis
    case -1: // parmetis
      break;
 
    case 0: // linear
      mesh_base.partitioner().reset(new 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;
  }
}

Referenced by MooseMesh::setPartitionerHelper().

setPartitionerHelper()

void MooseMesh::setPartitionerHelper ( MeshBase *  mesh = nullptr )

protectedinherited

Definition at line 3737 of file MooseMesh.C.

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

Referenced by MooseMesh::buildTypedMesh().

setPatchUpdateStrategy()

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

inherited

Set the patch size update strategy.

Definition at line 3516 of file MooseMesh.C.

{
  _patch_update_strategy = patch_update_strategy;
}

setSubdomainName() [1/2]

void MooseMesh::setSubdomainName ( MeshBase &  mesh, SubdomainID  subdomain_id, const SubdomainName &  name, const bool  synchronous = false  )

staticinherited

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

Definition at line 1749 of file MooseMesh.C.

{
  mooseAssert(name != "ANY_BLOCK_ID", "Cannot set subdomain name to 'ANY_BLOCK_ID'");
  mesh.set_subdomain_name(subdomain_id, name, synchronous);
}

setSubdomainName() [2/2]

void MooseMesh::setSubdomainName ( SubdomainID  subdomain_id, const SubdomainName &  name, const bool  synchronous = false  )

inherited

This method sets the name for subdomain_id to name.

Definition at line 1741 of file MooseMesh.C.

{
  setSubdomainName(getMesh(), subdomain_id, name, synchronous);
}

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

setUniformRefineLevel()

void MooseMesh::setUniformRefineLevel ( unsigned int  level, bool  deletion = true  )

inherited

Set uniform refinement level.

Definition at line 3331 of file MooseMesh.C.

{
  _uniform_refine_level = level;
  _skip_deletion_repartition_after_refine = deletion;
}

setupFiniteVolumeMeshData()

void MooseMesh::setupFiniteVolumeMeshData ( ) const

inherited

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

{
  buildFiniteVolumeInfo();
  computeFiniteVolumeCoords();
  cacheFaceInfoVariableOwnership();
  cacheFVElementalDoFs();
}

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

sideWithBoundaryID()

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

inherited

Calls BoundaryInfo::side_with_boundary_id().

Definition at line 3130 of file MooseMesh.C.

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

skipDeletionRepartitionAfterRefine()

bool MooseMesh::skipDeletionRepartitionAfterRefine ( ) const

inlineinherited

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

{
  return _skip_deletion_repartition_after_refine;
}

skipNoncriticalPartitioning()

bool MooseMesh::skipNoncriticalPartitioning ( ) const

virtualinherited

Definition at line 4531 of file MooseMesh.C.

{
  return _mesh->skip_noncritical_partitioning();
}

skipPartitioning()

virtual bool MooseMesh::skipPartitioning ( ) const

inlinevirtualinherited

Definition at line 342 of file MooseMesh.h.

{ return _mesh->skip_partitioning(); }

skipRefineWhenUseSplit()

bool MooseMesh::skipRefineWhenUseSplit ( ) const

inlineinherited

Whether or not skip uniform refinements when using a pre-split mesh.

Definition at line 593 of file MooseMesh.h.

{ return _skip_refine_when_use_split; }

spatialDimension()

virtual unsigned int MooseMesh::spatialDimension ( ) const

inlinevirtualinherited

Returns MeshBase::spatial_dimension.

Reimplemented in MFEMMesh.

Definition at line 206 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 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

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

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.

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

Referenced by CreateProblemDefaultAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), SetupDebugAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addConvergence(), FEProblemBase::addDistribution(), DistributedRectilinearMeshGenerator::addElement(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMProblemComposer(), FEProblemBase::addObject(), DistributedRectilinearMeshGenerator::addPoint(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MFEMProblem::addQuadratureFunction(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addVectorPostprocessor(), SubProblem::addVectorTag(), DisplacedProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), AuxKernelBase::AuxKernelBase(), FEProblemBase::backupMultiApps(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BoundaryPreservedMarker::BoundaryPreservedMarker(), DistributedRectilinearMeshGenerator::buildCube(), MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildLowerDMesh(), MooseMesh::buildPRefinementAndCoarseningMaps(), PhysicsBase::checkComponentType(), MeshGenerator::checkGetMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), FEProblemBase::checkUserObjectNameCollision(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), MeshInfo::CombinedInfos< ElemInfoMap, ElemInfoItems >::CombinedInfos(), ElemElemConstraint::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), DGKernel::computeElemNeighJacobian(), ADDGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ADDGKernel::computeElemNeighResidual(), ArrayDGLowerDKernel::computeLowerDJacobian(), DGLowerDKernel::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDJacobian(), LowerDIntegratedBC::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayHFEMDirichletBC::computeLowerDQpJacobian(), HFEMDirichletBC::computeLowerDQpJacobian(), ArrayHFEMDiffusion::computeLowerDQpJacobian(), HFEMDiffusion::computeLowerDQpJacobian(), ArrayLowerDIntegratedBC::computeLowerDQpOffDiagJacobian(), ArrayDGLowerDKernel::computeLowerDQpOffDiagJacobian(), ArrayHFEMDirichletBC::computeLowerDQpOffDiagJacobian(), HFEMDirichletBC::computeLowerDQpOffDiagJacobian(), FEProblemBase::computeMultiAppsDT(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ADDGKernel::computeOffDiagElemNeighJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), DGConvection::computeQpJacobian(), ArrayDGDiffusion::computeQpJacobian(), DGDiffusion::computeQpJacobian(), InterfaceDiffusion::computeQpJacobian(), InterfaceReaction::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), HFEMTestJump::computeQpOffDiagJacobian(), HFEMTrialJump::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), TiedValueConstraint::computeQpResidual(), DGConvection::computeQpResidual(), ADDGAdvection::computeQpResidual(), ADDGDiffusion::computeQpResidual(), DGDiffusion::computeQpResidual(), HFEMDiffusion::computeQpResidual(), HFEMTestJump::computeQpResidual(), HFEMTrialJump::computeQpResidual(), ADMatInterfaceReaction::computeQpResidual(), InterfaceDiffusion::computeQpResidual(), InterfaceReaction::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), ArrayHFEMDiffusion::computeQpResidual(), FEProblemBase::computeSystems(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::createQRules(), DisplacedProblem::createQRules(), MooseApp::createRecoverablePerfGraph(), MeshGenerator::declareMeshProperty(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::execMultiAppTransfers(), SteadyBase::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), FEProblemBase::finishMultiAppStep(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), Boundary2DDelaunayGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MultiAppTransfer::getAppInfo(), TransfiniteMeshGenerator::getEdge(), ElementGenerator::getElemType(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), MaterialOutputAction::getParams(), ReporterData::getReporterInfo(), MooseServer::getSyntaxMetadata(), FEProblemBase::getTransfers(), FEProblemBase::getUOQuery(), SubProblem::getVectorTags(), DisplacedProblem::getVectorTags(), EqualValueBoundaryConstraint::ghostPrimary(), CommonOutputAction::hasConsole(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), NEML2Action::inferMOOSEIOType(), AdvancedOutput::initAvailableLists(), FunctorPositions::initialize(), FunctorTimes::initialize(), LinearFVAdvection::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVDiffusion::initialSetup(), MultiAppConservativeTransfer::initialSetup(), ArrayDGDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), FEProblemBase::logAdd(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MooseObject::MooseObject(), SubProblem::numVectorTags(), DisplacedProblem::numVectorTags(), AdvancedOutput::output(), Console::output(), ConsoleUtils::outputExecutionInformation(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), MooseServer::parseDocumentForDiagnostics(), PointInUnionCheckUO::PointInUnionCheckUO(), MooseMesh::prepare(), ProjectedStatefulMaterialStorageAction::processProperty(), MooseApp::recursivelyCreateExecutors(), SolutionInvalidInterface::registerInvalidSolutionInternal(), FEProblemBase::restoreMultiApps(), MeshRepairGenerator::separateSubdomainsByElementType(), FEProblemBase::setCoupling(), MooseApp::setupOptions(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), Reporter::store(), MooseBase::typeAndName(), AuxScalarKernel::uOld(), ScalarKernelBase::uOld(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), UserObjectInterface::userObjectType(), and AdvancedOutput::wantOutput().

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.

{
  return type() + std::string(" \"") + name() + std::string("\"");
}

Referenced by MaterialPropertyStorage::addProperty(), FEProblemBase::checkUserObjectNameCollision(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< T >::finalize(), ReporterData::getReporterInfo(), MFEMSamplerBase::initialSetup(), MFEMVariableSamplerBase::initialSetup(), WebServerControl::outputMessage(), and Action::timedAct().

uniformRefineLevel()

unsigned int MooseMesh::uniformRefineLevel ( ) const

inherited

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

Definition at line 3325 of file MooseMesh.C.

{
  return _uniform_refine_level;
}

Referenced by Adaptivity::uniformRefineWithProjection().

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.

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

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

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

inherited

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

Definition at line 623 of file MooseMesh.C.

{
  TIME_SECTION("update", 3, "Updating Mesh", true);
 
  // Rebuild the boundary conditions
  buildNodeListFromSideList();
 
  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);
 
  computeMaxPerElemAndSide();
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (_app.getExecutioner() && _app.feProblem().initialized() &&
      _app.feProblem().hasKokkosObjects())
    _kokkos_mesh->update();
#endif
 
  _finite_volume_info_dirty = true;
 
  possiblyRebuildNodeToElemMap();
}

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

updateActiveSemiLocalNodeRange()

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

inherited

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

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

Definition at line 960 of file MooseMesh.C.

{
  TIME_SECTION("updateActiveSemiLocalNodeRange", 5, "Updating ActiveSemiLocalNode Range");
 
  _semilocal_node_list.clear();
 
  // First add the nodes connected to local elems
  const 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());
}

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

updateCoordTransform()

void MooseMesh::updateCoordTransform ( )

privateinherited

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

{
  if (!_coord_transform)
    _coord_transform = std::make_unique<MooseAppCoordTransform>(*this);
  else
    _coord_transform->setCoordinateSystem(*this);
}

Referenced by MooseMesh::MooseMesh(), MooseMesh::setAxisymmetricCoordAxis(), MooseMesh::setCoordSystem(), and MooseMesh::setGeneralAxisymmetricCoordAxes().

usingGeneralAxisymmetricCoordAxes()

bool MooseMesh::usingGeneralAxisymmetricCoordAxes ( ) const

inherited

Returns true if general axisymmetric coordinate axes are being used.

Definition at line 4408 of file MooseMesh.C.

{
  return _subdomain_id_to_rz_coord_axis.size() > 0;
}

Referenced by MooseMesh::getAxisymmetricRadialCoord(), and MooseMesh::getUniqueCoordSystem().

validParams()

InputParameters ImageMesh::validParams ( )

static

Definition at line 26 of file ImageMesh.C.

{
  InputParameters params = GeneratedMesh::validParams();
  params += FileRangeBuilder::validParams();
  params.addClassDescription("Generated mesh with the aspect ratio of a given image stack.");
 
  // Add ImageMesh-specific params
  params.addParam<bool>(
      "scale_to_one", true, "Whether or not to scale the image so its max dimension is 1");
  params.addRangeCheckedParam<Real>("cells_per_pixel",
                                    1.0,
                                    "cells_per_pixel<=1.0",
                                    "The number of mesh cells per pixel, must be <=1 ");
 
  return params;
}

writeRecoveryFiles()

std::vector< std::filesystem::path > MooseMesh::writeRecoveryFiles ( const std::filesystem::path &  file_base )

virtualinherited

Write the mesh files needed for recovery/checkpointing.

The base implementation writes the libMesh checkpoint mesh. Derived classes may extend this to write additional backend-specific files.

Returns

The additional backend-specific files written by the derived class.

Reimplemented in MFEMMesh.

Definition at line 2986 of file MooseMesh.C.

{
  libMesh::CheckpointIO io(getMesh(), false);
  io.write(file_base);
  return {};
}

Referenced by Checkpoint::output(), and MFEMMesh::writeRecoveryFiles().

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_node_range

std::unique_ptr<libMesh::NodeRange> MooseMesh::_active_node_range

protectedinherited

Definition at line 1663 of file MooseMesh.h.

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

_active_semilocal_node_range

std::unique_ptr<SemiLocalNodeRange> MooseMesh::_active_semilocal_node_range

protectedinherited

Ranges for use with threading, cached so they don't have to get rebuilt all the time (which takes time).

Definition at line 1662 of file MooseMesh.h.

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

_all_face_info

std::vector<FaceInfo> MooseMesh::_all_face_info

mutableprivateinherited

FaceInfo object storing information for face based loops.

This container holds all the FaceInfo objects accessible from this process

Definition at line 1774 of file MooseMesh.h.

Referenced by MooseMesh::allFaceInfo(), MooseMesh::buildFiniteVolumeInfo(), MooseMesh::cacheFaceInfoVariableOwnership(), and MooseMesh::computeFiniteVolumeCoords().

_allow_recovery

bool MooseMesh::_allow_recovery

privateinherited

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

Definition at line 1977 of file MooseMesh.h.

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

_allow_remote_element_removal

bool MooseMesh::_allow_remote_element_removal

privateinherited

Whether to allow removal of remote elements.

Definition at line 1990 of file MooseMesh.h.

Referenced by MooseMesh::allowRemoteElementRemoval(), MooseMesh::allowRemoteElementRemoval(), MooseMesh::buildTypedMesh(), MooseMesh::deleteRemoteElements(), and MooseMesh::setMeshBase().

_app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), FEProblemBase::acceptInvalidSolution(), FEProblemBase::addAnyRedistributers(), MeshGenerator::addChildMeshGenerator(), FEProblemBase::addMaterialHelper(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addOutput(), MeshGenerator::addParentMeshGenerator(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), FileMesh::buildMesh(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), DefaultNonlinearConvergence::checkConvergence(), MeshGenerator::checkGetMesh(), FEProblemBase::checkICRestartError(), FEProblemBase::checkProblemIntegrity(), LibmeshPartitioner::clone(), BlockWeightedPartitioner::clone(), CopyMeshPartitioner::clone(), GridPartitioner::clone(), HierarchicalGridPartitioner::clone(), PetscExternalPartitioner::clone(), RandomPartitioner::clone(), SingleRankPartitioner::clone(), ElementPointNeighborLayers::clone(), ElementSideNeighborLayers::clone(), GhostAllPointNeighbors::clone(), GhostBoundary::clone(), GhostEverything::clone(), GhostHigherDLowerDPointNeighbors::clone(), GhostLowerDElems::clone(), GhostPrimaryFace::clone(), ProxyRelationshipManager::clone(), RedistributeProperties::clone(), SampledOutput::cloneMesh(), FEProblemBase::computeJacobianSys(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualSys(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), Control::Control(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MultiApp::createApps(), FEProblemBase::customSetup(), MeshGenerator::declareMeshProperty(), MeshGenerator::declareNullMeshName(), MooseMesh::determineUseDistributedMesh(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), PIDTransientControl::execute(), Eigenvalue::execute(), InversePowerMethod::execute(), NonlinearEigen::execute(), SteadyBase::execute(), TransientBase::execute(), MFEMSteady::execute(), PseudoTimestep::execute(), IterationInfo::execute(), EigenProblem::execute(), Executioner::Executioner(), Executioner::Executioner(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), NEML2Assembly::finalize(), ChangeOverFixedPointPostprocessor::finalize(), RadialAverage::finalize(), FixedPointSolve::FixedPointSolve(), FEProblemBase::forceOutput(), FullSolveMultiApp::FullSolveMultiApp(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVAdvection::FVAdvection(), FileMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MeshGenerator::getCSGBaseByName(), FEProblemBase::getExecutor(), MeshGenerator::getMeshByName(), NumFixedPointIterations::getValue(), NumRelationshipManagers::getValue(), GhostingUserObject::GhostingUserObject(), MooseMesh::init(), Eigenvalue::init(), InversePowerMethod::init(), NonlinearEigen::init(), TransientBase::init(), MFEMMesh::init(), FEProblemBase::init(), CompositionDT::init(), SubProblem::initialSetup(), PIDTransientControl::initialSetup(), RealFunctionControl::initialSetup(), TimePeriod::initialSetup(), EigenProblemSolve::initialSetup(), FEProblemSolve::initialSetup(), Console::initialSetup(), FEProblemBase::initialSetup(), BoundaryMeshBuilder::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), EigenProblem::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), FEProblemBase::meshChanged(), MeshGenerator::MeshGenerator(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), EigenExecutionerBase::normalizeSolution(), NumFailedTimeSteps::NumFailedTimeSteps(), Checkpoint::output(), Exodus::output(), Nemesis::output(), PerfGraphOutput::output(), Tecplot::output(), MortarNodalGeometryOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), JSONOutput::outputReporters(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), Console::outputSystemInformation(), JSONOutput::outputSystemInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MultiApp::parentOutputPositionChanged(), TransientBase::preExecute(), FEProblemBase::projectSolution(), AnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), FileMesh::safeClone(), GeneratedMesh::safeClone(), safeClone(), MeshGeneratorMesh::safeClone(), PatternedMesh::safeClone(), RinglebMesh::safeClone(), SpiralAnnularMesh::safeClone(), StitchedMesh::safeClone(), TiledMesh::safeClone(), MFEMFileMesh::safeClone(), MFEMMeshGeneratorMesh::safeClone(), MultiApp::setAppOutputFileBase(), FileOutput::setFileBaseInternal(), MeshGenerator::setMeshProperty(), MeshGenerator::setMeshPropertyHelper(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), Output::setWallTimeIntervalFromCommandLineParam(), SideSetExtruderGenerator::SideSetExtruderGenerator(), SolutionInvalidityReporter::SolutionInvalidityReporter(), FixedPointSolve::solve(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::solveLinearSystem(), PetscOutput::solveSetup(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), SubProblem::timestepSetup(), PIDTransientControl::timestepSetup(), FEProblemBase::timestepSetup(), TransientBase::TransientBase(), MooseMesh::update(), NEML2FEInterpolation::updateDofMap(), NEML2FEInterpolation::updateGradPhi(), NEML2FEInterpolation::updateInterpolations(), FEProblemBase::updateMortarMesh(), NEML2FEInterpolation::updatePhi(), Console::write(), and FEProblemBase::~FEProblemBase().

_bias_x

Real GeneratedMesh::_bias_x

protectedinherited

The amount by which to bias the cells in the x,y,z directions.

Must be in the range 0.5 <= _bias_x <= 2.0. _bias_x < 1 implies cells are shrinking in the x-direction. _bias_x==1 implies no bias (original mesh unchanged). _bias_x > 1 implies cells are growing in the x-direction.

Definition at line 57 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), and GeneratedMesh::GeneratedMesh().

_bias_y

Real GeneratedMesh::_bias_y

protectedinherited

Definition at line 57 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), and GeneratedMesh::GeneratedMesh().

_bias_z

Real GeneratedMesh::_bias_z

protectedinherited

Definition at line 57 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), and GeneratedMesh::GeneratedMesh().

_block_id_mapping

std::vector<std::unordered_map<SubdomainID, std::set<dof_id_type> > > MooseMesh::_block_id_mapping

privateinherited

Unique element integer IDs for each subdomain and each extra element integers.

Definition at line 2002 of file MooseMesh.h.

Referenced by MooseMesh::buildElemIDInfo(), MooseMesh::getAllElemIDs(), and MooseMesh::getElemIDsOnBlocks().

_block_node_list

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

protectedinherited

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

Definition at line 1717 of file MooseMesh.h.

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

_bnd_elem_ids

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

protectedinherited

Map of set of elem IDs connected to each boundary.

Definition at line 1709 of file MooseMesh.h.

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

_bnd_elem_range

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

protectedinherited

Definition at line 1668 of file MooseMesh.h.

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

_bnd_elems

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

protectedinherited

array of boundary elems

Definition at line 1704 of file MooseMesh.h.

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

_bnd_node_ids

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

protectedinherited

Map of sets of node IDs in each boundary.

Definition at line 1701 of file MooseMesh.h.

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

_bnd_node_range

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

protectedinherited

Definition at line 1666 of file MooseMesh.h.

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

_bnd_nodes

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

protectedinherited

array of boundary nodes

Definition at line 1697 of file MooseMesh.h.

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

_boundary_to_normal_map

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

protectedinherited

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

Definition at line 1694 of file MooseMesh.h.

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

_bounds

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

protectedinherited

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

Definition at line 1744 of file MooseMesh.h.

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

_built_from_other_mesh

bool MooseMesh::_built_from_other_mesh = false

protectedinherited

Whether or not this mesh was built from another mesh.

Definition at line 1582 of file MooseMesh.h.

Referenced by MooseMesh::prepare().

_cells_per_pixel

const Real& ImageMesh::_cells_per_pixel

protected

A number <= 1.0 which determines the number of cells in the mesh per pixel in each direction.

Defaults to 1.0 Example: Given: Original image is 1843x1590 pixels _cells_per_pixel = 0.3 Result: Mesh has 552x477 elements

Definition at line 61 of file ImageMesh.h.

Referenced by buildMesh2D(), and buildMesh3D().

_coarsened_element_children

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

protectedinherited

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

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

Definition at line 1653 of file MooseMesh.h.

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

_coarsened_elements

std::unique_ptr<ConstElemPointerRange> MooseMesh::_coarsened_elements

protectedinherited

The elements that were just coarsened.

Definition at line 1646 of file MooseMesh.h.

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

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), FEProblemBase::adaptMesh(), Adaptivity::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::checkNonConformingFaces(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), CoarsenSurfaceMeshAlongSidesetGenerator::coarsenAlongSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::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::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::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(), FEProblemSolve::solve(), FixedPointSolve::solve(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::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

privateinherited

Whether or not to allow generation of nodesets from sidesets.

Definition at line 1980 of file MooseMesh.h.

Referenced by MooseMesh::buildNodeListFromSideList(), and MooseMesh::getConstructNodeListFromSideList().

_coord_sys

std::map<SubdomainID, Moose::CoordinateSystemType>& MooseMesh::_coord_sys

privateinherited

Type of coordinate system per subdomain.

Definition at line 2032 of file MooseMesh.h.

Referenced by MooseMesh::checkCoordinateSystems(), MooseMesh::getCoordSystem(), MooseMesh::getCoordSystem(), MooseMesh::getUniqueCoordSystem(), MooseMesh::setCoordData(), MooseMesh::setCoordSystem(), and MooseMesh::setGeneralAxisymmetricCoordAxes().

_coord_system_set

bool MooseMesh::_coord_system_set

privateinherited

Whether the coordinate system has been set.

Definition at line 2045 of file MooseMesh.h.

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

_coord_transform

std::unique_ptr<MooseAppCoordTransform> MooseMesh::_coord_transform

privateinherited

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

Definition at line 2042 of file MooseMesh.h.

Referenced by MooseMesh::coordTransform(), MooseMesh::lengthUnit(), and MooseMesh::updateCoordTransform().

_custom_partitioner

std::unique_ptr<libMesh::Partitioner> MooseMesh::_custom_partitioner

protectedinherited

The custom partitioner.

Definition at line 1608 of file MooseMesh.h.

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

_custom_partitioner_requested

bool MooseMesh::_custom_partitioner_requested

protectedinherited

Definition at line 1609 of file MooseMesh.h.

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

_dim

MooseEnum GeneratedMesh::_dim

protectedinherited

The dimension of the mesh.

Definition at line 37 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), GeneratedMesh::getMaxInDimension(), and GeneratedMesh::getMinInDimension().

_dims_may_have_changed

bool GeneratedMesh::_dims_may_have_changed

protectedinherited

Boolean to indicate that dimensions may have changed.

Definition at line 60 of file GeneratedMesh.h.

Referenced by GeneratedMesh::getMaxInDimension(), GeneratedMesh::getMinInDimension(), and GeneratedMesh::prepared().

_displace_node_list_by_side_list

bool MooseMesh::_displace_node_list_by_side_list

privateinherited

Whether or not to displace unrelated nodesets by nodesets constructed from sidesets.

Definition at line 1984 of file MooseMesh.h.

Referenced by MooseMesh::buildNodeListFromSideList(), and MooseMesh::getDisplaceNodeListBySideList().

_distribution_overridden

bool MooseMesh::_distribution_overridden

protectedinherited

Definition at line 1592 of file MooseMesh.h.

_doing_p_refinement

bool MooseMesh::_doing_p_refinement

privateinherited

Whether we have p-refinement (whether exclusively p- or hp-refinement)

Definition at line 2051 of file MooseMesh.h.

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

_elem_info

std::vector<const ElemInfo *> MooseMesh::_elem_info

mutableprivateinherited

Holds only those ElemInfo objects that have processor_id equal to this process's id, e.g.

the local ElemInfo objects

Definition at line 1770 of file MooseMesh.h.

Referenced by MooseMesh::buildFiniteVolumeInfo(), MooseMesh::elemInfoVector(), MooseMesh::ownedElemInfoBegin(), and MooseMesh::ownedElemInfoEnd().

_elem_side_to_face_info

std::unordered_map<std::pair<const Elem *, unsigned int>, FaceInfo *> MooseMesh::_elem_side_to_face_info

mutableprivateinherited

Map from elem-side pair to FaceInfo.

Definition at line 1782 of file MooseMesh.h.

Referenced by MooseMesh::buildFiniteVolumeInfo(), and MooseMesh::faceInfo().

_elem_to_elem_info

std::unordered_map<dof_id_type, ElemInfo> MooseMesh::_elem_to_elem_info

mutableprivateinherited

Map connecting elems with their corresponding ElemInfo, we use the element ID as the key.

Definition at line 1766 of file MooseMesh.h.

Referenced by MooseMesh::buildFiniteVolumeInfo(), MooseMesh::cacheFVElementalDoFs(), MooseMesh::computeFiniteVolumeCoords(), and MooseMesh::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

protectedinherited

Definition at line 1713 of file MooseMesh.h.

Referenced by MooseMesh::addQuadratureNode(), MooseMesh::clearQuadratureNodes(), and MooseMesh::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

privateinherited

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

Definition at line 1927 of file MooseMesh.h.

Referenced by MooseMesh::buildRefinementMap(), and MooseMesh::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

privateinherited

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

Referenced by MooseMesh::buildCoarseningMap(), and MooseMesh::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

privateinherited

Definition at line 1947 of file MooseMesh.h.

Referenced by MooseMesh::buildPRefinementAndCoarseningMaps(), and MooseMesh::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

privateinherited

Definition at line 1949 of file MooseMesh.h.

Referenced by MooseMesh::buildPRefinementAndCoarseningMaps(), and MooseMesh::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

privateinherited

Definition at line 1921 of file MooseMesh.h.

Referenced by MooseMesh::buildPRefinementAndCoarseningMaps(), and MooseMesh::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

privateinherited

Definition at line 1923 of file MooseMesh.h.

Referenced by MooseMesh::buildPRefinementAndCoarseningMaps(), and MooseMesh::getPRefinementSideMap().

_elem_type_to_refinement_map

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

privateinherited

Holds mappings for volume to volume and parent side to child side 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 1918 of file MooseMesh.h.

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

_enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

_extra_bnd_nodes

std::vector<BndNode> MooseMesh::_extra_bnd_nodes

protectedinherited

Definition at line 1714 of file MooseMesh.h.

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

_extreme_nodes

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

privateinherited

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

Definition at line 1806 of file MooseMesh.h.

Referenced by MooseMesh::detectOrthogonalDimRanges().

_face_info

std::vector<const FaceInfo *> MooseMesh::_face_info

mutableprivateinherited

Holds only those FaceInfo objects that have processor_id equal to this process's id, e.g.

the local FaceInfo objects

Definition at line 1778 of file MooseMesh.h.

Referenced by MooseMesh::buildFiniteVolumeInfo(), MooseMesh::faceInfo(), MooseMesh::nFace(), MooseMesh::ownedFaceInfoBegin(), and MooseMesh::ownedFaceInfoEnd().

_factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

Referenced by ElementIDOutputAction::act(), AdaptivityAction::act(), AddControlAction::act(), AddNodalNormalsAction::act(), AddPeriodicBCAction::act(), AutoCheckpointAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), DisplayGhostingAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), PartitionerAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupPreconditionerAction::act(), SetupPredictorAction::act(), SetupResidualDebugAction::act(), SetupTimeStepperAction::act(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), SampledOutput::cloneMesh(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), PhysicsBase::getFactory(), ActionComponent::getFactory(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), MFEMTransient::MFEMTransient(), and ProjectedStatefulMaterialStorageAction::processProperty().

_file_suffix

std::string FileRangeBuilder::_file_suffix

protectedinherited

Definition at line 50 of file FileRangeBuilder.h.

Referenced by FileRangeBuilder::FileRangeBuilder(), and FileRangeBuilder::fileSuffix().

_filenames

std::vector<std::string> FileRangeBuilder::_filenames

protectedinherited

Definition at line 51 of file FileRangeBuilder.h.

Referenced by buildMesh(), FileRangeBuilder::filenames(), FileRangeBuilder::FileRangeBuilder(), and ImageMeshGenerator::generate().

_finite_volume_info_dirty

bool MooseMesh::_finite_volume_info_dirty = true

mutableprivateinherited

Definition at line 1785 of file MooseMesh.h.

Referenced by MooseMesh::buildFiniteVolumeInfo(), MooseMesh::computeFiniteVolumeCoords(), MooseMesh::isFiniteVolumeInfoDirty(), MooseMesh::markFiniteVolumeInfoDirty(), and MooseMesh::update().

_gauss_lobatto_grid

bool GeneratedMesh::_gauss_lobatto_grid

protectedinherited

All of the libmesh build_line/square/cube routines support an option to grade the mesh into the boundaries according to the spacing of the Gauss-Lobatto quadrature points.

Defaults to false, and cannot be used in conjunction with x, y, and z biasing.

Definition at line 50 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), and GeneratedMesh::GeneratedMesh().

_ghost_elems_from_ghost_boundaries

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

privateinherited

Set of elements ghosted by ghostGhostedBoundaries.

Definition at line 1993 of file MooseMesh.h.

Referenced by MooseMesh::ghostGhostedBoundaries().

_ghosted_boundaries

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

protectedinherited

Definition at line 1722 of file MooseMesh.h.

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

_ghosted_boundaries_inflation

std::vector<Real> MooseMesh::_ghosted_boundaries_inflation

protectedinherited

Definition at line 1723 of file MooseMesh.h.

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

_ghosting_functors

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

protectedinherited

Deprecated (DO NOT USE)

Definition at line 1576 of file MooseMesh.h.

_ghosting_patch_size

unsigned int MooseMesh::_ghosting_patch_size

protectedinherited

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

Definition at line 1729 of file MooseMesh.h.

Referenced by MooseMesh::getGhostingPatchSize().

_half_range

RealVectorValue MooseMesh::_half_range

privateinherited

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

Definition at line 1803 of file MooseMesh.h.

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

_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

privateinherited

Holds a map from a high-order element side to its corresponding lower-d element.

Definition at line 1973 of file MooseMesh.h.

Referenced by MooseMesh::buildLowerDMesh(), MooseMesh::cacheInfo(), MooseMesh::getLowerDElem(), and MooseMesh::getLowerDElemMap().

_id_identical_flag

std::vector<std::vector<bool> > MooseMesh::_id_identical_flag

privateinherited

Flags to indicate whether or not any two extra element integers are the same.

Definition at line 2008 of file MooseMesh.h.

Referenced by MooseMesh::areElemIDsIdentical(), and MooseMesh::buildElemIDInfo().

_is_changed

bool MooseMesh::_is_changed

protectedinherited

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

Definition at line 1634 of file MooseMesh.h.

_is_displaced

bool MooseMesh::_is_displaced

privateinherited

Whether this mesh is displaced.

Definition at line 2023 of file MooseMesh.h.

Referenced by MooseMesh::isDisplaced(), and MooseMesh::isDisplaced().

_is_nemesis

bool MooseMesh::_is_nemesis

protectedinherited

True if a Nemesis Mesh was read in.

Definition at line 1637 of file MooseMesh.h.

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

_is_split

const bool MooseMesh::_is_split

protectedinherited

Whether or not we are using a (pre-)split mesh (automatically DistributedMesh)

Definition at line 1750 of file MooseMesh.h.

Referenced by MooseMesh::determineUseDistributedMesh(), and MooseMesh::isSplit().

_kokkos_mesh

std::unique_ptr<Moose::Kokkos::Mesh> MooseMesh::_kokkos_mesh

protectedinherited

Pointer to Kokkos mesh object.

Definition at line 1600 of file MooseMesh.h.

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

_linear_finite_volume_dofs_cached

bool MooseMesh::_linear_finite_volume_dofs_cached = false

mutableprivateinherited

Definition at line 1790 of file MooseMesh.h.

_local_node_range

std::unique_ptr<libMesh::ConstNodeRange> MooseMesh::_local_node_range

protectedinherited

Definition at line 1664 of file MooseMesh.h.

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

_lower_d_boundary_blocks

std::set<SubdomainID> MooseMesh::_lower_d_boundary_blocks

privateinherited

Mesh blocks for boundary lower-d elements in different types.

Definition at line 1970 of file MooseMesh.h.

Referenced by MooseMesh::boundaryLowerDBlocks(), MooseMesh::buildLowerDMesh(), and MooseMesh::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

privateinherited

Definition at line 1974 of file MooseMesh.h.

Referenced by MooseMesh::buildLowerDMesh(), MooseMesh::cacheInfo(), and MooseMesh::getHigherDSide().

_lower_d_interior_blocks

std::set<SubdomainID> MooseMesh::_lower_d_interior_blocks

privateinherited

Mesh blocks for interior lower-d elements in different types.

Definition at line 1968 of file MooseMesh.h.

Referenced by MooseMesh::buildLowerDMesh(), MooseMesh::cacheInfo(), and MooseMesh::interiorLowerDBlocks().

_max_h_level

unsigned int MooseMesh::_max_h_level

privateinherited

Maximum h-refinement level of all elements.

Definition at line 2055 of file MooseMesh.h.

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

_max_ids

std::vector<dof_id_type> MooseMesh::_max_ids

privateinherited

Maximum integer ID for each extra element integer.

Definition at line 2004 of file MooseMesh.h.

Referenced by MooseMesh::buildElemIDInfo(), and MooseMesh::maxElementID().

_max_leaf_size

unsigned int MooseMesh::_max_leaf_size

protectedinherited

Definition at line 1732 of file MooseMesh.h.

Referenced by MooseMesh::getMaxLeafSize().

_max_nodes_per_elem

unsigned int MooseMesh::_max_nodes_per_elem

privateinherited

The maximum number of nodes per element.

Definition at line 2014 of file MooseMesh.h.

Referenced by MooseMesh::computeMaxPerElemAndSide(), and MooseMesh::getMaxNodesPerElem().

_max_nodes_per_side

unsigned int MooseMesh::_max_nodes_per_side

privateinherited

The maximum number of nodes per side.

Definition at line 2017 of file MooseMesh.h.

Referenced by MooseMesh::computeMaxPerElemAndSide(), and MooseMesh::getMaxNodesPerSide().

_max_p_level

unsigned int MooseMesh::_max_p_level

privateinherited

Maximum p-refinement level of all elements.

Definition at line 2053 of file MooseMesh.h.

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

_max_sides_per_elem

unsigned int MooseMesh::_max_sides_per_elem

privateinherited

The maximum number of sides per element.

Definition at line 2011 of file MooseMesh.h.

Referenced by MooseMesh::computeMaxPerElemAndSide(), and MooseMesh::getMaxSidesPerElem().

_mesh

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

protectedinherited

Pointer to underlying libMesh mesh object.

Definition at line 1596 of file MooseMesh.h.

Referenced by MooseMesh::allowRemoteElementRemoval(), MooseMesh::buildFiniteVolumeInfo(), MooseMesh::buildPeriodicNodeMap(), MooseMesh::deleteRemoteElements(), MooseMesh::detectPairedSidesets(), MooseMesh::getMaxInDimension(), MooseMesh::getMesh(), MooseMesh::getMesh(), MooseMesh::getMeshPtr(), MooseMesh::getMinInDimension(), MooseMesh::hasMeshBase(), MooseMesh::init(), MooseMesh::nActiveElem(), MooseMesh::nActiveLocalElem(), MooseMesh::nLocalNodes(), MooseMesh::nPartitions(), MooseMesh::nSubdomains(), MooseMesh::prepare(), MooseMesh::prepared(), MooseMesh::prepared(), MooseMesh::setCoordSystem(), MooseMesh::setCustomPartitioner(), MooseMesh::setMeshBase(), MooseMesh::skipNoncriticalPartitioning(), MooseMesh::skipPartitioning(), and MooseMesh::spatialDimension().

_mesh_boundary_ids

std::set<BoundaryID> MooseMesh::_mesh_boundary_ids

protectedinherited

A set of boundary IDs currently present in the mesh.

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

Definition at line 1688 of file MooseMesh.h.

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

_mesh_nodeset_ids

std::set<BoundaryID> MooseMesh::_mesh_nodeset_ids

protectedinherited

Definition at line 1690 of file MooseMesh.h.

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

_mesh_sideset_ids

std::set<BoundaryID> MooseMesh::_mesh_sideset_ids

protectedinherited

Definition at line 1689 of file MooseMesh.h.

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

_mesh_subdomains

std::set<SubdomainID> MooseMesh::_mesh_subdomains

protectedinherited

A set of subdomain IDs currently present in the mesh.

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

Definition at line 1680 of file MooseMesh.h.

Referenced by MooseMesh::buildLowerDMesh(), MooseMesh::cacheInfo(), MooseMesh::checkDuplicateSubdomainNames(), MooseMesh::meshSubdomains(), and MooseMesh::prepare().

_metaname

const RestartableDataMapName Restartable::_metaname

privateinherited

Restartable metadata name.

Definition at line 247 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

_min_ids

std::vector<dof_id_type> MooseMesh::_min_ids

privateinherited

Minimum integer ID for each extra element integer.

Definition at line 2006 of file MooseMesh.h.

Referenced by MooseMesh::buildElemIDInfo(), and MooseMesh::minElementID().

_moose_mesh_prepared

bool MooseMesh::_moose_mesh_prepared = false

protectedinherited

True if prepare has been called on the mesh.

Definition at line 1640 of file MooseMesh.h.

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

_name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

Referenced by AddFieldSplitAction::act(), AddBCAction::act(), AddConstraintAction::act(), AddControlAction::act(), AddConvergenceAction::act(), AddCorrectorAction::act(), AddDamperAction::act(), AddDGKernelAction::act(), AddDiracKernelAction::act(), AddDistributionAction::act(), AddFunctionAction::act(), AddFunctorMaterialAction::act(), AddFVBCAction::act(), AddFVGradientMethodAction::act(), AddFVInitialConditionAction::act(), AddFVInterfaceKernelAction::act(), AddFVInterpolationMethodAction::act(), AddFVKernelAction::act(), AddHDGKernelAction::act(), AddIndicatorAction::act(), AddInitialConditionAction::act(), AddInterfaceKernelAction::act(), AddKernelAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddMarkerAction::act(), AddMaterialAction::act(), AddMeshDivisionAction::act(), AddMeshGeneratorAction::act(), AddMeshModifiersAction::act(), AddMultiAppAction::act(), AddNodalKernelAction::act(), AddOutputAction::act(), AddPositionsAction::act(), AddPostprocessorAction::act(), AddReporterAction::act(), AddSamplerAction::act(), AddScalarKernelAction::act(), AddTimesAction::act(), AddTimeStepperAction::act(), AddTransferAction::act(), AddUserObjectAction::act(), AddVectorPostprocessorAction::act(), PartitionerAction::act(), ReadExecutorParamsAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), AddMFEMFESpaceAction::act(), AddMFEMFESpaceHierarchyAction::act(), AddMFEMProblemComposerAction::act(), AddMFEMQuadratureFunctionAction::act(), AddMFEMSolverAction::act(), AddMFEMSubMeshAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), PiecewiseLinearBase::buildInterpolation(), CombinerGenerator::CombinerGenerator(), Executor::Executor(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), MultiApp::fillPositions(), CentroidMultiApp::fillPositions(), QuadraturePointMultiApp::fillPositions(), FunctionDT::FunctionDT(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), MooseBase::name(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseBase::setData(), and AddVariableAction::varName().

_need_delete

bool MooseMesh::_need_delete

privateinherited

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

Definition at line 1987 of file MooseMesh.h.

Referenced by MooseMesh::allowRemoteElementRemoval(), MooseMesh::needsRemoteElemDeletion(), and MooseMesh::needsRemoteElemDeletion().

_need_ghost_ghosted_boundaries

bool MooseMesh::_need_ghost_ghosted_boundaries

privateinherited

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

Referenced by MooseMesh::ghostGhostedBoundaries(), and MooseMesh::needGhostGhostedBoundaries().

_neighbor_subdomain_boundary_ids

std::unordered_map<SubdomainID, std::set<BoundaryID> > MooseMesh::_neighbor_subdomain_boundary_ids

privateinherited

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

Definition at line 1965 of file MooseMesh.h.

Referenced by MooseMesh::cacheInfo(), MooseMesh::getBoundaryConnectedSecondaryBlocks(), MooseMesh::getInterfaceConnectedBlocks(), and MooseMesh::getSubdomainInterfaceBoundaryIds().

_node_map

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

protectedinherited

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

Definition at line 1738 of file MooseMesh.h.

Referenced by MooseMesh::addUniqueNode().

_node_set_nodes

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

protectedinherited

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

Definition at line 1720 of file MooseMesh.h.

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

_node_to_elem_map

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

protectedinherited

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

Definition at line 1671 of file MooseMesh.h.

Referenced by MooseMesh::internalNodeToElemMap(), and MooseMesh::possiblyRebuildNodeToElemMap().

_node_to_elem_map_built

bool MooseMesh::_node_to_elem_map_built = false

protectedinherited

Whether _node_to_elem_map has been built.

Definition at line 1674 of file MooseMesh.h.

Referenced by MooseMesh::internalNodeToElemMap(), and MooseMesh::possiblyRebuildNodeToElemMap().

_nx

unsigned int GeneratedMesh::_nx

protectedinherited

Number of elements in x, y, z direction.

Definition at line 40 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), buildMesh2D(), and buildMesh3D().

_ny

unsigned int GeneratedMesh::_ny

protectedinherited

Definition at line 40 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), buildMesh2D(), and buildMesh3D().

_nz

unsigned int GeneratedMesh::_nz

protectedinherited

Definition at line 40 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), and buildMesh3D().

_paired_boundary

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

protectedinherited

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

Definition at line 1747 of file MooseMesh.h.

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

_parallel_type

ParallelType MooseMesh::_parallel_type

protectedinherited

Can be set to DISTRIBUTED, REPLICATED, or DEFAULT.

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

Definition at line 1586 of file MooseMesh.h.

Referenced by MooseMesh::determineUseDistributedMesh(), MooseMesh::getParallelType(), and MooseMesh::setParallelType().

_parallel_type_overridden

bool MooseMesh::_parallel_type_overridden

protectedinherited

Definition at line 1593 of file MooseMesh.h.

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

_parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), and DataFileInterface::getDataFilePath().

_pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MultiSystemSolveObject::MultiSystemSolveObject(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseBase::queryParam(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

_partitioner_name

MooseEnum MooseMesh::_partitioner_name

protectedinherited

The partitioner used on this mesh.

Definition at line 1604 of file MooseMesh.h.

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

_partitioner_overridden

bool MooseMesh::_partitioner_overridden

protectedinherited

Definition at line 1605 of file MooseMesh.h.

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

_patch_size

unsigned int MooseMesh::_patch_size

protectedinherited

The number of nodes to consider in the NearestNode neighborhood.

Definition at line 1726 of file MooseMesh.h.

Referenced by MooseMesh::getPatchSize().

_patch_update_strategy

Moose::PatchUpdateType MooseMesh::_patch_update_strategy

protectedinherited

The patch update strategy.

Definition at line 1735 of file MooseMesh.h.

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

_periodic_dim

std::map<std::pair<unsigned int, unsigned int>, std::array<bool, 3> > MooseMesh::_periodic_dim

privateinherited

A map from (system number, vector number) to which dimensions are periodic in a regular orthogonal mesh.

This data structure is populated by addPeriodicVariable.

Definition at line 1798 of file MooseMesh.h.

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

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 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 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_provided_coord_blocks

std::vector<SubdomainName> MooseMesh::_provided_coord_blocks

privateinherited

Set for holding user-provided coordinate system type block names.

Definition at line 2048 of file MooseMesh.h.

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

_quadrature_nodes

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

protectedinherited

Definition at line 1711 of file MooseMesh.h.

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

_refined_elements

std::unique_ptr<ConstElemPointerRange> MooseMesh::_refined_elements

protectedinherited

The elements that were just refined.

Definition at line 1643 of file MooseMesh.h.

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

_regular_orthogonal_mesh

bool MooseMesh::_regular_orthogonal_mesh

protectedinherited

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

Definition at line 1741 of file MooseMesh.h.

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

_relationship_managers

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

protectedinherited

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

Definition at line 1579 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_name

std::string Restartable::_restartable_name

privateinherited

The name of the object.

Definition at line 250 of file Restartable.h.

Referenced by Restartable::declareRestartableDataWithObjectNameWithContext(), and Restartable::restartableName().

_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

privateinherited

Storage for RZ axis selection.

Definition at line 2035 of file MooseMesh.h.

Referenced by MooseMesh::getAxisymmetricRadialCoord(), MooseMesh::setAxisymmetricCoordAxis(), and MooseMesh::setCoordData().

_scale_to_one

const bool ImageMesh::_scale_to_one

protected

If true, forces the maximum width (height) of the mesh to be 1.0 while retaining the original aspect ratio of the image.

Definition at line 51 of file ImageMesh.h.

Referenced by buildMesh2D(), and buildMesh3D().

_semilocal_node_list

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

protectedinherited

Used for generating the semilocal node range.

Definition at line 1656 of file MooseMesh.h.

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

_si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base

privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal(), SolutionInvalidInterface::mooseDeprecated(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), SolutionInvalidInterface::paramWarning(), and SolutionInvalidInterface::registerInvalidSolutionInternal().

_si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem

privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

_skip_deletion_repartition_after_refine

bool MooseMesh::_skip_deletion_repartition_after_refine

protectedinherited

Whether or not skip remote deletion and repartition after uniform refinements.

Definition at line 1631 of file MooseMesh.h.

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

_skip_refine_when_use_split

bool MooseMesh::_skip_refine_when_use_split

protectedinherited

Whether or not to skip uniform refinements when using a pre-split mesh.

Definition at line 1628 of file MooseMesh.h.

Referenced by MooseMesh::skipRefineWhenUseSplit().

_status

int FileRangeBuilder::_status

protectedinherited

Definition at line 49 of file FileRangeBuilder.h.

Referenced by FileRangeBuilder::errorCheck(), FileRangeBuilder::FileRangeBuilder(), MeshBaseImageSampler::setupImageSampler(), and ImageSampler::setupImageSampler().

_sub_to_data

std::unordered_map<SubdomainID, SubdomainData> MooseMesh::_sub_to_data

privateinherited

Holds a map from subdomain ids to associated data.

Definition at line 1962 of file MooseMesh.h.

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

_subdomain_id_to_rz_coord_axis

std::unordered_map<SubdomainID, std::pair<Point, RealVectorValue> > MooseMesh::_subdomain_id_to_rz_coord_axis

privateinherited

Map of subdomain ID to general axisymmetric axis.

Definition at line 2038 of file MooseMesh.h.

Referenced by MooseMesh::getGeneralAxisymmetricCoordAxis(), MooseMesh::setCoordData(), MooseMesh::setGeneralAxisymmetricCoordAxes(), and MooseMesh::usingGeneralAxisymmetricCoordAxes().

_type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), FEProblemBase::solverTypeString(), and MooseBase::type().

_uniform_refine_level

unsigned int MooseMesh::_uniform_refine_level

protectedinherited

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

Definition at line 1625 of file MooseMesh.h.

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

_use_distributed_mesh

bool MooseMesh::_use_distributed_mesh

protectedinherited

False by default.

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

Definition at line 1591 of file MooseMesh.h.

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

_xmax

Real GeneratedMesh::_xmax

protectedinherited

Definition at line 43 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), buildMesh2D(), buildMesh3D(), and GeneratedMesh::getMaxInDimension().

_xmin

Real GeneratedMesh::_xmin

protectedinherited

The min/max values for x,y,z component.

Definition at line 43 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), and GeneratedMesh::getMinInDimension().

_ymax

Real GeneratedMesh::_ymax

protectedinherited

Definition at line 43 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), buildMesh2D(), buildMesh3D(), and GeneratedMesh::getMaxInDimension().

_ymin

Real GeneratedMesh::_ymin

protectedinherited

Definition at line 43 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), and GeneratedMesh::getMinInDimension().

_zmax

Real GeneratedMesh::_zmax

protectedinherited

Definition at line 43 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), buildMesh3D(), and GeneratedMesh::getMaxInDimension().

_zmin

Real GeneratedMesh::_zmin

protectedinherited

Definition at line 43 of file GeneratedMesh.h.

Referenced by GeneratedMesh::buildMesh(), and GeneratedMesh::getMinInDimension().

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(), ActionFactory::getValidParams(), Factory::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 InputParameters::isKokkosObject().

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(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

periodic_dim_default

const std::array< bool, 3 > MooseMesh::periodic_dim_default {false, false, false}

staticinherited

Default value for the automatically detected paired boundaries for each unit dimension, in which the value for each unit dimension is false (not detected).

Definition at line 78 of file MooseMesh.h.

: _distance(std::numeric_limits<Real>::max()) {}

Referenced by MooseMesh::addPeriodicVariable(), MooseMesh::detectPairedSidesets(), and MooseMesh::queryPeriodicDimensions().

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

---

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

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