DistributedRectilinearMeshGenerator Class Reference

This class works by first creating a "distributed dual graph" of the element connectivity based on a linear partition of mesh before ever building an elements. More...

#include <DistributedRectilinearMeshGenerator.h>

Inheritance diagram for DistributedRectilinearMeshGenerator:

Public Types
using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name.

Public Member Functions
	DistributedRectilinearMeshGenerator (const InputParameters &parameters)
std::unique_ptr< MeshBase >	generate () override
	Generate / modify the mesh.
template<typename T >
void	buildCube (UnstructuredMesh &, const unsigned int, unsigned int, unsigned int, const Real, const Real, const Real, const Real, const Real, const Real, const ElemType)
	Build a cube mesh.
template<typename T >
dof_id_type	elemId (const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type)
	Get the element ID for a given hex.
template<typename T >
dof_id_type	numNeighbors (const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type)
	Get the number of neighbors this element will have.
template<typename T >
void	getNeighbors (const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, std::vector< dof_id_type > &, const bool)
	Get the IDs of the neighbors of a given element.
template<typename T >
dof_id_type	nodeId (const ElemType, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type)
	The ID of the i,j,k node.
template<typename T >
Node *	addPoint (const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const ElemType, MeshBase &)
	Add a node to the mesh.
template<typename T >
void	addElement (const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const processor_id_type, const ElemType, MeshBase &)
	Adds an element to the mesh.
template<typename T >
void	paritionSquarely (const dof_id_type, const dof_id_type, const dof_id_type, const processor_id_type, std::vector< dof_id_type > &, std::vector< dof_id_type > &, std::vector< dof_id_type > &)
	Partition mesh squarely.
template<typename T >
void	getIndices (const dof_id_type, const dof_id_type, const dof_id_type, dof_id_type &, dof_id_type &, dof_id_type &)
	Compute the i,j,k indices of a given element ID.
template<typename T >
void	getGhostNeighbors (const dof_id_type, const dof_id_type, const dof_id_type, const MeshBase &, const std::set< dof_id_type > &, std::set< dof_id_type > &)
	Find the elements and sides that need ghost elements.
template<typename T >
void	setBoundaryNames (BoundaryInfo &)
	Set the boundary names for any added boundary ideas.
template<typename T >
void	scaleNodalPositions (dof_id_type, dof_id_type, dof_id_type, Real, Real, Real, Real, Real, Real, MeshBase &)
	All meshes are generated on the unit square.
template<>
dof_id_type	elemId (const dof_id_type nx, const dof_id_type ny, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
dof_id_type	elemId (const dof_id_type nx, const dof_id_type ny, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
dof_id_type	elemId (const dof_id_type nx, const dof_id_type ny, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
dof_id_type	numNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
dof_id_type	numNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
dof_id_type	numNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
void	getNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, std::vector< dof_id_type > &neighbors, const bool corner)
template<>
void	getNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, std::vector< dof_id_type > &neighbors, const bool corner)
template<>
void	getNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, std::vector< dof_id_type > &neighbors, const bool corner)
template<>
dof_id_type	nodeId (const ElemType type, const dof_id_type nx, const dof_id_type ny, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
dof_id_type	nodeId (const ElemType type, const dof_id_type nx, const dof_id_type ny, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
dof_id_type	nodeId (const ElemType type, const dof_id_type nx, const dof_id_type ny, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
Node *	addPoint (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, const ElemType type, MeshBase &mesh)
template<>
Node *	addPoint (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, const ElemType type, MeshBase &mesh)
template<>
Node *	addPoint (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, const ElemType type, MeshBase &mesh)
template<>
void	addElement (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, const dof_id_type elem_id, const processor_id_type pid, const ElemType type, MeshBase &mesh)
template<>
void	addElement (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, const dof_id_type elem_id, const processor_id_type pid, const ElemType type, MeshBase &mesh)
template<>
void	addElement (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, const dof_id_type elem_id, const processor_id_type pid, const ElemType type, MeshBase &mesh)
template<>
void	getIndices (const dof_id_type nx, const dof_id_type ny, const dof_id_type elem_id, dof_id_type &i, dof_id_type &j, dof_id_type &k)
template<>
void	getIndices (const dof_id_type nx, const dof_id_type ny, const dof_id_type elem_id, dof_id_type &i, dof_id_type &j, dof_id_type &k)
template<>
void	getIndices (const dof_id_type nx, const dof_id_type ny, const dof_id_type elem_id, dof_id_type &i, dof_id_type &j, dof_id_type &k)
template<>
void	getGhostNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const MeshBase &mesh, const std::set< dof_id_type > &current_elems, std::set< dof_id_type > &ghost_elems)
template<>
void	getGhostNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const MeshBase &mesh, const std::set< dof_id_type > &current_elems, std::set< dof_id_type > &ghost_elems)
template<>
void	getGhostNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const MeshBase &mesh, const std::set< dof_id_type > &current_elems, std::set< dof_id_type > &ghost_elems)
template<>
void	scaleNodalPositions (dof_id_type nx, dof_id_type ny, dof_id_type nz, Real xmin, Real xmax, Real ymin, Real ymax, Real zmin, Real zmax, MeshBase &mesh)
template<>
void	scaleNodalPositions (dof_id_type nx, dof_id_type ny, dof_id_type nz, Real xmin, Real xmax, Real ymin, Real ymax, Real zmin, Real zmax, MeshBase &mesh)
template<>
void	scaleNodalPositions (dof_id_type nx, dof_id_type ny, dof_id_type nz, Real xmin, Real xmax, Real ymin, Real ymax, Real zmin, Real zmax, MeshBase &mesh)
template<>
void	setBoundaryNames (BoundaryInfo &boundary_info)
template<>
void	setBoundaryNames (BoundaryInfo &boundary_info)
template<>
void	setBoundaryNames (BoundaryInfo &boundary_info)
template<>
void	paritionSquarely (const dof_id_type, const dof_id_type, const dof_id_type, const processor_id_type, std::vector< dof_id_type > &, std::vector< dof_id_type > &, std::vector< dof_id_type > &)
template<>
void	paritionSquarely (const dof_id_type, const dof_id_type, const dof_id_type, const processor_id_type, std::vector< dof_id_type > &, std::vector< dof_id_type > &, std::vector< dof_id_type > &)
template<>
void	paritionSquarely (const dof_id_type, const dof_id_type, const dof_id_type, const processor_id_type, std::vector< dof_id_type > &, std::vector< dof_id_type > &, std::vector< dof_id_type > &)
template<>
dof_id_type	numNeighbors (const dof_id_type nx, const dof_id_type, const dof_id_type, const dof_id_type i, const dof_id_type, const dof_id_type)
template<>
void	getNeighbors (const dof_id_type nx, const dof_id_type, const dof_id_type, const dof_id_type i, const dof_id_type, const dof_id_type, std::vector< dof_id_type > &neighbors, const bool corner)
template<>
void	getIndices (const dof_id_type, const dof_id_type, const dof_id_type elem_id, dof_id_type &i, dof_id_type &, dof_id_type &)
template<>
void	getGhostNeighbors (const dof_id_type nx, const dof_id_type, const dof_id_type, const MeshBase &mesh, const std::set< dof_id_type > &current_elems, std::set< dof_id_type > &ghost_elems)
template<>
dof_id_type	elemId (const dof_id_type, const dof_id_type, const dof_id_type i, const dof_id_type, const dof_id_type)
template<>
void	addElement (const dof_id_type nx, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type, const dof_id_type elem_id, const processor_id_type pid, const ElemType, MeshBase &mesh)
template<>
void	setBoundaryNames (BoundaryInfo &boundary_info)
template<>
void	scaleNodalPositions (dof_id_type, dof_id_type, dof_id_type, Real xmin, Real xmax, Real, Real, Real, Real, MeshBase &mesh)
template<>
dof_id_type	numNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type, const dof_id_type i, const dof_id_type j, const dof_id_type)
template<>
dof_id_type	elemId (const dof_id_type nx, const dof_id_type, const dof_id_type i, const dof_id_type j, const dof_id_type)
template<>
void	getNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type, const dof_id_type i, const dof_id_type j, const dof_id_type, std::vector< dof_id_type > &neighbors, const bool corner)
template<>
void	getIndices (const dof_id_type nx, const dof_id_type, const dof_id_type elem_id, dof_id_type &i, dof_id_type &j, dof_id_type &)
template<>
void	getGhostNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type, const MeshBase &mesh, const std::set< dof_id_type > &current_elems, std::set< dof_id_type > &ghost_elems)
template<>
dof_id_type	nodeId (const ElemType, const dof_id_type nx, const dof_id_type, const dof_id_type i, const dof_id_type j, const dof_id_type)
template<>
void	addElement (const dof_id_type nx, const dof_id_type ny, const dof_id_type, const dof_id_type i, const dof_id_type j, const dof_id_type, const dof_id_type elem_id, const processor_id_type pid, const ElemType type, MeshBase &mesh)
template<>
void	setBoundaryNames (BoundaryInfo &boundary_info)
template<>
void	scaleNodalPositions (dof_id_type, dof_id_type, dof_id_type, Real xmin, Real xmax, Real ymin, Real ymax, Real, Real, MeshBase &mesh)
template<>
dof_id_type	elemId (const dof_id_type nx, const dof_id_type ny, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
dof_id_type	numNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
void	getNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, std::vector< dof_id_type > &neighbors, const bool corner)
template<>
dof_id_type	nodeId (const ElemType, const dof_id_type nx, const dof_id_type ny, const dof_id_type i, const dof_id_type j, const dof_id_type k)
template<>
Node *	addPoint (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, const ElemType type, MeshBase &mesh)
template<>
void	addElement (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const dof_id_type i, const dof_id_type j, const dof_id_type k, const dof_id_type elem_id, const processor_id_type pid, const ElemType type, MeshBase &mesh)
template<>
void	getIndices (const dof_id_type nx, const dof_id_type ny, const dof_id_type elem_id, dof_id_type &i, dof_id_type &j, dof_id_type &k)
template<>
void	getGhostNeighbors (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const MeshBase &mesh, const std::set< dof_id_type > &current_elems, std::set< dof_id_type > &ghost_elems)
template<>
void	setBoundaryNames (BoundaryInfo &boundary_info)
template<>
void	scaleNodalPositions (dof_id_type, dof_id_type, dof_id_type, Real xmin, Real xmax, Real ymin, Real ymax, Real zmin, Real zmax, MeshBase &mesh)
template<>
void	paritionSquarely (const dof_id_type nx, const dof_id_type, const dof_id_type, const processor_id_type num_procs, std::vector< dof_id_type > &istarts, std::vector< dof_id_type > &jstarts, std::vector< dof_id_type > &kstarts)
template<>
void	paritionSquarely (const dof_id_type nx, const dof_id_type ny, const dof_id_type, const processor_id_type num_procs, std::vector< dof_id_type > &istarts, std::vector< dof_id_type > &jstarts, std::vector< dof_id_type > &kstarts)
template<>
void	paritionSquarely (const dof_id_type nx, const dof_id_type ny, const dof_id_type nz, const processor_id_type num_procs, std::vector< dof_id_type > &istarts, std::vector< dof_id_type > &jstarts, std::vector< dof_id_type > &kstarts)
bool	hasGenerateData () const
bool	hasGenerateCSG () const
std::unique_ptr< CSG::CSGBase >	generateInternalCSG ()
	Internal generation method for CSG object generation.
std::unique_ptr< MeshBase >	generateInternal ()
	Internal generation method - this is what is actually called within MooseApp to execute the MeshGenerator.
const std::set< MeshGeneratorName > &	getRequestedMeshGenerators () const
const std::set< MeshGeneratorName > &	getRequestedMeshGeneratorsForSub () const
void	addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)
	Adds the MeshGenerator mg as a parent.
void	addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)
	Adds the MeshGenerator mg as a child.
const std::set< const MeshGenerator *, Comparator > &	getParentMeshGenerators () const
	Gets the MeshGenerators that are parents to this MeshGenerator.
const std::set< const MeshGenerator *, Comparator > &	getChildMeshGenerators () const
	Gets the MeshGenerators that are children to this MeshGenerator.
const std::set< const MeshGenerator *, Comparator > &	getSubMeshGenerators () const
	Gets the MeshGenerators that are children to this MeshGenerator.
bool	isParentMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const
bool	isChildMeshGenerator (const MeshGeneratorName &name, const bool direct=true) const
bool	isNullMeshName (const MeshGeneratorName &name) const
bool	hasSaveMesh () const
	Return whether or not to save the current mesh.
bool	hasOutput () const
const std::string &	getSavedMeshName () const
	Return the name of the saved mesh.
bool	isDataOnly () const
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.

Static Public Member Functions
static InputParameters	validParams ()
static void	setHasGenerateData (InputParameters &params)
	Sets that a mesh generator has a generateData() implementation.
static bool	hasGenerateData (const InputParameters &params)
static void	setHasGenerateCSG (InputParameters &params)
	Sets that a mesh generator has a generateCSG() implementation.
static bool	hasGenerateCSG (const InputParameters &params)
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::string	data_only_param = "_data_only"
	The name of the private parameter for setting data only.
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.
static constexpr auto	SYSTEM = "MeshMetaData"
	The system name used when initializing the Restartable interface.
static constexpr auto	NAME = "<empty>"
	The data name used when initializing the Restartable interface for non-MeshGenerator objects.

Protected Member Functions
virtual void	generateData ()
	Generate the mesh data.
virtual std::unique_ptr< CSG::CSGBase >	generateCSG ()
	Generate the CSG representation of the mesh (or meshing operation) created by this mesh generator.
template<typename T >
T &	copyMeshProperty (const std::string &target_data_name, const std::string &source_data_name, const std::string &source_mesh)
	Method for copying attribute from input mesh meta-data store to current mesh meta-data store.
template<typename T >
T &	copyMeshProperty (const std::string &source_data_name, const std::string &source_mesh)
	Method for copying attribute from input mesh meta-data store to current mesh meta-data store, keeping source and target data names the same.
std::unique_ptr< MeshBase > &	getMesh (const std::string &param_name, const bool allow_invalid=false)
	Takes the name of a MeshGeneratorName parameter and then gets a pointer to the Mesh that MeshGenerator is going to create.
std::vector< std::unique_ptr< MeshBase > * >	getMeshes (const std::string &param_name)
	Like getMesh(), but for multiple generators.
std::unique_ptr< MeshBase > &	getMeshByName (const MeshGeneratorName &mesh_generator_name)
	Like getMesh(), but takes the name of another MeshGenerator directly.
std::vector< std::unique_ptr< MeshBase > * >	getMeshesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)
	Like getMeshByName(), but for multiple generators.
std::unique_ptr< CSG::CSGBase > &	getCSGBase (const std::string &param_name)
	Takes the name of a MeshGeneratorName parameter and then gets a pointer to the CSGBase object that MeshGenerator has created.
std::unique_ptr< CSG::CSGBase > &	getCSGBaseByName (const MeshGeneratorName &mesh_generator_name)
	Like getCSGBase(), but takes the name of another MeshGenerator directly.
std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBases (const std::string &param_name)
	Like getCSGBase(), but for multiple generators.
std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBasesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)
	Like getCSGBaseByName(), but for multiple generators.
void	declareMeshForSub (const std::string &param_name)
	Declares that a MeshGenerator referenced in the InputParameters is to be used as a dependency of a sub MeshGenerator created by this MeshGenerator (see addSubMeshGenerator)
void	declareMeshesForSub (const std::string &param_name)
	Like declareMeshForSub(), but for multiple generators.
void	declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)
	Like declareMeshForSub(), but takes the name of another MeshGenerator directly.
void	declareMeshesForSubByName (const std::vector< MeshGeneratorName > &mesh_generator_names)
	Like declareMeshForSubByName(), but for multiple generators.
std::unique_ptr< MeshBase >	buildMeshBaseObject (unsigned int dim=libMesh::invalid_uint)
	Build a MeshBase object whose underlying type will be determined by the Mesh input file block.
std::unique_ptr< ReplicatedMesh >	buildReplicatedMesh (unsigned int dim=libMesh::invalid_uint)
	Build a replicated mesh.
std::unique_ptr< DistributedMesh >	buildDistributedMesh (unsigned int dim=libMesh::invalid_uint)
	Build a distributed mesh that has correct remote element removal behavior and geometric ghosting functors based on the simulation objects.
template<typename... Ts>
void	addMeshSubgenerator (const std::string &type, const std::string &name, Ts... extra_input_parameters)
	Construct a "subgenerator", a different MeshGenerator subclass that will be added to the same MooseApp on the fly.
void	addMeshSubgenerator (const std::string &type, const std::string &name, InputParameters params)
	Construct a "subgenerator", as above.
void	declareNullMeshName (const MeshGeneratorName &name)
	Registers the name name as a "null" mesh, which is a MeshGenerator used in InputParameters that will not represent an input mesh when requested via getMesh.
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 >
const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)
	Method for retrieving a property with the given type and name exists in the mesh meta-data store.
