#include <SideSetsGeneratorBase.h>

Inheritance diagram for SideSetsGeneratorBase:

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

Public Member Functions
	SideSetsGeneratorBase (const InputParameters &parameters)

virtual	~SideSetsGeneratorBase ()

bool	hasGenerateData () const

virtual std::unique_ptr< MeshBase >	generate ()=0
	Generate / modify the mesh. More...

std::unique_ptr< MeshBase >	generateInternal ()
	Internal generation method - this is what is actually called within MooseApp to execute the MeshGenerator. More...

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

void	addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)
	Adds the MeshGenerator `mg` as a child. More...

const std::set< const MeshGenerator *, Comparator > &	getParentMeshGenerators () const
	Gets the MeshGenerators that are parents to this MeshGenerator. More...

const std::set< const MeshGenerator *, Comparator > &	getChildMeshGenerators () const
	Gets the MeshGenerators that are children to this MeshGenerator. More...

const std::set< const MeshGenerator *, Comparator > &	getSubMeshGenerators () const
	Gets the MeshGenerators that are children to this MeshGenerator. More...

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

bool	hasOutput () const

const std::string &	getSavedMeshName () const
	Return the name of the saved mesh. More...

bool	isDataOnly () const

virtual bool	enabled () const
	Return the enabled status of the object. More...

std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group. More...

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

MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with. More...

const std::string &	type () const
	Get the type of this class. More...

virtual const std::string &	name () const
	Get the name of the class. More...

std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling. More...

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

void	callMooseError (std::string msg, const bool with_prefix) const
	Calls moose error with the message `msg`. More...

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
	The unique parameter name of a valid parameter of this object for accessing parameter controls. More...

const InputParameters &	parameters () const
	Get the parameters of the object. More...

MooseObjectName	uniqueName () const
	The unique name for accessing input parameters of this object in the InputParameterWarehouse. More...

template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object. More...

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object. More...

template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object. More...

template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object. More...

template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...

bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid. More...

bool	isParamSetByUser (const std::string &nm) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default. More...

template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action. More...

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type. More...

template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError(). More...

template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
	Emits a documented error with object name and type. More...

template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type. More...

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning(). More...

template<typename... Args>
void	mooseDeprecated (Args &&... args) const

template<typename... Args>
void	mooseInfo (Args &&... args) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

std::string	getDataFileName (const std::string &param) const
	Deprecated method. More...

std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method. More...

std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path. More...

Static Public Member Functions
static InputParameters	validParams ()

static void	setHasGenerateData (InputParameters &params)
	Sets that a mesh generator has a generateData() implementation. More...

static bool	hasGenerateData (const InputParameters &params)

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

Static Public Attributes
static const std::string	data_only_param = "_data_only"
	The name of the private parameter for setting data only. More...

static constexpr auto	SYSTEM = "MeshMetaData"
	The system name used when initializing the Restartable interface. More...

static constexpr auto	NAME = "<empty>"
	The data name used when initializing the Restartable interface for non-MeshGenerator objects. More...

Protected Member Functions
void	setup (MeshBase &mesh)
	This method is used to construct the FE object so we can compute normals of faces. More...

void	finalize ()
	This method finalizes the object, setting names back in the boundary_info object and releasing memory. More...

void	flood (const Elem *elem, const Point &normal, const boundary_id_type &side_id, MeshBase &mesh)
	This method implements a recursive flood routine to paint a sideset of mesh to neighboring faces given a starting element and normal. More...

bool	normalsWithinTol (const Point &normal_1, const Point &normal_2, const Real &tol) const
	Determines whether two normal vectors are within normal_tol of each other. More...

bool	elementSubdomainIdInList (const Elem *const elem, const std::vector< subdomain_id_type > &subdomain_id_list) const
	Determines whether the given element's subdomain id is in the given subdomain_id_list. More...

bool	elementSideInIncludedBoundaries (const Elem *const elem, const unsigned int side, const MeshBase &mesh) const
	Determines whether the given side of an element belongs to any boundaries in the included_boundaries parameter. More...

bool	elementSideInExcludedBoundaries (const Elem *const elem, const unsigned int side, const MeshBase &mesh) const
	Determines whether the given side of an element belongs to any boundaries in the excluded_boundaries parameter. More...

bool	elemSideSatisfiesRequirements (const Elem *const elem, const unsigned int side, const MeshBase &mesh, const Point &normal, const Point &face_normal)
	Determines whether the given element's side satisfies the following parameters: include_only_external_sides, included_boundaries, included_neighbor_subdomains and normal. More...

virtual void	generateData ()
	Generate the mesh data. More...

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

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

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

std::vector< std::unique_ptr< MeshBase > * >	getMeshes (const std::string &param_name)
	Like getMesh(), but for multiple generators. More...

std::unique_ptr< MeshBase > &	getMeshByName (const MeshGeneratorName &mesh_generator_name)
	Like `getMesh()`, but takes the name of another MeshGenerator directly. More...

std::vector< std::unique_ptr< MeshBase > * >	getMeshesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)
	Like getMeshByName(), but for multiple generators. More...

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

void	declareMeshesForSub (const std::string &param_name)
	Like declareMeshForSub(), but for multiple generators. More...

void	declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)
	Like declareMeshForSub(), but takes the name of another MeshGenerator directly. More...

void	declareMeshesForSubByName (const std::vector< MeshGeneratorName > &mesh_generator_names)
	Like declareMeshForSubByName(), but for multiple generators. More...

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

std::unique_ptr< ReplicatedMesh >	buildReplicatedMesh (unsigned int dim=libMesh::invalid_uint)
	Build a replicated mesh. More...

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

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

void	addMeshSubgenerator (const std::string &type, const std::string &name, InputParameters params)
	Construct a "subgenerator", as above. More...

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

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

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

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

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 mesh to add the sidesets to More...

std::vector< BoundaryName >	_boundary_names
	The list of new boundary names. More...

const bool	_fixed_normal
	Whether to fix the normal or allow it to vary to "paint" around curves. More...

const bool	_replace
	Whether or not to remove the old sidesets (all of them, if any) when adding sidesets. More...

const bool	_check_included_boundaries
	whether to check boundary ids against the included boundary list when adding sides or not More...

const bool	_check_excluded_boundaries
	whether to check boundary ids against the excluded boundary list when adding sides or not More...

const bool	_check_subdomains
	whether to check subdomain ids of the element in the (element, side, boundary id) tuple when adding sides More...

const bool	_check_neighbor_subdomains
	whether to check the subdomain ids of the neighbor element (on the other 'side' of the side) when adding sides More...

std::vector< boundary_id_type >	_included_boundary_ids
	A list of boundary ids that the side has to be part of, extracted from the included_boundaries parameter. More...

std::vector< boundary_id_type >	_excluded_boundary_ids
	A list of boundary ids that the side must not be a part of, extracted from the excluded_boundaries parameter. More...

std::vector< subdomain_id_type >	_included_subdomain_ids
	A list of included subdomain ids that the side has to be part of, extracted from the included_subdomains parameter. More...

