This PeripheralTriangleMeshGenerator object adds a circular peripheral region to the input mesh. More...

#include <PeripheralTriangleMeshGenerator.h>

Inheritance diagram for PeripheralTriangleMeshGenerator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PeripheralTriangleMeshGenerator (const InputParameters &parameters)

std::unique_ptr< MeshBase >	generate () override

std::unique_ptr< MeshBase >	generateInternal ()

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

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

void	addParentMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

void	addChildMeshGenerator (const MeshGenerator &mg, const AddParentChildKey)

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

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

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

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

bool	hasOutput () const

const std::string &	getSavedMeshName () const

bool	hasGenerateData () const

bool	isDataOnly () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

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

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

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static bool	hasGenerateData (const InputParameters &params)

static void	setHasGenerateData (InputParameters &params)

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static const std::string	data_only_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
virtual void	generateData ()

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

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

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

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

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

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

void	declareMeshForSub (const std::string &param_name)

void	declareMeshesForSub (const std::string &param_name)

void	declareMeshForSubByName (const MeshGeneratorName &mesh_generator_name)

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

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

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

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

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

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

void	declareNullMeshName (const MeshGeneratorName &name)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Protected Attributes
const MeshGeneratorName	_input_name
	Name of the mesh generator to get the input mesh. More...

const Real	_peripheral_ring_radius
	Radius of the peripheral region's outer circular boundary. More...

const unsigned int	_peripheral_ring_num_segments
	Number of segments in the peripheral region's outer circular boundary. More...

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

std::string	_desired_area_func
	Desired area as a function of (x,y) More...

std::unique_ptr< MeshBase > *	_build_mesh
	The final mesh that is generated by the subgenerators;. More...

MooseMesh *const	_mesh

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const Parallel::Communicator &	_communicator

Detailed Description

This PeripheralTriangleMeshGenerator object adds a circular peripheral region to the input mesh.

Definition at line 16 of file PeripheralTriangleMeshGenerator.h.

Constructor & Destructor Documentation

◆ PeripheralTriangleMeshGenerator()

PeripheralTriangleMeshGenerator::PeripheralTriangleMeshGenerator ( const InputParameters & parameters )

Definition at line 79 of file PeripheralTriangleMeshGenerator.C.

   : MeshGenerator(parameters),
     _input_name(getParam<MeshGeneratorName>("input")),
     _peripheral_ring_radius(getParam<Real>("peripheral_ring_radius")),
     _peripheral_ring_num_segments(getParam<unsigned int>("peripheral_ring_num_segments")),
     _desired_area(getParam<Real>("desired_area")),
     _desired_area_func(getParam<std::string>("desired_area_func"))
 {
   // Calculate outer boundary points
 
   std::vector<libMesh::Point> outer_polyline;
   // radial spacing
   Real d_theta = 2.0 * M_PI / _peripheral_ring_num_segments;
   for (unsigned int i = 0; i < _peripheral_ring_num_segments; i++)
   {
     // rotation angle
     Real theta = i * d_theta;
     // calculate (x, y) coords
     Real x = _peripheral_ring_radius * std::cos(theta);
     Real y = _peripheral_ring_radius * std::sin(theta);
 
     // add to outer boundary list
     outer_polyline.emplace_back(x, y, 0);
   }
 
   // Generate outer boundary polyline
   {
     auto params = _app.getFactory().getValidParams("PolyLineMeshGenerator");
     params.set<std::vector<Point>>("points") = outer_polyline;
     params.set<unsigned int>("num_edges_between_points") = 1;
     params.set<bool>("loop") = true;
     addMeshSubgenerator("PolyLineMeshGenerator", _input_name + "_periphery_polyline", params);
   }
 
   // Generate periphery region
   {
     declareMeshForSub("input");
     auto params = _app.getFactory().getValidParams("XYDelaunayGenerator");
     params.set<MeshGeneratorName>("boundary") =
         (MeshGeneratorName)_input_name + "_periphery_polyline";
     params.set<std::vector<MeshGeneratorName>>("holes") =
         std::vector<MeshGeneratorName>{_input_name};
     params.set<unsigned int>("add_nodes_per_boundary_segment") = 0;
     params.set<Real>("desired_area") = _desired_area;
     params.set<std::string>("desired_area_func") = _desired_area_func;
     params.set<bool>("use_auto_area_func") = getParam<bool>("use_auto_area_func");
     if (isParamSetByUser("auto_area_func_default_size"))
       params.set<Real>("auto_area_func_default_size") =
           getParam<Real>("auto_area_func_default_size");
     if (isParamSetByUser("auto_area_func_default_size_dist"))
       params.set<Real>("auto_area_func_default_size_dist") =
           getParam<Real>("auto_area_func_default_size_dist");
     if (isParamSetByUser("auto_area_function_num_points"))
       params.set<unsigned int>("auto_area_function_num_points") =
           getParam<unsigned int>("auto_area_function_num_points");
     if (isParamSetByUser("auto_area_function_power"))
       params.set<Real>("auto_area_function_power") = getParam<Real>("auto_area_function_power");
     params.set<bool>("refine_boundary") = false;
     params.set<std::vector<bool>>("refine_holes") = std::vector<bool>{false};
     params.set<std::vector<bool>>("stitch_holes") = std::vector<bool>{true};
     if (isParamValid("external_boundary_name"))
       params.set<BoundaryName>("output_boundary") =
           getParam<BoundaryName>("external_boundary_name");
     params.set<SubdomainName>("output_subdomain_name") =
         getParam<SubdomainName>("peripheral_ring_block_name");
     params.set<MooseEnum>("tri_element_type") = getParam<MooseEnum>("tri_element_type");
     params.set<bool>("verbose_stitching") = false;
     addMeshSubgenerator("XYDelaunayGenerator", _input_name + "_periphery", params);
     _build_mesh = &getMeshByName(_input_name + "_periphery");
   }
 }