template<typename T >
const T &	getMeshProperty (const std::string &data_name)
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const
template<typename T >
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const
bool	hasMeshProperty (const std::string &data_name) const
template<typename T >
bool	hasMeshProperty (const std::string &data_name) const
std::string	meshPropertyName (const std::string &data_name) const
template<typename T , typename... Args>
T &	declareMeshProperty (const std::string &data_name, Args &&... args)
	Methods for writing out attributes to the mesh meta-data store, which can be retrieved from most other MOOSE systems and is recoverable.
template<typename T >
T &	declareMeshProperty (const std::string &data_name, const T &data_value)
template<typename T , typename... Args>
T &	setMeshProperty (const std::string &data_name, Args &&... args)
	Method for updating attributes to the mesh meta-data store, which can only be invoked in the MeshGenerator generate routine only if the mesh generator property has already been declared.
template<typename T >
T &	setMeshProperty (const std::string &data_name, const T &data_value)

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
MooseEnum	_dim
	The dimension of the mesh.
dof_id_type &	_nx
	Number of elements in x, y, z direction.
dof_id_type &	_ny
dof_id_type &	_nz
Real &	_xmin
	The min/max values for x,y,z component.
Real &	_xmax
Real &	_ymin
Real &	_ymax
Real &	_zmin
Real &	_zmax
processor_id_type	_num_cores_for_partition
	Number of cores for partitioning the graph The number of cores for the graph partition can be different from that used for mesh generation and simulation.
ElemType	_elem_type
	The type of element to build.
Real	_bias_x
	The amount by which to bias the cells in the x,y,z directions.
Real	_bias_y
Real	_bias_z
std::string	_part_package
	External partitioner.
processor_id_type	_num_parts_per_compute_node
	Number of cores per compute node if hierarch partitioning is used.
std::string	_partition_method
	Which method is used to partition the mesh that is not built yet.
unsigned	_num_side_layers
	Number of element side neighbor layers While most of applications in moose require one layer of side neighbors, phase field simulation with grain tracker needs two layers.
MooseMesh *const	_mesh
	Pointer to the owning mesh.
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

Private Member Functions
virtual std::string	meshPropertyPrefix (const std::string &) const override final
	Override of the default prefix to use when getting mesh properties.
void	checkGetMesh (const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const
	Helper for performing error checking in the getMesh methods.
const MeshGeneratorName *	getMeshGeneratorNameFromParam (const std::string &param_name, const bool allow_invalid) const
	Helper for getting a MeshGeneratorName parameter.
const std::vector< MeshGeneratorName > &	getMeshGeneratorNamesFromParam (const std::string &param_name) const
	Helper for getting a std::vector<MeshGeneratorName> parameter.
RestartableDataValue &	setMeshPropertyHelper (const std::string &data_name)
	Helper for getting a writable reference to a mesh property, used in declareMeshProperty and setMeshProperty.
const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const
	Helper for getting a mesh property.
template<typename... Args>
void	mooseErrorInternal (Args &&... args) const
	Helper for forwarding a mooseError to an object's mooseError if it is available (said error will provide more context: object name and type)

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::set< MeshGeneratorName >	_requested_mesh_generators
	The names of the MeshGenerators that were requested in the getMesh methods.
std::set< MeshGeneratorName >	_requested_mesh_generators_for_sub
	The names of the MeshGenerators that were requested in the declareMeshForSub methods.
std::vector< std::pair< std::string, std::unique_ptr< MeshBase > * > >	_requested_meshes
	The meshes that were requested by this MeshGenerator; used to verify that any input meshes that are requested are properly released after generation.
std::vector< std::pair< std::string, std::unique_ptr< CSG::CSGBase > * > >	_requested_csg_bases
	The CSGBase objects that were requested by this MeshGenerator; used to verify that any input meshes that are requested are properly released after generation.
std::unique_ptr< MeshBase >	_null_mesh = nullptr
	A nullptr to use for when inputs aren't specified.
std::unique_ptr< CSG::CSGBase >	_null_csg_base = nullptr
	A nullptr to use for when inputs aren't specified.
std::set< const MeshGenerator *, Comparator >	_parent_mesh_generators
	The MeshGenerators that are parents to this MeshGenerator.
std::set< const MeshGenerator *, Comparator >	_child_mesh_generators
	The MeshGenerators that are children to this MeshGenerator.
std::set< const MeshGenerator *, Comparator >	_sub_mesh_generators
	The sub MeshGenerators constructed by this MeshGenerator.
std::set< std::string >	_null_mesh_names
	The declared "null" mesh names that will not represent a mesh in input; see declareNullMeshName()
const std::string &	_save_with_name
	A user-defined name to save the mesh.
const bool	_data_only
	Whether or not this mesh generator will run in data only mode.
const ParallelParamObject &	_parent
const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.
const FEProblemBase *	_si_problem
	A pointer to FEProblem base.
MooseApp &	_meta_data_app
	Reference to the application.
const MooseObject *const	_meta_data_object
	The MooseObject (if any); used for better error handling.

Detailed Description

This class works by first creating a "distributed dual graph" of the element connectivity based on a linear partition of mesh before ever building an elements.

It then uses PetscExternalPartitioner to partition that graph - assigning elements to processors. Then, each processor can read the partition map and build only the elements that need to be on that processor. Final steps include adding in "ghosted" elements and making sure that boundary conditions are right.

Definition at line 26 of file DistributedRectilinearMeshGenerator.h.

Member Typedef Documentation

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.

Constructor & Destructor Documentation

DistributedRectilinearMeshGenerator()

DistributedRectilinearMeshGenerator::DistributedRectilinearMeshGenerator

(

const InputParameters &

parameters

)

Definition at line 114 of file DistributedRectilinearMeshGenerator.C.

  : MeshGenerator(parameters),
    _dim(getParam<MooseEnum>("dim")),
    _nx(declareMeshProperty("num_elements_x", getParam<dof_id_type>("nx"))),
    _ny(declareMeshProperty("num_elements_y", getParam<dof_id_type>("ny"))),
    _nz(declareMeshProperty("num_elements_z", getParam<dof_id_type>("nz"))),
    _xmin(declareMeshProperty("xmin", getParam<Real>("xmin"))),
    _xmax(declareMeshProperty("xmax", getParam<Real>("xmax"))),
    _ymin(declareMeshProperty("ymin", getParam<Real>("ymin"))),
    _ymax(declareMeshProperty("ymax", getParam<Real>("ymax"))),
    _zmin(declareMeshProperty("zmin", getParam<Real>("zmin"))),
    _zmax(declareMeshProperty("zmax", getParam<Real>("zmax"))),
    _num_cores_for_partition(getParam<processor_id_type>("num_cores_for_partition")),
    _bias_x(getParam<Real>("bias_x")),
    _bias_y(getParam<Real>("bias_y")),
    _bias_z(getParam<Real>("bias_z")),
    _part_package(getParam<MooseEnum>("part_package")),
    _num_parts_per_compute_node(getParam<processor_id_type>("num_cores_per_compute_node")),
    _partition_method(getParam<MooseEnum>("partition")),
    _num_side_layers(getParam<unsigned>("num_side_layers"))
{
  declareMeshProperty("use_distributed_mesh", true);
}

Member Function Documentation

addChildMeshGenerator()

void MeshGenerator::addChildMeshGenerator ( const MeshGenerator &  mg, const AddParentChildKey    )

inherited

Adds the MeshGenerator mg as a child.

Protected by the AddParentChildKey so that parents can only be added by the MooseApp.

Definition at line 441 of file MeshGenerator.C.

{
  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
  _child_mesh_generators.insert(&mg);
}

addElement() [1/7]

template<>

void DistributedRectilinearMeshGenerator::addElement	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		const dof_id_type	elem_id,
		const processor_id_type	pid,
		const ElemType	type,
		MeshBase &	mesh
	)

addElement() [2/7]

template<>

void DistributedRectilinearMeshGenerator::addElement	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		const dof_id_type	elem_id,
		const processor_id_type	pid,
		const ElemType	type,
		MeshBase &	mesh
	)

addElement() [3/7]

template<>

void DistributedRectilinearMeshGenerator::addElement	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		const dof_id_type	elem_id,
		const processor_id_type	pid,
		const ElemType	type,
		MeshBase &	mesh
	)

addElement() [4/7]

template<>

void DistributedRectilinearMeshGenerator::addElement	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		const dof_id_type	elem_id,
		const processor_id_type	pid,
		const ElemType	type,
		MeshBase &	mesh
	)

Definition at line 713 of file DistributedRectilinearMeshGenerator.C.

{
  BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
  // This ordering was picked to match the ordering in mesh_generation.C
  auto node0_ptr = addPoint<Hex8>(nx, ny, nz, i, j, k, type, mesh);
  node0_ptr->processor_id() = pid;
  auto node1_ptr = addPoint<Hex8>(nx, ny, nz, i + 1, j, k, type, mesh);
  node1_ptr->processor_id() = pid;
  auto node2_ptr = addPoint<Hex8>(nx, ny, nz, i + 1, j + 1, k, type, mesh);
  node2_ptr->processor_id() = pid;
  auto node3_ptr = addPoint<Hex8>(nx, ny, nz, i, j + 1, k, type, mesh);
  node3_ptr->processor_id() = pid;
  auto node4_ptr = addPoint<Hex8>(nx, ny, nz, i, j, k + 1, type, mesh);
  node4_ptr->processor_id() = pid;
  auto node5_ptr = addPoint<Hex8>(nx, ny, nz, i + 1, j, k + 1, type, mesh);
  node5_ptr->processor_id() = pid;
  auto node6_ptr = addPoint<Hex8>(nx, ny, nz, i + 1, j + 1, k + 1, type, mesh);
  node6_ptr->processor_id() = pid;
  auto node7_ptr = addPoint<Hex8>(nx, ny, nz, i, j + 1, k + 1, type, mesh);
  node7_ptr->processor_id() = pid;
 
  Elem * elem = new Hex8;
  elem->set_id(elem_id);
  elem->processor_id() = pid;
  elem->set_unique_id(elem_id);
  elem = mesh.add_elem(elem);
  elem->set_node(0, node0_ptr);
  elem->set_node(1, node1_ptr);
  elem->set_node(2, node2_ptr);
  elem->set_node(3, node3_ptr);
  elem->set_node(4, node4_ptr);
  elem->set_node(5, node5_ptr);
  elem->set_node(6, node6_ptr);
  elem->set_node(7, node7_ptr);
 
  if (k == 0)
    boundary_info.add_side(elem, 0, 0);
 
  if (k == (nz - 1))
    boundary_info.add_side(elem, 5, 5);
 
  if (j == 0)
    boundary_info.add_side(elem, 1, 1);
 
  if (j == (ny - 1))
    boundary_info.add_side(elem, 3, 3);
 
  if (i == 0)
    boundary_info.add_side(elem, 4, 4);
 
  if (i == (nx - 1))
    boundary_info.add_side(elem, 2, 2);
}

addElement() [5/7]

template<>

void DistributedRectilinearMeshGenerator::addElement	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	,
		const dof_id_type	elem_id,
		const processor_id_type	pid,
		const ElemType	type,
		MeshBase &	mesh
	)

Definition at line 449 of file DistributedRectilinearMeshGenerator.C.

{
  BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
  // Bottom Left
  const dof_id_type node0_id = nodeId<Quad4>(type, nx, 0, i, j, 0);
  Node * node0_ptr = mesh.query_node_ptr(node0_id);
  if (!node0_ptr)
  {
    std::unique_ptr<Node> new_node =
        Node::build(Point(static_cast<Real>(i) / nx, static_cast<Real>(j) / ny, 0), node0_id);
 
    new_node->set_unique_id(nx * ny + node0_id);
    new_node->processor_id() = pid;
 
    node0_ptr = mesh.add_node(std::move(new_node));
  }
 
  // Bottom Right
  const dof_id_type node1_id = nodeId<Quad4>(type, nx, 0, i + 1, j, 0);
  Node * node1_ptr = mesh.query_node_ptr(node1_id);
  if (!node1_ptr)
  {
    std::unique_ptr<Node> new_node =
        Node::build(Point(static_cast<Real>(i + 1) / nx, static_cast<Real>(j) / ny, 0), node1_id);
 
    new_node->set_unique_id(nx * ny + node1_id);
    new_node->processor_id() = pid;
 
    node1_ptr = mesh.add_node(std::move(new_node));
  }
 
  // Top Right
  const dof_id_type node2_id = nodeId<Quad4>(type, nx, 0, i + 1, j + 1, 0);
  Node * node2_ptr = mesh.query_node_ptr(node2_id);
  if (!node2_ptr)
  {
    std::unique_ptr<Node> new_node = Node::build(
        Point(static_cast<Real>(i + 1) / nx, static_cast<Real>(j + 1) / ny, 0), node2_id);
 
    new_node->set_unique_id(nx * ny + node2_id);
    new_node->processor_id() = pid;
 
    node2_ptr = mesh.add_node(std::move(new_node));
  }
 
  // Top Left
  const dof_id_type node3_id = nodeId<Quad4>(type, nx, 0, i, j + 1, 0);
  Node * node3_ptr = mesh.query_node_ptr(node3_id);
  if (!node3_ptr)
  {
    std::unique_ptr<Node> new_node =
        Node::build(Point(static_cast<Real>(i) / nx, static_cast<Real>(j + 1) / ny, 0), node3_id);
 
    new_node->set_unique_id(nx * ny + node3_id);
    new_node->processor_id() = pid;
 
    node3_ptr = mesh.add_node(std::move(new_node));
  }
 
  Elem * elem = new Quad4;
  elem->set_id(elem_id);
  elem->processor_id() = pid;
  elem->set_unique_id(elem_id);
  elem = mesh.add_elem(elem);
  elem->set_node(0, node0_ptr);
  elem->set_node(1, node1_ptr);
  elem->set_node(2, node2_ptr);
  elem->set_node(3, node3_ptr);
 
  // Bottom
  if (j == 0)
    boundary_info.add_side(elem, 0, 0);
 
  // Right
  if (i == nx - 1)
    boundary_info.add_side(elem, 1, 1);
 
  // Top
  if (j == ny - 1)
    boundary_info.add_side(elem, 2, 2);
 
  // Left
  if (i == 0)
    boundary_info.add_side(elem, 3, 3);
}

addElement() [6/7]

template<>

void DistributedRectilinearMeshGenerator::addElement	(	const dof_id_type	nx,
		const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	elem_id,
		const processor_id_type	pid,
		const ElemType	,
		MeshBase &	mesh
	)

Definition at line 235 of file DistributedRectilinearMeshGenerator.C.

{
  BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
  auto node_offset = elem_id;
 
  Node * node0_ptr = mesh.query_node_ptr(node_offset);
  if (!node0_ptr)
  {
    std::unique_ptr<Node> new_node =
        Node::build(Point(static_cast<Real>(node_offset) / nx, 0, 0), node_offset);
 
    new_node->set_unique_id(nx + node_offset);
    new_node->processor_id() = pid;
 
    node0_ptr = mesh.add_node(std::move(new_node));
  }
 
  Node * node1_ptr = mesh.query_node_ptr(node_offset + 1);
  if (!node1_ptr)
  {
    std::unique_ptr<Node> new_node =
        Node::build(Point(static_cast<Real>(node_offset + 1) / nx, 0, 0), node_offset + 1);
 
    new_node->set_unique_id(nx + node_offset + 1);
    new_node->processor_id() = pid;
 
    node1_ptr = mesh.add_node(std::move(new_node));
  }
 
  Elem * elem = new Edge2;
  elem->set_id(elem_id);
  elem->processor_id() = pid;
  elem->set_unique_id(elem_id);
  elem = mesh.add_elem(elem);
  elem->set_node(0, node0_ptr);
  elem->set_node(1, node1_ptr);
 
  if (elem_id == 0)
    boundary_info.add_side(elem, 0, 0);
 
  if (elem_id == nx - 1)
    boundary_info.add_side(elem, 1, 1);
}

addElement() [7/7]

template<typename T >

void DistributedRectilinearMeshGenerator::addElement ( const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const processor_id_type  , const ElemType  , MeshBase &    )

inline

Adds an element to the mesh.

Parameters

nx	The number of elements in the x direction
ny	The number of elements in the y direction
nz	The number of elements in the z direction
i	The x index of this element
j	The y index of this element
k	The z index of this element
elem_id	The element ID of the element to add
pid	The processor ID to assign it to
type	The type of element to add
mesh	The mesh to add it to