std::vector< subdomain_id_type >	_included_neighbor_subdomain_ids
	A list of included neighbor subdomain ids that the sides' neighbor element must be a part of. More...

const bool	_include_only_external_sides
	Whether to only include external side when considering sides to add to the sideset. More...

bool	_using_normal
	true if only faces close to "normal" will be added More...

Point	_normal
	if specified, then faces are only added if their normal is close to this More...

const Real	_normal_tol
	if normal is specified, then faces are only added if face_normal.normal_hat <= 1 - normal_tol where normal_hat = _normal/\|_normal\| More...

std::unique_ptr< libMesh::FEBase >	_fe_face

std::unique_ptr< libMesh::QGauss >	_qface

std::map< boundary_id_type, std::set< const Elem * > >	_visited

MooseMesh *const	_mesh
	Pointer to the owning mesh. More...

const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects. More...

MooseApp &	_app
	The MOOSE application this is associated with. More...

const std::string	_type
	The type of this class. More...

const std::string	_name
	The name of this class. More...

const InputParameters &	_pars
	Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...

Factory &	_factory
	The Factory associated with the MooseApp. More...

ActionFactory &	_action_factory
	Builds Actions. More...

const Parallel::Communicator &	_communicator

Detailed Description

Definition at line 25 of file SideSetsGeneratorBase.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

◆ SideSetsGeneratorBase()

SideSetsGeneratorBase::SideSetsGeneratorBase ( const InputParameters & parameters )

Definition at line 85 of file SideSetsGeneratorBase.C.

   : MeshGenerator(parameters),
     _input(getMesh("input")),
     _boundary_names(std::vector<BoundaryName>()),
     _fixed_normal(getParam<bool>("fixed_normal")),
     _replace(getParam<bool>("replace")),
     _check_included_boundaries(isParamValid("included_boundaries")),
     _check_excluded_boundaries(isParamValid("excluded_boundaries")),
     _check_subdomains(isParamValid("included_subdomains")),
     _check_neighbor_subdomains(isParamValid("included_neighbors")),
     _included_boundary_ids(std::vector<boundary_id_type>()),
     _excluded_boundary_ids(std::vector<boundary_id_type>()),
     _included_subdomain_ids(std::vector<subdomain_id_type>()),
     _included_neighbor_subdomain_ids(std::vector<subdomain_id_type>()),
     _include_only_external_sides(getParam<bool>("include_only_external_sides")),
     _using_normal(isParamSetByUser("normal")),
     _normal(_using_normal ? Point(getParam<Point>("normal") / getParam<Point>("normal").norm())
                           : getParam<Point>("normal")),
     _normal_tol(getParam<Real>("normal_tol"))
 {
   if (isParamValid("new_boundary"))
     _boundary_names = getParam<std::vector<BoundaryName>>("new_boundary");
 }

◆ ~SideSetsGeneratorBase()

SideSetsGeneratorBase::~SideSetsGeneratorBase ( )

virtual

Definition at line 109 of file SideSetsGeneratorBase.C.

109 {}

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

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

◆ addMeshSubgenerator() [1/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 513 of file MeshGenerator.h.

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

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

◆ addMeshSubgenerator() [2/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 334 of file MeshGenerator.C.

 {
   if (!_app.constructingMeshGenerators())
     mooseError("Can only call addMeshSubgenerator() during MeshGenerator construction");
 
   // In case the user forgot it
   params.set<MooseApp *>("_moose_app") = &_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));
 }

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

Referenced by DistributedRectilinearMeshGenerator::generate().

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

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

Referenced by BlockToMeshConverterGenerator::generate(), ElementGenerator::generate(), FileMeshGenerator::generate(), SphereMeshGenerator::generate(), PolyLineMeshGenerator::generate(), ExamplePatchMeshGenerator::generate(), AnnularMeshGenerator::generate(), CartesianMeshGenerator::generate(), GeneratedMeshGenerator::generate(), AdvancedExtruderGenerator::generate(), MeshExtruderGenerator::generate(), and TransfiniteMeshGenerator::generate().

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

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

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

◆ callMooseError()

void MooseBase::callMooseError	(	std::string	msg,
		const bool	with_prefix
	)		const

inherited

Calls moose error with the message msg.

Will prefix the message with the subapp name if one exists.

If with_prefix, then add the prefix from errorPrefix() to the error.

Definition at line 33 of file MooseBase.C.

Referenced by InputParameters::callMooseErrorHelper(), MooseBaseErrorInterface::mooseDocumentedError(), MooseBaseErrorInterface::mooseError(), MooseBaseErrorInterface::mooseErrorNonPrefixed(), and MooseBaseParameterInterface::paramError().

 {
   _app.getOutputWarehouse().mooseConsole();
   const std::string prefix = _app.isUltimateMaster() ? "" : _app.name();
   if (with_prefix)
     msg = errorPrefix("error") + msg;
   moose::internal::mooseErrorRaw(msg, prefix);
 }

◆ connectControllableParams()

void MooseBaseParameterInterface::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 33 of file MooseBaseParameterInterface.C.

 {
   MooseObjectParameterName primary_name(uniqueName(), parameter);
   const auto base_type = _factory.getValidParams(object_type).get<std::string>("_moose_base");
   MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
   _moose_base.getMooseApp().getInputParameterWarehouse().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, _moose_base.name(), parameter);
       _moose_base.getMooseApp().getInputParameterWarehouse().addControllableParameterConnection(
           tagged_name, secondary_name, /*error_on_empty=*/false);
     }
   }
 }

◆ copyMeshProperty() [1/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 233 of file MeshGenerator.h.

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

◆ copyMeshProperty() [2/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 246 of file MeshGenerator.h.

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

◆ declareMeshesForSub()

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

protectedinherited

Like declareMeshForSub(), but for multiple generators.

Definition at line 215 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 231 of file MeshGenerator.C.

Referenced by MeshGenerator::declareMeshesForSub().

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

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

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

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

◆ declareMeshForSubByName()

void MeshGenerator::declareMeshForSubByName ( const MeshGeneratorName & mesh_generator_name )

protectedinherited

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

Definition at line 221 of file MeshGenerator.C.

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

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

◆ 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 455 of file MeshGenerator.h.

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

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

◆ declareMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 206 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 398 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);
 }

◆ elementSideInExcludedBoundaries()

bool SideSetsGeneratorBase::elementSideInExcludedBoundaries	(	const Elem *const	elem,
		const unsigned int	side,
		const MeshBase &	mesh
	)		const

protected

Determines whether the given side of an element belongs to any boundaries in the excluded_boundaries parameter.

Definition at line 301 of file SideSetsGeneratorBase.C.

Referenced by elemSideSatisfiesRequirements().

 {
   for (const auto bid : _excluded_boundary_ids)
     if (mesh.get_boundary_info().has_boundary_id(elem, side, bid))
       return true;
   return false;
 }

◆ elementSideInIncludedBoundaries()

