Extrudes a mesh to another dimension. More...

#include <AdvancedExtruderGenerator.h>

Inheritance diagram for AdvancedExtruderGenerator:

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

Public Member Functions
	AdvancedExtruderGenerator (const InputParameters &parameters)

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

bool	hasGenerateData () const

bool	hasGenerateCSG () const

std::unique_ptr< CSG::CSGBase >	generateInternalCSG ()
	Internal generation method for CSG object generation.

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

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

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

void	addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)
	Adds the MeshGenerator `mg` as a parent.

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

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

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

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

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

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

bool	isNullMeshName (const MeshGeneratorName &name) const

bool	hasSaveMesh () const
	Return whether or not to save the current mesh.

bool	hasOutput () const

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

bool	isDataOnly () const

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

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

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

bool	isKokkosObject () const
	Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

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

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

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

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

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

MooseObjectName	uniqueName () const

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

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

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

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

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

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

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

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

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

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

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

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

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const

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

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

std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used.

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

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

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

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

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

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

template<typename... Args>
void	mooseDeprecated (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and a stack trace.

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

template<typename... Args>
void	mooseDeprecatedNoTrace (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and no stack trace.

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
	External method for calling moose error with added object context.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

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

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

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

Static Public Member Functions
static InputParameters	validParams ()

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

static bool	hasGenerateData (const InputParameters &params)

static void	setHasGenerateCSG (InputParameters &params)
	Sets that a mesh generator has a generateCSG() implementation.

static bool	hasGenerateCSG (const InputParameters &params)

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)
	External method for calling moose error with added object context.

Public Attributes
	usingCombinedWarningSolutionWarnings

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

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

static const std::string	type_param = "_type"
	The name of the parameter that contains the object type.

static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name.

static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name.

static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp.

static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base.

static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor.

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

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

Protected Member Functions
Real	radialExpansionRatio (const Real t) const
	Calculate the share of the radial expansion to apply at the local node This share goes from 0 at the beginning of the extrusion to 1 at the end.

std::unordered_map< dof_id_type, Point >	computeNodeNormals (const MeshBase &input) const
	Compute, for each node, the extrusion direction as the JxW-weighted average of the normals, evaluated at that node with nodal quadrature, of all the elements connected to it.

virtual void	generateData ()
	Generate the mesh data.

virtual std::unique_ptr< CSG::CSGBase >	generateCSG ()
	Generate the CSG representation of the mesh (or meshing operation) created by this mesh generator.

template<typename T >
T &	copyMeshProperty (const std::string &target_data_name, const std::string &source_data_name, const std::string &source_mesh)
	Method for copying attribute from input mesh meta-data store to current mesh meta-data store.

template<typename T >
T &	copyMeshProperty (const std::string &source_data_name, const std::string &source_mesh)
	Method for copying attribute from input mesh meta-data store to current mesh meta-data store, keeping source and target data names the same.

std::unique_ptr< MeshBase > &	getMesh (const std::string &param_name, const bool allow_invalid=false)
	Takes the name of a MeshGeneratorName parameter and then gets a pointer to the Mesh that MeshGenerator is going to create.

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

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

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

std::unique_ptr< CSG::CSGBase > &	getCSGBase (const std::string &param_name)
	Takes the name of a MeshGeneratorName parameter and then gets a pointer to the CSGBase object that MeshGenerator has created.

std::unique_ptr< CSG::CSGBase > &	getCSGBaseByName (const MeshGeneratorName &mesh_generator_name)
	Like `getCSGBase()`, but takes the name of another MeshGenerator directly.

std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBases (const std::string &param_name)
	Like `getCSGBase()`, but for multiple generators.

std::vector< std::unique_ptr< CSG::CSGBase > * >	getCSGBasesByName (const std::vector< MeshGeneratorName > &mesh_generator_names)
	Like `getCSGBaseByName()`, but for multiple generators.

void	declareMeshForSub (const std::string &param_name)
	Declares that a MeshGenerator referenced in the InputParameters is to be used as a dependency of a sub MeshGenerator created by this MeshGenerator (see addSubMeshGenerator)

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

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

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

std::unique_ptr< MeshBase >	buildMeshBaseObject (unsigned int dim=libMesh::invalid_uint)
	Build a `MeshBase` object whose underlying type will be determined by the Mesh input file block.

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

std::unique_ptr< DistributedMesh >	buildDistributedMesh (unsigned int dim=libMesh::invalid_uint)
	Build a distributed mesh that has correct remote element removal behavior and geometric ghosting functors based on the simulation objects.

template<typename... Ts>
void	addMeshSubgenerator (const std::string &type, const std::string &name, Ts... extra_input_parameters)
	Construct a "subgenerator", a different MeshGenerator subclass that will be added to the same MooseApp on the fly.

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

void	declareNullMeshName (const MeshGeneratorName &name)
	Registers the name `name` as a "null" mesh, which is a MeshGenerator used in InputParameters that will not represent an input mesh when requested via getMesh.

template<bool warning>
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
	Set solution invalid mark for the given solution ID.

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

template<typename T >
const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)
	Method for retrieving a property with the given type and name exists in the mesh meta-data store.

template<typename T >
const T &	getMeshProperty (const std::string &data_name)

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

template<typename T >
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

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

template<typename T >
bool	hasMeshProperty (const std::string &data_name) const

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


template<typename T , typename... Args>
T &	declareMeshProperty (const std::string &data_name, Args &&... args)
	Methods for writing out attributes to the mesh meta-data store, which can be retrieved from most other MOOSE systems and is recoverable.

template<typename T >
T &	declareMeshProperty (const std::string &data_name, const T &data_value)


template<typename T , typename... Args>
T &	setMeshProperty (const std::string &data_name, Args &&... args)
	Method for updating attributes to the mesh meta-data store, which can only be invoked in the MeshGenerator generate routine only if the mesh generator property has already been declared.

template<typename T >
T &	setMeshProperty (const std::string &data_name, const T &data_value)

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

Protected Attributes
std::unique_ptr< MeshBase > &	_input
	Mesh that comes from another generator.

const std::vector< Real > &	_heights
	Height of each elevation.

const std::vector< Real >	_biases
	Bias growth factor of each elevation.

const std::vector< unsigned int > &	_num_layers
	Number of layers in each elevation.

const std::vector< std::vector< SubdomainName > > &	_subdomain_swaps
	Subdomains to swap out for each elevation.

const std::vector< std::vector< boundary_id_type > > &	_boundary_swaps
	Boundaries to swap out for each elevation.

const std::vector< std::string > &	_elem_integer_names_to_swap
	Names and indices of extra element integers to swap.

std::vector< unsigned int >	_elem_integer_indices_to_swap

const std::vector< std::vector< std::vector< dof_id_type > > > &	_elem_integers_swaps
	Extra element integers to swap out for each elevation and each element interger name.

std::vector< std::unordered_map< subdomain_id_type, subdomain_id_type > >	_subdomain_swap_pairs
	Easier to work with version of _sudomain_swaps.

std::vector< std::unordered_map< boundary_id_type, boundary_id_type > >	_boundary_swap_pairs
	Easier to work with version of _boundary_swaps.

std::vector< std::unordered_map< dof_id_type, dof_id_type > >	_elem_integers_swap_pairs
	Easier to work with version of _elem_integers_swaps.

Point	_direction
	The direction of the extrusion.

std::unique_ptr< MeshBase > &	_extrusion_curve
	Curve mesh to extrude along.

const RealVectorValue	_start_extrusion_direction
	Extrusion direction to follow at the start (first layer) of the extrusion.

const RealVectorValue	_end_extrusion_direction
	Extrusion direction for the final layer of the extrusion.

bool	_extrude_along_curve
	Whether we are extruding along a curve.

const bool	_extrude_along_node_normals
	Whether to extrude each node along the averaged normal of the elements connected to it.

const bool	_has_top_boundary

const BoundaryName	_top_boundary

const bool	_has_bottom_boundary

const BoundaryName	_bottom_boundary

const bool	_has_side_boundary
	Whether to add the lateral exterior sides (and their nodes) to a boundary.

const BoundaryName	_side_boundary
	Boundary for the lateral exterior sides and their nodes.

const std::vector< std::vector< subdomain_id_type > >	_upward_boundary_source_blocks
	The list of input mesh's blocks that need to be assigned upward boundary interfaces for each layer of elevation.

const std::vector< std::vector< boundary_id_type > >	_upward_boundary_ids
	Upward boundary interfaces for each layer of elevation.

const std::vector< std::vector< subdomain_id_type > >	_downward_boundary_source_blocks
	The list of input mesh's blocks that need to be assigned downward boundary interfaces for each layer of elevation.

const std::vector< std::vector< boundary_id_type > >	_downward_boundary_ids
	Downward boundary interfaces for each layer of elevation.

const Real	_twist_pitch
	Axial pitch for a full rotation.

const Real	_end_radial_extent
	Radial extent of the extruded geometry at the end of the extrusion.

const MooseEnum	_radial_expansion_method
	Function type for modifying the radial extent of the extruded shape.

const Real	_start_radial_growth_rate
	Derivative of the radial expansion function at the beginning of the extrusion.

const Real	_end_radial_growth_rate
	Derivative of the radial expansion function at the end of the extrusion.

MooseMesh *const	_mesh
	Pointer to the owning mesh.

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

MooseApp &	_app
	The MOOSE application this is associated with.

Factory &	_factory
	The Factory associated with the MooseApp.

ActionFactory &	_action_factory
	Builds Actions.

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

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

const InputParameters &	_pars
	The object's parameters.

const Parallel::Communicator &	_communicator

Private Member Functions
virtual std::string	meshPropertyPrefix (const std::string &) const override final
	Override of the default prefix to use when getting mesh properties.

void	checkGetMesh (const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const
	Helper for performing error checking in the getMesh methods.

const MeshGeneratorName *	getMeshGeneratorNameFromParam (const std::string &param_name, const bool allow_invalid) const
	Helper for getting a MeshGeneratorName parameter.

const std::vector< MeshGeneratorName > &	getMeshGeneratorNamesFromParam (const std::string &param_name) const
	Helper for getting a std::vector<MeshGeneratorName> parameter.

RestartableDataValue &	setMeshPropertyHelper (const std::string &data_name)
	Helper for getting a writable reference to a mesh property, used in declareMeshProperty and setMeshProperty.

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const
	Helper for getting a mesh property.

template<typename... Args>
void	mooseErrorInternal (Args &&... args) const
	Helper for forwarding a mooseError to an object's mooseError if it is available (said error will provide more context: object name and type)

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)
	Internal method for getting a hit node (if available) given a set of parameters.

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)
	Internal method for getting the message prefix for an object (object type, name, etc).

Private Attributes
std::set< MeshGeneratorName >	_requested_mesh_generators
	The names of the MeshGenerators that were requested in the getMesh methods.

std::set< MeshGeneratorName >	_requested_mesh_generators_for_sub
	The names of the MeshGenerators that were requested in the declareMeshForSub methods.

std::vector< std::pair< std::string, std::unique_ptr< MeshBase > * > >	_requested_meshes
	The meshes that were requested by this MeshGenerator; used to verify that any input meshes that are requested are properly released after generation.

std::vector< std::pair< std::string, std::unique_ptr< CSG::CSGBase > * > >	_requested_csg_bases
	The CSGBase objects that were requested by this MeshGenerator; used to verify that any input meshes that are requested are properly released after generation.

std::unique_ptr< MeshBase >	_null_mesh = nullptr
	A nullptr to use for when inputs aren't specified.

std::unique_ptr< CSG::CSGBase >	_null_csg_base = nullptr
	A nullptr to use for when inputs aren't specified.

std::set< const MeshGenerator *, Comparator >	_parent_mesh_generators
	The MeshGenerators that are parents to this MeshGenerator.

std::set< const MeshGenerator *, Comparator >	_child_mesh_generators
	The MeshGenerators that are children to this MeshGenerator.

std::set< const MeshGenerator *, Comparator >	_sub_mesh_generators
	The sub MeshGenerators constructed by this MeshGenerator.

std::set< std::string >	_null_mesh_names
	The declared "null" mesh names that will not represent a mesh in input; see declareNullMeshName()

const std::string &	_save_with_name
	A user-defined name to save the mesh.

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

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.

const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

MooseApp &	_meta_data_app
	Reference to the application.

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

Detailed Description

Extrudes a mesh to another dimension.

Definition at line 19 of file AdvancedExtruderGenerator.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

◆ AdvancedExtruderGenerator()

AdvancedExtruderGenerator::AdvancedExtruderGenerator ( const InputParameters & parameters )