Definition at line 197 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError(
        "addElement not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

addMeshSubgenerator() [1/2]

void MeshGenerator::addMeshSubgenerator ( const std::string &  type, const std::string &  name, InputParameters  params  )

protectedinherited

Construct a "subgenerator", as above.

User code is responsible for constructing valid InputParameters.

Parameters

type	The type of MeshGenerator
name	The name of the MeshGenerator
params	The parameters to use to construct the MeshGenerator

Definition at line 410 of file MeshGenerator.C.

{
  if (!_app.constructingMeshGenerators())
    mooseError("Can only call addMeshSubgenerator() during MeshGenerator construction");
 
  // In case the user forgot it
  params.set<MooseApp *>(MooseBase::app_param) = &_app;
 
  // Set this to be data-only if this generator is data only
  params.set<bool>(data_only_param) = isDataOnly();
 
  _app.addMeshGenerator(type, name, params);
  _sub_mesh_generators.insert(&std::as_const(_app).getMeshGenerator(name));
}

addMeshSubgenerator() [2/2]

template<typename... Ts>

void MeshGenerator::addMeshSubgenerator ( const std::string &  type, const std::string &  name, Ts...  extra_input_parameters  )

protectedinherited

Construct a "subgenerator", a different MeshGenerator subclass that will be added to the same MooseApp on the fly.

Parameters

type	The type of MeshGenerator
name	The name of the MeshGenerator
extra_input_parameters	... Additional InputParameters to pass

Sub generators must be added in the order that they are executed.

Any input dependencies for a sub generator that come from inputs for this generator must first be declared with the declareMesh(es)ForSub() method.

You can use the output of a sub generator as a mesh in this generator by calling getMesh() with the sub generator's name after adding said sub generator.

Definition at line 593 of file MeshGenerator.h.

{
  InputParameters subgenerator_params = _app.getFactory().getValidParams(type);
 
  subgenerator_params.setParameters(extra_input_parameters...);
 
  addMeshSubgenerator(type, name, subgenerator_params);
}

Referenced by MeshGenerator::addMeshSubgenerator(), OverlayMeshGenerator::OverlayMeshGenerator(), and SideSetExtruderGenerator::SideSetExtruderGenerator().

addParentMeshGenerator()

void MeshGenerator::addParentMeshGenerator ( const MeshGenerator &  mg, const AddParentChildKey    )

inherited

Adds the MeshGenerator mg as a parent.

Protected by the AddParentChildKey so that parents can only be added by the MooseApp.

Definition at line 434 of file MeshGenerator.C.

{
  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
  _parent_mesh_generators.insert(&mg);
}

addPoint() [1/5]

template<>

Node * DistributedRectilinearMeshGenerator::addPoint	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		const ElemType	type,
		MeshBase &	mesh
	)

addPoint() [2/5]

template<>

Node * DistributedRectilinearMeshGenerator::addPoint	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		const ElemType	type,
		MeshBase &	mesh
	)

addPoint() [3/5]

template<>

Node * DistributedRectilinearMeshGenerator::addPoint	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		const ElemType	type,
		MeshBase &	mesh
	)

addPoint() [4/5]

template<>

Node * DistributedRectilinearMeshGenerator::addPoint	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		const ElemType	type,
		MeshBase &	mesh
	)

Definition at line 687 of file DistributedRectilinearMeshGenerator.C.

{
  auto id = nodeId<Hex8>(type, nx, ny, i, j, k);
  Node * node_ptr = mesh.query_node_ptr(id);
  if (!node_ptr)
  {
    std::unique_ptr<Node> new_node = Node::build(
        Point(static_cast<Real>(i) / nx, static_cast<Real>(j) / ny, static_cast<Real>(k) / nz), id);
 
    new_node->set_unique_id(nx * ny * nz + id);
 
    node_ptr = mesh.add_node(std::move(new_node));
  }
 
  return node_ptr;
}

addPoint() [5/5]

template<typename T >

Node * DistributedRectilinearMeshGenerator::addPoint ( const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const ElemType  , MeshBase &    )

inline

Add a node to the mesh.

Parameters

nx	The number of elements in the x direction
nx	The number of elements in the y direction
nz	The number of elements in the z direction
i	The x index of this node
j	The y index of this node
k	The z index of this node
type	The element type
mesh	The mesh to add it to

Definition at line 169 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError(
        "addPoint not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

buildCube()

template<typename T >

void DistributedRectilinearMeshGenerator::buildCube	(	UnstructuredMesh &	mesh,
		const unsigned int	nx,
		unsigned int	ny,
		unsigned int	nz,
		const Real	xmin,
		const Real	xmax,
		const Real	ymin,
		const Real	ymax,
		const Real	zmin,
		const Real	zmax,
		const ElemType	type
	)

Build a cube mesh.

Parameters

mesh	Distributed UnstructuredMesh
nx	The number of elements in the x direction
ny	The number of elements in the y direction
nz	The number of elements in the z direction
xmin	Lower X Coordinate of the generated mesh
xmax	Upper X Coordinate of the generated mesh
ymin	Lower Y Coordinate of the generated mesh
ymax	Upper Y Coordinate of the generated mesh
zmin	Lower Z Coordinate of the generated mesh
zmax	Upper Z Coordinate of the generated mesh
type	The element type

1. "Partition" the element linearly (i.e. break them up into n_procs contiguous chunks
2. Create a (dual) graph of the local elements
3. Partition the graph using PetscExternalPartitioner
4. Push elements to new owners
5. Each processor creates only the elements it owns
6. Find the ghosts we need (all the elements that connect to at least one local mesh vertex)
7. Pull the PIDs of the ghosts
8. Add ghosts with the right PIDs to the mesh

Definition at line 1005 of file DistributedRectilinearMeshGenerator.C.

{
 
  auto & comm = mesh.comm();
 
  dof_id_type num_elems = nx * ny * nz;
 
  const auto num_procs = comm.size();
  // Current processor ID
  const auto pid = comm.rank();
 
  if (_num_cores_for_partition > num_procs)
    mooseError("Number of cores for the graph partitioner is too large ", _num_cores_for_partition);
 
  if (!_num_cores_for_partition)
    _num_cores_for_partition = num_procs;
 
  auto & boundary_info = mesh.get_boundary_info();
 
  std::unique_ptr<Elem> canonical_elem = std::make_unique<T>();
 
  // Will get used to find the neighbors of an element
  std::vector<dof_id_type> neighbors(canonical_elem->n_neighbors());
  // Number of neighbors
  dof_id_type n_neighbors = canonical_elem->n_neighbors();
 
  // "Partition" the elements linearly across the processors
  dof_id_type num_local_elems;
  dof_id_type local_elems_begin;
  dof_id_type local_elems_end;
  if (pid < _num_cores_for_partition)
    MooseUtils::linearPartitionItems(num_elems,
                                     _num_cores_for_partition,
                                     pid,
                                     num_local_elems,
                                     local_elems_begin,
                                     local_elems_end);
  else
  {
    num_local_elems = 0;
    local_elems_begin = 0;
    local_elems_end = 0;
  }
 
  std::vector<std::vector<dof_id_type>> graph;
 
  // Fill in xadj and adjncy
  // xadj is the offset into adjncy
  // adjncy are the face neighbors of each element on this processor
  graph.resize(num_local_elems);
  // Build a distributed graph
  num_local_elems = 0;
  for (dof_id_type e_id = local_elems_begin; e_id < local_elems_end; e_id++)
  {
    dof_id_type i, j, k = 0;
 
    getIndices<T>(nx, ny, e_id, i, j, k);
 
    getNeighbors<T>(nx, ny, nz, i, j, k, neighbors, false);
 
    std::vector<dof_id_type> & row = graph[num_local_elems++];
    row.reserve(n_neighbors);
 
    for (auto neighbor : neighbors)
      if (neighbor != Elem::invalid_id)
        row.push_back(neighbor);
  }
 
  // Partition the distributed graph
  std::vector<dof_id_type> partition_vec;
  if (_partition_method == "linear")
  {
    mooseWarning(" LinearPartitioner is mainly used for setting up regression tests. For the "
                 "production run, please do not use it.");
    // The graph is already partitioned linearly via calling MooseUtils::linearPartitionItems
    partition_vec.resize(num_local_elems);
    // We use it as is
    std::fill(partition_vec.begin(), partition_vec.end(), pid);
  }
  else if (_partition_method == "square")
  {
    // Starting partition indices along x direction
    std::vector<dof_id_type> istarts;
    // Starting partition indices along y direction
    std::vector<dof_id_type> jstarts;
    // Starting partition indices along z direction
    std::vector<dof_id_type> kstarts;
    partition_vec.resize(num_local_elems);
 
    // Partition mesh evenly along each direction
    paritionSquarely<T>(nx, ny, nz, num_procs, istarts, jstarts, kstarts);
    // At least one processor
    mooseAssert(istarts.size() > 1, "At least there is one processor along x direction");
    processor_id_type px = istarts.size() - 1;
    // At least one processor
    mooseAssert(jstarts.size() > 1, "At least there is one processor along y direction");
    processor_id_type py = jstarts.size() - 1;
    // At least one processor
    mooseAssert(kstarts.size() > 1, "At least there is one processor along z direction");
    // processor_id_type pz = kstarts.size() -1;
    for (dof_id_type e_id = local_elems_begin; e_id < local_elems_end; e_id++)
    {
      dof_id_type i = 0, j = 0, k = 0;
      getIndices<T>(nx, ny, e_id, i, j, k);
      processor_id_type pi = 0, pj = 0, pk = 0;
 
      pi = (std::upper_bound(istarts.begin(), istarts.end(), i) - istarts.begin()) - 1;
      pj = (std::upper_bound(jstarts.begin(), jstarts.end(), j) - jstarts.begin()) - 1;
      pk = (std::upper_bound(kstarts.begin(), kstarts.end(), k) - kstarts.begin()) - 1;
 
      partition_vec[e_id - local_elems_begin] = pk * px * py + pj * px + pi;
 
      mooseAssert((pk * px * py + pj * px + pi) < num_procs, "processor id is too large");
    }
  }
  else if (_partition_method == "graph")
    PetscExternalPartitioner::partitionGraph(
        comm, graph, {}, {}, num_procs, _num_parts_per_compute_node, _part_package, partition_vec);
  else
    mooseError("Unsupported partition method " + _partition_method);
 
  mooseAssert(partition_vec.size() == num_local_elems, " Invalid partition was generateed ");
 
  // Use current elements to remote processors according to partition
  std::map<processor_id_type, std::vector<dof_id_type>> pushed_elements_vecs;
 
  for (dof_id_type e_id = local_elems_begin; e_id < local_elems_end; e_id++)
    pushed_elements_vecs[partition_vec[e_id - local_elems_begin]].push_back(e_id);
 
  // Collect new elements I should own
  std::vector<dof_id_type> my_new_elems;
 
  auto elements_action_functor =
      [&my_new_elems](processor_id_type /*pid*/, const std::vector<dof_id_type> & data)
  { std::copy(data.begin(), data.end(), std::back_inserter(my_new_elems)); };
 
  Parallel::push_parallel_vector_data(comm, pushed_elements_vecs, elements_action_functor);
 
  // Add the elements this processor owns
  for (auto e_id : my_new_elems)
  {
    dof_id_type i = 0, j = 0, k = 0;
 
    getIndices<T>(nx, ny, e_id, i, j, k);
 
    addElement<T>(nx, ny, nz, i, j, k, e_id, pid, type, mesh);
  }
 
  // Need to link up the local elements before we can know what's missing
  mesh.find_neighbors();
 
  // Get the ghosts (missing face neighbors)
  std::set<dof_id_type> ghost_elems;
  // Current local elements
  std::set<dof_id_type> current_elems;
 
  // Fill current elems
  // We will grow domain from current elements
  for (auto & elem_ptr : mesh.element_ptr_range())
    current_elems.insert(elem_ptr->id());
 
  // Grow domain layer by layer
  for (unsigned layer = 0; layer < _num_side_layers; layer++)
  {
    // getGhostNeighbors produces one layer of side neighbors
    getGhostNeighbors<T>(nx, ny, nz, mesh, current_elems, ghost_elems);
    // Merge ghost elements into current element list
    current_elems.insert(ghost_elems.begin(), ghost_elems.end());
  }
  // We do not need it anymore
  current_elems.clear();
 
  // Elements we're going to request from others
  std::map<processor_id_type, std::vector<dof_id_type>> ghost_elems_to_request;
 
  for (auto & ghost_id : ghost_elems)
  {
    // This is the processor ID the ghost_elem was originally assigned to
    auto proc_id = MooseUtils::linearPartitionChunk(num_elems, _num_cores_for_partition, ghost_id);
 
    // Using side-effect insertion on purpose
    ghost_elems_to_request[proc_id].push_back(ghost_id);
  }
 
  // Next set ghost object ids from other processors
  auto gather_functor =
      [local_elems_begin, partition_vec](processor_id_type /*pid*/,
                                         const std::vector<dof_id_type> & coming_ghost_elems,
                                         std::vector<dof_id_type> & pid_for_ghost_elems)
  {
    auto num_ghost_elems = coming_ghost_elems.size();
    pid_for_ghost_elems.resize(num_ghost_elems);
 
    dof_id_type num_local_elems = 0;
 
    for (auto elem : coming_ghost_elems)
      pid_for_ghost_elems[num_local_elems++] = partition_vec[elem - local_elems_begin];
  };
 
  std::unordered_map<dof_id_type, processor_id_type> ghost_elem_to_pid;
 
  auto action_functor =
      [&ghost_elem_to_pid](processor_id_type /*pid*/,
                           const std::vector<dof_id_type> & my_ghost_elems,
                           const std::vector<dof_id_type> & pid_for_my_ghost_elems)
  {
    dof_id_type num_local_elems = 0;
 
    for (auto elem : my_ghost_elems)
      ghost_elem_to_pid[elem] = pid_for_my_ghost_elems[num_local_elems++];
  };
 
  const dof_id_type * ex = nullptr;
  libMesh::Parallel::pull_parallel_vector_data(
      comm, ghost_elems_to_request, gather_functor, action_functor, ex);
 
  // Add the ghost elements to the mesh
  for (auto gtop : ghost_elem_to_pid)
  {
    auto ghost_id = gtop.first;
    auto proc_id = gtop.second;
 
    dof_id_type i = 0, j = 0, k = 0;
 
    getIndices<T>(nx, ny, ghost_id, i, j, k);
 
    addElement<T>(nx, ny, nz, i, j, k, ghost_id, proc_id, type, mesh);
  }
 
  mesh.find_neighbors(true);
 
  // Set RemoteElem neighbors
  for (auto & elem_ptr : mesh.element_ptr_range())
    for (unsigned int s = 0; s < elem_ptr->n_sides(); s++)
      if (!elem_ptr->neighbor_ptr(s) && !boundary_info.n_boundary_ids(elem_ptr, s))
        elem_ptr->set_neighbor(s, const_cast<RemoteElem *>(remote_elem));
 
  setBoundaryNames<T>(boundary_info);
 
  Partitioner::set_node_processor_ids(mesh);
 
  // Already partitioned!
  mesh.skip_partitioning(true);
 
  // Scale the nodal positions
  scaleNodalPositions<T>(nx, ny, nz, xmin, xmax, ymin, ymax, zmin, zmax, mesh);
}

buildDistributedMesh()

std::unique_ptr< DistributedMesh > MeshGenerator::buildDistributedMesh ( unsigned int  dim = libMesh::invalid_uint )

protectedinherited

Build a distributed mesh that has correct remote element removal behavior and geometric ghosting functors based on the simulation objects.

Parameters

dim	The logical dimension of the mesh, e.g. 3 for hexes/tets, 2 for quads/tris. If the caller doesn't specify a value for dim, then the value in the Mesh input file block will be used

Definition at line 303 of file MeshGenerator.C.

{
  mooseAssert(_mesh, "Need a MooseMesh object");
  return _mesh->buildTypedMesh<DistributedMesh>(dim);
}

Referenced by generate().

buildMeshBaseObject()

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

protectedinherited

Build a MeshBase object whose underlying type will be determined by the Mesh input file block.

Parameters

dim	The logical dimension of the mesh, e.g. 3 for hexes/tets, 2 for quads/tris. If the caller doesn't specify a value for dim, then the value in the Mesh input file block will be used

Definition at line 289 of file MeshGenerator.C.

{
  mooseAssert(_mesh, "Need a MooseMesh object");
  return _mesh->buildMeshBaseObject(dim);
}

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AdvancedExtruderGenerator::generate(), AnnularMeshGenerator::generate(), BlockToMeshConverterGenerator::generate(), Boundary2DDelaunayGenerator::generate(), CartesianMeshGenerator::generate(), ElementGenerator::generate(), ExamplePatchMeshGenerator::generate(), FileMeshGenerator::generate(), GeneratedMeshGenerator::generate(), MeshExtruderGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), PolyLineMeshGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), SphereMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), and TransfiniteMeshGenerator::generate().

buildReplicatedMesh()

std::unique_ptr< ReplicatedMesh > MeshGenerator::buildReplicatedMesh ( unsigned int  dim = libMesh::invalid_uint )

protectedinherited

Build a replicated mesh.

Parameters

dim	The logical dimension of the mesh, e.g. 3 for hexes/tets, 2 for quads/tris. If the caller doesn't specify a value for dim, then the value in the Mesh input file block will be used

Definition at line 296 of file MeshGenerator.C.

{
  mooseAssert(_mesh, "Need a MooseMesh object");
  return _mesh->buildTypedMesh<ReplicatedMesh>(dim);
}

Referenced by BSplineCurveGenerator::generate(), ConcentricCircleMeshGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), ImageMeshGenerator::generate(), ParsedCurveGenerator::generate(), RinglebMeshGenerator::generate(), SpiralAnnularMeshGenerator::generate(), and SurfaceSubdomainsDelaunayRemesher::generate().

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

checkGetMesh()

void MeshGenerator::checkGetMesh ( const MeshGeneratorName &  mesh_generator_name, const std::string &  param_name  ) const