bool SideSetsGeneratorBase::elementSideInIncludedBoundaries	(	const Elem *const	elem,
		const unsigned int	side,
		const MeshBase &	mesh
	)		const

protected

Determines whether the given side of an element belongs to any boundaries in the included_boundaries parameter.

Definition at line 290 of file SideSetsGeneratorBase.C.

Referenced by elemSideSatisfiesRequirements().

 {
   for (const auto & bid : _included_boundary_ids)
     if (mesh.get_boundary_info().has_boundary_id(elem, side, bid))
       return true;
   return false;
 }

◆ elementSubdomainIdInList()

bool SideSetsGeneratorBase::elementSubdomainIdInList	(	const Elem *const	elem,
		const std::vector< subdomain_id_type > &	subdomain_id_list
	)		const

protected

Determines whether the given element's subdomain id is in the given subdomain_id_list.

Definition at line 281 of file SideSetsGeneratorBase.C.

Referenced by elemSideSatisfiesRequirements(), flood(), SideSetsBetweenSubdomainsGenerator::generate(), ParsedGenerateSideset::generate(), and SideSetsAroundSubdomainGenerator::generate().

 {
   subdomain_id_type curr_subdomain = elem->subdomain_id();
   return std::find(subdomain_id_list.begin(), subdomain_id_list.end(), curr_subdomain) !=
          subdomain_id_list.end();
 }

◆ elemSideSatisfiesRequirements()

bool SideSetsGeneratorBase::elemSideSatisfiesRequirements	(	const Elem *const	elem,
		const unsigned int	side,
		const MeshBase &	mesh,
		const Point &	normal,
		const Point &	face_normal
	)

protected

Determines whether the given element's side satisfies the following parameters: include_only_external_sides, included_boundaries, included_neighbor_subdomains and normal.

Definition at line 312 of file SideSetsGeneratorBase.C.

Referenced by flood(), SideSetsBetweenSubdomainsGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), ParsedGenerateSideset::generate(), and SideSetsAroundSubdomainGenerator::generate().

 {
   // Skip if side has neighbor and we only want external sides
   if ((elem->neighbor_ptr(side) && _include_only_external_sides))
     return false;
 
   // Skip if side is not part of included boundaries
   if (_check_included_boundaries && !elementSideInIncludedBoundaries(elem, side, mesh))
     return false;
   // Skip if side is part of excluded boundaries
   if (_check_excluded_boundaries && elementSideInExcludedBoundaries(elem, side, mesh))
     return false;
 
   // Skip if element does not have neighbor in specified subdomains
   if (_check_neighbor_subdomains)
   {
     const Elem * const neighbor = elem->neighbor_ptr(side);
     // if the neighbor does not exist, then skip this face; we only add sidesets
     // between existing elems if _check_neighbor_subdomains is true
     if (!(neighbor && elementSubdomainIdInList(neighbor, _included_neighbor_subdomain_ids)))
       return false;
   }
 
   if (_using_normal && !normalsWithinTol(desired_normal, face_normal, _normal_tol))
     return false;
 
   return true;
 }

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 40 of file MooseObject.h.

Referenced by EigenKernel::enabled().

40 { return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition: MooseObject.h:51

◆ errorPrefix()

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

inherited

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

Definition at line 43 of file MooseBase.C.

Referenced by MooseBase::callMooseError(), MooseBaseErrorInterface::mooseDeprecated(), MooseBaseErrorInterface::mooseInfo(), MooseBaseErrorInterface::mooseWarning(), and MooseBaseParameterInterface::paramErrorMsg().

 {
   std::stringstream oss;
   if (const auto node = _params.getHitNode())
     if (!node->isRoot())
       oss << node->fileLocation() << ":\n";
   oss << "The following " << error_type << " occurred in the ";
   if (const auto base_ptr = _params.getBase())
     oss << *base_ptr;
   else
     oss << "object";
   oss << " '" << name() << "' of type " << type() << ".\n\n";
   return oss.str();
 }

◆ finalize()

void SideSetsGeneratorBase::finalize ( )

protected

This method finalizes the object, setting names back in the boundary_info object and releasing memory.

Definition at line 222 of file SideSetsGeneratorBase.C.

Referenced by SideSetsFromNormalsGenerator::generate(), SideSetsFromPointsGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), and ParsedGenerateSideset::generate().

 {
   _qface.reset();
   _fe_face.reset();
 }

◆ flood()

void SideSetsGeneratorBase::flood	(	const Elem *	elem,
		const Point &	normal,
		const boundary_id_type &	side_id,
		MeshBase &	mesh
	)

protected

This method implements a recursive flood routine to paint a sideset of mesh to neighboring faces given a starting element and normal.

Definition at line 229 of file SideSetsGeneratorBase.C.

Referenced by SideSetsFromNormalsGenerator::generate(), SideSetsFromPointsGenerator::generate(), and AllSideSetsByNormalsGenerator::generate().

 {
   if (elem == nullptr || elem == remote_elem ||
       (_visited[side_id].find(elem) != _visited[side_id].end()))
     return;
 
   // Skip if element is not in specified subdomains
   if (_check_subdomains && !elementSubdomainIdInList(elem, _included_subdomain_ids))
     return;
 
   _visited[side_id].insert(elem);
 
   // Request to compute normal vectors
   const std::vector<Point> & face_normals = _fe_face->get_normals();
 
   for (const auto side : make_range(elem->n_sides()))
   {
 
     _fe_face->reinit(elem, side);
     // We'll just use the normal of the first qp
     const Point face_normal = face_normals[0];
 
     if (!elemSideSatisfiesRequirements(elem, side, mesh, normal, face_normal))
       continue;
 
     if (_replace)
       mesh.get_boundary_info().remove_side(elem, side);
 
     mesh.get_boundary_info().add_side(elem, side, side_id);
     for (const auto neighbor : make_range(elem->n_sides()))
     {
       // Flood to the neighboring elements using the current matching side normal from this
       // element.
       // This will allow us to tolerate small changes in the normals so we can "paint" around a
       // curve.
       flood(elem->neighbor_ptr(neighbor), _fixed_normal ? normal : face_normal, side_id, mesh);
     }
   }
 }

◆ generate()

virtual std::unique_ptr<MeshBase> MeshGenerator::generate ( )

pure virtualinherited

Generate / modify the mesh.