Definition at line 185 of file AdvancedExtruderGenerator.C.

  : MeshGenerator(parameters),
    _input(getMesh("input")),
    _heights(getParam<std::vector<Real>>("heights")),
    _biases(isParamValid("biases") ? getParam<std::vector<Real>>("biases")
                                   : std::vector<Real>(_heights.size(), 1.0)),
    _num_layers(getParam<std::vector<unsigned int>>("num_layers")),
    _subdomain_swaps(getParam<std::vector<std::vector<SubdomainName>>>("subdomain_swaps")),
    _boundary_swaps(getParam<std::vector<std::vector<boundary_id_type>>>("boundary_swaps")),
    _elem_integer_names_to_swap(getParam<std::vector<std::string>>("elem_integer_names_to_swap")),
    _elem_integers_swaps(
        getParam<std::vector<std::vector<std::vector<dof_id_type>>>>("elem_integers_swaps")),
    _direction(isParamValid("direction") ? getParam<Point>("direction") : Point(0, 0, 0)),
    _extrusion_curve(getMesh("extrusion_curve", true)),
    _start_extrusion_direction(isParamValid("start_extrusion_direction")
                                   ? getParam<RealVectorValue>("start_extrusion_direction").unit()
                                   : Point(0, 0, 0)),
    _end_extrusion_direction(isParamValid("end_extrusion_direction")
                                 ? getParam<RealVectorValue>("end_extrusion_direction").unit()
                                 : Point(0, 0, 0)),
    _extrude_along_curve(isParamValid("extrusion_curve")),
    _extrude_along_node_normals(getParam<bool>("extrude_along_node_normals")),
    _has_top_boundary(isParamValid("top_boundary")),
    _top_boundary(isParamValid("top_boundary") ? getParam<BoundaryName>("top_boundary") : "0"),
    _has_bottom_boundary(isParamValid("bottom_boundary")),
    _bottom_boundary(isParamValid("bottom_boundary") ? getParam<BoundaryName>("bottom_boundary")
                                                     : "0"),
    _has_side_boundary(isParamValid("side_boundary")),
    _side_boundary(isParamValid("side_boundary") ? getParam<BoundaryName>("side_boundary") : ""),
    _upward_boundary_source_blocks(
        isParamValid("upward_boundary_source_blocks")
            ? getParam<std::vector<std::vector<subdomain_id_type>>>("upward_boundary_source_blocks")
            : std::vector<std::vector<subdomain_id_type>>(_heights.size(),
                                                          std::vector<subdomain_id_type>())),
    _upward_boundary_ids(
        isParamValid("upward_boundary_ids")
            ? getParam<std::vector<std::vector<boundary_id_type>>>("upward_boundary_ids")
            : std::vector<std::vector<boundary_id_type>>(_heights.size(),
                                                         std::vector<boundary_id_type>())),
    _downward_boundary_source_blocks(isParamValid("downward_boundary_source_blocks")
                                         ? getParam<std::vector<std::vector<subdomain_id_type>>>(
                                               "downward_boundary_source_blocks")
                                         : std::vector<std::vector<subdomain_id_type>>(
                                               _heights.size(), std::vector<subdomain_id_type>())),
    _downward_boundary_ids(
        isParamValid("downward_boundary_ids")
            ? getParam<std::vector<std::vector<boundary_id_type>>>("downward_boundary_ids")
            : std::vector<std::vector<boundary_id_type>>(_heights.size(),
                                                         std::vector<boundary_id_type>())),
    _twist_pitch(getParam<Real>("twist_pitch")),
    _end_radial_extent(getParam<Real>("end_radial_extent")),
    _radial_expansion_method(getParam<MooseEnum>("radial_growth_method")),
    _start_radial_growth_rate(getParam<Real>("start_radial_growth_rate")),
    _end_radial_growth_rate(getParam<Real>("end_radial_growth_rate"))
{
  if (_extrude_along_curve)
  {
    if (isParamSetByUser("heights"))
      paramError("heights", "heights cannot be set if extruding along curve!");
    if (isParamValid("biases"))
      paramError("biases", "biases cannot be set if extruding along curve!");
    if (isParamSetByUser("num_layers"))
      paramError("num_layers", "num_layers cannot be set if extruding along curve!");
    if (isParamValid("direction"))
      paramError("direction", "direction cannot be set if extruding along curve!");
    if (_extrude_along_node_normals)
      paramError("extrude_along_node_normals",
                 "extrude_along_node_normals cannot be set if extruding along curve!");
  }
  else if (_extrude_along_node_normals)
  {
    if (isParamValid("direction"))
      paramError("direction",
                 "direction cannot be set if 'extrude_along_node_normals' is set, as the extrusion "
                 "direction is computed from the element normals!");
    if (!MooseUtils::absoluteFuzzyEqual(_twist_pitch, 0.))
      paramError("twist_pitch",
                 "twist_pitch cannot be set if 'extrude_along_node_normals' is set!");
    if (_end_radial_extent)
      paramError("end_radial_extent",
                 "end_radial_extent cannot be set if 'extrude_along_node_normals' is set!");
  }
  else
  {
    if (!_direction.norm())
      paramError("direction", "Must have some length!");
    _direction /= _direction.norm();
  }
 
  unsigned int num_elevations;
  if (_extrude_along_curve)
    num_elevations = 1;
  else
  {
    num_elevations = _heights.size();
    if (_num_layers.size() != num_elevations)
      paramError(
          "heights", "The length of 'heights' and 'num_layers' must be the same in ", name());
  }
 
  if (_subdomain_swaps.size() && (_subdomain_swaps.size() != num_elevations))
  {
    if (_extrude_along_curve)
      paramError("subdomain_swaps",
                 "If specified, 'subdomain_swaps' (" + std::to_string(_subdomain_swaps.size()) +
                     ") must be equal to 1 when extruding along a curve.");
    else
    {
      paramError("subdomain_swaps",
                 "If specified, 'subdomain_swaps' (" + std::to_string(_subdomain_swaps.size()) +
                     ") must be the same length as 'heights' (" + std::to_string(num_elevations) +
                     ") in ",
                 name());
    }
  }
 
  if (_boundary_swaps.size() && (_boundary_swaps.size() != num_elevations))
  {
    if (_extrude_along_curve)
    {
      paramError("boundary_swaps",
                 "If specified, 'boundary_swaps' (" + std::to_string(_boundary_swaps.size()) +
                     ") must be the same length as 'heights' (" + std::to_string(num_elevations) +
                     ") in ",
                 name());
    }
    else
    {
      paramError("boundary_swaps",
                 "If specified, 'boundary_swaps' (" + std::to_string(_boundary_swaps.size()) +
                     ") must be equal to 1 when extruding along a curve.");
    }
  }
 
  try
  {
    MooseMeshUtils::idSwapParametersProcessor(
        name(), "boundary_swaps", _boundary_swaps, _boundary_swap_pairs);
  }
  catch (const MooseException & e)
  {
    paramError("boundary_swaps", e.what());
  }
 
  if (_elem_integers_swaps.size() &&
      _elem_integers_swaps.size() != _elem_integer_names_to_swap.size())
    paramError("elem_integers_swaps",
               "If specified, 'elem_integers_swaps' must have the same length as the length of "
               "'elem_integer_names_to_swap'.");
 
  for (const auto & unit_elem_integers_swaps : _elem_integers_swaps)
    if (unit_elem_integers_swaps.size() != num_elevations)
      paramError("elem_integers_swaps",
                 "If specified, each element of 'elem_integers_swaps' must have the same length as "
                 "the length of 'heights'.");
 
  try
  {
    MooseMeshUtils::extraElemIntegerSwapParametersProcessor(name(),
                                                            num_elevations,
                                                            _elem_integer_names_to_swap.size(),
                                                            _elem_integers_swaps,
                                                            _elem_integers_swap_pairs);
  }
  catch (const MooseException & e)
  {
    paramError("elem_integers_swaps", e.what());
  }
 
  if (!_extrude_along_curve)
  {
    bool has_negative_entry = false;
    bool has_positive_entry = false;
    for (const auto & h : _heights)
    {
      if (h > 0.0)
        has_positive_entry = true;
      else
        has_negative_entry = true;
    }
 
    if (has_negative_entry && has_positive_entry)
      paramError("heights", "Cannot have both positive and negative heights!");
    if (_biases.size() != _heights.size())
      paramError("biases", "Size of this parameter, if provided, must be the same as heights.");
  }
 
  if ((_upward_boundary_source_blocks.size() || _upward_boundary_ids.size()) &&
      (_upward_boundary_source_blocks.size() != _upward_boundary_ids.size() ||
       _upward_boundary_ids.size() != num_elevations))
  {
    if (_extrude_along_curve)
      paramError(
          "upward_boundary_ids",
          "This parameter must have the same length (" +
              std::to_string(_upward_boundary_ids.size()) + ") as upward_boundary_source_blocks (" +
              std::to_string(_upward_boundary_source_blocks.size()) + ") and num_elevations (" +
              std::to_string(num_elevations) +
              "). Note that the number of heights is set to 1 when extruding along a curve.");
    else
    {
      paramError("upward_boundary_ids",
                 "This parameter must have the same length (" +
                     std::to_string(_upward_boundary_ids.size()) +
                     ") as upward_boundary_source_blocks (" +
                     std::to_string(_upward_boundary_source_blocks.size()) + ") and heights (" +
                     std::to_string(num_elevations) + ")");
    }
  }
 
  for (unsigned int i = 0; i < _upward_boundary_source_blocks.size(); i++)
    if (_upward_boundary_source_blocks[i].size() != _upward_boundary_ids[i].size())
      paramError("upward_boundary_ids",
                 "Every element of this parameter must have the same length as the corresponding "
                 "element of upward_boundary_source_blocks.");
 
  if ((_downward_boundary_source_blocks.size() || _downward_boundary_ids.size()) &&
      (_downward_boundary_source_blocks.size() != _downward_boundary_ids.size() ||
       _downward_boundary_ids.size() != num_elevations))
  {
    if (_extrude_along_curve)
      paramError(
          "downward_boundary_ids",
          "This parameter must have the same length (" +
              std::to_string(_downward_boundary_ids.size()) +
              ") as downward_boundary_source_blocks (" +
              std::to_string(_downward_boundary_source_blocks.size()) + ") and (" +
              std::to_string(num_elevations) +
              "). Note that the number of heights is set to 1 when extruding along a curve.");
    else
    {
      paramError("downward_boundary_ids",
                 "This parameter must have the same length (" +
                     std::to_string(_downward_boundary_ids.size()) +
                     ") as downward_boundary_source_blocks (" +
                     std::to_string(_downward_boundary_source_blocks.size()) + ") and heights (" +
                     std::to_string(num_elevations) + ")");
    }
  }
  for (unsigned int i = 0; i < _downward_boundary_source_blocks.size(); i++)
    if (_downward_boundary_source_blocks[i].size() != _downward_boundary_ids[i].size())
      paramError("downward_boundary_ids",
                 "Every element of this parameter must have the same length as the corresponding "
                 "element of downward_boundary_source_blocks.");
}

Member Function Documentation

◆ addChildMeshGenerator()

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

inherited

Adds the MeshGenerator mg as a child.

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

Definition at line 471 of file MeshGenerator.C.

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

◆ addMeshSubgenerator() [1/2]

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

protectedinherited

Construct a "subgenerator", as above.

User code is responsible for constructing valid InputParameters.

Parameters

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

Definition at line 440 of file MeshGenerator.C.

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

◆ addMeshSubgenerator() [2/2]

template<typename... Ts>

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

protectedinherited

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

Parameters

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

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

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

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

Definition at line 593 of file MeshGenerator.h.

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

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

◆ addParentMeshGenerator()

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

inherited

Adds the MeshGenerator mg as a parent.

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

Definition at line 464 of file MeshGenerator.C.

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

◆ buildDistributedMesh()

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

protectedinherited

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

Parameters

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

Definition at line 333 of file MeshGenerator.C.

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

Referenced by DistributedRectilinearMeshGenerator::generate().

◆ buildMeshBaseObject()

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

protectedinherited

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

Parameters

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

Definition at line 319 of file MeshGenerator.C.

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

◆ buildReplicatedMesh()

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

protectedinherited

Build a replicated mesh.

Parameters

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

Definition at line 326 of file MeshGenerator.C.

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

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

◆ callMooseError() [1/2]

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

staticinherited

External method for calling moose error with added object context.

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

Parameters

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

Definition at line 114 of file MooseBase.C.

{
  if (!node)
    node = MooseBase::getHitNode(params);
 
  std::string multiapp_prefix = "";
  if (app)
  {
    if (!app->isUltimateMaster())
      multiapp_prefix = app->name();
    app->getOutputWarehouse().mooseConsole();
  }
 
  if (with_prefix)
    // False here because the hit context will get processed by the node
    msg = messagePrefix(params, false) + msg;
 
  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
}

◆ callMooseError() [2/2]

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

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

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

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

◆ checkGetMesh()

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

privateinherited

Helper for performing error checking in the getMesh methods.

Definition at line 158 of file MeshGenerator.C.

{
  mooseAssert(!mesh_generator_name.empty(), "Empty name");
  const auto & mg_sys = _app.getMeshGeneratorSystem();
  if (!hasGenerateCSG() && !_app.constructingMeshGenerators())
    mooseError("Cannot get a mesh outside of construction");
  if (!mg_sys.hasMeshGenerator(mesh_generator_name) && !isNullMeshName(mesh_generator_name))
  {
    std::stringstream error;
    error << "The requested MeshGenerator with name '" << mesh_generator_name << "' ";
    if (mg_sys.hasMeshGeneratorParams(mesh_generator_name))
      error << "was found, but has not been constructed yet.\n\nThis can occur when your "
               "dependencies are not properly defined and we cannot infer the proper construction "
               "order of your MeshGenerators.\n\nThe most likely case is a sub generator whose "
               "input(s) are not declared as a sub dependency in the generator creating them.";
    else
      error << "was not found.\nMesh generators that can be found: "
            << Moose::stringify(mg_sys.getMeshGeneratorNames());
 
    if (param_name.size())
      paramError(param_name, error.str());
    else
      mooseError(error.str());
  }
 
#ifdef MOOSE_MFEM_ENABLED
  if (mg_sys.hasMeshGenerator(mesh_generator_name))
  {
    const auto is_mfem = [](const InputParameters & pars)
    {
      const auto * const flag = pars.queryParam<bool>("_mfem_mesh_generator");
      return flag && *flag;
    };
    const auto & parent = mg_sys.getMeshGenerator(mesh_generator_name);
    const bool parent_is_mfem = is_mfem(parent.parameters());
    const bool this_is_mfem = is_mfem(parameters());
    if (parent_is_mfem != this_is_mfem)
    {
      const auto & mfem_name = parent_is_mfem ? mesh_generator_name : name();
      const auto & mfem_type = parent_is_mfem ? parent.type() : type();
      const auto & libmesh_name = parent_is_mfem ? name() : mesh_generator_name;
      const auto & libmesh_type = parent_is_mfem ? type() : parent.type();
      const std::string msg = "Cannot chain MFEM-native mesh generator '" + mfem_name +
                              "' of type '" + mfem_type + "' with libMesh-native mesh generator '" +
                              libmesh_name + "' of type '" + libmesh_type +
                              "'. MFEM and libMesh mesh generators cannot be mixed within the "
                              "same generator chain.";
      if (param_name.size())
        paramError(param_name, msg);
      else
        mooseError(msg);
    }
  }
#endif
}

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