privateinherited

Helper for performing error checking in the getMesh methods.

Definition at line 158 of file MeshGenerator.C.

{
  mooseAssert(!mesh_generator_name.empty(), "Empty name");
  const auto & mg_sys = _app.getMeshGeneratorSystem();
  if (!hasGenerateCSG() && !_app.constructingMeshGenerators())
    mooseError("Cannot get a mesh outside of construction");
  if (!mg_sys.hasMeshGenerator(mesh_generator_name) && !isNullMeshName(mesh_generator_name))
  {
    std::stringstream error;
    error << "The requested MeshGenerator with name '" << mesh_generator_name << "' ";
    if (mg_sys.hasMeshGeneratorParams(mesh_generator_name))
      error << "was found, but has not been constructed yet.\n\nThis can occur when your "
               "dependencies are not properly defined and we cannot infer the proper construction "
               "order of your MeshGenerators.\n\nThe most likely case is a sub generator whose "
               "input(s) are not declared as a sub dependency in the generator creating them.";
    else
      error << "was not found.\nMesh generators that can be found: "
            << Moose::stringify(mg_sys.getMeshGeneratorNames());
 
    if (param_name.size())
      paramError(param_name, error.str());
    else
      mooseError(error.str());
  }
}

Referenced by MeshGenerator::declareMeshForSubByName(), MeshGenerator::getCSGBaseByName(), MeshGenerator::getMeshByName(), MeshGenerator::getMeshGeneratorNameFromParam(), and MeshGenerator::getMeshGeneratorNamesFromParam().

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

copyMeshProperty() [1/2]

template<typename T >

T & MeshGenerator::copyMeshProperty ( const std::string &  source_data_name, const std::string &  source_mesh  )

inlineprotectedinherited

Method for copying attribute from input mesh meta-data store to current mesh meta-data store, keeping source and target data names the same.

This may often be avoided as getMeshProperty calls can traverse the tree of mesh generators to find a metadata instance

Definition at line 276 of file MeshGenerator.h.

  {
    return copyMeshProperty<T>(source_data_name, source_data_name, source_mesh);
  }

copyMeshProperty() [2/2]

template<typename T >

T & MeshGenerator::copyMeshProperty ( const std::string &  target_data_name, const std::string &  source_data_name, const std::string &  source_mesh  )

inlineprotectedinherited

Method for copying attribute from input mesh meta-data store to current mesh meta-data store.

This may often be avoided as getMeshProperty calls can traverse the tree of mesh generators to find a metadata instance

Definition at line 263 of file MeshGenerator.h.

  {
    return declareMeshProperty(target_data_name, getMeshProperty<T>(source_data_name, source_mesh));
  }

declareMeshesForSub()

void MeshGenerator::declareMeshesForSub ( const std::string &  param_name )

protectedinherited

Like declareMeshForSub(), but for multiple generators.

Definition at line 265 of file MeshGenerator.C.

{
  declareMeshesForSubByName(getMeshGeneratorNamesFromParam(param_name));
}

declareMeshesForSubByName()

void MeshGenerator::declareMeshesForSubByName ( const std::vector< MeshGeneratorName > &  mesh_generator_names )

protectedinherited

Like declareMeshForSubByName(), but for multiple generators.

Definition at line 281 of file MeshGenerator.C.

{
  for (const auto & name : mesh_generator_names)
    declareMeshForSubByName(name);
}

Referenced by MeshGenerator::declareMeshesForSub().

declareMeshForSub()

void MeshGenerator::declareMeshForSub ( const std::string &  param_name )

protectedinherited

Declares that a MeshGenerator referenced in the InputParameters is to be used as a dependency of a sub MeshGenerator created by this MeshGenerator (see addSubMeshGenerator)

You must declare all such MeshGenerators that are passed by parameter to this MeshGenerator but instead used in a sub MeshGenerator. This is in order to declare the intention to use an input mesh as a dependency for a sub generator instead of this one.

Definition at line 259 of file MeshGenerator.C.

{
  declareMeshForSubByName(*getMeshGeneratorNameFromParam(param_name, false));
}

Referenced by OverlayMeshGenerator::OverlayMeshGenerator(), and SideSetExtruderGenerator::SideSetExtruderGenerator().

declareMeshForSubByName()

void MeshGenerator::declareMeshForSubByName ( const MeshGeneratorName &  mesh_generator_name )

protectedinherited

Like declareMeshForSub(), but takes the name of another MeshGenerator directly.

Definition at line 271 of file MeshGenerator.C.

{
  checkGetMesh(mesh_generator_name, "");
  if (isNullMeshName(mesh_generator_name))
    return;
 
  _requested_mesh_generators_for_sub.insert(mesh_generator_name);
}

Referenced by MeshGenerator::declareMeshesForSubByName(), and MeshGenerator::declareMeshForSub().

declareMeshProperty() [1/2]

template<typename T , typename... Args>

T & MeshGenerator::declareMeshProperty ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Methods for writing out attributes to the mesh meta-data store, which can be retrieved from most other MOOSE systems and is recoverable.

Definition at line 535 of file MeshGenerator.h.

{
  if (!_app.constructingMeshGenerators())
    mooseError("Can only call declareMeshProperty() during MeshGenerator construction");
 
  // We sort construction ordering so that we _must_ declare before retrieving
  if (hasMeshProperty(data_name))
    mooseError("While declaring mesh property '",
               data_name,
               "' with type '",
               MooseUtils::prettyCppType<T>(),
               "',\nsaid property has already been declared with type '",
               setMeshPropertyHelper(data_name).type(),
               "'");
 
  const auto full_name = meshPropertyName(data_name);
  auto new_T_value =
      std::make_unique<RestartableData<T>>(full_name, nullptr, std::forward<Args>(args)...);
  auto value =
      &_app.registerRestartableData(std::move(new_T_value), 0, false, MooseApp::MESH_META_DATA);
  mooseAssert(value->declared(), "Should be declared");
 
  RestartableData<T> * T_value = dynamic_cast<RestartableData<T> *>(value);
  mooseAssert(T_value, "Bad cast");
 
  return T_value->set();
}

Referenced by AddMetaDataGenerator::AddMetaDataGenerator(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), MeshGenerator::copyMeshProperty(), DistributedRectilinearMeshGenerator(), ImageMeshGenerator::ImageMeshGenerator(), RinglebMeshGenerator::RinglebMeshGenerator(), and SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator().

declareMeshProperty() [2/2]

template<typename T >

T & MeshGenerator::declareMeshProperty ( const std::string &  data_name, const T &  data_value  )

inlineprotectedinherited

Definition at line 236 of file MeshGenerator.h.

  {
    return declareMeshProperty<T, const T &>(data_name, data_value);
  }

declareNullMeshName()

void MeshGenerator::declareNullMeshName ( const MeshGeneratorName &  name )

protectedinherited

Registers the name name as a "null" mesh, which is a MeshGenerator used in InputParameters that will not represent an input mesh when requested via getMesh.

An example use case for this is when you as a developer want users to represent a hole in a mesh pattern that is defined in input.

Definition at line 474 of file MeshGenerator.C.

{
  mooseAssert(_app.constructingMeshGenerators(), "Should only be called at construction");
  mooseAssert(!_null_mesh_names.count(name), "Already declared");
  _null_mesh_names.insert(name);
}