Implemented in BoundingBoxNodeSetGenerator, DistributedRectilinearMeshGenerator, PatternedMeshGenerator, SubdomainBoundingBoxGenerator, ParsedGenerateSideset, SideSetsAroundSubdomainGenerator, TransfiniteMeshGenerator, ElementDeletionGeneratorBase, CutMeshByLevelSetGeneratorBase, OrientedSubdomainBoundingBoxGenerator, ParsedNodeTransformGenerator, RinglebMeshGenerator, SpiralAnnularMeshGenerator, XYDelaunayGenerator, XYMeshLineCutter, AdvancedExtruderGenerator, AllSideSetsByNormalsGenerator, BreakMeshByElementGenerator, CircularBoundaryCorrectionGenerator, CombinerGenerator, ElementsToSimplicesConverter, ImageMeshGenerator, MeshCollectionGenerator, MeshExtruderGenerator, ParsedCurveGenerator, ParsedExtraElementIDGenerator, ParsedGenerateNodeset, SideSetsFromBoundingBoxGenerator, StackGenerator, StitchBoundaryMeshGenerator, StitchedMeshGenerator, XYZDelaunayGenerator, AnnularMeshGenerator, BlockDeletionGenerator, BreakMeshByBlockGenerator, CartesianMeshGenerator, CoarsenBlockGenerator, ConcentricCircleMeshGenerator, ExamplePatchMeshGenerator, FlipSidesetGenerator, GeneratedMeshGenerator, ImageSubdomainGenerator, MeshDiagnosticsGenerator, MeshRepairGenerator, NodeSetsFromSideSetsGenerator, ParsedSubdomainGeneratorBase, PolyLineMeshGenerator, RefineBlockGenerator, RefineSidesetGenerator, SideSetExtruderGenerator, SideSetsBetweenSubdomainsGenerator, SideSetsFromNodeSetsGenerator, SideSetsFromPointsGenerator, TransformGenerator, AddMetaDataGenerator, BlockToMeshConverterGenerator, BoundaryLayerSubdomainGenerator, BreakBoundaryOnSubdomainGenerator, ElementGenerator, ElementsToTetrahedronsConverter, ExtraNodesetGenerator, FileMeshGenerator, FillBetweenCurvesGenerator, FillBetweenPointVectorsGenerator, FillBetweenSidesetsGenerator, LowerDBlockFromSidesetGenerator, MoveNodeGenerator, PlaneIDMeshGenerator, RenameBlockGenerator, RenameBoundaryGenerator, SideSetsFromNormalsGenerator, SmoothMeshGenerator, SphereMeshGenerator, SubdomainIDGenerator, SubdomainPerElementGenerator, SymmetryTransformGenerator, TiledMeshGenerator, UniqueExtraIDMeshGenerator, BoundaryDeletionGenerator, ElementOrderConversionGenerator, and OverlayMeshGenerator.

Referenced by MeshGenerator::generateInternal().

◆ generateData()

void MeshGenerator::generateData ( )

protectedvirtualinherited

Generate the mesh data.

Reimplemented in AddMetaDataGenerator.

Definition at line 424 of file MeshGenerator.C.

Referenced by MeshGenerator::generateInternal().

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

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

◆ getCheckedPointerParam()

template<typename T >

