Generates a triangulation in the XY plane, based on an input mesh defining the outer boundary (as well as explicitly required interior Steiner points) and an optional set of input meshes defining inner hole boundaries. More...

#include <XYDelaunayGenerator.h>

Inheritance diagram for XYDelaunayGenerator:

[legend]

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

Public Member Functions
	XYDelaunayGenerator (const InputParameters &parameters)

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

bool	hasGenerateData () const

bool	hasGenerateCSG () const

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

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

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

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

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

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

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

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

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

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

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

bool	isNullMeshName (const MeshGeneratorName &name) const

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

bool	hasOutput () const

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

bool	isDataOnly () const

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

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

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

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

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

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

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

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

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

MooseObjectName	uniqueName () const

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

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

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

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

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

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

template<typename T >
bool	haveParameter (const std::string &name) const
	Test if a parameter of the given name and type exists. More...

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

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

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

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

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

template<typename... Args>
void	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. More...

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

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

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

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

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

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

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

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

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

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

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

Static Public Member Functions
static InputParameters	validParams ()

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

static bool	hasGenerateData (const InputParameters &params)

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

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

Public Attributes
	usingCombinedWarningSolutionWarnings

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

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

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

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

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

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

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

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

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

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

Protected Member Functions
Point	elemNormal (const Elem &elem)
	Calculate the normal vector of a 2D element based the first three vertices. More...

Point	meshNormal2D (const MeshBase &mesh)
	Calculate the average normal vector of a 2D mesh based on the normal vectors of its elements using the element areas as weights. More...

Real	meshNormalDeviation2D (const MeshBase &mesh, const Point &global_norm)
	Calculate the maximum deviation of the normal vectors in a given mesh from a global average normal vector. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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

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

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

Protected Attributes
std::unique_ptr< MeshBase > &	_bdy_ptr
	Input mesh defining the boundary to triangulate within. More...

const unsigned int	_add_nodes_per_boundary_segment
	How many more nodes to add in each outer boundary segment. More...

const bool	_refine_bdy
	Whether to allow automatically refining the outer boundary. More...

SubdomainID	_output_subdomain_id
	What subdomain_id to set on the generated triangles. More...

const bool	_smooth_tri
	Whether to do Laplacian mesh smoothing on the generated triangles. More...

const bool	_verify_holes
	Whether to verify holes do not intersect boundary or each other. More...

const std::vector< std::unique_ptr< MeshBase > * >	_hole_ptrs
	Holds pointers to the pointers to input meshes defining holes. More...

const std::vector< bool >	_stitch_holes
	Whether to stitch to the mesh defining each hole. More...

const std::vector< bool >	_refine_holes
	Whether to allow automatically refining each hole boundary. More...

const Real	_desired_area
	Desired (maximum) triangle area. More...

const std::string	_desired_area_func
	Desired triangle area as a (fparser-compatible) function of x,y. More...

const MooseEnum	_algorithm
	Type of algorithm used to find matching nodes (binary or exhaustive) More...

const MooseEnum	_tri_elem_type
	Type of triangular elements to be generated. More...

const bool	_verbose_stitching
	Whether mesh stitching should have verbose output. More...

std::vector< Point >	_interior_points
	Desired interior node locations. More...

const Real	_outer_boundary_layer_thickness
	Thickness of an optional boundary-layer ring grown inward from the outer boundary. More...

const unsigned int	_outer_boundary_layer_num
	Number of element layers in the outer boundary-layer ring. More...

const Real	_outer_boundary_layer_bias
	Bias factor for the layer thicknesses in the outer boundary-layer ring. More...

const std::vector< Real >	_holes_boundary_layer_thickness
	Per-hole boundary-layer ring thicknesses (grown outward from each hole) More...

const std::vector< unsigned int >	_holes_boundary_layer_num
	Per-hole boundary-layer ring layer counts. More...

const std::vector< Real >	_holes_boundary_layer_bias
	Per-hole boundary-layer ring bias factors. More...

const bool	_use_auto_area_func
	Whether to use automatic desired area function. More...

const Real	_auto_area_func_default_size
	Background size for automatic desired area function. More...

const Real	_auto_area_func_default_size_dist
	Background size's effective distance for automatic desired area function. More...

const unsigned int	_auto_area_function_num_points
	Maximum number of points to use for the inverse distance interpolation for automatic area function. More...

const Real	_auto_area_function_power
	Power of the polynomial used in the inverse distance interpolation for automatic area function. More...

const Real	_max_angle_deviation
	Max angle deviation from the global average normal vector in the input mesh. More...

const bool	_verbose
	Whether the generator should be verbose. More...

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

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

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

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

ActionFactory &	_action_factory
	Builds Actions. More...

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

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

const InputParameters &	_pars
	The object's parameters. More...

const Parallel::Communicator &	_communicator

Detailed Description

Generates a triangulation in the XY plane, based on an input mesh defining the outer boundary (as well as explicitly required interior Steiner points) and an optional set of input meshes defining inner hole boundaries.

Definition at line 20 of file XYDelaunayGenerator.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

◆ XYDelaunayGenerator()

XYDelaunayGenerator::XYDelaunayGenerator ( const InputParameters & parameters )