elemId() [1/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::elemId	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

elemId() [2/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::elemId	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

elemId() [3/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::elemId	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

elemId() [4/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::elemId	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

Definition at line 577 of file DistributedRectilinearMeshGenerator.C.

{
  return i + (j * nx) + (k * nx * ny);
}

elemId() [5/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::elemId	(	const dof_id_type	nx,
		const dof_id_type	,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type
	)

Definition at line 342 of file DistributedRectilinearMeshGenerator.C.

{
  return (j * nx) + i;
}

elemId() [6/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::elemId	(	const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	i,
		const dof_id_type	,
		const dof_id_type
	)

Definition at line 224 of file DistributedRectilinearMeshGenerator.C.

{
  return i;
}

elemId() [7/7]

template<typename T >

dof_id_type DistributedRectilinearMeshGenerator::elemId ( const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type    )

inline

Get the element ID for a given hex.

Parameters

nx	The number of elements in the x direction
ny	The number of elements in the y direction
i	The x index of this element
j	The y index of this element
k	The z index of this element

Returns

The ID of the i,j element

Definition at line 74 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError(
        "elemId not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

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

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

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

generate()

std::unique_ptr< MeshBase > DistributedRectilinearMeshGenerator::generate ( )

overridevirtual

Generate / modify the mesh.

Implements MeshGenerator.

Definition at line 1272 of file DistributedRectilinearMeshGenerator.C.

{
  // We will set up boundaries accordingly. We do not want to call
  // ghostGhostedBoundaries in which allgather_packed_range  is unscalable.
  // ghostGhostedBoundaries will gather all boundaries to every single processor
  _mesh->needGhostGhostedBoundaries(false);
 
  // DistributedRectilinearMeshGenerator always generates a distributed mesh
  auto mesh = buildDistributedMesh();
 
  MooseEnum elem_type_enum = getParam<MooseEnum>("elem_type");
 
  if (!isParamValid("elem_type"))
  {
    // Switching on MooseEnum
    switch (_dim)
    {
      case 1:
        elem_type_enum = "EDGE2";
        break;
      case 2:
        elem_type_enum = "QUAD4";
        break;
      case 3:
        elem_type_enum = "HEX8";
        break;
    }
  }
 
  _elem_type = Utility::string_to_enum<ElemType>(elem_type_enum);
 
  mesh->set_mesh_dimension(_dim);
  mesh->set_spatial_dimension(_dim);
  // Let the mesh know that it's not serialized
  mesh->set_distributed();
 
  // Switching on MooseEnum
  switch (_dim)
  {
    // The build_XYZ mesh generation functions take an
    // UnstructuredMesh& as the first argument, hence the dynamic_cast.
    case 1:
      buildCube<Edge2>(
          dynamic_cast<UnstructuredMesh &>(*mesh), _nx, 1, 1, _xmin, _xmax, 0, 0, 0, 0, _elem_type);
      break;
    case 2:
      buildCube<Quad4>(dynamic_cast<UnstructuredMesh &>(*mesh),
                       _nx,
                       _ny,
                       1,
                       _xmin,
                       _xmax,
                       _ymin,
                       _ymax,
                       0,
                       0,
                       _elem_type);
      break;
    case 3:
      buildCube<Hex8>(dynamic_cast<UnstructuredMesh &>(*mesh),
                      _nx,
                      _ny,
                      _nz,
                      _xmin,
                      _xmax,
                      _ymin,
                      _ymax,
                      _zmin,
                      _zmax,
                      _elem_type);
      break;
    default:
      mooseError(
          getParam<MooseEnum>("elem_type"),
          " is not a currently supported element type for DistributedRectilinearMeshGenerator");
  }
 
  // Apply the bias if any exists
  if (_bias_x != 1.0 || _bias_y != 1.0 || _bias_z != 1.0)
  {
    // Biases
    Real bias[3] = {_bias_x, _bias_y, _bias_z};
 
    // "width" of the mesh in each direction
    Real width[3] = {_xmax - _xmin, _ymax - _ymin, _zmax - _zmin};
 
    // Min mesh extent in each direction.
    Real mins[3] = {_xmin, _ymin, _zmin};
 
    // Number of elements in each direction.
    dof_id_type nelem[3] = {_nx, _ny, _nz};
 
    // We will need the biases raised to integer powers in each
    // direction, so let's pre-compute those...
    std::vector<std::vector<Real>> pows(LIBMESH_DIM);
    for (dof_id_type dir = 0; dir < LIBMESH_DIM; ++dir)
    {
      pows[dir].resize(nelem[dir] + 1);
      for (dof_id_type i = 0; i < pows[dir].size(); ++i)
        pows[dir][i] = std::pow(bias[dir], static_cast<int>(i));
    }
 
    // Loop over the nodes and move them to the desired location
    for (auto & node_ptr : mesh->node_ptr_range())
    {
      Node & node = *node_ptr;
 
      for (dof_id_type dir = 0; dir < LIBMESH_DIM; ++dir)
      {
        if (width[dir] != 0. && bias[dir] != 1.)
        {
          // Compute the scaled "index" of the current point.  This
          // will either be close to a whole integer or a whole
          // integer+0.5 for quadratic nodes.
          Real float_index = (node(dir) - mins[dir]) * nelem[dir] / width[dir];
 
          Real integer_part = 0;
          Real fractional_part = std::modf(float_index, &integer_part);
 
          // Figure out where to move the node...
          if (std::abs(fractional_part) < TOLERANCE || std::abs(fractional_part - 1.0) < TOLERANCE)
          {
            // If the fractional_part ~ 0.0 or 1.0, this is a vertex node, so
            // we don't need an average.
            //
            // Compute the "index" we are at in the current direction.  We
            // round to the nearest integral value to get this instead
            // of using "integer_part", since that could be off by a
            // lot (e.g. we want 3.9999 to map to 4.0 instead of 3.0).
            int index = round(float_index);
 
            // Move node to biased location.
            node(dir) =
                mins[dir] + width[dir] * (1. - pows[dir][index]) / (1. - pows[dir][nelem[dir]]);
          }
          else if (std::abs(fractional_part - 0.5) < TOLERANCE)
          {
            // If the fractional_part ~ 0.5, this is a midedge/face
            // (i.e. quadratic) node.  We don't move those with the same
            // bias as the vertices, instead we put them midway between
            // their respective vertices.
            //
            // Also, since the fractional part is nearly 0.5, we know that
            // the integer_part will be the index of the vertex to the
            // left, and integer_part+1 will be the index of the
            // vertex to the right.
            node(dir) = mins[dir] +
                        width[dir] *
                            (1. - 0.5 * (pows[dir][integer_part] + pows[dir][integer_part + 1])) /
                            (1. - pows[dir][nelem[dir]]);
          }
          else
          {
            // We don't yet handle anything higher order than quadratic...
            mooseError("Unable to bias node at node(", dir, ")=", node(dir));
          }
        }
      }
    }
  }
 
  // MeshOutput<MT>::write_equation_systems will automatically renumber node and element IDs.
  // So we have to make that consistent at the first place. Otherwise, the moose cached data such as
  // _block_node_list will be inconsistent when we doing MooseMesh::getNodeBlockIds. That being
  // said, moose will pass new ids to getNodeBlockIds while the cached _block_node_list still use
  // the old node IDs. Yes, you could say: go ahead to do a mesh update, but I would say no. I do
  // not change mesh and there is no point to update anything.
  mesh->allow_renumbering(true);
  mesh->prepare_for_use();
 
  return dynamic_pointer_cast<MeshBase>(mesh);
}

generateCSG()

std::unique_ptr< CSG::CSGBase > MeshGenerator::generateCSG ( )

protectedvirtualinherited

Generate the CSG representation of the mesh (or meshing operation) created by this mesh generator.

Definition at line 507 of file MeshGenerator.C.

{
  mooseAssert(!hasGenerateCSG(), "Inconsistent flag");
  mooseError("This MeshGenerator does not have a generateCSG() implementation.");
}

Referenced by MeshGenerator::generateInternalCSG().

generateData()

void MeshGenerator::generateData ( )

protectedvirtualinherited

Generate the mesh data.

Reimplemented in AddMetaDataGenerator.

Definition at line 500 of file MeshGenerator.C.

{
  mooseAssert(!hasGenerateData(), "Inconsistent flag");
  mooseError("This MeshGenerator does not have a generateData() implementation.");
}

Referenced by MeshGenerator::generateInternal().

generateInternal()

std::unique_ptr< MeshBase > MeshGenerator::generateInternal ( )

inherited

Internal generation method - this is what is actually called within MooseApp to execute the MeshGenerator.

Definition at line 310 of file MeshGenerator.C.

{
  libmesh_parallel_only(comm());
  mooseAssert(comm().verify(type() + name()), "Inconsistent execution ordering");
 
  if (hasGenerateData())
    generateData();
 
  if (isDataOnly())
    return nullptr;
 
  auto mesh = generate();
  if (!mesh)
    mooseError("A mesh was not generated by this generator (it was nullptr).");
 
  for (const auto & [requested_name, requested_mesh] : _requested_meshes)
    if (*requested_mesh)
      mooseError(
          "The mesh from input ",
          _app.getMeshGenerator(requested_name).type(),
          " '",
          _app.getMeshGenerator(requested_name).name(),
          "' was not moved.\n\nThe MeshGenerator system requires that the memory from all input "
          "meshes\nare managed by the requesting MeshGenerator during the generate phase.\n\nThis "
          "is achieved with a std::move() operation within the generate() method.");
 
  if (getParam<bool>("show_info"))
  {
    if (!mesh->is_prepared())
      mesh->prepare_for_use();
 
    const auto mesh_info = mesh->get_info(/* verbosity = */ 2);
 
    // We will prefix all information with "type() 'name()':" because this could potentially
    // output a ton of information and looks a bit better with a prefix
    std::stringstream oss;
    const auto split = MooseUtils::split(mesh_info, "\n");
    if (split.size())
      for (std::size_t i = 0; i < split.size() - 1; ++i) // ignore the last line break
        oss << COLOR_CYAN << "" << type() << " '" << name() << "': " << COLOR_DEFAULT << split[i]
            << std::endl;
    _console << oss.str() << std::flush;
  }
 
  // output the current mesh block to file
  if (hasOutput())
  {
    if (!mesh->is_prepared())
      mesh->prepare_for_use();
 
    if (!getParam<bool>("nemesis"))
    {
      libMesh::ExodusII_IO exio(*mesh);
 
      if (mesh->mesh_dimension() == 1)
        exio.write_as_dimension(3);
 
      // Avoid truncating names
      exio.set_max_name_length(80);
 
      // Default to non-HDF5 output for wider compatibility
      exio.set_hdf5_writing(false);
 
      exio.write(name() + "_in.e");
    }
    else
    {
      libMesh::Nemesis_IO nemesis_io(*mesh);
 
      // Default to non-HDF5 output for wider compatibility
      nemesis_io.set_hdf5_writing(false);
 
      nemesis_io.write(name() + "_in.e");
    }
  }
 
  return mesh;
}

generateInternalCSG()

std::unique_ptr< CSG::CSGBase > MeshGenerator::generateInternalCSG ( )

inherited

Internal generation method for CSG object generation.

Definition at line 390 of file MeshGenerator.C.

{
  mooseAssert(isDataOnly(), "Trying to use csg-only mode while not in data-driven mode");
  auto csg_obj = generateCSG();
  mooseAssert(csg_obj, "Null CSG object");
  for (const auto & [requested_name, requested_csg] : _requested_csg_bases)
    if (*requested_csg)
      mooseError(
          "The CSGBase object from input ",
          _app.getMeshGenerator(requested_name).type(),
          " '",
          _app.getMeshGenerator(requested_name).name(),
          "' was not moved.\n\nThe MeshGenerator system requires that the memory from all input "
          "meshes\nare managed by the requesting MeshGenerator during the generate phase.\n\nThis "
          "is achieved with a std::move() operation within the generateCSG() method.");
 
  return csg_obj;
}

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 Factory::copyConstruct(), and MooseBase::uniqueParameterName().

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

getChildMeshGenerators()

const std::set< const MeshGenerator *, Comparator > & MeshGenerator::getChildMeshGenerators ( ) const

inlineinherited

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 148 of file MeshGenerator.h.

  {
    return _child_mesh_generators;
  }

Referenced by MeshGenerator::isChildMeshGenerator().

getCSGBase()

std::unique_ptr< CSG::CSGBase > & MeshGenerator::getCSGBase ( const std::string &  param_name )

protectedinherited

Takes the name of a MeshGeneratorName parameter and then gets a pointer to the CSGBase object that MeshGenerator has created.

NOTE: You MUST catch this by reference!

Parameters

param_name

The name of the parameter that contains the name of the MeshGenerator

Returns

The CSGBase object generated by that MeshGenerator

Definition at line 223 of file MeshGenerator.C.

{
  const MeshGeneratorName * name = getMeshGeneratorNameFromParam(param_name, false);
  if (!name)
    return _null_csg_base;
  return getCSGBaseByName(*name);
}

getCSGBaseByName()

std::unique_ptr< CSG::CSGBase > & MeshGenerator::getCSGBaseByName ( const MeshGeneratorName &  mesh_generator_name )

protectedinherited

Like getCSGBase(), but takes the name of another MeshGenerator directly.

NOTE: You MUST catch this by reference!

Parameters

mesh_generator_name

The name of the MeshGenerator associated with the CSGBase object

Returns

The CSGBase pointer generated by that MeshGenerator

Definition at line 232 of file MeshGenerator.C.

{
  checkGetMesh(mesh_generator_name, "");
  if (isNullMeshName(mesh_generator_name))
    return _null_csg_base;
 
  auto & csg_base = _app.getMeshGeneratorSystem().getCSGBaseGeneratorOutput(mesh_generator_name);
  _requested_csg_bases.emplace_back(mesh_generator_name, &csg_base);
  return csg_base;
}

Referenced by MeshGenerator::getCSGBase(), and MeshGenerator::getCSGBasesByName().

getCSGBases()

std::vector< std::unique_ptr< CSG::CSGBase > * > MeshGenerator::getCSGBases ( const std::string &  param_name )

protectedinherited

Like getCSGBase(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters

param_name

The name of the parameter that contains the names of MeshGenerator objects

Returns

Vector of CSGBase pointers associated with input parameter

Definition at line 244 of file MeshGenerator.C.

{
  return getCSGBasesByName(getMeshGeneratorNamesFromParam(param_name));
}

getCSGBasesByName()

std::vector< std::unique_ptr< CSG::CSGBase > * > MeshGenerator::getCSGBasesByName ( const std::vector< MeshGeneratorName > &  mesh_generator_names )

protectedinherited

Like getCSGBaseByName(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters

mesh_generator_names

The names of MeshGenerator objects

Returns

Vector of CSGBase pointers associated with input parameter

Definition at line 250 of file MeshGenerator.C.

{
  std::vector<std::unique_ptr<CSG::CSGBase> *> csg_bases;
  for (const auto & name : mesh_generator_names)
    csg_bases.push_back(&getCSGBaseByName(name));
  return csg_bases;
}

Referenced by MeshGenerator::getCSGBases().

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

getGhostNeighbors() [1/7]

template<>

void DistributedRectilinearMeshGenerator::getGhostNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const MeshBase &	mesh,
		const std::set< dof_id_type > &	current_elems,
		std::set< dof_id_type > &	ghost_elems
	)

getGhostNeighbors() [2/7]

template<>

void DistributedRectilinearMeshGenerator::getGhostNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const MeshBase &	mesh,
		const std::set< dof_id_type > &	current_elems,
		std::set< dof_id_type > &	ghost_elems
	)

getGhostNeighbors() [3/7]

template<>

void DistributedRectilinearMeshGenerator::getGhostNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const MeshBase &	mesh,
		const std::set< dof_id_type > &	current_elems,
		std::set< dof_id_type > &	ghost_elems
	)

getGhostNeighbors() [4/7]

template<>

void DistributedRectilinearMeshGenerator::getGhostNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const MeshBase &	mesh,
		const std::set< dof_id_type > &	current_elems,
		std::set< dof_id_type > &	ghost_elems
	)

Definition at line 793 of file DistributedRectilinearMeshGenerator.C.

{
  dof_id_type i, j, k;
 
  std::vector<dof_id_type> neighbors(27);
 
  for (auto elem_id : current_elems)
  {
    getIndices<Hex8>(nx, ny, elem_id, i, j, k);
 
    getNeighbors<Hex8>(nx, ny, nz, i, j, k, neighbors, true);
 
    for (auto neighbor : neighbors)
      if (neighbor != Elem::invalid_id && !mesh.query_elem_ptr(neighbor))
        ghost_elems.insert(neighbor);
  }
}

getGhostNeighbors() [5/7]

template<>

void DistributedRectilinearMeshGenerator::getGhostNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	,
		const MeshBase &	mesh,
		const std::set< dof_id_type > &	current_elems,
		std::set< dof_id_type > &	ghost_elems
	)

Definition at line 410 of file DistributedRectilinearMeshGenerator.C.

{
  dof_id_type i, j, k;
 
  std::vector<dof_id_type> neighbors(9);
 
  for (auto elem_id : current_elems)
  {
    getIndices<Quad4>(nx, 0, elem_id, i, j, k);
 
    getNeighbors<Quad4>(nx, ny, 0, i, j, 0, neighbors, true);
 
    for (auto neighbor : neighbors)
      if (neighbor != Elem::invalid_id && !mesh.query_elem_ptr(neighbor))
        ghost_elems.insert(neighbor);
  }
}

getGhostNeighbors() [6/7]

template<>

void DistributedRectilinearMeshGenerator::getGhostNeighbors	(	const dof_id_type	nx,
		const dof_id_type	,
		const dof_id_type	,
		const MeshBase &	mesh,
		const std::set< dof_id_type > &	current_elems,
		std::set< dof_id_type > &	ghost_elems
	)

Definition at line 202 of file DistributedRectilinearMeshGenerator.C.

{
  std::vector<dof_id_type> neighbors(2);
 
  for (auto elem_id : current_elems)
  {
    getNeighbors<Edge2>(nx, 0, 0, elem_id, 0, 0, neighbors, true);
 
    for (auto neighbor : neighbors)
      if (neighbor != Elem::invalid_id && !mesh.query_elem_ptr(neighbor))
        ghost_elems.insert(neighbor);
  }
}

getGhostNeighbors() [7/7]

template<typename T >

void DistributedRectilinearMeshGenerator::getGhostNeighbors ( const dof_id_type  , const dof_id_type  , const dof_id_type  , const MeshBase &  , const std::set< dof_id_type > &  , std::set< dof_id_type > &    )

inline

Find the elements and sides that need ghost elements.

Parameters

nx	The number of elements in the x direction
ny	The number of elements in the y direction
mesh	The mesh - without any ghost elements
ghost_elems	The ghost elems that need to be added

Definition at line 271 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError("getGhostNeighbors not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

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

getIndices() [1/7]

template<>

void DistributedRectilinearMeshGenerator::getIndices	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	elem_id,
		dof_id_type &	i,
		dof_id_type &	j,
		dof_id_type &	k
	)

getIndices() [2/7]

template<>

void DistributedRectilinearMeshGenerator::getIndices	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	elem_id,
		dof_id_type &	i,
		dof_id_type &	j,
		dof_id_type &	k
	)

getIndices() [3/7]

template<>

void DistributedRectilinearMeshGenerator::getIndices	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	elem_id,
		dof_id_type &	i,
		dof_id_type &	j,
		dof_id_type &	k
	)

getIndices() [4/7]

template<>

void DistributedRectilinearMeshGenerator::getIndices	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	elem_id,
		dof_id_type &	i,
		dof_id_type &	j,
		dof_id_type &	k
	)

Definition at line 779 of file DistributedRectilinearMeshGenerator.C.

{
  i = elem_id % nx;
  j = (((elem_id - i) / nx) % ny);
  k = ((elem_id - i) - (j * nx)) / (nx * ny);
}

getIndices() [5/7]

template<>

void DistributedRectilinearMeshGenerator::getIndices	(	const dof_id_type	nx,
		const dof_id_type	,
		const dof_id_type	elem_id,
		dof_id_type &	i,
		dof_id_type &	j,
		dof_id_type &
	)

Definition at line 397 of file DistributedRectilinearMeshGenerator.C.

{
  i = elem_id % nx;
  j = (elem_id - i) / nx;
}

getIndices() [6/7]

template<>

void DistributedRectilinearMeshGenerator::getIndices	(	const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	elem_id,
		dof_id_type &	i,
		dof_id_type &	,
		dof_id_type &
	)

Definition at line 190 of file DistributedRectilinearMeshGenerator.C.

{
  i = elem_id;
}

getIndices() [7/7]

template<typename T >

void DistributedRectilinearMeshGenerator::getIndices ( const dof_id_type  , const dof_id_type  , const dof_id_type  , dof_id_type &  , dof_id_type &  , dof_id_type &    )

inline

Compute the i,j,k indices of a given element ID.

Parameters

nx	The number of elements in the x direction
ny	The number of elements in the y direction
elem_id	The ID of the element
i	Output: The index in the x direction
j	Output: The index in the y direction
k	Output: The index in the z direction

Definition at line 251 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError(
        "getIndices not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

getMesh()

std::unique_ptr< MeshBase > & MeshGenerator::getMesh ( const std::string &  param_name, const bool  allow_invalid = false  )

protectedinherited

Takes the name of a MeshGeneratorName parameter and then gets a pointer to the Mesh that MeshGenerator is going to create.

That MeshGenerator is made to be a dependency of this one, so will generate() its mesh first.

Parameters

param_name	The name of the parameter that contains the name of the MeshGenerator
allow_invalid	If true, will allow for invalid parameters and will return a nullptr mesh if said parameter does not exist

Returns

The Mesh generated by that MeshGenerator

NOTE: You MUST catch this by reference!

Definition at line 186 of file MeshGenerator.C.

{
  const MeshGeneratorName * name = getMeshGeneratorNameFromParam(param_name, allow_invalid);
  if (!name)
    return _null_mesh;
  return getMeshByName(*name);
}

getMeshByName()

std::unique_ptr< MeshBase > & MeshGenerator::getMeshByName ( const MeshGeneratorName &  mesh_generator_name )

protectedinherited

Like getMesh(), but takes the name of another MeshGenerator directly.

NOTE: You MUST catch this by reference!

Returns

The Mesh generated by that MeshGenerator

Definition at line 201 of file MeshGenerator.C.

{
  checkGetMesh(mesh_generator_name, "");
  if (isNullMeshName(mesh_generator_name))
    return _null_mesh;
 
  _requested_mesh_generators.insert(mesh_generator_name);
  auto & mesh = _app.getMeshGeneratorSystem().getMeshGeneratorOutput(mesh_generator_name);
  _requested_meshes.emplace_back(mesh_generator_name, &mesh);
  return mesh;
}

Referenced by MeshGenerator::getMesh(), MeshGenerator::getMeshesByName(), OverlayMeshGenerator::OverlayMeshGenerator(), and SideSetExtruderGenerator::SideSetExtruderGenerator().

getMeshes()

std::vector< std::unique_ptr< MeshBase > * > MeshGenerator::getMeshes ( const std::string &  param_name )

protectedinherited

Like getMesh(), but for multiple generators.

Returns

The generated meshes

Definition at line 195 of file MeshGenerator.C.

{
  return getMeshesByName(getMeshGeneratorNamesFromParam(param_name));
}

getMeshesByName()

std::vector< std::unique_ptr< MeshBase > * > MeshGenerator::getMeshesByName ( const std::vector< MeshGeneratorName > &  mesh_generator_names )

protectedinherited

Like getMeshByName(), but for multiple generators.

Returns

The generated meshes

Definition at line 214 of file MeshGenerator.C.

{
  std::vector<std::unique_ptr<MeshBase> *> meshes;
  for (const auto & name : mesh_generator_names)
    meshes.push_back(&getMeshByName(name));
  return meshes;
}

Referenced by MeshGenerator::getMeshes().

getMeshGeneratorNameFromParam()

const MeshGeneratorName * MeshGenerator::getMeshGeneratorNameFromParam ( const std::string &  param_name, const bool  allow_invalid  ) const

privateinherited

Helper for getting a MeshGeneratorName parameter.

Definition at line 106 of file MeshGenerator.C.

{
  const auto valid_param = isParamValid(param_name);
  if (!allow_invalid)
  {
    if (!valid_param)
      mooseError("Failed to get a parameter with the name \"",
                 param_name,
                 "\" when getting a MeshGenerator.",
                 "\n\nKnown parameters:\n",
                 _pars);
    if (!_pars.isType<MeshGeneratorName>(param_name))
      paramError(param_name,
                 "Parameter of type \"",
                 _pars.type(param_name),
                 "\" is not an expected type for getting a MeshGenerator (should be of type "
                 "\"MeshGeneratorName\")");
  }
  else if (!valid_param)
    return nullptr;
 
  const auto & name = getParam<MeshGeneratorName>(param_name);
  checkGetMesh(name, param_name);
 
  return &name;
}

Referenced by MeshGenerator::declareMeshForSub(), MeshGenerator::getCSGBase(), and MeshGenerator::getMesh().

getMeshGeneratorNamesFromParam()

const std::vector< MeshGeneratorName > & MeshGenerator::getMeshGeneratorNamesFromParam ( const std::string &  param_name ) const

privateinherited

Helper for getting a std::vector<MeshGeneratorName> parameter.

Definition at line 135 of file MeshGenerator.C.

{
  if (!isParamValid(param_name))
    mooseError("Failed to get a parameter with the name \"",
               param_name,
               "\" when getting MeshGenerators.",
               "\n\nKnown parameters:\n",
               _pars);
  if (!_pars.isType<std::vector<MeshGeneratorName>>(param_name))
    paramError(param_name,
               "Parameter of type \"",
               _pars.type(param_name),
               "\" is not an expected type for getting MeshGenerators (should be of type "
               "\"std::vector<MeshGeneratorName>\")");
 
  const auto & names = getParam<std::vector<MeshGeneratorName>>(param_name);
  for (const auto & name : names)
    checkGetMesh(name, param_name);
 
  return names;
}

Referenced by MeshGenerator::declareMeshesForSub(), MeshGenerator::getCSGBases(), and MeshGenerator::getMeshes().

getMeshProperty() [1/2]

template<typename T >

const T & MeshMetaDataInterface::getMeshProperty ( const std::string &  data_name )

inlineprotectedinherited

Definition at line 64 of file MeshMetaDataInterface.h.

  {
    return getMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
  }

getMeshProperty() [2/2]

template<typename T >

const T & MeshMetaDataInterface::getMeshProperty ( const std::string &  data_name, const std::string &  prefix  )

protectedinherited

Method for retrieving a property with the given type and name exists in the mesh meta-data store.

This method will throw an error if the property does not exist.

Definition at line 142 of file MeshMetaDataInterface.h.

{
  if (!hasMeshProperty(data_name, prefix))
    mooseErrorInternal("Failed to get mesh property '", prefix, "/", data_name, "'");
 
  auto value = &getMeshPropertyInternal(data_name, prefix);
  mooseAssert(value->declared(), "Value has not been declared");
  const RestartableData<T> * T_value = dynamic_cast<const RestartableData<T> *>(value);
  if (!T_value)
    mooseErrorInternal("While retrieving mesh property '",
                       prefix,
                       "/",
                       data_name,
                       "' with type '",
                       MooseUtils::prettyCppType<T>(),
                       "',\nthe property exists with different type '",
                       value->type(),
                       "'");
  return T_value->get();
}

getMeshPropertyInternal()

const RestartableDataValue & MeshMetaDataInterface::getMeshPropertyInternal ( const std::string &  data_name, const std::string &  prefix  ) const

privateinherited

Helper for getting a mesh property.

Definition at line 54 of file MeshMetaDataInterface.C.

{
  return _meta_data_app.getRestartableMetaData(
      meshPropertyName(data_name, prefix), MooseApp::MESH_META_DATA, 0);
}

Referenced by MeshMetaDataInterface::getMeshProperty(), and MeshMetaDataInterface::hasMeshProperty().

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(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

getNeighbors() [1/7]

template<>

void DistributedRectilinearMeshGenerator::getNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		std::vector< dof_id_type > &	neighbors,
		const bool	corner
	)

getNeighbors() [2/7]

template<>

void DistributedRectilinearMeshGenerator::getNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		std::vector< dof_id_type > &	neighbors,
		const bool	corner
	)

getNeighbors() [3/7]

template<>

void DistributedRectilinearMeshGenerator::getNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		std::vector< dof_id_type > &	neighbors,
		const bool	corner
	)

