Generates a triangulation in the XY plane by advancing a front, based on an input mesh defining the outer boundary and an optional set of input meshes defining inner hole boundaries. More...

#include <XYFrontalDelaunayGenerator.h>

Inheritance diagram for XYFrontalDelaunayGenerator:

[legend]

Classes
struct	FrontEdge
	An edge of the front, which separates the triangles that meet the target size from the triangles that do not. More...

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

Public Member Functions
	XYFrontalDelaunayGenerator (const InputParameters &parameters)

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

bool	hasGenerateData () const

bool	hasGenerateCSG () const

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

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

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

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

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

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

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

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

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

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

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

bool	isNullMeshName (const MeshGeneratorName &name) const

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

bool	hasOutput () const

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

bool	isDataOnly () const

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

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

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

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

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

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

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

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

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

MooseObjectName	uniqueName () const

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

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

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

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

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

Static Public Member Functions
static InputParameters	validParams ()

static InputParameters	boundaryAndHolesParams ()
	The parameters that select the outer boundary to triangulate within and the holes to leave out of the triangulation, together with the names and the element area limit the result gets.

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

static bool	hasGenerateData (const InputParameters &params)

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

static bool	hasGenerateCSG (const InputParameters &params)

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

Public Attributes
	usingCombinedWarningSolutionWarnings

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

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

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

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

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

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

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

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

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

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

Protected Member Functions
std::unique_ptr< MeshBase >	buildBackgroundMesh (const MeshBase &boundary_mesh, const std::vector< std::unique_ptr< MeshBase > > &holes, const MeshTriangulationUtils::XYDelaunayOptions &opts)
	Triangulates the domain with the existing Delaunay triangulator at _background_area_factor times the requested area.

void	appendLoop (const std::vector< Point > &loop, bool refine, unsigned int extra_nodes, boundary_id_type bcid, std::vector< Point > &points, std::vector< XYIncrementalDelaunay::Segment > &segments)
	Adds one closed loop of the input boundary to the points the triangulation is seeded with and to the segments it is constrained by, splitting each segment of the loop into pieces that the front does not have to refine further, and recording which boundary those pieces belong to.

Real	targetArea (const Point &point) const

Real	targetSize (Real area) const

Real	targetCircumradius (Real size) const

void	buildBoundarySegmentGrid ()
	Sorts the boundary segments into the buckets the BOUNDARY frame searches, so that a search only has to reach out until it has covered the distance to the nearest segment rather than measure against every segment of the boundary.

std::pair< Point, Point >	localFrame (const Point &point) const

Real	metricDistance (const Point &first, const Point &second, const std::pair< Point, Point > &frame) const

bool	insideDomain (const Point &point) const

std::pair< long, long >	gridKey (const Point &point, Real cell) const

void	addToGrid (std::size_t vertex, const Point &point)
	Records a vertex in the grid the rejection rule searches.

bool	hasVertexWithin (const XYIncrementalDelaunay &delaunay, const Point &point, Real distance, const std::pair< Point, Point > &frame) const

bool	placePoint (const XYIncrementalDelaunay &delaunay, const FrontEdge &edge, Point &point) const
	Computes where the advance would place a point ahead of a front edge and applies the rejection rule to it.

std::vector< FrontEdge >	collectFront (const XYIncrementalDelaunay &delaunay, const std::vector< XYIncrementalDelaunay::Triangle > &triangles, const std::vector< bool > &inside) const

void	recordSplitBoundaryIds (const XYIncrementalDelaunay &delaunay, std::size_t vertex)
	Moves the boundary id recorded for the constrained segment an insertion split onto the two halves that insertion divided it into, which are the segments the output mesh has sides on now.

void	advanceFront (XYIncrementalDelaunay &delaunay)
	Advances the front over the whole domain, inserting points into the triangulation.

std::unique_ptr< MeshBase >	buildTriangleMesh (const XYIncrementalDelaunay &delaunay)

void	checkBoundaryAndHolesParams (const std::vector< std::unique_ptr< MeshBase > * > &hole_ptrs) const
	Errors if the parameters boundaryAndHolesParams() adds contradict each other or the holes they refer to.

void	checkInteriorPoints (const std::vector< Point > &interior_points) const
	Errors if a point was given twice as an interior point, which the triangulation cannot honor.

void	fillDelaunayOptions (MeshTriangulationUtils::XYDelaunayOptions &opts) const
	Fills the triangulation options that follow from the parameters boundaryAndHolesParams() adds, and only those: the caller fills whatever its own parameters set on top of them.

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

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.

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.

virtual void	generateData ()
	Generate the mesh data.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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

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

Static Protected Member Functions
static std::map< dof_id_type, Real >	boundaryTangentAngles (const MeshBase &mesh)

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.

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

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

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

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

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

const Real	_desired_area
	Desired (maximum) triangle area.

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

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

const MooseEnum	_metric
	Norm the target size is measured in when a point is placed ahead of the front.

const MooseEnum	_orientation
	Where the local frame the LINF metric measures in comes from.

std::unique_ptr< libMesh::TriangulatorInterface::MeshedHole >	_outer_outline
	Outline of the outer boundary, which the advance stays inside.

std::vector< std::unique_ptr< libMesh::TriangulatorInterface::MeshedHole > >	_hole_outlines
	Outlines of the holes, which the advance stays outside.

std::unique_ptr< MeshBase >	_background_mesh
	Coarse triangulation of the domain the cross field is solved on.

std::unique_ptr< libMesh::PointLocatorBase >	_background_locator
	Locates the background element whose area is the target where no area limit was given.

Real	_background_mean_area
	Mean area of the background elements, the target where the background locator finds nothing.

std::unique_ptr< libMesh::ParsedFunction< Real > >	_area_function
	Desired area as a function of position, built only when 'desired_area_func' is set.

std::unique_ptr< XYCrossFieldSolver >	_cross_field
	Cross field over the domain, built only when the LINF metric asks for the CROSS_FIELD frame.

std::vector< std::pair< Point, Point > >	_boundary_segments
	Segments of the outer boundary and of the holes, whose tangents give the BOUNDARY frame.

Real	_boundary_cell
	Side of the buckets the boundary segments are sorted into so that the frame search stays local.

std::map< std::pair< long, long >, std::vector< std::size_t > >	_boundary_segment_grid
	Indices into _boundary_segments, bucketed by the cells each of those segments passes through.

Real	_grid_cell
	Side of the buckets the vertices are sorted into so that the rejection rule stays local.

std::map< std::pair< long, long >, std::vector< std::size_t > >	_vertex_grid
	Vertex ids of the triangulation, bucketed by position.

std::map< XYIncrementalDelaunay::Segment, boundary_id_type >	_segment_boundary_ids
	Boundary id of each seed segment, keyed on its two vertices with the smaller id first.

const bool	_use_auto_area_func
	Whether to use automatic desired area function.

const Real	_auto_area_func_default_size
	Background size for automatic desired area function.

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

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

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

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

const bool	_verbose
	Whether the generator should be verbose.

MooseMesh *const	_mesh
	Pointer to the owning mesh.

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

MooseApp &	_app
	The MOOSE application this is associated with.

Factory &	_factory
	The Factory associated with the MooseApp.

ActionFactory &	_action_factory
	Builds Actions.

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

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

const InputParameters &	_pars
	The object's parameters.

const Parallel::Communicator &	_communicator

Static Protected Attributes
static constexpr Real	_background_area_factor = 16.0
	How much coarser in area the background triangulation is than the mesh being generated.

static constexpr Real	_size_tolerance = 1.2
	How far the circumradius of a triangle may exceed the target before the advance refines it.

static constexpr Real	_rejection_factor = 0.7
	How close to an existing vertex, as a fraction of the target size, a new point may not come.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.

const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

MooseApp &	_meta_data_app
	Reference to the application.

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

Detailed Description

Generates a triangulation in the XY plane by advancing a front, based on an input mesh defining the outer boundary and an optional set of input meshes defining inner hole boundaries.

Where XYDelaunayGenerator refines a triangulation until every triangle is small enough, this generator grows one: the triangles that already meet the target size are separated from those that do not by a front, and a point is placed a target size ahead of the worst front edge until nothing is left to place. At the start only the boundary points exist, so the front is the boundary itself, the outer boundary and every hole boundary at once, and it advances inward from all of them simultaneously, worst edge first, until the fronts meet and no triangle misses the target. The triangulation itself is maintained by XYIncrementalDelaunay, which keeps the outer boundary and the hole boundaries as constrained segments, so the front never crosses them.

Points placed under the LINF metric form right isosceles triangles in a local frame rather than equilateral ones, which is what lets pairs of them recombine into good quadrilaterals; the frame comes either from a cross field solved over the domain or from the nearest boundary segment.

The result is a TRI3 mesh. Chain SmoothMeshGenerator after this generator to smooth it, and TriToQuadConverter to recombine it into quadrilaterals.

Definition at line 49 of file XYFrontalDelaunayGenerator.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

◆ XYFrontalDelaunayGenerator()

XYFrontalDelaunayGenerator::XYFrontalDelaunayGenerator ( const InputParameters & parameters )

Definition at line 247 of file XYFrontalDelaunayGenerator.C.

  : SurfaceDelaunayGeneratorBase(parameters),
    _bdy_ptr(getMesh("boundary")),
    _hole_ptrs(getMeshes("holes")),
    _add_nodes_per_boundary_segment(getParam<unsigned int>("add_nodes_per_boundary_segment")),
    _refine_bdy(getParam<bool>("refine_boundary")),
    _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")),
    _interior_points(getParam<std::vector<Point>>("interior_points")),
    _metric(getParam<MooseEnum>("metric")),
    _orientation(getParam<MooseEnum>("orientation")),
    _background_mean_area(0.0),
    _boundary_cell(0.0),
    _grid_cell(0.0)
{
  checkBoundaryAndHolesParams(_hole_ptrs);
  checkInteriorPoints(_interior_points);
 
  // The frame the orientation selects only enters the LINF metric, so it does nothing under L2
  if (_metric == "L2" && isParamSetByUser("orientation"))
    paramError("orientation", "This parameter only applies to the 'LINF' metric.");
}