◆ computeNodeNormals()

std::unordered_map< dof_id_type, Point > AdvancedExtruderGenerator::computeNodeNormals ( const MeshBase & input ) const

protected

Compute, for each node, the extrusion direction as the JxW-weighted average of the normals, evaluated at that node with nodal quadrature, of all the elements connected to it.

The input surface mesh is expected to have consistently oriented elements.

Parameters

input the 1D or 2D mesh being extruded

Returns: a map from node id to its (unit) extrusion direction

Definition at line 1810 of file AdvancedExtruderGenerator.C.

{
  // Evaluate the geometric map of each element at its nodes with a nodal quadrature rule, as done
  // for mortar nodal normals. On curved (higher-order) elements this captures the local surface
  // normal at each node rather than a single per-element normal.
  const auto dim = input.mesh_dimension();
  libMesh::QNodal qrule(dim);
  const auto & qweights = qrule.get_weights();
  std::unique_ptr<FEBase> fe(FEBase::build(dim, FEType(FIRST, LAGRANGE)));
  fe->attach_quadrature_rule(&qrule);
  const auto & dxyzdxi = fe->get_dxyzdxi();
  const auto & dxyzdeta = fe->get_dxyzdeta();
  const auto & q_points = fe->get_xyz();
  const Point z_axis(0, 0, 1);
 
  // Sum the JxW-weighted normals of the elements connected to each node
  std::unordered_map<dof_id_type, Point> node_normals;
  for (const auto & elem : input.element_ptr_range())
  {
    fe->reinit(elem);
    const auto qpoint_to_node = MooseMeshUtils::nodalQuadraturePointToNodeMap(*elem, q_points);
    for (const auto qp : index_range(q_points))
    {
      // The weighted normal JxW * n is the quadrature weight times the area vector
      // dxyz/dxi x dxyz/deta in 2D, or the in-plane rotation z x dxyz/dxi of the tangent in 1D.
      // Both have the orientation of the element's node ordering, so that the extruded elements
      // are not inverted.
      Point weighted_normal;
      if (dim == 2)
        weighted_normal = dxyzdxi[qp].cross(dxyzdeta[qp]);
      else
      {
        // A curve only defines a unique normal within its plane
        if (std::abs(dxyzdxi[qp](2)) > libMesh::TOLERANCE * dxyzdxi[qp].norm())
          paramError("extrude_along_node_normals",
                     "Extruding a 1D mesh along node normals requires the mesh to lie in a plane "
                     "of constant z, but element ",
                     elem->id(),
                     " is not.");
        weighted_normal = z_axis.cross(dxyzdxi[qp]);
      }
      node_normals[elem->node_id(qpoint_to_node[qp])] += qweights[qp] * weighted_normal;
    }
  }
 
  // The input surface mesh is expected to have consistently oriented elements.
  for (auto & [node_id, normal] : node_normals)
  {
    if (normal.norm_sq() == 0)
      mooseError("The averaged normal at node ",
                 node_id,
                 " is zero; an extrusion direction cannot be determined. This can happen if the "
                 "connected elements do not have consistent orientations.");
    normal = normal.unit();
  }
 
  return node_normals;
}

Referenced by generate().

◆ connectControllableParams()

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

inherited

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

Parameters

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

Definition at line 77 of file MooseBase.C.

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

◆ copyMeshProperty() [1/2]

template<typename T >

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

inlineprotectedinherited

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

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

Definition at line 276 of file MeshGenerator.h.

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

◆ copyMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

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

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

Definition at line 263 of file MeshGenerator.h.

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

◆ declareMeshesForSub()

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

protectedinherited

Like declareMeshForSub(), but for multiple generators.

Definition at line 295 of file MeshGenerator.C.

{
  declareMeshesForSubByName(getMeshGeneratorNamesFromParam(param_name));
}

Referenced by XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve().

◆ declareMeshesForSubByName()

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

protectedinherited

Like declareMeshForSubByName(), but for multiple generators.

Definition at line 311 of file MeshGenerator.C.

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

Referenced by MeshGenerator::declareMeshesForSub(), and XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve().

◆ declareMeshForSub()

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

protectedinherited

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

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

Definition at line 289 of file MeshGenerator.C.

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

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

◆ declareMeshForSubByName()

void MeshGenerator::declareMeshForSubByName ( const MeshGeneratorName & mesh_generator_name )

protectedinherited

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

Definition at line 301 of file MeshGenerator.C.

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

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

◆ declareMeshProperty() [1/2]

template<typename T , typename... Args>

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

protectedinherited

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

Definition at line 535 of file MeshGenerator.h.

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

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

◆ declareMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 236 of file MeshGenerator.h.

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

◆ declareNullMeshName()

void MeshGenerator::declareNullMeshName ( const MeshGeneratorName & name )

protectedinherited

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

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

Definition at line 504 of file MeshGenerator.C.

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

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