getNeighbors() [4/7]

template<>

void DistributedRectilinearMeshGenerator::getNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k,
		std::vector< dof_id_type > &	neighbors,
		const bool	corner
	)

Definition at line 620 of file DistributedRectilinearMeshGenerator.C.

{
  std::fill(neighbors.begin(), neighbors.end(), Elem::invalid_id);
 
  if (corner)
  {
    // We collect one layer of point neighbors
    // We add one layer of point neighbors by default. Besides,
    // The elements on the opposite side of the current boundary are included
    // for, in case, periodic boundary conditions. The overhead is negligible
    // since you could consider every element has the same number of neighbors
    unsigned int nnb = 0;
    for (unsigned int ii = 0; ii <= 2; ii++)
      for (unsigned int jj = 0; jj <= 2; jj++)
        for (unsigned int kk = 0; kk <= 2; kk++)
          neighbors[nnb++] = elemId<Hex8>(
              nx, ny, (i + ii - 1 + nx) % nx, (j + jj - 1 + ny) % ny, (k + kk - 1 + nz) % nz);
 
    return;
  }
 
  // Back
  if (k != 0)
    neighbors[0] = elemId<Hex8>(nx, ny, i, j, k - 1);
 
  // Bottom
  if (j != 0)
    neighbors[1] = elemId<Hex8>(nx, ny, i, j - 1, k);
 
  // Right
  if (i != nx - 1)
    neighbors[2] = elemId<Hex8>(nx, ny, i + 1, j, k);
 
  // Top
  if (j != ny - 1)
    neighbors[3] = elemId<Hex8>(nx, ny, i, j + 1, k);
 
  // Left
  if (i != 0)
    neighbors[4] = elemId<Hex8>(nx, ny, i - 1, j, k);
 
  // Front
  if (k != nz - 1)
    neighbors[5] = elemId<Hex8>(nx, ny, i, j, k + 1);
}

getNeighbors() [5/7]

template<>

void DistributedRectilinearMeshGenerator::getNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	,
		std::vector< dof_id_type > &	neighbors,
		const bool	corner
	)

Definition at line 353 of file DistributedRectilinearMeshGenerator.C.

{
  std::fill(neighbors.begin(), neighbors.end(), Elem::invalid_id);
 
  if (corner)
  {
    // libMesh dof_id_type looks like unsigned int
    // We add one layer of point neighbors by default. Besides,
    // The elements on the opposite side of the current boundary are included
    // for, in case, periodic boundary conditions. The overhead is negligible
    // since you could consider every element has the same number of neighbors
    unsigned int nnb = 0;
    for (unsigned int ii = 0; ii <= 2; ii++)
      for (unsigned int jj = 0; jj <= 2; jj++)
        neighbors[nnb++] = elemId<Quad4>(nx, 0, (i + ii - 1 + nx) % nx, (j + jj - 1 + ny) % ny, 0);
 
    return;
  }
  // Bottom
  if (j != 0)
    neighbors[0] = elemId<Quad4>(nx, 0, i, j - 1, 0);
 
  // Right
  if (i != nx - 1)
    neighbors[1] = elemId<Quad4>(nx, 0, i + 1, j, 0);
 
  // Top
  if (j != ny - 1)
    neighbors[2] = elemId<Quad4>(nx, 0, i, j + 1, 0);
 
  // Left
  if (i != 0)
    neighbors[3] = elemId<Quad4>(nx, 0, i - 1, j, 0);
}

getNeighbors() [6/7]

template<>

void DistributedRectilinearMeshGenerator::getNeighbors	(	const dof_id_type	nx,
		const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	i,
		const dof_id_type	,
		const dof_id_type	,
		std::vector< dof_id_type > &	neighbors,
		const bool	corner
	)

Definition at line 156 of file DistributedRectilinearMeshGenerator.C.

{
  if (corner)
  {
    // The elements on the opposite of the current boundary are required
    // for periodic boundary conditions
    neighbors[0] = (i - 1 + nx) % nx;
    neighbors[1] = (i + 1 + nx) % nx;
 
    return;
  }
 
  neighbors[0] = i - 1;
  neighbors[1] = i + 1;
 
  // First element doesn't have a left neighbor
  if (i == 0)
    neighbors[0] = Elem::invalid_id;
 
  // Last element doesn't have a right neighbor
  if (i == nx - 1)
    neighbors[1] = Elem::invalid_id;
}

getNeighbors() [7/7]

template<typename T >

void DistributedRectilinearMeshGenerator::getNeighbors ( const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , std::vector< dof_id_type > &  , const bool    )

inline

Get the IDs of the neighbors of a given element.

Parameters

nx	The number of elements in the x direction
nx	The number of elements in the y direction
nz	The number of elements in the z direction
i	The x index of this element
j	The y index of this element
k	The z index of this element
neighbors	This will be filled with the IDs of the two neighbors or invalid_dof_id if there is no neighbor. THIS MUST be of size 6 BEFORE calling this function

Definition at line 120 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError("getNeighbors not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

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

getParentMeshGenerators()

const std::set< const MeshGenerator *, Comparator > & MeshGenerator::getParentMeshGenerators ( ) const

inlineinherited

Gets the MeshGenerators that are parents to this MeshGenerator.

Definition at line 141 of file MeshGenerator.h.

  {
    return _parent_mesh_generators;
  }

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder(), and MeshGenerator::isParentMeshGenerator().

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 + "'");
}

getRequestedMeshGenerators()

const std::set< MeshGeneratorName > & MeshGenerator::getRequestedMeshGenerators ( ) const

inlineinherited

Returns

The names of the MeshGenerators that were requested in the getMesh methods

Definition at line 99 of file MeshGenerator.h.

  {
    return _requested_mesh_generators;
  }

getRequestedMeshGeneratorsForSub()

const std::set< MeshGeneratorName > & MeshGenerator::getRequestedMeshGeneratorsForSub ( ) const

inlineinherited

Returns

The names of the MeshGenerators that were requested in the declareMeshForSub methods

Definition at line 107 of file MeshGenerator.h.

  {
    return _requested_mesh_generators_for_sub;
  }

getSavedMeshName()

const std::string & MeshGenerator::getSavedMeshName ( ) const

inherited

Return the name of the saved mesh.

Definition at line 494 of file MeshGenerator.C.

{
  return _save_with_name;
}

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

getSubMeshGenerators()

const std::set< const MeshGenerator *, Comparator > & MeshGenerator::getSubMeshGenerators ( ) const

inlineinherited

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 155 of file MeshGenerator.h.

  {
    return _sub_mesh_generators;
  }

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

hasGenerateCSG() [1/2]

bool MeshGenerator::hasGenerateCSG ( ) const

inlineinherited

Returns

Whether or not this generator has a generateCSG() implementation

Definition at line 209 of file MeshGenerator.h.

{ return hasGenerateCSG(_pars); }

Referenced by MeshGenerator::checkGetMesh(), MeshGenerator::generateCSG(), MeshGenerator::hasGenerateCSG(), and MeshGenerator::MeshGenerator().

hasGenerateCSG() [2/2]

bool MeshGenerator::hasGenerateCSG ( const InputParameters &  params )

staticinherited

Returns

Whether or not the mesh generator noted by the given parameters has a generateCSG() implementation

Definition at line 100 of file MeshGenerator.C.

{
  return params.get<bool>("_has_generate_csg");
}

hasGenerateData() [1/2]

bool MeshGenerator::hasGenerateData ( ) const

inlineinherited

Returns

Whether or not this generator has a generateData() implementation

Definition at line 204 of file MeshGenerator.h.

{ return hasGenerateData(_pars); }

Referenced by MeshGenerator::generateData(), MeshGenerator::generateInternal(), MeshGenerator::hasGenerateData(), and MeshGenerator::MeshGenerator().

hasGenerateData() [2/2]

bool MeshGenerator::hasGenerateData ( const InputParameters &  params )

staticinherited

Returns

Whether or not the mesh generator noted by the given parameters has a generateData() implementation

Definition at line 88 of file MeshGenerator.C.

{
  return params.get<bool>("_has_generate_data");
}

hasMeshProperty() [1/4]

bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name ) const

inlineprotectedinherited

Returns

Whether or not a mesh meta-data exists with the default prefix.

Definition at line 82 of file MeshMetaDataInterface.h.

  {
    return hasMeshProperty(data_name, meshPropertyPrefix(data_name));
  }

hasMeshProperty() [2/4]

template<typename T >

bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name ) const

inlineprotectedinherited

Returns

Whether or not a mesh meta-data exists with the default prefix and the given type.

Definition at line 90 of file MeshMetaDataInterface.h.

  {
    return hasMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
  }

hasMeshProperty() [3/4]

bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name, const std::string &  prefix  ) const

protectedinherited

Returns

Whether or not a mesh meta-data exists.

Definition at line 33 of file MeshMetaDataInterface.C.

{
  return _meta_data_app.hasRestartableMetaData(meshPropertyName(data_name, prefix),
                                               MooseApp::MESH_META_DATA);
}

Referenced by MeshGenerator::declareMeshProperty(), MeshMetaDataInterface::getMeshProperty(), MeshMetaDataInterface::hasMeshProperty(), MeshMetaDataInterface::hasMeshProperty(), and MeshGenerator::setMeshProperty().

hasMeshProperty() [4/4]

template<typename T >

bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name, const std::string &  prefix  ) const

protectedinherited

Returns

Whether or not a mesh meta-data exists with the given type.

Definition at line 166 of file MeshMetaDataInterface.h.

{
  if (!hasMeshProperty(data_name, prefix))
    return false;
  const auto & value = getMeshPropertyInternal(data_name, prefix);
  return dynamic_cast<const RestartableData<T> *>(&value) != nullptr;
}

hasOutput()

bool MeshGenerator::hasOutput ( ) const

inherited

Returns

Whether or not to output this mesh generator separately (output parameter is set)

Definition at line 488 of file MeshGenerator.C.

{
  return getParam<bool>("output");
}

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder(), and MeshGenerator::generateInternal().

hasSaveMesh()

bool MeshGenerator::hasSaveMesh ( ) const

inherited

Return whether or not to save the current mesh.

Definition at line 482 of file MeshGenerator.C.

{
  return _save_with_name.size();
}

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder(), and MeshGenerator::MeshGenerator().

isChildMeshGenerator()

bool MeshGenerator::isChildMeshGenerator ( const MeshGeneratorName &  name, const bool  direct = true  ) const

inherited

Returns

Whether or not the MeshGenerator with the name name is a child of this MeshGenerator.

If direct = true, check only immediate children of this generator. Otherwise, check all children.

Definition at line 461 of file MeshGenerator.C.

{
  return std::find_if(getChildMeshGenerators().begin(),
                      getChildMeshGenerators().end(),
                      [&name, &direct](const auto & mg)
                      {
                        return mg->name() == name ||
                               (!direct && mg->isChildMeshGenerator(name, /* direct = */ false));
                      }) != getChildMeshGenerators().end();
}

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder().

isDataOnly()

bool MeshGenerator::isDataOnly ( ) const

inlineinherited

Returns

Whether or not this generator is to be generated in data-only mode

Definition at line 214 of file MeshGenerator.h.

{ return _data_only; }

Referenced by MeshGenerator::addMeshSubgenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), and MeshGenerator::MeshGenerator().

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

isNullMeshName()

bool MeshGenerator::isNullMeshName ( const MeshGeneratorName &  name ) const

inlineinherited

Returns

Whether or not the name name is registered as a "null" mesh, that is, a MeshGenerator that will not represent an input mesh when requested via getMesh.

See declareNullMeshName().

Definition at line 184 of file MeshGenerator.h.

{ return _null_mesh_names.count(name); }

Referenced by MeshGenerator::checkGetMesh(), MeshGenerator::declareMeshForSubByName(), MeshGenerator::getCSGBaseByName(), and MeshGenerator::getMeshByName().

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(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMVariable::MFEMVariable(), MortarConstraintBase::MortarConstraintBase(), 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(), SetupMeshAction::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(), 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::setFileBase(), 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().

isParentMeshGenerator()

bool MeshGenerator::isParentMeshGenerator ( const MeshGeneratorName &  name, const bool  direct = true  ) const

inherited

Returns

Whether or not the MeshGenerator with the name name is a parent of this MeshGenerator.

If direct = true, check only immediate parents of this generator. Otherwise, check all parents.

Definition at line 448 of file MeshGenerator.C.

{
  return std::find_if(getParentMeshGenerators().begin(),
                      getParentMeshGenerators().end(),
                      [&name, &direct](const auto & mg)
                      {
                        return mg->name() == name ||
                               (!direct && mg->isParentMeshGenerator(name, /* direct = */ false));
                      }) != getParentMeshGenerators().end();
}

meshPropertyName() [1/2]

std::string MeshMetaDataInterface::meshPropertyName ( const std::string &  data_name ) const

inlineprotectedinherited

Returns

The default mesh property name for mesh property data

Definition at line 103 of file MeshMetaDataInterface.h.

  {
    return meshPropertyName(data_name, meshPropertyPrefix(data_name));
  }

meshPropertyName() [2/2]

std::string MeshMetaDataInterface::meshPropertyName ( const std::string &  data_name, const std::string &  prefix  )

staticprotectedinherited

Returns

The full name for mesh property data.

Definition at line 41 of file MeshMetaDataInterface.C.

{
  return std::string(SYSTEM) + "/" + prefix + "/" + data_name;
}

Referenced by MeshGenerator::declareMeshProperty(), MeshMetaDataInterface::getMeshPropertyInternal(), MeshMetaDataInterface::hasMeshProperty(), MeshMetaDataInterface::meshPropertyName(), and MeshGenerator::setMeshPropertyHelper().

meshPropertyPrefix()

virtual std::string MeshGenerator::meshPropertyPrefix ( const std::string &  ) const

inlinefinaloverrideprivatevirtualinherited

Override of the default prefix to use when getting mesh properties.

Until we support getting mesh properties from other mesh generators (which is coming), we will default to properties returned by this generator.

Reimplemented from MeshMetaDataInterface.

Definition at line 471 of file MeshGenerator.h.

  {
    return name();
  }

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

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(), addElement(), MooseApp::addExecutor(), SubProblem::addFunctor(), PhysicsComponentInterface::addInitialConditionsFromComponents(), ComponentJunction::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), SubProblem::addPiecewiseByBlockLambdaFunctor(), 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(), 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(), 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(), FVFluxBC::computeResidual(), 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(), elemId(), MooseApp::errorCheck(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), FixedPointSolve::examineFixedPointConvergence(), Eigenvalue::execute(), TransientBase::execute(), WebServerControl::execute(), MooseApp::executeExecutioner(), 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(), 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(), 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(), getGhostNeighbors(), 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(), 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(), 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(), nodeId(), numNeighbors(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), MortarNodalGeometryOutput::output(), Output::Output(), MooseApp::outputMachineReadableData(), 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(), scaleNodalPositions(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), 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(), and MooseApp::writeRestartableMetaData().

mooseErrorInternal()

template<typename... Args>

void MeshMetaDataInterface::mooseErrorInternal ( Args &&...  args ) const

inlineprivateinherited

Helper for forwarding a mooseError to an object's mooseError if it is available (said error will provide more context: object name and type)

Definition at line 132 of file MeshMetaDataInterface.h.

  {
    if (_meta_data_object)
      _meta_data_object->mooseError(std::forward<Args>(args)...);
    mooseError(std::forward<Args>(args)...);
  }