Definition at line 135 of file XYDelaunayGenerator.C.

   : SurfaceDelaunayGeneratorBase(parameters),
     _bdy_ptr(getMesh("boundary")),
     _add_nodes_per_boundary_segment(getParam<unsigned int>("add_nodes_per_boundary_segment")),
     _refine_bdy(getParam<bool>("refine_boundary")),
     _output_subdomain_id(0),
     _smooth_tri(getParam<bool>("smooth_triangulation")),
     _verify_holes(getParam<bool>("verify_holes")),
     _hole_ptrs(getMeshes("holes")),
     _stitch_holes(getParam<std::vector<bool>>("stitch_holes")),
     _refine_holes(getParam<std::vector<bool>>("refine_holes")),
     _desired_area(getParam<Real>("desired_area")),
     _desired_area_func(getParam<std::string>("desired_area_func")),
     _algorithm(parameters.get<MooseEnum>("algorithm")),
     _tri_elem_type(parameters.get<MooseEnum>("tri_element_type")),
     _verbose_stitching(parameters.get<bool>("verbose_stitching")),
     _interior_points(getParam<std::vector<Point>>("interior_points")),
     _outer_boundary_layer_thickness(getParam<Real>("outer_boundary_layer_thickness")),
     _outer_boundary_layer_num(getParam<unsigned int>("outer_boundary_layer_num")),
     _outer_boundary_layer_bias(getParam<Real>("outer_boundary_layer_bias")),
     _holes_boundary_layer_thickness(
         isParamValid("holes_boundary_layer_thickness")
             ? getParam<std::vector<Real>>("holes_boundary_layer_thickness")
             : std::vector<Real>()),
     _holes_boundary_layer_num(isParamValid("holes_boundary_layer_num")
                                   ? getParam<std::vector<unsigned int>>("holes_boundary_layer_num")
                                   : std::vector<unsigned int>()),
     _holes_boundary_layer_bias(isParamValid("holes_boundary_layer_bias")
                                    ? getParam<std::vector<Real>>("holes_boundary_layer_bias")
                                    : std::vector<Real>())
 {
   if ((_desired_area > 0.0 && !_desired_area_func.empty()) ||
       (_desired_area > 0.0 && _use_auto_area_func) ||
       (!_desired_area_func.empty() && _use_auto_area_func))
     paramError("desired_area_func",
                "Only one of the three methods ('desired_area', 'desired_area_func', and "
                "'_use_auto_area_func') to set element area limit should be used.");
 
   if (!_use_auto_area_func)
     if (isParamSetByUser("auto_area_func_default_size") ||
         isParamSetByUser("auto_area_func_default_size_dist") ||
         isParamSetByUser("auto_area_function_num_points") ||
         isParamSetByUser("auto_area_function_power"))
       paramError("use_auto_area_func",
                  "If this parameter is set to false, the following parameters should not be set: "
                  "'auto_area_func_default_size', 'auto_area_func_default_size_dist', "
                  "'auto_area_function_num_points', 'auto_area_function_power'.");
 
   if (!_stitch_holes.empty() && _stitch_holes.size() != _hole_ptrs.size())
     paramError("stitch_holes", "Need one stitch_holes entry per hole, if specified.");
 
   for (auto hole_i : index_range(_stitch_holes))
     if (_stitch_holes[hole_i] && (hole_i >= _refine_holes.size() || _refine_holes[hole_i]))
       paramError("refine_holes", "Disable auto refine of any hole boundary to be stitched.");
 
   if (isParamValid("hole_boundaries"))
   {
     auto & hole_boundaries = getParam<std::vector<BoundaryName>>("hole_boundaries");
     if (hole_boundaries.size() != _hole_ptrs.size())
       paramError("hole_boundaries", "Need one hole_boundaries entry per hole, if specified.");
   }
   // Copied from MultiApp.C
   const auto & positions_files = getParam<std::vector<FileName>>("interior_point_files");
   for (const auto p_file_it : index_range(positions_files))
   {
     const std::string positions_file = positions_files[p_file_it];
     MooseUtils::DelimitedFileReader file(positions_file, &_communicator);
     file.setFormatFlag(MooseUtils::DelimitedFileReader::FormatFlag::ROWS);
     file.read();
 
     const std::vector<Point> & data = file.getDataAsPoints();
     for (const auto & d : data)
       _interior_points.push_back(d);
   }
   bool has_duplicates =
       std::any_of(_interior_points.begin(),
                   _interior_points.end(),
                   [&](const Point & p)
                   { return std::count(_interior_points.begin(), _interior_points.end(), p) > 1; });
   if (has_duplicates)
     paramError("interior_points", "Duplicate points were found in the provided interior points.");
 
   if ((_outer_boundary_layer_thickness > 0 && _outer_boundary_layer_num == 0) ||
       (_outer_boundary_layer_thickness == 0 && _outer_boundary_layer_num > 0))
     paramError(
         "outer_boundary_layer_thickness",
         "this parameter must be set as non-zero along with a non-zero outer_boundary_layer_num.");
 
   if (_outer_boundary_layer_num > 0)
   {
     if (_add_nodes_per_boundary_segment)
       paramError("add_nodes_per_boundary_segment",
                  "Cannot add nodes per boundary segment when using an outer boundary layer.");
     if (_refine_bdy)
       paramError("refine_boundary", "Cannot refine boundary when using an outer boundary layer.");
   }
 
   if ((_holes_boundary_layer_thickness.size() && _holes_boundary_layer_num.size() &&
        _holes_boundary_layer_bias.size()) !=
       (_holes_boundary_layer_thickness.size() || _holes_boundary_layer_num.size() ||
        _holes_boundary_layer_bias.size()))
     paramError("holes_boundary_layer_num",
                "holes_boundary_layer_thickness, holes_boundary_layer_bias and this parameter must "
                "be specified or not specified together.");
   if (_holes_boundary_layer_thickness.size() &&
       _holes_boundary_layer_thickness.size() != _hole_ptrs.size())
     paramError("holes_boundary_layer_thickness",
                "If specified, this parameter must have the same length as 'holes'.");
   if (_holes_boundary_layer_num.size() && _holes_boundary_layer_num.size() != _hole_ptrs.size())
     paramError("holes_boundary_layer_num",
                "If specified, this parameter must have the same length as 'holes'.");
   if (_holes_boundary_layer_bias.size() && _holes_boundary_layer_bias.size() != _hole_ptrs.size())
     paramError("holes_boundary_layer_bias",
                "If specified, this parameter must have the same length as 'holes'.");
   for (const auto & i : index_range(_holes_boundary_layer_thickness))
   {
     if ((_holes_boundary_layer_thickness[i] > 0 && _holes_boundary_layer_num[i] == 0) ||
         (_holes_boundary_layer_thickness[i] == 0 && _holes_boundary_layer_num[i] > 0))
       paramError(
           "holes_boundary_layer_thickness",
           "entry " + std::to_string(i) +
               " must be set as non-zero along with a non-zero holes_boundary_layer_num entry.");
     if (_holes_boundary_layer_thickness[i] > 0)
     {
       if ((_refine_holes.size() > i && _refine_holes[i]) || _refine_holes.empty())
         paramError("refine_holes", "Cannot refine hole boundary when using a hole boundary layer.");
     }
   }
 }

Member Function Documentation

◆ addChildMeshGenerator()

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

inherited

Adds the MeshGenerator mg as a child.

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

Definition at line 441 of file MeshGenerator.C.

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

◆ addMeshSubgenerator() [1/2]

template<typename... Ts>

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

protectedinherited

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

Parameters

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

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

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

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

Definition at line 593 of file MeshGenerator.h.

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

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

◆ addMeshSubgenerator() [2/2]

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

protectedinherited

Construct a "subgenerator", as above.

User code is responsible for constructing valid InputParameters.

Parameters

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

Definition at line 410 of file MeshGenerator.C.

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

◆ addParentMeshGenerator()

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

inherited

Adds the MeshGenerator mg as a parent.

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

Definition at line 434 of file MeshGenerator.C.

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

◆ buildDistributedMesh()

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

protectedinherited

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

Parameters

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

Definition at line 303 of file MeshGenerator.C.

Referenced by DistributedRectilinearMeshGenerator::generate().

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

◆ buildMeshBaseObject()

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

protectedinherited

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

Parameters

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

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

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

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

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

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

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

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

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

◆ copyMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

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

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

Definition at line 276 of file MeshGenerator.h.

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