49{ return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition MooseObject.h:71

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

◆ errorPrefix()

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

inlineinherited

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

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ flagInvalidSolutionInternal()

template<bool warning>

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

protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

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

◆ generate()

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

overridevirtual

Generate / modify the mesh.

Implements MeshGenerator.

Definition at line 432 of file AdvancedExtruderGenerator.C.

{
  // Note: bulk of this code originally from libmesh mesh_modification.C
  // Original copyright: Copyright (C) 2002-2019 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
  // Original license is LGPL so it can be used here.
 
  auto mesh = buildMeshBaseObject(_input->mesh_dimension() + 1);
  mesh->set_mesh_dimension(_input->mesh_dimension() + 1);
 
  // Check if the element integer names are existent in the input mesh.
  for (const auto i : make_range(_elem_integer_names_to_swap.size()))
    if (_input->has_elem_integer(_elem_integer_names_to_swap[i]))
      _elem_integer_indices_to_swap.push_back(
          _input->get_elem_integer_index(_elem_integer_names_to_swap[i]));
    else
      paramError("elem_integer_names_to_swap",
                 "Element ",
                 i + 1,
                 " of 'elem_integer_names_to_swap' in is not a valid extra element integer of the "
                 "input mesh.");
 
  // prepare for transferring extra element integers from original mesh to the extruded mesh.
  const unsigned int num_extra_elem_integers = _input->n_elem_integers();
  std::vector<std::string> id_names;
 
  for (unsigned int i = 0; i < num_extra_elem_integers; i++)
  {
    id_names.push_back(_input->get_elem_integer_name(i));
    if (!mesh->has_elem_integer(id_names[i]))
      mesh->add_elem_integer(id_names[i]);
  }
 
  // retrieve subdomain/sideset/nodeset name maps
  if (!_input->preparation().has_cached_elem_data)
    _input->cache_elem_data();
  const auto & input_subdomain_map = _input->get_subdomain_name_map();
  const auto & input_sideset_map = _input->get_boundary_info().get_sideset_name_map();
  const auto & input_nodeset_map = _input->get_boundary_info().get_nodeset_name_map();
 
  // Check that the swaps source blocks are present in the mesh
  for (const auto & swap : _subdomain_swaps)
    for (const auto i : index_range(swap))
      if (i % 2 == 0 && !MooseMeshUtils::hasSubdomainName(*_input, swap[i]))
      {
        std::string blocks;
        for (const auto & [name, id] : MooseMeshUtils::getAllSubdomainNamesAndIDs(*_input))
          blocks += (blocks.empty() ? "" : ", ") + name + " (" + std::to_string(id) + ")";
        paramError("subdomain_swaps",
                   "The block '",
                   swap[i],
                   "' was not found within the mesh.\nBlock names (ID) in the mesh: " + blocks);
      }
 
  // Convert the subdomain swaps from names to IDs. Target subdomains that are neither IDs nor
  // names of subdomains in the input mesh are assigned new IDs, unused by the input mesh and by
  // any other target ID
  subdomain_id_type next_free_subdomain_id = MooseMeshUtils::getNextFreeSubdomainID(*_input);
  for (const auto & swap : _subdomain_swaps)
    for (const auto i : index_range(swap))
      if (i % 2 == 1 && MooseUtils::isDigits(swap[i]))
        next_free_subdomain_id = std::max(
            next_free_subdomain_id,
            cast_int<subdomain_id_type>(MooseMeshUtils::getSubdomainID(swap[i], *_input) + 1));
  std::map<SubdomainName, subdomain_id_type> new_subdomain_ids;
  std::vector<std::vector<subdomain_id_type>> subdomain_swap_ids(_subdomain_swaps.size());
  for (const auto row : index_range(_subdomain_swaps))
    for (const auto i : index_range(_subdomain_swaps[row]))
    {
      const auto & subdomain = _subdomain_swaps[row][i];
      if (i % 2 == 0 || MooseUtils::isDigits(subdomain) ||
          MooseMeshUtils::hasSubdomainName(*_input, subdomain))
        subdomain_swap_ids[row].push_back(MooseMeshUtils::getSubdomainID(subdomain, *_input));
      else
      {
        if (!new_subdomain_ids.count(subdomain))
          new_subdomain_ids[subdomain] = next_free_subdomain_id++;
        subdomain_swap_ids[row].push_back(new_subdomain_ids[subdomain]);
      }
    }
 
  try
  {
    MooseMeshUtils::idSwapParametersProcessor(
        name(), "subdomain_swaps", subdomain_swap_ids, _subdomain_swap_pairs);
  }
  catch (const MooseException & e)
  {
    paramError("subdomain_swaps", e.what());
  }
 
  // Check that the swaps source boundaries are present in the mesh
  for (const auto & swap : _boundary_swaps)
    for (const auto i : index_range(swap))
      if (i % 2 == 0 && !MooseMeshUtils::hasBoundaryID(*_input, swap[i]))
        paramError("boundary_swaps",
                   "The boundary '",
                   swap[i],
                   "' was not found within the mesh.\nBoundaries in the mesh: " +
                       Moose::stringify(MooseMeshUtils::getAllBoundaryNamesAndIDs(*_input)));
 
  // Check that the source blocks for layer top/bottom boundaries exist in the mesh
  for (const auto & layer_vec : _upward_boundary_source_blocks)
    for (const auto bid : layer_vec)
      if (!MooseMeshUtils::hasSubdomainID(*_input, bid))
        paramError(
            "upward_boundary_source_blocks", "The block '", bid, "' was not found within the mesh");
  for (const auto & layer_vec : _downward_boundary_source_blocks)
    for (const auto bid : layer_vec)
      if (!MooseMeshUtils::hasSubdomainID(*_input, bid))
        paramError("downward_boundary_source_blocks",
                   "The block '",
                   bid,
                   "' was not found within the mesh");
 
  // Move the meshes as requested by the mesh generator system
  std::unique_ptr<MeshBase> input = std::move(_input);
  std::unique_ptr<MeshBase> extrusion_curve;
  if (_extrude_along_curve)
    extrusion_curve = std::move(_extrusion_curve);
 
  if (_extrude_along_node_normals && !input->is_serial())
    paramError("extrude_along_node_normals",
               "Extruding along node normals is not implemented for non-serialized distributed "
               "meshes yet.");
 
  // We must serialize the curve to know how to extrude across all ranks
  std::unique_ptr<libMesh::MeshSerializer> serializer;
  if (_extrude_along_curve)
    serializer = std::make_unique<libMesh::MeshSerializer>(*extrusion_curve);
 
  // Exterior sides of the input mesh are identified by their lack of neighbor
  if (_has_side_boundary && !input->preparation().has_neighbor_ptrs)
    input->find_neighbors();
 
  // If we're using a distributed mesh... then make sure we don't have any remote elements hanging
  // around
  if (!input->is_serial())
  {
    input->delete_remote_elements();
    // This should be a no-op, and yet, it's needed for two THM tests
    mesh->delete_remote_elements();
  }
 
  if (input->n_nodes() != input->max_node_id())
    input->renumber_nodes_and_elements();
 
  if (input->n_nodes() != input->max_node_id())
    mooseError(
        "You must allow renumbering, because the extruded mesh should be contiguously numbered. "
        "Alternatively, you can use a separate mesh generator (MeshRepairGenerator with the "
        "renumber_contiguously parameter for example) to renumber the nodes contiguously.");
 
  unsigned int total_num_layers;
  unsigned int total_num_elevations;
  if (!_extrude_along_curve)
  {
    total_num_layers = std::accumulate(_num_layers.begin(), _num_layers.end(), 0);
    total_num_elevations = _heights.size();
  }
  else
  {
    total_num_layers = extrusion_curve->n_elem();
    total_num_elevations = 1;
  }
 
  dof_id_type orig_elem = input->n_elem();
  dof_id_type orig_nodes = input->n_nodes();
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  unique_id_type orig_unique_ids = input->parallel_max_unique_id();
  bool has_poly_midnodes = false;
#endif
 
  bool has_polygons = false;
  unsigned int order = 1;
 
  BoundaryInfo & boundary_info = mesh->get_boundary_info();
  const BoundaryInfo & input_boundary_info = input->get_boundary_info();
 
  // Determine boundary IDs for the new user provided boundary names
  std::vector<BoundaryName> new_boundary_names;
  if (_has_bottom_boundary)
    new_boundary_names.push_back(_bottom_boundary);
  if (_has_top_boundary)
    new_boundary_names.push_back(_top_boundary);
  if (_has_side_boundary)
    new_boundary_names.push_back(_side_boundary);
  std::vector<boundary_id_type> new_boundary_ids =
      MooseMeshUtils::getBoundaryIDs(*input, new_boundary_names, true);
  // getBoundaryIDs generates a distinct ID for each unknown name, even a repeated one, so make
  // boundaries given the same name share an ID
  for (const auto i : index_range(new_boundary_names))
    for (const auto j : make_range(i))
      if (new_boundary_names[i] == new_boundary_names[j])
        new_boundary_ids[i] = new_boundary_ids[j];
  const auto user_bottom_boundary_id =
      _has_bottom_boundary ? new_boundary_ids.front() : libMesh::BoundaryInfo::invalid_id;
  const auto user_top_boundary_id = _has_top_boundary
                                        ? new_boundary_ids[_has_bottom_boundary ? 1 : 0]
                                        : libMesh::BoundaryInfo::invalid_id;
  const auto user_side_boundary_id =
      _has_side_boundary ? new_boundary_ids.back() : libMesh::BoundaryInfo::invalid_id;
 
  // We know a priori how many elements we'll need
  mesh->reserve_elem(total_num_layers * orig_elem);
 
  // Look for higher order elements which introduce an extra layer
  std::set<ElemType> higher_orders = {EDGE3, EDGE4, TRI6, TRI7, QUAD8, QUAD9};
  bool extruding_quad_eights = false;
  std::vector<ElemType> types;
  MeshTools::elem_types(*input, types);
  for (const auto elem_type : types)
  {
    if (higher_orders.count(elem_type))
      order = 2;
    if (elem_type == QUAD8)
      extruding_quad_eights = true;
  }
  mesh->comm().max(order);
  mesh->comm().max(extruding_quad_eights);
 
  // Reserve for the max number possibly needed
  mesh->reserve_nodes((order * total_num_layers + 1) * orig_nodes);
 
  // Container to catch the boundary IDs handed back by the BoundaryInfo object
  std::vector<boundary_id_type> ids_to_copy;
 
  // We need to compute the distance to the axis
  Real start_radial_extent = 0;
  Point reference_point;
  if (_extrude_along_curve)
    reference_point = *(extrusion_curve->node_ptr(0));
  else if (!MooseUtils::absoluteFuzzyEqual(_twist_pitch, 0.))
    // Backwards compatibility: we were twisting along an axis going through the origin
    reference_point = Point(0, 0, 0);
  else
    reference_point = MooseMeshUtils::meshCentroidCalculator(*input);
 
  if (_end_radial_extent)
  {
    // the center is at the curve if we are extruding along a curve, and the centroid of the mesh
    // otherwise
    RealVectorValue reference_direction;
    if (_extrude_along_curve)
      reference_direction =
          _start_extrusion_direction.norm_sq() > 0
              ? _start_extrusion_direction
              : RealVectorValue(
                    (*(extrusion_curve->node_ptr(1)) - *(extrusion_curve->node_ptr(0))).unit());
    else
      reference_direction = _direction;
 
    // now we measure the initial radial extent
    start_radial_extent =
        MooseMeshUtils::computeMaxDistanceToAxis(*input, reference_point, reference_direction);
  }
 
  // Compute the total extrusion distance along the axis
  Real total_extrusion_distance_at_axis;
  if (_extrude_along_curve)
  {
    if (!extrusion_curve->is_prepared())
      extrusion_curve->prepare_for_use();
    total_extrusion_distance_at_axis = MeshTools::volume(*extrusion_curve);
  }
  else
    total_extrusion_distance_at_axis = std::accumulate(_heights.begin(), _heights.end(), 0);
 
  // When extruding along node normals, precompute each node's extrusion direction from the
  // normals of the elements connected to it
  std::unordered_map<dof_id_type, Point> node_normals;
  if (_extrude_along_node_normals)
    node_normals = computeNodeNormals(*input);
 
  // Create translated layers of nodes in the direction of extrusion
  for (const auto & node : input->node_ptr_range())
  {
    unsigned int current_node_layer = 0;
    Point orig_node_to_previous;
    Point orig_node_to_current;
    Real sum_step_sizes = 0.;
    Real sum_step_sizes_at_axis = 0.;
    // Initial distance from the node to the extrusion axis
    Real start_node_radius = (*node - reference_point).norm();
 
    // Direction to extrude this node along: a fixed direction, or the averaged normal of the
    // elements connected to it
    Point node_extrude_direction = _direction;
    if (_extrude_along_node_normals)
    {
      auto it = node_normals.find(node->id());
      if (it == node_normals.end())
        mooseError("Node ",
                   node->id(),
                   " is not connected to any element with a well-defined normal; its extrusion "
                   "direction cannot be determined.");
      node_extrude_direction = it->second;
    }
 
    // e is the elevation layer ordering
    for (const auto e : make_range(total_num_elevations))
    {
      unsigned int num_layers = libMesh::invalid_uint;
      Real height = std::numeric_limits<Real>::max(), bias = std::numeric_limits<Real>::max();
      if (_extrude_along_curve)
      {
        num_layers = extrusion_curve->n_elem();
      }
      else
      {
        num_layers = _num_layers[e];
        height = _heights[e];
        bias = _biases[e];
      }
 
      // In first layer we also add the base nodes, hence the "plus one"
      unsigned int num_heights_at_elevation = order * num_layers + (e == 0 ? 1 : 0);
      // Keep track of the plane normal to the extrusion
      RealVectorValue prev_intersecting_plane_normal_vec = _start_extrusion_direction;
 
      // k is the element layer ordering within each elevation layer
      for (const auto k : make_range(num_heights_at_elevation))
      {
        // Compute 'orig_node_to_current', the update vector
        // For the first layer we don't need to move
        if (e == 0 && k == 0)
          orig_node_to_current.zero();
        else
        {
          // Shift the previous position by a certain fraction of 'height' along the extrusion
          // direction to get the new position.
 
          // Compute orig_node_to_current before any transformation
          Real step_size = 0;
          Real step_size_at_axis = 0;
          if (_extrude_along_curve)
          {
            // current point in extrusion curve
            const Node * P_current = extrusion_curve->node_ptr(k);
            // previous point in extrusion curve
            const Node * P_prev = extrusion_curve->node_ptr(k - 1);
 
            // Quantities for the previous position of the extruded node
            const auto old_node = orig_node_to_previous + *node;
            RealVectorValue b_vec = old_node - *P_prev;
            Real node_distance_to_curve = b_vec.norm();
 
            // Node does not lie exactly on the extrusion curve we are following
            if (node_distance_to_curve > libMesh::TOLERANCE)
            {
              // normal vector to the plane to extrude the point into
              RealVectorValue intersecting_plane_normal_vec;
 
              // Select the extrusion direction based on the curve or the user parameters
              if (k == 1)
              {
                const auto P_next = extrusion_curve->node_ptr(k + 1);
                intersecting_plane_normal_vec =
                    0.5 * (_start_extrusion_direction + (*P_next - *P_current).unit());
              }
              else if (k < order * num_layers - 1)
              {
                const auto P_next = extrusion_curve->node_ptr(k + 1);
                // this approximates the derivative at the spline point
                intersecting_plane_normal_vec = *P_next - *P_prev;
              }
              else
              {
                intersecting_plane_normal_vec = (_end_extrusion_direction.norm_sq() > 0)
                                                    ? _end_extrusion_direction
                                                    : RealVectorValue(*P_current - *P_prev);
              }
              intersecting_plane_normal_vec /= intersecting_plane_normal_vec.norm();
 
              Point new_node_point;
              // If the extrusion direction and the previous plane normal are aligned,
              // we can't define a rotation axis. We simply translate the points
              if (MooseUtils::absoluteFuzzyEqual(
                      prev_intersecting_plane_normal_vec.cross(intersecting_plane_normal_vec)
                          .norm_sq(),
                      0))
                new_node_point = old_node + *P_current - *P_prev;
              // We use a rotation from the previous extrusion plane normal to the current one
              // We have tried in the past:
              // - assuming (P_prev, P_current, old_node, current_node) are coplanar
              // - assuming (P_prev, P_current) and (old_node, current_node) are parallel
              // Both result in a slight deformation of the shape during extrusion.
              else
              {
                auto axis = prev_intersecting_plane_normal_vec.cross(intersecting_plane_normal_vec);
                const auto sin_th = axis.norm();
                axis /= sin_th;
                Real cos_th = prev_intersecting_plane_normal_vec * intersecting_plane_normal_vec;
                // Rodrigues formula for rotation
                const auto new_v = cos_th * b_vec + axis.cross(b_vec) * sin_th +
                                   axis * (axis * b_vec) * (1. - cos_th);
 
                mooseAssert(MooseUtils::absoluteFuzzyEqual(new_v.norm(), b_vec.norm()),
                            "Radial extent be conserved");
                new_node_point = *P_current + new_v;
              }
 
              orig_node_to_current = new_node_point - *node;
 
              step_size = (orig_node_to_current - orig_node_to_previous).norm();
              step_size_at_axis = (*P_current - *P_prev).norm();
              prev_intersecting_plane_normal_vec = intersecting_plane_normal_vec;
            }
            // Point is on the axis of the line
            else
            {
              _direction = *P_current - *P_prev;
              _direction /= _direction.norm();
              mooseAssert(std::abs(_direction.norm() - 1.0) < libMesh::TOLERANCE,
                          "Norm of direction vector is not 1!");
 
              // Calculate step size.
              // Note: orig_node_to_previous + *node is the vector description of the
              // previously-created node
              step_size = ((*P_current - (orig_node_to_previous + *node)) * _direction);
              step_size_at_axis = step_size;
              orig_node_to_current = orig_node_to_previous + _direction * step_size;
            }
          }
          // Extruding in a fixed direction (not along a curve)
          else
          {
            // Divide by the order to avoid applying the bias to the nodes within a higher order
            // element
            auto layer_index = (k - (e == 0 ? 1 : 0)) / order + 1;
            step_size = MooseUtils::absoluteFuzzyEqual(bias, 1.0)
                            ? height / (Real)num_layers / (Real)order
                            : height * std::pow(bias, (Real)(layer_index - 1)) * (1.0 - bias) /
                                  (1.0 - std::pow(bias, (Real)(num_layers))) / (Real)order;
            step_size_at_axis = step_size;
            // update distance from starting node to new node
            orig_node_to_current = orig_node_to_previous + node_extrude_direction * step_size;
          }
 
          // Keep track of the cumulative step size as an extrusion axis coordinate
          sum_step_sizes += step_size;
          sum_step_sizes_at_axis += step_size_at_axis;
 
          // Handle radial expansion. No need to perform expansion at the centerline
          if (_end_radial_extent && start_node_radius > libMesh::TOLERANCE)
          {
            // How far along we are in the extrusion, measured at the axis (=curve when extruding
            // along a curve)
            Real tm1 =
                (sum_step_sizes_at_axis - step_size_at_axis) / total_extrusion_distance_at_axis;
            Real t = sum_step_sizes_at_axis / total_extrusion_distance_at_axis;
 
            // Direction of radial expansion.
            RealVectorValue node_to_extrusion_axis;
            if (_extrude_along_curve)
              node_to_extrusion_axis =
                  *node + orig_node_to_current - *(extrusion_curve->node_ptr(k));
            // The radial expansion has to be performed in the rotated frame
            else if (!MooseUtils::absoluteFuzzyEqual(_twist_pitch, 0.))
              node_to_extrusion_axis =
                  *node + orig_node_to_current - (reference_point + _direction * sum_step_sizes);
            // when extruding in a straight line with no twisting, we can use the original radial
            // direction
            else
              node_to_extrusion_axis = *node - reference_point;
 
            // Fraction of the total starting radius the node lives in
            const auto radius_scaling = start_node_radius / start_radial_extent;
            // Calculate weighting for expansion
            const auto radial_ratio_m1 = AdvancedExtruderGenerator::radialExpansionRatio(tm1);
            const auto radial_ratio = AdvancedExtruderGenerator::radialExpansionRatio(t);
 
            // Compute change in step
            orig_node_to_current += (start_radial_extent * (radial_ratio_m1 - radial_ratio) +
                                     (radial_ratio - radial_ratio_m1) * _end_radial_extent) *
                                    radius_scaling * node_to_extrusion_axis.unit();
          }
 
          // Handle helicoidal extrusion
          if (!MooseUtils::absoluteFuzzyEqual(_twist_pitch, 0.))
          {
            // twist 1 should be 'normal' to the extruded shape
            RealVectorValue twist1 = _direction.cross(*node);
            // This happens for any node on the helicoidal extrusion axis
            if (!MooseUtils::absoluteFuzzyEqual(twist1.norm(), .0))
              twist1 /= twist1.norm();
            const RealVectorValue twist2 = twist1.cross(_direction);
 
            auto twist =
                (cos(2. * libMesh::pi * current_node_layer * step_size / _twist_pitch) -
                 cos(2. * libMesh::pi * (current_node_layer - 1) * step_size / _twist_pitch)) *
                    twist2 +
                (sin(2. * libMesh::pi * current_node_layer * step_size / _twist_pitch) -
                 sin(2. * libMesh::pi * (current_node_layer - 1) * step_size / _twist_pitch)) *
                    twist1;
 
            // If we normalize twist, we must multiply by 2 * sin(libMesh::pi * step_size /
            // _twist_pitch) if (!MooseUtils::absoluteFuzzyEqual(twist.norm(), .0))
            //   twist /= twist.norm();
 
            // Get a point on the extrusion axis (around which we currently twist the geometry)
            // at the local elevation height to be able to compute the distance to the axis
            Point extrusion_axis_at_elevation;
            Point prev_extrusion_axis_at_elevation;
            if (_extrude_along_curve)
            {
              extrusion_axis_at_elevation = *extrusion_curve->node_ptr(k);
              prev_extrusion_axis_at_elevation = *extrusion_curve->node_ptr(k - 1);
            }
            else
            {
              // We can't use old and current step updates because they have been "twisted"
              extrusion_axis_at_elevation = reference_point + _direction * sum_step_sizes;
              prev_extrusion_axis_at_elevation =
                  reference_point + _direction * (sum_step_sizes - step_size);
            }
 
            // Scale with how far the node is from the extrusion axis, before twisting
            twist *= (*node + orig_node_to_current - extrusion_axis_at_elevation).norm();
 
            // No need to twist or expand the point on the axis
            if (!MooseUtils::absoluteFuzzyEqual(twist1.norm(), .0))
              orig_node_to_current += twist;
          }
        }
 
        // Add the new node to the mesh
        Node * new_node = mesh->add_point(*node + orig_node_to_current,
                                          node->id() + (current_node_layer * orig_nodes),
                                          node->processor_id());
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
        // Let's give the base of the extruded mesh the same
        // unique_ids as the source mesh, in case anyone finds that
        // a useful map to preserve.
        const unique_id_type uid = (current_node_layer == 0)
                                       ? node->unique_id()
                                       : orig_unique_ids +
                                             (current_node_layer - 1) * (orig_elem + orig_nodes) +
                                             node->id();
        new_node->set_unique_id(uid);
#endif
 
        // Add the new node to the extruded boundaries
        input_boundary_info.boundary_ids(node, ids_to_copy);
        if (_boundary_swap_pairs.empty())
          boundary_info.add_node(new_node, ids_to_copy);
        else
          for (const auto & id_to_copy : ids_to_copy)
          {
            boundary_info.add_node(new_node,
                                   _boundary_swap_pairs[e].count(id_to_copy)
                                       ? _boundary_swap_pairs[e][id_to_copy]
                                       : id_to_copy);
          }
 
        orig_node_to_previous = orig_node_to_current;
        current_node_layer++;
      }
    }
  }
 
  const auto & side_ids = input_boundary_info.get_side_boundary_ids();
 
  boundary_id_type next_side_id =
      side_ids.empty() ? 0 : cast_int<boundary_id_type>(*side_ids.rbegin() + 1);
 
  // side_ids may not include ids from remote elements, in which case
  // some processors may have underestimated the next_side_id; let's
  // fix that.
  input->comm().max(next_side_id);
 
  // A generated side boundary ID starts after the largest input boundary ID, so it can coincide
  // with the default bottom (next_side_id) and top (next_side_id + 1) IDs
  if (_has_side_boundary)
    while (user_side_boundary_id == next_side_id || user_side_boundary_id == next_side_id + 1)
      ++next_side_id;
 
  // Map to keep track of polygon sides of polygonal prisms
  std::map<std::array<unsigned int, 3>, std::shared_ptr<libMesh::Polygon>> poly_extruded_sides;
 
  // Build the extruded elements
  for (const auto & elem : input->element_ptr_range())
  {
    const ElemType etype = elem->type();
 
    // build_extrusion currently only works on coarse meshes
    libmesh_assert(!elem->parent());
 
    unsigned int current_layer = 0;
 
    for (unsigned int e = 0; e != total_num_elevations; e++)
    {
      auto num_layers = !_extrude_along_curve ? _num_layers[e] : extrusion_curve->n_nodes() - 1;
 
      for (unsigned int k = 0; k != num_layers; ++k)
      {
        std::unique_ptr<Elem> new_elem;
        bool is_flipped(false);
        switch (etype)
        {
          case EDGE2:
          {
            new_elem = std::make_unique<Quad4>();
            new_elem->set_node(
                0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
            new_elem->set_node(
                1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
            new_elem->set_node(
                2, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                3, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
 
            if (elem->neighbor_ptr(0) == remote_elem)
              new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(1) == remote_elem)
              new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
 
            break;
          }
          case EDGE3:
          {
            new_elem = std::make_unique<Quad9>();
            new_elem->set_node(
                0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                2,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                3,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                4, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                5,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                6,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                7,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                8,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
 
            if (elem->neighbor_ptr(0) == remote_elem)
              new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(1) == remote_elem)
              new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
 
            break;
          }
          case TRI3:
          {
            new_elem = std::make_unique<Prism6>();
            new_elem->set_node(
                0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
            new_elem->set_node(
                1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
            new_elem->set_node(
                2, mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * orig_nodes)));
            new_elem->set_node(
                3, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                4, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                5, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer + 1) * orig_nodes)));
 
            if (elem->neighbor_ptr(0) == remote_elem)
              new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(1) == remote_elem)
              new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(2) == remote_elem)
              new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
 
            if (new_elem->volume() < 0.0)
            {
              MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
              MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
              MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
              is_flipped = true;
            }
 
            break;
          }
          case TRI6:
          {
            new_elem = std::make_unique<Prism18>();
            new_elem->set_node(
                0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                3,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                4,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                5,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                6, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                7, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                8, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                9,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                10,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                11,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                12,
                mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                13,
                mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                14,
                mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                15,
                mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                16,
                mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                17,
                mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
 
            if (elem->neighbor_ptr(0) == remote_elem)
              new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(1) == remote_elem)
              new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(2) == remote_elem)
              new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
 
            if (new_elem->volume() < 0.0)
            {
              MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
              MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
              MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
              MooseMeshUtils::swapNodesInElem(*new_elem, 6, 12);
              MooseMeshUtils::swapNodesInElem(*new_elem, 7, 13);
              MooseMeshUtils::swapNodesInElem(*new_elem, 8, 14);
              is_flipped = true;
            }
 
            break;
          }
          case TRI7:
          {
            new_elem = std::make_unique<Prism21>();
            new_elem->set_node(
                0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                3,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                4,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                5,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                6, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                7, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                8, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                9,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                10,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                11,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                12,
                mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                13,
                mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                14,
                mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                15,
                mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                16,
                mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                17,
                mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                18, mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                19,
                mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                20,
                mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 1) * orig_nodes)));
 
            if (elem->neighbor_ptr(0) == remote_elem)
              new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(1) == remote_elem)
              new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(2) == remote_elem)
              new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
 
            if (new_elem->volume() < 0.0)
            {
              MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
              MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
              MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
              MooseMeshUtils::swapNodesInElem(*new_elem, 6, 12);
              MooseMeshUtils::swapNodesInElem(*new_elem, 7, 13);
              MooseMeshUtils::swapNodesInElem(*new_elem, 8, 14);
              MooseMeshUtils::swapNodesInElem(*new_elem, 18, 19);
              is_flipped = true;
            }
 
            break;
          }
          case QUAD4:
          {
            new_elem = std::make_unique<Hex8>();
            new_elem->set_node(
                0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
            new_elem->set_node(
                1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
            new_elem->set_node(
                2, mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * orig_nodes)));
            new_elem->set_node(
                3, mesh->node_ptr(elem->node_ptr(3)->id() + (current_layer * orig_nodes)));
            new_elem->set_node(
                4, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                5, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                6, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                7, mesh->node_ptr(elem->node_ptr(3)->id() + ((current_layer + 1) * orig_nodes)));
 
            if (elem->neighbor_ptr(0) == remote_elem)
              new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(1) == remote_elem)
              new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(2) == remote_elem)
              new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(3) == remote_elem)
              new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
 
            if (new_elem->volume() < 0.0)
            {
              MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
              MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
              MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
              MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
              is_flipped = true;
            }
 
            break;
          }
          case QUAD8:
          {
            new_elem = std::make_unique<Hex20>();
            new_elem->set_node(
                0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                3, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                4,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                5,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                6,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                7,
                mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                8, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                9, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                10, mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                11, mesh->node_ptr(elem->node_ptr(7)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                12,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                13,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                14,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                15,
                mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                16,
                mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                17,
                mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                18,
                mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                19,
                mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 2) * orig_nodes)));
 
            if (elem->neighbor_ptr(0) == remote_elem)
              new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(1) == remote_elem)
              new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(2) == remote_elem)
              new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(3) == remote_elem)
              new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
 
            if (new_elem->volume() < 0.0)
            {
              MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
              MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
              MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
              MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
              MooseMeshUtils::swapNodesInElem(*new_elem, 8, 16);
              MooseMeshUtils::swapNodesInElem(*new_elem, 9, 17);
              MooseMeshUtils::swapNodesInElem(*new_elem, 10, 18);
              MooseMeshUtils::swapNodesInElem(*new_elem, 11, 19);
              is_flipped = true;
            }
 
            break;
          }
          case QUAD9:
          {
            new_elem = std::make_unique<Hex27>();
            new_elem->set_node(
                0, mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                1, mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                2, mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                3, mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                4,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                5,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                6,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                7,
                mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                8, mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                9, mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                10, mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                11, mesh->node_ptr(elem->node_ptr(7)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                12,
                mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                13,
                mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                14,
                mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                15,
                mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                16,
                mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                17,
                mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                18,
                mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                19,
                mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                20, mesh->node_ptr(elem->node_ptr(8)->id() + (2 * current_layer * orig_nodes)));
            new_elem->set_node(
                21,
                mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                22,
                mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                23,
                mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                24,
                mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 1) * orig_nodes)));
            new_elem->set_node(
                25,
                mesh->node_ptr(elem->node_ptr(8)->id() + ((2 * current_layer + 2) * orig_nodes)));
            new_elem->set_node(
                26,
                mesh->node_ptr(elem->node_ptr(8)->id() + ((2 * current_layer + 1) * orig_nodes)));
 
            if (elem->neighbor_ptr(0) == remote_elem)
              new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(1) == remote_elem)
              new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(2) == remote_elem)
              new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
            if (elem->neighbor_ptr(3) == remote_elem)
              new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
 
            if (new_elem->volume() < 0.0)
            {
              MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
              MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
              MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
              MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
              MooseMeshUtils::swapNodesInElem(*new_elem, 8, 16);
              MooseMeshUtils::swapNodesInElem(*new_elem, 9, 17);
              MooseMeshUtils::swapNodesInElem(*new_elem, 10, 18);
              MooseMeshUtils::swapNodesInElem(*new_elem, 11, 19);
              MooseMeshUtils::swapNodesInElem(*new_elem, 20, 25);
              is_flipped = true;
            }
 
            break;
          }
          case libMesh::C0POLYGON:
          {
            has_polygons = true;
            const auto num_sides = elem->n_sides();
            std::vector<std::shared_ptr<libMesh::Polygon>> sides;
            sides.reserve(2 + num_sides);
            if (2 * elem->n_nodes() > libMesh::C0Polygon::max_n_nodes)
              mooseError("Too many nodes in polygons to extrude it. Max number of the prism "
                         "polyhedral nodes after extrusion: " +
                         std::to_string(libMesh::C0Polygon::max_n_nodes));
            // Make a copy of the original element to use as a side
            auto new_ptr = std::make_shared<libMesh::C0Polygon>(num_sides);
            for (const auto node_i : make_range(elem->n_nodes()))
            {
              // This one will be oriented outwards, it should be OK though, polyhedron code does
              // not mind
              new_ptr->set_node(
                  node_i,
                  mesh->node_ptr(elem->node_ptr(node_i)->id() + (current_layer * orig_nodes)));
            }
            sides.push_back(new_ptr);
            // Form the next horizontal side
            auto translated_side = std::make_shared<libMesh::C0Polygon>(num_sides);
            for (const auto node_i : make_range(elem->n_nodes()))
              translated_side->set_node(node_i,
                                        mesh->node_ptr(elem->node_ptr(node_i)->id() +
                                                       ((current_layer + 1) * orig_nodes)));
            sides.push_back(translated_side);
 
            // Form the vertical sides
            for (const auto side_i : make_range(num_sides))
            {
              // If the side already exists, use that
              std::array<unsigned int, 3> side_key = {
                  current_layer,
                  static_cast<unsigned int>(
                      std::min(elem->node_ptr(side_i)->id(),
                               elem->node_ptr((side_i + 1) % num_sides)->id())),
                  static_cast<unsigned int>(
                      std::max(elem->node_ptr(side_i)->id(),
                               elem->node_ptr((side_i + 1) % num_sides)->id()))};
              if (poly_extruded_sides.count(side_key))
              {
                sides.push_back(poly_extruded_sides[side_key]);
                continue;
              }
 
              // They are all quads, but constructor expects polygons
              auto vert_side = std::make_shared<libMesh::C0Polygon>(4);
              vert_side->set_node(
                  0, mesh->node_ptr(elem->node_ptr(side_i)->id() + (current_layer * orig_nodes)));
              vert_side->set_node(1,
                                  mesh->node_ptr(elem->node_ptr((side_i + 1) % num_sides)->id() +
                                                 (current_layer * orig_nodes)));
              vert_side->set_node(2,
                                  mesh->node_ptr(elem->node_ptr((side_i + 1) % num_sides)->id() +
                                                 ((current_layer + 1) * orig_nodes)));
              vert_side->set_node(3,
                                  mesh->node_ptr(elem->node_ptr(side_i)->id() +
                                                 ((current_layer + 1) * orig_nodes)));
              sides.push_back(vert_side);
 
              poly_extruded_sides.insert(std::make_pair(side_key, vert_side));
            }
            mooseAssert(sides.size() == 2 + num_sides, "Unexpected size of side vector");
 
            // Create the element from the sides, let libMesh figure out the orientation
            std::unique_ptr<libMesh::Node> mid_elem_node;
            new_elem = std::make_unique<libMesh::C0Polyhedron>(sides, mid_elem_node);
            if (mid_elem_node)
            {
#ifdef LIBMESH_ENABLE_UNIQUE_ID
              // Number it at the end for convenience
              // use the element ID to be able to set in parallel
              unsigned int total_new_node_layers = total_num_layers * order;
              unsigned int last_uid = orig_unique_ids + (total_new_node_layers - 1) * orig_elem +
                                      total_new_node_layers * orig_nodes + elem->unique_id();
              mid_elem_node->set_unique_id(last_uid);
              has_poly_midnodes = true;
#endif
              mesh->add_node(std::move(mid_elem_node));
            }
 
            break;
          }
          default:
            mooseError("Extrusion is not implemented for element type " + Moose::stringify(etype));
        }
 
        new_elem->set_id(elem->id() + (current_layer * orig_elem));
        new_elem->processor_id() = elem->processor_id();
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
        // Let's give the base of the extruded mesh the same
        // unique_ids as the source mesh, in case anyone finds that
        // a useful map to preserve.
        const unique_id_type uid = (current_layer == 0)
                                       ? elem->unique_id()
                                       : orig_unique_ids +
                                             (current_layer - 1) * (orig_elem + orig_nodes) +
                                             orig_nodes + elem->id();
 
        new_elem->set_unique_id(uid);