T MooseBaseParameterInterface::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 286 of file MooseBaseParameterInterface.h.

 {
   return parameters().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 129 of file MeshGenerator.h.

Referenced by MeshGenerator::isChildMeshGenerator().

   {
     return _child_mesh_generators;
   }

◆ getDataFileName()

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

inherited

Deprecated method.

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

Definition at line 21 of file DataFileInterface.C.

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

◆ getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

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

◆ getDataFilePath()

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

inherited

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

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

Definition at line 40 of file DataFileInterface.C.

Referenced by DataFileInterface::getDataFileNameByName().

 {
   // This should only ever be used with relative paths. There is no point to
   // use this search path with an absolute path.
   if (std::filesystem::path(relative_path).is_absolute())
     _parent.mooseWarning("While using getDataFilePath(\"",
                          relative_path,
                          "\"): This API should not be used for absolute paths.");
 
   // Throw on error so that if getPath() fails, we can throw an error
   // with the context of _parent.mooseError()
   const auto throw_on_error_before = Moose::_throw_on_error;
   Moose::_throw_on_error = true;
   std::optional<std::string> error;
 
   // This will search the data paths for this relative path
   Moose::DataFileUtils::Path found_path;
   try
   {
     found_path = Moose::DataFileUtils::getPath(relative_path);
   }
   catch (std::exception & e)
   {
     error = e.what();
   }
 
   Moose::_throw_on_error = throw_on_error_before;
   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;
 }

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

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

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

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

Referenced by MeshGenerator::getMeshes().

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

◆ getMeshProperty() [1/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 134 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();
 }

◆ getMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 56 of file MeshMetaDataInterface.h.

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

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

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

45 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:84

◆ getParam() [1/2]

template<typename T >

const T & MooseBaseParameterInterface::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 215 of file MooseBaseParameterInterface.h.

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

◆ getParam() [2/2]

template<typename T1 , typename T2 >

std::vector< std::pair< T1, T2 > > MooseBaseParameterInterface::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 279 of file MooseBaseParameterInterface.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 122 of file MeshGenerator.h.

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

   {
     return _parent_mesh_generators;
   }

◆ getRenamedParam()

template<typename T >

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

 {
   // this enables having a default on the new parameter but bypassing it with the old one
   // Most important: accept new parameter
   if (isParamSetByUser(new_name) && !isParamValid(old_name))
     return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
   // Second most: accept old parameter
   else if (isParamValid(old_name) && !isParamSetByUser(new_name))
     return InputParameters::getParamHelper(old_name, _pars, static_cast<T *>(0), &_moose_base);
   // Third most: accept default for new parameter
   else if (isParamValid(new_name) && !isParamValid(old_name))
     return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
   // Refuse: no default, no value passed
   else if (!isParamValid(old_name) && !isParamValid(new_name))
     mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
                "' is being retrieved without being set.\n"
                "Did you misspell it?");
   // Refuse: both old and new parameters set by user
   else
     mooseError(_pars.blockFullpath() + ": 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 80 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 88 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 418 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 68 of file MooseObject.C.

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

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

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 81 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 136 of file MeshGenerator.h.

   {
     return _sub_mesh_generators;
   }

◆ hasGenerateData() [1/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 86 of file MeshGenerator.C.

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

◆ hasGenerateData() [2/2]

bool MeshGenerator::hasGenerateData ( ) const

inlineinherited

Returns: Whether or not this generator has a generateData() implementation

Definition at line 185 of file MeshGenerator.h.

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

185 { return hasGenerateData(_pars); }

MeshGenerator::hasGenerateData

bool hasGenerateData() const

Definition: MeshGenerator.h:185

MooseBaseParameterInterface::_pars

const InputParameters & _pars

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

Definition: MooseBaseParameterInterface.h:173

◆ hasMeshProperty() [1/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 25 of file MeshMetaDataInterface.C.

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

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

◆ hasMeshProperty() [2/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 158 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;
 }

◆ hasMeshProperty() [3/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 74 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [4/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 82 of file MeshMetaDataInterface.h.

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

◆ hasOutput()

bool MeshGenerator::hasOutput ( ) const

inherited

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

Definition at line 412 of file MeshGenerator.C.

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

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

◆ hasSaveMesh()

bool MeshGenerator::hasSaveMesh ( ) const

inherited

Return whether or not to save the current mesh.

Definition at line 406 of file MeshGenerator.C.

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

 {
   return _save_with_name.size();
 }

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

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder().

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

◆ isDataOnly()

bool MeshGenerator::isDataOnly ( ) const

inlineinherited

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

Definition at line 190 of file MeshGenerator.h.

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

190 { 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:450

◆ 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 165 of file MeshGenerator.h.

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

165 { return _null_mesh_names.count(name); }

MeshGenerator::_null_mesh_names

std::set< std::string > _null_mesh_names

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

Definition: MeshGenerator.h:444

MooseBase::name

virtual const std::string & name() const

Get the name of the class.

Definition: MooseBase.h:57

◆ isParamSetByUser()

bool MooseBaseParameterInterface::isParamSetByUser ( const std::string & nm ) const

inlineinherited

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

Parameters

nm	The name of the parameter to test

Definition at line 128 of file MooseBaseParameterInterface.h.

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), LibtorchNeuralNetControl::conditionalParameterError(), DiffusionPhysicsBase::DiffusionPhysicsBase(), ElementSubdomainModifierBase::ElementSubdomainModifierBase(), MooseBaseParameterInterface::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MFEMSolverBase::setPreconditioner(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

128 { return _pars.isParamSetByUser(nm); }

InputParameters::isParamSetByUser

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

Method returns true if the parameter was set by the user.

Definition: InputParameters.C:1178

MooseBaseParameterInterface::_pars

const InputParameters & _pars

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

Definition: MooseBaseParameterInterface.h:173

◆ isParamValid()

bool MooseBaseParameterInterface::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 122 of file MooseBaseParameterInterface.h.

122 { return _pars.isParamValid(name); }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

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

Definition: MooseBaseParameterInterface.h:173

InputParameters::isParamValid

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

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

Definition: InputParameters.C:390

◆ 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 372 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 std::string &	prefix
	)

staticprotectedinherited

Returns: The full name for mesh property data.

Definition at line 33 of file MeshMetaDataInterface.C.

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

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

◆ meshPropertyName() [2/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 95 of file MeshMetaDataInterface.h.

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

◆ mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 91 of file MooseBaseErrorInterface.h.

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

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

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Emits a documented error with object name and type.

Documented errors are errors that have an issue associated with them.

The repository name repo_name links a named repository to a URL and should be registered at the application level with registerRepository(). See Moose.C for an example of the "moose" repository registration.

Parameters

repo_name	The repository name where the issue resides
issue_num	The number of the issue
args	The error message to be combined

Definition at line 61 of file MooseBaseErrorInterface.h.

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

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     const auto msg = moose::internal::formatMooseDocumentedError(repo_name, issue_num, oss.str());
     _moose_base.callMooseError(msg, /* with_prefix = */ true);
   }

◆ mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type.

Definition at line 29 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     _moose_base.callMooseError(oss.str(), /* with_prefix = */ true);
   }

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 40 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     _moose_base.callMooseError(oss.str(), /* with_prefix = */ false);
   }

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 98 of file MooseBaseErrorInterface.h.

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

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

◆ mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 75 of file MooseBaseErrorInterface.h.

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

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

◆ mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 85 of file MooseBaseErrorInterface.h.

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

◆ name()

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

inlinevirtualinherited

Get the name of the class.

Returns: The name of the class

Reimplemented in MooseVariableBase.

Definition at line 57 of file MooseBase.h.

57 { return _name; }

MooseBase::_name

const std::string _name

The name of this class.

Definition: MooseBase.h:90

◆ normalsWithinTol()

bool SideSetsGeneratorBase::normalsWithinTol	(	const Point &	normal_1,
		const Point &	normal_2,
		const Real &	tol
	)		const

protected

Determines whether two normal vectors are within normal_tol of each other.

Parameters

normal_1	The first normal vector to compare to normal_2.
normal_2	The second normal vector to compare to normal_1.
tol	The comparison tolerance.

Returns: A bool indicating whether 1 - dot(normal_1, normal_2) <= tol.

Definition at line 273 of file SideSetsGeneratorBase.C.

Referenced by elemSideSatisfiesRequirements(), SideSetsFromNormalsGenerator::generate(), SideSetsFromPointsGenerator::generate(), and AllSideSetsByNormalsGenerator::generate().

 {
   return (1.0 - normal_1 * normal_2) <= tol;
 }

◆ paramError()

template<typename... Args>

void MooseBaseParameterInterface::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 255 of file MooseBaseParameterInterface.h.

 {
   Moose::show_trace = false;
   _moose_base.callMooseError(paramErrorMsg(param, std::forward<Args>(args)...),
                              /* with_prefix = */ false);
   Moose::show_trace = true;
 }

◆ parameters()

const InputParameters& MooseBaseParameterInterface::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 62 of file MooseBaseParameterInterface.h.

62 { return _pars; }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

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

Definition: MooseBaseParameterInterface.h:173

◆ paramInfo()

template<typename... Args>

void MooseBaseParameterInterface::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 272 of file MooseBaseParameterInterface.h.

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

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

◆ paramWarning()

template<typename... Args>

void MooseBaseParameterInterface::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 265 of file MooseBaseParameterInterface.h.

Referenced by GridPartitioner::_do_partition(), EigenProblem::checkProblemIntegrity(), CombinerGenerator::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

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

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

If the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns: A pointer to the parameter value, if it exists

Definition at line 222 of file MooseBaseParameterInterface.h.

 {
   return isParamValid(name) ? &getParam<T>(name) : nullptr;
 }

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

Referenced by AddMetaDataGenerator::validParams().

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

◆ 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 485 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 221 of file MeshGenerator.h.

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

◆ setup()

void SideSetsGeneratorBase::setup ( MeshBase & mesh )

protected

This method is used to construct the FE object so we can compute normals of faces.

Additionaly this method also grabs the sideset ids from the mesh given a list of sideset names.

Definition at line 112 of file SideSetsGeneratorBase.C.

Referenced by SideSetsFromNormalsGenerator::generate(), SideSetsFromPointsGenerator::generate(), SideSetsBetweenSubdomainsGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), SideSetsAroundSubdomainGenerator::generate(), and ParsedGenerateSideset::generate().

 {
   mooseAssert(_fe_face == nullptr, "FE Face has already been initialized");
 
   // To know the dimension of the mesh
   if (!mesh.is_prepared())
     mesh.prepare_for_use();
   const auto dim = mesh.mesh_dimension();
 
   // Setup the FE Object so we can calculate normals
   libMesh::FEType fe_type(Utility::string_to_enum<Order>("CONSTANT"),
                           Utility::string_to_enum<libMesh::FEFamily>("MONOMIAL"));
   _fe_face = libMesh::FEBase::build(dim, fe_type);
   _qface = std::make_unique<libMesh::QGauss>(dim - 1, FIRST);
   _fe_face->attach_quadrature_rule(_qface.get());
   // Must always pre-request quantities you want to compute
   _fe_face->get_normals();
 
   // Handle incompatible parameters
   if (_include_only_external_sides && _check_neighbor_subdomains)
     paramError("include_only_external_sides", "External sides dont have neighbors");
 
   if (_check_included_boundaries)
   {
     const auto & included_boundaries = getParam<std::vector<BoundaryName>>("included_boundaries");
     for (const auto & boundary_name : _boundary_names)
       if (std::find(included_boundaries.begin(), included_boundaries.end(), boundary_name) !=
           included_boundaries.end())
         paramError(
             "new_boundary",
             "A boundary cannot be both the new boundary and be included in the list of included "
             "boundaries. If you are trying to restrict an existing boundary, you must use a "
             "different name for 'new_boundary', delete the old boundary, and then rename the "
             "new boundary to the old boundary.");
 
     _included_boundary_ids = MooseMeshUtils::getBoundaryIDs(mesh, included_boundaries, false);
 
     // Check that the included boundary ids/names exist in the mesh
     for (const auto i : index_range(_included_boundary_ids))
       if (_included_boundary_ids[i] == Moose::INVALID_BOUNDARY_ID)
         paramError("included_boundaries",
                    "The boundary '",
                    included_boundaries[i],
                    "' was not found within the mesh");
   }
 
   if (_check_excluded_boundaries)
   {
     const auto & excluded_boundaries = getParam<std::vector<BoundaryName>>("excluded_boundaries");
     for (const auto & boundary_name : _boundary_names)
       if (std::find(excluded_boundaries.begin(), excluded_boundaries.end(), boundary_name) !=
           excluded_boundaries.end())
         paramError(
             "new_boundary",
             "A boundary cannot be both the new boundary and be excluded in the list of excluded "
             "boundaries.");
     _excluded_boundary_ids = MooseMeshUtils::getBoundaryIDs(mesh, excluded_boundaries, false);
 
     // Check that the excluded boundary ids/names exist in the mesh
     for (const auto i : index_range(_excluded_boundary_ids))
       if (_excluded_boundary_ids[i] == Moose::INVALID_BOUNDARY_ID)
         paramError("excluded_boundaries",
                    "The boundary '",
                    excluded_boundaries[i],
                    "' was not found within the mesh");
 
     if (_check_included_boundaries)
     {
       // Check that included and excluded boundary lists do not overlap
       for (const auto & boundary_id : _included_boundary_ids)
         if (std::find(_excluded_boundary_ids.begin(), _excluded_boundary_ids.end(), boundary_id) !=
             _excluded_boundary_ids.end())
           paramError("excluded_boundaries",
                      "'included_boundaries' and 'excluded_boundaries' lists should not overlap");
     }
   }
 
   // Get the boundary ids from the names
   if (parameters().isParamValid("included_subdomains"))
   {
     // check that the subdomains exist in the mesh
     const auto subdomains = getParam<std::vector<SubdomainName>>("included_subdomains");
     for (const auto & name : subdomains)
       if (!MooseMeshUtils::hasSubdomainName(mesh, name))
         paramError("included_subdomains", "The block '", name, "' was not found in the mesh");
 
     _included_subdomain_ids = MooseMeshUtils::getSubdomainIDs(mesh, subdomains);
   }
 
   if (parameters().isParamValid("included_neighbors"))
   {
     // check that the subdomains exist in the mesh
     const auto subdomains = getParam<std::vector<SubdomainName>>("included_neighbors");
     for (const auto & name : subdomains)
       if (!MooseMeshUtils::hasSubdomainName(mesh, name))
         paramError("included_neighbors", "The block '", name, "' was not found in the mesh");
 
     _included_neighbor_subdomain_ids = MooseMeshUtils::getSubdomainIDs(mesh, subdomains);
   }
 
   // We will want to Change the below code when we have more fine-grained control over advertising
   // what we need and how we satisfy those needs. For now we know we need to have neighbors per
   // #15823...and we do have an explicit `find_neighbors` call...but we don't have a
   // `neighbors_found` API and it seems off to do:
   //
   // if (!mesh.is_prepared())
   //   mesh.find_neighbors()
 }

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

51 { return _type; }

MooseBase::_type

const std::string _type

The type of this class.

Definition: MooseBase.h:87

◆ 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 27 of file MooseBase.C.

Referenced by MaterialPropertyStorage::addProperty(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

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

◆ uniqueName()

MooseObjectName MooseBaseParameterInterface::uniqueName ( ) const

inlineinherited

The unique name for accessing input parameters of this object in the InputParameterWarehouse.

Definition at line 67 of file MooseBaseParameterInterface.h.

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

   {
     return MooseObjectName(_pars.get<std::string>("_unique_name"));
   }

◆ uniqueParameterName()

MooseObjectParameterName MooseBaseParameterInterface::uniqueParameterName ( const std::string & parameter_name ) const

inlineinherited

The unique parameter name of a valid parameter of this object for accessing parameter controls.

Definition at line 52 of file MooseBaseParameterInterface.h.

   {
     return MooseObjectParameterName(
         _pars.get<std::string>("_moose_base"), _moose_base.name(), parameter_name);
   }

◆ validParams()

InputParameters SideSetsGeneratorBase::validParams ( )

static

Definition at line 25 of file SideSetsGeneratorBase.C.

Referenced by SideSetsFromNormalsGenerator::validParams(), SideSetsFromPointsGenerator::validParams(), SideSetsBetweenSubdomainsGenerator::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), AllSideSetsByNormalsGenerator::validParams(), SideSetsAroundSubdomainGenerator::validParams(), and ParsedGenerateSideset::validParams().

 {
   InputParameters params = MeshGenerator::validParams();
   params.addRequiredParam<MeshGeneratorName>("input", "The mesh we want to modify");
   params.addRequiredParam<std::vector<BoundaryName>>(
       "new_boundary", "The list of boundary names to create on the supplied subdomain");
   params.addParam<bool>("fixed_normal",
                         false,
                         "This Boolean determines whether we fix our normal "
                         "or allow it to vary to \"paint\" around curves");
 
   params.addParam<bool>("replace",
                         false,
                         "If true, replace the old sidesets. If false, the current sidesets (if "
                         "any) will be preserved.");
 
   params.addParam<std::vector<BoundaryName>>(
       "included_boundaries",
       "A set of boundary names or ids whose sides will be included in the new sidesets.  A side "
       "is only added if it also belongs to one of these boundaries.");
   params.addParam<std::vector<BoundaryName>>(
       "excluded_boundaries",
       "A set of boundary names or ids whose sides will be excluded from the new sidesets.  A side "
       "is only added if does not belong to any of these boundaries.");
   params.addParam<std::vector<SubdomainName>>(
       "included_subdomains",
       "A set of subdomain names or ids whose sides will be included in the new sidesets. A side "
       "is only added if the subdomain id of the corresponding element is in this set.");
   params.addParam<std::vector<SubdomainName>>("included_neighbors",
                                               "A set of neighboring subdomain names or ids. A face "
                                               "is only added if the subdomain id of the "
                                               "neighbor is in this set");
   params.addParam<bool>(
       "include_only_external_sides",
       false,
       "Whether to only include external sides when considering sides to add to the sideset");
 
   params.addParam<Point>("normal",
                          Point(),
                          "If supplied, only faces with normal equal to this, up to "
                          "normal_tol, will be added to the sidesets specified");
   params.addRangeCheckedParam<Real>("normal_tol",
                                     0.1,
                                     "normal_tol>=0 & normal_tol<=2",
                                     "If normal is supplied then faces are "
                                     "only added if face_normal.normal_hat >= "
                                     "1 - normal_tol, where normal_hat = "
                                     "normal/|normal|");
   params.addParam<Real>("variance", "The variance allowed when comparing normals");
   params.deprecateParam("variance", "normal_tol", "4/01/2025");
 
   // Sideset restriction param group
   params.addParamNamesToGroup(
       "included_boundaries excluded_boundaries included_subdomains included_neighbors "
       "include_only_external_sides normal normal_tol",
       "Sideset restrictions");
 
   return params;
 }

Member Data Documentation

◆ _action_factory

ActionFactory& MooseBaseParameterInterface::_action_factory

protectedinherited

Builds Actions.

Definition at line 179 of file MooseBaseParameterInterface.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 84 of file MooseBase.h.

◆ _boundary_names

std::vector<BoundaryName> SideSetsGeneratorBase::_boundary_names

protected

The list of new boundary names.

Definition at line 99 of file SideSetsGeneratorBase.h.

Referenced by SideSetsFromNormalsGenerator::generate(), SideSetsBetweenSubdomainsGenerator::generate(), SideSetsFromPointsGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), ParsedGenerateSideset::generate(), SideSetsAroundSubdomainGenerator::generate(), ParsedGenerateSideset::ParsedGenerateSideset(), setup(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), and SideSetsGeneratorBase().

◆ _check_excluded_boundaries

const bool SideSetsGeneratorBase::_check_excluded_boundaries

protected

whether to check boundary ids against the excluded boundary list when adding sides or not

Definition at line 111 of file SideSetsGeneratorBase.h.

Referenced by elemSideSatisfiesRequirements(), and setup().

◆ _check_included_boundaries

const bool SideSetsGeneratorBase::_check_included_boundaries

protected

whether to check boundary ids against the included boundary list when adding sides or not

Definition at line 108 of file SideSetsGeneratorBase.h.

Referenced by elemSideSatisfiesRequirements(), and setup().

◆ _check_neighbor_subdomains

const bool SideSetsGeneratorBase::_check_neighbor_subdomains

protected

whether to check the subdomain ids of the neighbor element (on the other 'side' of the side) when adding sides

Definition at line 117 of file SideSetsGeneratorBase.h.

Referenced by elemSideSatisfiesRequirements(), and setup().

◆ _check_subdomains

const bool SideSetsGeneratorBase::_check_subdomains

protected

whether to check subdomain ids of the element in the (element, side, boundary id) tuple when adding sides

Definition at line 114 of file SideSetsGeneratorBase.h.

Referenced by flood(), SideSetsBetweenSubdomainsGenerator::generate(), ParsedGenerateSideset::generate(), and SideSetsAroundSubdomainGenerator::generate().

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

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 51 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _excluded_boundary_ids

std::vector<boundary_id_type> SideSetsGeneratorBase::_excluded_boundary_ids

protected

A list of boundary ids that the side must not be a part of, extracted from the excluded_boundaries parameter.

Definition at line 123 of file SideSetsGeneratorBase.h.

Referenced by elementSideInExcludedBoundaries(), and setup().

◆ _factory

Factory& MooseBaseParameterInterface::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 176 of file MooseBaseParameterInterface.h.

Referenced by ElementIDOutputAction::act(), AutoCheckpointAction::act(), PartitionerAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupMeshAction::act(), AdaptivityAction::act(), CombineComponentsMeshes::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), SetupPreconditionerAction::act(), SetupResidualDebugAction::act(), CreateDisplacedProblemAction::act(), MaterialDerivativeTestAction::act(), SetAdaptivityOptionsAction::act(), DisplayGhostingAction::act(), AddControlAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), AddNodalNormalsAction::act(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), SampledOutput::cloneMesh(), MooseBaseParameterInterface::connectControllableParams(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), ActionComponent::getFactory(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), and ProjectedStatefulMaterialStorageAction::processProperty().