◆ declareMeshesForSub()

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

protectedinherited

Like declareMeshForSub(), but for multiple generators.

Definition at line 265 of file MeshGenerator.C.

 {
   declareMeshesForSubByName(getMeshGeneratorNamesFromParam(param_name));
 }

◆ declareMeshesForSubByName()

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

protectedinherited

Like declareMeshForSubByName(), but for multiple generators.

Definition at line 281 of file MeshGenerator.C.

Referenced by MeshGenerator::declareMeshesForSub().

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

◆ declareMeshForSub()

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

protectedinherited

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

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

Definition at line 259 of file MeshGenerator.C.

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

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

◆ declareMeshForSubByName()

void MeshGenerator::declareMeshForSubByName ( const MeshGeneratorName & mesh_generator_name )

protectedinherited

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

Definition at line 271 of file MeshGenerator.C.

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

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

◆ declareMeshProperty() [1/2]

template<typename T , typename... Args>

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

protectedinherited

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

Definition at line 535 of file MeshGenerator.h.

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

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

◆ declareMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 236 of file MeshGenerator.h.

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

◆ declareNullMeshName()

void MeshGenerator::declareNullMeshName ( const MeshGeneratorName & name )

protectedinherited

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

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

Definition at line 474 of file MeshGenerator.C.

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

◆ elemNormal()

Point SurfaceDelaunayGeneratorBase::elemNormal ( const Elem & elem )

protectedinherited

Calculate the normal vector of a 2D element based the first three vertices.

Parameters

elem	The element for which the normal vector is to be calculated

Returns: the normal vector of the 2D element

Definition at line 71 of file SurfaceDelaunayGeneratorBase.C.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), SurfaceDelaunayGeneratorBase::meshNormal2D(), and SurfaceDelaunayGeneratorBase::meshNormalDeviation2D().

 {
   mooseAssert(elem.n_vertices() == 3 || elem.n_vertices() == 4, "unsupported element type.");
   // Only the first three vertices are used to calculate the normal vector
   const Point & p0 = *elem.node_ptr(0);
   const Point & p1 = *elem.node_ptr(1);
   const Point & p2 = *elem.node_ptr(2);
 
   if (elem.n_vertices() == 4)
   {
     const Point & p3 = *elem.node_ptr(3);
     return ((p2 - p0).cross(p3 - p1)).unit();
   }
 
   return ((p2 - p1).cross(p0 - p1)).unit();
 }

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

Referenced by EigenKernel::enabled().

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

◆ errorPrefix()

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

inlineinherited

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

Definition at line 274 of file MooseBase.h.

274 { return messagePrefix(); }

MooseBase::messagePrefix

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

Definition: MooseBase.h:266

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

overridevirtual

Generate / modify the mesh.

Implements SurfaceDelaunayGeneratorBase.