#endif
 
        // maintain the subdomain_id
        new_elem->subdomain_id() = elem->subdomain_id();
 
        // define upward boundaries
        if (k == num_layers - 1)
        {
          // Identify the side index of the new element that is part of the upward boundary
          const unsigned short top_id =
              new_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
          // Assign sideset id to the side if the element belongs to a specified
          // upward_boundary_source_blocks
          if (_upward_boundary_source_blocks.size() || _upward_boundary_ids.size())
            for (unsigned int i = 0; i < _upward_boundary_source_blocks[e].size(); i++)
              if (new_elem->subdomain_id() == _upward_boundary_source_blocks[e][i])
                boundary_info.add_side(
                    new_elem.get(), is_flipped ? 0 : top_id, _upward_boundary_ids[e][i]);
        }
        // define downward boundaries
        if (k == 0)
        {
          const unsigned short top_id =
              new_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
          if (_downward_boundary_source_blocks.size() || _downward_boundary_ids.size())
            for (unsigned int i = 0; i < _downward_boundary_source_blocks[e].size(); i++)
              if (new_elem->subdomain_id() == _downward_boundary_source_blocks[e][i])
                boundary_info.add_side(
                    new_elem.get(), is_flipped ? top_id : 0, _downward_boundary_ids[e][i]);
        }
 
        // perform subdomain swaps
        if (_subdomain_swap_pairs.size())
        {
          auto & elevation_swap_pairs = _subdomain_swap_pairs[e];
 
          auto new_id_it = elevation_swap_pairs.find(elem->subdomain_id());
 
          if (new_id_it != elevation_swap_pairs.end())
            new_elem->subdomain_id() = new_id_it->second;
        }
 
        Elem * added_elem = mesh->add_elem(std::move(new_elem));
 
        // maintain extra integers
        for (unsigned int i = 0; i < num_extra_elem_integers; i++)
          added_elem->set_extra_integer(i, elem->get_extra_integer(i));
 
        if (_elem_integers_swap_pairs.size())
        {
          for (unsigned int i = 0; i < _elem_integer_indices_to_swap.size(); i++)
          {
            auto & elevation_extra_swap_pairs = _elem_integers_swap_pairs[i * _heights.size() + e];
 
            auto new_extra_id_it = elevation_extra_swap_pairs.find(
                elem->get_extra_integer(_elem_integer_indices_to_swap[i]));
 
            if (new_extra_id_it != elevation_extra_swap_pairs.end())
              added_elem->set_extra_integer(_elem_integer_indices_to_swap[i],
                                            new_extra_id_it->second);
          }
        }
 
        // Copy any old boundary ids on all sides
        for (auto s : elem->side_index_range())
        {
          input_boundary_info.boundary_ids(elem, s, ids_to_copy);
 
          if (added_elem->dim() == 3)
          {
            // For 2D->3D extrusion, we give the boundary IDs
            // for side s on the old element to side s+1 on the
            // new element.  This is just a happy coincidence as
            // far as I can tell...
            if (_boundary_swap_pairs.empty())
              boundary_info.add_side(added_elem, cast_int<unsigned short>(s + 1), ids_to_copy);
            else
              for (const auto & id_to_copy : ids_to_copy)
                boundary_info.add_side(added_elem,
                                       cast_int<unsigned short>(s + 1),
                                       _boundary_swap_pairs[e].count(id_to_copy)
                                           ? _boundary_swap_pairs[e][id_to_copy]
                                           : id_to_copy);
          }
          else
          {
            // For 1D->2D extrusion, the boundary IDs map as:
            // Old elem -> New elem
            // 0        -> 3
            // 1        -> 1
            libmesh_assert_less(s, 2);
            const unsigned short sidemap[2] = {3, 1};
            if (_boundary_swap_pairs.empty())
              boundary_info.add_side(added_elem, sidemap[s], ids_to_copy);
            else
              for (const auto & id_to_copy : ids_to_copy)
                boundary_info.add_side(added_elem,
                                       sidemap[s],
                                       _boundary_swap_pairs[e].count(id_to_copy)
                                           ? _boundary_swap_pairs[e][id_to_copy]
                                           : id_to_copy);
          }
 
          // Add the extruded exterior sides and their nodes to the side boundary
          if (_has_side_boundary && !elem->neighbor_ptr(s))
          {
            const unsigned short new_side =
                added_elem->dim() == 3 ? cast_int<unsigned short>(s + 1) : (s == 0 ? 3 : 1);
            boundary_info.add_side(added_elem, new_side, user_side_boundary_id);
            for (const auto n : added_elem->nodes_on_side(new_side))
              boundary_info.add_node(added_elem->node_ptr(n), user_side_boundary_id);
          }
        }
 
        // Give new boundary ids to bottom and top
        if (current_layer == 0)
        {
          const unsigned short top_id =
              added_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
          if (_has_bottom_boundary)
          {
            mooseAssert(user_bottom_boundary_id != libMesh::BoundaryInfo::invalid_id,
                        "We should have retrieved a proper boundary ID");
            boundary_info.add_side(added_elem, is_flipped ? top_id : 0, user_bottom_boundary_id);
          }
          else
            boundary_info.add_side(added_elem, is_flipped ? top_id : 0, next_side_id);
        }
 
        if (current_layer == total_num_layers - 1)
        {
          // For 2D->3D extrusion, the "top" ID is 1+the original
          // element's number of sides.  For 1D->2D extrusion, the
          // "top" ID is side 2.
          const unsigned short top_id =
              added_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
 
          if (_has_top_boundary)
          {
            mooseAssert(user_top_boundary_id != libMesh::BoundaryInfo::invalid_id,
                        "We should have retrieved a proper boundary ID");
            boundary_info.add_side(added_elem, is_flipped ? 0 : top_id, user_top_boundary_id);
          }
          else
            boundary_info.add_side(
                added_elem, is_flipped ? 0 : top_id, cast_int<boundary_id_type>(next_side_id + 1));
        }
 
        current_layer++;
      }
    }
  }
 
  if (has_polygons && !input->is_serial())
    mooseError("Distributed meshes are not supported when extruding polygons at this time.");
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  // Update the value of next_unique_id based on newly created nodes and elements
  // Note: Number of element layers is one less than number of node layers
  unsigned int total_new_node_layers = total_num_layers * order;
  unsigned int new_unique_ids = orig_unique_ids + (total_new_node_layers - 1) * orig_elem +
                                total_new_node_layers * orig_nodes;
  // Maximum case for the unique ids: all poly elements have a midnode
  if (has_poly_midnodes)
    new_unique_ids += orig_elem;
  mesh->set_next_unique_id(new_unique_ids);