◆ _fe_face

std::unique_ptr<libMesh::FEBase> SideSetsGeneratorBase::_fe_face

protected

Definition at line 147 of file SideSetsGeneratorBase.h.

Referenced by finalize(), flood(), SideSetsFromNormalsGenerator::generate(), SideSetsBetweenSubdomainsGenerator::generate(), SideSetsFromPointsGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), ParsedGenerateSideset::generate(), SideSetsAroundSubdomainGenerator::generate(), and setup().

◆ _fixed_normal

const bool SideSetsGeneratorBase::_fixed_normal

protected

Whether to fix the normal or allow it to vary to "paint" around curves.

Definition at line 102 of file SideSetsGeneratorBase.h.

Referenced by flood(), and SideSetsFromNormalsGenerator::generate().

◆ _include_only_external_sides

const bool SideSetsGeneratorBase::_include_only_external_sides

protected

Whether to only include external side when considering sides to add to the sideset.

Definition at line 132 of file SideSetsGeneratorBase.h.

Referenced by elemSideSatisfiesRequirements(), and setup().

◆ _included_boundary_ids

std::vector<boundary_id_type> SideSetsGeneratorBase::_included_boundary_ids

protected

A list of boundary ids that the side has to be part of, extracted from the included_boundaries parameter.

Definition at line 120 of file SideSetsGeneratorBase.h.