Definition at line 266 of file XYDelaunayGenerator.C.

 {
   MeshTriangulationUtils::XYDelaunayOptions xyd_opts;
   if (isParamValid("input_boundary_names"))
     xyd_opts.input_boundary_names = getParam<std::vector<BoundaryName>>("input_boundary_names");
   if (isParamValid("input_subdomain_names"))
     xyd_opts.input_subdomain_names = getParam<std::vector<SubdomainName>>("input_subdomain_names");
   xyd_opts.add_nodes_per_boundary_segment = _add_nodes_per_boundary_segment;
   xyd_opts.refine_bdy = _refine_bdy;
   xyd_opts.verify_holes = _verify_holes;
   xyd_opts.smooth_tri = _smooth_tri;
   xyd_opts.desired_area = _desired_area;
   xyd_opts.desired_area_func = _desired_area_func;
   xyd_opts.use_auto_area_func = _use_auto_area_func;
   xyd_opts.auto_area_func_default_size = _auto_area_func_default_size;
   xyd_opts.auto_area_func_default_size_dist = _auto_area_func_default_size_dist;
   xyd_opts.auto_area_function_num_points = _auto_area_function_num_points;
   xyd_opts.auto_area_function_power = _auto_area_function_power;
   xyd_opts.interior_points = _interior_points;
   xyd_opts.tri_elem_type = std::string(_tri_elem_type);
   xyd_opts.stitch_holes = _stitch_holes;
   xyd_opts.refine_holes = _refine_holes;
   xyd_opts.use_binary_search = (_algorithm == "BINARY");
   xyd_opts.verbose_stitching = _verbose_stitching;
   if (isParamValid("output_subdomain_id"))
   {
     xyd_opts.has_output_subdomain_id = true;
     xyd_opts.output_subdomain_id = getParam<SubdomainID>("output_subdomain_id");
   }
   if (isParamValid("output_subdomain_name"))
   {
     xyd_opts.has_output_subdomain_name = true;
     xyd_opts.output_subdomain_name = getParam<SubdomainName>("output_subdomain_name");
   }
   if (isParamValid("output_boundary"))
   {
     xyd_opts.has_output_boundary = true;
     xyd_opts.output_boundary = getParam<BoundaryName>("output_boundary");
   }
   if (isParamValid("hole_boundaries"))
     xyd_opts.hole_boundaries = getParam<std::vector<BoundaryName>>("hole_boundaries");
 
   std::vector<std::unique_ptr<MeshBase>> hole_meshes(_hole_ptrs.size());
   for (auto hole_i : index_range(_hole_ptrs))
     hole_meshes[hole_i] = std::move(*_hole_ptrs[hole_i]);
 
   std::unique_ptr<MeshBase> boundary_mesh = std::move(_bdy_ptr);
 
   // Preserve the user-facing output_boundary so we can restore it after the outer-ring stitch-back
   // (we'll temporarily replace it with a sentinel name to locate the seam).
   const bool user_has_output_boundary = xyd_opts.has_output_boundary;
   const BoundaryName user_output_boundary = xyd_opts.output_boundary;
   const BoundaryName tmp_outer_name("__xyd_bdry_layer_tmp_outer__");
 
   const bool using_outer_layer = (_outer_boundary_layer_num > 0);
   const SubdomainID layer_sd_id =
       xyd_opts.has_output_subdomain_id ? xyd_opts.output_subdomain_id : SubdomainID(0);
   const SubdomainName layer_sd_name =
       xyd_opts.has_output_subdomain_name ? xyd_opts.output_subdomain_name : SubdomainName();
 
   // Build outer boundary-layer ring if requested. The ring's innermost side (bcid 1) becomes the
   // outer constraint for the interior triangulation; we then stitch a clone of the ring back onto
   // the result at that seam.
   std::unique_ptr<MeshBase> outer_ring_clone;
   if (using_outer_layer)
   {
     auto outer_ring = BoundaryLayerUtils::buildBoundaryLayerRing(*this,
                                                                  *boundary_mesh,
                                                                  xyd_opts.input_boundary_names,
                                                                  _outer_boundary_layer_num,
                                                                  _outer_boundary_layer_thickness,
                                                                  _outer_boundary_layer_bias,
                                                                  /*outward=*/false,
                                                                  _tri_elem_type,
                                                                  layer_sd_id,
                                                                  layer_sd_name);
     outer_ring_clone = outer_ring->clone();
     boundary_mesh = std::move(outer_ring);
     xyd_opts.input_boundary_names = {BoundaryName("1")};
     xyd_opts.has_output_boundary = true;
     xyd_opts.output_boundary = tmp_outer_name;
   }
 
   // Build hole boundary-layer rings if requested. Each ring is stitched into the result by the
   // standard hole-stitching path in triangulateWithDelaunay (with stitch_holes forced true).
   for (auto hole_i : index_range(_hole_ptrs))
   {
     if (hole_i < _holes_boundary_layer_num.size() && _holes_boundary_layer_num[hole_i] > 0)
     {
       const bool keep_input = (hole_i < _stitch_holes.size() && _stitch_holes[hole_i]);
       auto hole_ring =
           BoundaryLayerUtils::buildBoundaryLayerRing(*this,
                                                      *hole_meshes[hole_i],
                                                      std::vector<BoundaryName>(),
                                                      _holes_boundary_layer_num[hole_i],
                                                      _holes_boundary_layer_thickness[hole_i],
                                                      _holes_boundary_layer_bias[hole_i],
                                                      /*outward=*/true,
                                                      _tri_elem_type,
                                                      layer_sd_id,
                                                      layer_sd_name);
 
       if (keep_input)
       {
         // Stitch the original hole mesh into the ring at ring's innermost side (bcid 1).
         auto & ring_u = dynamic_cast<UnstructuredMesh &>(*hole_ring);
         auto & inp_u = dynamic_cast<UnstructuredMesh &>(*hole_meshes[hole_i]);
         libMesh::MeshSerializer s1(ring_u), s2(inp_u);
         if (!ring_u.is_prepared())
           ring_u.prepare_for_use();
         if (!inp_u.is_prepared())
           inp_u.prepare_for_use();
         // Renumber input mesh boundary ids so they don't overlap with the ring's, mirroring the
         // approach in StitchMeshGenerator. This avoids degenerate stitching when both meshes
         // contain the same bcids on different sides.
         const auto & ring_bids = ring_u.get_boundary_info().get_global_boundary_ids();
         const auto inp_bids = inp_u.get_boundary_info().get_global_boundary_ids();
         const auto max_bid = std::max(*ring_bids.rbegin(),
                                       inp_bids.empty() ? boundary_id_type(0) : *inp_bids.rbegin());
         BoundaryID ext_id = 1;
         bool overlap = false;
         for (auto b : inp_bids)
           if (ring_bids.count(b))
             overlap = true;
         if (overlap)
         {
           BoundaryID idx = 1;
           for (auto b : inp_bids)
           {
             const auto new_b = max_bid + (idx++);
             inp_u.get_boundary_info().renumber_id(b, new_b);
           }
           ext_id = max_bid + idx;
         }
         else
           ext_id = max_bid + 1;
         inp_u.comm().max(ext_id);
         bool has_ext = false;
         MooseMeshUtils::addExternalBoundary(inp_u, ext_id, has_ext);
         mooseAssert(has_ext, "A 2D-XY mesh should have an external boundary.");
         const auto ring_u_ext_id =
             std::max(MooseMeshUtils::getNextFreeBoundaryID(ring_u), BoundaryID(ext_id + 1));
         MooseMeshUtils::changeBoundaryId(ring_u, 1, ring_u_ext_id, false);
         if (xyd_opts.hole_boundary_inner_id_defaults.size() <= hole_i)
           xyd_opts.hole_boundary_inner_id_defaults.resize(_hole_ptrs.size());
         xyd_opts.hole_boundary_inner_id_defaults[hole_i] = {ring_u_ext_id};
         // we want to keep the ring's original inner bcid (1) for later use.
         ring_u.stitch_meshes(inp_u,
                              1,
                              ext_id,
                              TOLERANCE,
                              /*clear_stitched_bcids=*/true,
                              _verbose_stitching,
                              _algorithm == "BINARY",
                              /*enforce_all_nodes_match_on_boundaries=*/false,
                              /*merge_boundary_nodes_all_or_nothing=*/false,
                              /*remap_subdomain_ids=*/false);
       }
 
       hole_meshes[hole_i] = std::move(hole_ring);
       if (xyd_opts.stitch_holes.size() <= hole_i)
         xyd_opts.stitch_holes.resize(_hole_ptrs.size(), false);
       xyd_opts.stitch_holes[hole_i] = true;
       // The ring presents multiple external manifolds; tell triangulateWithDelaunay to use the
       // outermost (bcid (num_layers - 1) * 2) as the hole's outer boundary.
       if (xyd_opts.hole_boundary_id_filters.size() <= hole_i)
         xyd_opts.hole_boundary_id_filters.resize(_hole_ptrs.size());
       xyd_opts.hole_boundary_id_filters[hole_i] = {
           std::size_t((_holes_boundary_layer_num[hole_i] - 1) * 2)};
     }
   }
 
   auto result = MeshTriangulationUtils::triangulateWithDelaunay(
       *this, std::move(boundary_mesh), std::move(hole_meshes), xyd_opts);
 
   // Stitch the outer ring clone back onto the interior triangulation at the recorded seam.
   if (outer_ring_clone)
   {
     auto sentinel_ids = MooseMeshUtils::getBoundaryIDs(*result, {tmp_outer_name}, false);
     const boundary_id_type sentinel_id = sentinel_ids[0];
 
     // Preserve the ring's outermost bcid (= (num_layers - 1) * 2) by renaming it to a high temp
     // value so the post-stitch rename can recover it as the final outer bcid.
     const boundary_id_type ring_outermost_orig =
         boundary_id_type((_outer_boundary_layer_num - 1) * 2);
     // The maximum boundary ID in the outer ring is _outer_boundary_layer_num * 2 - 1, so
     // _outer_boundary_layer_num * 2 is safe for itself. We need the maximum boundary ID of the
     // result mesh too.
     const boundary_id_type ring_outermost_temp =
         std::max(boundary_id_type(_outer_boundary_layer_num * 2),
                  MooseMeshUtils::getNextFreeBoundaryID(*result));
     libMesh::MeshTools::Modification::change_boundary_id(
         *outer_ring_clone, ring_outermost_orig, ring_outermost_temp);
 
     auto & result_u = dynamic_cast<UnstructuredMesh &>(*result);
     auto & clone_u = dynamic_cast<UnstructuredMesh &>(*outer_ring_clone);
     libMesh::MeshSerializer s1(result_u), s2(clone_u);
     result_u.stitch_meshes(clone_u,
                            sentinel_id,
                            1,
                            TOLERANCE,
                            /*clear_stitched_bcids=*/true,
                            _verbose_stitching,
                            _algorithm == "BINARY");
 
     libMesh::MeshTools::Modification::change_boundary_id(*result, ring_outermost_temp, sentinel_id);
 
     if (user_has_output_boundary)
     {
       auto user_id = MooseMeshUtils::getBoundaryIDs(*result, {user_output_boundary}, true).front();
       if (user_id != sentinel_id)
         libMesh::MeshTools::Modification::change_boundary_id(*result, sentinel_id, user_id);
       result->get_boundary_info().sideset_name(user_id) = user_output_boundary;
     }
 
     result->unset_is_prepared();
   }
 
   return result;
 }