Member Function Documentation

◆ addChildMeshGenerator()

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

inherited

Adds the MeshGenerator mg as a child.

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

Definition at line 471 of file MeshGenerator.C.

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

◆ addMeshSubgenerator() [1/2]

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

protectedinherited

Construct a "subgenerator", as above.

User code is responsible for constructing valid InputParameters.

Parameters

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

Definition at line 440 of file MeshGenerator.C.

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

◆ addMeshSubgenerator() [2/2]

template<typename... Ts>

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

protectedinherited

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

Parameters

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

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

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

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

Definition at line 593 of file MeshGenerator.h.

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

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

◆ addParentMeshGenerator()

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

inherited

Adds the MeshGenerator mg as a parent.

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

Definition at line 464 of file MeshGenerator.C.

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

◆ addToGrid()

void XYFrontalDelaunayGenerator::addToGrid	(	std::size_t	vertex,
		const Point &	point
	)

protected

Records a vertex in the grid the rejection rule searches.

Parameters

vertex	The vertex id
point	The position of that vertex

Definition at line 555 of file XYFrontalDelaunayGenerator.C.

{
  _vertex_grid[gridKey(point, _grid_cell)].push_back(vertex);
}

Referenced by advanceFront().

◆ advanceFront()

void XYFrontalDelaunayGenerator::advanceFront ( XYIncrementalDelaunay & delaunay )

protected

Advances the front over the whole domain, inserting points into the triangulation.

Definition at line 720 of file XYFrontalDelaunayGenerator.C.

{
  // The front is walked over and over rather than rebuilt after every point, which is what keeps
  // the cost of the advance down. A pass that places nothing has nothing left to place: every
  // point is at least the rejection distance from every other, so only finitely many fit
  bool placed_any = true;
  while (placed_any)
  {
    placed_any = false;
 
    const auto triangles = delaunay.getTriangles();
    // The outer boundary was seeded first and counter-clockwise, so the domain is on the left of
    // the segment from vertex 0 to vertex 1
    const auto inside = frontalInsideTriangles(delaunay, triangles, 0, 1);
 
    for (const auto & edge : collectFront(delaunay, triangles, inside))
    {
      Point point;
      if (!placePoint(delaunay, edge, point))
        continue;
 
      const auto vertices_before = delaunay.numPoints();
      const auto segments_before = delaunay.constrainedSegments().size();
      const auto vertex = delaunay.insertPoint({point(0), point(1)});
      if (delaunay.numPoints() == vertices_before)
        continue;
 
      // A point that lands exactly on a constrained segment splits it, which leaves the boundary id
      // of that segment recorded against a segment the triangulation no longer has
      if (delaunay.constrainedSegments().size() != segments_before)
        recordSplitBoundaryIds(delaunay, vertex);
 
      addToGrid(vertex, point);
      placed_any = true;
    }
  }
}

◆ appendLoop()

void XYFrontalDelaunayGenerator::appendLoop	(	const std::vector< Point > &	loop,
		bool	refine,
		unsigned int	extra_nodes,
		boundary_id_type	bcid,
		std::vector< Point > &	points,
		std::vector< XYIncrementalDelaunay::Segment > &	segments
	)

protected

Adds one closed loop of the input boundary to the points the triangulation is seeded with and to the segments it is constrained by, splitting each segment of the loop into pieces that the front does not have to refine further, and recording which boundary those pieces belong to.

Parameters

loop	The corners of the loop, in order
refine	Whether segments longer than the local target size may be split
extra_nodes	How many nodes to add inside every segment of the loop
bcid	The boundary id to set on the sides of the output mesh that lie on this loop
points	Appended with the points of the loop
segments	Appended with the segments between them

Definition at line 330 of file XYFrontalDelaunayGenerator.C.

{
  const std::size_t loop_start = points.size();
 
  for (const auto i : index_range(loop))
  {
    const Point & start = loop[i];
    const Point & end = loop[(i + 1) % loop.size()];
    _boundary_segments.emplace_back(start, end);
 
    unsigned int pieces = extra_nodes + 1;
    if (refine)
    {
      // Splitting a segment the front would otherwise have to advance along is the only chance to
      // refine it, because the front never moves a constrained segment
      const Real size = targetSize(targetArea(0.5 * (start + end)));
      pieces = std::max(pieces, static_cast<unsigned int>(std::ceil((end - start).norm() / size)));
    }
 
    points.push_back(start);
    for (const auto piece : make_range(1u, pieces))
      points.push_back(start + (Real(piece) / pieces) * (end - start));
  }
 
  for (const auto vertex : make_range(loop_start, points.size()))
  {
    const std::size_t next = (vertex + 1 < points.size()) ? vertex + 1 : loop_start;
    segments.emplace_back(vertex, next);
    _segment_boundary_ids[XYIncrementalDelaunay::makeSegment(vertex, next)] = bcid;
  }
}

Referenced by generate().

◆ boundaryAndHolesParams()

InputParameters SurfaceDelaunayGeneratorBase::boundaryAndHolesParams ( )

staticinherited

The parameters that select the outer boundary to triangulate within and the holes to leave out of the triangulation, together with the names and the element area limit the result gets.

A generator that takes its region to mesh as a boundary mesh and hole meshes adds these to its own parameters; the ones derived from this class that select that region some other way do not, which is why the base class does not add them itself.

Returns: the parameters shared by the generators that triangulate within an input boundary mesh

Definition at line 63 of file SurfaceDelaunayGeneratorBase.C.

{
  InputParameters params = emptyInputParameters();
 
  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<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<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");
 
  return params;
}

Referenced by XYDelaunayGenerator::validParams(), and validParams().

◆ boundaryTangentAngles()

std::map< dof_id_type, Real > XYFrontalDelaunayGenerator::boundaryTangentAngles ( const MeshBase & mesh )

staticprotected

Parameters

mesh	The background triangulation

Returns: The boundary tangent angle at every boundary node of the background mesh, keyed by node id, in the form the cross field solver takes its Dirichlet data

Definition at line 301 of file XYFrontalDelaunayGenerator.C.

{
  std::map<dof_id_type, std::complex<Real>> directions;
 
  for (const auto & elem : mesh.element_ptr_range())
    for (const auto side : elem->side_index_range())
    {
      if (elem->neighbor_ptr(side))
        continue;
 
      const Node & start = elem->node_ref(side);
      const Node & end = elem->node_ref((side + 1) % elem->n_sides());
 
      // Accumulating exp(4 i theta) rather than theta averages the directions modulo pi / 2, the
      // symmetry a cross carries, so that the two sides of a right angle agree with each other
      const std::complex<Real> direction =
          std::polar(1.0, 4.0 * std::atan2(end(1) - start(1), end(0) - start(0)));
      directions[start.id()] += direction;
      directions[end.id()] += direction;
    }
 
  std::map<dof_id_type, Real> angles;
  for (const auto & [node_id, direction] : directions)
    angles[node_id] = std::arg(direction) / 4.0;
 
  return angles;
}

Referenced by generate().

◆ buildBackgroundMesh()

std::unique_ptr< MeshBase > XYFrontalDelaunayGenerator::buildBackgroundMesh	(	const MeshBase &	boundary_mesh,
		const std::vector< std::unique_ptr< MeshBase > > &	holes,
		const MeshTriangulationUtils::XYDelaunayOptions &	opts
	)

protected

Triangulates the domain with the existing Delaunay triangulator at _background_area_factor times the requested area.

The result carries the cross field and, where no area limit is given, the target area itself, so it only has to cover the domain and be coarse.

Parameters

boundary_mesh	The input mesh holding the outer boundary
holes	The input meshes holding the holes
opts	The triangulation options of this generator

Returns: The background triangulation

Definition at line 273 of file XYFrontalDelaunayGenerator.C.

{
  MeshTriangulationUtils::XYDelaunayOptions background_opts = opts;
 
  // The background mesh only has to cover the domain, so it carries none of the naming and none of
  // the stitching the output mesh gets
  background_opts.stitch_holes.clear();
  background_opts.hole_boundaries.clear();
  background_opts.has_output_subdomain_name = false;
  background_opts.has_output_boundary = false;
 
  background_opts.desired_area = _background_area_factor * opts.desired_area;
  if (!opts.desired_area_func.empty())
    background_opts.desired_area_func =
        std::to_string(_background_area_factor) + "*(" + opts.desired_area_func + ")";
 
  std::vector<std::unique_ptr<MeshBase>> hole_clones;
  for (const auto & hole : holes)
    hole_clones.push_back(hole->clone());
 
  return MeshTriangulationUtils::triangulateWithDelaunay(
      *this, boundary_mesh.clone(), std::move(hole_clones), background_opts);
}

Referenced by generate().

◆ buildBoundarySegmentGrid()

void XYFrontalDelaunayGenerator::buildBoundarySegmentGrid ( )

protected

Sorts the boundary segments into the buckets the BOUNDARY frame searches, so that a search only has to reach out until it has covered the distance to the nearest segment rather than measure against every segment of the boundary.

Only for that frame, and only once the whole boundary has been seeded.

Definition at line 417 of file XYFrontalDelaunayGenerator.C.