Referenced by elementSideInIncludedBoundaries(), SideSetsFromBoundingBoxGenerator::generate(), and setup().

◆ _included_neighbor_subdomain_ids

std::vector<subdomain_id_type> SideSetsGeneratorBase::_included_neighbor_subdomain_ids

protected

A list of included neighbor subdomain ids that the sides' neighbor element must be a part of.

Definition at line 129 of file SideSetsGeneratorBase.h.

Referenced by elemSideSatisfiesRequirements(), and setup().

◆ _included_subdomain_ids

std::vector<subdomain_id_type> SideSetsGeneratorBase::_included_subdomain_ids

protected

A list of included subdomain ids that the side has to be part of, extracted from the included_subdomains parameter.

Definition at line 126 of file SideSetsGeneratorBase.h.

Referenced by flood(), SideSetsBetweenSubdomainsGenerator::generate(), ParsedGenerateSideset::generate(), SideSetsAroundSubdomainGenerator::generate(), and setup().

◆ _input

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

protected

the mesh to add the sidesets to

Definition at line 96 of file SideSetsGeneratorBase.h.

Referenced by SideSetsFromNormalsGenerator::generate(), SideSetsFromPointsGenerator::generate(), SideSetsBetweenSubdomainsGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), SideSetsAroundSubdomainGenerator::generate(), and ParsedGenerateSideset::generate().

◆ _mesh

MooseMesh* const MeshGenerator::_mesh

protectedinherited

Pointer to the owning mesh.