◆ generateCSG()

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

protectedvirtualinherited

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

Definition at line 507 of file MeshGenerator.C.

Referenced by MeshGenerator::generateInternalCSG().

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

◆ generateData()

void MeshGenerator::generateData ( )

protectedvirtualinherited

Generate the mesh data.

Reimplemented in AddMetaDataGenerator.

Definition at line 500 of file MeshGenerator.C.

Referenced by MeshGenerator::generateInternal().

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

◆ generateInternal()

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

inherited

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

Definition at line 310 of file MeshGenerator.C.

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

◆ generateInternalCSG()

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

inherited

Internal generation method for CSG object generation.

Definition at line 390 of file MeshGenerator.C.

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

◆ getBase()

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

inlineinherited

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

Definition at line 147 of file MooseBase.h.

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

147 { return _pars.getBase(); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:394

InputParameters::getBase

const std::string & getBase() const

Definition: InputParameters.C:505

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

Referenced by MeshGenerator::isChildMeshGenerator().

   {
     return _child_mesh_generators;
   }

◆ getCSGBase()

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

protectedinherited

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

NOTE: You MUST catch this by reference!

Parameters

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

Returns: The CSGBase object generated by that MeshGenerator

Definition at line 223 of file MeshGenerator.C.

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

◆ getCSGBaseByName()

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

protectedinherited

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

NOTE: You MUST catch this by reference!

Parameters

mesh_generator_name The name of the MeshGenerator associated with the CSGBase object

Returns: The CSGBase pointer generated by that MeshGenerator

Definition at line 232 of file MeshGenerator.C.

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

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

◆ getCSGBases()

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

protectedinherited

Like getCSGBase(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters

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

Returns: Vector of CSGBase pointers associated with input parameter

Definition at line 244 of file MeshGenerator.C.

 {
   return getCSGBasesByName(getMeshGeneratorNamesFromParam(param_name));
 }

◆ getCSGBasesByName()

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

protectedinherited

Like getCSGBaseByName(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters

mesh_generator_names The names of MeshGenerator objects

Returns: Vector of CSGBase pointers associated with input parameter

Definition at line 250 of file MeshGenerator.C.

Referenced by MeshGenerator::getCSGBases().

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

◆ getDataFileName()

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

inherited

Deprecated method.

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

Definition at line 21 of file DataFileInterface.C.

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

◆ getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

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

◆ getDataFilePath()

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

inherited

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

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

Definition at line 40 of file DataFileInterface.C.

Referenced by DataFileInterface::getDataFileNameByName().

 {
   // This should only ever be used with relative paths. There is no point to
   // use this search path with an absolute path.
   if (std::filesystem::path(relative_path).is_absolute())
     _parent.mooseWarning("While using getDataFilePath(\"",
                          relative_path,
                          "\"): This API should not be used for absolute paths.");
 
   // 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;
 }

◆ getHitNode()

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.

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

136 { return getHitNode(_pars); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:394

MooseBase::getHitNode

const hit::Node * getHitNode() const

Definition: MooseBase.h:136

◆ getMesh()

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

protectedinherited

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

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

Parameters

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

Returns: The Mesh generated by that MeshGenerator

NOTE: You MUST catch this by reference!

Definition at line 186 of file MeshGenerator.C.

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

◆ getMeshByName()

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

protectedinherited

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

NOTE: You MUST catch this by reference!

Returns: The Mesh generated by that MeshGenerator

Definition at line 201 of file MeshGenerator.C.

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

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

◆ getMeshes()

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

protectedinherited

Like getMesh(), but for multiple generators.

Returns: The generated meshes

Definition at line 195 of file MeshGenerator.C.

 {
   return getMeshesByName(getMeshGeneratorNamesFromParam(param_name));
 }

◆ getMeshesByName()

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

protectedinherited

Like getMeshByName(), but for multiple generators.

Returns: The generated meshes

Definition at line 214 of file MeshGenerator.C.

Referenced by MeshGenerator::getMeshes().

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

◆ getMeshProperty() [1/2]

template<typename T >

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

protectedinherited

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

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

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

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

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

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

87 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:385

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

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

◆ getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

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

Parameters

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

Returns: Vector of pairs of first and second parameters

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

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

   {
     return _parent_mesh_generators;
   }

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

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

◆ getRequestedMeshGenerators()

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

inlineinherited

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

Definition at line 99 of file MeshGenerator.h.

   {
     return _requested_mesh_generators;
   }

◆ getRequestedMeshGeneratorsForSub()

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

inlineinherited

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

Definition at line 107 of file MeshGenerator.h.

   {
     return _requested_mesh_generators_for_sub;
   }

◆ getSavedMeshName()

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

inherited

Return the name of the saved mesh.

Definition at line 494 of file MeshGenerator.C.

 {
   return _save_with_name;
 }

◆ getSharedPtr() [1/2]

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

inherited

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

Wrapper around shared_from_this().

Definition at line 70 of file MooseObject.C.

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

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

◆ getSharedPtr() [2/2]

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

inherited

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

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:394

InputParameters::hasBase

bool hasBase() const

Definition: InputParameters.C:499

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

◆ hasGenerateCSG() [2/2]

bool MeshGenerator::hasGenerateCSG ( ) const

inlineinherited

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

Definition at line 209 of file MeshGenerator.h.

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

209 { return hasGenerateCSG(_pars); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:394

MeshGenerator::hasGenerateCSG

bool hasGenerateCSG() const

Definition: MeshGenerator.h:209

◆ hasGenerateData() [1/2]

bool MeshGenerator::hasGenerateData ( const InputParameters & params )

staticinherited

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

Definition at line 88 of file MeshGenerator.C.

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

◆ hasGenerateData() [2/2]

bool MeshGenerator::hasGenerateData ( ) const

inlineinherited

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

Definition at line 204 of file MeshGenerator.h.

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

204 { return hasGenerateData(_pars); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:394

MeshGenerator::hasGenerateData

bool hasGenerateData() const

Definition: MeshGenerator.h:204

◆ hasMeshProperty() [1/4]

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

protectedinherited

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

Definition at line 33 of file MeshMetaDataInterface.C.

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

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

◆ hasMeshProperty() [2/4]

template<typename T >

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

protectedinherited

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

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

◆ hasMeshProperty() [3/4]

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

inlineprotectedinherited

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

Definition at line 82 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [4/4]

template<typename T >

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

inlineprotectedinherited

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

Definition at line 90 of file MeshMetaDataInterface.h.

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

◆ hasOutput()

bool MeshGenerator::hasOutput ( ) const

inherited

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

Definition at line 488 of file MeshGenerator.C.

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

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

◆ hasSaveMesh()

bool MeshGenerator::hasSaveMesh ( ) const

inherited

Return whether or not to save the current mesh.

Definition at line 482 of file MeshGenerator.C.

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

 {
   return _save_with_name.size();
 }

◆ haveParameter()

template<typename T >

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

inlineinherited

Test if a parameter of the given name and type exists.

Parameters

name	The name of the parameter to test

Definition at line 200 of file MooseBase.h.

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

◆ isChildMeshGenerator()

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

inherited

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

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

Definition at line 461 of file MeshGenerator.C.

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder().

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

◆ isDataOnly()

bool MeshGenerator::isDataOnly ( ) const

inlineinherited

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

Definition at line 214 of file MeshGenerator.h.

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

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

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

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

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

MooseBase::parameters

const InputParameters & parameters() const

Get the parameters of the object.

Definition: MooseBase.h:131

InputParameters::isKokkosObject

bool isKokkosObject() const

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

Definition: InputParameters.C:433

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

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

184 { return _null_mesh_names.count(name); }

MeshGenerator::_null_mesh_names

std::set< std::string > _null_mesh_names

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

Definition: MeshGenerator.h:524

MooseBase::name

const std::string & name() const

Get the name of the class.

Definition: MooseBase.h:103

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

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

   {
     return _pars.isParamSetByUser(name);
   }

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

209 { return _pars.isParamValid(name); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:394

MooseBase::name

const std::string & name() const

Get the name of the class.

Definition: MooseBase.h:103

InputParameters::isParamValid

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

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

Definition: InputParameters.C: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 448 of file MeshGenerator.C.

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

◆ meshNormal2D()

Point SurfaceDelaunayGeneratorBase::meshNormal2D ( const MeshBase & mesh )

protectedinherited

Calculate the average normal vector of a 2D mesh based on the normal vectors of its elements using the element areas as weights.

Parameters

mesh	The mesh for which the average normal vector is to be calculated

Returns: the average normal vector of the 2D mesh

Definition at line 89 of file SurfaceDelaunayGeneratorBase.C.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), and SurfaceSubdomainsDelaunayRemesher::General2DDelaunay().

 {
   Point mesh_norm = Point(0.0, 0.0, 0.0);
   Real mesh_area = 0.0;
 
   // Check all the elements' normal vectors
   for (const auto & elem : mesh.active_local_element_ptr_range())
   {
     const Real elem_area = elem->volume();
     mesh_norm += elemNormal(*elem) * elem_area;
     mesh_area += elem_area;
   }
   mesh.comm().sum(mesh_norm);
   mesh.comm().sum(mesh_area);
   mesh_norm /= mesh_area;
   return mesh_norm.unit();
 }

◆ meshNormalDeviation2D()

Real SurfaceDelaunayGeneratorBase::meshNormalDeviation2D	(	const MeshBase &	mesh,
		const Point &	global_norm
	)

protectedinherited

Calculate the maximum deviation of the normal vectors in a given mesh from a global average normal vector.

Parameters

mesh	The mesh for which the maximum deviation is to be calculated
global_norm	The global average normal vector

Returns: the maximum deviation of the normal vectors in the mesh from the global average normal in degrees

Definition at line 108 of file SurfaceDelaunayGeneratorBase.C.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), and SurfaceSubdomainsDelaunayRemesher::General2DDelaunay().

 {
   Real max_deviation(0.0);
   // Check all the elements' deviation from the global normal vector
   for (const auto & elem : mesh.active_local_element_ptr_range())
   {
     const Real elem_deviation = std::acos(global_norm * elemNormal(*elem)) / M_PI * 180.0;
     max_deviation = std::max(max_deviation, elem_deviation);
     if (_verbose && elem_deviation > _max_angle_deviation)
       _console << "Element " << elem->id() << " from subdomain ID " << elem->subdomain_id()
                << " has normal deviation: " << elem_deviation << std::endl;
   }
   mesh.comm().max(max_deviation);
   return max_deviation;
 }

◆ meshPropertyName() [1/2]

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

staticprotectedinherited

Returns: The full name for mesh property data.

Definition at line 41 of file MeshMetaDataInterface.C.

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

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

◆ meshPropertyName() [2/2]

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

inlineprotectedinherited

Returns: The default mesh property name for mesh property data

Definition at line 103 of file MeshMetaDataInterface.h.

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

◆ messagePrefix()

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

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

   {
     return messagePrefix(_pars, hit_prefix);
   }

◆ mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

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

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

◆ mooseDeprecated() [2/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 327 of file MooseBase.h.

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

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

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

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

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Definition at line 287 of file MooseBase.h.

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

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

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

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 300 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 344 of file MooseBase.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldKDTreeTransferBase::evaluateNearestNodeFromKDTrees(), PIDTransientControl::execute(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), PolyLineMeshFollowingNodeSetGenerator::generate(), ManifoldSubdomainGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), MultiAppTransfer::mapBackWithoutCollapsing(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramInfo(), ProjectionAux::ProjectionAux(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), MooseApp::setupOptions(), SolutionUserObjectBase::SolutionUserObjectBase(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), and TransientBase::TransientBase().

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

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

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

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

◆ mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 309 of file MooseBase.h.

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

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

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

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 318 of file MooseBase.h.

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

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

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:394

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

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

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

◆ paramWarning() [1/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

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

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

◆ paramWarning() [2/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 474 of file MooseBase.h.

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

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

Referenced by MFEMExecutedObject::getRequestedItems().

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

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

Referenced by AddMetaDataGenerator::validParams().

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

◆ setMeshProperty() [1/2]

template<typename T , typename... Args>

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

protectedinherited

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

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

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

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

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

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

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

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

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

static

Definition at line 27 of file XYDelaunayGenerator.C.

 {
   InputParameters params = SurfaceDelaunayGeneratorBase::validParams();
 
   MooseEnum algorithm("BINARY EXHAUSTIVE", "BINARY");
   MooseEnum tri_elem_type("TRI3 TRI6 TRI7 DEFAULT", "DEFAULT");
 
   params.addRequiredParam<MeshGeneratorName>(
       "boundary",
       "The input MeshGenerator defining the output outer boundary and required Steiner points.");
   params.addParam<std::vector<BoundaryName>>(
       "input_boundary_names", "2D-input-mesh boundaries defining the output mesh outer boundary");
   params.addParam<std::vector<SubdomainName>>(
       "input_subdomain_names", "1D-input-mesh subdomains defining the output mesh outer boundary");
   params.addParam<unsigned int>("add_nodes_per_boundary_segment",
                                 0,
                                 "How many more nodes to add in each outer boundary segment.");
   params.addParam<bool>(
       "refine_boundary", true, "Whether to allow automatically refining the outer boundary.");
 
   params.addParam<SubdomainName>("output_subdomain_name",
                                  "Subdomain name to set on new triangles.");
   params.addParam<SubdomainID>("output_subdomain_id", "Subdomain id to set on new triangles.");
 
   params.addParam<BoundaryName>(
       "output_boundary",
       "Boundary name to set on new outer boundary.  Default ID: 0 if no hole meshes are stitched; "
       "or maximum boundary ID of all the stitched hole meshes + 1.");
   params.addParam<std::vector<BoundaryName>>(
       "hole_boundaries",
       "Boundary names to set on holes.  Default IDs are numbered up from 1 if no hole meshes are "
       "stitched; or from maximum boundary ID of all the stitched hole meshes + 2.");
 
   params.addParam<bool>(
       "verify_holes",
       true,
       "Verify holes do not intersect boundary or each other.  Asymptotically costly.");
 
   params.addParam<bool>("smooth_triangulation",
                         false,
                         "Whether to do Laplacian mesh smoothing on the generated triangles.");
   params.addParam<std::vector<MeshGeneratorName>>(
       "holes", std::vector<MeshGeneratorName>(), "The MeshGenerators that define mesh holes.");
   params.addParam<std::vector<bool>>(
       "stitch_holes", std::vector<bool>(), "Whether to stitch to the mesh defining each hole.");
   params.addParam<std::vector<bool>>("refine_holes",
                                      std::vector<bool>(),
                                      "Whether to allow automatically refining each hole boundary.");
   params.addRangeCheckedParam<Real>(
       "desired_area",
       0,
       "desired_area>=0",
       "Desired (maximum) triangle area, or 0 to skip uniform refinement");
   params.addParam<std::string>(
       "desired_area_func",
       std::string(),
       "Desired area as a function of x,y; omit to skip non-uniform refinement");
 
   params.addParam<MooseEnum>(
       "algorithm",
       algorithm,
       "Control the use of binary search for the nodes of the stitched surfaces.");
   params.addParam<MooseEnum>(
       "tri_element_type", tri_elem_type, "Type of the triangular elements to be generated.");
   params.addParam<bool>(
       "verbose_stitching", false, "Whether mesh stitching should have verbose output.");
   params.addParam<std::vector<Point>>("interior_points",
                                       {},
                                       "Interior node locations, if no smoothing is used. Any point "
                                       "outside the surface will not be meshed.");
   params.addParam<std::vector<FileName>>(
       "interior_point_files", {}, "Text file(s) with the interior points, one per line");
   params.addClassDescription("Triangulates meshes within boundaries defined by input meshes.");
 
   params.addRangeCheckedParam<Real>("outer_boundary_layer_thickness",
                                     0,
                                     "outer_boundary_layer_thickness>=0",
                                     "Thickness of the outer boundary layer to be added.");
   params.addParam<unsigned int>(
       "outer_boundary_layer_num", 0, "Number of layers for the outer boundary layer.");
   params.addRangeCheckedParam<Real>(
       "outer_boundary_layer_bias",
       1.0,
       "outer_boundary_layer_bias>0",
       "Bias factor for the thickness of each layer in the outer boundary layer.");
 
   params.addRangeCheckedParam<std::vector<Real>>(
       "holes_boundary_layer_thickness",
       "holes_boundary_layer_thickness>=0",
       "Thickness of the hole boundary layers to be added.");
   params.addParam<std::vector<unsigned int>>("holes_boundary_layer_num",
                                              "Numbers of layers for the hole boundary layers.");
   params.addRangeCheckedParam<std::vector<Real>>(
       "holes_boundary_layer_bias",
       "holes_boundary_layer_bias>0",
       "Bias factors for the thickness of each layer in the hole boundary layers.");
 
   params.addParamNamesToGroup("interior_points interior_point_files",
                               "Mandatory mesh interior nodes");
 
   params.addParamNamesToGroup("outer_boundary_layer_thickness outer_boundary_layer_num "
                               "outer_boundary_layer_bias holes_boundary_layer_thickness "
                               "holes_boundary_layer_num holes_boundary_layer_bias",
                               "Boundary layer");
 
   return params;
 }

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

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

◆ _add_nodes_per_boundary_segment

const unsigned int XYDelaunayGenerator::_add_nodes_per_boundary_segment

protected

How many more nodes to add in each outer boundary segment.

Definition at line 34 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _algorithm

const MooseEnum XYDelaunayGenerator::_algorithm

protected

Type of algorithm used to find matching nodes (binary or exhaustive)

Definition at line 64 of file XYDelaunayGenerator.h.

Referenced by generate().

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 385 of file MooseBase.h.

◆ _auto_area_func_default_size

const Real SurfaceDelaunayGeneratorBase::_auto_area_func_default_size

protectedinherited

Background size for automatic desired area function.

Definition at line 56 of file SurfaceDelaunayGeneratorBase.h.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), and generate().

◆ _auto_area_func_default_size_dist

const Real SurfaceDelaunayGeneratorBase::_auto_area_func_default_size_dist

protectedinherited

Background size's effective distance for automatic desired area function.

Definition at line 59 of file SurfaceDelaunayGeneratorBase.h.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), and generate().

◆ _auto_area_function_num_points

const unsigned int SurfaceDelaunayGeneratorBase::_auto_area_function_num_points

protectedinherited

Maximum number of points to use for the inverse distance interpolation for automatic area function.

Definition at line 62 of file SurfaceDelaunayGeneratorBase.h.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), and generate().

◆ _auto_area_function_power

const Real SurfaceDelaunayGeneratorBase::_auto_area_function_power

protectedinherited

Power of the polynomial used in the inverse distance interpolation for automatic area function.

Definition at line 65 of file SurfaceDelaunayGeneratorBase.h.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), and generate().

◆ _bdy_ptr

std::unique_ptr<MeshBase>& XYDelaunayGenerator::_bdy_ptr

protected

Input mesh defining the boundary to triangulate within.

Definition at line 31 of file XYDelaunayGenerator.h.

Referenced by generate().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

◆ _desired_area

const Real XYDelaunayGenerator::_desired_area

protected

Desired (maximum) triangle area.

Definition at line 58 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _desired_area_func

const std::string XYDelaunayGenerator::_desired_area_func

protected

Desired triangle area as a (fparser-compatible) function of x,y.

Definition at line 61 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

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

◆ _hole_ptrs

const std::vector<std::unique_ptr<MeshBase> *> XYDelaunayGenerator::_hole_ptrs

protected

Holds pointers to the pointers to input meshes defining holes.

Definition at line 49 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _holes_boundary_layer_bias

const std::vector<Real> XYDelaunayGenerator::_holes_boundary_layer_bias

protected

Per-hole boundary-layer ring bias factors.

Definition at line 91 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _holes_boundary_layer_num

const std::vector<unsigned int> XYDelaunayGenerator::_holes_boundary_layer_num

protected

Per-hole boundary-layer ring layer counts.

Definition at line 88 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _holes_boundary_layer_thickness

const std::vector<Real> XYDelaunayGenerator::_holes_boundary_layer_thickness

protected

Per-hole boundary-layer ring thicknesses (grown outward from each hole)

Definition at line 85 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _interior_points

std::vector<Point> XYDelaunayGenerator::_interior_points

protected

Desired interior node locations.

Definition at line 73 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _max_angle_deviation

const Real SurfaceDelaunayGeneratorBase::_max_angle_deviation

protectedinherited

Max angle deviation from the global average normal vector in the input mesh.

Definition at line 68 of file SurfaceDelaunayGeneratorBase.h.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), and SurfaceDelaunayGeneratorBase::meshNormalDeviation2D().

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

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 391 of file MooseBase.h.

◆ _outer_boundary_layer_bias

const Real XYDelaunayGenerator::_outer_boundary_layer_bias

protected

Bias factor for the layer thicknesses in the outer boundary-layer ring.

Definition at line 82 of file XYDelaunayGenerator.h.

Referenced by generate().

◆ _outer_boundary_layer_num

const unsigned int XYDelaunayGenerator::_outer_boundary_layer_num

protected

Number of element layers in the outer boundary-layer ring.

Definition at line 79 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _outer_boundary_layer_thickness

const Real XYDelaunayGenerator::_outer_boundary_layer_thickness

protected

Thickness of an optional boundary-layer ring grown inward from the outer boundary.

Definition at line 76 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _output_subdomain_id

SubdomainID XYDelaunayGenerator::_output_subdomain_id

protected

What subdomain_id to set on the generated triangles.

Definition at line 40 of file XYDelaunayGenerator.h.

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 394 of file MooseBase.h.

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

◆ _refine_bdy

const bool XYDelaunayGenerator::_refine_bdy

protected

Whether to allow automatically refining the outer boundary.

Definition at line 37 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _refine_holes

const std::vector<bool> XYDelaunayGenerator::_refine_holes

protected

Whether to allow automatically refining each hole boundary.

Definition at line 55 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _smooth_tri

const bool XYDelaunayGenerator::_smooth_tri

protected

Whether to do Laplacian mesh smoothing on the generated triangles.

Definition at line 43 of file XYDelaunayGenerator.h.

Referenced by generate().

◆ _stitch_holes

const std::vector<bool> XYDelaunayGenerator::_stitch_holes

protected

Whether to stitch to the mesh defining each hole.

Definition at line 52 of file XYDelaunayGenerator.h.

Referenced by generate(), and XYDelaunayGenerator().

◆ _tri_elem_type

const MooseEnum XYDelaunayGenerator::_tri_elem_type

protected

Type of triangular elements to be generated.

Definition at line 67 of file XYDelaunayGenerator.h.

Referenced by generate().

◆ _type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 388 of file MooseBase.h.

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

◆ _use_auto_area_func

const bool SurfaceDelaunayGeneratorBase::_use_auto_area_func

protectedinherited

Whether to use automatic desired area function.

Definition at line 53 of file SurfaceDelaunayGeneratorBase.h.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), generate(), and XYDelaunayGenerator().

◆ _verbose

const bool SurfaceDelaunayGeneratorBase::_verbose

protectedinherited

Whether the generator should be verbose.

Definition at line 71 of file SurfaceDelaunayGeneratorBase.h.

Referenced by SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), and SurfaceDelaunayGeneratorBase::meshNormalDeviation2D().

◆ _verbose_stitching

const bool XYDelaunayGenerator::_verbose_stitching

protected

Whether mesh stitching should have verbose output.

Definition at line 70 of file XYDelaunayGenerator.h.

Referenced by generate().

◆ _verify_holes

const bool XYDelaunayGenerator::_verify_holes

protected

Whether to verify holes do not intersect boundary or each other.

Definition at line 46 of file XYDelaunayGenerator.h.

Referenced by generate().

◆ app_param

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

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), Factory::getValidParams(), ActionFactory::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>"

