#include <MeshDiagnosticsGenerator.h>

Inheritance diagram for MeshDiagnosticsGenerator:

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

Public Member Functions
	MeshDiagnosticsGenerator (const InputParameters &parameters)

std::unique_ptr< MeshBase >	generate () override
	Generate / modify the mesh.

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
std::unique_ptr< MeshBase > &	_input
	the input mesh to be diagnosed

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
void	checkSidesetsOrientation (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check sideset orientation near subdomains.

void	checkWatertightSidesets (const std::unique_ptr< MeshBase > &mesh) const

void	checkWatertightNodesets (const std::unique_ptr< MeshBase > &mesh) const

std::vector< boundary_id_type >	findBoundaryOverlap (const std::vector< boundary_id_type > &watertight_boundaries, std::vector< boundary_id_type > &boundary_ids) const
	Helper function that finds the intersection between the given vectors.

void	checkElementVolumes (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check the element volumes.

void	checkElementTypes (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check the element types in each subdomain.

void	checkElementOverlap (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check whether elements overlap in the mesh.

void	checkNonPlanarSides (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check whether there are non-planar sides in the mesh.

void	checkNonConformalMesh (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check whether a mesh presents non-conformality.

void	checkNonConformingFaces (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check for element faces that border material but match no neighbor face.

void	checkNonConformalMeshFromAdaptivity (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check whether a mesh presents non-conformality born from adaptivity.

void	checkLocalJacobians (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check whether the Jacobians (elem and side) are not negative.

void	checkNonMatchingEdges (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check for non matching edges.

void	checkPolygons (const std::unique_ptr< MeshBase > &mesh) const
	Routine to check for non-convex polygons.

void	diagnosticsLog (std::string msg, const MooseEnum &log_level, bool problem_detected) const
	Utility routine to output the final diagnostics level in the desired mode.

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
const MooseEnum	_check_sidesets_orientation
	whether to check that sidesets are consistently oriented using neighbor subdomains

const MooseEnum	_check_watertight_sidesets
	whether to check that each external side is assigned to a sideset

const MooseEnum	_check_watertight_nodesets
	whether to check that each external node is assigned to a nodeset

std::vector< BoundaryName >	_watertight_boundary_names
	Names of boundaries to be checked in watertight checks.

std::vector< BoundaryID >	_watertight_boundaries
	IDs of boundaries to be checked in watertight checks.

const MooseEnum	_check_element_volumes
	whether to check element volumes

const Real	_min_volume
	minimum size for element volume to be counted as a tiny element

const Real	_max_volume
	maximum size for element volume to be counted as a big element

const MooseEnum	_check_element_types
	whether to check different element types in the same sub-domain

const MooseEnum	_check_element_overlap
	whether to check for intersecting elements

const MooseEnum	_check_non_planar_sides
	whether to check for elements in different planes (non_planar)

const MooseEnum	_check_non_conformal_mesh
	whether to check for non-conformal meshes

const Real	_non_conformality_tol
	tolerance for detecting when meshes are not conformal

const MooseEnum	_check_nonconforming_faces
	whether to check for element faces that border material but match no neighbor face

const MooseEnum	_check_non_matching_edges

const Real	_non_matching_edge_tol

const MooseEnum	_check_adaptivity_non_conformality
	whether to check for the adaptivity of non-conformal meshes

const MooseEnum	_check_local_jacobian
	whether to check for negative jacobians in the domain

const MooseEnum	_check_polygons
	whether to check for non-convex polygons in the mesh

const unsigned int	_num_outputs
	number of logs to output at most for each check

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

Definition at line 18 of file MeshDiagnosticsGenerator.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

◆ MeshDiagnosticsGenerator()

MeshDiagnosticsGenerator::MeshDiagnosticsGenerator ( const InputParameters & parameters )

Definition at line 107 of file MeshDiagnosticsGenerator.C.

  : MeshGenerator(parameters),
    _input(getMesh("input")),
    _check_sidesets_orientation(getParam<MooseEnum>("examine_sidesets_orientation")),
    _check_watertight_sidesets(getParam<MooseEnum>("check_for_watertight_sidesets")),
    _check_watertight_nodesets(getParam<MooseEnum>("check_for_watertight_nodesets")),
    _watertight_boundary_names(getParam<std::vector<BoundaryName>>("boundaries_to_check")),
    _check_element_volumes(getParam<MooseEnum>("examine_element_volumes")),
    _min_volume(getParam<Real>("minimum_element_volumes")),
    _max_volume(getParam<Real>("maximum_element_volumes")),
    _check_element_types(getParam<MooseEnum>("examine_element_types")),
    _check_element_overlap(getParam<MooseEnum>("examine_element_overlap")),
    _check_non_planar_sides(getParam<MooseEnum>("examine_nonplanar_sides")),
    _check_non_conformal_mesh(getParam<MooseEnum>("examine_non_conformality")),
    _non_conformality_tol(getParam<Real>("nonconformal_tol")),
    _check_nonconforming_faces(getParam<MooseEnum>("examine_nonconforming_faces")),
    _check_non_matching_edges(getParam<MooseEnum>("examine_non_matching_edges")),
    _non_matching_edge_tol(getParam<Real>("intersection_tol")),
    _check_adaptivity_non_conformality(
        getParam<MooseEnum>("search_for_adaptivity_nonconformality")),
    _check_local_jacobian(getParam<MooseEnum>("check_local_jacobian")),
    _check_polygons(getParam<MooseEnum>("check_polygons")),
    _num_outputs(getParam<unsigned int>("log_length_limit"))
{
  // Check that no secondary parameters have been passed with the main check disabled
  if ((isParamSetByUser("minimum_element_volumes") ||
       isParamSetByUser("maximum_element_volumes")) &&
      _check_element_volumes == "NO_CHECK")
    paramError("examine_element_volumes",
               "You must set this parameter to true to trigger element size checks");
  if (isParamSetByUser("nonconformal_tol") && _check_non_conformal_mesh == "NO_CHECK")
    paramError("examine_non_conformality",
               "You must set this parameter to true to trigger mesh conformality check");
  if (_check_sidesets_orientation == "NO_CHECK" && _check_watertight_sidesets == "NO_CHECK" &&
      _check_watertight_nodesets == "NO_CHECK" && _check_element_volumes == "NO_CHECK" &&
      _check_element_types == "NO_CHECK" && _check_element_overlap == "NO_CHECK" &&
      _check_non_planar_sides == "NO_CHECK" && _check_non_conformal_mesh == "NO_CHECK" &&
      _check_adaptivity_non_conformality == "NO_CHECK" && _check_local_jacobian == "NO_CHECK" &&
      _check_non_matching_edges == "NO_CHECK" && _check_nonconforming_faces == "NO_CHECK" &&
      _check_polygons == "NO_CHECK")
    mooseError("You need to turn on at least one diagnostic. Did you misspell a parameter?");
}

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 471 of file MeshGenerator.C.

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

◆ 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 440 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 464 of file MeshGenerator.C.

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

◆ 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 333 of file MeshGenerator.C.

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

Referenced by DistributedRectilinearMeshGenerator::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 319 of file MeshGenerator.C.

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

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

◆ checkElementOverlap()

void MeshDiagnosticsGenerator::checkElementOverlap ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check whether elements overlap in the mesh.

Definition at line 566 of file MeshDiagnosticsGenerator.C.

{
  {
    unsigned int num_elem_overlaps = 0;
    auto pl = mesh->sub_point_locator();
    // loop on nodes, assumed replicated mesh
    for (auto & node : mesh->node_ptr_range())
    {
      // find all the elements around this node
      std::set<const Elem *> elements;
      (*pl)(*node, elements);
 
      for (auto & elem : elements)
      {
        if (!elem->contains_point(*node))
          continue;
 
        // not overlapping inside the element if part of its nodes
        bool found = false;
        for (auto & elem_node : elem->node_ref_range())
          if (*node == elem_node)
          {
            found = true;
            break;
          }
        // not overlapping inside the element if right on its side
        bool on_a_side = false;
        for (const auto & elem_side_index : elem->side_index_range())
          if (elem->side_ptr(elem_side_index)->contains_point(*node, _non_conformality_tol))
            on_a_side = true;
        if (!found && !on_a_side)
        {
          num_elem_overlaps++;
          if (num_elem_overlaps < _num_outputs)
            _console << "Element overlap detected at : " << *node << std::endl;
          else if (num_elem_overlaps == _num_outputs)
            _console << "Maximum output reached, log is silenced" << std::endl;
        }
      }
    }
 
    diagnosticsLog("Number of elements overlapping (node-based heuristics): " +
                       Moose::stringify(num_elem_overlaps),
                   _check_element_overlap,
                   num_elem_overlaps);
    num_elem_overlaps = 0;
 
    // loop on all elements in mesh: assumes a replicated mesh
    for (auto & elem : mesh->active_element_ptr_range())
    {
      // find all the elements around the centroid of this element
      std::set<const Elem *> overlaps;
      (*pl)(elem->vertex_average(), overlaps);
 
      if (overlaps.size() > 1)
      {
        num_elem_overlaps++;
        if (num_elem_overlaps < _num_outputs)
          _console << "Element overlap detected with element : " << elem->id() << " near point "
                   << elem->vertex_average() << std::endl;
        else if (num_elem_overlaps == _num_outputs)
          _console << "Maximum output reached, log is silenced" << std::endl;
      }
    }
    diagnosticsLog("Number of elements overlapping (centroid-based heuristics): " +
                       Moose::stringify(num_elem_overlaps),
                   _check_element_overlap,
                   num_elem_overlaps);
  }
}

Referenced by generate().

◆ checkElementTypes()

void MeshDiagnosticsGenerator::checkElementTypes ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check the element types in each subdomain.

Definition at line 538 of file MeshDiagnosticsGenerator.C.

{
  std::set<subdomain_id_type> ids;
  mesh->subdomain_ids(ids);
  // loop on sub-domain
  for (auto & id : ids)
  {
    // ElemType defines an enum for geometric element types
    std::set<ElemType> types;
    // loop on elements within this sub-domain
    for (auto & elem : mesh->active_subdomain_elements_ptr_range(id))
      types.insert(elem->type());
 
    std::string elem_type_names = "";
    for (auto & elem_type : types)
      elem_type_names += " " + Moose::stringify(elem_type);
 
    _console << "Element type in subdomain " + mesh->subdomain_name(id) + " (" +
                    std::to_string(id) + ") :" + elem_type_names
             << std::endl;
    if (types.size() > 1)
      diagnosticsLog("Two different element types in subdomain " + std::to_string(id),
                     _check_element_types,
                     true);
  }
}

Referenced by generate().

◆ checkElementVolumes()

void MeshDiagnosticsGenerator::checkElementVolumes ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check the element volumes.

Definition at line 486 of file MeshDiagnosticsGenerator.C.

{
  unsigned int num_tiny_elems = 0;
  unsigned int num_negative_elems = 0;
  unsigned int num_big_elems = 0;
  // loop elements within the mesh (assumes replicated)
  for (auto & elem : mesh->active_element_ptr_range())
  {
    Real vol = elem->volume();
 
    if (vol <= _min_volume)
    {
      if (num_tiny_elems < _num_outputs)
        _console << "Element with volume below threshold detected : \n"
                 << "id " << elem->id() << " near point " << elem->vertex_average() << std::endl;
      else if (num_tiny_elems == _num_outputs)
        _console << "Maximum output reached, log is silenced" << std::endl;
      num_tiny_elems++;
    }
    if (vol < 0)
    {
      if (num_negative_elems < _num_outputs)
        _console << "Element with negative volume detected : \n"
                 << "id " << elem->id() << " near point " << elem->vertex_average() << std::endl;
      else if (num_negative_elems == _num_outputs)
        _console << "Maximum output reached, log is silenced" << std::endl;
      num_negative_elems++;
    }
    if (vol >= _max_volume)
    {
      if (num_big_elems < _num_outputs)
        _console << "Element with volume above threshold detected : \n"
                 << elem->get_info() << std::endl;
      else if (num_big_elems == _num_outputs)
        _console << "Maximum output reached, log is silenced" << std::endl;
      num_big_elems++;
    }
  }
  diagnosticsLog("Number of elements below prescribed minimum volume : " +
                     std::to_string(num_tiny_elems),
                 _check_element_volumes,
                 num_tiny_elems);
  diagnosticsLog("Number of elements with negative volume : " + std::to_string(num_negative_elems),
                 _check_element_volumes,
                 num_negative_elems);
  diagnosticsLog("Number of elements above prescribed maximum volume : " +
                     std::to_string(num_big_elems),
                 _check_element_volumes,
                 num_big_elems);
}

Referenced by generate().

◆ 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());
  }
 
#ifdef MOOSE_MFEM_ENABLED
  if (mg_sys.hasMeshGenerator(mesh_generator_name))
  {
    const auto is_mfem = [](const InputParameters & pars)
    {
      const auto * const flag = pars.queryParam<bool>("_mfem_mesh_generator");
      return flag && *flag;
    };
    const auto & parent = mg_sys.getMeshGenerator(mesh_generator_name);
    const bool parent_is_mfem = is_mfem(parent.parameters());
    const bool this_is_mfem = is_mfem(parameters());
    if (parent_is_mfem != this_is_mfem)
    {
      const auto & mfem_name = parent_is_mfem ? mesh_generator_name : name();
      const auto & mfem_type = parent_is_mfem ? parent.type() : type();
      const auto & libmesh_name = parent_is_mfem ? name() : mesh_generator_name;
      const auto & libmesh_type = parent_is_mfem ? type() : parent.type();
      const std::string msg = "Cannot chain MFEM-native mesh generator '" + mfem_name +
                              "' of type '" + mfem_type + "' with libMesh-native mesh generator '" +
                              libmesh_name + "' of type '" + libmesh_type +
                              "'. MFEM and libMesh mesh generators cannot be mixed within the "
                              "same generator chain.";
      if (param_name.size())
        paramError(param_name, msg);
      else
        mooseError(msg);
    }
  }
#endif
}

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

◆ checkLocalJacobians()

void MeshDiagnosticsGenerator::checkLocalJacobians ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check whether the Jacobians (elem and side) are not negative.

Definition at line 1416 of file MeshDiagnosticsGenerator.C.

{
  unsigned int num_bad_elem_qp_jacobians = 0;
  // Get a high-ish order quadrature
  auto qrule_dimension = mesh->mesh_dimension();
  libMesh::QGauss qrule(qrule_dimension, FIFTH);
 
  // Use a constant monomial
  const libMesh::FEType fe_type(CONSTANT, libMesh::MONOMIAL);
 
  // Initialize a basic constant monomial shape function everywhere
  std::unique_ptr<libMesh::FEBase> fe_elem;
  if (mesh->mesh_dimension() == 1)
    fe_elem = std::make_unique<libMesh::FEMonomial<1>>(fe_type);
  if (mesh->mesh_dimension() == 2)
    fe_elem = std::make_unique<libMesh::FEMonomial<2>>(fe_type);
  else
    fe_elem = std::make_unique<libMesh::FEMonomial<3>>(fe_type);
 
  fe_elem->get_JxW();
  fe_elem->attach_quadrature_rule(&qrule);
 
  // Check elements (assumes serialized mesh)
  for (const auto & elem : mesh->element_ptr_range())
  {
    // Handle mixed-dimensional meshes
    if (qrule_dimension != elem->dim())
    {
      // Re-initialize a quadrature
      qrule_dimension = elem->dim();
      qrule = libMesh::QGauss(qrule_dimension, FIFTH);
 
      // Re-initialize a monomial FE
      if (elem->dim() == 1)
        fe_elem = std::make_unique<libMesh::FEMonomial<1>>(fe_type);
      if (elem->dim() == 2)
        fe_elem = std::make_unique<libMesh::FEMonomial<2>>(fe_type);
      else
        fe_elem = std::make_unique<libMesh::FEMonomial<3>>(fe_type);
 
      fe_elem->get_JxW();
      fe_elem->attach_quadrature_rule(&qrule);
    }
 
    try
    {
      fe_elem->reinit(elem);
    }
    catch (std::exception & e)
    {
      if (!strstr(e.what(), "Jacobian"))
        throw;
 
      num_bad_elem_qp_jacobians++;
      if (num_bad_elem_qp_jacobians < _num_outputs)
        _console << "Bad Jacobian found in element " << elem->id() << " near point "
                 << elem->vertex_average() << std::endl;
      else if (num_bad_elem_qp_jacobians == _num_outputs)
        _console << "Maximum log output reached, silencing output" << std::endl;
    }
  }
  diagnosticsLog("Number of elements with a bad Jacobian: " +
                     Moose::stringify(num_bad_elem_qp_jacobians),
                 _check_local_jacobian,
                 num_bad_elem_qp_jacobians);
 
  unsigned int num_bad_side_qp_jacobians = 0;
  // Get a high-ish order side quadrature
  auto qrule_side_dimension = mesh->mesh_dimension() - 1;
  libMesh::QGauss qrule_side(qrule_side_dimension, FIFTH);
 
  // Use the side quadrature now
  fe_elem->attach_quadrature_rule(&qrule_side);
 
  // Check element sides
  for (const auto & elem : mesh->element_ptr_range())
  {
    // Handle mixed-dimensional meshes
    if (int(qrule_side_dimension) != elem->dim() - 1)
    {
      qrule_side_dimension = elem->dim() - 1;
      qrule_side = libMesh::QGauss(qrule_side_dimension, FIFTH);
 
      // Re-initialize a side FE
      if (elem->dim() == 1)
        fe_elem = std::make_unique<libMesh::FEMonomial<1>>(fe_type);
      if (elem->dim() == 2)
        fe_elem = std::make_unique<libMesh::FEMonomial<2>>(fe_type);
      else
        fe_elem = std::make_unique<libMesh::FEMonomial<3>>(fe_type);
 
      fe_elem->get_JxW();
      fe_elem->attach_quadrature_rule(&qrule_side);
    }
 
    for (const auto & side : elem->side_index_range())
    {
      try
      {
        fe_elem->reinit(elem, side);
      }
      catch (std::exception & e)
      {
        // In 2D dbg/devel modes libMesh could hit
        // libmesh_assert_not_equal_to on a side reinit
        if (!strstr(e.what(), "Jacobian") && !strstr(e.what(), "det != 0"))
          throw;
 
        num_bad_side_qp_jacobians++;
        if (num_bad_side_qp_jacobians < _num_outputs)
          _console << "Bad Jacobian found in side " << side << " of element" << elem->id()
                   << " near point " << elem->vertex_average() << std::endl;
        else if (num_bad_side_qp_jacobians == _num_outputs)
          _console << "Maximum log output reached, silencing output" << std::endl;
      }
    }
  }
  diagnosticsLog("Number of element sides with bad Jacobians: " +
                     Moose::stringify(num_bad_side_qp_jacobians),
                 _check_local_jacobian,
                 num_bad_side_qp_jacobians);
}

Referenced by generate().

◆ checkNonConformalMesh()

void MeshDiagnosticsGenerator::checkNonConformalMesh ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check whether a mesh presents non-conformality.

Definition at line 699 of file MeshDiagnosticsGenerator.C.

{
  unsigned int num_nonconformal_nodes = 0;
  MeshBaseDiagnosticsUtils::checkNonConformalMesh(
      mesh, _console, _num_outputs, _non_conformality_tol, num_nonconformal_nodes);
  diagnosticsLog("Number of non-conformal nodes: " + Moose::stringify(num_nonconformal_nodes),
                 _check_non_conformal_mesh,
                 num_nonconformal_nodes);
}

Referenced by generate().

◆ checkNonConformalMeshFromAdaptivity()

void MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check whether a mesh presents non-conformality born from adaptivity.

Definition at line 768 of file MeshDiagnosticsGenerator.C.

{
  unsigned int num_likely_AMR_created_nonconformality = 0;
  auto pl = mesh->sub_point_locator();
  pl->set_close_to_point_tol(_non_conformality_tol);
 
  // We have to make a copy because adding the new parent element to the mesh
  // will modify the mesh for the analysis of the next nodes
  // Make a copy of the mesh, add this element
  auto mesh_copy = mesh->clone();
  libMesh::MeshRefinement mesh_refiner(*mesh_copy);
 
  // loop on nodes, assumes a replicated mesh
  for (auto & node : mesh->node_ptr_range())
  {
    // find all the elements around this node
    std::set<const Elem *> elements_around;
    (*pl)(*node, elements_around);
 
    // Keep track of the refined elements and the coarse element
    std::set<const Elem *> fine_elements;
    std::set<const Elem *> coarse_elements;
 
    // loop through the set of elements near this node
    for (auto elem : elements_around)
    {
      // If the node is not part of this element's nodes, it is a
      // case of non-conformality
      bool node_on_elem = false;
 
      if (elem->get_node_index(node) != libMesh::invalid_uint)
      {
        node_on_elem = true;
        // non-vertex nodes are not cause for the kind of non-conformality we are looking for
        if (!elem->is_vertex(elem->get_node_index(node)))
          continue;
      }
 
      // Keep track of all the elements this node is a part of. They are potentially the
      // 'fine' (refined) elements next to a coarser element
      if (node_on_elem)
        fine_elements.insert(elem);
      // Else, the node is not part of the element considered, so if the element had been part
      // of an AMR-created non-conformality, this element is on the coarse side
      if (!node_on_elem)
        coarse_elements.insert(elem);
    }
 
    // all the elements around contained the node as one of their nodes
    // if the coarse and refined sides are not stitched together, this check can fail,
    // as nodes that are physically near one element are not part of it because of the lack of
    // stitching (overlapping nodes)
    if (fine_elements.size() == elements_around.size())
      continue;
 
    if (fine_elements.empty())
      continue;
 
    // Depending on the type of element, we already know the number of elements we expect
    // to be part of this set of likely refined candidates for a given non-conformal node to
    // examine. We can only decide if it was born out of AMR if it's the center node of the face
    // of a coarse element near refined elements
    const auto elem_type = (*fine_elements.begin())->type();
    if ((elem_type == QUAD4 || elem_type == QUAD8 || elem_type == QUAD9) &&
        fine_elements.size() != 2)
      continue;
    else if ((elem_type == HEX8 || elem_type == HEX20 || elem_type == HEX27) &&
             fine_elements.size() != 4)
      continue;
    else if ((elem_type == TRI3 || elem_type == TRI6 || elem_type == TRI7) &&
             fine_elements.size() != 3)
      continue;
    else if ((elem_type == TET4 || elem_type == TET10 || elem_type == TET14) &&
             (fine_elements.size() % 2 != 0))
      continue;
 
    // only one coarse element in front of refined elements except for tets. Whatever we're
    // looking at is not the interface between coarse and refined elements
    // Tets are split on their edges (rather than the middle of a face) so there could be any
    // number of coarse elements in front of the node non-conformality created by refinement
    if (elem_type != TET4 && elem_type != TET10 && elem_type != TET14 && coarse_elements.size() > 1)
      continue;
 
    // There exists non-conformality, the node should have been a node of all the elements
    // that are close enough to the node, and it is not
 
    // Nodes of the tentative parent element
    std::vector<const Node *> tentative_coarse_nodes;
 
    // For quads and hexes, there is one (quad) or four (hexes) sides that are tied to this node
    // at the non-conformal interface between the refined elements and a coarse element
    if (elem_type == QUAD4 || elem_type == QUAD8 || elem_type == QUAD9 || elem_type == HEX8 ||
        elem_type == HEX20 || elem_type == HEX27)
    {
      const auto elem = *fine_elements.begin();
 
      // Find which sides (of the elements) the node considered is part of
      std::vector<Elem *> node_on_sides;
      unsigned int side_inside_parent = std::numeric_limits<unsigned int>::max();
      for (auto i : make_range(elem->n_sides()))
      {
        const auto side = elem->side_ptr(i);
        std::vector<const Node *> other_nodes_on_side;
        bool node_on_side = false;
        for (const auto & elem_node : side->node_ref_range())
        {
          if (*node == elem_node)
            node_on_side = true;
          else
            other_nodes_on_side.emplace_back(&elem_node);
        }
        // node is on the side, but is it the side that goes away from the coarse element?
        if (node_on_side)
        {
          // if all the other nodes on this side are in one of the other potentially refined
          // elements, it's one of the side(s) (4 sides in a 3D hex for example) inside the
          // parent
          bool all_side_nodes_are_shared = true;
          for (const auto & other_node : other_nodes_on_side)
          {
            bool shared_with_a_fine_elem = false;
            for (const auto & other_elem : fine_elements)
              if (other_elem != elem &&
                  other_elem->get_node_index(other_node) != libMesh::invalid_uint)
                shared_with_a_fine_elem = true;
 
            if (!shared_with_a_fine_elem)
              all_side_nodes_are_shared = false;
          }
          if (all_side_nodes_are_shared)
          {
            side_inside_parent = i;
            // We stop examining sides, it does not matter which side we pick inside the parent
            break;
          }
        }
      }
      if (side_inside_parent == std::numeric_limits<unsigned int>::max())
        continue;
 
      // Gather the other potential elements in the refined element:
      // they are point neighbors of the node that is shared between all the elements flagged
      // for the non-conformality
      // Find shared node
      const auto interior_side = elem->side_ptr(side_inside_parent);
      const Node * interior_node = nullptr;
      for (const auto & other_node : interior_side->node_ref_range())
      {
        if (other_node == *node)
          continue;
        bool in_all_node_neighbor_elements = true;
        for (auto other_elem : fine_elements)
        {
          if (other_elem->get_node_index(&other_node) == libMesh::invalid_uint)
            in_all_node_neighbor_elements = false;
        }
        if (in_all_node_neighbor_elements)
        {
          interior_node = &other_node;
          break;
        }
      }
      // Did not find interior node. Probably not AMR
      if (!interior_node)
        continue;
 
      // Add point neighbors of interior node to list of potentially refined elements
      std::set<const Elem *> all_elements;
      elem->find_point_neighbors(*interior_node, all_elements);
 
      if (elem_type == QUAD4 || elem_type == QUAD8 || elem_type == QUAD9)
      {
        const auto success = MeshCoarseningUtils::getFineElementsFromInteriorNode(
            *interior_node, *node, *elem, tentative_coarse_nodes, fine_elements);
        if (!success)
          continue;
      }
      // For hexes we first look at the fine-neighbors of the non-conformality
      // then the fine elements neighbors of the center 'node' of the potential parent
      else
      {
        // Get the coarse neighbor side to be able to recognize nodes that should become part of
        // the coarse parent
        const auto & coarse_elem = *coarse_elements.begin();
        unsigned short coarse_side_i = 0;
        for (const auto & coarse_side_index : coarse_elem->side_index_range())
        {
          const auto coarse_side_ptr = coarse_elem->side_ptr(coarse_side_index);
          // The side of interest is the side that contains the non-conformality
          if (!coarse_side_ptr->close_to_point(*node, 10 * _non_conformality_tol))
            continue;
          else
          {
            coarse_side_i = coarse_side_index;
            break;
          }
        }
        const auto coarse_side = coarse_elem->side_ptr(coarse_side_i);
 
        // We did not find the side of the coarse neighbor near the refined elements
        // Try again at another node
        if (!coarse_side)
          continue;
 
        // We cant directly use the coarse neighbor nodes
        // - The user might be passing a disjoint mesh
        // - There could two levels of refinement separating the coarse neighbor and its refined
        // counterparts
        // We use the fine element nodes
        unsigned int i = 0;
        tentative_coarse_nodes.resize(4);
        for (const auto & elem_1 : fine_elements)
          for (const auto & coarse_node : elem_1->node_ref_range())
          {
            bool node_shared = false;
            for (const auto & elem_2 : fine_elements)
            {
              if (elem_2 != elem_1)
                if (elem_2->get_node_index(&coarse_node) != libMesh::invalid_uint)
                  node_shared = true;
            }
            // A node for the coarse parent will appear in only one fine neighbor (not shared)
            // and will lay on the side of the coarse neighbor
            // We only care about the coarse neighbor vertex nodes
            if (!node_shared && coarse_side->close_to_point(coarse_node, _non_conformality_tol) &&
                elem_1->is_vertex(elem_1->get_node_index(&coarse_node)))
              tentative_coarse_nodes[i++] = &coarse_node;
            mooseAssert(i <= 5, "We went too far in this index");
          }
 
        // We did not find 4 coarse nodes. Mesh might be disjoint and the coarse element does not
        // contain the fine elements nodes we found
        if (i != 4)
          continue;
 
        // Need to order these nodes to form a valid quad / base of an hex
        // We go around the axis formed by the node and the interior node
        Point axis = *interior_node - *node;
        const auto start_circle = elem->vertex_average();
        MeshCoarseningUtils::reorderNodes(
            tentative_coarse_nodes, *interior_node, start_circle, axis);
        tentative_coarse_nodes.resize(8);
 
        // Use the neighbors of the fine elements that contain these nodes to get the vertex
        // nodes
        for (const auto & elem : fine_elements)
        {
          // Find the index of the coarse node for the starting element
          unsigned int node_index = 0;
          for (const auto & coarse_node : tentative_coarse_nodes)
          {
            if (elem->get_node_index(coarse_node) != libMesh::invalid_uint)
              break;
            node_index++;
          }
 
          // Get the neighbor element that is part of the fine elements to coarsen together
          for (const auto & neighbor : elem->neighbor_ptr_range())
            if (all_elements.count(neighbor) && !fine_elements.count(neighbor))
            {
              // Find the coarse node for the neighbor
              const Node * coarse_elem_node = nullptr;
              for (const auto & fine_node : neighbor->node_ref_range())
              {
                if (!neighbor->is_vertex(neighbor->get_node_index(&fine_node)))
                  continue;
                bool node_shared = false;
                for (const auto & elem_2 : all_elements)
                  if (elem_2 != neighbor &&
                      elem_2->get_node_index(&fine_node) != libMesh::invalid_uint)
                    node_shared = true;
                if (!node_shared)
                {
                  coarse_elem_node = &fine_node;
                  break;
                }
              }
              // Insert the coarse node at the right place
              tentative_coarse_nodes[node_index + 4] = coarse_elem_node;
              mooseAssert(node_index + 4 < tentative_coarse_nodes.size(), "Indexed too far");
              mooseAssert(coarse_elem_node, "Did not find last coarse element node");
            }
        }
      }
 
      // No need to separate fine elements near the non-conformal node and away from it
      fine_elements = all_elements;
    }
    // For TRI elements, we use the fine triangle element at the center of the potential
    // coarse triangle element
    else if (elem_type == TRI3 || elem_type == TRI6 || elem_type == TRI7)
    {
      // Find the center element
      // It's the only element that shares a side with both of the other elements near the node
      // considered
      const Elem * center_elem = nullptr;
      for (const auto refined_elem_1 : fine_elements)
      {
        unsigned int num_neighbors = 0;
        for (const auto refined_elem_2 : fine_elements)
        {
          if (refined_elem_1 == refined_elem_2)
            continue;
          if (refined_elem_1->has_neighbor(refined_elem_2))
            num_neighbors++;
        }
        if (num_neighbors >= 2)
          center_elem = refined_elem_1;
      }
      // Did not find the center fine element, probably not AMR
      if (!center_elem)
        continue;
      // Now get the tentative coarse element nodes
      for (const auto refined_elem : fine_elements)
      {
        if (refined_elem == center_elem)
          continue;
        for (const auto & other_node : refined_elem->node_ref_range())
          if (center_elem->get_node_index(&other_node) == libMesh::invalid_uint &&
              refined_elem->is_vertex(refined_elem->get_node_index(&other_node)))
            tentative_coarse_nodes.push_back(&other_node);
      }
 
      // Get the final tentative new coarse element node, on the other side of the center
      // element from the non-conformality
      unsigned int center_side_opposite_node = std::numeric_limits<unsigned int>::max();
      for (auto side_index : center_elem->side_index_range())
        if (center_elem->side_ptr(side_index)->get_node_index(node) == libMesh::invalid_uint)
          center_side_opposite_node = side_index;
      const auto neighbor_on_other_side_of_opposite_center_side =
          center_elem->neighbor_ptr(center_side_opposite_node);
 
      // Element is on a boundary, cannot form a coarse element
      if (!neighbor_on_other_side_of_opposite_center_side)
        continue;
 
      fine_elements.insert(neighbor_on_other_side_of_opposite_center_side);
      for (const auto & tri_node : neighbor_on_other_side_of_opposite_center_side->node_ref_range())
        if (neighbor_on_other_side_of_opposite_center_side->is_vertex(
                neighbor_on_other_side_of_opposite_center_side->get_node_index(&tri_node)) &&
            center_elem->side_ptr(center_side_opposite_node)->get_node_index(&tri_node) ==
                libMesh::invalid_uint)
          tentative_coarse_nodes.push_back(&tri_node);
 
      mooseAssert(center_side_opposite_node != std::numeric_limits<unsigned int>::max(),
                  "Did not find the side opposite the non-conformality");
      mooseAssert(tentative_coarse_nodes.size() == 3,
                  "We are forming a coarsened triangle element");
    }
    // For TET elements, it's very different because the non-conformality does not happen inside
    // of a face, but on an edge of one or more coarse elements
    else if (elem_type == TET4 || elem_type == TET10 || elem_type == TET14)
    {
      // There are 4 tets on the tips of the coarsened tet and 4 tets inside
      // let's identify all of them
      std::set<const Elem *> tips_tets;
      std::set<const Elem *> inside_tets;
 
      // pick a coarse element and work with its fine neighbors
      const Elem * coarse_elem = nullptr;
      std::set<const Elem *> fine_tets;
      for (auto & coarse_one : coarse_elements)
      {
        for (const auto & elem : fine_elements)
          // for two levels of refinement across, this is not working
          // we would need a "has_face_embedded_in_this_other_ones_face" routine
          if (elem->has_neighbor(coarse_one))
            fine_tets.insert(elem);
 
        if (fine_tets.size())
        {
          coarse_elem = coarse_one;
          break;
        }
      }
      // There's no coarse element neighbor to a group of finer tets, not AMR
      if (!coarse_elem)
        continue;
 
      // There is one last point neighbor of the node that is sandwiched between two neighbors
      for (const auto & elem : fine_elements)
      {
        int num_face_neighbors = 0;
        for (const auto & tet : fine_tets)
          if (tet->has_neighbor(elem))
            num_face_neighbors++;
        if (num_face_neighbors == 2)
        {
          fine_tets.insert(elem);
          break;
        }
      }
 
      // There should be two other nodes with non-conformality near this coarse element
      // Find both, as they will be nodes of the rest of the elements to add to the potential
      // fine tet list. They are shared by two of the fine tets we have already found
      std::set<const Node *> other_nodes;
      for (const auto & tet_1 : fine_tets)
      {
        for (const auto & node_1 : tet_1->node_ref_range())
        {
          if (&node_1 == node)
            continue;
          if (!tet_1->is_vertex(tet_1->get_node_index(&node_1)))
            continue;
          for (const auto & tet_2 : fine_tets)
          {
            if (tet_2 == tet_1)
              continue;
            if (tet_2->get_node_index(&node_1) != libMesh::invalid_uint)
              // check that it's near the coarse element as well
              if (coarse_elem->close_to_point(node_1, 10 * _non_conformality_tol))
                other_nodes.insert(&node_1);
          }
        }
      }
      mooseAssert(other_nodes.size() == 2,
                  "Should find only two extra non-conformal nodes near the coarse element");
 
      // Now we can go towards this tip element next to two non-conformalities
      for (const auto & tet_1 : fine_tets)
      {
        for (const auto & neighbor : tet_1->neighbor_ptr_range())
          if (neighbor->get_node_index(*other_nodes.begin()) != libMesh::invalid_uint &&
              neighbor->is_vertex(neighbor->get_node_index(*other_nodes.begin())) &&
              neighbor->get_node_index(*other_nodes.rbegin()) != libMesh::invalid_uint &&
              neighbor->is_vertex(neighbor->get_node_index(*other_nodes.rbegin())))
            fine_tets.insert(neighbor);
      }
      // Now that the element next to the time is in the fine_tets, we can get the tip
      for (const auto & tet_1 : fine_tets)
      {
        for (const auto & neighbor : tet_1->neighbor_ptr_range())
          if (neighbor->get_node_index(*other_nodes.begin()) != libMesh::invalid_uint &&
              neighbor->is_vertex(neighbor->get_node_index(*other_nodes.begin())) &&
              neighbor->get_node_index(*other_nodes.rbegin()) != libMesh::invalid_uint &&
              neighbor->is_vertex(neighbor->get_node_index(*other_nodes.rbegin())))
            fine_tets.insert(neighbor);
      }
 
      // Get the sandwiched tets between the tets we already found
      for (const auto & tet_1 : fine_tets)
        for (const auto & neighbor : tet_1->neighbor_ptr_range())
          for (const auto & tet_2 : fine_tets)
            if (tet_1 != tet_2 && tet_2->has_neighbor(neighbor) && neighbor != coarse_elem)
              fine_tets.insert(neighbor);
 
      // tips tests are the only ones to have a node that is shared by no other tet in the group
      for (const auto & tet_1 : fine_tets)
      {
        unsigned int unshared_nodes = 0;
        for (const auto & other_node : tet_1->node_ref_range())
        {
          if (!tet_1->is_vertex(tet_1->get_node_index(&other_node)))
            continue;
          bool node_shared = false;
          for (const auto & tet_2 : fine_tets)
            if (tet_2 != tet_1 && tet_2->get_node_index(&other_node) != libMesh::invalid_uint)
              node_shared = true;
          if (!node_shared)
            unshared_nodes++;
        }
        if (unshared_nodes == 1)
          tips_tets.insert(tet_1);
        else if (unshared_nodes == 0)
          inside_tets.insert(tet_1);
        else
          mooseError("Did not expect a tet to have two unshared vertex nodes here");
      }
 
      // Finally grab the last tip of the tentative coarse tet. It shares:
      // - 3 nodes with the other tips, only one with each
      // - 1 face with only one tet of the fine tet group
      // - it has a node that no other fine tet shares (the tip node)
      for (const auto & tet : inside_tets)
      {
        for (const auto & neighbor : tet->neighbor_ptr_range())
        {
          // Check that it shares a face with no other potential fine tet
          bool shared_with_another_tet = false;
          for (const auto & tet_2 : fine_tets)
          {
            if (tet_2 == tet)
              continue;
            if (tet_2->has_neighbor(neighbor))
              shared_with_another_tet = true;
          }
          if (shared_with_another_tet)
            continue;
 
          // Used to count the nodes shared with tip tets. Can only be 1 per tip tet
          std::vector<const Node *> tip_nodes_shared;
          unsigned int unshared_nodes = 0;
          for (const auto & other_node : neighbor->node_ref_range())
          {
            if (!neighbor->is_vertex(neighbor->get_node_index(&other_node)))
              continue;
 
            // Check for being a node-neighbor of the 3 other tip tets
            for (const auto & tip_tet : tips_tets)
            {
              if (neighbor == tip_tet)
                continue;
 
              // we could break here but we want to check that no other tip shares that node
              if (tip_tet->get_node_index(&other_node) != libMesh::invalid_uint)
                tip_nodes_shared.push_back(&other_node);
            }
            // Check for having a node shared with no other tet
            bool node_shared = false;
            for (const auto & tet_2 : fine_tets)
              if (tet_2 != neighbor && tet_2->get_node_index(&other_node) != libMesh::invalid_uint)
                node_shared = true;
            if (!node_shared)
              unshared_nodes++;
          }
          if (tip_nodes_shared.size() == 3 && unshared_nodes == 1)
            tips_tets.insert(neighbor);
        }
      }
 
      // append the missing fine tets (inside the coarse element, away from the node considered)
      // into the fine elements set for the check on "did it refine the tentative coarse tet
      // onto the same fine tets"
      fine_elements.clear();
      for (const auto & elem : tips_tets)
        fine_elements.insert(elem);
      for (const auto & elem : inside_tets)
        fine_elements.insert(elem);
 
      // get the vertex of the coarse element from the tip tets
      for (const auto & tip : tips_tets)
      {
        for (const auto & node : tip->node_ref_range())
        {
          bool outside = true;
 
          const auto id = tip->get_node_index(&node);
          if (!tip->is_vertex(id))
            continue;
          for (const auto & tet : inside_tets)
            if (tet->get_node_index(&node) != libMesh::invalid_uint)
              outside = false;
          if (outside)
          {
            tentative_coarse_nodes.push_back(&node);
            // only one tip node per tip tet
            break;
          }
        }
      }
 
      std::sort(tentative_coarse_nodes.begin(), tentative_coarse_nodes.end());
      tentative_coarse_nodes.erase(
          std::unique(tentative_coarse_nodes.begin(), tentative_coarse_nodes.end()),
          tentative_coarse_nodes.end());
 
      // The group of fine elements ended up having less or more than 4 tips, so it's clearly
      // not forming a coarse tetrahedral
      if (tentative_coarse_nodes.size() != 4)
        continue;
    }
    else
    {
      mooseInfo("Unsupported element type ",
                elem_type,
                ". Skipping detection for this node and all future nodes near only this "
                "element type");
      continue;
    }
 
    // Check the fine element types: if not all the same then it's not uniform AMR
    for (auto elem : fine_elements)
      if (elem->type() != elem_type)
        continue;
 
    // Check the number of coarse element nodes gathered
    for (const auto & check_node : tentative_coarse_nodes)
      if (check_node == nullptr)
        continue;
 
    // Form a parent, of a low order type as we only have the extreme vertex nodes
    std::unique_ptr<Elem> parent = Elem::build(Elem::first_order_equivalent_type(elem_type));
    auto parent_ptr = mesh_copy->add_elem(parent.release());
 
    // Set the nodes to the coarse element
    for (auto i : index_range(tentative_coarse_nodes))
      parent_ptr->set_node(i, mesh_copy->node_ptr(tentative_coarse_nodes[i]->id()));
 
    // Refine this parent
    parent_ptr->set_refinement_flag(Elem::REFINE);
    parent_ptr->refine(mesh_refiner);
    const auto num_children = parent_ptr->n_children();
 
    // Compare with the original set of elements
    // We already know the child share the exterior node. If they share the same vertex
    // average as the group of unrefined elements we will call this good enough for now
    // For tetrahedral elements we cannot rely on the children all matching as the choice in
    // the diagonal selection can be made differently. We'll just say 4 matching children is
    // good enough for the heuristic
    unsigned int num_children_match = 0;
    for (const auto & child : parent_ptr->child_ref_range())
    {
      for (const auto & potential_children : fine_elements)
        if (MooseUtils::absoluteFuzzyEqual(child.vertex_average()(0),
                                           potential_children->vertex_average()(0),
                                           _non_conformality_tol) &&
            MooseUtils::absoluteFuzzyEqual(child.vertex_average()(1),
                                           potential_children->vertex_average()(1),
                                           _non_conformality_tol) &&
            MooseUtils::absoluteFuzzyEqual(child.vertex_average()(2),
                                           potential_children->vertex_average()(2),
                                           _non_conformality_tol))
        {
          num_children_match++;
          break;
        }
    }
 
    if (num_children_match == num_children ||
        ((elem_type == TET4 || elem_type == TET10 || elem_type == TET14) &&
         num_children_match == 4))
    {
      num_likely_AMR_created_nonconformality++;
      if (num_likely_AMR_created_nonconformality < _num_outputs)
      {
        _console << "Detected non-conformality likely created by AMR near" << *node
                 << Moose::stringify(elem_type)
                 << " elements that could be merged into a coarse element:" << std::endl;
        for (const auto & elem : fine_elements)
          _console << elem->id() << " ";
        _console << std::endl;
      }
      else if (num_likely_AMR_created_nonconformality == _num_outputs)
        _console << "Maximum log output reached, silencing output" << std::endl;
    }
  }
 
  diagnosticsLog(
      "Number of non-conformal nodes likely due to mesh refinement detected by heuristic: " +
          Moose::stringify(num_likely_AMR_created_nonconformality),
      _check_adaptivity_non_conformality,
      num_likely_AMR_created_nonconformality);
  pl->unset_close_to_point_tol();
}

Referenced by generate().

◆ checkNonConformingFaces()

void MeshDiagnosticsGenerator::checkNonConformingFaces ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check for element faces that border material but match no neighbor face.

Definition at line 710 of file MeshDiagnosticsGenerator.C.

{
  // A conforming internal interface has a matching face on each side, so libMesh assigns a
  // neighbor across it. This check finds element faces that have NO neighbor on a side,
  // (considered external) yet have material on the other side -- i.e. the face is covered by
  // neighbor faces that share only part of it, such as a HEX8 quad face abutting two TET4
  // triangle faces. All corners are shared in that situation, so no node lies on another
  // element's face and the hanging-node 'examine_non_conformality' check does not detect it.
  //
  // For each external (no-neighbor) face, we probe a point just outside it, along the outward
  // direction from the element centroid. If the point locator finds another element there, the
  // face borders material but matched no neighbor face, so the interface is non-conforming.
  auto pl = mesh->sub_point_locator();
  pl->enable_out_of_mesh_mode();
  unsigned int num_nonconforming_faces = 0;
  for (const auto elem : mesh->active_element_ptr_range())
  {
    const Point elem_center = elem->vertex_average();
    for (const auto s : elem->side_index_range())
    {
      // Skip faces that already have a matching neighbor; those are conforming.
      if (elem->neighbor_ptr(s) != nullptr)
        continue;
      const auto side = elem->side_ptr(s);
      const Point side_center = side->vertex_average();
      // Just outside the face (1% of the centroid-to-face distance beyond it).
      const Point probe = side_center + 0.01 * (side_center - elem_center);
      std::set<const Elem *> found;
      (*pl)(probe, found);
      bool material_outside = false;
      for (const auto other : found)
        if (other != elem && other->active())
        {
          material_outside = true;
          break;
        }
      if (material_outside)
      {
        if (num_nonconforming_faces < _num_outputs)
          _console << "Non-conforming element face (borders another cell but matches no neighbor "
                      "element across the face) on "
                      "element "
                   << elem->id() << " side " << s << " near " << side_center << std::endl;
        num_nonconforming_faces++;
      }
    }
  }
  pl->disable_out_of_mesh_mode();
  diagnosticsLog(
      "Number of non-conforming element faces (border another cell but match no neighbor "
      "element across the face): " +
          std::to_string(num_nonconforming_faces),
      _check_nonconforming_faces != "NO_CHECK" ? _check_nonconforming_faces
                                               : _check_non_conformal_mesh,
      num_nonconforming_faces);
}

Referenced by generate().

◆ checkNonMatchingEdges()

void MeshDiagnosticsGenerator::checkNonMatchingEdges ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check for non matching edges.

Definition at line 1540 of file MeshDiagnosticsGenerator.C.

{
  /*Algorithm Overview
    1)Prechecks
      a)This algorithm only works for 3D so check for that first
    2)Loop
      a)Loop through every element
      b)For each element get the edges associated with it
      c)For each edge check overlap with any edges of nearby elements
      d)Have check to make sure the same pair of edges are not being tested twice for overlap
    3)Overlap check
      a)Shortest line that connects both lines is perpendicular to both lines
      b)A good overview of the math for finding intersecting lines can be found
    here->paulbourke.net/geometry/pointlineplane/
  */
  if (mesh->mesh_dimension() != 3)
  {
    mooseWarning("The edge intersection algorithm only works with 3D meshes. "
                 "'examine_non_matching_edges' is skipped");
    return;
  }
  if (!mesh->is_serial())
    mooseError("Only serialized/replicated meshes are supported");
  unsigned int num_intersecting_edges = 0;
 
  // Create map of element to bounding box to avoing reinitializing the same bounding box multiple
  // times
  std::unordered_map<Elem *, BoundingBox> bounding_box_map;
  for (const auto elem : mesh->active_element_ptr_range())
  {
    const auto boundingBox = elem->loose_bounding_box();
    bounding_box_map.insert({elem, boundingBox});
  }
 
  std::unique_ptr<PointLocatorBase> point_locator = mesh->sub_point_locator();
  std::set<std::array<dof_id_type, 4>> overlapping_edges_nodes;
  for (const auto elem : mesh->active_element_ptr_range())
  {
    // loop through elem's nodes and find nearby elements with it
    std::set<const Elem *> candidate_elems;
    std::set<const Elem *> nearby_elems;
    for (unsigned int i = 0; i < elem->n_nodes(); i++)
    {
      (*point_locator)(elem->point(i), candidate_elems);
      nearby_elems.insert(candidate_elems.begin(), candidate_elems.end());
    }
    std::vector<std::unique_ptr<const Elem>> elem_edges(elem->n_edges());
    for (auto i : elem->edge_index_range())
      elem_edges[i] = elem->build_edge_ptr(i);
    for (const auto other_elem : nearby_elems)
    {
      // If they're the same element then there's no need to check for overlap
      if (elem->id() >= other_elem->id())
        continue;
 
      std::vector<std::unique_ptr<const Elem>> other_edges(other_elem->n_edges());
      for (auto j : other_elem->edge_index_range())
        other_edges[j] = other_elem->build_edge_ptr(j);
      for (auto & edge : elem_edges)
      {
        for (auto & other_edge : other_edges)
        {
          // Get nodes from edges
          const Node * n1 = edge->get_nodes()[0];
          const Node * n2 = edge->get_nodes()[1];
          const Node * n3 = other_edge->get_nodes()[0];
          const Node * n4 = other_edge->get_nodes()[1];
 
          // Create array<dof_id_type, 4> to check against set
          std::array<dof_id_type, 4> node_id_array = {n1->id(), n2->id(), n3->id(), n4->id()};
          std::sort(node_id_array.begin(), node_id_array.end());
 
          // Check if the edges have already been added to our check_edges list
          if (overlapping_edges_nodes.count(node_id_array))
          {
            continue;
          }
 
          // Check element/edge type
          if (edge->type() != EDGE2)
          {
            std::string element_message = "Edge of type " + Utility::enum_to_string(edge->type()) +
                                          " was found in cell " + std::to_string(elem->id()) +
                                          " which is of type " +
                                          Utility::enum_to_string(elem->type()) + '\n' +
                                          "The edge intersection check only works for EDGE2 "
                                          "elements.\nThis message will not be output again";
            mooseDoOnce(_console << element_message << std::endl);
            continue;
          }
          if (other_edge->type() != EDGE2)
            continue;
 
          // Now compare edge with other_edge
          Point intersection_coords;
          bool overlap = MeshBaseDiagnosticsUtils::checkFirstOrderEdgeOverlap(
              *edge, *other_edge, intersection_coords, _non_matching_edge_tol);
          if (overlap)
          {
            // Add the nodes that make up the 2 edges to the vector overlapping_edges_nodes
            overlapping_edges_nodes.insert(node_id_array);
            num_intersecting_edges += 2;
            if (num_intersecting_edges < _num_outputs)
            {
              // Print error message
              std::string elem_id = std::to_string(elem->id());
              std::string other_elem_id = std::to_string(other_elem->id());
              std::string x_coord = std::to_string(intersection_coords(0));
              std::string y_coord = std::to_string(intersection_coords(1));
              std::string z_coord = std::to_string(intersection_coords(2));
              std::string message = "Intersecting edges found between elements " + elem_id +
                                    " and " + other_elem_id + " near point (" + x_coord + ", " +
                                    y_coord + ", " + z_coord + ")";
              _console << message << std::endl;
            }
          }
        }
      }
    }
  }
  diagnosticsLog("Number of intersecting element edges: " +
                     Moose::stringify(num_intersecting_edges),
                 _check_non_matching_edges,
                 num_intersecting_edges);
}

Referenced by generate().

◆ checkNonPlanarSides()

void MeshDiagnosticsGenerator::checkNonPlanarSides ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check whether there are non-planar sides in the mesh.

Definition at line 638 of file MeshDiagnosticsGenerator.C.

{
  unsigned int sides_non_planar = 0;
  // loop on all elements in mesh: assumes a replicated mesh
  for (auto & elem : mesh->active_element_ptr_range())
  {
    for (auto i : make_range(elem->n_sides()))
    {
      auto side = elem->side_ptr(i);
      std::vector<const Point *> nodes;
      for (auto & node : side->node_ref_range())
        nodes.emplace_back(&node);
 
      if (nodes.size() <= 3)
        continue;
      // First vector of the base
      const RealVectorValue v1 = *nodes[0] - *nodes[1];
 
      // Find another node so that we can form a basis. It should just be node 0, 1, 2
      // to form two independent vectors, but degenerate elements can make them aligned
      bool aligned = true;
      unsigned int third_node_index = 2;
      RealVectorValue v2;
      while (aligned && third_node_index < nodes.size())
      {
        v2 = *nodes[0] - *nodes[third_node_index++];
        aligned = MooseUtils::absoluteFuzzyEqual(v1 * v2 - v1.norm() * v2.norm(), 0);
      }
 
      // Degenerate element, could not find a third node that is not aligned
      if (aligned)
        continue;
 
      bool found_non_planar = false;
 
      for (auto node_offset : make_range(nodes.size() - 3))
      {
        RealVectorValue v3 = *nodes[0] - *nodes[node_offset + 3];
        bool planar = MooseUtils::absoluteFuzzyEqual(v2.cross(v1) * v3, 0);
        if (!planar)
          found_non_planar = true;
      }
 
      if (found_non_planar)
      {
        sides_non_planar++;
        if (sides_non_planar < _num_outputs)
          _console << "Nonplanar side detected for side " << i
                   << " of element :" << elem->get_info() << std::endl;
        else if (sides_non_planar == _num_outputs)
          _console << "Maximum output reached, log is silenced" << std::endl;
      }
    }
  }
  diagnosticsLog("Number of non-planar element sides detected: " +
                     Moose::stringify(sides_non_planar),
                 _check_non_planar_sides,
                 sides_non_planar);
}

Referenced by generate().

◆ checkPolygons()

void MeshDiagnosticsGenerator::checkPolygons ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check for non-convex polygons.

Definition at line 1667 of file MeshDiagnosticsGenerator.C.

{
  unsigned int num_polygons = 0;
  unsigned int num_nonconvex = 0;
  unsigned int num_nonplanar = 0;
  unsigned int num_flat_consecutive_sides = 0;
 
  for (const auto & elem : mesh->element_ptr_range())
    if (elem->type() == libMesh::C0POLYGON)
    {
      num_polygons++;
      const auto n_nodes = elem->n_nodes();
      Point base_top_dir(0, 0, 0);
      bool nonconvex = false;
      bool nonplanar = false;
      for (const auto & i : make_range(n_nodes))
      {
        const auto n1 = elem->point(i);
        const auto n2 = elem->point((i + 1) % n_nodes);
        const auto n3 = elem->point((i + 2) % n_nodes);
        // can't be const with unit
        Point top_dir = (n2 - n1).cross(n3 - n2);
 
        if (top_dir.norm_sq() > 0 && base_top_dir.norm() == 0)
        {
          base_top_dir = top_dir.unit();
          continue;
        }
        if (base_top_dir * top_dir < 0)
          nonconvex = true;
        if (top_dir.norm_sq() > 0)
          top_dir = top_dir.unit();
        else
          num_flat_consecutive_sides++;
        if (!MooseUtils::absoluteFuzzyEqual((top_dir - base_top_dir).norm_sq(), 0, TOLERANCE) &&
            !MooseUtils::absoluteFuzzyEqual((top_dir + base_top_dir).norm_sq(), 0, TOLERANCE))
          nonplanar = true;
      }
 
      if (nonconvex)
      {
        num_nonconvex++;
        if (num_nonconvex < _num_outputs)
          _console << "Non convex C0 polygon detected:" << elem->get_info() << std::endl;
        else if (num_nonconvex == _num_outputs)
          _console << "Ouptut limit reached for non-convex polygons" << std::endl;
      }
      if (nonplanar)
      {
        num_nonplanar++;
        if (num_nonconvex < _num_outputs)
          _console << "Non planar C0 polygon detected:" << elem->get_info() << std::endl;
        else if (num_nonconvex == _num_outputs)
          _console << "Ouptut limit reached for non-planar polygons" << std::endl;
      }
    }
 
  if (!num_polygons)
    mooseWarning("No C0 polygons in geometry: polyon check did nothing");
  else
  {
    diagnosticsLog("Number of non convex polygons: " + Moose::stringify(num_nonconvex),
                   _check_polygons,
                   num_nonconvex);
    diagnosticsLog("Number of non planar polygons: " + Moose::stringify(num_nonplanar),
                   _check_polygons,
                   num_nonplanar);
    diagnosticsLog("Number of colinear consecutive sides of polygons: " +
                       Moose::stringify(num_flat_consecutive_sides),
                   _check_polygons,
                   num_flat_consecutive_sides);
  }
}

Referenced by generate().

◆ checkSidesetsOrientation()

void MeshDiagnosticsGenerator::checkSidesetsOrientation ( const std::unique_ptr< MeshBase > & mesh ) const

private

Routine to check sideset orientation near subdomains.

Definition at line 216 of file MeshDiagnosticsGenerator.C.

{
  auto & boundary_info = mesh->get_boundary_info();
  auto side_tuples = boundary_info.build_side_list();
 
  for (const auto bid : boundary_info.get_boundary_ids())
  {
    // This check only looks at subdomains on both sides of the sideset
    // it wont pick up if the sideset is changing orientations while inside of a subdomain
    std::set<std::pair<subdomain_id_type, subdomain_id_type>> block_neighbors;
    for (const auto index : index_range(side_tuples))
    {
      if (std::get<2>(side_tuples[index]) != bid)
        continue;
      const auto elem_ptr = mesh->elem_ptr(std::get<0>(side_tuples[index]));
      if (elem_ptr->neighbor_ptr(std::get<1>(side_tuples[index])))
        block_neighbors.insert(std::make_pair(
            elem_ptr->subdomain_id(),
            elem_ptr->neighbor_ptr(std::get<1>(side_tuples[index]))->subdomain_id()));
    }
 
    // Check that there is no flipped pair
    std::set<std::pair<subdomain_id_type, subdomain_id_type>> flipped_pairs;
    for (const auto & block_pair_1 : block_neighbors)
      for (const auto & block_pair_2 : block_neighbors)
        if (block_pair_1 != block_pair_2)
          if (block_pair_1.first == block_pair_2.second &&
              block_pair_1.second == block_pair_2.first)
            flipped_pairs.insert(block_pair_1);
 
    std::string message;
    const std::string sideset_full_name =
        boundary_info.sideset_name(bid) + " (" + std::to_string(bid) + ")";
    if (!flipped_pairs.empty())
    {
      std::string block_pairs_string = "";
      for (const auto & pair : flipped_pairs)
        block_pairs_string +=
            " [" + mesh->subdomain_name(pair.first) + " (" + std::to_string(pair.first) + "), " +
            mesh->subdomain_name(pair.second) + " (" + std::to_string(pair.second) + ")]";
      message = "Inconsistent orientation of sideset " + sideset_full_name +
                " with regards to subdomain pairs" + block_pairs_string;
    }
    else
      message = "Sideset " + sideset_full_name +
                " is consistently oriented with regards to the blocks it neighbors";
 
    diagnosticsLog(message, _check_sidesets_orientation, flipped_pairs.size());
 
    // Now check that there is no sideset radically flipping from one side's normal to another
    // side next to it, in the same sideset
    // We'll consider pi / 2 to be the most steep angle we'll pass
    unsigned int num_normals_flipping = 0;
    Real steepest_side_angles = 0;
    for (const auto & [elem_id, side_id, side_bid] : side_tuples)
    {
      if (side_bid != bid)
        continue;
      const auto & elem_ptr = mesh->elem_ptr(elem_id);
 
      // Get side normal
      const std::unique_ptr<const Elem> face = elem_ptr->build_side_ptr(side_id);
      std::unique_ptr<libMesh::FEBase> fe(
          libMesh::FEBase::build(elem_ptr->dim(), libMesh::FEType(elem_ptr->default_order())));
      libMesh::QGauss qface(elem_ptr->dim() - 1, CONSTANT);
      fe->attach_quadrature_rule(&qface);
      const auto & normals = fe->get_normals();
      fe->reinit(elem_ptr, side_id);
      mooseAssert(normals.size() == 1, "We expected only one normal here");
      const auto & side_normal = normals[0];
 
      // Compare to the sideset normals of neighbor sides in that sideset
      for (const auto neighbor : elem_ptr->neighbor_ptr_range())
        if (neighbor)
          for (const auto neigh_side_index : neighbor->side_index_range())
          {
            // Check that the neighbor side is also in the sideset being examined
            if (!boundary_info.has_boundary_id(neighbor, neigh_side_index, bid))
              continue;
 
            // We re-init everything for the neighbor in case it's a different dimension
            std::unique_ptr<libMesh::FEBase> fe_neighbor(libMesh::FEBase::build(
                neighbor->dim(), libMesh::FEType(neighbor->default_order())));
            libMesh::QGauss qface(neighbor->dim() - 1, CONSTANT);
            fe_neighbor->attach_quadrature_rule(&qface);
            const auto & neigh_normals = fe_neighbor->get_normals();
            fe_neighbor->reinit(neighbor, neigh_side_index);
            mooseAssert(neigh_normals.size() == 1, "We expected only one normal here");
            const auto & neigh_side_normal = neigh_normals[0];
 
            // Check the angle by computing the dot product
            if (neigh_side_normal * side_normal <= 0)
            {
              num_normals_flipping++;
              steepest_side_angles =
                  std::max(std::acos(neigh_side_normal * side_normal), steepest_side_angles);
              if (num_normals_flipping <= _num_outputs)
                _console << "Side normals changed by more than pi/2 for sideset "
                         << sideset_full_name << " between side " << side_id << " of element "
                         << elem_ptr->id() << " and side " << neigh_side_index
                         << " of neighbor element " << neighbor->id() << std::endl;
              else if (num_normals_flipping == _num_outputs + 1)
                _console << "Maximum output reached for sideset normal flipping check. Silencing "
                            "output from now on"
                         << std::endl;
            }
          }
    }
 
    if (num_normals_flipping)
      message = "Sideset " + sideset_full_name +
                " has two neighboring sides with a very large angle. Largest angle detected: " +
                std::to_string(steepest_side_angles) + " rad (" +
                std::to_string(steepest_side_angles * 180 / libMesh::pi) + " degrees).";
    else
      message = "Sideset " + sideset_full_name +
                " does not appear to have side-to-neighbor-side orientation flips. All neighbor "
                "sides normal differ by less than pi/2";
 
    diagnosticsLog(message, _check_sidesets_orientation, num_normals_flipping);
  }
}

Referenced by generate().

◆ checkWatertightNodesets()

void MeshDiagnosticsGenerator::checkWatertightNodesets ( const std::unique_ptr< MeshBase > & mesh ) const

private

Definition at line 405 of file MeshDiagnosticsGenerator.C.

{
  /*
  Diagnostic Overview:
  1) Mesh precheck
  2) Loop through all elements
  3) Loop through all sides of that element
  4) If side is external loop through its nodes
  5) If node is not associated with any nodeset add to list
  6) Print out node id
  */
  if (mesh->mesh_dimension() < 2)
    mooseError("The nodeset check only works for 2D and 3D meshes");
  auto & boundary_info = mesh->get_boundary_info();
  unsigned int num_nodes_without_nodeset = 0;
  std::set<dof_id_type> checked_nodes_id;
 
  for (const auto elem : mesh->active_element_ptr_range())
  {
    for (const auto i : elem->side_index_range())
    {
      // Check if side is external
      if (elem->neighbor_ptr(i) == nullptr)
      {
        // Side is external, now check nodes
        auto side = elem->side_ptr(i);
        const auto & node_list = side->get_nodes();
        for (unsigned int j = 0; j < side->n_nodes(); j++)
        {
          const auto node = node_list[j];
          if (checked_nodes_id.count(node->id()))
            continue;
          // get vector of node's boundaries (in most cases it will only have one)
          std::vector<boundary_id_type> boundary_ids;
          boundary_info.boundary_ids(node, boundary_ids);
          std::vector<boundary_id_type> intersection =
              findBoundaryOverlap(_watertight_boundaries, boundary_ids);
 
          bool no_specified_ids = boundary_info.n_boundary_ids(node) == 0;
          bool specified_ids = !_watertight_boundaries.empty() && intersection.empty();
          std::string message =
              "Node " + std::to_string(node->id()) +
              " is on an external boundary of the mesh, but has not been assigned to ";
          if (no_specified_ids)
            message = message + "a nodeset";
          else if (specified_ids)
            message = message + "one of the specified nodesets";
          if ((no_specified_ids || specified_ids) && num_nodes_without_nodeset < _num_outputs)
          {
            checked_nodes_id.insert(node->id());
            num_nodes_without_nodeset++;
            _console << message << std::endl;
          }
        }
      }
    }
  }
  std::string message;
  message = "Number of external nodes that have not been assigned to a nodeset: " +
            std::to_string(num_nodes_without_nodeset);
  diagnosticsLog(message, _check_watertight_nodesets, num_nodes_without_nodeset);
}

Referenced by generate().

◆ checkWatertightSidesets()

void MeshDiagnosticsGenerator::checkWatertightSidesets ( const std::unique_ptr< MeshBase > & mesh ) const

private

Definition at line 340 of file MeshDiagnosticsGenerator.C.

{
  /*
  Algorithm Overview:
  1) Loop through all elements
  2) For each element loop through all its sides
  3) If it has no neighbors it's an external side
  4) If external check if it's part of a sideset
  */
  if (mesh->mesh_dimension() < 2)
    mooseError("The sideset check only works for 2D and 3D meshes");
  auto & boundary_info = mesh->get_boundary_info();
  boundary_info.build_side_list();
  const auto sideset_map = boundary_info.get_sideset_map();
  unsigned int num_faces_without_sideset = 0;
 
  for (const auto elem : mesh->active_element_ptr_range())
  {
    for (auto i : elem->side_index_range())
    {
      // Check if side is external
      if (elem->neighbor_ptr(i) == nullptr)
      {
        // If external get the boundary ids associated with this side
        std::vector<boundary_id_type> boundary_ids;
        auto side_range = sideset_map.equal_range(elem);
        for (const auto & itr : as_range(side_range))
          if (itr.second.first == i)
            boundary_ids.push_back(i);
        // get intersection of boundary_ids and _watertight_boundaries
        std::vector<boundary_id_type> intersections =
            findBoundaryOverlap(_watertight_boundaries, boundary_ids);
 
        bool no_specified_ids = boundary_ids.empty();
        bool specified_ids = !_watertight_boundaries.empty() && intersections.empty();
        std::string message;
        if (mesh->mesh_dimension() == 3)
          message = "Element " + std::to_string(elem->id()) +
                    " contains an external face which has not been assigned to ";
        else
          message = "Element " + std::to_string(elem->id()) +
                    " contains an external edge which has not been assigned to ";
        if (no_specified_ids)
          message = message + "a sideset";
        else if (specified_ids)
          message = message + "one of the specified sidesets";
        if ((no_specified_ids || specified_ids) && num_faces_without_sideset < _num_outputs)
        {
          _console << message << std::endl;
          num_faces_without_sideset++;
        }
      }
    }
  }
  std::string message;
  if (mesh->mesh_dimension() == 3)
    message = "Number of external element faces that have not been assigned to a sideset: " +
              std::to_string(num_faces_without_sideset);
  else
    message = "Number of external element edges that have not been assigned to a sideset: " +
              std::to_string(num_faces_without_sideset);
  diagnosticsLog(message, _check_watertight_sidesets, num_faces_without_sideset);
}

Referenced by generate().

◆ 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 295 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 311 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 289 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 301 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::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 504 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);
}

◆ diagnosticsLog()

void MeshDiagnosticsGenerator::diagnosticsLog	(	std::string	msg,
		const MooseEnum &	log_level,
		bool	problem_detected
	)		const

private

Utility routine to output the final diagnostics level in the desired mode.

Parameters

msg	the message to output
log_level	the log level to output the message at
problem_detected	if set to false, prevents erroring from the log, despite the log level problem_detected is used to avoid erroring when the log is requested but there are no issues so it should just say "0 problems" with an info message

Definition at line 1742 of file MeshDiagnosticsGenerator.C.

{
  mooseAssert(log_level != "NO_CHECK",
              "We should not be outputting logs if the check had been disabled");
  if (log_level == "INFO" || !problem_detected)
    mooseInfoRepeated(msg);
  else if (log_level == "WARNING")
    mooseWarning(msg);
  else if (log_level == "ERROR")
    mooseError(msg);
  else
    mooseError("Should not reach here");
}

Referenced by checkElementOverlap(), checkElementTypes(), checkElementVolumes(), checkLocalJacobians(), checkNonConformalMesh(), checkNonConformalMeshFromAdaptivity(), checkNonConformingFaces(), checkNonMatchingEdges(), checkNonPlanarSides(), checkPolygons(), checkSidesetsOrientation(), checkWatertightNodesets(), and checkWatertightSidesets().

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

49{ return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition MooseObject.h:71

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.

264{ return messagePrefix(); }

◆ findBoundaryOverlap()

std::vector< boundary_id_type > MeshDiagnosticsGenerator::findBoundaryOverlap	(	const std::vector< boundary_id_type > &	watertight_boundaries,
		std::vector< boundary_id_type > &	boundary_ids
	)		const

private

Helper function that finds the intersection between the given vectors.

Definition at line 469 of file MeshDiagnosticsGenerator.C.

{
  // Only the boundary_ids vector is sorted here. watertight_boundaries has to be sorted beforehand
  // Returns their intersection (elements that they share)
  std::sort(boundary_ids.begin(), boundary_ids.end());
  std::vector<boundary_id_type> boundary_intersection;
  std::set_intersection(watertight_boundaries.begin(),
                        watertight_boundaries.end(),
                        boundary_ids.begin(),
                        boundary_ids.end(),
                        std::back_inserter(boundary_intersection));
  return boundary_intersection;
}

Referenced by checkWatertightNodesets(), and checkWatertightSidesets().

◆ 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 > MeshDiagnosticsGenerator::generate ( )

overridevirtual

Generate / modify the mesh.

Implements MeshGenerator.

Definition at line 151 of file MeshDiagnosticsGenerator.C.

{
  std::unique_ptr<MeshBase> mesh = std::move(_input);
 
  // Most of the checks assume we have the full mesh
  if (!mesh->is_serial())
    mooseError("Only serialized meshes are supported");
 
  // We prepare for use at the beginning to facilitate diagnosis
  // This deliberately does not trust the mesh to know whether it's already prepared or not
  mesh->prepare_for_use();
 
  // check that specified boundary is valid, convert BoundaryNames to BoundaryIDs, and sort
  for (const auto & boundary_name : _watertight_boundary_names)
  {
    if (!MooseMeshUtils::hasBoundaryNameOrID(*mesh, boundary_name))
      mooseError("User specified boundary_to_check \'", boundary_name, "\' does not exist");
  }
  _watertight_boundaries = MooseMeshUtils::getBoundaryIDs(*mesh, _watertight_boundary_names, false);
  std::sort(_watertight_boundaries.begin(), _watertight_boundaries.end());
 
  if (_check_sidesets_orientation != "NO_CHECK")
    checkSidesetsOrientation(mesh);
 
  if (_check_watertight_sidesets != "NO_CHECK")
    checkWatertightSidesets(mesh);
 
  if (_check_watertight_nodesets != "NO_CHECK")
    checkWatertightNodesets(mesh);
 
  if (_check_element_volumes != "NO_CHECK")
    checkElementVolumes(mesh);
 
  if (_check_element_types != "NO_CHECK")
    checkElementTypes(mesh);
 
  if (_check_element_overlap != "NO_CHECK")
    checkElementOverlap(mesh);
 
  if (_check_non_planar_sides != "NO_CHECK")
    checkNonPlanarSides(mesh);
 
  if (_check_non_conformal_mesh != "NO_CHECK")
    checkNonConformalMesh(mesh);
 
  if (_check_nonconforming_faces != "NO_CHECK" ||
      (_check_non_conformal_mesh != "NO_CHECK" && !isParamSetByUser("examine_nonconforming_faces")))
    checkNonConformingFaces(mesh);
 
  if (_check_adaptivity_non_conformality != "NO_CHECK")
    checkNonConformalMeshFromAdaptivity(mesh);
 
  if (_check_local_jacobian != "NO_CHECK")
    checkLocalJacobians(mesh);
 
  if (_check_non_matching_edges != "NO_CHECK")
    checkNonMatchingEdges(mesh);
 
  if (_check_polygons != "NO_CHECK")
    checkPolygons(mesh);
 
  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 537 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 530 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 340 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 420 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.

147{ return _pars.getBase(); }

InputParameters::getBase

const std::string & getBase() const

Definition InputParameters.C:505

Referenced by 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 253 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 262 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 274 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 280 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().

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

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

◆ 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 216 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 231 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 225 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 244 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.

87{ return _app; }

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

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

◆ 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 524 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.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

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

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

204{ 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 518 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 512 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 491 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.

214{ return _data_only; }

MeshGenerator::_data_only

const bool _data_only

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

Definition MeshGenerator.h:530

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.

63{ return parameters().isKokkosObject(); }

InputParameters::isKokkosObject

bool isKokkosObject() const

Returns whether this InputParameters belongs to a Kokkos object Checks whether MooseBase::kokkos_obje...

Definition InputParameters.C:433

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.

184{ 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(), generate(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMVariable::MFEMVariable(), MortarConstraintBase::MortarConstraintBase(), MoveNodesByParsedExpressionModifier::moveNodes(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::run(), MooseApp::runInputFile(), MooseApp::runInputs(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

InputParameters::isParamValid

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

This method returns parameters that have been initialized in one fashion or another,...

Definition InputParameters.C:386

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

◆ 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(), checkNonConformalMeshFromAdaptivity(), PIDTransientControl::execute(), Executioner::Executioner(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), ManifoldSubdomainGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), MultiAppTransfer::mapBackWithoutCollapsing(), SolutionInvalidityOutput::output(), MooseBase::paramInfo(), MooseApp::setupOptions(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

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

◆ mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

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

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

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 308 of file MooseBase.h.

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

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

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

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

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

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

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

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

inherited

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

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

Definition at line 471 of file MooseBase.h.

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

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

◆ paramWarning() [1/2]

template<typename... Args>

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

inherited

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

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

Definition at line 464 of file MooseBase.h.

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

◆ paramWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

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

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

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

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

◆ 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 MeshDiagnosticsGenerator::validParams ( )

static

Definition at line 33 of file MeshDiagnosticsGenerator.C.

{
 
  InputParameters params = MeshGenerator::validParams();
 
  params.addRequiredParam<MeshGeneratorName>("input", "The mesh we want to diagnose");
  params.addClassDescription("Runs a series of diagnostics on the mesh to detect potential issues "
                             "such as unsupported features");
 
  // Options for the output level
  MooseEnum chk_option("NO_CHECK INFO WARNING ERROR", "NO_CHECK");
 
  params.addParam<MooseEnum>(
      "examine_sidesets_orientation",
      chk_option,
      "whether to check that sidesets are consistently oriented using neighbor subdomains. If a "
      "sideset is inconsistently oriented within a subdomain, this will not be detected");
  params.addParam<MooseEnum>(
      "check_for_watertight_sidesets",
      chk_option,
      "whether to check for external sides that are not assigned to any sidesets");
  params.addParam<MooseEnum>(
      "check_for_watertight_nodesets",
      chk_option,
      "whether to check for external nodes that are not assigned to any nodeset");
  params.addParam<std::vector<BoundaryName>>(
      "boundaries_to_check",
      {},
      "Names boundaries that should form a watertight envelope around the mesh. Defaults to all "
      "the boundaries combined.");
  params.addParam<MooseEnum>(
      "examine_element_volumes", chk_option, "whether to examine volume of the elements");
  params.addParam<Real>("minimum_element_volumes", 1e-16, "minimum size for element volume");
  params.addParam<Real>("maximum_element_volumes", 1e16, "Maximum size for element volume");
 
  params.addParam<MooseEnum>("examine_element_types",
                             chk_option,
                             "whether to look for multiple element types in the same sub-domain");
  params.addParam<MooseEnum>(
      "examine_element_overlap", chk_option, "whether to find overlapping elements");
  params.addParam<MooseEnum>(
      "examine_nonplanar_sides", chk_option, "whether to check element sides are planar");
  params.addParam<MooseEnum>("examine_non_conformality",
                             chk_option,
                             "whether to examine the conformality of elements in the mesh. "
                             "Automatically turns on 'examine_nonconforming_faces' as well,"
                             " unless specified otherwise.");
  params.addParam<MooseEnum>(
      "examine_nonconforming_faces",
      chk_option,
      "whether to check for element faces that border another element but do not match a "
      "neighbor face (for example a quad face abutting two triangle faces). Unlike "
      "'examine_non_conformality', this does not require a hanging node.");
  params.addParam<MooseEnum>("examine_non_matching_edges",
                             chk_option,
                             "Whether to check if there are any intersecting edges");
  params.addParam<Real>("intersection_tol", TOLERANCE, "tolerence for intersecting edges");
  params.addParam<Real>("nonconformal_tol", TOLERANCE, "tolerance for element non-conformality");
  params.addParam<MooseEnum>(
      "search_for_adaptivity_nonconformality",
      chk_option,
      "whether to check for non-conformality arising from adaptive mesh refinement");
  params.addParam<MooseEnum>("check_local_jacobian",
                             chk_option,
                             "whether to check the local Jacobian for bad (non-positive) values");
  params.addParam<MooseEnum>(
      "check_polygons", chk_option, "Whether to check that all C0 polygons are convex");
  params.addParam<unsigned int>(
      "log_length_limit",
      10,
      "How many problematic element/nodes/sides/etc are explicitly reported on by each check");
  return params;
}

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

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

◆ _check_adaptivity_non_conformality

const MooseEnum MeshDiagnosticsGenerator::_check_adaptivity_non_conformality

private

whether to check for the adaptivity of non-conformal meshes

Definition at line 106 of file MeshDiagnosticsGenerator.h.

Referenced by checkNonConformalMeshFromAdaptivity(), generate(), and MeshDiagnosticsGenerator().

◆ _check_element_overlap

const MooseEnum MeshDiagnosticsGenerator::_check_element_overlap

private

whether to check for intersecting elements

Definition at line 92 of file MeshDiagnosticsGenerator.h.

Referenced by checkElementOverlap(), generate(), and MeshDiagnosticsGenerator().

◆ _check_element_types

const MooseEnum MeshDiagnosticsGenerator::_check_element_types

private

whether to check different element types in the same sub-domain

Definition at line 90 of file MeshDiagnosticsGenerator.h.

Referenced by checkElementTypes(), generate(), and MeshDiagnosticsGenerator().

◆ _check_element_volumes

const MooseEnum MeshDiagnosticsGenerator::_check_element_volumes

private

whether to check element volumes

Definition at line 84 of file MeshDiagnosticsGenerator.h.

Referenced by checkElementVolumes(), generate(), and MeshDiagnosticsGenerator().

◆ _check_local_jacobian

const MooseEnum MeshDiagnosticsGenerator::_check_local_jacobian

private

whether to check for negative jacobians in the domain

Definition at line 108 of file MeshDiagnosticsGenerator.h.

Referenced by checkLocalJacobians(), generate(), and MeshDiagnosticsGenerator().

◆ _check_non_conformal_mesh

const MooseEnum MeshDiagnosticsGenerator::_check_non_conformal_mesh

private

whether to check for non-conformal meshes

Definition at line 96 of file MeshDiagnosticsGenerator.h.

Referenced by checkNonConformalMesh(), checkNonConformingFaces(), generate(), and MeshDiagnosticsGenerator().

◆ _check_non_matching_edges

const MooseEnum MeshDiagnosticsGenerator::_check_non_matching_edges

private

Definition at line 102 of file MeshDiagnosticsGenerator.h.

Referenced by checkNonMatchingEdges(), generate(), and MeshDiagnosticsGenerator().

◆ _check_non_planar_sides

const MooseEnum MeshDiagnosticsGenerator::_check_non_planar_sides

private

whether to check for elements in different planes (non_planar)

Definition at line 94 of file MeshDiagnosticsGenerator.h.

Referenced by checkNonPlanarSides(), generate(), and MeshDiagnosticsGenerator().

◆ _check_nonconforming_faces

const MooseEnum MeshDiagnosticsGenerator::_check_nonconforming_faces

private

whether to check for element faces that border material but match no neighbor face

Definition at line 100 of file MeshDiagnosticsGenerator.h.

Referenced by checkNonConformingFaces(), generate(), and MeshDiagnosticsGenerator().

◆ _check_polygons

const MooseEnum MeshDiagnosticsGenerator::_check_polygons

private

whether to check for non-convex polygons in the mesh

Definition at line 110 of file MeshDiagnosticsGenerator.h.

Referenced by checkPolygons(), generate(), and MeshDiagnosticsGenerator().

◆ _check_sidesets_orientation

const MooseEnum MeshDiagnosticsGenerator::_check_sidesets_orientation

private

whether to check that sidesets are consistently oriented using neighbor subdomains

Definition at line 74 of file MeshDiagnosticsGenerator.h.

Referenced by checkSidesetsOrientation(), generate(), and MeshDiagnosticsGenerator().

◆ _check_watertight_nodesets

const MooseEnum MeshDiagnosticsGenerator::_check_watertight_nodesets

private

whether to check that each external node is assigned to a nodeset

Definition at line 78 of file MeshDiagnosticsGenerator.h.

Referenced by checkWatertightNodesets(), generate(), and MeshDiagnosticsGenerator().

◆ _check_watertight_sidesets

const MooseEnum MeshDiagnosticsGenerator::_check_watertight_sidesets

private

whether to check that each external side is assigned to a sideset

Definition at line 76 of file MeshDiagnosticsGenerator.h.

Referenced by checkWatertightSidesets(), generate(), and MeshDiagnosticsGenerator().

◆ _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(), checkElementOverlap(), checkElementTypes(), checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), checkLocalJacobians(), checkNonConformalMesh(), checkNonConformalMeshFromAdaptivity(), checkNonConformingFaces(), checkNonMatchingEdges(), checkNonPlanarSides(), checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), checkSidesetsOrientation(), checkWatertightNodesets(), checkWatertightSidesets(), CoarsenSurfaceMeshAlongSidesetGenerator::coarsenAlongSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

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

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

◆ _input

std::unique_ptr<MeshBase>& MeshDiagnosticsGenerator::_input

protected

the input mesh to be diagnosed

Definition at line 29 of file MeshDiagnosticsGenerator.h.

Referenced by generate().

◆ _max_volume

const Real MeshDiagnosticsGenerator::_max_volume

private

maximum size for element volume to be counted as a big element

Definition at line 88 of file MeshDiagnosticsGenerator.h.

Referenced by checkElementVolumes().

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

◆ _min_volume

const Real MeshDiagnosticsGenerator::_min_volume

private

minimum size for element volume to be counted as a tiny element

Definition at line 86 of file MeshDiagnosticsGenerator.h.

Referenced by checkElementVolumes().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _non_conformality_tol

const Real MeshDiagnosticsGenerator::_non_conformality_tol

private

tolerance for detecting when meshes are not conformal

Definition at line 98 of file MeshDiagnosticsGenerator.h.

Referenced by checkElementOverlap(), checkNonConformalMesh(), and checkNonConformalMeshFromAdaptivity().

◆ _non_matching_edge_tol

const Real MeshDiagnosticsGenerator::_non_matching_edge_tol

private

Definition at line 104 of file MeshDiagnosticsGenerator.h.

Referenced by checkNonMatchingEdges().

◆ _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_outputs

const unsigned int MeshDiagnosticsGenerator::_num_outputs

private

number of logs to output at most for each check

Definition at line 112 of file MeshDiagnosticsGenerator.h.

Referenced by checkElementOverlap(), checkElementVolumes(), checkLocalJacobians(), checkNonConformalMesh(), checkNonConformalMeshFromAdaptivity(), checkNonConformingFaces(), checkNonMatchingEdges(), checkNonPlanarSides(), checkPolygons(), checkSidesetsOrientation(), checkWatertightNodesets(), and checkWatertightSidesets().

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

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

◆ _watertight_boundaries

std::vector<BoundaryID> MeshDiagnosticsGenerator::_watertight_boundaries

private

IDs of boundaries to be checked in watertight checks.

Definition at line 82 of file MeshDiagnosticsGenerator.h.

Referenced by checkWatertightNodesets(), checkWatertightSidesets(), and generate().

◆ _watertight_boundary_names

std::vector<BoundaryName> MeshDiagnosticsGenerator::_watertight_boundary_names

private

Names of boundaries to be checked in watertight checks.

Definition at line 80 of file MeshDiagnosticsGenerator.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/MeshDiagnosticsGenerator.h
src/meshgenerators/MeshDiagnosticsGenerator.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ MeshDiagnosticsGenerator()

Member Function Documentation

◆ addChildMeshGenerator()

◆ addMeshSubgenerator() [1/2]

◆ addMeshSubgenerator() [2/2]

◆ addParentMeshGenerator()

◆ buildDistributedMesh()

◆ buildMeshBaseObject()

◆ buildReplicatedMesh()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ checkElementOverlap()

◆ checkElementTypes()

◆ checkElementVolumes()

◆ checkGetMesh()

◆ checkLocalJacobians()

◆ checkNonConformalMesh()

◆ checkNonConformalMeshFromAdaptivity()

◆ checkNonConformingFaces()

◆ checkNonMatchingEdges()

◆ checkNonPlanarSides()

◆ checkPolygons()

◆ checkSidesetsOrientation()

◆ checkWatertightNodesets()

◆ checkWatertightSidesets()

◆ connectControllableParams()

◆ copyMeshProperty() [1/2]

◆ copyMeshProperty() [2/2]

◆ declareMeshesForSub()

◆ declareMeshesForSubByName()

◆ declareMeshForSub()

◆ declareMeshForSubByName()

◆ declareMeshProperty() [1/2]

◆ declareMeshProperty() [2/2]

◆ declareNullMeshName()

◆ diagnosticsLog()

◆ enabled()

◆ errorPrefix()

◆ findBoundaryOverlap()

◆ flagInvalidSolutionInternal()

◆ generate()

◆ generateCSG()

◆ generateData()

◆ generateInternal()

◆ generateInternalCSG()

◆ getBase()

◆ getCheckedPointerParam()

◆ getChildMeshGenerators()

◆ getCSGBase()

◆ getCSGBaseByName()

◆ getCSGBases()

◆ getCSGBasesByName()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getHitNode() [1/2]

◆ getHitNode() [2/2]

◆ getMesh()

◆ getMeshByName()

◆ getMeshes()

◆ getMeshesByName()

◆ getMeshGeneratorNameFromParam()

◆ getMeshGeneratorNamesFromParam()

◆ getMeshProperty() [1/2]

◆ getMeshProperty() [2/2]