#endif
 
  // Copy all the subdomain/sideset/nodeset name maps to the extruded mesh
  if (!input_subdomain_map.empty())
    mesh->set_subdomain_name_map().insert(input_subdomain_map.begin(), input_subdomain_map.end());
  for (const auto & [subdomain_name, subdomain_id] : new_subdomain_ids)
    mesh->set_subdomain_name(subdomain_id, subdomain_name, true);
  if (!input_sideset_map.empty())
    mesh->get_boundary_info().set_sideset_name_map().insert(input_sideset_map.begin(),
                                                            input_sideset_map.end());
  if (!input_nodeset_map.empty())
    mesh->get_boundary_info().set_nodeset_name_map().insert(input_nodeset_map.begin(),
                                                            input_nodeset_map.end());
 
  for (const auto i : index_range(new_boundary_names))
    boundary_info.sideset_name(new_boundary_ids[i]) = new_boundary_names[i];
  if (_has_side_boundary)
    boundary_info.nodeset_name(user_side_boundary_id) = _side_boundary;
 
  mesh->unset_is_prepared();
  // Creating the layered meshes creates a lot of leftover nodes, notably in the boundary_info,
  // which will crash both paraview and trigger exodiff. Best to be safe.
  if (extruding_quad_eights)
    mesh->prepare_for_use();
 
  return mesh;
}

◆ generateCSG()

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

protectedvirtualinherited

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

Definition at line 537 of file MeshGenerator.C.

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

Referenced by MeshGenerator::generateInternalCSG().

◆ generateData()

void MeshGenerator::generateData ( )

protectedvirtualinherited

Generate the mesh data.

Reimplemented in AddMetaDataGenerator.

Definition at line 530 of file MeshGenerator.C.

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

Referenced by MeshGenerator::generateInternal().

◆ generateInternal()

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

inherited

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

Definition at line 340 of file MeshGenerator.C.

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

◆ generateInternalCSG()

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

inherited

Internal generation method for CSG object generation.

Definition at line 420 of file MeshGenerator.C.

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

◆ getBase()

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

inlineinherited

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

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

InputParameters::getBase

const std::string & getBase() const

Definition InputParameters.C:505

Referenced by MooseBase::uniqueParameterName().

◆ getCheckedPointerParam()

template<typename T >

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

inherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 450 of file MooseBase.h.

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

◆ getChildMeshGenerators()

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

inlineinherited

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 148 of file MeshGenerator.h.

  {
    return _child_mesh_generators;
  }

Referenced by MeshGenerator::isChildMeshGenerator().

◆ getCSGBase()

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

protectedinherited

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

NOTE: You MUST catch this by reference!

Parameters

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

Returns: The CSGBase object generated by that MeshGenerator

Definition at line 253 of file MeshGenerator.C.

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

◆ getCSGBaseByName()

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

protectedinherited

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

NOTE: You MUST catch this by reference!

Parameters

mesh_generator_name The name of the MeshGenerator associated with the CSGBase object

Returns: The CSGBase pointer generated by that MeshGenerator

Definition at line 262 of file MeshGenerator.C.

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

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

◆ getCSGBases()

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

protectedinherited