staticinherited

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(), ActionFactory::create(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

◆ SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"

staticinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().

◆ 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/XYDelaunayGenerator.h
src/meshgenerators/XYDelaunayGenerator.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ XYDelaunayGenerator()

Member Function Documentation

◆ addChildMeshGenerator()

◆ addMeshSubgenerator() [1/2]

◆ addMeshSubgenerator() [2/2]

◆ addParentMeshGenerator()

◆ buildDistributedMesh()

◆ buildMeshBaseObject()

◆ buildReplicatedMesh()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ connectControllableParams()

◆ copyMeshProperty() [1/2]

◆ copyMeshProperty() [2/2]

◆ declareMeshesForSub()

◆ declareMeshesForSubByName()

◆ declareMeshForSub()

◆ declareMeshForSubByName()

◆ declareMeshProperty() [1/2]

◆ declareMeshProperty() [2/2]

◆ declareNullMeshName()

◆ elemNormal()

◆ enabled()

◆ errorPrefix()

◆ flagInvalidSolutionInternal()

◆ generate()

◆ generateCSG()

◆ generateData()

◆ generateInternal()

◆ generateInternalCSG()

◆ getBase()

◆ getCheckedPointerParam()

◆ getChildMeshGenerators()

◆ getCSGBase()

◆ getCSGBaseByName()

◆ getCSGBases()

◆ getCSGBasesByName()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getHitNode()

◆ getMesh()

◆ getMeshByName()

◆ getMeshes()

◆ getMeshesByName()

◆ getMeshProperty() [1/2]

◆ getMeshProperty() [2/2]

◆ getMooseApp()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getParentMeshGenerators()

◆ getRenamedParam()

◆ getRequestedMeshGenerators()

◆ getRequestedMeshGeneratorsForSub()

◆ getSavedMeshName()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ getSubMeshGenerators()

◆ hasBase()

◆ hasGenerateCSG() [1/2]

◆ hasGenerateCSG() [2/2]

◆ hasGenerateData() [1/2]

◆ hasGenerateData() [2/2]

◆ hasMeshProperty() [1/4]

◆ hasMeshProperty() [2/4]

◆ hasMeshProperty() [3/4]

◆ hasMeshProperty() [4/4]

◆ hasOutput()