{
  mooseAssert(!_boundary_segments.empty(),
              "The boundary was seeded before the grid over it is built.");
 
  Real min_x = std::numeric_limits<Real>::max();
  Real max_x = std::numeric_limits<Real>::lowest();
  Real min_y = min_x;
  Real max_y = max_x;
  for (const auto & [start, end] : _boundary_segments)
    for (const auto & corner : {start, end})
    {
      min_x = std::min(min_x, corner(0));
      max_x = std::max(max_x, corner(0));
      min_y = std::min(min_y, corner(1));
      max_y = std::max(max_y, corner(1));
    }
 
  // Buckets that hold about one segment each: coarser ones leave a list to walk in every bucket the
  // search reaches, finer ones leave the search reaching over more buckets to cover the same
  // distance. They are never finer than the vertex grid, which is as fine as the mesh itself gets
  const Real extent = (max_x - min_x) * (max_y - min_y);
  _boundary_cell = std::max(_grid_cell, std::sqrt(extent / _boundary_segments.size()));
 
  for (const auto segment : index_range(_boundary_segments))
  {
    const auto & [start, end] = _boundary_segments[segment];
 
    // Walking the segment in steps of half a bucket puts consecutive steps in the same bucket or in
    // neighboring ones, so every bucket the segment passes through neighbors one it is recorded in,
    // which is the reach the search below adds to the distance it has covered
    const auto steps =
        std::max(std::size_t(1),
                 static_cast<std::size_t>(std::ceil(2.0 * (end - start).norm() / _boundary_cell)));
    for (const auto step : make_range(steps + 1))
    {
      auto & bucket = _boundary_segment_grid[gridKey(start + (Real(step) / steps) * (end - start),
                                                     _boundary_cell)];
      // The steps of a straight segment reach a bucket in one run, so the last entry is the only
      // one that can already be this segment
      if (bucket.empty() || bucket.back() != segment)
        bucket.push_back(segment);
    }
  }
}

Referenced by generate().

◆ buildDistributedMesh()

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

protectedinherited

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

Parameters

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

Definition at line 333 of file MeshGenerator.C.

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

Referenced by DistributedRectilinearMeshGenerator::generate().

◆ buildMeshBaseObject()

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

protectedinherited

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

Parameters

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

Definition at line 319 of file MeshGenerator.C.

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

◆ buildReplicatedMesh()

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

protectedinherited

Build a replicated mesh.

Parameters

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

Definition at line 326 of file MeshGenerator.C.

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

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

◆ buildTriangleMesh()

std::unique_ptr< MeshBase > XYFrontalDelaunayGenerator::buildTriangleMesh ( const XYIncrementalDelaunay & delaunay )

protected

Returns: A TRI3 mesh of the triangles of the triangulation that lie in the domain

Definition at line 759 of file XYFrontalDelaunayGenerator.C.

{
  const auto triangles = delaunay.getTriangles();
  // The outer boundary was seeded first and counter-clockwise, so the domain is on the left of the
  // segment from vertex 0 to vertex 1
  const auto inside = frontalInsideTriangles(delaunay, triangles, 0, 1);
 
  auto mesh = buildReplicatedMesh(2);
 
  // Adding the nodes in vertex order rather than as the triangles reach them keeps the node
  // numbering of the output tied to the order the points were placed in
  std::set<std::size_t> used_vertices;
  for (const auto t : index_range(triangles))
    if (inside[t])
      used_vertices.insert(triangles[t].vertices.begin(), triangles[t].vertices.end());
 
  std::map<std::size_t, Node *> nodes;
  for (const auto vertex : used_vertices)
    nodes[vertex] = mesh->add_point(frontalToPoint(delaunay.point(vertex)));
 
  auto & boundary_info = mesh->get_boundary_info();
  for (const auto t : index_range(triangles))
  {
    if (!inside[t])
      continue;
 
    const auto & triangle = triangles[t];
    Elem * const elem = mesh->add_elem(Elem::build(libMesh::ElemType::TRI3));
    for (const auto k : make_range(n_frontal_tri_sides))
      elem->set_node(k, libmesh_map_find(nodes, triangle.vertices[k]));
    elem->subdomain_id() = 0;
 
    for (const auto side : make_range(n_frontal_tri_sides))
    {
      // Side s of a triangle runs from vertex s to vertex s + 1, which is the edge the
      // triangulation holds opposite vertex s + 2
      const auto neighbor = triangle.neighbors[(side + 2) % n_frontal_tri_sides];
      if (neighbor != XYIncrementalDelaunay::invalid_index && inside[neighbor])
        continue;
 
      const auto first = triangle.vertices[side];
      const auto second = triangle.vertices[(side + 1) % n_frontal_tri_sides];
      const auto bcid =
          _segment_boundary_ids.find(XYIncrementalDelaunay::makeSegment(first, second));
      if (bcid == _segment_boundary_ids.end())
        mooseError("A side of the triangulation lies on the boundary of the domain without lying "
                   "on any of the input boundaries, which happens when a point of "
                   "'interior_points' falls on the outer boundary or on a hole boundary.");
 
      boundary_info.add_side(elem, side, bcid->second);
    }
  }
 
  mesh->prepare_for_use();
 
  return mesh;
}

◆ callMooseError() [1/2]

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

staticinherited

External method for calling moose error with added object context.

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

Parameters

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

Definition at line 114 of file MooseBase.C.

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

◆ callMooseError() [2/2]

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

inherited

External method for calling moose error with added object context.

Parameters

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

Definition at line 105 of file MooseBase.C.

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

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

◆ checkBoundaryAndHolesParams()

void SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams ( const std::vector< std::unique_ptr< MeshBase > * > & hole_ptrs ) const

protectedinherited

Errors if the parameters boundaryAndHolesParams() adds contradict each other or the holes they refer to.

Only for a generator that added those parameters.

Parameters

hole_ptrs The input meshes 'holes' resolved to

Definition at line 130 of file SurfaceDelaunayGeneratorBase.C.