Like getCSGBase(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters

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

Returns: Vector of CSGBase pointers associated with input parameter

Definition at line 274 of file MeshGenerator.C.

{
  return getCSGBasesByName(getMeshGeneratorNamesFromParam(param_name));
}

◆ getCSGBasesByName()

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

protectedinherited

Like getCSGBaseByName(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters

mesh_generator_names The names of MeshGenerator objects

Returns: Vector of CSGBase pointers associated with input parameter

Definition at line 280 of file MeshGenerator.C.

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

Referenced by MeshGenerator::getCSGBases().

◆ getDataFileName()

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

inherited

Deprecated method.

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

Definition at line 21 of file DataFileInterface.C.

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

◆ getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

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

◆ getDataFilePath()

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

inherited

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

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

Definition at line 40 of file DataFileInterface.C.

{
  // This should only ever be used with relative paths. There is no point to
  // use this search path with an absolute path.
  if (std::filesystem::path(relative_path).is_absolute())
    _parent.mooseWarning("While using getDataFilePath(\"",
                         relative_path,
                         "\"): This API should not be used for absolute paths.");
 
  // This will search the data paths for this relative path
  std::optional<std::string> error;
  Moose::DataFileUtils::Path found_path;
  {
    // Throw on error so that if getPath() fails, we can throw an error
    // with the context of _parent.mooseError()
    Moose::ScopedThrowOnError scoped_throw_on_error;
 
    try
    {
      found_path = Moose::DataFileUtils::getPath(relative_path);
    }
    catch (std::exception & e)
    {
      error = e.what();
    }
  }
 
  if (error)
    _parent.mooseError(*error);
 
  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
              "Should only ever obtain data");
  mooseAssert(found_path.data_name, "Should be set");
 
  const std::string msg =
      "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
  _parent.mooseInfo(msg);
 
  return found_path.path;
}

Referenced by DataFileInterface::getDataFileNameByName().

◆ getHitNode() [1/2]

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

inlineinherited

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

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

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

◆ getHitNode() [2/2]

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

staticprivateinherited

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

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

Definition at line 167 of file MooseBase.C.

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

◆ getMesh()

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

protectedinherited

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

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

Parameters

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

Returns: The Mesh generated by that MeshGenerator

NOTE: You MUST catch this by reference!

Definition at line 216 of file MeshGenerator.C.

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

◆ getMeshByName()

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

protectedinherited

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

NOTE: You MUST catch this by reference!

Returns: The Mesh generated by that MeshGenerator

Definition at line 231 of file MeshGenerator.C.

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

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

◆ getMeshes()

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

protectedinherited

Like getMesh(), but for multiple generators.

Returns: The generated meshes

Definition at line 225 of file MeshGenerator.C.

{
  return getMeshesByName(getMeshGeneratorNamesFromParam(param_name));
}

◆ getMeshesByName()

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

protectedinherited

Like getMeshByName(), but for multiple generators.

Returns: The generated meshes

Definition at line 244 of file MeshGenerator.C.

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

Referenced by MeshGenerator::getMeshes().

◆ getMeshGeneratorNameFromParam()

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

privateinherited

Helper for getting a MeshGeneratorName parameter.

Definition at line 106 of file MeshGenerator.C.

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

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

◆ getMeshGeneratorNamesFromParam()

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

privateinherited

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

Definition at line 135 of file MeshGenerator.C.

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

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

◆ getMeshProperty() [1/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 64 of file MeshMetaDataInterface.h.

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

◆ getMeshProperty() [2/2]

template<typename T >

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

protectedinherited

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

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

Definition at line 142 of file MeshMetaDataInterface.h.

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

◆ getMeshPropertyInternal()

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

privateinherited

Helper for getting a mesh property.

Definition at line 54 of file MeshMetaDataInterface.C.

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

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

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

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

◆ getParam() [1/2]

template<typename T >

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

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 406 of file MooseBase.h.

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

Referenced by CommonOutputAction::act(), CreateDisplacedProblemAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), CylinderComponent::addMeshGenerators(), FEProblemBase::addOutput(), ArrayParsedAux::ArrayParsedAux(), BicubicSplineFunction::BicubicSplineFunction(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), Console::Console(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DiffusionPhysicsBase::DiffusionPhysicsBase(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), MFEMEigenvaluesPostprocessor::execute(), FEProblemSolve::FEProblemSolve(), SurfaceDelaunayGeneratorBase::fillDelaunayOptions(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), ParsedSubdomainGeneratorBase::functionInitialize(), BlockDeletionGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FileMeshGenerator::generate(), MeshExtruderGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), AdvancedOutput::init(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), AdvancedOutput::initAvailableLists(), AttribThread::initFrom(), AttribExecutionOrderGroup::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseVariableBase::MooseVariableBase(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedVectorReporter::ParsedVectorReporter(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), ReferenceResidualInterface::ReferenceResidualInterface(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), PetscOutput::solveSetup(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorOfPostprocessors::VectorOfPostprocessors(), and XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve().

◆ getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

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

Parameters

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

Returns: Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

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

◆ getParentMeshGenerators()

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

inlineinherited

Gets the MeshGenerators that are parents to this MeshGenerator.

Definition at line 141 of file MeshGenerator.h.

  {
    return _parent_mesh_generators;
  }

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

◆ getRenamedParam()

template<typename T >

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

inherited

Retrieve a renamed parameter for the object.

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

Parameters

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

Definition at line 420 of file MooseBase.h.

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

◆ getRequestedMeshGenerators()

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

inlineinherited

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

Definition at line 99 of file MeshGenerator.h.

  {
    return _requested_mesh_generators;
  }

◆ getRequestedMeshGeneratorsForSub()

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

inlineinherited

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

Definition at line 107 of file MeshGenerator.h.

  {
    return _requested_mesh_generators_for_sub;
  }

◆ getSavedMeshName()

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

inherited

Return the name of the saved mesh.

Definition at line 524 of file MeshGenerator.C.

{
  return _save_with_name;
}

◆ getSharedPtr() [1/2]

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

inherited

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

Wrapper around shared_from_this().

Definition at line 70 of file MooseObject.C.

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

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

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 83 of file MooseObject.C.

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

◆ getSubMeshGenerators()

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

inlineinherited

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 155 of file MeshGenerator.h.

  {
    return _sub_mesh_generators;
  }

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

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

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

◆ hasGenerateCSG() [1/2]

bool MeshGenerator::hasGenerateCSG ( ) const

inlineinherited

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

Definition at line 209 of file MeshGenerator.h.

209{ return hasGenerateCSG(_pars); }

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

◆ hasGenerateCSG() [2/2]

bool MeshGenerator::hasGenerateCSG ( const InputParameters & params )

staticinherited

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

Definition at line 100 of file MeshGenerator.C.

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

◆ hasGenerateData() [1/2]

bool MeshGenerator::hasGenerateData ( ) const

inlineinherited

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

Definition at line 204 of file MeshGenerator.h.

204{ return hasGenerateData(_pars); }

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

◆ hasGenerateData() [2/2]

bool MeshGenerator::hasGenerateData ( const InputParameters & params )

staticinherited

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

Definition at line 88 of file MeshGenerator.C.

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

◆ hasMeshProperty() [1/4]

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

inlineprotectedinherited

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

Definition at line 82 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [2/4]

template<typename T >

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

inlineprotectedinherited

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

Definition at line 90 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [3/4]

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

protectedinherited

Returns: Whether or not a mesh meta-data exists.

Definition at line 33 of file MeshMetaDataInterface.C.

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

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

◆ hasMeshProperty() [4/4]

template<typename T >

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

protectedinherited

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

Definition at line 166 of file MeshMetaDataInterface.h.

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

◆ hasOutput()

bool MeshGenerator::hasOutput ( ) const

inherited

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

Definition at line 518 of file MeshGenerator.C.

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

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

◆ hasSaveMesh()

bool MeshGenerator::hasSaveMesh ( ) const

inherited

Return whether or not to save the current mesh.

Definition at line 512 of file MeshGenerator.C.

{
  return _save_with_name.size();
}

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

◆ isChildMeshGenerator()

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

inherited

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

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

Definition at line 491 of file MeshGenerator.C.

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

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder().

◆ isDataOnly()

bool MeshGenerator::isDataOnly ( ) const

inlineinherited

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

Definition at line 214 of file MeshGenerator.h.

214{ return _data_only; }

MeshGenerator::_data_only

const bool _data_only

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

Definition MeshGenerator.h:530

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

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

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

Definition at line 63 of file MooseObject.h.

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

InputParameters::isKokkosObject

bool isKokkosObject() const

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

Definition InputParameters.C:433

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

◆ isNullMeshName()

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

inlineinherited

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

See declareNullMeshName().

Definition at line 184 of file MeshGenerator.h.

184{ return _null_mesh_names.count(name); }

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

◆ isParamSetByUser()

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

inlineinherited

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

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

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

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

InputParameters::isParamValid

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

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

Definition InputParameters.C:386

◆ isParentMeshGenerator()

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

inherited

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

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

Definition at line 478 of file MeshGenerator.C.

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

◆ meshPropertyName() [1/2]

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

inlineprotectedinherited

Returns: The default mesh property name for mesh property data

Definition at line 103 of file MeshMetaDataInterface.h.

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

◆ meshPropertyName() [2/2]

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

staticprotectedinherited

Returns: The full name for mesh property data.

Definition at line 41 of file MeshMetaDataInterface.C.

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

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

◆ meshPropertyPrefix()

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

inlinefinaloverrideprivatevirtualinherited

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

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

Reimplemented from MeshMetaDataInterface.

Definition at line 471 of file MeshGenerator.h.

  {
    return name();
  }

◆ messagePrefix() [1/2]

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

inlineinherited

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

Definition at line 256 of file MooseBase.h.

  {
    return messagePrefix(_pars, hit_prefix);
  }

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

◆ messagePrefix() [2/2]

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

staticprivateinherited

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

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

Definition at line 140 of file MooseBase.C.

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

◆ mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 317 of file MooseBase.h.

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

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

◆ mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

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

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

◆ mooseDeprecatedNoTrace()

template<typename... Args>

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

inlineinherited

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

Definition at line 327 of file MooseBase.h.

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

Referenced by MooseApp::MooseApp().

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Definition at line 277 of file MooseBase.h.

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

◆ mooseError()

template<typename... Args>

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

inlineinherited

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

Definition at line 271 of file MooseBase.h.

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

◆ mooseErrorInternal()

template<typename... Args>

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

inlineprivateinherited

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

Definition at line 132 of file MeshMetaDataInterface.h.

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

Referenced by MeshMetaDataInterface::getMeshProperty().

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 290 of file MooseBase.h.

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

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

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

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

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

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

◆ mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

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

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

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 308 of file MooseBase.h.

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

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

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

◆ name()

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

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 103 of file MooseBase.h.

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

◆ paramError()

template<typename... Args>

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

inherited

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

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

Definition at line 457 of file MooseBase.h.

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

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

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

inherited

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

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

Definition at line 471 of file MooseBase.h.

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

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

◆ paramWarning() [1/2]

template<typename... Args>

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

inherited

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

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

Definition at line 464 of file MooseBase.h.

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

◆ paramWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

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

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

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

If a parameter of the given name and type does not exist or if the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

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

Definition at line 413 of file MooseBase.h.

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

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

◆ radialExpansionRatio()

Real AdvancedExtruderGenerator::radialExpansionRatio ( const Real t ) const

protected

Calculate the share of the radial expansion to apply at the local node This share goes from 0 at the beginning of the extrusion to 1 at the end.

Parameters

t	coordinate along the curve (in the axial direction of extrusion)

Definition at line 1792 of file AdvancedExtruderGenerator.C.

{
  // NOTE: All functions added to this method must obey the following: f(0)=0, f(1)=1 for all t in
  // [0,1].
  switch (_radial_expansion_method)
  {
    case 0:
      return t;
    // Only linear and cubic implemented
    default:
      return (-2. + _start_radial_growth_rate + _end_radial_growth_rate) * MathUtils::pow(t, 3) +
             (3. - (2. * _start_radial_growth_rate + _end_radial_growth_rate)) *
                 MathUtils::pow(t, 2) +
             _start_radial_growth_rate * t;
  }
}

Referenced by generate().

◆ registerInvalidSolutionInternal()

InvalidSolutionID SolutionInvalidInterface::registerInvalidSolutionInternal	(	const std::string &	message,
		const bool	warning
	)		const

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

{
  return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
      _si_moose_base.type(), message, warning);
}

◆ setHasGenerateCSG()

void MeshGenerator::setHasGenerateCSG ( InputParameters & params )

staticinherited

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

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

Definition at line 94 of file MeshGenerator.C.

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

◆ setHasGenerateData()

void MeshGenerator::setHasGenerateData ( InputParameters & params )

staticinherited

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

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

Definition at line 82 of file MeshGenerator.C.

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

Referenced by AddMetaDataGenerator::validParams().

◆ setMeshProperty() [1/2]

template<typename T , typename... Args>

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

protectedinherited

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

Definition at line 565 of file MeshGenerator.h.

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

◆ setMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 251 of file MeshGenerator.h.

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

◆ setMeshPropertyHelper()

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

privateinherited

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

Definition at line 458 of file MeshGenerator.C.

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

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

◆ type()

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

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 93 of file MooseBase.h.

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

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns: The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

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

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

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

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

Definition at line 69 of file MooseBase.C.

{
  if (!_pars.have_parameter<std::string>(unique_name_param))
    mooseError("uniqueName(): Object does not have a unique name");
  return MooseObjectName(_pars.get<std::string>(unique_name_param));
}

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

◆ uniqueParameterName()

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

inherited

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

Definition at line 63 of file MooseBase.C.

{
  return MooseObjectParameterName(getBase(), name(), parameter_name);
}

◆ validParams()

InputParameters AdvancedExtruderGenerator::validParams ( )

static

Definition at line 58 of file AdvancedExtruderGenerator.C.

{
  InputParameters params = MeshGenerator::validParams();
 
  params.addClassDescription(
      "Extrudes a 1D mesh into 2D, or a 2D mesh into 3D, and supports a variable height for each "
      "elevation, variable number of layers within each elevation, variable growth factors of "
      "axial element sizes within each elevation and remap subdomain_ids, boundary_ids and element "
      "extra integers within each elevation as well as interface boundaries between neighboring "
      "elevation layers, as well as following a 1D curve and modifying the radial (normal to "
      "the extrusion axis) extent of the geometry. It can also extrude each node along the "
      "averaged normal of the elements it is connected to, which is useful to create boundary "
      "layers.");
 
  params.addRequiredParam<MeshGeneratorName>("input", "The mesh to extrude");
 
  // User input of extrusion heights / axial discretization
  params.addParam<std::vector<Real>>("heights", {}, "The height of each elevation");
  params.addRangeCheckedParam<std::vector<Real>>(
      "biases", "biases>0.0", "The axial growth factor used for mesh biasing for each elevation.");
  params.addParam<std::vector<unsigned int>>(
      "num_layers",
      {},
      "The number of layers for each elevation - must be num_elevations in length!");
 
  // Swaps on every height
  params.addParam<std::vector<std::vector<SubdomainName>>>(
      "subdomain_swaps",
      {},
      "For each row, every two entries are interpreted as a pair of "
      "'from' and 'to' to remap the subdomains for that elevation. Subdomains may be specified by "
      "name or ID. A 'to' name absent from the input mesh creates a new subdomain");
  params.addParam<std::vector<std::vector<boundary_id_type>>>(
      "boundary_swaps",
      {},
      "For each row, every two entries are interpreted as a pair of "
      "'from' and 'to' to remap the boundaries for that elevation");
  params.addParam<std::vector<std::string>>(
      "elem_integer_names_to_swap",
      {},
      "Array of element extra integer names that need to be swapped during extrusion.");
  params.addParam<std::vector<std::vector<std::vector<dof_id_type>>>>(
      "elem_integers_swaps",
      {},
      "For each row, every two entries are interpreted as a pair of 'from' and 'to' to remap the "
      "element extra integer for that elevation. If multiple element extra integers need to be "
      "swapped, the enties are stacked based on the order provided in "
      "'elem_integer_names_to_swap' to form the third dimension.");
 
  // Direction parameter
  params.addParam<Point>("direction",
                         "A vector that points in the direction to extrude (note, this will be "
                         "normalized internally - so don't worry about it here)");
  params.addParam<MeshGeneratorName>(
      "extrusion_curve",
      "Name of the mesh generator providing the line mesh curve to be extruded along. The "
      "extrusion path follows the node order in the line mesh");
  params.addParam<RealVectorValue>(
      "start_extrusion_direction",
      "A vector that points in the starting direction for extruding along a curve. This vector "
      "should be the tangent vector at the FIRST node of the extrusion curve. Vector will be "
      "normalized in code, so don't worry about it here.");
  params.addParam<RealVectorValue>(
      "end_extrusion_direction",
      "A vector that points in the ending direction for extruding along a curve. This vector "
      "should be the tangent vector at the LAST node of the extrusion curve. Vector will be "
      "normalized in code, so don't worry about it here.");
  params.addParam<bool>(
      "extrude_along_node_normals",
      false,
      "If true, each node is extruded along the averaged normal of the elements it is connected "
      "to, instead of along a fixed 'direction'. Only supported when extruding a 1D mesh in a "
      "plane of constant z into 2D, or a 2D surface mesh into 3D. This is useful to create "
      "boundary layers.");
 
  // Boundaries and interfaces
  params.addParam<BoundaryName>(
      "top_boundary",
      "The boundary name to set on the top boundary. If omitted an ID will be generated.");
  params.addParam<BoundaryName>(
      "bottom_boundary",
      "The boundary name to set on the bottom boundary. If omitted an ID will be generated.");
  params.addParam<BoundaryName>(
      "side_boundary",
      "The boundary name to add the extruded exterior sides of the input mesh, and their nodes, "
      "to. If omitted, no side boundary is added.");
  params.addParam<std::vector<std::vector<subdomain_id_type>>>(
      "upward_boundary_source_blocks", "Block ids used to generate upward interface boundaries.");
  params.addParam<std::vector<std::vector<boundary_id_type>>>("upward_boundary_ids",
                                                              "Upward interface boundary ids.");
  params.addParam<std::vector<std::vector<subdomain_id_type>>>(
      "downward_boundary_source_blocks",
      "Block ids used to generate downward interface boundaries.");
  params.addParam<std::vector<std::vector<boundary_id_type>>>("downward_boundary_ids",
                                                              "Downward interface boundary ids.");
 
  // Radial transformations
  params.addParam<Real>("twist_pitch",
                        0,
                        "Pitch for helicoidal extrusion around an axis going through the origin "
                        "following the direction vector");
  params.addParam<Real>("end_radial_extent",
                        0,
                        "If modifying the radial extent of the extruded geometry, final radial "
                        "extent to reach at the end of the extrusion process");
  MooseEnum radial_growth_methods("linear cubic", "linear");
  params.addParam<MooseEnum>("radial_growth_method",
                             radial_growth_methods,
                             "Functional form to change radius while extruding along curve.");
  params.addParam<Real>("start_radial_growth_rate", 1., "Starting rate of radial expansion.");
  params.addParam<Real>("end_radial_growth_rate", 1., "Ending rate of radial expansion.");
 
  params.addParamNamesToGroup("top_boundary bottom_boundary side_boundary "
                              "upward_boundary_source_blocks upward_boundary_ids "
                              "downward_boundary_source_blocks downward_boundary_ids",
                              "Boundary Assignment");
  params.addParamNamesToGroup(
      "subdomain_swaps boundary_swaps elem_integer_names_to_swap elem_integers_swaps", "ID Swap");
  params.addParamNamesToGroup("extrusion_curve start_extrusion_direction end_extrusion_direction",
                              "Extrusion along curve");
  params.addParamNamesToGroup("twist_pitch end_radial_extent radial_growth_method "
                              "start_radial_growth_rate end_radial_growth_rate",
                              "Radial transformation");
 
  return params;
}

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

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

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

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

◆ _biases

const std::vector<Real> AdvancedExtruderGenerator::_biases

protected

Bias growth factor of each elevation.

Definition at line 36 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _bottom_boundary

const BoundaryName AdvancedExtruderGenerator::_bottom_boundary

protected

Definition at line 83 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _boundary_swap_pairs

std::vector<std::unordered_map<boundary_id_type, boundary_id_type> > AdvancedExtruderGenerator::_boundary_swap_pairs

protected

Easier to work with version of _boundary_swaps.

Definition at line 58 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _boundary_swaps

const std::vector<std::vector<boundary_id_type> >& AdvancedExtruderGenerator::_boundary_swaps

protected

Boundaries to swap out for each elevation.

Definition at line 45 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _child_mesh_generators

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

privateinherited

The MeshGenerators that are children to this MeshGenerator.

Definition at line 519 of file MeshGenerator.h.

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

◆ _console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

◆ _data_only

const bool MeshGenerator::_data_only

privateinherited

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

Definition at line 530 of file MeshGenerator.h.

Referenced by MeshGenerator::isDataOnly().

◆ _direction

Point AdvancedExtruderGenerator::_direction

protected

The direction of the extrusion.

Definition at line 64 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _downward_boundary_ids

const std::vector<std::vector<boundary_id_type> > AdvancedExtruderGenerator::_downward_boundary_ids

protected

Downward boundary interfaces for each layer of elevation.

Definition at line 100 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _downward_boundary_source_blocks

const std::vector<std::vector<subdomain_id_type> > AdvancedExtruderGenerator::_downward_boundary_source_blocks

protected

The list of input mesh's blocks that need to be assigned downward boundary interfaces for each layer of elevation.

Definition at line 97 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _elem_integer_indices_to_swap

std::vector<unsigned int> AdvancedExtruderGenerator::_elem_integer_indices_to_swap

protected

Definition at line 49 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _elem_integer_names_to_swap

const std::vector<std::string>& AdvancedExtruderGenerator::_elem_integer_names_to_swap

protected

Names and indices of extra element integers to swap.

Definition at line 48 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _elem_integers_swap_pairs

std::vector<std::unordered_map<dof_id_type, dof_id_type> > AdvancedExtruderGenerator::_elem_integers_swap_pairs

protected

Easier to work with version of _elem_integers_swaps.

Definition at line 61 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _elem_integers_swaps

const std::vector<std::vector<std::vector<dof_id_type> > >& AdvancedExtruderGenerator::_elem_integers_swaps

protected

Extra element integers to swap out for each elevation and each element interger name.

Definition at line 52 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator().

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _end_extrusion_direction

const RealVectorValue AdvancedExtruderGenerator::_end_extrusion_direction

protected

Extrusion direction for the final layer of the extrusion.

Definition at line 72 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _end_radial_extent

const Real AdvancedExtruderGenerator::_end_radial_extent

protected

Radial extent of the extruded geometry at the end of the extrusion.

Definition at line 107 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _end_radial_growth_rate

const Real AdvancedExtruderGenerator::_end_radial_growth_rate

protected

Derivative of the radial expansion function at the end of the extrusion.

Definition at line 113 of file AdvancedExtruderGenerator.h.

Referenced by radialExpansionRatio().

◆ _extrude_along_curve

bool AdvancedExtruderGenerator::_extrude_along_curve

protected

Whether we are extruding along a curve.

Definition at line 74 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _extrude_along_node_normals

const bool AdvancedExtruderGenerator::_extrude_along_node_normals

protected

Whether to extrude each node along the averaged normal of the elements connected to it.

Definition at line 77 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _extrusion_curve

std::unique_ptr<MeshBase>& AdvancedExtruderGenerator::_extrusion_curve

protected

Curve mesh to extrude along.

Definition at line 68 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

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

◆ _has_bottom_boundary

const bool AdvancedExtruderGenerator::_has_bottom_boundary

protected

Definition at line 82 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _has_side_boundary

const bool AdvancedExtruderGenerator::_has_side_boundary

protected

Whether to add the lateral exterior sides (and their nodes) to a boundary.

Definition at line 86 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _has_top_boundary

const bool AdvancedExtruderGenerator::_has_top_boundary

protected

Definition at line 79 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _heights

const std::vector<Real>& AdvancedExtruderGenerator::_heights

protected

Height of each elevation.

Definition at line 33 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _input

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

protected

Mesh that comes from another generator.

Definition at line 30 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _mesh

MooseMesh* const MeshGenerator::_mesh

protectedinherited

Pointer to the owning mesh.

Definition at line 462 of file MeshGenerator.h.

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

◆ _meta_data_app

MooseApp& MeshMetaDataInterface::_meta_data_app

privateinherited

Reference to the application.

Definition at line 122 of file MeshMetaDataInterface.h.

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

◆ _meta_data_object

const MooseObject* const MeshMetaDataInterface::_meta_data_object

privateinherited

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

Definition at line 125 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::mooseErrorInternal().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _null_csg_base

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

privateinherited

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

Definition at line 514 of file MeshGenerator.h.

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

◆ _null_mesh

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

privateinherited

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

Definition at line 511 of file MeshGenerator.h.

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

◆ _null_mesh_names

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

privateinherited

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

Definition at line 524 of file MeshGenerator.h.

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

◆ _num_layers

const std::vector<unsigned int>& AdvancedExtruderGenerator::_num_layers

protected

Number of layers in each elevation.

Definition at line 39 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

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

◆ _parent_mesh_generators

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

privateinherited

The MeshGenerators that are parents to this MeshGenerator.

Definition at line 517 of file MeshGenerator.h.

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

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseApp::MooseApp(), MooseBase::MooseBase(), MultiSystemSolveObject::MultiSystemSolveObject(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseBase::queryParam(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

◆ _radial_expansion_method

const MooseEnum AdvancedExtruderGenerator::_radial_expansion_method

protected

Function type for modifying the radial extent of the extruded shape.

Definition at line 109 of file AdvancedExtruderGenerator.h.

Referenced by radialExpansionRatio().

◆ _requested_csg_bases

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

privateinherited

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

Definition at line 508 of file MeshGenerator.h.

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

◆ _requested_mesh_generators

std::set<MeshGeneratorName> MeshGenerator::_requested_mesh_generators

privateinherited

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

Definition at line 500 of file MeshGenerator.h.

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

◆ _requested_mesh_generators_for_sub

std::set<MeshGeneratorName> MeshGenerator::_requested_mesh_generators_for_sub

privateinherited

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

Definition at line 502 of file MeshGenerator.h.

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

◆ _requested_meshes

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

privateinherited

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

Definition at line 505 of file MeshGenerator.h.

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

◆ _save_with_name

const std::string& MeshGenerator::_save_with_name

privateinherited

A user-defined name to save the mesh.

Definition at line 527 of file MeshGenerator.h.

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

◆ _si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base

privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal(), SolutionInvalidInterface::mooseDeprecated(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), SolutionInvalidInterface::paramWarning(), and SolutionInvalidInterface::registerInvalidSolutionInternal().

◆ _si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem

privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ _side_boundary

const BoundaryName AdvancedExtruderGenerator::_side_boundary

protected

Boundary for the lateral exterior sides and their nodes.

Definition at line 88 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _start_extrusion_direction

const RealVectorValue AdvancedExtruderGenerator::_start_extrusion_direction

protected

Extrusion direction to follow at the start (first layer) of the extrusion.

Definition at line 70 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _start_radial_growth_rate

const Real AdvancedExtruderGenerator::_start_radial_growth_rate

protected

Derivative of the radial expansion function at the beginning of the extrusion.

Definition at line 111 of file AdvancedExtruderGenerator.h.

Referenced by radialExpansionRatio().

◆ _sub_mesh_generators

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

privateinherited

The sub MeshGenerators constructed by this MeshGenerator.

Definition at line 521 of file MeshGenerator.h.

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

◆ _subdomain_swap_pairs

std::vector<std::unordered_map<subdomain_id_type, subdomain_id_type> > AdvancedExtruderGenerator::_subdomain_swap_pairs

protected

Easier to work with version of _sudomain_swaps.

Definition at line 55 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _subdomain_swaps

const std::vector<std::vector<SubdomainName> >& AdvancedExtruderGenerator::_subdomain_swaps

protected

Subdomains to swap out for each elevation.

Definition at line 42 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _top_boundary

const BoundaryName AdvancedExtruderGenerator::_top_boundary

protected

Definition at line 80 of file AdvancedExtruderGenerator.h.

Referenced by generate().

◆ _twist_pitch

const Real AdvancedExtruderGenerator::_twist_pitch

protected

Axial pitch for a full rotation.

Definition at line 103 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), FEProblemBase::solverTypeString(), and MooseBase::type().

◆ _upward_boundary_ids

const std::vector<std::vector<boundary_id_type> > AdvancedExtruderGenerator::_upward_boundary_ids

protected

Upward boundary interfaces for each layer of elevation.

Definition at line 94 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ _upward_boundary_source_blocks

const std::vector<std::vector<subdomain_id_type> > AdvancedExtruderGenerator::_upward_boundary_source_blocks

protected

The list of input mesh's blocks that need to be assigned upward boundary interfaces for each layer of elevation.

Definition at line 91 of file AdvancedExtruderGenerator.h.

Referenced by AdvancedExtruderGenerator(), and generate().

◆ app_param

const std::string MooseBase::app_param = "_moose_app"

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), ActionFactory::getValidParams(), Factory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ data_only_param

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

staticinherited

The name of the private parameter for setting data only.

Definition at line 76 of file MeshGenerator.h.

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

◆ kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"

staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"

staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

◆ NAME

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

staticconstexprinherited

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

Definition at line 33 of file MeshMetaDataInterface.h.

◆ name_param

const std::string MooseBase::name_param = "_object_name"

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

◆ SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"

staticconstexprinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().

◆ type_param

const std::string MooseBase::type_param = "_type"

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

◆ unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"

staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

◆ usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings

inherited

Definition at line 67 of file MooseObject.h.

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

include/meshgenerators/AdvancedExtruderGenerator.h
src/meshgenerators/AdvancedExtruderGenerator.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ AdvancedExtruderGenerator()

Member Function Documentation

◆ addChildMeshGenerator()

◆ addMeshSubgenerator() [1/2]

◆ addMeshSubgenerator() [2/2]

◆ addParentMeshGenerator()

◆ buildDistributedMesh()

◆ buildMeshBaseObject()

◆ buildReplicatedMesh()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ checkGetMesh()

◆ computeNodeNormals()

◆ connectControllableParams()

◆ copyMeshProperty() [1/2]

◆ copyMeshProperty() [2/2]

◆ declareMeshesForSub()

◆ declareMeshesForSubByName()

◆ declareMeshForSub()

◆ declareMeshForSubByName()

◆ declareMeshProperty() [1/2]

◆ declareMeshProperty() [2/2]

◆ declareNullMeshName()

◆ enabled()

◆ errorPrefix()

◆ flagInvalidSolutionInternal()

◆ generate()

◆ generateCSG()

◆ generateData()

◆ generateInternal()

◆ generateInternalCSG()

◆ getBase()

◆ getCheckedPointerParam()

◆ getChildMeshGenerators()

◆ getCSGBase()

◆ getCSGBaseByName()

◆ getCSGBases()

◆ getCSGBasesByName()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getHitNode() [1/2]

◆ getHitNode() [2/2]

◆ getMesh()

◆ getMeshByName()

◆ getMeshes()

◆ getMeshesByName()

◆ getMeshGeneratorNameFromParam()

◆ getMeshGeneratorNamesFromParam()

◆ getMeshProperty() [1/2]

◆ getMeshProperty() [2/2]

◆ getMeshPropertyInternal()

◆ getMooseApp()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getParentMeshGenerators()

◆ getRenamedParam()

◆ getRequestedMeshGenerators()

◆ getRequestedMeshGeneratorsForSub()

◆ getSavedMeshName()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ getSubMeshGenerators()

◆ hasBase()

◆ hasGenerateCSG() [1/2]