Member Function Documentation

◆ generate()

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

overridevirtual

Implements MeshGenerator.

Definition at line 152 of file PeripheralTriangleMeshGenerator.C.

 {
   (*_build_mesh)->find_neighbors();
   return std::move(*_build_mesh);
 }

◆ validParams()

InputParameters PeripheralTriangleMeshGenerator::validParams ( )

static

Definition at line 21 of file PeripheralTriangleMeshGenerator.C.

 {
   InputParameters params = MeshGenerator::validParams();
   params.addRequiredParam<MeshGeneratorName>("input", "The input mesh to be modified.");
   params.addRequiredRangeCheckedParam<Real>("peripheral_ring_radius",
                                             "peripheral_ring_radius>0",
                                             "Radius of the peripheral ring to be added.");
   params.addRequiredRangeCheckedParam<unsigned int>("peripheral_ring_num_segments",
                                                     "peripheral_ring_num_segments>0",
                                                     "Number of segments of the peripheral ring.");
   params.addRangeCheckedParam<Real>(
       "desired_area",
       0,
       "desired_area>=0",
       "Desired (maximum) triangle area, or 0 to skip uniform refinement");
   params.addParam<std::string>(
       "desired_area_func",
       std::string(),
       "Desired area as a function of x,y; omit to skip non-uniform refinement");
 
   params.addParam<bool>(
       "use_auto_area_func", false, "Use the automatic area function in the peripheral region.");
   params.addParam<Real>(
       "auto_area_func_default_size",
       0,
       "Background size for automatic area function, or 0 to use non background size");
   params.addParam<Real>("auto_area_func_default_size_dist",
                         -1.0,
                         "Effective distance of background size for automatic area "
                         "function, or negative to use non background size");
   params.addParam<unsigned int>("auto_area_function_num_points",
                                 10,
                                 "Maximum number of nearest points used for the inverse distance "
                                 "interpolation algorithm for automatic area function calculation.");
   params.addRangeCheckedParam<Real>(
       "auto_area_function_power",
       1.0,
       "auto_area_function_power>0",
       "Polynomial power of the inverse distance interpolation algorithm for automatic area "
       "function calculation.");
 
   params.addParam<SubdomainName>(
       "peripheral_ring_block_name", "", "The block name assigned to the created peripheral layer.");
   params.addParam<BoundaryName>("external_boundary_name",
                                 "Optional customized external boundary name.");
   MooseEnum tri_elem_type("TRI3 TRI6 TRI7 DEFAULT", "DEFAULT");
   params.addParam<MooseEnum>(
       "tri_element_type", tri_elem_type, "Type of the triangular elements to be generated.");
   params.addClassDescription("This PeripheralTriangleMeshGenerator object is designed to generate "
                              "a triangulated mesh between a generated outer circle boundary "
                              "and a provided inner mesh.");
   params.addParamNamesToGroup("desired_area desired_area_func use_auto_area_func "
                               "auto_area_func_default_size auto_area_func_default_size_dist "
                               "auto_area_function_num_points auto_area_function_power",
                               "Peripheral Area Delaunay");
   return params;
 }