{
  const auto desired_area = getParam<Real>("desired_area");
  const auto & desired_area_func = getParam<std::string>("desired_area_func");
 
  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'.");
 
  const auto & stitch_holes = getParam<std::vector<bool>>("stitch_holes");
  const auto & refine_holes = getParam<std::vector<bool>>("refine_holes");
 
  if (!stitch_holes.empty() && stitch_holes.size() != hole_ptrs.size())
    paramError("stitch_holes", "Need one stitch_holes entry per hole, if specified.");
 
  for (const 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"))
    if (getParam<std::vector<BoundaryName>>("hole_boundaries").size() != hole_ptrs.size())
      paramError("hole_boundaries", "Need one hole_boundaries entry per hole, if specified.");
}

Referenced by XYDelaunayGenerator::XYDelaunayGenerator(), and XYFrontalDelaunayGenerator().

◆ checkGetMesh()

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

privateinherited

Helper for performing error checking in the getMesh methods.

Definition at line 158 of file MeshGenerator.C.

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

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

◆ checkInteriorPoints()

void SurfaceDelaunayGeneratorBase::checkInteriorPoints ( const std::vector< Point > & interior_points ) const

protectedinherited

Errors if a point was given twice as an interior point, which the triangulation cannot honor.

Parameters

interior_points The interior points to be meshed through

Definition at line 169 of file SurfaceDelaunayGeneratorBase.C.

{
  std::vector<Point> sorted_points(interior_points);
  std::sort(sorted_points.begin(), sorted_points.end());
  const bool has_duplicates =
      std::adjacent_find(sorted_points.begin(), sorted_points.end()) != sorted_points.end();
  if (has_duplicates)
    paramError("interior_points", "Duplicate points were found in the provided interior points.");
}

Referenced by XYDelaunayGenerator::XYDelaunayGenerator(), and XYFrontalDelaunayGenerator().

◆ collectFront()

std::vector< XYFrontalDelaunayGenerator::FrontEdge > XYFrontalDelaunayGenerator::collectFront	(	const XYIncrementalDelaunay &	delaunay,
		const std::vector< XYIncrementalDelaunay::Triangle > &	triangles,
		const std::vector< bool > &	inside
	)		const

protected

Parameters

delaunay	The triangulation the front belongs to
triangles	The triangles of that triangulation
inside	Whether each of those triangles lies in the domain

Returns: The front edges, worst first

Definition at line 630 of file XYFrontalDelaunayGenerator.C.

{
  // The circumradius answers for both the size and the shape of a triangle: it grows with the
  // triangle and it runs away as the triangle flattens
  std::vector<Real> excess(triangles.size(), 0.0);
  for (const auto t : index_range(triangles))
  {
    if (!inside[t])
      continue;
 
    const Point first = frontalToPoint(delaunay.point(triangles[t].vertices[0]));
    const Point second = frontalToPoint(delaunay.point(triangles[t].vertices[1]));
    const Point third = frontalToPoint(delaunay.point(triangles[t].vertices[2]));
    const Point centroid = (first + second + third) / 3.0;
 
    excess[t] = frontalCircumradius(first, second, third) /
                targetCircumradius(targetSize(targetArea(centroid)));
  }
 
  std::vector<FrontEdge> front;
  for (const auto t : index_range(triangles))
  {
    if (!inside[t] || excess[t] <= _size_tolerance)
      continue;
 
    const auto & triangle = triangles[t];
    for (const auto i : make_range(n_frontal_tri_sides))
    {
      // An edge between two triangles that both miss the target is behind the front, not on it
      const auto neighbor = triangle.neighbors[i];
      if (neighbor != XYIncrementalDelaunay::invalid_index && inside[neighbor] &&
          excess[neighbor] > _size_tolerance)
        continue;
 
      front.push_back({triangle.vertices[(i + 1) % n_frontal_tri_sides],
                       triangle.vertices[(i + 2) % n_frontal_tri_sides],
                       excess[t]});
    }
  }
 
  // Ties are broken by the vertices of the edge so that the same points are placed, in the same
  // order, from one run to the next
  std::sort(front.begin(),
            front.end(),
            [](const FrontEdge & a, const FrontEdge & b)
            {
              if (a.excess > b.excess)
                return true;
              if (b.excess > a.excess)
                return false;
 
              return XYIncrementalDelaunay::makeSegment(a.start, a.end) <
                     XYIncrementalDelaunay::makeSegment(b.start, b.end);
            });
 
  return front;
}

Referenced by advanceFront().

◆ connectControllableParams()

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

inherited

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

Parameters

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

Definition at line 77 of file MooseBase.C.

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

◆ copyMeshProperty() [1/2]

template<typename T >

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

inlineprotectedinherited

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

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

Definition at line 276 of file MeshGenerator.h.

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

◆ copyMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

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

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

Definition at line 263 of file MeshGenerator.h.

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

◆ declareMeshesForSub()

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

protectedinherited

Like declareMeshForSub(), but for multiple generators.

Definition at line 295 of file MeshGenerator.C.

{
  declareMeshesForSubByName(getMeshGeneratorNamesFromParam(param_name));
}

Referenced by XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve().

◆ declareMeshesForSubByName()

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

protectedinherited

Like declareMeshForSubByName(), but for multiple generators.

Definition at line 311 of file MeshGenerator.C.

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

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

◆ declareMeshForSub()

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

protectedinherited

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

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

Definition at line 289 of file MeshGenerator.C.

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

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

◆ declareMeshForSubByName()

void MeshGenerator::declareMeshForSubByName ( const MeshGeneratorName & mesh_generator_name )

protectedinherited

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

Definition at line 301 of file MeshGenerator.C.

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

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

◆ declareMeshProperty() [1/2]

template<typename T , typename... Args>

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

protectedinherited

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

Definition at line 535 of file MeshGenerator.h.

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

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

◆ declareMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 236 of file MeshGenerator.h.

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

◆ declareNullMeshName()

void MeshGenerator::declareNullMeshName ( const MeshGeneratorName & name )

protectedinherited

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

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

Definition at line 504 of file MeshGenerator.C.

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

◆ 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 215 of file SurfaceDelaunayGeneratorBase.C.

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

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

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

49{ return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition MooseObject.h:71

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

◆ errorPrefix()

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

inlineinherited

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

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ fillDelaunayOptions()

void SurfaceDelaunayGeneratorBase::fillDelaunayOptions ( MeshTriangulationUtils::XYDelaunayOptions & opts ) const

protectedinherited

Fills the triangulation options that follow from the parameters boundaryAndHolesParams() adds, and only those: the caller fills whatever its own parameters set on top of them.

Parameters

opts	The options to fill

Definition at line 180 of file SurfaceDelaunayGeneratorBase.C.

{
  if (isParamValid("input_boundary_names"))
    opts.input_boundary_names = getParam<std::vector<BoundaryName>>("input_boundary_names");
  if (isParamValid("input_subdomain_names"))
    opts.input_subdomain_names = getParam<std::vector<SubdomainName>>("input_subdomain_names");
  opts.add_nodes_per_boundary_segment = getParam<unsigned int>("add_nodes_per_boundary_segment");
  opts.refine_bdy = getParam<bool>("refine_boundary");
  opts.verify_holes = getParam<bool>("verify_holes");
  opts.desired_area = getParam<Real>("desired_area");
  opts.desired_area_func = getParam<std::string>("desired_area_func");
  opts.use_auto_area_func = _use_auto_area_func;
  opts.auto_area_func_default_size = _auto_area_func_default_size;
  opts.auto_area_func_default_size_dist = _auto_area_func_default_size_dist;
  opts.auto_area_function_num_points = _auto_area_function_num_points;
  opts.auto_area_function_power = _auto_area_function_power;
  opts.stitch_holes = getParam<std::vector<bool>>("stitch_holes");
  opts.refine_holes = getParam<std::vector<bool>>("refine_holes");
 
  if (isParamValid("output_subdomain_name"))
  {
    opts.has_output_subdomain_name = true;
    opts.output_subdomain_name = getParam<SubdomainName>("output_subdomain_name");
  }
  if (isParamValid("output_boundary"))
  {
    opts.has_output_boundary = true;
    opts.output_boundary = getParam<BoundaryName>("output_boundary");
  }
  if (isParamValid("hole_boundaries"))
    opts.hole_boundaries = getParam<std::vector<BoundaryName>>("hole_boundaries");
}

Referenced by XYDelaunayGenerator::generate(), and generate().

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

overridevirtual

Generate / modify the mesh.

Implements SurfaceDelaunayGeneratorBase.

Definition at line 818 of file XYFrontalDelaunayGenerator.C.

{
  std::unique_ptr<MeshBase> boundary_mesh = std::move(_bdy_ptr);
 
  std::vector<std::unique_ptr<MeshBase>> hole_meshes(_hole_ptrs.size());
  for (const auto hole_i : index_range(_hole_ptrs))
    hole_meshes[hole_i] = std::move(*_hole_ptrs[hole_i]);
 
  // The advance places one point at a time against the whole triangulation, which no process holds
  // a part of
  if (!boundary_mesh->is_replicated())
    mooseError("XYFrontalDelaunayGenerator is not implemented for distributed meshes");
 
  // The outer boundary is only known once the mesh knows which of its sides face outward
  if (!boundary_mesh->is_prepared())
    boundary_mesh->prepare_for_use();
 
  for (const auto & elem : boundary_mesh->element_ptr_range())
    if (elem->default_order() != libMesh::FIRST)
      paramError("boundary",
                 "Element ",
                 elem->id(),
                 " is a ",
                 libMesh::Utility::enum_to_string(elem->type()),
                 " element. Only first order boundary elements are supported, because this mesh "
                 "generator produces TRI3 elements.");
 
  MeshTriangulationUtils::XYDelaunayOptions opts;
  fillDelaunayOptions(opts);
 
  _outer_outline = std::make_unique<libMesh::TriangulatorInterface::MeshedHole>(
      *boundary_mesh, MeshTriangulationUtils::outerBoundaryIds(*this, *boundary_mesh, opts));
 
  std::vector<bool> holes_with_midpoints(hole_meshes.size());
  _hole_outlines.reserve(hole_meshes.size());
  for (const auto hole_i : index_range(hole_meshes))
  {
    if (!hole_meshes[hole_i]->is_prepared())
      hole_meshes[hole_i]->prepare_for_use();
 
    _hole_outlines.push_back(
        std::make_unique<libMesh::TriangulatorInterface::MeshedHole>(*hole_meshes[hole_i]));
    holes_with_midpoints[hole_i] = _hole_outlines.back()->n_midpoints();
 
    if (holes_with_midpoints[hole_i] && hole_i < _stitch_holes.size() && _stitch_holes[hole_i])
      paramError("stitch_holes",
                 "Cannot stitch a quadratic element hole to the first order triangles this mesh "
                 "generator produces. Please reduce the order of the hole inputs.");
  }
 
  _background_mesh = buildBackgroundMesh(*boundary_mesh, hole_meshes, opts);
  _background_mesh->prepare_for_use();
  _background_locator = _background_mesh->sub_point_locator();
  _background_locator->enable_out_of_mesh_mode();
 
  Real background_area = 0.0;
  for (const auto & elem : _background_mesh->element_ptr_range())
    background_area += elem->volume();
  _background_mean_area = background_area / _background_mesh->n_elem();
 
  if (!_desired_area_func.empty())
    _area_function = std::make_unique<libMesh::ParsedFunction<Real>>(_desired_area_func);
 
  // The buckets of the rejection rule are sized on the smallest triangle the advance is asked for,
  // so that a search of the buckets around a point covers the distance the rule needs
  _grid_cell = std::numeric_limits<Real>::max();
  for (const auto & elem : _background_mesh->element_ptr_range())
    _grid_cell = std::min(_grid_cell, targetSize(targetArea(elem->vertex_average())));
 
  if (_metric == "LINF" && _orientation == "CROSS_FIELD")
  {
    _cross_field = std::make_unique<XYCrossFieldSolver>(*_background_mesh,
                                                        boundaryTangentAngles(*_background_mesh));
    _cross_field->solve();
  }
 
  // The outer boundary is walked counter-clockwise so that the domain is on the left of its first
  // segment, which is where the triangles in the domain are then found from
  std::vector<Point> outer_loop;
  for (const auto i : make_range(_outer_outline->n_points()))
    outer_loop.push_back(_outer_outline->point(i));
  frontalCanonicalizeLoop(outer_loop);
 
  std::vector<Point> points;
  std::vector<XYIncrementalDelaunay::Segment> segments;
  appendLoop(outer_loop, _refine_bdy, _add_nodes_per_boundary_segment, 0, points, segments);
 
  for (const auto hole_i : index_range(_hole_outlines))
  {
    std::vector<Point> hole_loop;
    for (const auto i : make_range(_hole_outlines[hole_i]->n_points()))
      hole_loop.push_back(_hole_outlines[hole_i]->point(i));
    frontalCanonicalizeLoop(hole_loop);
 
    const bool refine = (hole_i >= _refine_holes.size() || _refine_holes[hole_i]);
    appendLoop(hole_loop, refine, 0, static_cast<boundary_id_type>(hole_i + 1), points, segments);
  }
 
  // The frame of the nearest boundary segment is only asked for once every segment has been seeded,
  // and only when no cross field answers for it
  if (_metric == "LINF" && !_cross_field)
    buildBoundarySegmentGrid();
 
  // A point on a boundary would split the segment it lies on, which would leave the output mesh
  // with a side that belongs to no input boundary
  for (const auto & interior_point : _interior_points)
    if (insideDomain(interior_point))
      points.push_back(interior_point);
 
  std::vector<XYIncrementalDelaunay::Point2D> plane_points;
  plane_points.reserve(points.size());
  for (const auto & point : points)
    plane_points.push_back({point(0), point(1)});
 
  XYIncrementalDelaunay delaunay;
  delaunay.initialize(plane_points, segments);
 
  for (const auto vertex : make_range(delaunay.numPoints()))
    addToGrid(vertex, frontalToPoint(delaunay.point(vertex)));
 
  advanceFront(delaunay);
 
  auto mesh = buildTriangleMesh(delaunay);
 
  MeshTriangulationUtils::finalizeTriangulation(
      *this, dynamic_cast<UnstructuredMesh &>(*mesh), hole_meshes, holes_with_midpoints, opts);
 
  return mesh;
}

◆ generateCSG()

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

protectedvirtualinherited

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

Definition at line 537 of file MeshGenerator.C.

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

Referenced by MeshGenerator::generateInternalCSG().

◆ generateData()

void MeshGenerator::generateData ( )

protectedvirtualinherited

Generate the mesh data.

Reimplemented in AddMetaDataGenerator.

Definition at line 530 of file MeshGenerator.C.

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

Referenced by MeshGenerator::generateInternal().

◆ generateInternal()

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

inherited

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

Definition at line 340 of file MeshGenerator.C.

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

◆ generateInternalCSG()

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

inherited

Internal generation method for CSG object generation.

Definition at line 420 of file MeshGenerator.C.

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

◆ getBase()

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

inlineinherited

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

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

InputParameters::getBase

const std::string & getBase() const

Definition InputParameters.C:505

Referenced by MooseBase::uniqueParameterName().

◆ getCheckedPointerParam()

template<typename T >

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

inherited

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

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

Definition at line 450 of file MooseBase.h.

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

◆ getChildMeshGenerators()

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

inlineinherited

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 148 of file MeshGenerator.h.

  {
    return _child_mesh_generators;
  }

Referenced by MeshGenerator::isChildMeshGenerator().

◆ getCSGBase()

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

protectedinherited

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

NOTE: You MUST catch this by reference!

Parameters

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

Returns: The CSGBase object generated by that MeshGenerator

Definition at line 253 of file MeshGenerator.C.

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

◆ getCSGBaseByName()

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

protectedinherited

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

NOTE: You MUST catch this by reference!

Parameters

mesh_generator_name The name of the MeshGenerator associated with the CSGBase object

Returns: The CSGBase pointer generated by that MeshGenerator

Definition at line 262 of file MeshGenerator.C.

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

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

◆ getCSGBases()

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

protectedinherited

Like getCSGBase(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters

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

Returns: Vector of CSGBase pointers associated with input parameter

Definition at line 274 of file MeshGenerator.C.

{
  return getCSGBasesByName(getMeshGeneratorNamesFromParam(param_name));
}

◆ getCSGBasesByName()

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

protectedinherited

Like getCSGBaseByName(), but for multiple generators.

NOTE: You MUST catch this by reference!

Parameters

mesh_generator_names The names of MeshGenerator objects

Returns: Vector of CSGBase pointers associated with input parameter

Definition at line 280 of file MeshGenerator.C.

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

Referenced by MeshGenerator::getCSGBases().

◆ getDataFileName()

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

inherited

Deprecated method.

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

Definition at line 21 of file DataFileInterface.C.

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

◆ getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

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

◆ getDataFilePath()

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

inherited

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

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

Definition at line 40 of file DataFileInterface.C.

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

Referenced by DataFileInterface::getDataFileNameByName().

◆ getHitNode() [1/2]

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

inlineinherited

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

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

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

◆ getHitNode() [2/2]

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

staticprivateinherited

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

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

Definition at line 167 of file MooseBase.C.

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

◆ getMesh()

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

protectedinherited

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

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

Parameters

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

Returns: The Mesh generated by that MeshGenerator

NOTE: You MUST catch this by reference!

Definition at line 216 of file MeshGenerator.C.

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

◆ getMeshByName()

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

protectedinherited

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

NOTE: You MUST catch this by reference!

Returns: The Mesh generated by that MeshGenerator

Definition at line 231 of file MeshGenerator.C.

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

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

◆ getMeshes()

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

protectedinherited

Like getMesh(), but for multiple generators.

Returns: The generated meshes

Definition at line 225 of file MeshGenerator.C.

{
  return getMeshesByName(getMeshGeneratorNamesFromParam(param_name));
}

◆ getMeshesByName()

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

protectedinherited

Like getMeshByName(), but for multiple generators.

Returns: The generated meshes

Definition at line 244 of file MeshGenerator.C.

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

Referenced by MeshGenerator::getMeshes().

◆ getMeshGeneratorNameFromParam()

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

privateinherited

Helper for getting a MeshGeneratorName parameter.

Definition at line 106 of file MeshGenerator.C.

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

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

◆ getMeshGeneratorNamesFromParam()

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

privateinherited

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

Definition at line 135 of file MeshGenerator.C.

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

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

◆ getMeshProperty() [1/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 64 of file MeshMetaDataInterface.h.

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

◆ getMeshProperty() [2/2]

template<typename T >

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

protectedinherited

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

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

Definition at line 142 of file MeshMetaDataInterface.h.

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

◆ getMeshPropertyInternal()

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

privateinherited

Helper for getting a mesh property.

Definition at line 54 of file MeshMetaDataInterface.C.

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

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

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

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

◆ getParam() [1/2]

template<typename T >

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

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 406 of file MooseBase.h.

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

◆ getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

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

Parameters

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

Returns: Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

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

◆ getParentMeshGenerators()

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

inlineinherited

Gets the MeshGenerators that are parents to this MeshGenerator.

Definition at line 141 of file MeshGenerator.h.

  {
    return _parent_mesh_generators;
  }

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

◆ getRenamedParam()

template<typename T >

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

inherited

Retrieve a renamed parameter for the object.

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

Parameters

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

Definition at line 420 of file MooseBase.h.

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

◆ getRequestedMeshGenerators()

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

inlineinherited

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

Definition at line 99 of file MeshGenerator.h.

  {
    return _requested_mesh_generators;
  }

◆ getRequestedMeshGeneratorsForSub()

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

inlineinherited

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

Definition at line 107 of file MeshGenerator.h.

  {
    return _requested_mesh_generators_for_sub;
  }

◆ getSavedMeshName()

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

inherited

Return the name of the saved mesh.

Definition at line 524 of file MeshGenerator.C.

{
  return _save_with_name;
}

◆ getSharedPtr() [1/2]

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

inherited

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

Wrapper around shared_from_this().

Definition at line 70 of file MooseObject.C.

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

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

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 83 of file MooseObject.C.

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

◆ getSubMeshGenerators()

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

inlineinherited

Gets the MeshGenerators that are children to this MeshGenerator.

Definition at line 155 of file MeshGenerator.h.

  {
    return _sub_mesh_generators;
  }

◆ gridKey()

std::pair< long, long > XYFrontalDelaunayGenerator::gridKey	(	const Point &	point,
		Real	cell
	)		const

protected

Returns: The bucket a point falls in on a grid of the given cell size

Definition at line 410 of file XYFrontalDelaunayGenerator.C.

{
  return {static_cast<long>(std::floor(point(0) / cell)),
          static_cast<long>(std::floor(point(1) / cell))};
}

Referenced by addToGrid(), buildBoundarySegmentGrid(), hasVertexWithin(), and localFrame().

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

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

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

◆ hasGenerateCSG() [1/2]

bool MeshGenerator::hasGenerateCSG ( ) const

inlineinherited

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

Definition at line 209 of file MeshGenerator.h.

209{ return hasGenerateCSG(_pars); }

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

◆ hasGenerateCSG() [2/2]

bool MeshGenerator::hasGenerateCSG ( const InputParameters & params )

staticinherited

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

Definition at line 100 of file MeshGenerator.C.

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

◆ hasGenerateData() [1/2]

bool MeshGenerator::hasGenerateData ( ) const

inlineinherited

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

Definition at line 204 of file MeshGenerator.h.

204{ return hasGenerateData(_pars); }

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

◆ hasGenerateData() [2/2]

bool MeshGenerator::hasGenerateData ( const InputParameters & params )

staticinherited

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

Definition at line 88 of file MeshGenerator.C.

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

◆ hasMeshProperty() [1/4]

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

inlineprotectedinherited

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

Definition at line 82 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [2/4]

template<typename T >

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

inlineprotectedinherited

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

Definition at line 90 of file MeshMetaDataInterface.h.

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

◆ hasMeshProperty() [3/4]

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

protectedinherited

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

Definition at line 33 of file MeshMetaDataInterface.C.

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

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

◆ hasMeshProperty() [4/4]

template<typename T >

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

protectedinherited

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

Definition at line 166 of file MeshMetaDataInterface.h.

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

◆ hasOutput()

bool MeshGenerator::hasOutput ( ) const

inherited

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

Definition at line 518 of file MeshGenerator.C.

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

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

◆ hasSaveMesh()

bool MeshGenerator::hasSaveMesh ( ) const

inherited

Return whether or not to save the current mesh.

Definition at line 512 of file MeshGenerator.C.

{
  return _save_with_name.size();
}

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

◆ hasVertexWithin()

bool XYFrontalDelaunayGenerator::hasVertexWithin	(	const XYIncrementalDelaunay &	delaunay,
		const Point &	point,
		Real	distance,
		const std::pair< Point, Point > &	frame
	)		const

protected

Parameters

delaunay	The triangulation holding the vertices
point	The candidate point
distance	The distance no vertex may be within
frame	The frame the LINF metric measures in

Returns: Whether a vertex of the triangulation lies within distance of the point

Definition at line 561 of file XYFrontalDelaunayGenerator.C.

{
  // A LINF ball of the given radius reaches sqrt(2) times as far as an L2 one of the same radius,
  // so that is how far the buckets have to be searched for the vertices the metric then judges
  const Real reach = (_metric == "L2") ? distance : distance * std::sqrt(2.0);
  const long span = static_cast<long>(std::ceil(reach / _grid_cell));
  const auto [center_i, center_j] = gridKey(point, _grid_cell);
 
  // The buckets are sized on the smallest triangle the advance is asked for, so where the target is
  // coarser the reach spans many of them and all but a few are empty. Walking each row of the
  // search from the first bucket at or past its start leaves the empty ones unvisited, rather than
  // looked up one by one
  for (long i = center_i - span; i <= center_i + span; ++i)
    for (auto bucket = _vertex_grid.lower_bound({i, center_j - span});
         bucket != _vertex_grid.end() && bucket->first.first == i &&
         bucket->first.second <= center_j + span;
         ++bucket)
      for (const auto vertex : bucket->second)
        if (metricDistance(point, frontalToPoint(delaunay.point(vertex)), frame) < distance)
          return true;
 
  return false;
}

Referenced by placePoint().

◆ insideDomain()

bool XYFrontalDelaunayGenerator::insideDomain ( const Point & point ) const

protected

Returns: Whether a point lies inside the outer boundary and outside every hole

Definition at line 542 of file XYFrontalDelaunayGenerator.C.

{
  if (!_outer_outline->contains(point))
    return false;
 
  for (const auto & outline : _hole_outlines)
    if (outline->contains(point))
      return false;
 
  return true;
}

Referenced by generate(), and placePoint().

◆ isChildMeshGenerator()

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

inherited

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

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

Definition at line 491 of file MeshGenerator.C.

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

Referenced by MeshGeneratorSystem::createMeshGeneratorOrder().

◆ isDataOnly()

bool MeshGenerator::isDataOnly ( ) const

inlineinherited

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

Definition at line 214 of file MeshGenerator.h.

214{ return _data_only; }

MeshGenerator::_data_only

const bool _data_only

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

Definition MeshGenerator.h:530

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

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

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

Definition at line 63 of file MooseObject.h.

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

InputParameters::isKokkosObject

bool isKokkosObject() const

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

Definition InputParameters.C:433

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

◆ isNullMeshName()

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

inlineinherited

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

See declareNullMeshName().

Definition at line 184 of file MeshGenerator.h.

184{ return _null_mesh_names.count(name); }

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

◆ isParamSetByUser()

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

inlineinherited

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

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

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

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

InputParameters::isParamValid

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

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

Definition InputParameters.C:386

◆ isParentMeshGenerator()

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

inherited

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

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

Definition at line 478 of file MeshGenerator.C.

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

◆ localFrame()

std::pair< Point, Point > XYFrontalDelaunayGenerator::localFrame ( const Point & point ) const

protected

Returns: The local frame (u, v) the LINF metric measures in, at a point

Definition at line 464 of file XYFrontalDelaunayGenerator.C.

{
  if (_cross_field)
    return _cross_field->crossFrame(point);
 
  mooseAssert(_boundary_cell > 0.0,
              "The grid over the boundary segments is built before any frame is taken from them.");
 
  const auto [center_i, center_j] = gridKey(point, _boundary_cell);
 
  // The nearest segment is the one of the lowest index at the smallest distance, whichever buckets
  // it is found in, so that the frame follows from the geometry and not from the order of the
  // search. The distances are compared squared, which orders them the same way
  Real nearest = std::numeric_limits<Real>::max();
  std::size_t nearest_segment = std::numeric_limits<std::size_t>::max();
  const auto search = [&](const long i, const long j)
  {
    const auto bucket = _boundary_segment_grid.find({i, j});
    if (bucket == _boundary_segment_grid.end())
      return;
 
    for (const auto segment : bucket->second)
    {
      const auto & [start, end] = _boundary_segments[segment];
      const Real distance = geom_utils::pointSegmentDistanceSq(point, start, end);
      if (distance < nearest || (distance == nearest && segment < nearest_segment))
      {
        nearest = distance;
        nearest_segment = segment;
      }
    }
  };
 
  // The buckets are searched a ring at a time, until the nearest segment found is closer than the
  // rings still to come can reach. A segment that has not been searched yet lies in a bucket more
  // than one ring out, and so no nearer than the ring before the one just searched
  for (long span = 0;; ++span)
  {
    if (span == 0)
      search(center_i, center_j);
    else
    {
      for (long i = center_i - span; i <= center_i + span; ++i)
      {
        search(i, center_j - span);
        search(i, center_j + span);
      }
      for (long j = center_j - span + 1; j <= center_j + span - 1; ++j)
      {
        search(center_i - span, j);
        search(center_i + span, j);
      }
    }
 
    const Real covered = std::max(0L, span - 1) * _boundary_cell;
    if (nearest < covered * covered)
      break;
  }
 
  const auto & [start, end] = _boundary_segments[nearest_segment];
  const Point tangent = (end - start).unit();
 
  return {tangent, Point(-tangent(1), tangent(0), 0.0)};
}

Referenced by placePoint().

◆ 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 233 of file SurfaceDelaunayGeneratorBase.C.

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

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

◆ 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 252 of file SurfaceDelaunayGeneratorBase.C.

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

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

◆ meshPropertyName() [1/2]

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

inlineprotectedinherited

Returns: The default mesh property name for mesh property data

Definition at line 103 of file MeshMetaDataInterface.h.

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

◆ meshPropertyName() [2/2]

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

staticprotectedinherited

Returns: The full name for mesh property data.

Definition at line 41 of file MeshMetaDataInterface.C.

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

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

◆ meshPropertyPrefix()

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

inlinefinaloverrideprivatevirtualinherited

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

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

Reimplemented from MeshMetaDataInterface.

Definition at line 471 of file MeshGenerator.h.

  {
    return name();
  }

◆ messagePrefix() [1/2]

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

inlineinherited

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

Definition at line 256 of file MooseBase.h.

  {
    return messagePrefix(_pars, hit_prefix);
  }

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

◆ messagePrefix() [2/2]

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

staticprivateinherited

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

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

Definition at line 140 of file MooseBase.C.

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

◆ metricDistance()

Real XYFrontalDelaunayGenerator::metricDistance	(	const Point &	first,
		const Point &	second,
		const std::pair< Point, Point > &	frame
	)		const

protected

Returns: The distance between two points under the selected metric, measured in the frame

Definition at line 530 of file XYFrontalDelaunayGenerator.C.

{
  const Point offset = first - second;
  if (_metric == "L2")
    return offset.norm();
 
  return std::max(std::abs(offset * frame.first), std::abs(offset * frame.second));
}

Referenced by hasVertexWithin().

◆ mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 317 of file MooseBase.h.

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

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

◆ mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

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

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

◆ mooseDeprecatedNoTrace()

template<typename... Args>

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

inlineinherited

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

Definition at line 327 of file MooseBase.h.

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

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Definition at line 277 of file MooseBase.h.

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

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>

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

inlineinherited

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

Definition at line 271 of file MooseBase.h.

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

◆ mooseErrorInternal()

template<typename... Args>

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

inlineprivateinherited

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

Definition at line 132 of file MeshMetaDataInterface.h.

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

Referenced by MeshMetaDataInterface::getMeshProperty().

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 290 of file MooseBase.h.

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

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

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

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

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

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

◆ mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

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

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

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 308 of file MooseBase.h.

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

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

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

◆ name()

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

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 103 of file MooseBase.h.

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

◆ paramError()

template<typename... Args>

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

inherited

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

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

Definition at line 457 of file MooseBase.h.

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

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

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

inherited

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

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

Definition at line 471 of file MooseBase.h.

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

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

◆ paramWarning() [1/2]

template<typename... Args>

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

inherited

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

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

Definition at line 464 of file MooseBase.h.

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

◆ paramWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

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

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

◆ placePoint()

bool XYFrontalDelaunayGenerator::placePoint	(	const XYIncrementalDelaunay &	delaunay,
		const FrontEdge &	edge,
		Point &	point
	)		const

protected

Computes where the advance would place a point ahead of a front edge and applies the rejection rule to it.

Parameters

delaunay	The triangulation the front belongs to
edge	The front edge to advance
point	Filled with the point to insert

Returns: Whether that point is to be inserted

Definition at line 589 of file XYFrontalDelaunayGenerator.C.

{
  const Point start = frontalToPoint(delaunay.point(edge.start));
  const Point end = frontalToPoint(delaunay.point(edge.end));
  const Point midpoint = 0.5 * (start + end);
 
  const Real size = targetSize(targetArea(midpoint));
 
  // The triangle the front advances into is on the left of the edge, so the left normal points to
  // the side the new point goes on
  const Point along = end - start;
  const Real length = along.norm();
  const Point normal(-along(1) / length, along(0) / length, 0.0);
 
  // The frame only enters the LINF metric, so an L2 advance never asks for the cross field
  const std::pair<Point, Point> world_frame(Point(1.0, 0.0, 0.0), Point(0.0, 1.0, 0.0));
  const std::pair<Point, Point> frame = (_metric == "L2") ? world_frame : localFrame(midpoint);
 
  if (_metric == "L2")
  {
    // The apex at the target distance from both ends of the edge, or of the right isosceles
    // triangle on the edge once that edge is longer than sqrt(2) times the target size
    const Real half_length = 0.5 * length;
    point = midpoint + std::sqrt(std::max(size * size - half_length * half_length,
                                          half_length * half_length)) *
                           normal;
  }
  else
    point = frontalLinfCorner(start, end, normal, size, frame);
 
  if (!insideDomain(point))
    return false;
 
  // A point too close to a vertex that is already there would make a sliver; the front edge is
  // instead left to connect to that vertex, which the triangulation has already done
  return !hasVertexWithin(delaunay, point, _rejection_factor * size, frame);
}

Referenced by advanceFront().

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

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

Parameters

name	The name of the parameter

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

Definition at line 413 of file MooseBase.h.

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

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

◆ recordSplitBoundaryIds()

void XYFrontalDelaunayGenerator::recordSplitBoundaryIds	(	const XYIncrementalDelaunay &	delaunay,
		std::size_t	vertex
	)

protected

Moves the boundary id recorded for the constrained segment an insertion split onto the two halves that insertion divided it into, which are the segments the output mesh has sides on now.

Parameters

delaunay	The triangulation, whose constrained segments already hold the two halves
vertex	The vertex the insertion placed on the segment

Definition at line 692 of file XYFrontalDelaunayGenerator.C.

{
  // The vertex the insertion placed is the newest one, so it is the larger id of every segment it
  // is an end of, and the two halves are the only constrained segments it is an end of at all
  std::vector<std::size_t> ends;
  for (const auto & [first, second] : delaunay.constrainedSegments())
    if (second == vertex)
      ends.push_back(first);
 
  mooseAssert(ends.size() == 2,
              "A split replaces the segment the new vertex landed on by the two halves that vertex "
              "divides it into");
 
  const auto split = XYIncrementalDelaunay::makeSegment(ends.front(), ends.back());
  const auto recorded = _segment_boundary_ids.find(split);
  // A constrained segment carrying no boundary id belongs to no input boundary, which
  // buildTriangleMesh() reports; leaving the halves without one as well keeps that report
  if (recorded == _segment_boundary_ids.end())
    return;
 
  const boundary_id_type bcid = recorded->second;
  _segment_boundary_ids.erase(recorded);
  _segment_boundary_ids[XYIncrementalDelaunay::makeSegment(ends.front(), vertex)] = bcid;
  _segment_boundary_ids[XYIncrementalDelaunay::makeSegment(ends.back(), vertex)] = bcid;
}

Referenced by advanceFront().

◆ registerInvalidSolutionInternal()

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

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

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

◆ setHasGenerateCSG()

void MeshGenerator::setHasGenerateCSG ( InputParameters & params )

staticinherited

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

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

Definition at line 94 of file MeshGenerator.C.

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

◆ setHasGenerateData()

void MeshGenerator::setHasGenerateData ( InputParameters & params )

staticinherited

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

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

Definition at line 82 of file MeshGenerator.C.

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

Referenced by AddMetaDataGenerator::validParams().

◆ setMeshProperty() [1/2]

template<typename T , typename... Args>

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

protectedinherited

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

Definition at line 565 of file MeshGenerator.h.

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

◆ setMeshProperty() [2/2]

template<typename T >

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

inlineprotectedinherited

Definition at line 251 of file MeshGenerator.h.

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

◆ setMeshPropertyHelper()

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

privateinherited

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

Definition at line 458 of file MeshGenerator.C.

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

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

◆ targetArea()

Real XYFrontalDelaunayGenerator::targetArea ( const Point & point ) const

protected

Returns: The target triangle area at a point, from whichever area limit the user set

Definition at line 368 of file XYFrontalDelaunayGenerator.C.

{
  if (_area_function)
  {
    const Real area = (*_area_function)(point);
    if (area <= 0.0)
      paramError("desired_area_func",
                 "The desired area must be positive everywhere in the meshed domain, but it is ",
                 area,
                 " at ",
                 point,
                 ".");
    return area;
  }
 
  if (_desired_area > 0.0)
    return _desired_area;
 
  // With no area limit of its own the advance targets the background triangulation, which the
  // automatic area function or the spacing of the boundary points sized
  const Elem * const background_elem = (*_background_locator)(point);
 
  return background_elem ? background_elem->volume() : _background_mean_area;
}

Referenced by appendLoop(), collectFront(), generate(), and placePoint().

◆ targetCircumradius()

Real XYFrontalDelaunayGenerator::targetCircumradius ( Real size ) const

protected

Returns: The circumradius of the target triangle of the given edge length

Definition at line 402 of file XYFrontalDelaunayGenerator.C.

{
  // The equilateral triangle of side h has circumradius h / sqrt(3), the right isosceles triangle
  // of legs h has half of its hypotenuse
  return (_metric == "L2") ? size / std::sqrt(3.0) : size / std::sqrt(2.0);
}

Referenced by collectFront().

◆ targetSize()

Real XYFrontalDelaunayGenerator::targetSize ( Real area ) const

protected

Returns: The target edge length of a triangle of the given area under the selected metric

Definition at line 394 of file XYFrontalDelaunayGenerator.C.

{
  // The equilateral triangle of side h has area sqrt(3) h^2 / 4, the right isosceles triangle of
  // legs h has area h^2 / 2
  return (_metric == "L2") ? std::sqrt(4.0 * area / std::sqrt(3.0)) : std::sqrt(2.0 * area);
}

Referenced by appendLoop(), collectFront(), generate(), and placePoint().

◆ type()

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

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 93 of file MooseBase.h.

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

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

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

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

Definition at line 57 of file MooseBase.C.

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

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

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

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

Definition at line 69 of file MooseBase.C.

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

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

◆ uniqueParameterName()

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

inherited

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

Definition at line 63 of file MooseBase.C.

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

◆ validParams()

InputParameters XYFrontalDelaunayGenerator::validParams ( )

static

Definition at line 211 of file XYFrontalDelaunayGenerator.C.

{
  InputParameters params = SurfaceDelaunayGeneratorBase::validParams();
  params += SurfaceDelaunayGeneratorBase::boundaryAndHolesParams();
 
  MooseEnum metric("L2 LINF", "LINF");
  MooseEnum orientation("BOUNDARY CROSS_FIELD", "CROSS_FIELD");
 
  params.addParam<std::vector<Point>>(
      "interior_points",
      {},
      "Interior node locations. Any point outside the surface will not be meshed.");
 
  params.addParam<MooseEnum>("metric",
                             metric,
                             "The norm the target size is measured in when a point is placed ahead "
                             "of the front. 'L2' places points that make equilateral triangles. "
                             "'LINF' places points that make right isosceles triangles in the "
                             "local frame, the shape that recombines into good quadrilaterals.");
  params.addParam<MooseEnum>("orientation",
                             orientation,
                             "Where the local frame the 'LINF' metric measures in comes from. "
                             "'CROSS_FIELD' solves for a cross field over the domain. 'BOUNDARY' "
                             "takes the frame of the nearest boundary segment, which needs no "
                             "solve. This parameter has no effect when metric is 'L2'.");
 
  params.addParamNamesToGroup("interior_points", "Mandatory mesh interior nodes");
  params.addParamNamesToGroup("metric orientation", "Frontal advance");
 
  params.addClassDescription(
      "Triangulates meshes within boundaries defined by input meshes by advancing a front, which "
      "places points at a target size ahead of the triangles that are still too large.");
 
  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 XYFrontalDelaunayGenerator::_add_nodes_per_boundary_segment

protected

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

Definition at line 205 of file XYFrontalDelaunayGenerator.h.

Referenced by generate().

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

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

◆ _area_function

std::unique_ptr<libMesh::ParsedFunction<Real> > XYFrontalDelaunayGenerator::_area_function

protected

Desired area as a function of position, built only when 'desired_area_func' is set.

Definition at line 247 of file XYFrontalDelaunayGenerator.h.

Referenced by generate(), and targetArea().

◆ _auto_area_func_default_size

const Real SurfaceDelaunayGeneratorBase::_auto_area_func_default_size

protectedinherited

Background size for automatic desired area function.

Definition at line 92 of file SurfaceDelaunayGeneratorBase.h.

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

◆ _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 95 of file SurfaceDelaunayGeneratorBase.h.

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

◆ _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 98 of file SurfaceDelaunayGeneratorBase.h.

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

◆ _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 101 of file SurfaceDelaunayGeneratorBase.h.

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

◆ _background_area_factor

constexpr Real XYFrontalDelaunayGenerator::_background_area_factor = 16.0

staticconstexprprotected

How much coarser in area the background triangulation is than the mesh being generated.

Definition at line 271 of file XYFrontalDelaunayGenerator.h.

Referenced by buildBackgroundMesh().

◆ _background_locator

std::unique_ptr<libMesh::PointLocatorBase> XYFrontalDelaunayGenerator::_background_locator

protected

Locates the background element whose area is the target where no area limit was given.

Definition at line 241 of file XYFrontalDelaunayGenerator.h.

Referenced by generate().

◆ _background_mean_area

Real XYFrontalDelaunayGenerator::_background_mean_area

protected

Mean area of the background elements, the target where the background locator finds nothing.

Definition at line 244 of file XYFrontalDelaunayGenerator.h.

Referenced by generate(), and targetArea().

◆ _background_mesh

std::unique_ptr<MeshBase> XYFrontalDelaunayGenerator::_background_mesh

protected

Coarse triangulation of the domain the cross field is solved on.

Definition at line 238 of file XYFrontalDelaunayGenerator.h.

Referenced by generate().

◆ _bdy_ptr

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

protected

Input mesh defining the boundary to triangulate within.

Definition at line 199 of file XYFrontalDelaunayGenerator.h.

Referenced by generate().

◆ _boundary_cell

Real XYFrontalDelaunayGenerator::_boundary_cell

protected

Side of the buckets the boundary segments are sorted into so that the frame search stays local.

Definition at line 256 of file XYFrontalDelaunayGenerator.h.

Referenced by buildBoundarySegmentGrid(), and localFrame().

◆ _boundary_segment_grid

std::map<std::pair<long, long>, std::vector<std::size_t> > XYFrontalDelaunayGenerator::_boundary_segment_grid

protected

Indices into _boundary_segments, bucketed by the cells each of those segments passes through.

Definition at line 259 of file XYFrontalDelaunayGenerator.h.

Referenced by buildBoundarySegmentGrid(), and localFrame().

◆ _boundary_segments

std::vector<std::pair<Point, Point> > XYFrontalDelaunayGenerator::_boundary_segments

protected

Segments of the outer boundary and of the holes, whose tangents give the BOUNDARY frame.

Definition at line 253 of file XYFrontalDelaunayGenerator.h.

Referenced by appendLoop(), buildBoundarySegmentGrid(), and localFrame().

◆ _child_mesh_generators

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

privateinherited

The MeshGenerators that are children to this MeshGenerator.

Definition at line 519 of file MeshGenerator.h.

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

◆ _console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

◆ _cross_field

std::unique_ptr<XYCrossFieldSolver> XYFrontalDelaunayGenerator::_cross_field

protected

Cross field over the domain, built only when the LINF metric asks for the CROSS_FIELD frame.

Definition at line 250 of file XYFrontalDelaunayGenerator.h.

Referenced by generate(), and localFrame().

◆ _data_only

const bool MeshGenerator::_data_only

privateinherited

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

Definition at line 530 of file MeshGenerator.h.

Referenced by MeshGenerator::isDataOnly().

◆ _desired_area

const Real XYFrontalDelaunayGenerator::_desired_area

protected

Desired (maximum) triangle area.

Definition at line 217 of file XYFrontalDelaunayGenerator.h.

Referenced by targetArea().

◆ _desired_area_func

const std::string XYFrontalDelaunayGenerator::_desired_area_func

protected

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

Definition at line 220 of file XYFrontalDelaunayGenerator.h.

Referenced by generate().

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

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

◆ _grid_cell

Real XYFrontalDelaunayGenerator::_grid_cell

protected

Side of the buckets the vertices are sorted into so that the rejection rule stays local.

Definition at line 262 of file XYFrontalDelaunayGenerator.h.

Referenced by addToGrid(), buildBoundarySegmentGrid(), generate(), and hasVertexWithin().

◆ _hole_outlines

std::vector<std::unique_ptr<libMesh::TriangulatorInterface::MeshedHole> > XYFrontalDelaunayGenerator::_hole_outlines

protected

Outlines of the holes, which the advance stays outside.

Definition at line 235 of file XYFrontalDelaunayGenerator.h.

Referenced by generate(), and insideDomain().

◆ _hole_ptrs

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

protected

Holds pointers to the pointers to input meshes defining holes.

Definition at line 202 of file XYFrontalDelaunayGenerator.h.

Referenced by generate(), and XYFrontalDelaunayGenerator().

◆ _interior_points

const std::vector<Point> XYFrontalDelaunayGenerator::_interior_points

protected

Desired interior node locations.

Definition at line 223 of file XYFrontalDelaunayGenerator.h.

Referenced by generate(), and XYFrontalDelaunayGenerator().

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

◆ _meta_data_app

MooseApp& MeshMetaDataInterface::_meta_data_app

privateinherited

Reference to the application.

Definition at line 122 of file MeshMetaDataInterface.h.

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

◆ _meta_data_object

const MooseObject* const MeshMetaDataInterface::_meta_data_object

privateinherited

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

Definition at line 125 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::mooseErrorInternal().

◆ _metric

const MooseEnum XYFrontalDelaunayGenerator::_metric

protected

Norm the target size is measured in when a point is placed ahead of the front.

Definition at line 226 of file XYFrontalDelaunayGenerator.h.

Referenced by generate(), hasVertexWithin(), metricDistance(), placePoint(), targetCircumradius(), targetSize(), and XYFrontalDelaunayGenerator().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _null_csg_base

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

privateinherited

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

Definition at line 514 of file MeshGenerator.h.

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

◆ _null_mesh

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

privateinherited

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

Definition at line 511 of file MeshGenerator.h.

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

◆ _null_mesh_names

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

privateinherited

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

Definition at line 524 of file MeshGenerator.h.

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

◆ _orientation

const MooseEnum XYFrontalDelaunayGenerator::_orientation

protected

Where the local frame the LINF metric measures in comes from.

Definition at line 229 of file XYFrontalDelaunayGenerator.h.

Referenced by generate().

◆ _outer_outline

std::unique_ptr<libMesh::TriangulatorInterface::MeshedHole> XYFrontalDelaunayGenerator::_outer_outline

protected

Outline of the outer boundary, which the advance stays inside.

Definition at line 232 of file XYFrontalDelaunayGenerator.h.

Referenced by generate(), and insideDomain().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

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

◆ _parent_mesh_generators

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

privateinherited

The MeshGenerators that are parents to this MeshGenerator.

Definition at line 517 of file MeshGenerator.h.

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

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

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

◆ _refine_bdy

const bool XYFrontalDelaunayGenerator::_refine_bdy

protected

Whether to allow automatically refining the outer boundary.

Definition at line 208 of file XYFrontalDelaunayGenerator.h.

Referenced by generate().

◆ _refine_holes

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

protected

Whether to allow automatically refining each hole boundary.

Definition at line 214 of file XYFrontalDelaunayGenerator.h.

Referenced by generate().

◆ _rejection_factor

constexpr Real XYFrontalDelaunayGenerator::_rejection_factor = 0.7

staticconstexprprotected

How close to an existing vertex, as a fraction of the target size, a new point may not come.

Definition at line 277 of file XYFrontalDelaunayGenerator.h.

Referenced by placePoint().

◆ _requested_csg_bases

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

privateinherited

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

Definition at line 508 of file MeshGenerator.h.

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

◆ _requested_mesh_generators

std::set<MeshGeneratorName> MeshGenerator::_requested_mesh_generators

privateinherited

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

Definition at line 500 of file MeshGenerator.h.

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

◆ _requested_mesh_generators_for_sub

std::set<MeshGeneratorName> MeshGenerator::_requested_mesh_generators_for_sub

privateinherited

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

Definition at line 502 of file MeshGenerator.h.

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

◆ _requested_meshes

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

privateinherited

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

Definition at line 505 of file MeshGenerator.h.

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

◆ _save_with_name

const std::string& MeshGenerator::_save_with_name

privateinherited

A user-defined name to save the mesh.

Definition at line 527 of file MeshGenerator.h.

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

◆ _segment_boundary_ids

std::map<XYIncrementalDelaunay::Segment, boundary_id_type> XYFrontalDelaunayGenerator::_segment_boundary_ids

protected

Boundary id of each seed segment, keyed on its two vertices with the smaller id first.

Definition at line 268 of file XYFrontalDelaunayGenerator.h.

Referenced by appendLoop(), buildTriangleMesh(), and recordSplitBoundaryIds().

◆ _si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base

privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

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

◆ _si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem

privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ _size_tolerance

constexpr Real XYFrontalDelaunayGenerator::_size_tolerance = 1.2

staticconstexprprotected

How far the circumradius of a triangle may exceed the target before the advance refines it.

Definition at line 274 of file XYFrontalDelaunayGenerator.h.

Referenced by collectFront().

◆ _stitch_holes

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

protected

Whether to stitch to the mesh defining each hole.

Definition at line 211 of file XYFrontalDelaunayGenerator.h.

Referenced by generate().

◆ _sub_mesh_generators

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

privateinherited

The sub MeshGenerators constructed by this MeshGenerator.

Definition at line 521 of file MeshGenerator.h.

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

◆ _type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

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

◆ _use_auto_area_func

const bool SurfaceDelaunayGeneratorBase::_use_auto_area_func

protectedinherited

Whether to use automatic desired area function.

Definition at line 89 of file SurfaceDelaunayGeneratorBase.h.

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

◆ _verbose

const bool SurfaceDelaunayGeneratorBase::_verbose

protectedinherited

Whether the generator should be verbose.

Definition at line 107 of file SurfaceDelaunayGeneratorBase.h.

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

◆ _vertex_grid

std::map<std::pair<long, long>, std::vector<std::size_t> > XYFrontalDelaunayGenerator::_vertex_grid

protected

Vertex ids of the triangulation, bucketed by position.

Definition at line 265 of file XYFrontalDelaunayGenerator.h.

Referenced by addToGrid(), and hasVertexWithin().

◆ app_param

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

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

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

◆ data_only_param

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

staticinherited

The name of the private parameter for setting data only.

Definition at line 76 of file MeshGenerator.h.

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

◆ kokkos_object_param

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

staticinherited

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

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

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

staticinherited

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

Definition at line 61 of file MooseBase.h.

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

◆ NAME

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

staticconstexprinherited

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

Definition at line 33 of file MeshMetaDataInterface.h.

◆ name_param

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

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

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

◆ SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"

staticconstexprinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().

◆ type_param

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

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

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

◆ unique_name_param

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

staticinherited

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

Definition at line 57 of file MooseBase.h.

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

◆ usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings

inherited

Definition at line 67 of file MooseObject.h.

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

include/meshgenerators/XYFrontalDelaunayGenerator.h
src/meshgenerators/XYFrontalDelaunayGenerator.C

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ XYFrontalDelaunayGenerator()

Member Function Documentation

◆ addChildMeshGenerator()

◆ addMeshSubgenerator() [1/2]

◆ addMeshSubgenerator() [2/2]

◆ addParentMeshGenerator()

◆ addToGrid()

◆ advanceFront()

◆ appendLoop()

◆ boundaryAndHolesParams()

◆ boundaryTangentAngles()

◆ buildBackgroundMesh()

◆ buildBoundarySegmentGrid()

◆ buildDistributedMesh()

◆ buildMeshBaseObject()

◆ buildReplicatedMesh()

◆ buildTriangleMesh()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ checkBoundaryAndHolesParams()

◆ checkGetMesh()

◆ checkInteriorPoints()

◆ collectFront()

◆ connectControllableParams()

◆ copyMeshProperty() [1/2]

◆ copyMeshProperty() [2/2]

◆ declareMeshesForSub()

◆ declareMeshesForSubByName()

◆ declareMeshForSub()

◆ declareMeshForSubByName()

◆ declareMeshProperty() [1/2]

◆ declareMeshProperty() [2/2]

◆ declareNullMeshName()

◆ elemNormal()

◆ enabled()

◆ errorPrefix()

◆ fillDelaunayOptions()

◆ flagInvalidSolutionInternal()

◆ generate()

◆ generateCSG()

◆ generateData()

◆ generateInternal()

◆ generateInternalCSG()

◆ getBase()

◆ getCheckedPointerParam()

◆ getChildMeshGenerators()

◆ getCSGBase()

◆ getCSGBaseByName()

◆ getCSGBases()

◆ getCSGBasesByName()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getHitNode() [1/2]

◆ getHitNode() [2/2]

◆ getMesh()

◆ getMeshByName()

◆ getMeshes()

◆ getMeshesByName()

◆ getMeshGeneratorNameFromParam()

◆ getMeshGeneratorNamesFromParam()

◆ getMeshProperty() [1/2]

◆ getMeshProperty() [2/2]