Referenced by MeshMetaDataInterface::getMeshProperty().

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(), 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(), MFEMRefinementMarker::initialSetup(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), 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");
  }

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::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::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(), TaggingInterface::checkForNans(), SamplerBase::checkForStandardFieldVariableType(), 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(), 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(), 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(), 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(), 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::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::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(), 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(), MFEMVectorQuadratureFunction::MFEMVectorQuadratureFunction(), OutputWarehouse::mooseConsole(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< T >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), 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(), 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(), 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(), 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().

nodeId() [1/6]

template<>

dof_id_type DistributedRectilinearMeshGenerator::nodeId	(	const ElemType	type,
		const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

nodeId() [2/6]

template<>

dof_id_type DistributedRectilinearMeshGenerator::nodeId	(	const ElemType	type,
		const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

nodeId() [3/6]

template<>

dof_id_type DistributedRectilinearMeshGenerator::nodeId	(	const ElemType	type,
		const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

nodeId() [4/6]

template<>

dof_id_type DistributedRectilinearMeshGenerator::nodeId	(	const ElemType	,
		const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

Definition at line 675 of file DistributedRectilinearMeshGenerator.C.

{
  return i + (nx + 1) * (j + k * (ny + 1));
}

nodeId() [5/6]

template<>

dof_id_type DistributedRectilinearMeshGenerator::nodeId	(	const ElemType	,
		const dof_id_type	nx,
		const dof_id_type	,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type
	)

Definition at line 436 of file DistributedRectilinearMeshGenerator.C.

{
  return i + j * (nx + 1);
}

nodeId() [6/6]

template<typename T >

dof_id_type DistributedRectilinearMeshGenerator::nodeId ( const ElemType  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type    )

inline

The ID of the i,j,k node.

Parameters

type	The element type
nx	The number of elements in the x direction
nx	The number of elements in the y direction
nz	The number of elements in the z direction
i	The x index of this node
j	The y index of this node
k	The z index of this node

Definition at line 145 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError(
        "nodeId not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

numNeighbors() [1/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::numNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

numNeighbors() [2/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::numNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

numNeighbors() [3/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::numNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

numNeighbors() [4/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::numNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type	k
	)

Definition at line 588 of file DistributedRectilinearMeshGenerator.C.

{
  dof_id_type n = 6;
 
  if (i == 0)
    n--;
 
  if (i == nx - 1)
    n--;
 
  if (j == 0)
    n--;
 
  if (j == ny - 1)
    n--;
 
  if (k == 0)
    n--;
 
  if (k == nz - 1)
    n--;
 
  return n;
}

numNeighbors() [5/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::numNeighbors	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	,
		const dof_id_type	i,
		const dof_id_type	j,
		const dof_id_type
	)

Definition at line 316 of file DistributedRectilinearMeshGenerator.C.

{
  dof_id_type n = 4;
 
  if (i == 0)
    n--;
 
  if (i == nx - 1)
    n--;
 
  if (j == 0)
    n--;
 
  if (j == ny - 1)
    n--;
 
  return n;
}

numNeighbors() [6/7]

template<>

dof_id_type DistributedRectilinearMeshGenerator::numNeighbors	(	const dof_id_type	nx,
		const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	i,
		const dof_id_type	,
		const dof_id_type
	)

Definition at line 140 of file DistributedRectilinearMeshGenerator.C.

{
  // The ends only have one neighbor
  if (i == 0 || i == nx - 1)
    return 1;
 
  return 2;
}

numNeighbors() [7/7]

template<typename T >

dof_id_type DistributedRectilinearMeshGenerator::numNeighbors ( const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type  , const dof_id_type    )

inline

Get the number of neighbors this element will have.

Parameters

nx	The number of elements in the x direction
ny	The number of elements in the y direction
nz	The number of elements in the z direction
i	The x index of this element
j	The y index of this element
k	The z index of this element

Returns

The number of neighboring elements

Definition at line 96 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError("numNeighbors not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

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(), 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(), FunctorPositions::FunctorPositions(), 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(), 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(), 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(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMMultiAppTransfer::MFEMMultiAppTransfer(), MFEMNDtoRTAux::MFEMNDtoRTAux(), MFEMSumAux::MFEMSumAux(), MFEMVariable::MFEMVariable(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), 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(), 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(), 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::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::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(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), MooseMeshUtils::copyIntoMesh(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), 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(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ReferenceResidualConvergence::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

paritionSquarely() [1/7]

template<>

void DistributedRectilinearMeshGenerator::paritionSquarely	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	nz,
		const processor_id_type	num_procs,
		std::vector< dof_id_type > &	istarts,
		std::vector< dof_id_type > &	jstarts,
		std::vector< dof_id_type > &	kstarts
	)

Definition at line 934 of file DistributedRectilinearMeshGenerator.C.

{
  /* Try for squarish distribution */
  // The number of processors along y direction
  processor_id_type py =
      (processor_id_type)(0.5 + std::pow(((Real)ny * ny) * ((Real)num_procs) / ((Real)nz * nx),
                                         (Real)(1. / 3.)));
  if (!py)
    py = 1;
  // The number of processors for pxpz plane
  processor_id_type pxpz = 1;
  // Factorize num_procs into py times pxpz
  while (py > 0)
  {
    pxpz = num_procs / py;
    if (py * pxpz == num_procs)
      break;
    py--;
  }
 
  if (!py)
    py = 1;
 
  // There number of processors along x direction
  processor_id_type px =
      (processor_id_type)(0.5 + std::sqrt(((Real)nx) * ((Real)num_procs) / ((Real)nz * py)));
  if (!px)
    px = 1;
  // The number of processors along z direction
  processor_id_type pz = 1;
  // Factorize num_procs into px times py times pz
  while (px > 0)
  {
    pz = num_procs / (px * py);
    if (px * py * pz == num_procs)
      break;
    px--;
  }
  // denser mesh takes more processors
  if (nx > nz && px < pz)
    std::swap(px, pz);
 
  istarts.resize(px + 1);
  jstarts.resize(py + 1);
  kstarts.resize(pz + 1);
 
  istarts[0] = 0;
  for (processor_id_type pxid = 0; pxid < px; pxid++)
    // Partition mesh evenly along x direction
    istarts[pxid + 1] = istarts[pxid] + nx / px + ((nx % px) > pxid);
 
  jstarts[0] = 0;
  for (processor_id_type pyid = 0; pyid < py; pyid++)
    // Partition mesh evenly along y direction
    jstarts[pyid + 1] = jstarts[pyid] + (ny / py + ((ny % py) > pyid));
 
  kstarts[0] = 0;
  for (processor_id_type pzid = 0; pzid < pz; pzid++)
    // Partition mesh evenly along z direction
    kstarts[pzid + 1] = kstarts[pzid] + (nz / pz + ((nz % pz) > pzid));
}

paritionSquarely() [2/7]

template<>

void DistributedRectilinearMeshGenerator::paritionSquarely	(	const dof_id_type	nx,
		const dof_id_type	ny,
		const dof_id_type	,
		const processor_id_type	num_procs,
		std::vector< dof_id_type > &	istarts,
		std::vector< dof_id_type > &	jstarts,
		std::vector< dof_id_type > &	kstarts
	)

Definition at line 881 of file DistributedRectilinearMeshGenerator.C.

{
  // Try for squarish distribution
  // The number of processors along x direction
  processor_id_type px =
      (processor_id_type)(0.5 + std::sqrt(((Real)nx) * ((Real)num_procs) / ((Real)ny)));
 
  if (!px)
    px = 1;
 
  // The number of processors along y direction
  processor_id_type py = 1;
  // Fact num_procs into px times py
  while (px > 0)
  {
    py = num_procs / px;
    if (py * px == num_procs)
      break;
    px--;
  }
  // More processors are needed for denser side
  if (nx > ny && py < px)
    std::swap(px, py);
 
  // Starting indices along x direction
  istarts.resize(px + 1);
  // Starting indices along y direction
  jstarts.resize(py + 1);
  // Starting indices along z direction
  kstarts.resize(2);
  // There is no elements along z direction
  kstarts[0] = 0;
  kstarts[1] = 1;
 
  istarts[0] = 0;
  for (processor_id_type pxid = 0; pxid < px; pxid++)
    // Partition elements evenly along x direction
    istarts[pxid + 1] = istarts[pxid] + nx / px + ((nx % px) > pxid);
 
  jstarts[0] = 0;
  for (processor_id_type pyid = 0; pyid < py; pyid++)
    // Partition elements evenly along y direction
    jstarts[pyid + 1] = jstarts[pyid] + (ny / py + ((ny % py) > pyid));
}

paritionSquarely() [3/7]

template<>

void DistributedRectilinearMeshGenerator::paritionSquarely	(	const dof_id_type	nx,
		const dof_id_type	,
		const dof_id_type	,
		const processor_id_type	num_procs,
		std::vector< dof_id_type > &	istarts,
		std::vector< dof_id_type > &	jstarts,
		std::vector< dof_id_type > &	kstarts
	)

Definition at line 852 of file DistributedRectilinearMeshGenerator.C.

{
  // Starting indices along x direction
  istarts.resize(num_procs + 1);
  // Starting indices along y direction
  // There is only one processor along y direction since it is a 1D mesh
  jstarts.resize(2);
  jstarts[0] = 0;
  jstarts[1] = 1;
  // Starting indices along z direction
  // There is only one processor along z direction since it is a 1D mesh
  kstarts.resize(2);
  kstarts[0] = 0;
  kstarts[1] = 1;
 
  istarts[0] = 0;
  for (processor_id_type pid = 0; pid < num_procs; pid++)
    // Partition mesh evenly. The extra elements are assigned to the front processors
    istarts[pid + 1] = istarts[pid] + (nx / num_procs + ((nx % num_procs) > pid));
}

paritionSquarely() [4/7]

template<typename T >

void DistributedRectilinearMeshGenerator::paritionSquarely ( const dof_id_type  , const dof_id_type  , const dof_id_type  , const processor_id_type  , std::vector< dof_id_type > &  , std::vector< dof_id_type > &  , std::vector< dof_id_type > &    )

inline

Partition mesh squarely.

This minic DMDA partition in PETSc. The motivation is that partition a rec mesh using the same way in which DMDA is partitioned so that the partitions between MOOSE and PETSc DMDA are consistent to minimize the communication const in multiapp transfers

Parameters

nx	The number of elements in the x direction
ny	The number of elements in the y direction
nz	The number of elements in the z direction
num_procs	The number of processors
istarts	The starting x indices of elements for each processor
jstarts	The starting y indices of elements for each processor
kstarts	The starting z indices of elements for each processor

Definition at line 228 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError("paritionSquarely not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

paritionSquarely() [5/7]

template<>

void DistributedRectilinearMeshGenerator::paritionSquarely	(	const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	,
		const processor_id_type	,
		std::vector< dof_id_type > &	,
		std::vector< dof_id_type > &	,
		std::vector< dof_id_type > &
	)

paritionSquarely() [6/7]

template<>

void DistributedRectilinearMeshGenerator::paritionSquarely	(	const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	,
		const processor_id_type	,
		std::vector< dof_id_type > &	,
		std::vector< dof_id_type > &	,
		std::vector< dof_id_type > &
	)

paritionSquarely() [7/7]

template<>

void DistributedRectilinearMeshGenerator::paritionSquarely	(	const dof_id_type	,
		const dof_id_type	,
		const dof_id_type	,
		const processor_id_type	,
		std::vector< dof_id_type > &	,
		std::vector< dof_id_type > &	,
		std::vector< dof_id_type > &
	)

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

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

scaleNodalPositions() [1/7]

template<>

void DistributedRectilinearMeshGenerator::scaleNodalPositions	(	dof_id_type	nx,
		dof_id_type	ny,
		dof_id_type	nz,
		Real	xmin,
		Real	xmax,
		Real	ymin,
		Real	ymax,
		Real	zmin,
		Real	zmax,
		MeshBase &	mesh
	)

scaleNodalPositions() [2/7]

template<>

void DistributedRectilinearMeshGenerator::scaleNodalPositions	(	dof_id_type	nx,
		dof_id_type	ny,
		dof_id_type	nz,
		Real	xmin,
		Real	xmax,
		Real	ymin,
		Real	ymax,
		Real	zmin,
		Real	zmax,
		MeshBase &	mesh
	)

scaleNodalPositions() [3/7]

template<>

void DistributedRectilinearMeshGenerator::scaleNodalPositions	(	dof_id_type	nx,
		dof_id_type	ny,
		dof_id_type	nz,
		Real	xmin,
		Real	xmax,
		Real	ymin,
		Real	ymax,
		Real	zmin,
		Real	zmax,
		MeshBase &	mesh
	)

scaleNodalPositions() [4/7]

template<>

void DistributedRectilinearMeshGenerator::scaleNodalPositions	(	dof_id_type	,
		dof_id_type	,
		dof_id_type	,
		Real	xmin,
		Real	xmax,
		Real	ymin,
		Real	ymax,
		Real	zmin,
		Real	zmax,
		MeshBase &	mesh
	)

Definition at line 831 of file DistributedRectilinearMeshGenerator.C.

{
  for (auto & node_ptr : mesh.node_ptr_range())
  {
    (*node_ptr)(0) = (*node_ptr)(0) * (xmax - xmin) + xmin;
    (*node_ptr)(1) = (*node_ptr)(1) * (ymax - ymin) + ymin;
    (*node_ptr)(2) = (*node_ptr)(2) * (zmax - zmin) + zmin;
  }
}

scaleNodalPositions() [5/7]

template<>

void DistributedRectilinearMeshGenerator::scaleNodalPositions	(	dof_id_type	,
		dof_id_type	,
		dof_id_type	,
		Real	xmin,
		Real	xmax,
		Real	ymin,
		Real	ymax,
		Real	,
		Real	,
		MeshBase &	mesh
	)

Definition at line 557 of file DistributedRectilinearMeshGenerator.C.

{
  for (auto & node_ptr : mesh.node_ptr_range())
  {
    (*node_ptr)(0) = (*node_ptr)(0) * (xmax - xmin) + xmin;
    (*node_ptr)(1) = (*node_ptr)(1) * (ymax - ymin) + ymin;
  }
}

scaleNodalPositions() [6/7]

template<>

void DistributedRectilinearMeshGenerator::scaleNodalPositions	(	dof_id_type	,
		dof_id_type	,
		dof_id_type	,
		Real	xmin,
		Real	xmax,
		Real	,
		Real	,
		Real	,
		Real	,
		MeshBase &	mesh
	)

Definition at line 299 of file DistributedRectilinearMeshGenerator.C.

{
  for (auto & node_ptr : mesh.node_ptr_range())
    (*node_ptr)(0) = (*node_ptr)(0) * (xmax - xmin) + xmin;
}

scaleNodalPositions() [7/7]

template<typename T >

void DistributedRectilinearMeshGenerator::scaleNodalPositions ( dof_id_type  , dof_id_type  , dof_id_type  , Real  , Real  , Real  , Real  , Real  , Real  , MeshBase &    )

inline

All meshes are generated on the unit square.

This function stretches the mesh out to fill the correct area.

Parameters

nx	The number of elements in the x direction
ny	The number of elements in the y direction
nz	The number of elements in the z direction
xmin	Lower X Coordinate of the generated mesh
xmax	Upper X Coordinate of the generated mesh
ymin	Lower Y Coordinate of the generated mesh
ymax	Upper Y Coordinate of the generated mesh
zmin	Lower Z Coordinate of the generated mesh
zmax	Upper Z Coordinate of the generated mesh
mesh	Distributed UnstructuredMesh

Definition at line 310 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError("scaleNodalPositions not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

setBoundaryNames() [1/7]

template<typename T >

void DistributedRectilinearMeshGenerator::setBoundaryNames ( BoundaryInfo &  )

inline

Set the boundary names for any added boundary ideas.

@boundary_info The BoundaryInfo object to set the boundary names on

Definition at line 288 of file DistributedRectilinearMeshGenerator.h.

  {
    mooseError("setBoundaryNames not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

setBoundaryNames() [2/7]

template<>

void DistributedRectilinearMeshGenerator::setBoundaryNames

(

BoundaryInfo &

boundary_info

)

setBoundaryNames() [3/7]

template<>

void DistributedRectilinearMeshGenerator::setBoundaryNames

(

BoundaryInfo &

boundary_info

)

setBoundaryNames() [4/7]

template<>

void DistributedRectilinearMeshGenerator::setBoundaryNames

(

BoundaryInfo &

boundary_info

)

setBoundaryNames() [5/7]

template<>

void DistributedRectilinearMeshGenerator::setBoundaryNames

(

BoundaryInfo &

boundary_info

)

Definition at line 291 of file DistributedRectilinearMeshGenerator.C.

{
  boundary_info.sideset_name(0) = "left";
  boundary_info.sideset_name(1) = "right";
}

setBoundaryNames() [6/7]

template<>

void DistributedRectilinearMeshGenerator::setBoundaryNames

(

BoundaryInfo &

boundary_info

)

Definition at line 547 of file DistributedRectilinearMeshGenerator.C.

{
  boundary_info.sideset_name(0) = "bottom";
  boundary_info.sideset_name(1) = "right";
  boundary_info.sideset_name(2) = "top";
  boundary_info.sideset_name(3) = "left";
}

setBoundaryNames() [7/7]

template<>

void DistributedRectilinearMeshGenerator::setBoundaryNames

(

BoundaryInfo &

boundary_info

)

Definition at line 819 of file DistributedRectilinearMeshGenerator.C.

{
  boundary_info.sideset_name(0) = "back";
  boundary_info.sideset_name(1) = "bottom";
  boundary_info.sideset_name(2) = "right";
  boundary_info.sideset_name(3) = "top";
  boundary_info.sideset_name(4) = "left";
  boundary_info.sideset_name(5) = "front";
}

setHasGenerateCSG()

void MeshGenerator::setHasGenerateCSG ( InputParameters &  params )

staticinherited

Sets that a mesh generator has a generateCSG() implementation.

This must be called in the validParams() implementation for all mesh generators that implement generateCSG().

Definition at line 94 of file MeshGenerator.C.

{
  params.set<bool>("_has_generate_csg") = true;
}

setHasGenerateData()

void MeshGenerator::setHasGenerateData ( InputParameters &  params )

staticinherited

Sets that a mesh generator has a generateData() implementation.

This must be called in the validParams() implementation for all mesh generators that implement generateData().

Definition at line 82 of file MeshGenerator.C.

{
  params.set<bool>("_has_generate_data") = true;
}

Referenced by AddMetaDataGenerator::validParams().

setMeshProperty() [1/2]

template<typename T , typename... Args>

T & MeshGenerator::setMeshProperty ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Method for updating attributes to the mesh meta-data store, which can only be invoked in the MeshGenerator generate routine only if the mesh generator property has already been declared.

Definition at line 565 of file MeshGenerator.h.

{
  if (_app.actionWarehouse().getCurrentTaskName() != "execute_mesh_generators")
    mooseError("Updating mesh meta data with setMeshProperty() can only be called during "
               "MeshGenerator::generate()");
 
  if (!hasMeshProperty(data_name))
    mooseError("Failed to get the mesh property '", data_name, "'");
  RestartableDataValue * value = &setMeshPropertyHelper(data_name);
  RestartableData<T> * T_value = dynamic_cast<RestartableData<T> *>(value);
  if (!T_value)
    mooseError("While retrieving mesh property '",
               data_name,
               "' with type '",
               MooseUtils::prettyCppType<T>(),
               "',\nthe property was found with type '",
               value->type(),
               "'");
 
  // Set the value if someone provided arguments to set it to
  if constexpr (sizeof...(args) > 0)
    T_value->set() = T(std::forward<Args>(args)...);
 
  return T_value->set();
}

setMeshProperty() [2/2]

template<typename T >

T & MeshGenerator::setMeshProperty ( const std::string &  data_name, const T &  data_value  )

inlineprotectedinherited

Definition at line 251 of file MeshGenerator.h.

  {
    return setMeshProperty<T, const T &>(data_name, data_value);
  }

setMeshPropertyHelper()

RestartableDataValue & MeshGenerator::setMeshPropertyHelper ( const std::string &  data_name )

privateinherited

Helper for getting a writable reference to a mesh property, used in declareMeshProperty and setMeshProperty.

Definition at line 428 of file MeshGenerator.C.

{
  return _app.getRestartableMetaData(meshPropertyName(data_name), MooseApp::MESH_META_DATA, 0);
}

Referenced by MeshGenerator::declareMeshProperty(), and MeshGenerator::setMeshProperty().

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::addAuxVariable(), FEProblemBase::addConvergence(), FEProblemBase::addDistribution(), addElement(), addElement(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addObject(), 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(), buildCube(), MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildLowerDMesh(), MooseMesh::buildPRefinementAndCoarseningMaps(), PhysicsBase::checkComponentType(), 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::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), 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(), 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(), MFEMProblem::mesh(), MooseObject::MooseObject(), SubProblem::numVectorTags(), DisplacedProblem::numVectorTags(), AdvancedOutput::output(), Console::output(), ConsoleUtils::outputExecutionInformation(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), MooseServer::parseDocumentForDiagnostics(), 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().

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

validParams()

InputParameters DistributedRectilinearMeshGenerator::validParams ( )

static

Definition at line 35 of file DistributedRectilinearMeshGenerator.C.

{
  InputParameters params = PetscExternalPartitioner::validParams();
  params += MeshGenerator::validParams();
 
  MooseEnum dims("1=1 2 3");
  params.addRequiredParam<MooseEnum>(
      "dim", dims, "The dimension of the mesh to be generated"); // Make this parameter required
 
  params.addParam<dof_id_type>("nx", 1, "Number of elements in the X direction");
  params.addParam<dof_id_type>("ny", 1, "Number of elements in the Y direction");
  params.addParam<dof_id_type>("nz", 1, "Number of elements in the Z direction");
  params.addParam<Real>("xmin", 0.0, "Lower X Coordinate of the generated mesh");
  params.addParam<Real>("ymin", 0.0, "Lower Y Coordinate of the generated mesh");
  params.addParam<Real>("zmin", 0.0, "Lower Z Coordinate of the generated mesh");
  params.addParam<Real>("xmax", 1.0, "Upper X Coordinate of the generated mesh");
  params.addParam<Real>("ymax", 1.0, "Upper Y Coordinate of the generated mesh");
  params.addParam<Real>("zmax", 1.0, "Upper Z Coordinate of the generated mesh");
 
  params.addParam<processor_id_type>(
      "num_cores_for_partition", 0, "Number of cores for partitioning the graph");
 
  params.addRangeCheckedParam<unsigned>(
      "num_side_layers",
      2,
      "num_side_layers>=1 & num_side_layers<5",
      "Number of layers of off-processor side neighbors is reserved during mesh generation");
 
  params.addRelationshipManager("ElementSideNeighborLayers",
                                Moose::RelationshipManagerType::GEOMETRIC,
                                [](const InputParameters & obj_params, InputParameters & rm_params)
                                {
                                  // Let this RM safeguard users specified ghosted layers
                                  rm_params.set<unsigned short>("layers") =
                                      obj_params.get<unsigned>("num_side_layers");
                                  // We can not attach geometric early here because some simulation
                                  // related info, such as, periodic BCs is not available yet during
                                  // an early stage. Periodic BCs will be passed into ghosting
                                  // functor during initFunctor of ElementSideNeighborLayers. There
                                  // is no hurt to attach geometric late for general simulations
                                  // that do not have extra requirements on ghosting elements. That
                                  // is especially true distributed generated meshes since there is
                                  // not much redundant info.
                                  rm_params.set<bool>("attach_geometric_early") = false;
                                });
 
  MooseEnum partition("graph linear square", "graph", false);
  params.addParam<MooseEnum>(
      "partition", partition, "Which method (graph linear square) use to partition mesh");
 
  MooseEnum elem_types("EDGE2 QUAD4 HEX8"); // no default
  params.addParam<MooseEnum>("elem_type",
                             elem_types,
                             "The type of element from libMesh to "
                             "generate (default: linear element for "
                             "requested dimension)");
 
  params.addRangeCheckedParam<Real>(
      "bias_x",
      1.,
      "bias_x>=0.5 & bias_x<=2",
      "The amount by which to grow (or shrink) the cells in the x-direction.");
  params.addRangeCheckedParam<Real>(
      "bias_y",
      1.,
      "bias_y>=0.5 & bias_y<=2",
      "The amount by which to grow (or shrink) the cells in the y-direction.");
  params.addRangeCheckedParam<Real>(
      "bias_z",
      1.,
      "bias_z>=0.5 & bias_z<=2",
      "The amount by which to grow (or shrink) the cells in the z-direction.");
 
  params.addClassDescription(
      "Create a line, square, or cube mesh with uniformly spaced or biased elements.");
 
  return params;
}

Referenced by OverlayMeshGenerator::validParams().

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

_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(), 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(), ImageMesh::safeClone(), MeshGeneratorMesh::safeClone(), PatternedMesh::safeClone(), RinglebMesh::safeClone(), SpiralAnnularMesh::safeClone(), StitchedMesh::safeClone(), TiledMesh::safeClone(), MFEMMesh::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 DistributedRectilinearMeshGenerator::_bias_x

protected

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 351 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_bias_y

Real DistributedRectilinearMeshGenerator::_bias_y

protected

Definition at line 351 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_bias_z

Real DistributedRectilinearMeshGenerator::_bias_z

protected

Definition at line 351 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_child_mesh_generators

std::set<const MeshGenerator *, Comparator> MeshGenerator::_child_mesh_generators

privateinherited

The MeshGenerators that are children to this MeshGenerator.

Definition at line 519 of file MeshGenerator.h.

Referenced by MeshGenerator::addChildMeshGenerator(), and MeshGenerator::getChildMeshGenerators().

_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::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), 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(), 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().

_data_only

const bool MeshGenerator::_data_only

privateinherited

Whether or not this mesh generator will run in data only mode.

Definition at line 530 of file MeshGenerator.h.

Referenced by MeshGenerator::isDataOnly().

_dim

MooseEnum DistributedRectilinearMeshGenerator::_dim

protected

The dimension of the mesh.

Definition at line 327 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_elem_type

ElemType DistributedRectilinearMeshGenerator::_elem_type

protected

The type of element to build.

Definition at line 344 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

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

_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(), and ProjectedStatefulMaterialStorageAction::processProperty().

_mesh

MooseMesh* const MeshGenerator::_mesh

protectedinherited

Pointer to the owning mesh.

Definition at line 462 of file MeshGenerator.h.

Referenced by MeshGenerator::buildDistributedMesh(), MeshGenerator::buildMeshBaseObject(), MeshGenerator::buildReplicatedMesh(), generate(), and XYTriangleBoundaryLayerGenerator::generate().

_meta_data_app

MooseApp& MeshMetaDataInterface::_meta_data_app

privateinherited

Reference to the application.

Definition at line 122 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::getMeshPropertyInternal(), and MeshMetaDataInterface::hasMeshProperty().

_meta_data_object

const MooseObject* const MeshMetaDataInterface::_meta_data_object

privateinherited

The MooseObject (if any); used for better error handling.

Definition at line 125 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::mooseErrorInternal().

_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(), 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(), 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().

_null_csg_base

std::unique_ptr<CSG::CSGBase> MeshGenerator::_null_csg_base = nullptr

privateinherited

A nullptr to use for when inputs aren't specified.

Definition at line 514 of file MeshGenerator.h.

Referenced by MeshGenerator::getCSGBase(), and MeshGenerator::getCSGBaseByName().

_null_mesh

std::unique_ptr<MeshBase> MeshGenerator::_null_mesh = nullptr

privateinherited

A nullptr to use for when inputs aren't specified.

Definition at line 511 of file MeshGenerator.h.

Referenced by MeshGenerator::getMesh(), and MeshGenerator::getMeshByName().

_null_mesh_names

std::set<std::string> MeshGenerator::_null_mesh_names

privateinherited

The declared "null" mesh names that will not represent a mesh in input; see declareNullMeshName()

Definition at line 524 of file MeshGenerator.h.

Referenced by MeshGenerator::declareNullMeshName(), and MeshGenerator::isNullMeshName().

_num_cores_for_partition

processor_id_type DistributedRectilinearMeshGenerator::_num_cores_for_partition

protected

Number of cores for partitioning the graph The number of cores for the graph partition can be different from that used for mesh generation and simulation.

Partitioners often become inefficient in compute time when the number of cores is large (around 10,0000). A possible "fix" is to partition the graph using a small number of cores when the mesh generation and the numerical simulation use a large number of processor cores.

Definition at line 341 of file DistributedRectilinearMeshGenerator.h.

Referenced by buildCube().

_num_parts_per_compute_node

processor_id_type DistributedRectilinearMeshGenerator::_num_parts_per_compute_node

protected

Number of cores per compute node if hierarch partitioning is used.

Definition at line 357 of file DistributedRectilinearMeshGenerator.h.

Referenced by buildCube().

_num_side_layers

unsigned DistributedRectilinearMeshGenerator::_num_side_layers

protected

Number of element side neighbor layers While most of applications in moose require one layer of side neighbors, phase field simulation with grain tracker needs two layers.

This parameter allow us to reserve an arbitrary number of side neighbors

Definition at line 366 of file DistributedRectilinearMeshGenerator.h.

Referenced by buildCube().

_nx

dof_id_type& DistributedRectilinearMeshGenerator::_nx

protected

Number of elements in x, y, z direction.

Definition at line 330 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_ny

dof_id_type & DistributedRectilinearMeshGenerator::_ny

protected

Definition at line 330 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_nz

dof_id_type & DistributedRectilinearMeshGenerator::_nz

protected

Definition at line 330 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), and DataFileInterface::getDataFilePath().

_parent_mesh_generators

std::set<const MeshGenerator *, Comparator> MeshGenerator::_parent_mesh_generators

privateinherited

The MeshGenerators that are parents to this MeshGenerator.

Definition at line 517 of file MeshGenerator.h.

Referenced by MeshGenerator::addParentMeshGenerator(), and MeshGenerator::getParentMeshGenerators().

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

_part_package

std::string DistributedRectilinearMeshGenerator::_part_package

protected

External partitioner.

Definition at line 354 of file DistributedRectilinearMeshGenerator.h.

Referenced by buildCube().

_partition_method

std::string DistributedRectilinearMeshGenerator::_partition_method

protected

Which method is used to partition the mesh that is not built yet.

Definition at line 360 of file DistributedRectilinearMeshGenerator.h.

Referenced by buildCube().

_requested_csg_bases

std::vector<std::pair<std::string, std::unique_ptr<CSG::CSGBase> *> > MeshGenerator::_requested_csg_bases

privateinherited

The CSGBase objects that were requested by this MeshGenerator; used to verify that any input meshes that are requested are properly released after generation.

Definition at line 508 of file MeshGenerator.h.

Referenced by MeshGenerator::generateInternalCSG(), and MeshGenerator::getCSGBaseByName().

_requested_mesh_generators

std::set<MeshGeneratorName> MeshGenerator::_requested_mesh_generators

privateinherited

The names of the MeshGenerators that were requested in the getMesh methods.

Definition at line 500 of file MeshGenerator.h.

Referenced by MeshGenerator::getMeshByName(), and MeshGenerator::getRequestedMeshGenerators().

_requested_mesh_generators_for_sub

std::set<MeshGeneratorName> MeshGenerator::_requested_mesh_generators_for_sub

privateinherited

The names of the MeshGenerators that were requested in the declareMeshForSub methods.

Definition at line 502 of file MeshGenerator.h.

Referenced by MeshGenerator::declareMeshForSubByName(), and MeshGenerator::getRequestedMeshGeneratorsForSub().

_requested_meshes

std::vector<std::pair<std::string, std::unique_ptr<MeshBase> *> > MeshGenerator::_requested_meshes

privateinherited

The meshes that were requested by this MeshGenerator; used to verify that any input meshes that are requested are properly released after generation.

Definition at line 505 of file MeshGenerator.h.

Referenced by MeshGenerator::generateInternal(), and MeshGenerator::getMeshByName().

_save_with_name

const std::string& MeshGenerator::_save_with_name

privateinherited

A user-defined name to save the mesh.

Definition at line 527 of file MeshGenerator.h.

Referenced by MeshGenerator::getSavedMeshName(), MeshGenerator::hasSaveMesh(), and MeshGenerator::MeshGenerator().

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

_sub_mesh_generators

std::set<const MeshGenerator *, Comparator> MeshGenerator::_sub_mesh_generators

privateinherited

The sub MeshGenerators constructed by this MeshGenerator.

Definition at line 521 of file MeshGenerator.h.

Referenced by MeshGenerator::addMeshSubgenerator(), and MeshGenerator::getSubMeshGenerators().

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

_xmax

Real & DistributedRectilinearMeshGenerator::_xmax

protected

Definition at line 333 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_xmin

Real& DistributedRectilinearMeshGenerator::_xmin

protected

The min/max values for x,y,z component.

Definition at line 333 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_ymax

Real & DistributedRectilinearMeshGenerator::_ymax

protected

Definition at line 333 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_ymin

Real & DistributedRectilinearMeshGenerator::_ymin

protected

Definition at line 333 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_zmax

Real & DistributedRectilinearMeshGenerator::_zmax

protected

Definition at line 333 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

_zmin

Real & DistributedRectilinearMeshGenerator::_zmin

protected

Definition at line 333 of file DistributedRectilinearMeshGenerator.h.

Referenced by generate().

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

data_only_param

const std::string MeshGenerator::data_only_param = "_data_only"

staticinherited

The name of the private parameter for setting data only.

Definition at line 76 of file MeshGenerator.h.

Referenced by MeshGenerator::addMeshSubgenerator(), MeshGeneratorSystem::createAddedMeshGenerators(), and MeshGenerator::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

constexpr auto MeshMetaDataInterface::NAME = "<empty>"

staticconstexprinherited

The data name used when initializing the Restartable interface for non-MeshGenerator objects.

Definition at line 33 of file MeshMetaDataInterface.h.

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

SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"

staticconstexprinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().

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/meshgenerators/DistributedRectilinearMeshGenerator.h
• src/meshgenerators/DistributedRectilinearMeshGenerator.C