Definition at line 388 of file MeshGenerator.h.

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

◆ _name

const std::string MooseBase::_name

protectedinherited

The name of this class.

Definition at line 90 of file MooseBase.h.

Referenced by AddBCAction::act(), AddConstraintAction::act(), PartitionerAction::act(), AddFVInterfaceKernelAction::act(), AddUserObjectAction::act(), AddFVInitialConditionAction::act(), AddScalarKernelAction::act(), AddKernelAction::act(), ReadExecutorParamsAction::act(), AddMeshGeneratorAction::act(), AddVectorPostprocessorAction::act(), AddFunctorMaterialAction::act(), AddMarkerAction::act(), AddNodalKernelAction::act(), AddMaterialAction::act(), AddIndicatorAction::act(), AddPostprocessorAction::act(), AddDamperAction::act(), AddInitialConditionAction::act(), AddMultiAppAction::act(), AddTransferAction::act(), AddDGKernelAction::act(), AddDiracKernelAction::act(), AddInterfaceKernelAction::act(), AddPositionsAction::act(), AddReporterAction::act(), AddTimesAction::act(), AddFieldSplitAction::act(), AddFVKernelAction::act(), AddFVBCAction::act(), AddTimeStepperAction::act(), AddDistributionAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddFunctionAction::act(), AddConvergenceAction::act(), AddMeshDivisionAction::act(), AddHDGKernelAction::act(), AddOutputAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddCorrectorAction::act(), AddMeshModifiersAction::act(), AddSamplerAction::act(), AddControlAction::act(), AddMFEMSolverAction::act(), AddMFEMPreconditionerAction::act(), AddMFEMSubMeshAction::act(), AddMFEMFESpaceAction::act(), AddPeriodicBCAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), CombinerGenerator::CombinerGenerator(), Executor::Executor(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::name(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseBase::setData(), and AddVariableAction::varName().

◆ _normal

Point SideSetsGeneratorBase::_normal

protected

if specified, then faces are only added if their normal is close to this

Definition at line 138 of file SideSetsGeneratorBase.h.

Referenced by SideSetsBetweenSubdomainsGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), ParsedGenerateSideset::generate(), and SideSetsAroundSubdomainGenerator::generate().

◆ _normal_tol

const Real SideSetsGeneratorBase::_normal_tol

protected

if normal is specified, then faces are only added if face_normal.normal_hat <= 1 - normal_tol where normal_hat = _normal/|_normal|

Definition at line 145 of file SideSetsGeneratorBase.h.

Referenced by elemSideSatisfiesRequirements(), SideSetsFromNormalsGenerator::generate(), and SideSetsFromPointsGenerator::generate().

◆ _pars

const InputParameters& MooseBaseParameterInterface::_pars

protectedinherited

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

Definition at line 173 of file MooseBaseParameterInterface.h.

◆ _qface

std::unique_ptr<libMesh::QGauss> SideSetsGeneratorBase::_qface

protected

Definition at line 148 of file SideSetsGeneratorBase.h.

Referenced by finalize(), and setup().

◆ _replace

const bool SideSetsGeneratorBase::_replace

protected

Whether or not to remove the old sidesets (all of them, if any) when adding sidesets.

Definition at line 105 of file SideSetsGeneratorBase.h.

Referenced by flood(), SideSetsBetweenSubdomainsGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), ParsedGenerateSideset::generate(), and SideSetsAroundSubdomainGenerator::generate().

◆ _type

const std::string MooseBase::_type

protectedinherited

The type of this class.

Definition at line 87 of file MooseBase.h.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), FillBetweenSidesetsGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), ExplicitTimeIntegrator::init(), FEProblemBase::init(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), FEProblemBase::solverTypeString(), and MooseBase::type().

◆ _using_normal

bool SideSetsGeneratorBase::_using_normal

protected

true if only faces close to "normal" will be added

Definition at line 135 of file SideSetsGeneratorBase.h.

Referenced by elemSideSatisfiesRequirements(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), and SideSetsFromPointsGenerator::SideSetsFromPointsGenerator().

◆ _visited

std::map<boundary_id_type, std::set<const Elem *> > SideSetsGeneratorBase::_visited

protected

Definition at line 149 of file SideSetsGeneratorBase.h.

Referenced by flood(), SideSetsFromNormalsGenerator::generate(), SideSetsFromPointsGenerator::generate(), and AllSideSetsByNormalsGenerator::generate().

◆ 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 62 of file MeshGenerator.h.

Referenced by MeshGenerator::addMeshSubgenerator(), MeshGeneratorSystem::createAddedMeshGenerators(), and MeshGenerator::validParams().

◆ NAME

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

staticinherited

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

Definition at line 33 of file MeshMetaDataInterface.h.

◆ SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"

staticinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().

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

include/meshgenerators/SideSetsGeneratorBase.h
src/meshgenerators/SideSetsGeneratorBase.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ SideSetsGeneratorBase()

◆ ~SideSetsGeneratorBase()

Member Function Documentation

◆ addChildMeshGenerator()

◆ addMeshSubgenerator() [1/2]

◆ addMeshSubgenerator() [2/2]

◆ addParentMeshGenerator()

◆ buildDistributedMesh()

◆ buildMeshBaseObject()

◆ buildReplicatedMesh()

◆ callMooseError()

◆ connectControllableParams()

◆ copyMeshProperty() [1/2]

◆ copyMeshProperty() [2/2]

◆ declareMeshesForSub()

◆ declareMeshesForSubByName()

◆ declareMeshForSub()

◆ declareMeshForSubByName()

◆ declareMeshProperty() [1/2]

◆ declareMeshProperty() [2/2]

◆ declareNullMeshName()

◆ elementSideInExcludedBoundaries()

◆ elementSideInIncludedBoundaries()

◆ elementSubdomainIdInList()

◆ elemSideSatisfiesRequirements()

◆ enabled()

◆ errorPrefix()

◆ finalize()

◆ flood()

◆ generate()

◆ generateData()

◆ generateInternal()

◆ getCheckedPointerParam()

◆ getChildMeshGenerators()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getMesh()

◆ getMeshByName()

◆ getMeshes()

◆ getMeshesByName()

◆ getMeshProperty() [1/2]

◆ getMeshProperty() [2/2]

◆ getMooseApp()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getParentMeshGenerators()

◆ getRenamedParam()

◆ getRequestedMeshGenerators()

◆ getRequestedMeshGeneratorsForSub()

◆ getSavedMeshName()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ getSubMeshGenerators()

◆ hasGenerateData() [1/2]

◆ hasGenerateData() [2/2]

◆ hasMeshProperty() [1/4]

◆ hasMeshProperty() [2/4]

◆ hasMeshProperty() [3/4]

◆ hasMeshProperty() [4/4]

◆ hasOutput()

◆ hasSaveMesh()

◆ isChildMeshGenerator()

◆ isDataOnly()

◆ isNullMeshName()

◆ isParamSetByUser()

◆ isParamValid()

◆ isParentMeshGenerator()