This RevolveGenerator object is designed to revolve a 1D mesh into 2D, or a 2D mesh into 3D based on an axis. More...

#include <RevolveGenerator.h>

Inheritance diagram for RevolveGenerator:

Public Types
enum	PolygonSizeStyle { PolygonSizeStyle::apothem, PolygonSizeStyle::radius }
	An enum class for style of input polygon size. More...

enum	MESH_TYPE { CORNER_MESH = 1, BOUNDARY_MESH = 2, INNER_MESH = 3 }

enum	RETURN_TYPE { ANGLE_DEGREE = 1, ANGLE_TANGENT = 2 }

enum	INTRISIC_SUBDOMAIN_ID : subdomain_id_type { PERIPHERAL_ID_SHIFT = 1000, TRANSITION_LAYER_DEFAULT = 10000 }

enum	INTRINSIC_SIDESET_ID : boundary_id_type { OUTER_SIDESET_ID = 10000, OUTER_SIDESET_ID_ALT = 15000, SLICE_BEGIN = 30000, SLICE_END = 31000, SLICE_ALT = 30500 }

enum	INTRINSIC_NUM_SIDES { HEXAGON_NUM_SIDES = 6, SQUARE_NUM_SIDES = 4 }

enum	TRI_ELEM_TYPE { TRI_ELEM_TYPE::TRI3, TRI_ELEM_TYPE::TRI6, TRI_ELEM_TYPE::TRI7 }

enum	QUAD_ELEM_TYPE { QUAD_ELEM_TYPE::QUAD4, QUAD_ELEM_TYPE::QUAD8, QUAD_ELEM_TYPE::QUAD9 }

typedef DataFileName	DataFileParameterType

Public Member Functions
	RevolveGenerator (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
std::pair< Real, Point >	getRotationCenterAndRadius (const Point &p_ext, const Point &p_axis, const Point &dir_axis) const
	Get the rotation center and radius of the circular rotation based on the rotation axis and the external point. More...

std::vector< Point >	rotationVectors (const Point &p_axis, const Point &dir_axis, const Point &p_input) const
	Calculate the transform matrix between the rotation coordinate system and the original coordinate system. More...

std::pair< std::vector< dof_id_type >, std::vector< dof_id_type > >	onAxisNodesIdentifier (const Elem &elem, const std::vector< dof_id_type > &nodes_on_axis) const
	Categorize the nodes of an element into two groups: nodes on the axis and nodes off the axis. More...

void	nodeModification (Node &node)
	Modify the position of a node to account for radius correction. More...

void	createQUADfromEDGE (const ElemType quad_elem_type, const Elem *elem, const std::unique_ptr< MeshBase > &mesh, std::unique_ptr< Elem > &new_elem, const int current_layer, const unsigned int orig_nodes, const unsigned int total_num_azimuthal_intervals, std::vector< std::pair< dof_id_type, dof_id_type >> &side_pairs, bool &is_flipped) const
	Create a new QUAD element from an existing EDGE element by revolving it. More...

void	createTRIfromEDGE (const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &nodes_cates, const ElemType tri_elem_type, const Elem *elem, const std::unique_ptr< MeshBase > &mesh, std::unique_ptr< Elem > &new_elem, const int current_layer, const unsigned int orig_nodes, const unsigned int total_num_azimuthal_intervals, std::vector< std::pair< dof_id_type, dof_id_type >> &side_pairs, dof_id_type &axis_node_case, bool &is_flipped) const
	Create a new TRI element from an existing EDGE element by revolving it. More...

void	createPRISMfromTRI (const ElemType prism_elem_type, const Elem *elem, const std::unique_ptr< MeshBase > &mesh, std::unique_ptr< Elem > &new_elem, const int current_layer, const unsigned int orig_nodes, const unsigned int total_num_azimuthal_intervals, std::vector< std::pair< dof_id_type, dof_id_type >> &side_pairs, bool &is_flipped) const
	Create a new PRISM element from an existing TRI element by revolving it. More...

void	createPYRAMIDfromTRI (const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &nodes_cates, const ElemType pyramid_elem_type, const Elem *elem, const std::unique_ptr< MeshBase > &mesh, std::unique_ptr< Elem > &new_elem, const int current_layer, const unsigned int orig_nodes, const unsigned int total_num_azimuthal_intervals, std::vector< std::pair< dof_id_type, dof_id_type >> &side_pairs, dof_id_type &axis_node_case, bool &is_flipped) const
	Create a new PYRAMID element from an existing TRI element by revolving it. More...

void	createTETfromTRI (const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &nodes_cates, const ElemType tet_elem_type, const Elem *elem, const std::unique_ptr< MeshBase > &mesh, std::unique_ptr< Elem > &new_elem, const int current_layer, const unsigned int orig_nodes, const unsigned int total_num_azimuthal_intervals, std::vector< std::pair< dof_id_type, dof_id_type >> &side_pairs, dof_id_type &axis_node_case, bool &is_flipped) const
	Create a new TET element from an existing TRI element by revolving it. More...

void	createHEXfromQUAD (const ElemType hex_elem_type, const Elem *elem, const std::unique_ptr< MeshBase > &mesh, std::unique_ptr< Elem > &new_elem, const int current_layer, const unsigned int orig_nodes, const unsigned int total_num_azimuthal_intervals, std::vector< std::pair< dof_id_type, dof_id_type >> &side_pairs, bool &is_flipped) const
	Create a new HEX element from an existing QUAD element by revolving it. More...

void	createPRISMfromQUAD (const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &nodes_cates, const ElemType prism_elem_type, const Elem *elem, const std::unique_ptr< MeshBase > &mesh, std::unique_ptr< Elem > &new_elem, const int current_layer, const unsigned int orig_nodes, const unsigned int total_num_azimuthal_intervals, std::vector< std::pair< dof_id_type, dof_id_type >> &side_pairs, dof_id_type &axis_node_case, bool &is_flipped) const
	Create a new PRISM element from an existing QUAD element by revolving it. More...

void	createPYRAMIDPRISMfromQUAD (const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &nodes_cates, const ElemType pyramid_elem_type, const ElemType prism_elem_type, const Elem *elem, const std::unique_ptr< MeshBase > &mesh, std::unique_ptr< Elem > &new_elem, std::unique_ptr< Elem > &new_elem_1, const int current_layer, const unsigned int orig_nodes, const unsigned int total_num_azimuthal_intervals, std::vector< std::pair< dof_id_type, dof_id_type >> &side_pairs, dof_id_type &axis_node_case, bool &is_flipped, bool &is_flipped_additional) const
	Create a new PYRAMID element and a new PRISM element from an existing QUAD element by revolving it. More...

std::unique_ptr< ReplicatedMesh >	buildSimpleSlice (std::vector< Real > ring_radii, const std::vector< unsigned int > ring_layers, const std::vector< Real > ring_radial_biases, const multiBdryLayerParams &ring_inner_boundary_layer_params, const multiBdryLayerParams &ring_outer_boundary_layer_params, std::vector< Real > ducts_center_dist, const std::vector< unsigned int > ducts_layers, const std::vector< Real > duct_radial_biases, const multiBdryLayerParams &duct_inner_boundary_layer_params, const multiBdryLayerParams &duct_outer_boundary_layer_params, const Real pitch, const unsigned int num_sectors_per_side, const unsigned int background_intervals, const Real background_radial_bias, const singleBdryLayerParams &background_inner_boundary_layer_params, const singleBdryLayerParams &background_outer_boundary_layer_params, dof_id_type &node_id_background_meta, const unsigned int side_number, const unsigned int side_index, const std::vector< Real > azimuthal_tangent=std::vector< Real >(), const subdomain_id_type block_id_shift=0, const bool quad_center_elements=false, const Real center_quad_factor=0.0, const bool create_inward_interface_boundaries=false, const bool create_outward_interface_boundaries=true, const boundary_id_type boundary_id_shift=0, const bool generate_side_specific_boundaries=true, const TRI_ELEM_TYPE tri_elem_type=TRI_ELEM_TYPE::TRI3, const QUAD_ELEM_TYPE quad_elem_type=QUAD_ELEM_TYPE::QUAD4)
	Creates a mesh of a slice that corresponds to a single side of the polygon to be generated. More...

std::unique_ptr< ReplicatedMesh >	buildGeneralSlice (std::vector< Real > ring_radii, const std::vector< unsigned int > ring_layers, const std::vector< Real > ring_radial_biases, const multiBdryLayerParams &ring_inner_boundary_layer_params, const multiBdryLayerParams &ring_outer_boundary_layer_params, std::vector< Real > ducts_center_dist, const std::vector< unsigned int > ducts_layers, const std::vector< Real > duct_radial_biases, const multiBdryLayerParams &duct_inner_boundary_layer_params, const multiBdryLayerParams &duct_outer_boundary_layer_params, const Real primary_side_length, const Real secondary_side_length, const unsigned int num_sectors_per_side, const unsigned int background_intervals, const Real background_radial_bias, const singleBdryLayerParams &background_inner_boundary_layer_params, const singleBdryLayerParams &background_outer_boundary_layer_params, dof_id_type &node_id_background_meta, const Real azimuthal_angle, const std::vector< Real > azimuthal_tangent, const unsigned int side_index, const bool quad_center_elements, const Real center_quad_factor, const Real rotation_angle, const bool generate_side_specific_boundaries=true)
	Creates a mesh of a general polygon slice with a triangular shape and circular regions on one of its vertex. More...

std::unique_ptr< ReplicatedMesh >	buildSlice (std::vector< Real > ring_radii, const std::vector< unsigned int > ring_layers, const std::vector< Real > ring_radial_biases, const multiBdryLayerParams &ring_inner_boundary_layer_params, const multiBdryLayerParams &ring_outer_boundary_layer_params, std::vector< Real > ducts_center_dist, const std::vector< unsigned int > ducts_layers, const std::vector< Real > duct_radial_biases, const multiBdryLayerParams &duct_inner_boundary_layer_params, const multiBdryLayerParams &duct_outer_boundary_layer_params, const Real pitch, const unsigned int num_sectors_per_side, const unsigned int background_intervals, const Real background_radial_bias, const singleBdryLayerParams &background_inner_boundary_layer_params, const singleBdryLayerParams &background_outer_boundary_layer_params, dof_id_type &node_id_background_meta, const Real virtual_side_number, const unsigned int side_index, const std::vector< Real > azimuthal_tangent=std::vector< Real >(), const subdomain_id_type block_id_shift=0, const bool quad_center_elements=false, const Real center_quad_factor=0.0, const bool create_inward_interface_boundaries=false, const bool create_outward_interface_boundaries=true, const boundary_id_type boundary_id_shift=0, const Real pitch_scale_factor=1.0, const bool generate_side_specific_boundaries=true, const TRI_ELEM_TYPE tri_elem_type=TRI_ELEM_TYPE::TRI3, const QUAD_ELEM_TYPE quad_elem_type=QUAD_ELEM_TYPE::QUAD4)
	Generates a mesh of a polygon slice, which is the foundation of both buildGeneralSlice and buildSimpleSlice. More...

void	centerNodes (ReplicatedMesh &mesh, const Real virtual_side_number, const unsigned int div_num, const Real ring_radii_0, std::vector< std::vector< Node *>> &nodes) const
	Creates nodes of the very central mesh layer of the polygon for quad central elements. More...

void	ringNodes (ReplicatedMesh &mesh, const std::vector< Real > ring_radii, const std::vector< unsigned int > ring_layers, const std::vector< std::vector< Real >> biased_terms, const unsigned int num_sectors_per_side, const Real corner_p[2][2], const Real corner_to_corner, const std::vector< Real > azimuthal_tangent=std::vector< Real >()) const
	Creates nodes for the ring-geometry region of a single slice. More...

void	backgroundNodes (ReplicatedMesh &mesh, const unsigned int num_sectors_per_side, const unsigned int background_intervals, const std::vector< Real > biased_terms, const Real background_corner_distance, const Real background_corner_radial_interval_length, const Real corner_p[2][2], const Real corner_to_corner, const Real background_in, const std::vector< Real > azimuthal_tangent=std::vector< Real >()) const
	Creates nodes for the ring-to-polygon transition region (i.e., background) of a single slice. More...

void	ductNodes (ReplicatedMesh &mesh, std::vector< Real > *const ducts_center_dist, const std::vector< unsigned int > ducts_layers, const std::vector< std::vector< Real >> biased_terms, const unsigned int num_sectors_per_side, const Real corner_p[2][2], const Real corner_to_corner, const std::vector< Real > azimuthal_tangent=std::vector< Real >()) const
	Creates nodes for the duct-geometry region of a single slice. More...

void	cenQuadElemDef (ReplicatedMesh &mesh, const unsigned int div_num, const subdomain_id_type block_id_shift, const bool create_outward_interface_boundaries, const boundary_id_type boundary_id_shift, std::vector< std::vector< Node *>> &nodes, const bool assign_external_boundary=false, const unsigned int side_index=0, const bool generate_side_specific_boundaries=true, const QUAD_ELEM_TYPE quad_elem_type=QUAD_ELEM_TYPE::QUAD4) const
	Defines quad elements in the very central region of the polygon. More...

void	cenTriElemDef (ReplicatedMesh &mesh, const unsigned int num_sectors_per_side, const std::vector< Real > azimuthal_tangent=std::vector< Real >(), const subdomain_id_type block_id_shift=0, const bool create_outward_interface_boundaries=true, const boundary_id_type boundary_id_shift=0, const bool assign_external_boundary=false, const unsigned int side_index=0, const bool generate_side_specific_boundaries=true, const TRI_ELEM_TYPE tri_elem_type=TRI_ELEM_TYPE::TRI3) const
	Defines triangular elements in the very central region of the polygon. More...

void	quadElemDef (ReplicatedMesh &mesh, const unsigned int num_sectors_per_side, const std::vector< unsigned int > subdomain_rings, const unsigned int side_index, const std::vector< Real > azimuthal_tangent=std::vector< Real >(), const subdomain_id_type block_id_shift=0, const dof_id_type nodeid_shift=0, const bool create_inward_interface_boundaries=false, const bool create_outward_interface_boundaries=true, const boundary_id_type boundary_id_shift=0, const bool generate_side_specific_boundaries=true, const QUAD_ELEM_TYPE quad_elem_type=QUAD_ELEM_TYPE::QUAD4) const
	Defines general quad elements for the polygon. More...

std::unique_ptr< ReplicatedMesh >	buildSimplePeripheral (const unsigned int num_sectors_per_side, const unsigned int peripheral_invervals, const std::vector< std::pair< Real, Real >> &position_inner, const std::vector< std::pair< Real, Real >> &d_position_outer, const subdomain_id_type id_shift, const QUAD_ELEM_TYPE quad_elem_type, const bool create_inward_interface_boundaries=false, const bool create_outward_interface_boundaries=true)
	Creates peripheral area mesh for the patterned hexagon mesh. More...

void	adjustPeripheralQuadraticElements (MeshBase &out_mesh, const QUAD_ELEM_TYPE boundary_quad_elem_type) const
	Adjusts the mid-edge node locations in boundary regions when using quadratic elements with uniform boundary node spacing enabled. More...

std::pair< Real, Real >	pointInterpolate (const Real pi_1_x, const Real pi_1_y, const Real po_1_x, const Real po_1_y, const Real pi_2_x, const Real pi_2_y, const Real po_2_x, const Real po_2_y, const unsigned int i, const unsigned int j, const unsigned int num_sectors_per_side, const unsigned int peripheral_intervals) const
	Calculates the point coordinates of within a parallelogram region using linear interpolation. More...

void	nodeCoordRotate (Real &x, Real &y, const Real theta) const
	Calculates x and y coordinates after rotating by theta angle. More...

void	cutOffPolyDeform (MeshBase &mesh, const Real orientation, const Real y_max_0, const Real y_max_n, const Real y_min, const unsigned int mesh_type, const Real unit_angle=60.0, const Real tols=1E-5) const
	Deforms peripheral region when the external side of a polygon assembly of stitched meshes cuts off the stitched meshes. More...

std::pair< Real, Real >	fourPointIntercept (const std::pair< Real, Real > &p1, const std::pair< Real, Real > &p2, const std::pair< Real, Real > &p3, const std::pair< Real, Real > &p4) const
	Finds the center of a quadrilateral based on four vertices. More...

std::vector< Real >	azimuthalAnglesCollector (ReplicatedMesh &mesh, std::vector< Point > &boundary_points, const Real lower_azi=-30.0, const Real upper_azi=30.0, const unsigned int return_type=ANGLE_TANGENT, const unsigned int num_sides=6, const boundary_id_type bid=OUTER_SIDESET_ID, const bool calculate_origin=true, const Real input_origin_x=0.0, const Real input_origin_y=0.0, const Real tol=1.0E-10) const
	Collects sorted azimuthal angles of the external boundary. More...

std::vector< Real >	azimuthalAnglesCollector (ReplicatedMesh &mesh, const Real lower_azi=-30.0, const Real upper_azi=30.0, const unsigned int return_type=ANGLE_TANGENT, const unsigned int num_sides=6, const boundary_id_type bid=OUTER_SIDESET_ID, const bool calculate_origin=true, const Real input_origin_x=0.0, const Real input_origin_y=0.0, const Real tol=1.0E-10) const
	Collects sorted azimuthal angles of the external boundary. More...

std::vector< std::vector< Real > >	biasTermsCalculator (const std::vector< Real > radial_biases, const std::vector< unsigned int > intervals, const multiBdryLayerParams inner_boundary_layer_params, const multiBdryLayerParams outer_boundary_layer_params) const
	Creates bias terms for multiple blocks. More...

std::vector< Real >	biasTermsCalculator (const Real radial_bias, const unsigned int intervals, const singleBdryLayerParams inner_boundary_layer_params={0.0, 0.0, 0, 1.0}, const singleBdryLayerParams outer_boundary_layer_params={0.0, 0.0, 0, 1.0}) const
	Creates bias terms for a single block. More...

void	setSectorExtraIDs (MeshBase &mesh, const std::string id_name, const unsigned int num_sides, const std::vector< unsigned int > num_sectors_per_side)
	assign sector extra ids to polygon mesh More...

void	setRingExtraIDs (MeshBase &mesh, const std::string id_name, const unsigned int num_sides, const std::vector< unsigned int > num_sectors_per_side, const std::vector< unsigned int > ring_intervals, const bool ring_wise_id, const bool quad_center_elements)
	assign ring extra ids to polygon mesh More...

void	reassignBoundaryIDs (MeshBase &mesh, const boundary_id_type id_shift, const std::set< boundary_id_type > &boundary_ids, const bool reverse=false)
	reassign interface boundary IDs on the input mesh by applying the boundary ID shift More...

std::set< boundary_id_type >	getInterfaceBoundaryIDs (const std::vector< std::vector< unsigned int >> &pattern, const std::vector< std::vector< boundary_id_type >> &interface_boundary_id_shift_pattern, const std::set< boundary_id_type > &boundary_ids, const std::vector< std::set< boundary_id_type >> &input_interface_boundary_ids, const bool use_interface_boundary_id_shift, const bool create_interface_boundary_id, const unsigned int num_extra_layers) const
	returns a list of interface boundary IDs on the mesh generated by this mesh generator More...

multiBdryLayerParams	modifiedMultiBdryLayerParamsCreator (const multiBdryLayerParams &original_multi_bdry_layer_params, const unsigned int order) const
	Modifies the input multi boundary layer parameters for node generation, especially for the quadratic elements. More...

singleBdryLayerParams	modifiedSingleBdryLayerParamsCreator (const singleBdryLayerParams &original_single_bdry_layer_params, const unsigned int order) const
	Modifies the input single boundary layer parameters for node generation, especially for the quadratic elements. More...

std::string	pitchMetaDataErrorGenerator (const std::vector< MeshGeneratorName > &input_names, const std::vector< Real > &metadata_vals, const std::string &metadata_name) const
	Generate a string that contains the detailed metadata information for inconsistent input mesh metadata error messages. More...

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 void	addRingAndSectorIDParams (InputParameters &params)
	Add InputParameters which are used by ring and sector IDs. More...

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

Protected Attributes
std::unique_ptr< MeshBase > &	_input
	Lower dimensional mesh from another generator. More...

const Point &	_axis_point
	A point of the axis of revolution. More...

const Point &	_axis_direction
	A direction vector of the axis of revolution. More...

const std::vector< Real >	_revolving_angles
	Angles of revolution delineating each azimuthal section. More...

const std::vector< std::vector< subdomain_id_type > > &	_subdomain_swaps
	Subdomains to swap out for each azimuthal section. More...

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

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

std::vector< unsigned int >	_elem_integer_indices_to_swap

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

const bool &	_clockwise
	Revolving direction. More...

const std::vector< unsigned int > &	_nums_azimuthal_intervals
	Numbers of azimuthal mesh intervals in each azimuthal section. More...

const bool	_preserve_volumes
	Volume preserving function is optional. More...

bool	_has_start_boundary
	Whether a starting boundary is specified. More...

boundary_id_type	_start_boundary
	Boundary ID of the starting boundary. More...

bool	_has_end_boundary
	Whether an ending boundary is specified. More...

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

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

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

bool	_full_circle_revolving
	Whether to revolve for a full circle or not. More...

std::vector< Real >	_unit_angles
	Unit angles of all azimuthal sections of revolution. More...

boundary_id_type	_end_boundary
	Boundary ID of the ending boundary. More...

Real	_radius_correction_factor
	Radius correction factor. 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 RevolveGenerator object is designed to revolve a 1D mesh into 2D, or a 2D mesh into 3D based on an axis.

Definition at line 17 of file RevolveGenerator.h.

Member Enumeration Documentation

◆ INTRINSIC_NUM_SIDES

enum PolygonMeshGeneratorBase::INTRINSIC_NUM_SIDES

inherited

Enumerator
HEXAGON_NUM_SIDES
SQUARE_NUM_SIDES

Definition at line 75 of file PolygonMeshGeneratorBase.h.

   {
     HEXAGON_NUM_SIDES = 6,
     SQUARE_NUM_SIDES = 4
   };

◆ INTRINSIC_SIDESET_ID

enum PolygonMeshGeneratorBase::INTRINSIC_SIDESET_ID : boundary_id_type

inherited

Enumerator
OUTER_SIDESET_ID
OUTER_SIDESET_ID_ALT
SLICE_BEGIN
SLICE_END
SLICE_ALT

Definition at line 66 of file PolygonMeshGeneratorBase.h.

                             : boundary_id_type
   {
     OUTER_SIDESET_ID = 10000,
     OUTER_SIDESET_ID_ALT = 15000,
     SLICE_BEGIN = 30000,
     SLICE_END = 31000,
     SLICE_ALT = 30500
   };

◆ INTRISIC_SUBDOMAIN_ID

enum PolygonMeshGeneratorBase::INTRISIC_SUBDOMAIN_ID : subdomain_id_type

inherited

Enumerator
PERIPHERAL_ID_SHIFT
TRANSITION_LAYER_DEFAULT

Definition at line 60 of file PolygonMeshGeneratorBase.h.

                              : subdomain_id_type
   {
     PERIPHERAL_ID_SHIFT = 1000,
     TRANSITION_LAYER_DEFAULT = 10000
   };

◆ MESH_TYPE

enum PolygonMeshGeneratorBase::MESH_TYPE

inherited

Enumerator
CORNER_MESH
BOUNDARY_MESH
INNER_MESH

Definition at line 47 of file PolygonMeshGeneratorBase.h.

   {
     CORNER_MESH = 1,
     BOUNDARY_MESH = 2,
     INNER_MESH = 3
   };

◆ PolygonSizeStyle

enum PolygonMeshGeneratorBase::PolygonSizeStyle

stronginherited

An enum class for style of input polygon size.

Enumerator
apothem
radius

Definition at line 41 of file PolygonMeshGeneratorBase.h.

   {
     apothem,
     radius
   };

◆ QUAD_ELEM_TYPE

enum PolygonMeshGeneratorBase::QUAD_ELEM_TYPE

stronginherited

Enumerator
QUAD4
QUAD8
QUAD9

Definition at line 88 of file PolygonMeshGeneratorBase.h.

   {
     QUAD4,
     QUAD8,
     QUAD9
   };

◆ RETURN_TYPE

enum PolygonMeshGeneratorBase::RETURN_TYPE

inherited

Enumerator
ANGLE_DEGREE
ANGLE_TANGENT

Definition at line 54 of file PolygonMeshGeneratorBase.h.

   {
     ANGLE_DEGREE = 1,
     ANGLE_TANGENT = 2
   };

◆ TRI_ELEM_TYPE

enum PolygonMeshGeneratorBase::TRI_ELEM_TYPE

stronginherited

Enumerator
TRI3
TRI6
TRI7

Definition at line 81 of file PolygonMeshGeneratorBase.h.

   {
     TRI3,
     TRI6,
     TRI7
   };

Constructor & Destructor Documentation

◆ RevolveGenerator()

RevolveGenerator::RevolveGenerator ( const InputParameters & parameters )

Definition at line 110 of file RevolveGenerator.C.

   : PolygonMeshGeneratorBase(parameters),
     _input(getMesh("input")),
     _axis_point(getParam<Point>("axis_point")),
     _axis_direction(getParam<Point>("axis_direction")),
     _revolving_angles(isParamValid("revolving_angles")
                           ? getParam<std::vector<Real>>("revolving_angles")
                           : std::vector<Real>(1, 360.0)),
     _subdomain_swaps(getParam<std::vector<std::vector<subdomain_id_type>>>("subdomain_swaps")),
     _boundary_swaps(getParam<std::vector<std::vector<boundary_id_type>>>("boundary_swaps")),
     _elem_integer_names_to_swap(getParam<std::vector<std::string>>("elem_integer_names_to_swap")),
     _elem_integers_swaps(
         getParam<std::vector<std::vector<std::vector<dof_id_type>>>>("elem_integers_swaps")),
     _clockwise(getParam<bool>("clockwise")),
     _nums_azimuthal_intervals(getParam<std::vector<unsigned int>>("nums_azimuthal_intervals")),
     _preserve_volumes(getParam<bool>("preserve_volumes")),
     _has_start_boundary(isParamValid("start_boundary")),
     _start_boundary(isParamValid("start_boundary") ? getParam<boundary_id_type>("start_boundary")
                                                    : 0),
     _has_end_boundary(isParamValid("end_boundary")),
     _end_boundary(isParamValid("end_boundary") ? getParam<boundary_id_type>("end_boundary") : 0),
     _radius_correction_factor(1.0)
 {
   if (_revolving_angles.size() != _nums_azimuthal_intervals.size())
     paramError("nums_azimuthal_intervals",
                "The number of azimuthal intervals should be the same as the number of revolving "
                "angles.");
   if (_subdomain_swaps.size() && (_subdomain_swaps.size() != _nums_azimuthal_intervals.size()))
     paramError(
         "subdomain_swaps",
         "If specified, 'subdomain_swaps' must be the same length as 'nums_azimuthal_intervals'.");
 
   if (_boundary_swaps.size() && (_boundary_swaps.size() != _nums_azimuthal_intervals.size()))
     paramError(
         "boundary_swaps",
         "If specified, 'boundary_swaps' must be the same length as 'nums_azimuthal_intervals'.");
 
   for (const auto & unit_elem_integers_swaps : _elem_integers_swaps)
     if (unit_elem_integers_swaps.size() != _nums_azimuthal_intervals.size())
       paramError("elem_integers_swaps",
                  "If specified, each element of 'elem_integers_swaps' must have the same length as "
                  "the length of 'nums_azimuthal_intervals'.");
 
   if (_elem_integers_swaps.size() &&
       _elem_integers_swaps.size() != _elem_integer_names_to_swap.size())
     paramError("elem_integers_swaps",
                "If specified, 'elem_integers_swaps' must have the same length as the length of "
                "'elem_integer_names_to_swap'.");
 
   _full_circle_revolving =
       MooseUtils::absoluteFuzzyEqual(
           std::accumulate(_revolving_angles.begin(), _revolving_angles.end(), 0), 360.0)
           ? true
           : false;
   if (MooseUtils::absoluteFuzzyGreaterThan(
           std::accumulate(_revolving_angles.begin(), _revolving_angles.end(), 0), 360.0))
     paramError("revolving_angles",
                "The sum of revolving angles should be less than or equal to 360.");
 
   if ((_has_start_boundary && _full_circle_revolving) ||
       (_has_end_boundary && _full_circle_revolving))
     paramError("full_circle_revolving",
                "starting or ending boundaries can only be assigned for partial revolving.");
 
   try
   {
     MooseMeshUtils::idSwapParametersProcessor(
         name(), "subdomain_swaps", _subdomain_swaps, _subdomain_swap_pairs);
   }
   catch (const MooseException & e)
   {
     paramError("subdomain_swaps", e.what());
   }
 
   try
   {
     MooseMeshUtils::idSwapParametersProcessor(
         name(), "boundary_swaps", _boundary_swaps, _boundary_swap_pairs);
   }
   catch (const MooseException & e)
   {
     paramError("boundary_swaps", e.what());
   }
 
   try
   {
     MooseMeshUtils::extraElemIntegerSwapParametersProcessor(name(),
                                                             _nums_azimuthal_intervals.size(),
                                                             _elem_integer_names_to_swap.size(),
                                                             _elem_integers_swaps,
                                                             _elem_integers_swap_pairs);
   }
   catch (const MooseException & e)
   {
     paramError("elem_integers_swaps", e.what());
   }
 }

Member Function Documentation

◆ addRingAndSectorIDParams()

void PolygonMeshGeneratorBase::addRingAndSectorIDParams ( InputParameters & params )

staticprotectedinherited

Add InputParameters which are used by ring and sector IDs.

Parameters

params InputParameters to be modified with the added params

Definition at line 1598 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonConcentricCircleMeshGeneratorBase::validParams(), and TriPinHexAssemblyGenerator::validParams().

 {
   params.addParam<std::string>("sector_id_name",
                                "Name of integer (reporting) ID for sector regions to use the "
                                "reporting ID for azimuthal sector regions of ring geometry block.");
   params.addParam<std::string>("ring_id_name",
                                "Name of integer (reporting) ID for ring regions to use the "
                                "reporting ID for annular regions of ring geometry block.");
   MooseEnum ring_id_option("block_wise ring_wise", "block_wise");
   params.addParam<MooseEnum>(
       "ring_id_assign_type", ring_id_option, "Type of ring ID assignment: block_wise or ring_wise");
   params.addParamNamesToGroup("sector_id_name ring_id_name ring_id_assign_type", "Ring/Sector IDs");
 }

◆ adjustPeripheralQuadraticElements()

void PolygonMeshGeneratorBase::adjustPeripheralQuadraticElements	(	MeshBase &	out_mesh,
		const QUAD_ELEM_TYPE	boundary_quad_elem_type
	)		const

protectedinherited

Adjusts the mid-edge node locations in boundary regions when using quadratic elements with uniform boundary node spacing enabled.

Parameters

out_mesh	mesh to be adjusted.
boundary_quad_elem_type	boundary quad element type.

Definition at line 1253 of file PolygonMeshGeneratorBase.C.

Referenced by PatternedHexMeshGenerator::generate(), and PatternedCartesianMeshGenerator::generate().

 {
   const auto side_list = out_mesh.get_boundary_info().build_side_list();
 
   // select out elements on outer boundary
   // std::set used to filter duplicate elem_ids
   std::set<dof_id_type> elem_set;
   for (auto side_item : side_list)
   {
     boundary_id_type boundary_id = std::get<2>(side_item);
     dof_id_type elem_id = std::get<0>(side_item);
 
     if (boundary_id == OUTER_SIDESET_ID)
       elem_set.insert(elem_id);
   }
 
   // adjust nodes for outer boundary elements
   for (const auto elem_id : elem_set)
   {
     Elem * elem = out_mesh.elem_ptr(elem_id);
 
     // adjust right side mid-edge node
     Point pt_5 = (elem->point(1) + elem->point(2)) / 2.0;
     out_mesh.add_point(pt_5, elem->node_ptr(5)->id());
 
     // adjust left side mid-edge node
     Point pt_7 = (elem->point(0) + elem->point(3)) / 2.0;
     out_mesh.add_point(pt_7, elem->node_ptr(7)->id());
 
     // adjust central node when using QUAD9
     if (boundary_quad_elem_type == QUAD_ELEM_TYPE::QUAD9)
     {
       Point pt_8 = elem->true_centroid();
       out_mesh.add_point(pt_8, elem->node_ptr(8)->id());
     }
   }
 }

◆ azimuthalAnglesCollector() [1/2]

std::vector<Real> PolygonMeshGeneratorBase::azimuthalAnglesCollector	(	ReplicatedMesh &	mesh,
		std::vector< Point > &	boundary_points,
		const Real	lower_azi = `-30.0`,
		const Real	upper_azi = `30.0`,
		const unsigned int	return_type = `ANGLE_TANGENT`,
		const unsigned int	num_sides = `6`,
		const boundary_id_type	bid = `OUTER_SIDESET_ID`,
		const bool	calculate_origin = `true`,
		const Real	input_origin_x = `0.0`,
		const Real	input_origin_y = `0.0`,
		const Real	tol = `1.0E-10`
	)		const

protectedinherited

Collects sorted azimuthal angles of the external boundary.

Parameters

mesh	input mesh whose boundary node azimuthal angles need to be collected
boundary_points	reference vector to contain the Points corresponding to the collected azimuthal angles
lower_azi	lower boundary of the azimuthal angles to be collected
upper_azi	upper boundary of the azimuthal angles to be collected
return_type	whether angle values or tangent values are returned
num_sides	number of sides of the input mesh (only used if return type is ANGLE_TANGENT)
bid	id of the boundary of which the nodes' azimuthal angles are collected
calculate_origin	whether the mesh origin is calculated based on the centroid position
input_origin_x	precalculated mesh origin coordinate x
input_origin_y	precalculated mesh origin coordinate y
tol	tolerance that the minimum azimuthal angle is

Returns: the list of azimuthal angles of all the nodes on the external grain boundary within the given range

Referenced by AzimuthalBlockSplitGenerator::generate(), PolygonConcentricCircleMeshGeneratorBase::generate(), and PatternedPolygonPeripheralModifierBase::generate().

◆ azimuthalAnglesCollector() [2/2]

std::vector<Real> PolygonMeshGeneratorBase::azimuthalAnglesCollector	(	ReplicatedMesh &	mesh,
		const Real	lower_azi = `-30.0`,
		const Real	upper_azi = `30.0`,
		const unsigned int	return_type = `ANGLE_TANGENT`,
		const unsigned int	num_sides = `6`,
		const boundary_id_type	bid = `OUTER_SIDESET_ID`,
		const bool	calculate_origin = `true`,
		const Real	input_origin_x = `0.0`,
		const Real	input_origin_y = `0.0`,
		const Real	tol = `1.0E-10`
	)		const

protectedinherited

Collects sorted azimuthal angles of the external boundary.

Parameters

mesh	input mesh whose boundary node azimuthal angles need to be collected
lower_azi	lower boundary of the azimuthal angles to be collected
upper_azi	upper boundary of the azimuthal angles to be collected
return_type	whether angle values or tangent values are returned
num_sides	number of sides of the input mesh (only used if return type is ANGLE_TANGENT)
bid	id of the boundary of which the nodes' azimuthal angles are collected
calculate_origin	whether the mesh origin is calculated based on the centroid position
input_origin_x	precalculated mesh origin coordinate x
input_origin_y	precalculated mesh origin coordinate y
tol	tolerence that the minimum azimuthal angle is

Returns: the list of azimuthal angles of all the nodes on the external grain boundary within the given range

◆ backgroundNodes()

void PolygonMeshGeneratorBase::backgroundNodes	(	ReplicatedMesh &	mesh,
		const unsigned int	num_sectors_per_side,
		const unsigned int	background_intervals,
		const std::vector< Real >	biased_terms,
		const Real	background_corner_distance,
		const Real	background_corner_radial_interval_length,
		const Real	corner_p[2][2],
		const Real	corner_to_corner,
		const Real	background_in,
		const std::vector< Real >	azimuthal_tangent = `std::vector<Real>()`
	)		const

protectedinherited

Creates nodes for the ring-to-polygon transition region (i.e., background) of a single slice.

Parameters

mesh	input mesh to add the nodes onto
num_sectors_per_side	number of azimuthal intervals
background_intervals	number of radial intervals of the background region
biased_terms	normalized spacing values used for radial meshing biasing in background region
background_corner_distance	center to duct (innermost duct) corner distance
background_corner_radial_interval_length	radial interval distance
corner_p[2][2]	array contains the coordinates of the corner positions
corner_to_corner	diameter of the circumscribed circle of the polygon
background_in	radius of the inner boundary of the background region
azimuthal_tangent	vector of tangent values of the azimuthal angles as reference for adaptive boundary matching

Returns: a mesh with background region nodes created

Definition at line 720 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice().

 {
   unsigned int angle_number =
       azimuthal_tangent.size() == 0 ? num_sectors_per_side : (azimuthal_tangent.size() - 1);
   for (unsigned int k = 0; k < (background_intervals); k++)
   {
     const Real background_corner_p_x =
         background_corner_distance / (0.5 * corner_to_corner) * corner_p[0][0] *
         (background_in +
          biased_terms[k] * background_intervals * background_corner_radial_interval_length) /
         background_corner_distance;
     const Real background_corner_p_y =
         background_corner_distance / (0.5 * corner_to_corner) * corner_p[0][1] *
         (background_in +
          biased_terms[k] * background_intervals * background_corner_radial_interval_length) /
         background_corner_distance;
 
     // background_corner_p(s) are the points in the background region, on the bins towards the six
     // corners, at different intervals
     mesh.add_point(Point(background_corner_p_x, background_corner_p_y, 0.0));
 
     for (unsigned int j = 1; j <= angle_number; j++)
     {
       const Real cell_boundary_p_x =
           background_corner_distance / (0.5 * corner_to_corner) *
           (corner_p[0][0] + (corner_p[1][0] - corner_p[0][0]) *
                                 (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
                                                                : (azimuthal_tangent[j] / 2.0)));
       const Real cell_boundary_p_y =
           background_corner_distance / (0.5 * corner_to_corner) *
           (corner_p[0][1] + (corner_p[1][1] - corner_p[0][1]) *
                                 (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
                                                                : (azimuthal_tangent[j] / 2.0)));
       // cell_boundary_p(s) are the points on the cell's six boundaries (flat sides) at different
       // azimuthal angles
       const Real pin_boundary_p_x =
           cell_boundary_p_x * background_in /
           std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
       const Real pin_boundary_p_y =
           cell_boundary_p_y * background_in /
           std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
       // pin_boundary_p(s) are the points on pin boundary (outside ring) at different azimuthal
       // angles
       const Real background_radial_interval =
           std::sqrt(Utility::pow<2>(cell_boundary_p_x - pin_boundary_p_x) +
                     Utility::pow<2>(cell_boundary_p_y - pin_boundary_p_y)) /
           background_intervals;
       const Real background_azimuthal_p_x =
           cell_boundary_p_x *
           (background_in + biased_terms[k] * background_intervals * background_radial_interval) /
           std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
       const Real background_azimuthal_p_y =
           cell_boundary_p_y *
           (background_in + biased_terms[k] * background_intervals * background_radial_interval) /
           std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
       // background_azimuthal_p are the points on the bins towards different azimuthal angles, at
       // different intervals; excluding the ones produced by background_corner_p
       mesh.add_point(Point(background_azimuthal_p_x, background_azimuthal_p_y, 0.0));
     }
   }
 }

◆ biasTermsCalculator() [1/2]

std::vector< std::vector< Real > > PolygonMeshGeneratorBase::biasTermsCalculator	(	const std::vector< Real >	radial_biases,
		const std::vector< unsigned int >	intervals,
		const multiBdryLayerParams	inner_boundary_layer_params,
		const multiBdryLayerParams	outer_boundary_layer_params
	)		const

protectedinherited

Creates bias terms for multiple blocks.

Parameters

radial_biases	bias growth factors of the elements within the main regions of the blocks
intervals	radial interval numbers of the main regions of the blocks
inner_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the inner boundary layers
outer_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the outer boundary layers

Returns: bias list of terms describing the cumulative radial fractions of the nodes within multiple blocks

Definition at line 1523 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice(), and PeripheralRingMeshGenerator::generate().

 {
   std::vector<std::vector<Real>> bias_terms_vec;
   for (unsigned int i = 0; i < radial_biases.size(); i++)
     bias_terms_vec.push_back(biasTermsCalculator(radial_biases[i],
                                                  intervals[i],
                                                  {0.0,
                                                   inner_boundary_layer_params.fractions[i],
                                                   inner_boundary_layer_params.intervals[i],
                                                   inner_boundary_layer_params.biases[i]},
                                                  {0.0,
                                                   outer_boundary_layer_params.fractions[i],
                                                   outer_boundary_layer_params.intervals[i],
                                                   outer_boundary_layer_params.biases[i]}));
   return bias_terms_vec;
 }

◆ biasTermsCalculator() [2/2]

std::vector< Real > PolygonMeshGeneratorBase::biasTermsCalculator	(	const Real	radial_bias,
		const unsigned int	intervals,
		const singleBdryLayerParams	inner_boundary_layer_params = `{0.0, 0.0, 0, 1.0}`,
		const singleBdryLayerParams	outer_boundary_layer_params = `{0.0, 0.0, 0, 1.0}`
	)		const

protectedinherited

Creates bias terms for a single block.

Parameters

radial_bias	bias growth factor of the elements within the main region of the block
intervals	radial interval number of the main region of the block
inner_boundary_layer_params	width, radial fraction, radial sector, and growth factor of the inner boundary layer
outer_boundary_layer_params	width, radial fraction, radial sector, and growth factor of the outer boundary layer

Returns: bias terms describing the cumulative radial fractions of the nodes within a single block

Definition at line 1545 of file PolygonMeshGeneratorBase.C.

 {
   // To get biased indices:
   // If no bias is involved, namely bias factor = 1.0, the increment in indices is uniform.
   // Thus, (i + 1) is used to get such linearly increasing indices.
   // If a non-trivial bias factor q is used, the increment in the indices is geometric
   // progression. So, if first (i = 0) increment is 1.0, second (i = 1) is q, third (i = 2) is
   // q^2,..., last or n_interval'th is q^(n_interval - 1). Then, the summation of the first (i +
   // 1) increments over the summation of all n_interval increments is the (i + 1)th index The
   // summation of the first (i + 1) increments is (1.0 - q^(i + 1)) / (1 - q); The summation of
   // all n_interval increments is (1.0 - q^n_interval) / (1 - q); Thus, the index is (1.0 - q^(i +
   // 1)) / (1.0 - q^n_interval)
   // This approach is used by inner boundary layer, main region, outer boundary layer separately.
 
   std::vector<Real> biased_terms;
   for (unsigned int i = 0; i < inner_boundary_layer_params.intervals; i++)
     biased_terms.push_back(
         MooseUtils::absoluteFuzzyEqual(inner_boundary_layer_params.bias, 1.0)
             ? ((Real)(i + 1) * inner_boundary_layer_params.fraction /
                (Real)inner_boundary_layer_params.intervals)
             : ((1.0 - std::pow(inner_boundary_layer_params.bias, (Real)(i + 1))) /
                (1.0 - std::pow(inner_boundary_layer_params.bias,
                                (Real)(inner_boundary_layer_params.intervals))) *
                inner_boundary_layer_params.fraction));
   for (unsigned int i = 0; i < intervals; i++)
     biased_terms.push_back(inner_boundary_layer_params.fraction +
                            (MooseUtils::absoluteFuzzyEqual(radial_bias, 1.0)
                                 ? ((Real)(i + 1) *
                                    (1.0 - inner_boundary_layer_params.fraction -
                                     outer_boundary_layer_params.fraction) /
                                    (Real)intervals)
                                 : ((1.0 - std::pow(radial_bias, (Real)(i + 1))) /
                                    (1.0 - std::pow(radial_bias, (Real)(intervals))) *
                                    (1.0 - inner_boundary_layer_params.fraction -
                                     outer_boundary_layer_params.fraction))));
   for (unsigned int i = 0; i < outer_boundary_layer_params.intervals; i++)
     biased_terms.push_back(
         1.0 - outer_boundary_layer_params.fraction +
         (MooseUtils::absoluteFuzzyEqual(outer_boundary_layer_params.bias, 1.0)
              ? ((Real)(i + 1) * outer_boundary_layer_params.fraction /
                 (Real)outer_boundary_layer_params.intervals)
              : ((1.0 - std::pow(outer_boundary_layer_params.bias, (Real)(i + 1))) /
                 (1.0 - std::pow(outer_boundary_layer_params.bias,
                                 (Real)(outer_boundary_layer_params.intervals))) *
                 outer_boundary_layer_params.fraction)));
   return biased_terms;
 }

◆ buildGeneralSlice()

std::unique_ptr< ReplicatedMesh > PolygonMeshGeneratorBase::buildGeneralSlice	(	std::vector< Real >	ring_radii,
		const std::vector< unsigned int >	ring_layers,
		const std::vector< Real >	ring_radial_biases,
		const multiBdryLayerParams &	ring_inner_boundary_layer_params,
		const multiBdryLayerParams &	ring_outer_boundary_layer_params,
		std::vector< Real >	ducts_center_dist,
		const std::vector< unsigned int >	ducts_layers,
		const std::vector< Real >	duct_radial_biases,
		const multiBdryLayerParams &	duct_inner_boundary_layer_params,
		const multiBdryLayerParams &	duct_outer_boundary_layer_params,
		const Real	primary_side_length,
		const Real	secondary_side_length,
		const unsigned int	num_sectors_per_side,
		const unsigned int	background_intervals,
		const Real	background_radial_bias,
		const singleBdryLayerParams &	background_inner_boundary_layer_params,
		const singleBdryLayerParams &	background_outer_boundary_layer_params,
		dof_id_type &	node_id_background_meta,
		const Real	azimuthal_angle,
		const std::vector< Real >	azimuthal_tangent,
		const unsigned int	side_index,
		const bool	quad_center_elements,
		const Real	center_quad_factor,
		const Real	rotation_angle,
		const bool	generate_side_specific_boundaries = `true`
	)

protectedinherited

Creates a mesh of a general polygon slice with a triangular shape and circular regions on one of its vertex.

Parameters

ring_radii	radii of the ring regions
ring_layers	numbers of radial intervals of the ring regions
ring_radial_biases	values used for radial meshing biasing in ring regions
ring_inner_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the ring regions
ring_outer_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the ring regions
ducts_center_dist	distance parameters of the duct regions
ducts_layers	numbers of radial intervals of the duct regions
duct_radial_biases	values used for radial meshing biasing in duct regions
duct_inner_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the duct regions
duct_outer_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the duct regions
primary_side_length	length of the first side (i.e., the side that is parallel to y-axis when rotation_angle is zero) that involves the ring center vertex
secondary_side_length	length of the second side (obtained by clockwise rotating the fist side by azimuthal_angle) that involves the ring center vertex
num_sectors_per_side	number of azimuthal intervals
background_intervals	number of radial intervals of the background region
background_radial_bias	value used for radial meshing biasing in background region
background_inner_boundary_layer_params	width, radial sectors, and growth factor of the inner boundary layer of the background region
background_outer_boundary_layer_params	width, radial sectors, and growth factor of the outer boundary layer of the background region
node_id_background_meta	pointer to the first node's id of the background region
azimuthal_angle	the angle defined by the primary and secondary sides
azimuthal_tangent	vector of tangent values of the azimuthal angles as reference for adaptive boundary matching
side_index	index of the polygon side
quad_center_elements	whether the central region contains quad elements or not
center_quad_factor	A fractional radius factor used to determine the radial positions of transition nodes in the center region meshed by quad elements (default is 1.0 - 1.0/div_num)
rotation_angle	azimuthal angle of the primary side
generate_side_specific_boundaries	whether the side-specific external boundaries are generated or not

Returns: a mesh of a general slice

Definition at line 42 of file PolygonMeshGeneratorBase.C.

Referenced by TriPinHexAssemblyGenerator::buildSinglePinSection().

 {
   const Real virtual_pitch = 2.0 * primary_side_length * cos(azimuthal_angle / 360.0 * M_PI);
   const Real virtual_side_number = 360.0 / azimuthal_angle;
   const Real pitch_scale_factor = secondary_side_length / primary_side_length;
 
   auto mesh = buildSlice(ring_radii,
                          ring_layers,
                          ring_radial_biases,
                          ring_inner_boundary_layer_params,
                          ring_outer_boundary_layer_params,
                          ducts_center_dist,
                          ducts_layers,
                          duct_radial_biases,
                          duct_inner_boundary_layer_params,
                          duct_outer_boundary_layer_params,
                          virtual_pitch,
                          num_sectors_per_side,
                          background_intervals,
                          background_radial_bias,
                          background_inner_boundary_layer_params,
                          background_outer_boundary_layer_params,
                          node_id_background_meta,
                          virtual_side_number,
                          side_index,
                          azimuthal_tangent,
                          0,
                          quad_center_elements,
                          center_quad_factor,
                          false,
                          true,
                          0,
                          pitch_scale_factor,
                          generate_side_specific_boundaries);
   MeshTools::Modification::rotate(*mesh, rotation_angle, 0, 0);
   return mesh;
 }

◆ buildSimplePeripheral()

std::unique_ptr< ReplicatedMesh > PolygonMeshGeneratorBase::buildSimplePeripheral	(	const unsigned int	num_sectors_per_side,
		const unsigned int	peripheral_invervals,
		const std::vector< std::pair< Real, Real >> &	position_inner,
		const std::vector< std::pair< Real, Real >> &	d_position_outer,
		const subdomain_id_type	id_shift,
		const QUAD_ELEM_TYPE	quad_elem_type,
		const bool	create_inward_interface_boundaries = `false`,
		const bool	create_outward_interface_boundaries = `true`
	)

protectedinherited

Creates peripheral area mesh for the patterned hexagon mesh.

Note that the function create the peripheral area for each side of the unit hexagon mesh before stitching. An edge unit hexagon has two sides that need peripheral areas, whereas a corner unit hexagon has three such sides. The positions of the inner and outer boundary nodes are pre-calculated as positions_inner and d_positions_outer; This function performs interpolation to generate the mesh grid.

Parameters

mesh	input mesh to create the peripheral area mesh onto
num_sectors_per_side	number of azimuthal intervals
peripheral_invervals	number of radial intervals of the peripheral region
position_inner	key positions of the inner side of the peripheral region
d_position_outer	key inremental positions of the outer side of the peripheral region
id_shift	shift of subdomain id of the peripheral region
create_inward_interface_boundaries	whether inward interface boundary sidesets are created
create_outward_interface_boundaries	whether outward interface boundary sidesets are created
quad_elem_type	type of quad element to be created

Returns: a mesh with the peripheral region added to a hexagon input mesh

Definition at line 1153 of file PolygonMeshGeneratorBase.C.

Referenced by PatternedHexMeshGenerator::addPeripheralMesh(), and PatternedCartesianMeshGenerator::addPeripheralMesh().

 {
   auto mesh = buildReplicatedMesh(2);
   std::pair<Real, Real> positions_p;
 
   // generate node positions
   for (unsigned int i = 0; i <= peripheral_invervals; i++)
   {
     for (unsigned int j = 0; j <= num_sectors_per_side / 2; j++)
     {
       positions_p = pointInterpolate(positions_inner[0].first,
                                      positions_inner[0].second,
                                      d_positions_outer[0].first,
                                      d_positions_outer[0].second,
                                      positions_inner[1].first,
                                      positions_inner[1].second,
                                      d_positions_outer[1].first,
                                      d_positions_outer[1].second,
                                      i,
                                      j,
                                      num_sectors_per_side,
                                      peripheral_invervals);
       mesh->add_point(Point(positions_p.first, positions_p.second, 0.0));
     }
     for (unsigned int j = 1; j <= num_sectors_per_side / 2; j++)
     {
       positions_p = pointInterpolate(positions_inner[1].first,
                                      positions_inner[1].second,
                                      d_positions_outer[1].first,
                                      d_positions_outer[1].second,
                                      positions_inner[2].first,
                                      positions_inner[2].second,
                                      d_positions_outer[2].first,
                                      d_positions_outer[2].second,
                                      i,
                                      j,
                                      num_sectors_per_side,
                                      peripheral_invervals);
       mesh->add_point(Point(positions_p.first, positions_p.second, 0.0));
     }
   }
 
   // element definition
   BoundaryInfo & boundary_info = mesh->get_boundary_info();
 
   for (unsigned int i = 0; i < peripheral_invervals; i++)
   {
     for (unsigned int j = 0; j < num_sectors_per_side; j++)
     {
       std::unique_ptr<Elem> new_elem;
 
       new_elem = std::make_unique<Quad4>();
       new_elem->set_node(0, mesh->node_ptr(j + (num_sectors_per_side + 1) * (i)));
       new_elem->set_node(1, mesh->node_ptr(j + 1 + (num_sectors_per_side + 1) * (i)));
       new_elem->set_node(2, mesh->node_ptr(j + 1 + (num_sectors_per_side + 1) * (i + 1)));
       new_elem->set_node(3, mesh->node_ptr(j + (num_sectors_per_side + 1) * (i + 1)));
 
       Elem * elem = mesh->add_elem(std::move(new_elem));
 
       // add subdoamin and boundary IDs
       elem->subdomain_id() = PERIPHERAL_ID_SHIFT + id_shift;
       if (i == 0)
       {
         boundary_info.add_side(elem, 0, OUTER_SIDESET_ID);
         if (create_inward_interface_boundaries)
           boundary_info.add_side(elem, 0, SLICE_ALT + id_shift * 2);
       }
       if (i == peripheral_invervals - 1)
       {
         boundary_info.add_side(elem, 2, OUTER_SIDESET_ID);
         if (create_outward_interface_boundaries)
           boundary_info.add_side(elem, 2, SLICE_ALT + id_shift * 2 + 1);
       }
       if (j == 0)
         boundary_info.add_side(elem, 3, OUTER_SIDESET_ID);
       if (j == num_sectors_per_side - 1)
         boundary_info.add_side(elem, 1, OUTER_SIDESET_ID);
     }
   }
 
   // convert element to second order if needed
   if (quad_elem_type != QUAD_ELEM_TYPE::QUAD4)
   {
     // full_ordered 2nd order element --> QUAD9, otherwise QUAD8
     const bool full_ordered = (quad_elem_type == QUAD_ELEM_TYPE::QUAD9);
     mesh->all_second_order(full_ordered);
   }
 
   return mesh;
 }

◆ buildSimpleSlice()

std::unique_ptr< ReplicatedMesh > PolygonMeshGeneratorBase::buildSimpleSlice	(	std::vector< Real >	ring_radii,
		const std::vector< unsigned int >	ring_layers,
		const std::vector< Real >	ring_radial_biases,
		const multiBdryLayerParams &	ring_inner_boundary_layer_params,
		const multiBdryLayerParams &	ring_outer_boundary_layer_params,
		std::vector< Real >	ducts_center_dist,
		const std::vector< unsigned int >	ducts_layers,
		const std::vector< Real >	duct_radial_biases,
		const multiBdryLayerParams &	duct_inner_boundary_layer_params,
		const multiBdryLayerParams &	duct_outer_boundary_layer_params,
		const Real	pitch,
		const unsigned int	num_sectors_per_side,
		const unsigned int	background_intervals,
		const Real	background_radial_bias,
		const singleBdryLayerParams &	background_inner_boundary_layer_params,
		const singleBdryLayerParams &	background_outer_boundary_layer_params,
		dof_id_type &	node_id_background_meta,
		const unsigned int	side_number,
		const unsigned int	side_index,
		const std::vector< Real >	azimuthal_tangent = `std::vector<Real>()`,
		const subdomain_id_type	block_id_shift = `0`,
		const bool	quad_center_elements = `false`,
		const Real	center_quad_factor = `0.0`,
		const bool	create_inward_interface_boundaries = `false`,
		const bool	create_outward_interface_boundaries = `true`,
		const boundary_id_type	boundary_id_shift = `0`,
		const bool	generate_side_specific_boundaries = `true`,
		const TRI_ELEM_TYPE	tri_elem_type = `TRI_ELEM_TYPE::TRI3`,
		const QUAD_ELEM_TYPE	quad_elem_type = `QUAD_ELEM_TYPE::QUAD4`
	)

protectedinherited

Creates a mesh of a slice that corresponds to a single side of the polygon to be generated.

Parameters

ring_radii	radii of the ring regions
ring_layers	numbers of radial intervals of the ring regions
ring_radial_biases	values used for radial meshing biasing in ring regions
ring_inner_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the ring regions
ring_outer_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the ring regions
ducts_center_dist	distance parameters of the duct regions
ducts_layers	numbers of radial intervals of the duct regions
duct_radial_biases	values used for radial meshing biasing in duct regions
duct_inner_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the duct regions
duct_outer_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the duct regions
pitch	twice the distance from the ring center vertex to the side defined by the other vertices
num_sectors_per_side	number of azimuthal intervals
background_intervals	number of radial intervals of the background region
background_radial_bias	value used for radial meshing biasing in background region
background_inner_boundary_layer_params	width, radial sectors, and growth factor of the inner boundary layer of the background region
background_outer_boundary_layer_params	width, radial sectors, and growth factor of the outer boundary layer of the background region
node_id_background_meta	pointer to the first node's id of the background region
side_number	number of sides of the polygon
side_index	index of the polygon side
azimuthal_tangent	vector of tangent values of the azimuthal angles as reference for adaptive boundary matching
block_id_shift	shift of the subdomain ids generated by this function
quad_center_elements	whether the central region contrains quad elements or not
center_quad_factor	A fractional radius factor used to determine the radial positions of transition nodes in the center region meshed by quad elements (default is 1.0 - 1.0/div_num)
create_inward_interface_boundaries	whether inward interface boundary sidesets are created
create_outward_interface_boundaries	whether outward interface boundary sidesets are created
boundary_id_shift	shift of the interface boundary ids
generate_side_specific_boundaries	whether the side-specific external boundaries are generated or not
tri_elem_type	type of the triangular elements to be generated
quad_elem_type	type of the quadrilateral elements to be generated

Returns: a mesh of a polygon slice

Definition at line 106 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

 {
   return buildSlice(ring_radii,
                     ring_layers,
                     ring_radial_biases,
                     ring_inner_boundary_layer_params,
                     ring_outer_boundary_layer_params,
                     ducts_center_dist,
                     ducts_layers,
                     duct_radial_biases,
                     duct_inner_boundary_layer_params,
                     duct_outer_boundary_layer_params,
                     pitch,
                     num_sectors_per_side,
                     background_intervals,
                     background_radial_bias,
                     background_inner_boundary_layer_params,
                     background_outer_boundary_layer_params,
                     node_id_background_meta,
                     side_number,
                     side_index,
                     azimuthal_tangent,
                     block_id_shift,
                     quad_center_elements,
                     center_quad_factor,
                     create_inward_interface_boundaries,
                     create_outward_interface_boundaries,
                     boundary_id_shift,
                     1.0,
                     generate_side_specific_boundaries,
                     tri_elem_type,
                     quad_elem_type);
 }

◆ buildSlice()

std::unique_ptr< ReplicatedMesh > PolygonMeshGeneratorBase::buildSlice	(	std::vector< Real >	ring_radii,
		const std::vector< unsigned int >	ring_layers,
		const std::vector< Real >	ring_radial_biases,
		const multiBdryLayerParams &	ring_inner_boundary_layer_params,
		const multiBdryLayerParams &	ring_outer_boundary_layer_params,
		std::vector< Real >	ducts_center_dist,
		const std::vector< unsigned int >	ducts_layers,
		const std::vector< Real >	duct_radial_biases,
		const multiBdryLayerParams &	duct_inner_boundary_layer_params,
		const multiBdryLayerParams &	duct_outer_boundary_layer_params,
		const Real	pitch,
		const unsigned int	num_sectors_per_side,
		const unsigned int	background_intervals,
		const Real	background_radial_bias,
		const singleBdryLayerParams &	background_inner_boundary_layer_params,
		const singleBdryLayerParams &	background_outer_boundary_layer_params,
		dof_id_type &	node_id_background_meta,
		const Real	virtual_side_number,
		const unsigned int	side_index,
		const std::vector< Real >	azimuthal_tangent = `std::vector<Real>()`,
		const subdomain_id_type	block_id_shift = `0`,
		const bool	quad_center_elements = `false`,
		const Real	center_quad_factor = `0.0`,
		const bool	create_inward_interface_boundaries = `false`,
		const bool	create_outward_interface_boundaries = `true`,
		const boundary_id_type	boundary_id_shift = `0`,
		const Real	pitch_scale_factor = `1.0`,
		const bool	generate_side_specific_boundaries = `true`,
		const TRI_ELEM_TYPE	tri_elem_type = `TRI_ELEM_TYPE::TRI3`,
		const QUAD_ELEM_TYPE	quad_elem_type = `QUAD_ELEM_TYPE::QUAD4`
	)

protectedinherited

Generates a mesh of a polygon slice, which is the foundation of both buildGeneralSlice and buildSimpleSlice.

Parameters

ring_radii	radii of the ring regions
ring_layers	numbers of radial intervals of the ring regions
ring_radial_biases	values used for radial meshing biasing in ring regions
ring_inner_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the ring regions
ring_outer_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the ring regions
ducts_center_dist	distance parameters of the duct regions
ducts_layers	numbers of radial intervals of the duct regions
duct_radial_biases	values used for radial meshing biasing in duct regions
duct_inner_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the duct regions
duct_outer_boundary_layer_params	widths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the duct regions
pitch	twice of the length of the first side times cosine of the azimuthal angle
num_sectors_per_side	number of azimuthal intervals
background_intervals	number of radial intervals of the background region
background_radial_bias	value used for radial meshing biasing in background region
background_inner_boundary_layer_params	width, radial sectors, and growth factor of the inner boundary layer of the background region
background_outer_boundary_layer_params	width, radial sectors, and growth factor of the outer boundary layer of the background region
node_id_background_meta	pointer to the first node's id of the background region
virtual_side_number	360.0 over the azimuthal angle of the slice (happens to be number of sides of the polygon if a regular polygon is to be generated)
side_index	index of the polygon side
azimuthal_tangent	vector of tangent values of the azimuthal angles as reference for adaptive boundary matching
block_id_shift	shift of the subdomain ids generated by this function
quad_center_elements	whether the central region contrains quad elements or not
center_quad_factor	A fractional radius factor used to determine the radial positions of transition nodes in the center region meshed by quad elements (default is 1.0 - 1.0/div_num)
create_inward_interface_boundaries	whether inward interface boundary sidesets are created
create_outward_interface_boundaries	whether outward interface boundary sidesets are created
boundary_id_shift	shift of the interface boundary ids
pitch_scale_factor	the ratio between the secondary side length to the primary side length.
generate_side_specific_boundaries	whether the side-specific external boundaries are generated or not
tri_elem_type	type of the triangular elements to be generated
quad_elem_type	type of the quadrilateral elements to be generated

Returns: a mesh of a slice

Definition at line 170 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildGeneralSlice(), PolygonMeshGeneratorBase::buildSimpleSlice(), and AdvancedConcentricCircleGenerator::generate().

 {
   const unsigned short order = quad_elem_type == QUAD_ELEM_TYPE::QUAD4 ? 1 : 2;
   if (order != (tri_elem_type == TRI_ELEM_TYPE::TRI3 ? 1 : 2))
     mooseError("In mesh generator ",
                this->name(),
                ", an incompatible elements type combination is used when calling "
                "PolygonMeshGeneratorBase::buildSlice().");
   // In order to create quadratic elements (i.e., order = 2), we creates nodes with double mesh
   // density. Thus, the related parameters need to be modified accordingly. A prefix "mod_" is used
   // to indicate the modified parameters.
 
   // For ring_layers, modification is to double the number of layers for order = 2
   std::vector<unsigned int> mod_ring_layers(ring_layers);
   std::for_each(
       mod_ring_layers.begin(), mod_ring_layers.end(), [&order](unsigned int & n) { n *= order; });
   // For ring_radial_biases, modification is to take the square root of the original biases for
   // order = 2
   std::vector<Real> mod_ring_radial_biases(ring_radial_biases);
   std::for_each(mod_ring_radial_biases.begin(),
                 mod_ring_radial_biases.end(),
                 [&order](Real & n) { n = std::pow(n, 1.0 / order); });
   // ducts_layers is similar to ring_layers
   std::vector<unsigned int> mod_ducts_layers(ducts_layers);
   std::for_each(
       mod_ducts_layers.begin(), mod_ducts_layers.end(), [&order](unsigned int & n) { n *= order; });
   // duct_radial_biases is similar to ring_radial_biases
   std::vector<Real> mod_duct_radial_biases(duct_radial_biases);
   std::for_each(mod_duct_radial_biases.begin(),
                 mod_duct_radial_biases.end(),
                 [&order](Real & n) { n = std::pow(n, 1.0 / order); });
   // Azimuthal mesh density is also doubled for order = 2
   const unsigned int mod_num_sectors_per_side = num_sectors_per_side * order;
   const unsigned int mod_background_intervals = background_intervals * order;
   // background_radial_bias is similar to ring_radial_biases
   const Real mod_background_radial_bias = std::pow(background_radial_bias, 1.0 / order);
   // Perform similar modifications for boundary layer parameters
   const auto mod_ring_inner_boundary_layer_params =
       modifiedMultiBdryLayerParamsCreator(ring_inner_boundary_layer_params, order);
   const auto mod_ring_outer_boundary_layer_params =
       modifiedMultiBdryLayerParamsCreator(ring_outer_boundary_layer_params, order);
   const auto mod_duct_inner_boundary_layer_params =
       modifiedMultiBdryLayerParamsCreator(duct_inner_boundary_layer_params, order);
   const auto mod_duct_outer_boundary_layer_params =
       modifiedMultiBdryLayerParamsCreator(duct_outer_boundary_layer_params, order);
 
   const auto mod_background_inner_boundary_layer_params =
       modifiedSingleBdryLayerParamsCreator(background_inner_boundary_layer_params, order);
   const auto mod_background_outer_boundary_layer_params =
       modifiedSingleBdryLayerParamsCreator(background_outer_boundary_layer_params, order);
 
   // The distance parameters of the rings and duct need to be modified too as they may be involved
   // in the boundary layer cases.
   std::vector<Real> mod_ducts_center_dist(ducts_center_dist);
   std::vector<Real> mod_ring_radii(ring_radii);
   bool has_rings(ring_radii.size());
   bool has_ducts(ducts_center_dist.size());
   bool has_background(background_intervals);
   auto mesh = buildReplicatedMesh(2);
 
   // Calculate biasing terms
   // background region needs to be split into three parts
   const auto main_background_bias_terms =
       biasTermsCalculator(background_radial_bias, background_intervals);
   const auto inner_background_bias_terms =
       biasTermsCalculator(background_inner_boundary_layer_params.bias,
                           background_inner_boundary_layer_params.intervals);
   const auto outer_background_bias_terms =
       biasTermsCalculator(background_outer_boundary_layer_params.bias,
                           background_outer_boundary_layer_params.intervals);
   auto rings_bias_terms = biasTermsCalculator(ring_radial_biases,
                                               ring_layers,
                                               ring_inner_boundary_layer_params,
                                               ring_outer_boundary_layer_params);
   auto duct_bias_terms = biasTermsCalculator(duct_radial_biases,
                                              ducts_layers,
                                              duct_inner_boundary_layer_params,
                                              duct_outer_boundary_layer_params);
   // Equivalent "mod_" parts
   const auto mod_main_background_bias_terms =
       biasTermsCalculator(mod_background_radial_bias, mod_background_intervals);
   const auto mod_inner_background_bias_terms =
       biasTermsCalculator(mod_background_inner_boundary_layer_params.bias,
                           mod_background_inner_boundary_layer_params.intervals);
   const auto mod_outer_background_bias_terms =
       biasTermsCalculator(mod_background_outer_boundary_layer_params.bias,
                           mod_background_outer_boundary_layer_params.intervals);
   auto mod_rings_bias_terms = biasTermsCalculator(mod_ring_radial_biases,
                                                   mod_ring_layers,
                                                   mod_ring_inner_boundary_layer_params,
                                                   mod_ring_outer_boundary_layer_params);
   auto mod_duct_bias_terms = biasTermsCalculator(mod_duct_radial_biases,
                                                  mod_ducts_layers,
                                                  mod_duct_inner_boundary_layer_params,
                                                  mod_duct_outer_boundary_layer_params);
 
   std::vector<unsigned int> total_ring_layers;
   for (unsigned int i = 0; i < ring_layers.size(); i++)
     total_ring_layers.push_back(ring_layers[i] + ring_inner_boundary_layer_params.intervals[i] +
                                 ring_outer_boundary_layer_params.intervals[i]);
 
   if (background_inner_boundary_layer_params.intervals)
   {
     total_ring_layers.push_back(background_inner_boundary_layer_params.intervals);
     rings_bias_terms.push_back(inner_background_bias_terms);
     ring_radii.push_back((ring_radii.empty() ? 0.0 : ring_radii.back()) +
                          background_inner_boundary_layer_params.width);
     has_rings = true;
   }
   std::vector<unsigned int> mod_total_ring_layers;
   for (unsigned int i = 0; i < mod_ring_layers.size(); i++)
     mod_total_ring_layers.push_back(mod_ring_layers[i] +
                                     mod_ring_inner_boundary_layer_params.intervals[i] +
                                     mod_ring_outer_boundary_layer_params.intervals[i]);
 
   if (mod_background_inner_boundary_layer_params.intervals)
   {
     mod_total_ring_layers.push_back(mod_background_inner_boundary_layer_params.intervals);
     mod_rings_bias_terms.push_back(mod_inner_background_bias_terms);
     mod_ring_radii.push_back((mod_ring_radii.empty() ? 0.0 : mod_ring_radii.back()) +
                              mod_background_inner_boundary_layer_params.width);
     // has_rings should be modified before in the none "mod_" part
   }
 
   std::vector<unsigned int> total_ducts_layers;
   if (background_outer_boundary_layer_params.intervals)
   {
     total_ducts_layers.push_back(background_outer_boundary_layer_params.intervals);
     duct_bias_terms.insert(duct_bias_terms.begin(), outer_background_bias_terms);
     ducts_center_dist.insert(ducts_center_dist.begin(),
                              (ducts_center_dist.empty()
                                   ? pitch / 2.0 / std::cos(M_PI / virtual_side_number)
                                   : ducts_center_dist.front()) -
                                  background_outer_boundary_layer_params.width);
     has_ducts = true;
   }
   for (unsigned int i = 0; i < ducts_layers.size(); i++)
     total_ducts_layers.push_back(ducts_layers[i] + duct_inner_boundary_layer_params.intervals[i] +
                                  duct_outer_boundary_layer_params.intervals[i]);
 
   std::vector<unsigned int> mod_total_ducts_layers;
   if (mod_background_outer_boundary_layer_params.intervals)
   {
     mod_total_ducts_layers.push_back(mod_background_outer_boundary_layer_params.intervals);
     mod_duct_bias_terms.insert(mod_duct_bias_terms.begin(), mod_outer_background_bias_terms);
     mod_ducts_center_dist.insert(mod_ducts_center_dist.begin(),
                                  (mod_ducts_center_dist.empty()
                                       ? pitch / 2.0 / std::cos(M_PI / virtual_side_number)
                                       : mod_ducts_center_dist.front()) -
                                      mod_background_outer_boundary_layer_params.width);
     // has_ducts should be modified before in the none "mod_" part
   }
   for (unsigned int i = 0; i < mod_ducts_layers.size(); i++)
     mod_total_ducts_layers.push_back(mod_ducts_layers[i] +
                                      mod_duct_inner_boundary_layer_params.intervals[i] +
                                      mod_duct_outer_boundary_layer_params.intervals[i]);
 
   unsigned int angle_number = azimuthal_tangent.size() == 0
                                   ? num_sectors_per_side
                                   : ((azimuthal_tangent.size() - 1) / order);
   unsigned int mod_angle_number =
       azimuthal_tangent.size() == 0 ? mod_num_sectors_per_side : (azimuthal_tangent.size() - 1);
 
   // Geometries
   const Real corner_to_corner =
       pitch / std::cos(M_PI / virtual_side_number); // distance of bin center to cell corner
   const Real corner_p[2][2] = {
       {0.0, 0.5 * corner_to_corner},
       {0.5 * corner_to_corner * pitch_scale_factor * std::sin(2.0 * M_PI / virtual_side_number),
        0.5 * corner_to_corner * pitch_scale_factor * std::cos(2.0 * M_PI / virtual_side_number)}};
   const unsigned int div_num = angle_number / 2 + 1;
   const unsigned int mod_div_num = mod_angle_number / 2 + 1;
 
   // From now on, we work on the nodes, which need the "mod_" parameters
   std::vector<std::vector<Node *>> nodes(mod_div_num, std::vector<Node *>(mod_div_num));
   if (quad_center_elements)
   {
     Real ring_radii_0;
 
     if (has_rings)
       ring_radii_0 = ring_radii.front() * mod_rings_bias_terms.front()[order - 1];
     else if (has_ducts)
       ring_radii_0 = mod_ducts_center_dist.front() * std::cos(M_PI / virtual_side_number) *
                      mod_main_background_bias_terms[order - 1];
     else
       ring_radii_0 = pitch / 2.0 * mod_main_background_bias_terms[order - 1];
     // If center_quad_factor is zero, default value (div_num - 1)/div_num  is used.
     // We use div_num instead of mod_div_num because we are dealing wth elements here
     // This approach ensures that the order = 2 mesh elements are consistent with the order = 1
     ring_radii_0 *=
         center_quad_factor == 0.0 ? (((Real)div_num - 1.0) / (Real)div_num) : center_quad_factor;
 
     centerNodes(*mesh, virtual_side_number, mod_div_num, ring_radii_0, nodes);
   }
   else // pin-cell center
     mesh->add_point(Point(0.0, 0.0, 0.0));
 
   // create nodes for the ring regions
   if (has_rings)
     ringNodes(*mesh,
               ring_radii,
               mod_total_ring_layers,
               mod_rings_bias_terms,
               mod_num_sectors_per_side,
               corner_p,
               corner_to_corner,
               azimuthal_tangent);
 
   if (has_background)
   {
     // add nodes in background region; the background region is defined as the area between the
     // outermost pin (if there is a pin; if no pin, the center) and the innermost hex/duct; if
     // _has_ducts is false, the background region is the area between the pin and enclosing hexagon
     Real background_corner_radial_interval_length;
     Real background_corner_distance;
     Real background_in;
     Real background_out; // background outer frontier
     if (has_rings)
       background_in = ring_radii.back();
     else
       background_in = 0;
 
     if (has_ducts)
     {
       background_out = mod_ducts_center_dist.front();
       background_corner_distance =
           mod_ducts_center_dist
               .front(); // it is the center to duct (innermost duct) corner distance
     }
     else
     {
       background_out = 0.5 * corner_to_corner;
       background_corner_distance =
           0.5 * corner_to_corner; // it is the center to hex corner distance
     }
 
     background_corner_radial_interval_length =
         (background_out - background_in) / mod_background_intervals;
 
     node_id_background_meta = mesh->n_nodes();
 
     // create nodes for background region
     backgroundNodes(*mesh,
                     mod_num_sectors_per_side,
                     mod_background_intervals,
                     mod_main_background_bias_terms,
                     background_corner_distance,
                     background_corner_radial_interval_length,
                     corner_p,
                     corner_to_corner,
                     background_in,
                     azimuthal_tangent);
   }
 
   // create nodes for duct regions
   if (has_ducts)
     ductNodes(*mesh,
               &mod_ducts_center_dist,
               mod_total_ducts_layers,
               mod_duct_bias_terms,
               mod_num_sectors_per_side,
               corner_p,
               corner_to_corner,
               azimuthal_tangent);
 
   // See if the central region is the only part of the innermost part
   // The central region of the slice is special.
   // Unlike the outer regions, which are layered quad elements,
   // the central region is either a layer of tri elements or a specially-patterned quad elements.
   // If there is at least one `ring` defined in the slice,
   // the central region must belong to the innermost (first) ring.
   // Otherwise the central region belongs to the `background`
   // In either case, if the innermost ring or background has only one radial interval,
   // the central region is an independent ring or background
   // Otherwise, the central region and one or several quad element layers together form the
   // innermost ring or background
   bool is_central_region_independent;
   if (ring_layers.empty())
     is_central_region_independent = mod_background_inner_boundary_layer_params.intervals +
                                         mod_background_intervals +
                                         mod_background_outer_boundary_layer_params.intervals ==
                                     1;
   else
     is_central_region_independent = mod_ring_layers[0] +
                                         mod_ring_inner_boundary_layer_params.intervals[0] +
                                         mod_ring_outer_boundary_layer_params.intervals[0] ==
                                     1;
 
   // From now on, we work on the elements, which need the none "mod_" parameters
   // Assign elements, boundaries, and subdomains;
   // Add Tri3/Tri6/Tri7 or Quad4/Quad8/Quad9 mesh into innermost (central) region
   if (quad_center_elements)
     cenQuadElemDef(*mesh,
                    div_num,
                    block_id_shift,
                    create_outward_interface_boundaries && is_central_region_independent,
                    boundary_id_shift,
                    nodes,
                    (!has_rings) && (!has_ducts) && (background_intervals == 1),
                    // Note here, has_ring means either there are ring regions or background inner
                    // boundary layer; has_ducts means either there are duct regions or background
                    // outer boundary layer. Same in cenTriElemDef()
                    side_index,
                    generate_side_specific_boundaries,
                    quad_elem_type);
   else
     cenTriElemDef(
         *mesh,
         num_sectors_per_side,
         azimuthal_tangent,
         block_id_shift,
         create_outward_interface_boundaries && is_central_region_independent,
         boundary_id_shift,
         ((!has_rings) && (!has_ducts) && (background_intervals == 1)) ||
             ((!has_background) &&
              (std::accumulate(total_ring_layers.begin(), total_ring_layers.end(), 0) == 1)),
         // Only for ACCG, it is possible that the entire mesh is a single-layer ring.
         // cenQuadElemDef() does not need this as it does not work for ACCG.
         side_index,
         generate_side_specific_boundaries,
         tri_elem_type);
 
   // Add Quad4 mesh into outer circle
   // total number of mesh should be all the rings for pin regions + background regions;
   // total number of quad mesh should be total number of mesh -1 (-1 is because the inner circle for
   // tri/quad mesh has been added above)
 
   std::vector<unsigned int> subdomain_rings;
   if (has_rings) //  define the rings in each subdomain
   {
     subdomain_rings = total_ring_layers;
     subdomain_rings.front() -= 1; // remove the inner TRI mesh subdomain
     if (background_inner_boundary_layer_params.intervals)
     {
       subdomain_rings.back() =
           background_inner_boundary_layer_params.intervals + background_intervals +
           background_outer_boundary_layer_params.intervals; // add the background region
       if (ring_radii.size() == 1)
         subdomain_rings.back() -= 1; // remove the inner TRI mesh subdomain
     }
     else if (has_background)
       subdomain_rings.push_back(background_inner_boundary_layer_params.intervals +
                                 background_intervals +
                                 background_outer_boundary_layer_params.intervals);
   }
   else
   {
     subdomain_rings.push_back(
         background_inner_boundary_layer_params.intervals + background_intervals +
         background_outer_boundary_layer_params.intervals); // add the background region
     subdomain_rings[0] -= 1;                               // remove the inner TRI mesh subdomain
   }
 
   if (has_ducts)
     for (unsigned int i = (background_outer_boundary_layer_params.intervals > 0);
          i < total_ducts_layers.size();
          i++)
       subdomain_rings.push_back(total_ducts_layers[i]);
 
   quadElemDef(*mesh,
               num_sectors_per_side,
               subdomain_rings,
               side_index,
               azimuthal_tangent,
               block_id_shift,
               quad_center_elements ? (mod_div_num * mod_div_num - 1) : 0,
               create_inward_interface_boundaries,
               create_outward_interface_boundaries,
               boundary_id_shift,
               generate_side_specific_boundaries,
               quad_elem_type);
   if (tri_elem_type == TRI_ELEM_TYPE::TRI6 || quad_elem_type == QUAD_ELEM_TYPE::QUAD8)
     mesh->remove_orphaned_nodes();
   return mesh;
 }

◆ cenQuadElemDef()

void PolygonMeshGeneratorBase::cenQuadElemDef	(	ReplicatedMesh &	mesh,
		const unsigned int	div_num,
		const subdomain_id_type	block_id_shift,
		const bool	create_outward_interface_boundaries,
		const boundary_id_type	boundary_id_shift,
		std::vector< std::vector< Node *>> &	nodes,
		const bool	assign_external_boundary = `false`,
		const unsigned int	side_index = `0`,
		const bool	generate_side_specific_boundaries = `true`,
		const QUAD_ELEM_TYPE	quad_elem_type = `QUAD_ELEM_TYPE::QUAD4`
	)		const

protectedinherited

Defines quad elements in the very central region of the polygon.

Parameters

mesh	input mesh to create the elements onto
div_num	division number of the central mesh layer
block_id_shift	shift of the subdomain ids generated by this function
create_outward_interface_boundaries	whether outward interface boundary sidesets are created
boundary_id_shift	shift of the interface boundary ids
id_array	pointer to a vector that contains the node_ids with basic geometry information
assign_external_boundary	whether the external boundary ids are assigned
side_index	index of the polygon side (only used if external boundary ids are assigned)
generate_side_specific_boundaries	whether the side-specific external boundaries are generated or not
quad_elem_type	type of the quadrilateral elements to be generated

Definition at line 853 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice().

 {
 
   BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
   // This loop defines quad elements for the central regions except for the outermost layer
   for (unsigned int i = 0; i < div_num - 1; i++)
   {
     unsigned int id_x = 0;
     unsigned int id_y = i;
     for (unsigned int j = 0; j < 2 * i + 1; j++)
     {
       std::unique_ptr<Elem> new_elem;
       if (quad_elem_type == QUAD_ELEM_TYPE::QUAD4)
       {
         new_elem = std::make_unique<Quad4>();
         new_elem->set_node(0, nodes[id_x][id_y]);
         new_elem->set_node(3, nodes[id_x][id_y + 1]);
         new_elem->set_node(2, nodes[id_x + 1][id_y + 1]);
         new_elem->set_node(1, nodes[id_x + 1][id_y]);
         new_elem->subdomain_id() = 1 + block_id_shift;
       }
       else // QUAD8/QUAD9
       {
         new_elem = std::make_unique<Quad8>();
         if (quad_elem_type == QUAD_ELEM_TYPE::QUAD9)
         {
           new_elem = std::make_unique<Quad9>();
           new_elem->set_node(8, nodes[id_x * 2 + 1][id_y * 2 + 1]);
         }
         new_elem->set_node(0, nodes[id_x * 2][id_y * 2]);
         new_elem->set_node(3, nodes[id_x * 2][id_y * 2 + 2]);
         new_elem->set_node(2, nodes[id_x * 2 + 2][id_y * 2 + 2]);
         new_elem->set_node(1, nodes[id_x * 2 + 2][id_y * 2]);
         new_elem->set_node(4, nodes[id_x * 2 + 1][id_y * 2]);
         new_elem->set_node(5, nodes[id_x * 2 + 2][id_y * 2 + 1]);
         new_elem->set_node(6, nodes[id_x * 2 + 1][id_y * 2 + 2]);
         new_elem->set_node(7, nodes[id_x * 2][id_y * 2 + 1]);
         new_elem->subdomain_id() = 1 + block_id_shift;
       }
       Elem * elem_Quad = mesh.add_elem(std::move(new_elem));
 
       if (id_x == 0)
         boundary_info.add_side(elem_Quad, 3, SLICE_BEGIN);
       if (id_y == 0)
         boundary_info.add_side(elem_Quad, 0, SLICE_END);
       if (j < i)
         id_x++;
       if (j >= i)
         id_y--;
     }
   }
   // This loop defines the outermost layer quad elements of the central region
   for (unsigned int i = (div_num - 1) * (div_num - 1); i < div_num * div_num - 1; i++)
   {
     std::unique_ptr<Elem> new_elem;
     if (quad_elem_type == QUAD_ELEM_TYPE::QUAD4)
     {
       new_elem = std::make_unique<Quad4>();
       new_elem->set_node(0, mesh.node_ptr(i));
       new_elem->set_node(3, mesh.node_ptr(i + 2 * div_num - 1));
       new_elem->set_node(2, mesh.node_ptr(i + 2 * div_num));
       new_elem->set_node(1, mesh.node_ptr(i + 1));
     }
     else // QUAD8/QUAD9
     {
       new_elem = std::make_unique<Quad8>();
       if (quad_elem_type == QUAD_ELEM_TYPE::QUAD9)
       {
         new_elem = std::make_unique<Quad9>();
         new_elem->set_node(8,
                            mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
                                          (i - (div_num - 1) * (div_num - 1)) * 2 + 1 +
                                          ((div_num - 1) * 4 + 1)));
       }
       new_elem->set_node(0,
                          mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
                                        (i - (div_num - 1) * (div_num - 1)) * 2));
       new_elem->set_node(3,
                          mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
                                        (i - (div_num - 1) * (div_num - 1)) * 2 +
                                        ((div_num - 1) * 4 + 1) * 2));
       new_elem->set_node(2,
                          mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
                                        (i - (div_num - 1) * (div_num - 1)) * 2 + 2 +
                                        ((div_num - 1) * 4 + 1) * 2));
       new_elem->set_node(1,
                          mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
                                        (i - (div_num - 1) * (div_num - 1)) * 2 + 2));
       new_elem->set_node(4,
                          mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
                                        (i - (div_num - 1) * (div_num - 1)) * 2 + 1));
       new_elem->set_node(5,
                          mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
                                        (i - (div_num - 1) * (div_num - 1)) * 2 + 2 +
                                        ((div_num - 1) * 4 + 1)));
       new_elem->set_node(6,
                          mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
                                        (i - (div_num - 1) * (div_num - 1)) * 2 + 1 +
                                        ((div_num - 1) * 4 + 1) * 2));
       new_elem->set_node(7,
                          mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
                                        (i - (div_num - 1) * (div_num - 1)) * 2 +
                                        ((div_num - 1) * 4 + 1)));
     }
 
     Elem * elem_Quad = mesh.add_elem(std::move(new_elem));
     elem_Quad->subdomain_id() = 1 + block_id_shift;
     if (create_outward_interface_boundaries)
       boundary_info.add_side(elem_Quad, 2, 1 + boundary_id_shift);
     if (i == (div_num - 1) * (div_num - 1))
       boundary_info.add_side(elem_Quad, 3, SLICE_BEGIN);
     if (i == div_num * div_num - 2)
       boundary_info.add_side(elem_Quad, 1, SLICE_END);
     if (assign_external_boundary)
     {
       boundary_info.add_side(elem_Quad, 2, OUTER_SIDESET_ID);
       if (generate_side_specific_boundaries)
         boundary_info.add_side(
             elem_Quad,
             2,
             (i < div_num * (div_num - 1) ? OUTER_SIDESET_ID : OUTER_SIDESET_ID_ALT) + side_index);
     }
   }
 }

◆ centerNodes()

void PolygonMeshGeneratorBase::centerNodes	(	ReplicatedMesh &	mesh,
		const Real	virtual_side_number,
		const unsigned int	div_num,
		const Real	ring_radii_0,
		std::vector< std::vector< Node *>> &	nodes
	)		const

protectedinherited

Creates nodes of the very central mesh layer of the polygon for quad central elements.

Parameters

mesh	input mesh to add the nodes onto
virtual_side_number	virtual number of sides of the polygon (360/slice_azimuthal)
div_num	division number of the central mesh layer
ring_radii_0	radius of the central mesh layer
nodes	pointer to the mesh's nodes
nodes	vector that contains the nodes with basic geometry information

Definition at line 577 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice().

 {
   const std::pair<Real, Real> p_origin = std::make_pair(0.0, 0.0);
   const std::pair<Real, Real> p_bottom =
       std::make_pair(0.0, ring_radii_0 * std::cos(M_PI / virtual_side_number));
   const std::pair<Real, Real> p_top =
       std::make_pair(p_bottom.second * std::sin(2.0 * M_PI / virtual_side_number),
                      p_bottom.second * std::cos(2.0 * M_PI / virtual_side_number));
   const std::pair<Real, Real> p_diag =
       std::make_pair(ring_radii_0 * std::sin(M_PI / virtual_side_number),
                      ring_radii_0 * std::cos(M_PI / virtual_side_number));
 
   // The four vertices of the central quad region are defined above.
   // The following loops transverse all the nodes within this central quad region by moving p1 thru
   // p4 and calculate the four-point intercept (pc).
   //  p_top------o-------p4--------o-----p_diag
   //    |        |        |        |        |
   //    |        |        |        |        |
   //    o--------o--------o--------o--------o
   //    |        |        |        |        |
   //    |        |        |        |        |
   //   p1--------o-------pc--------o-------p2
   //    |        |        |        |        |
   //    |        |        |        |        |
   //    o--------o--------o--------o--------o
   //    |        |        |        |        |
   //    |        |        |        |        |
   // p_origin-----o-------p3--------o----p_bottom
   //
   // The loops are designed to transverse the nodes as shown below to facilitate elements
   // and sides creation.
   //
   //   25-------24-------23-------22-------21
   //    |        |        |        |        |
   //    |        |        |        |        |
   //   16-------15-------14-------13-------20
   //    |        |        |        |        |
   //    |        |        |        |        |
   //    9--------8------- 7-------12-------19
   //    |        |        |        |        |
   //    |        |        |        |        |
   //    4--------3--------6-------11-------18
   //    |        |        |        |        |
   //    |        |        |        |        |
   //    1--------2--------5-------10-------17
 
   for (unsigned int i = 0; i < div_num; i++)
   {
     unsigned int id_x = 0;
     unsigned int id_y = i;
     for (unsigned int j = 0; j < 2 * i + 1; j++)
     {
       std::pair<Real, Real> p1 = std::make_pair(
           (p_origin.first * (div_num - 1 - id_x) + p_top.first * id_x) / (div_num - 1),
           (p_origin.second * (div_num - 1 - id_x) + p_top.second * id_x) / (div_num - 1));
       std::pair<Real, Real> p2 = std::make_pair(
           (p_bottom.first * (div_num - 1 - id_x) + p_diag.first * id_x) / (div_num - 1),
           (p_bottom.second * (div_num - 1 - id_x) + p_diag.second * id_x) / (div_num - 1));
       std::pair<Real, Real> p3 = std::make_pair(
           (p_origin.first * (div_num - 1 - id_y) + p_bottom.first * id_y) / (div_num - 1),
           (p_origin.second * (div_num - 1 - id_y) + p_bottom.second * id_y) / (div_num - 1));
       std::pair<Real, Real> p4 = std::make_pair(
           (p_top.first * (div_num - 1 - id_y) + p_diag.first * id_y) / (div_num - 1),
           (p_top.second * (div_num - 1 - id_y) + p_diag.second * id_y) / (div_num - 1));
       std::pair<Real, Real> pc = fourPointIntercept(p1, p2, p3, p4);
       nodes[id_x][id_y] = mesh.add_point(Point(pc.first, pc.second, 0.0));
       if (j < i)
         id_x++;
       if (j >= i)
         id_y--;
     }
   }
 }

◆ cenTriElemDef()

void PolygonMeshGeneratorBase::cenTriElemDef	(	ReplicatedMesh &	mesh,
		const unsigned int	num_sectors_per_side,
		const std::vector< Real >	azimuthal_tangent = `std::vector<Real>()`,
		const subdomain_id_type	block_id_shift = `0`,
		const bool	create_outward_interface_boundaries = `true`,
		const boundary_id_type	boundary_id_shift = `0`,
		const bool	assign_external_boundary = `false`,
		const unsigned int	side_index = `0`,
		const bool	generate_side_specific_boundaries = `true`,
		const TRI_ELEM_TYPE	tri_elem_type = `TRI_ELEM_TYPE::TRI3`
	)		const

protectedinherited

Defines triangular elements in the very central region of the polygon.

Parameters

mesh	input mesh to create the elements onto
num_sectors_per_side	number of azimuthal intervals
azimuthal_tangent	vector of tangent values of the azimuthal angles as reference for adaptive boundary matching
block_id_shift	shift of the subdomain ids generated by this function
create_outward_interface_boundaries	whether outward interface boundary sidesets are created
boundary_id_shift	shift of the interface boundary ids
assign_external_boundary	whether the external boundary ids are assigned
side_index	index of the polygon side (only used if external boundary ids are assigned)
generate_side_specific_boundaries	whether the side-specific external boundaries are generated or not
tri_elem_type	type of the triangular elements to be generated

Definition at line 989 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice().

 {
   const unsigned short order = tri_elem_type == TRI_ELEM_TYPE::TRI3 ? 1 : 2;
   unsigned int angle_number = azimuthal_tangent.size() == 0
                                   ? num_sectors_per_side
                                   : ((azimuthal_tangent.size() - 1) / order);
 
   BoundaryInfo & boundary_info = mesh.get_boundary_info();
   for (unsigned int i = 1; i <= angle_number; i++)
   {
     std::unique_ptr<Elem> new_elem;
     if (tri_elem_type == TRI_ELEM_TYPE::TRI3)
     {
       new_elem = std::make_unique<Tri3>();
       new_elem->set_node(0, mesh.node_ptr(0));
       new_elem->set_node(2, mesh.node_ptr(i));
       new_elem->set_node(1, mesh.node_ptr(i + 1));
     }
     else // TRI6/TRI7
     {
       new_elem = std::make_unique<Tri6>();
       if (tri_elem_type == TRI_ELEM_TYPE::TRI7)
       {
         new_elem = std::make_unique<Tri7>();
         new_elem->set_node(6, mesh.node_ptr(i * 2));
       }
       new_elem->set_node(0, mesh.node_ptr(0));
       new_elem->set_node(2, mesh.node_ptr(i * 2 + angle_number * order));
       new_elem->set_node(1, mesh.node_ptr((i + 1) * 2 + angle_number * order));
       new_elem->set_node(3, mesh.node_ptr(i * 2 + 1));
       new_elem->set_node(5, mesh.node_ptr(i * 2 - 1));
       new_elem->set_node(4, mesh.node_ptr(i * 2 + 1 + angle_number * order));
     }
 
     Elem * elem = mesh.add_elem(std::move(new_elem));
     if (create_outward_interface_boundaries)
       boundary_info.add_side(elem, 1, 1 + boundary_id_shift);
     elem->subdomain_id() = 1 + block_id_shift;
     if (i == 1)
       boundary_info.add_side(elem, 2, SLICE_BEGIN);
     if (i == angle_number)
       boundary_info.add_side(elem, 0, SLICE_END);
     if (assign_external_boundary)
     {
       boundary_info.add_side(elem, 1, OUTER_SIDESET_ID);
       if (generate_side_specific_boundaries)
         boundary_info.add_side(elem,
                                1,
                                (i <= angle_number / 2 ? OUTER_SIDESET_ID : OUTER_SIDESET_ID_ALT) +
                                    side_index);
     }
   }
 }

◆ createHEXfromQUAD()

void RevolveGenerator::createHEXfromQUAD	(	const ElemType	hex_elem_type,
		const Elem *	elem,
		const std::unique_ptr< MeshBase > &	mesh,
		std::unique_ptr< Elem > &	new_elem,
		const int	current_layer,
		const unsigned int	orig_nodes,
		const unsigned int	total_num_azimuthal_intervals,
		std::vector< std::pair< dof_id_type, dof_id_type >> &	side_pairs,
		bool &	is_flipped
	)		const

protected

Create a new HEX element from an existing QUAD element by revolving it.

Parameters

hex_elem_type	the type of the new HEX element
elem	the QUAD element to be revolved
mesh	the mesh that the new HEX element will be added to
new_elem	the new HEX element
current_layer	the current layer of the revolving
orig_nodes	the number of nodes in the original mesh
total_num_azimuthal_intervals	the total number of azimuthal intervals for revolving
side_pairs	a vector of pairs to record the corresponding side indices of the original and the new elements
is_flipped	a flag to indicate whether the new element is flipped after creation (to ensure a positive element volume)

Definition at line 2043 of file RevolveGenerator.C.

Referenced by generate().

 {
   if (hex_elem_type != HEX8 && hex_elem_type != HEX20 && hex_elem_type != HEX27)
     mooseError("unsupported situation");
 
   side_pairs.push_back(std::make_pair(0, 5));
   const unsigned int order = hex_elem_type == HEX8 ? 1 : 2;
 
   new_elem = std::make_unique<Hex8>();
   if (order == 2)
   {
     new_elem = std::make_unique<Hex20>();
     if (hex_elem_type == HEX27)
     {
       new_elem = std::make_unique<Hex27>();
       new_elem->set_node(
           20, mesh->node_ptr(elem->node_ptr(8)->id() + (current_layer * 2 * orig_nodes)));
       new_elem->set_node(
           25,
           mesh->node_ptr(elem->node_ptr(8)->id() + ((current_layer + 1) %
                                                     (total_num_azimuthal_intervals + 1 -
                                                      (unsigned int)_full_circle_revolving) *
                                                     2 * orig_nodes)));
       new_elem->set_node(
           26, mesh->node_ptr(elem->node_ptr(8)->id() + ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(
           21, mesh->node_ptr(elem->node_ptr(4)->id() + ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(
           22, mesh->node_ptr(elem->node_ptr(5)->id() + ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(
           23, mesh->node_ptr(elem->node_ptr(6)->id() + ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(
           24, mesh->node_ptr(elem->node_ptr(7)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     }
     new_elem->set_node(8,
                        mesh->node_ptr(elem->node_ptr(4)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(9,
                        mesh->node_ptr(elem->node_ptr(5)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(10,
                        mesh->node_ptr(elem->node_ptr(6)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(11,
                        mesh->node_ptr(elem->node_ptr(7)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(
         16,
         mesh->node_ptr(elem->node_ptr(4)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         17,
         mesh->node_ptr(elem->node_ptr(5)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         18,
         mesh->node_ptr(elem->node_ptr(6)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         19,
         mesh->node_ptr(elem->node_ptr(7)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         12, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         13, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         14, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         15, mesh->node_ptr(elem->node_ptr(3)->id() + ((current_layer * 2 + 1) * orig_nodes)));
   }
   new_elem->set_node(
       0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * order * orig_nodes)));
   new_elem->set_node(
       1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * order * orig_nodes)));
   new_elem->set_node(
       2, mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * order * orig_nodes)));
   new_elem->set_node(
       3, mesh->node_ptr(elem->node_ptr(3)->id() + (current_layer * order * orig_nodes)));
   new_elem->set_node(
       4,
       mesh->node_ptr(elem->node_ptr(0)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem->set_node(
       5,
       mesh->node_ptr(elem->node_ptr(1)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem->set_node(
       6,
       mesh->node_ptr(elem->node_ptr(2)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem->set_node(
       7,
       mesh->node_ptr(elem->node_ptr(3)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
 
   if (new_elem->volume() < 0.0)
   {
     MooseMeshUtils::swapNodesInElem(*new_elem, 0, 4);
     MooseMeshUtils::swapNodesInElem(*new_elem, 1, 5);
     MooseMeshUtils::swapNodesInElem(*new_elem, 2, 6);
     MooseMeshUtils::swapNodesInElem(*new_elem, 3, 7);
     if (order == 2)
     {
       MooseMeshUtils::swapNodesInElem(*new_elem, 8, 16);
       MooseMeshUtils::swapNodesInElem(*new_elem, 9, 17);
       MooseMeshUtils::swapNodesInElem(*new_elem, 10, 18);
       MooseMeshUtils::swapNodesInElem(*new_elem, 11, 19);
       if (hex_elem_type == HEX27)
       {
         MooseMeshUtils::swapNodesInElem(*new_elem, 20, 25);
       }
     }
     is_flipped = true;
   }
 }

◆ createPRISMfromQUAD()

void RevolveGenerator::createPRISMfromQUAD	(	const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &	nodes_cates,
		const ElemType	prism_elem_type,
		const Elem *	elem,
		const std::unique_ptr< MeshBase > &	mesh,
		std::unique_ptr< Elem > &	new_elem,
		const int	current_layer,
		const unsigned int	orig_nodes,
		const unsigned int	total_num_azimuthal_intervals,
		std::vector< std::pair< dof_id_type, dof_id_type >> &	side_pairs,
		dof_id_type &	axis_node_case,
		bool &	is_flipped
	)		const

protected

Create a new PRISM element from an existing QUAD element by revolving it.

Parameters

nodes_cates	a pair of two lists of node IDs: the first list is for nodes on the axis, and the second list is for nodes off the axis
prism_elem_type	the type of the new PRISM element
elem	the QUAD element to be revolved
mesh	the mesh that the new PRISM element will be added to
new_elem	the new PRISM element
current_layer	the current layer of the revolving
orig_nodes	the number of nodes in the original mesh
total_num_azimuthal_intervals	the total number of azimuthal intervals for revolving
side_pairs	a vector of pairs to record the corresponding side indices of the original and the new elements
axis_node_case	a parameter to record on-axis node(s)
is_flipped	a flag to indicate whether the new element is flipped after creation (to ensure a positive element volume)

Definition at line 2181 of file RevolveGenerator.C.

Referenced by generate().

 {
   if (prism_elem_type != PRISM6 && prism_elem_type != PRISM15 && prism_elem_type != PRISM18)
     mooseError("unsupported situation");
 
   side_pairs.push_back(std::make_pair(1, 3));
   const unsigned int order = prism_elem_type == PRISM6 ? 1 : 2;
   if (order == 2)
   {
     // Sanity check to filter unsupported cases
     if (nodes_cates.first[0] > 3 || nodes_cates.first[1] > 3 || nodes_cates.first[2] < 4)
       mooseError("unsupported situation 2");
   }
   // Can only be 0-1, 1-2, 2-3, 3-0, we only consider vetices here.
   // nodes_cates are natually sorted
   const dof_id_type min_on_axis = nodes_cates.first[0];
   const dof_id_type max_on_axis = nodes_cates.first[1];
   axis_node_case = max_on_axis - min_on_axis == 1 ? min_on_axis : max_on_axis;
 
   new_elem = std::make_unique<Prism6>();
   if (order == 2)
   {
     new_elem = std::make_unique<Prism15>();
     if (prism_elem_type == PRISM18)
     {
       new_elem = std::make_unique<Prism18>();
       new_elem->set_node(
           15, mesh->node_ptr(elem->node_ptr(8)->id() + (current_layer * 2 * orig_nodes)));
       new_elem->set_node(16,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4 + 4)->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(
           17,
           mesh->node_ptr(elem->node_ptr(8)->id() + ((current_layer + 1) %
                                                     (total_num_azimuthal_intervals + 1 -
                                                      (unsigned int)_full_circle_revolving) *
                                                     2 * orig_nodes)));
     }
     new_elem->set_node(9, mesh->node_ptr(elem->node_ptr(axis_node_case + 4)->id()));
     new_elem->set_node(10,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4 + 4)->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(12,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4 + 4)->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(6,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4 + 4)->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(
         14,
         mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4 + 4)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         8,
         mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4 + 4)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         11,
         mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4 + 4)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(7,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4)->id() +
                                       ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(13,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4)->id() +
                                       ((current_layer * 2 + 1) * orig_nodes)));
   }
   new_elem->set_node(0, mesh->node_ptr(elem->node_ptr(axis_node_case)->id()));
   new_elem->set_node(3, mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4)->id()));
   new_elem->set_node(4,
                      mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4)->id() +
                                     (current_layer * order * orig_nodes)));
   new_elem->set_node(1,
                      mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4)->id() +
                                     (current_layer * order * orig_nodes)));
   new_elem->set_node(
       5,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem->set_node(
       2,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
 
   if (new_elem->volume() < 0.0)
   {
     MooseMeshUtils::swapNodesInElem(*new_elem, 1, 2);
     MooseMeshUtils::swapNodesInElem(*new_elem, 4, 5);
     if (order == 2)
     {
       MooseMeshUtils::swapNodesInElem(*new_elem, 12, 14);
       MooseMeshUtils::swapNodesInElem(*new_elem, 6, 8);
       MooseMeshUtils::swapNodesInElem(*new_elem, 10, 11);
       if (prism_elem_type == PRISM18)
       {
         MooseMeshUtils::swapNodesInElem(*new_elem, 15, 17);
       }
     }
     is_flipped = true;
   }
 }

◆ createPRISMfromTRI()

void RevolveGenerator::createPRISMfromTRI	(	const ElemType	prism_elem_type,
		const Elem *	elem,
		const std::unique_ptr< MeshBase > &	mesh,
		std::unique_ptr< Elem > &	new_elem,
		const int	current_layer,
		const unsigned int	orig_nodes,
		const unsigned int	total_num_azimuthal_intervals,
		std::vector< std::pair< dof_id_type, dof_id_type >> &	side_pairs,
		bool &	is_flipped
	)		const

protected

Create a new PRISM element from an existing TRI element by revolving it.

Parameters

prism_elem_type	the type of the new TET element
elem	the TRI element to be revolved
mesh	the mesh that the new TET element will be added to
new_elem	the new TET element
current_layer	the current layer of the revolving
orig_nodes	the number of nodes in the original mesh
total_num_azimuthal_intervals	the total number of azimuthal intervals for revolving
side_pairs	a vector of pairs to record the corresponding side indices of the original and the new elements
is_flipped	a flag to indicate whether the new element is flipped after creation (to ensure a positive element volume)

Definition at line 1689 of file RevolveGenerator.C.

Referenced by generate().

 {
   if (prism_elem_type != PRISM6 && prism_elem_type != PRISM18 && prism_elem_type != PRISM21)
     mooseError("unsupported situation");
 
   side_pairs.push_back(std::make_pair(0, 4));
   const unsigned int order = prism_elem_type == PRISM6 ? 1 : 2;
 
   new_elem = std::make_unique<Prism6>();
 
   if (order == 2)
   {
     new_elem = std::make_unique<Prism18>();
     if (prism_elem_type == PRISM21)
     {
       new_elem = std::make_unique<Prism21>();
       new_elem->set_node(
           18, mesh->node_ptr(elem->node_ptr(6)->id() + (current_layer * 2 * orig_nodes)));
       new_elem->set_node(
           19,
           mesh->node_ptr(elem->node_ptr(6)->id() + ((current_layer + 1) %
                                                     (total_num_azimuthal_intervals + 1 -
                                                      (unsigned int)_full_circle_revolving) *
                                                     2 * orig_nodes)));
       new_elem->set_node(
           20, mesh->node_ptr(elem->node_ptr(6)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     }
     new_elem->set_node(6,
                        mesh->node_ptr(elem->node_ptr(3)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(7,
                        mesh->node_ptr(elem->node_ptr(4)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(8,
                        mesh->node_ptr(elem->node_ptr(5)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(
         9, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         10, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         11, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         12,
         mesh->node_ptr(elem->node_ptr(3)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         13,
         mesh->node_ptr(elem->node_ptr(4)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         14,
         mesh->node_ptr(elem->node_ptr(5)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         15, mesh->node_ptr(elem->node_ptr(3)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         16, mesh->node_ptr(elem->node_ptr(4)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         17, mesh->node_ptr(elem->node_ptr(5)->id() + ((current_layer * 2 + 1) * orig_nodes)));
   }
   new_elem->set_node(
       0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * order * orig_nodes)));
   new_elem->set_node(
       1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * order * orig_nodes)));
   new_elem->set_node(
       2, mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * order * orig_nodes)));
   new_elem->set_node(
       3,
       mesh->node_ptr(elem->node_ptr(0)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem->set_node(
       4,
       mesh->node_ptr(elem->node_ptr(1)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem->set_node(
       5,
       mesh->node_ptr(elem->node_ptr(2)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
 
   if (new_elem->volume() < 0.0)
   {
     MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
     MooseMeshUtils::swapNodesInElem(*new_elem, 1, 4);
     MooseMeshUtils::swapNodesInElem(*new_elem, 2, 5);
     if (prism_elem_type != PRISM6)
     {
       MooseMeshUtils::swapNodesInElem(*new_elem, 6, 12);
       MooseMeshUtils::swapNodesInElem(*new_elem, 7, 13);
       MooseMeshUtils::swapNodesInElem(*new_elem, 8, 14);
       if (prism_elem_type == PRISM21)
       {
         MooseMeshUtils::swapNodesInElem(*new_elem, 18, 19);
       }
     }
     is_flipped = true;
   }
 }

◆ createPYRAMIDfromTRI()

void RevolveGenerator::createPYRAMIDfromTRI	(	const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &	nodes_cates,
		const ElemType	pyramid_elem_type,
		const Elem *	elem,
		const std::unique_ptr< MeshBase > &	mesh,
		std::unique_ptr< Elem > &	new_elem,
		const int	current_layer,
		const unsigned int	orig_nodes,
		const unsigned int	total_num_azimuthal_intervals,
		std::vector< std::pair< dof_id_type, dof_id_type >> &	side_pairs,
		dof_id_type &	axis_node_case,
		bool &	is_flipped
	)		const

protected

Create a new PYRAMID element from an existing TRI element by revolving it.

Parameters

nodes_cates	a pair of two lists of node IDs: the first list is for nodes on the axis, and the second list is for nodes off the axis
pyramid_elem_type	the type of the new PYRAMID element
elem	the TRI element to be revolved
mesh	the mesh that the new PYRAMID element will be added to
new_elem	the new PYRAMID element
current_layer	the current layer of the revolving
orig_nodes	the number of nodes in the original mesh
total_num_azimuthal_intervals	the total number of azimuthal intervals for revolving
side_pairs	a vector of pairs to record the corresponding side indices of the original and the new elements
axis_node_case	a parameter to record on-axis node(s)
is_flipped	a flag to indicate whether the new element is flipped after creation (to ensure a positive element volume)

Definition at line 1806 of file RevolveGenerator.C.

Referenced by generate().

 {
   if (pyramid_elem_type != PYRAMID5 && pyramid_elem_type != PYRAMID13 &&
       pyramid_elem_type != PYRAMID18)
     mooseError("unsupported situation");
 
   side_pairs.push_back(std::make_pair(0, 2));
   const unsigned int order = pyramid_elem_type == PYRAMID5 ? 1 : 2;
   axis_node_case = nodes_cates.first.front();
 
   new_elem = std::make_unique<Pyramid5>();
 
   if (order == 2)
   {
     new_elem = std::make_unique<Pyramid13>();
     if (pyramid_elem_type == PYRAMID18)
     {
       new_elem = std::make_unique<Pyramid18>();
       new_elem->set_node(13,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 3 + 3)->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(15,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 3 + 3)->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(17,
                          mesh->node_ptr(elem->node_ptr(axis_node_case + 3)->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(
           14, mesh->node_ptr(elem->node_ptr(6)->id() + (current_layer * 2 * orig_nodes)));
       new_elem->set_node(
           16,
           mesh->node_ptr(elem->node_ptr(6)->id() + ((current_layer + 1) %
                                                     (total_num_azimuthal_intervals + 1 -
                                                      (unsigned int)_full_circle_revolving) *
                                                     2 * orig_nodes)));
     }
     new_elem->set_node(6,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 3)->id() +
                                       ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(8,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 3)->id() +
                                       ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(5,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 3 + 3)->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(
         7,
         mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 3 + 3)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(9,
                        mesh->node_ptr(elem->node_ptr(axis_node_case + 3)->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(10,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 3 + 3)->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(
         12,
         mesh->node_ptr(elem->node_ptr(axis_node_case + 3)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         11,
         mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 3 + 3)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
   }
   new_elem->set_node(4, mesh->node_ptr(elem->node_ptr(axis_node_case)->id()));
   new_elem->set_node(0,
                      mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 3)->id() +
                                     (current_layer * order * orig_nodes)));
   new_elem->set_node(1,
                      mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 3)->id() +
                                     (current_layer * order * orig_nodes)));
   new_elem->set_node(
       2,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 3)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem->set_node(
       3,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 3)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
 
   if (new_elem->volume() < 0.0)
   {
     MooseMeshUtils::swapNodesInElem(*new_elem, 1, 2);
     MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
     if (order == 2)
     {
       MooseMeshUtils::swapNodesInElem(*new_elem, 5, 7);
       MooseMeshUtils::swapNodesInElem(*new_elem, 10, 11);
       MooseMeshUtils::swapNodesInElem(*new_elem, 9, 12);
       if (pyramid_elem_type == PYRAMID18)
       {
         MooseMeshUtils::swapNodesInElem(*new_elem, 14, 16);
       }
     }
     is_flipped = true;
   }
 }

◆ createPYRAMIDPRISMfromQUAD()

void RevolveGenerator::createPYRAMIDPRISMfromQUAD	(	const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &	nodes_cates,
		const ElemType	pyramid_elem_type,
		const ElemType	prism_elem_type,
		const Elem *	elem,
		const std::unique_ptr< MeshBase > &	mesh,
		std::unique_ptr< Elem > &	new_elem,
		std::unique_ptr< Elem > &	new_elem_1,
		const int	current_layer,
		const unsigned int	orig_nodes,
		const unsigned int	total_num_azimuthal_intervals,
		std::vector< std::pair< dof_id_type, dof_id_type >> &	side_pairs,
		dof_id_type &	axis_node_case,
		bool &	is_flipped,
		bool &	is_flipped_additional
	)		const

protected

Create a new PYRAMID element and a new PRISM element from an existing QUAD element by revolving it.

Parameters

nodes_cates	a pair of two lists of node IDs: the first list is for nodes on the axis, and the second list is for nodes off the axis
pyramid_elem_type	the type of the new PYRAMID element
prism_elem_type	the type of the new PRISM element
elem	the QUAD element to be revolved
mesh	the mesh that the new PYRAMID element will be added to
new_elem	the new PYRAMID element
new_elem_1	the new PRISM element
current_layer	the current layer of the revolving
orig_nodes	the number of nodes in the original mesh
total_num_azimuthal_intervals	the total number of azimuthal intervals for revolving
side_pairs	a vector of pairs to record the corresponding side indices of the original and the new elements
axis_node_case	a parameter to record on-axis node(s)
is_flipped	a flag to indicate whether the PYRAMID element is flipped after creation (to ensure a positive element volume)
is_flipped_additional	a flag to indicate whether the PRISM element is flipped after (to ensure a positive element volume) creation

Definition at line 2305 of file RevolveGenerator.C.

Referenced by generate().

 {
   if (!(pyramid_elem_type == PYRAMID5 && prism_elem_type == PRISM6) &&
       !(pyramid_elem_type == PYRAMID14 && prism_elem_type == PRISM18))
     mooseError("unsupported situation");
   const unsigned int order = pyramid_elem_type == PYRAMID5 ? 1 : 2;
 
   side_pairs.push_back(std::make_pair(0, 2));
   axis_node_case = nodes_cates.first.front();
   new_elem = std::make_unique<Pyramid5>();
   if (pyramid_elem_type == PYRAMID14)
   {
     new_elem = std::make_unique<Pyramid14>();
     new_elem->set_node(9,
                        mesh->node_ptr(elem->node_ptr(axis_node_case + 4)->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(10,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4 + 4)->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(5,
                        mesh->node_ptr(elem->node_ptr(8)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(8,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4)->id() +
                                       ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(6,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4)->id() +
                                       ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         13, mesh->node_ptr(elem->node_ptr(8)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         7,
         mesh->node_ptr(elem->node_ptr(8)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         11,
         mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4 + 4)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         12,
         mesh->node_ptr(elem->node_ptr(axis_node_case + 4)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
   }
   new_elem->set_node(4, mesh->node_ptr(elem->node_ptr(axis_node_case)->id()));
   new_elem->set_node(0,
                      mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4)->id() +
                                     (current_layer * order * orig_nodes)));
   new_elem->set_node(1,
                      mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4)->id() +
                                     (current_layer * order * orig_nodes)));
   new_elem->set_node(
       2,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem->set_node(
       3,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
 
   if (new_elem->volume() < 0.0)
   {
     MooseMeshUtils::swapNodesInElem(*new_elem, 1, 2);
     MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
     if (pyramid_elem_type == PYRAMID14)
     {
       MooseMeshUtils::swapNodesInElem(*new_elem, 5, 7);
       MooseMeshUtils::swapNodesInElem(*new_elem, 10, 11);
       MooseMeshUtils::swapNodesInElem(*new_elem, 9, 12);
     }
     is_flipped = true;
   }
 
   side_pairs.push_back(std::make_pair(0, 4));
   new_elem_1 = std::make_unique<Prism6>();
   if (prism_elem_type == PRISM18)
   {
     new_elem_1 = std::make_unique<Prism18>();
     new_elem_1->set_node(
         6, mesh->node_ptr(elem->node_ptr(8)->id() + (current_layer * 2 * orig_nodes)));
     new_elem_1->set_node(8,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4 + 4)->id() +
                                         (current_layer * 2 * orig_nodes)));
     new_elem_1->set_node(7,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4 + 4)->id() +
                                         (current_layer * 2 * orig_nodes)));
     new_elem_1->set_node(9,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4)->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
     new_elem_1->set_node(10,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4)->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
     new_elem_1->set_node(11,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4)->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
     new_elem_1->set_node(
         15, mesh->node_ptr(elem->node_ptr(8)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem_1->set_node(17,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4 + 4)->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
     new_elem_1->set_node(16,
                          mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4 + 4)->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
     new_elem_1->set_node(
         12,
         mesh->node_ptr(elem->node_ptr(8)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem_1->set_node(
         13,
         mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4 + 4)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem_1->set_node(
         14,
         mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4 + 4)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
   }
   new_elem_1->set_node(0,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4)->id() +
                                       (current_layer * order * orig_nodes)));
   new_elem_1->set_node(1,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4)->id() +
                                       (current_layer * order * orig_nodes)));
   new_elem_1->set_node(2,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4)->id() +
                                       (current_layer * order * orig_nodes)));
   new_elem_1->set_node(
       3,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 4)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem_1->set_node(
       4,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 3) % 4)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem_1->set_node(
       5,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 2) % 4)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
 
   if (new_elem_1->volume() < 0.0)
   {
     MooseMeshUtils::swapNodesInElem(*new_elem_1, 0, 3);
     MooseMeshUtils::swapNodesInElem(*new_elem_1, 1, 4);
     MooseMeshUtils::swapNodesInElem(*new_elem_1, 2, 5);
     if (prism_elem_type == PRISM18)
     {
       MooseMeshUtils::swapNodesInElem(*new_elem_1, 6, 12);
       MooseMeshUtils::swapNodesInElem(*new_elem_1, 7, 13);
       MooseMeshUtils::swapNodesInElem(*new_elem_1, 8, 14);
     }
     is_flipped_additional = true;
   }
 }

◆ createQUADfromEDGE()

void RevolveGenerator::createQUADfromEDGE	(	const ElemType	quad_elem_type,
		const Elem *	elem,
		const std::unique_ptr< MeshBase > &	mesh,
		std::unique_ptr< Elem > &	new_elem,
		const int	current_layer,
		const unsigned int	orig_nodes,
		const unsigned int	total_num_azimuthal_intervals,
		std::vector< std::pair< dof_id_type, dof_id_type >> &	side_pairs,
		bool &	is_flipped
	)		const

protected

Create a new QUAD element from an existing EDGE element by revolving it.

Parameters

quad_elem_type	the type of the new QUAD element
elem	the EDGE element to be revolved
mesh	the mesh that the new QUAD element will be added to
new_elem	the new QUAD element
current_layer	the current azimuthal layer
orig_nodes	the number of nodes in the original mesh
total_num_azimuthal_intervals	the total number of azimuthal intervals for revolving
side_pairs	a vector of pairs to record the corresponding side indices of the original and the new elements
is_flipped	a flag to indicate whether the new element is flipped after creation (to ensure a positive element volume)

Definition at line 1565 of file RevolveGenerator.C.

Referenced by generate().

 {
   if (quad_elem_type != QUAD4 && quad_elem_type != QUAD9)
     mooseError("Unsupported element type", quad_elem_type);
 
   side_pairs.push_back(std::make_pair(0, 2));
   const unsigned int order = quad_elem_type == QUAD4 ? 1 : 2;
 
   new_elem = std::make_unique<Quad4>();
   if (quad_elem_type == QUAD9)
   {
     new_elem = std::make_unique<Quad9>();
     new_elem->set_node(4,
                        mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(
         5, mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         6,
         mesh->node_ptr(elem->node_ptr(2)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         7, mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         8, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer * 2 + 1) * orig_nodes)));
   }
 
   new_elem->set_node(
       0, mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * order * orig_nodes)));
   new_elem->set_node(
       1, mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * order * orig_nodes)));
   new_elem->set_node(
       3,
       mesh->node_ptr(elem->node_ptr(0)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
   new_elem->set_node(
       2,
       mesh->node_ptr(elem->node_ptr(1)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
 
   if (new_elem->volume() < 0.0)
   {
     MooseMeshUtils::swapNodesInElem(*new_elem, 0, 3);
     MooseMeshUtils::swapNodesInElem(*new_elem, 1, 2);
     if (quad_elem_type == QUAD9)
       MooseMeshUtils::swapNodesInElem(*new_elem, 4, 6);
     is_flipped = true;
   }
 }

◆ createTETfromTRI()

void RevolveGenerator::createTETfromTRI	(	const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &	nodes_cates,
		const ElemType	tet_elem_type,
		const Elem *	elem,
		const std::unique_ptr< MeshBase > &	mesh,
		std::unique_ptr< Elem > &	new_elem,
		const int	current_layer,
		const unsigned int	orig_nodes,
		const unsigned int	total_num_azimuthal_intervals,
		std::vector< std::pair< dof_id_type, dof_id_type >> &	side_pairs,
		dof_id_type &	axis_node_case,
		bool &	is_flipped
	)		const

protected

Create a new TET element from an existing TRI element by revolving it.

Parameters

nodes_cates	a pair of two lists of node IDs: the first list is for nodes on the axis, and the second list is for nodes off the axis
tet_elem_type	the type of the new TET element
elem	the TRI element to be revolved
mesh	the mesh that the new TET element will be added to
new_elem	the new TET element
current_layer	the current layer of the revolving
orig_nodes	the number of nodes in the original mesh
total_num_azimuthal_intervals	the total number of azimuthal intervals for revolving
side_pairs	a vector of pairs to record the corresponding side indices of the original and the new elements
axis_node_case	a parameter to record on-axis node(s)
is_flipped	a flag to indicate whether the new element is flipped after creation (to ensure a positive element volume)

Definition at line 1926 of file RevolveGenerator.C.

Referenced by generate().

 {
   if (tet_elem_type != TET4 && tet_elem_type != TET10 && tet_elem_type != TET14)
     mooseError("unsupported situation");
 
   side_pairs.push_back(std::make_pair(0, 1));
   const unsigned int order = tet_elem_type == TET4 ? 1 : 2;
   if (order == 2)
   {
     // Sanity check to filter unsupported cases
     if (nodes_cates.first[0] > 2 || nodes_cates.first[1] > 2 || nodes_cates.first[2] < 3)
       mooseError("unsupported situation 2");
   }
   axis_node_case = nodes_cates.second.front();
 
   new_elem = std::make_unique<Tet4>();
   if (order == 2)
   {
     const bool node_order = nodes_cates.first[1] - nodes_cates.first[0] == 1;
     new_elem = std::make_unique<Tet10>();
     if (tet_elem_type == TET14)
     {
       new_elem = std::make_unique<Tet14>();
       new_elem->set_node(
           12,
           mesh->node_ptr(elem->node_ptr(node_order ? (nodes_cates.first[1] + 3)
                                                    : (nodes_cates.second.front() + 3))
                              ->id() +
                          ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(13,
                          mesh->node_ptr(elem->node_ptr(node_order ? (nodes_cates.second.front() + 3)
                                                                   : (nodes_cates.first[0] + 3))
                                             ->id() +
                                         ((current_layer * 2 + 1) * orig_nodes)));
       new_elem->set_node(
           10, mesh->node_ptr(elem->node_ptr(6)->id() + (current_layer * 2 * orig_nodes)));
       new_elem->set_node(
           11,
           mesh->node_ptr(elem->node_ptr(6)->id() + ((current_layer + 1) %
                                                     (total_num_azimuthal_intervals + 1 -
                                                      (unsigned int)_full_circle_revolving) *
                                                     2 * orig_nodes)));
     }
     new_elem->set_node(4,
                        mesh->node_ptr(elem->node_ptr(node_order ? (nodes_cates.first[0] + 3)
                                                                 : (nodes_cates.first[1] + 3))
                                           ->id()));
     new_elem->set_node(5,
                        mesh->node_ptr(elem->node_ptr(node_order ? (nodes_cates.first[1] + 3)
                                                                 : (nodes_cates.second.front() + 3))
                                           ->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(6,
                        mesh->node_ptr(elem->node_ptr(node_order ? (nodes_cates.second.front() + 3)
                                                                 : (nodes_cates.first[0] + 3))
                                           ->id() +
                                       (current_layer * 2 * orig_nodes)));
     new_elem->set_node(
         8,
         mesh->node_ptr(elem->node_ptr(node_order ? (nodes_cates.first[1] + 3)
                                                  : (nodes_cates.second.front() + 3))
                            ->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         7,
         mesh->node_ptr(elem->node_ptr(node_order ? (nodes_cates.second.front() + 3)
                                                  : (nodes_cates.first[0] + 3))
                            ->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(9,
                        mesh->node_ptr(elem->node_ptr(nodes_cates.second.front())->id() +
                                       ((current_layer * 2 + 1) * orig_nodes)));
   }
   new_elem->set_node(0, mesh->node_ptr(elem->node_ptr(nodes_cates.first[0])->id()));
   new_elem->set_node(1, mesh->node_ptr(elem->node_ptr(nodes_cates.first[1])->id()));
   new_elem->set_node(2,
                      mesh->node_ptr(elem->node_ptr(nodes_cates.second.front())->id() +
                                     (current_layer * order * orig_nodes)));
   new_elem->set_node(
       3,
       mesh->node_ptr(elem->node_ptr(nodes_cates.second.front())->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
 
   if (new_elem->volume() < 0.0)
   {
     MooseMeshUtils::swapNodesInElem(*new_elem, 2, 3);
     if (order == 2)
     {
       MooseMeshUtils::swapNodesInElem(*new_elem, 5, 8);
       MooseMeshUtils::swapNodesInElem(*new_elem, 6, 7);
       if (tet_elem_type == TET14)
       {
         MooseMeshUtils::swapNodesInElem(*new_elem, 10, 11);
       }
     }
     is_flipped = true;
   }
 }

◆ createTRIfromEDGE()

void RevolveGenerator::createTRIfromEDGE	(	const std::pair< std::vector< dof_id_type >, std::vector< dof_id_type >> &	nodes_cates,
		const ElemType	tri_elem_type,
		const Elem *	elem,
		const std::unique_ptr< MeshBase > &	mesh,
		std::unique_ptr< Elem > &	new_elem,
		const int	current_layer,
		const unsigned int	orig_nodes,
		const unsigned int	total_num_azimuthal_intervals,
		std::vector< std::pair< dof_id_type, dof_id_type >> &	side_pairs,
		dof_id_type &	axis_node_case,
		bool &	is_flipped
	)		const

protected

Create a new TRI element from an existing EDGE element by revolving it.

Parameters

nodes_cates	a pair of two lists of node IDs: the first list is for nodes on the axis, and the second list is for nodes off the axis
tri_elem_type	the type of the new TRI element
elem	the EDGE element to be revolved
mesh	the mesh that the new TRI element will be added to
new_elem	the new TRI element
current_layer	the current layer of the revolving
orig_nodes	the number of nodes in the original mesh
total_num_azimuthal_intervals	the total number of azimuthal intervals for revolving
side_pairs	a vector of pairs to record the corresponding side indices of the original and the new elements
axis_node_case	a parameter to record on-axis node(s)
is_flipped	a flag to indicate whether the new element is flipped after creation (to ensure a positive element volume)

Definition at line 1629 of file RevolveGenerator.C.

Referenced by generate().

 {
   if (tri_elem_type != TRI3 && tri_elem_type != TRI7)
     mooseError("Unsupported element type", tri_elem_type);
 
   side_pairs.push_back(std::make_pair(0, 2));
   const unsigned int order = tri_elem_type == TRI3 ? 1 : 2;
   axis_node_case = nodes_cates.first.front();
 
   new_elem = std::make_unique<Tri3>();
   if (tri_elem_type == TRI7)
   {
     new_elem = std::make_unique<Tri7>();
     new_elem->set_node(3,
                        mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * 2 * orig_nodes)));
     new_elem->set_node(4,
                        mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 2)->id() +
                                       ((current_layer * 2 + 1) * orig_nodes)));
     new_elem->set_node(
         5,
         mesh->node_ptr(elem->node_ptr(2)->id() +
                        ((current_layer + 1) %
                         (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                         2 * orig_nodes)));
     new_elem->set_node(
         6, mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer * 2 + 1) * orig_nodes)));
   }
 
   new_elem->set_node(0, mesh->node_ptr(elem->node_ptr(axis_node_case)->id()));
   new_elem->set_node(1,
                      mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 2)->id() +
                                     (current_layer * order * orig_nodes)));
   new_elem->set_node(
       2,
       mesh->node_ptr(elem->node_ptr((axis_node_case + 1) % 2)->id() +
                      ((current_layer + 1) %
                       (total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
                       order * orig_nodes)));
 
   if (new_elem->volume() < 0.0)
   {
     MooseMeshUtils::swapNodesInElem(*new_elem, 1, 2);
     if (tri_elem_type == TRI7)
       MooseMeshUtils::swapNodesInElem(*new_elem, 3, 5);
     is_flipped = true;
   }
 }

◆ cutOffPolyDeform()

void PolygonMeshGeneratorBase::cutOffPolyDeform	(	MeshBase &	mesh,
		const Real	orientation,
		const Real	y_max_0,
		const Real	y_max_n,
		const Real	y_min,
		const unsigned int	mesh_type,
		const Real	unit_angle = `60.0`,
		const Real	tols = `1E-5`
	)		const

protectedinherited

Deforms peripheral region when the external side of a polygon assembly of stitched meshes cuts off the stitched meshes.

Parameters

mesh	input mesh to be deformed
orientation	orientation angle of the input mesh (move the deformation direction to y)
y_max_0	original maximum y position
y_max_n	maximum y position after deformation
y_min	minimum y position that is affected by the deformation
mesh_type	whether the peripheral region is for a corner or a side hexagon mesh.
tols	tolerance used to determine the boundary of deformation region
unit_angle	unit angle of the geometry, which is 60.0 for hexagonal and 90.0 for square

Returns: n/a (input mesh is directly altered)

Definition at line 1329 of file PolygonMeshGeneratorBase.C.

Referenced by PatternedHexMeshGenerator::generate(), and PatternedCartesianMeshGenerator::generate().

 {
   for (auto & node_ptr : as_range(mesh.nodes_begin(), mesh.nodes_end()))
   {
     // This function can definitely be optimized in future for better efficiency.
     Real & x = (*node_ptr)(0);
     Real & y = (*node_ptr)(1);
     if (mesh_type == CORNER_MESH)
     {
       nodeCoordRotate(x, y, orientation);
       if (x >= 0.0 && y > y_max_0)
         y = y - y_max_0 + y_max_n;
       else if (x >= 0.0 && y >= y_min)
         y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
       else if (y > -x / std::tan(unit_angle / 360.0 * M_PI) + tols && y > y_max_0)
       {
         x /= y;
         y = y - y_max_0 + y_max_n;
         x *= y;
       }
       else if (y > -x / std::tan(unit_angle / 360.0 * M_PI) + tols && y >= y_min)
       {
         x /= y;
         y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
         x *= y;
       }
       nodeCoordRotate(x, y, -orientation);
 
       nodeCoordRotate(x, y, orientation - unit_angle);
       if (x <= 0 && y > y_max_0)
         y = y - y_max_0 + y_max_n;
       else if (x <= 0 && y >= y_min)
         y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
       else if (y >= x / std::tan(unit_angle / 360.0 * M_PI) - tols && y > y_max_0)
       {
         x /= y;
         y = y - y_max_0 + y_max_n;
         x *= y;
       }
       else if (y >= x / std::tan(unit_angle / 360.0 * M_PI) - tols && y >= y_min)
       {
         x /= y;
         y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
         x *= y;
       }
       nodeCoordRotate(x, y, unit_angle - orientation);
     }
     else
     {
       nodeCoordRotate(x, y, orientation);
       if (y > y_max_0)
         y = y - y_max_0 + y_max_n;
       else if (y >= y_min)
         y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
       nodeCoordRotate(x, y, -orientation);
     }
   }
 }

◆ ductNodes()

void PolygonMeshGeneratorBase::ductNodes	(	ReplicatedMesh &	mesh,
		std::vector< Real > *const	ducts_center_dist,
		const std::vector< unsigned int >	ducts_layers,
		const std::vector< std::vector< Real >>	biased_terms,
		const unsigned int	num_sectors_per_side,
		const Real	corner_p[2][2],
		const Real	corner_to_corner,
		const std::vector< Real >	azimuthal_tangent = `std::vector<Real>()`
	)		const

protectedinherited

Creates nodes for the duct-geometry region of a single slice.

Parameters

mesh	input mesh to add the nodes onto
ducts_center_dist	distance parameters of the duct regions
ducts_layers	numbers of radial intervals of the duct regions
biased_terms	normalized spacing values used for radial meshing biasing in duct region
num_sectors_per_side	number of azimuthal intervals
corner_p[2][2]	array contains the coordinates of the corner positions
corner_to_corner	diameter of the circumscribed circle of the polygon
azimuthal_tangent	vector of tangent values of the azimuthal angles as reference for adaptive boundary matching

Definition at line 792 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice().

 {
   unsigned int angle_number =
       azimuthal_tangent.size() == 0 ? num_sectors_per_side : (azimuthal_tangent.size() - 1);
   // Add nodes in ducts regions
   (*ducts_center_dist)
       .push_back(0.5 * corner_to_corner); // add hex boundary as the last element in this vector
   std::vector<Real> duct_radius_interval_length(ducts_layers.size());
 
   Real bin_radial_distance;
   for (unsigned int l = 0; l < ducts_layers.size(); l++)
   {
     duct_radius_interval_length[l] =
         ((*ducts_center_dist)[l + 1] - (*ducts_center_dist)[l]) /
         ducts_layers[l]; // the pin radius interval for each ring_radii/subdomain
 
     // add rings in each pin subdomain
     for (unsigned int k = 0; k < ducts_layers[l]; k++)
     {
       bin_radial_distance = ((*ducts_center_dist)[l] +
                              biased_terms[l][k] * ducts_layers[l] * duct_radius_interval_length[l]);
       const Real pin_corner_p_x = corner_p[0][0] * bin_radial_distance / (0.5 * corner_to_corner);
       const Real pin_corner_p_y = corner_p[0][1] * bin_radial_distance / (0.5 * corner_to_corner);
 
       // pin_corner_p(s) are the points in the pin region, on the bins towards the six corners,
       // at different intervals
       mesh.add_point(Point(pin_corner_p_x, pin_corner_p_y, 0.0));
 
       for (unsigned int j = 1; j <= angle_number; j++)
       {
         const Real cell_boundary_p_x =
             corner_p[0][0] + (corner_p[1][0] - corner_p[0][0]) *
                                  (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
                                                                 : (azimuthal_tangent[j] / 2.0));
         const Real cell_boundary_p_y =
             corner_p[0][1] + (corner_p[1][1] - corner_p[0][1]) *
                                  (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
                                                                 : (azimuthal_tangent[j] / 2.0));
         // cell_boundary_p(s) are the points on the cell's six boundaries (flat sides) at
         // different azimuthal angles
         const Real pin_azimuthal_p_x =
             cell_boundary_p_x * bin_radial_distance / (0.5 * corner_to_corner);
         const Real pin_azimuthal_p_y =
             cell_boundary_p_y * bin_radial_distance / (0.5 * corner_to_corner);
 
         // pin_azimuthal_p are the points on the bins towards different azimuthal angles, at
         // different intervals; excluding the ones produced by pin_corner_p
         mesh.add_point(Point(pin_azimuthal_p_x, pin_azimuthal_p_y, 0.0));
       }
     }
   }
 }

◆ fourPointIntercept()

std::pair< Real, Real > PolygonMeshGeneratorBase::fourPointIntercept	(	const std::pair< Real, Real > &	p1,
		const std::pair< Real, Real > &	p2,
		const std::pair< Real, Real > &	p3,
		const std::pair< Real, Real > &	p4
	)		const

protectedinherited

Finds the center of a quadrilateral based on four vertices.

Parameters

p1	vertex 1
p2	vertex 2
p3	vertex 3
p4	vertex 4

Returns: the intecept point coordinate x and y

Definition at line 1396 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::centerNodes(), and AzimuthalBlockSplitGenerator::nodeModifier().

 {
   const Real x1 = p1.first;
   const Real y1 = p1.second;
   const Real x2 = p2.first;
   const Real y2 = p2.second;
   const Real x3 = p3.first;
   const Real y3 = p3.second;
   const Real x4 = p4.first;
   const Real y4 = p4.second;
 
   Real x = -((x1 - x2) * (y3 * x4 - x3 * y4) - (x3 - x4) * (y1 * x2 - x1 * y2)) /
            ((y1 - y2) * (x3 - x4) - (y3 - y4) * (x1 - x2));
   Real y = -((y1 - y2) * (y3 * x4 - x3 * y4) - (y3 - y4) * (y1 * x2 - x1 * y2)) /
            ((y1 - y2) * (x3 - x4) - (y3 - y4) * (x1 - x2));
 
   return std::make_pair(x, y);
 }

◆ generate()

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

overridevirtual

Reimplemented from PolygonMeshGeneratorBase.

Definition at line 209 of file RevolveGenerator.C.

 {
   // Note: Inspired by AdvancedExtruderGenerator::generate()
 
   auto mesh = buildMeshBaseObject();
 
   // Only works for 1D and 2D input meshes
   if (_input->mesh_dimension() > 2)
     paramError("input", "This mesh generator only works for 1D and 2D input meshes.");
 
   mesh->set_mesh_dimension(_input->mesh_dimension() + 1);
 
   // Check if the element integer names are existent in the input mesh.
   for (const auto i : index_range(_elem_integer_names_to_swap))
     if (_input->has_elem_integer(_elem_integer_names_to_swap[i]))
       _elem_integer_indices_to_swap.push_back(
           _input->get_elem_integer_index(_elem_integer_names_to_swap[i]));
     else
       paramError("elem_integer_names_to_swap",
                  "Element ",
                  i + 1,
                  " of 'elem_integer_names_to_swap' is not a valid extra element integer of the "
                  "input mesh.");
 
   // prepare for transferring extra element integers from original mesh to the revolved mesh.
   const unsigned int num_extra_elem_integers = _input->n_elem_integers();
   std::vector<std::string> id_names;
 
   for (const auto i : make_range(num_extra_elem_integers))
   {
     id_names.push_back(_input->get_elem_integer_name(i));
     if (!mesh->has_elem_integer(id_names[i]))
       mesh->add_elem_integer(id_names[i]);
   }
 
   // retrieve subdomain/sideset/nodeset name maps
   const auto & input_subdomain_map = _input->get_subdomain_name_map();
   const auto & input_sideset_map = _input->get_boundary_info().get_sideset_name_map();
   const auto & input_nodeset_map = _input->get_boundary_info().get_nodeset_name_map();
 
   std::unique_ptr<MeshBase> input = std::move(_input);
 
   // If we're using a distributed mesh... then make sure we don't have any remote elements hanging
   // around
   if (!input->is_serial())
     mesh->delete_remote_elements();
 
   // check that subdomain swap sources exist in the mesh
   std::set<subdomain_id_type> blocks;
   input->subdomain_ids(blocks, true);
   for (const auto & swap_map : _subdomain_swap_pairs)
     for (const auto & [bid, tbid] : swap_map)
     {
       libmesh_ignore(tbid);
       if (blocks.count(bid) == 0)
         paramError("subdomain_swaps",
                    "Source subdomain " + std::to_string(bid) + " was not found in the mesh");
     }
 
   // Subdomain IDs for on-axis elements must be new
   std::set<subdomain_id_type> subdomain_ids_set;
   input->subdomain_ids(subdomain_ids_set);
   const subdomain_id_type max_subdomain_id = *subdomain_ids_set.rbegin();
   const subdomain_id_type tri_to_pyramid_subdomain_id_shift =
       std::max((int)max_subdomain_id, 1) + 1;
   const subdomain_id_type tri_to_tet_subdomain_id_shift =
       std::max((int)max_subdomain_id, 1) * 2 + 1;
   const subdomain_id_type quad_to_prism_subdomain_id_shift = std::max((int)max_subdomain_id, 1) + 1;
   const subdomain_id_type quad_to_pyramid_subdomain_id_shift =
       std::max((int)max_subdomain_id, 1) * 2 + 1;
   const subdomain_id_type quad_to_hi_pyramid_subdomain_id_shift =
       std::max((int)max_subdomain_id, 1) * 3 + 1;
   const subdomain_id_type edge_to_tri_subdomain_id_shift = std::max((int)max_subdomain_id, 1) + 1;
 
   // Get the centroid of the input mesh
   const auto input_centroid = MooseMeshUtils::meshCentroidCalculator(*input);
   const Point axis_centroid_cross = (input_centroid - _axis_point).cross(_axis_direction);
 
   if (MooseUtils::absoluteFuzzyEqual(axis_centroid_cross.norm(), 0.0))
     mooseError("The input mesh is either across the axis or overlapped with the axis!");
 
   Real inner_product_1d(0.0);
   bool inner_product_1d_initialized(false);
   // record ids of nodes on the axis
   std::vector<dof_id_type> node_ids_on_axis;
   for (const auto & node : input->node_ptr_range())
   {
     const Point axis_node_cross = (*node - _axis_point).cross(_axis_direction);
     // if the cross product is zero, then the node is on the axis
     if (!MooseUtils::absoluteFuzzyEqual(axis_node_cross.norm(), 0.0))
     {
       if (MooseUtils::absoluteFuzzyLessThan(axis_node_cross * axis_centroid_cross, 0.0))
         mooseError("The input mesh is across the axis.");
       else if (MooseUtils::absoluteFuzzyLessThan(axis_node_cross * axis_centroid_cross,
                                                  axis_centroid_cross.norm() *
                                                      axis_node_cross.norm()))
         mooseError("The input mesh is not in the same plane with the rotation axis.");
     }
     else
       node_ids_on_axis.push_back(node->id());
 
     // Only for 1D input mesh, we need to check if the axis is perpendicular to the input mesh
     if (input->mesh_dimension() == 1)
     {
       const Real temp_inner_product = (*node - _axis_point) * _axis_direction.unit();
       if (inner_product_1d_initialized)
       {
         if (!MooseUtils::absoluteFuzzyEqual(temp_inner_product, inner_product_1d))
           mooseError("The 1D input mesh is not perpendicular to the rotation axis.");
       }
       else
       {
         inner_product_1d_initialized = true;
         inner_product_1d = temp_inner_product;
       }
     }
   }
 
   // If there are any on-axis nodes, we need to check if there are any QUAD8 elements with one
   // vertex on the axis. If so, we need to replace it with a QUAD9 element.
   if (!node_ids_on_axis.empty())
   {
     // Sort the vector for using set_intersection
     std::sort(node_ids_on_axis.begin(), node_ids_on_axis.end());
     // For QUAD8 elements with one vertex on the axis, we need to replace it with a QUAD9 element
     std::set<subdomain_id_type> converted_quad8_subdomain_ids;
     for (const auto & elem : input->element_ptr_range())
     {
       if (elem->type() == QUAD8)
       {
         std::vector<dof_id_type> elem_vertex_node_ids;
         for (unsigned int i = 0; i < 4; i++)
         {
           elem_vertex_node_ids.push_back(elem->node_id(i));
         }
         std::sort(elem_vertex_node_ids.begin(), elem_vertex_node_ids.end());
         std::vector<dof_id_type> common_node_ids;
         std::set_intersection(node_ids_on_axis.begin(),
                               node_ids_on_axis.end(),
                               elem_vertex_node_ids.begin(),
                               elem_vertex_node_ids.end(),
                               std::back_inserter(common_node_ids));
         // Temporarily shift the subdomain ID to mark the element
         if (common_node_ids.size() == 1)
         {
           // we borrow quad_to_hi_pyramid_subdomain_id_shift here
           elem->subdomain_id() += quad_to_hi_pyramid_subdomain_id_shift;
           converted_quad8_subdomain_ids.emplace(elem->subdomain_id());
         }
       }
     }
     // Convert the recorded subdomains
     input->all_second_order_range(
         input->active_subdomain_set_elements_ptr_range(converted_quad8_subdomain_ids));
     // Restore the subdomain ID; we do not worry about repeated subdomain IDs because those QUAD9
     // will become PYRAMID and PRISM elements with new shifts
     for (auto elem : input->active_subdomain_set_elements_ptr_range(converted_quad8_subdomain_ids))
       elem->subdomain_id() -= quad_to_hi_pyramid_subdomain_id_shift;
   }
 
   // We should only record this info after QUAD8->QUAD9 conversion
   dof_id_type orig_elem = input->n_elem();
   dof_id_type orig_nodes = input->n_nodes();
 
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
   // Add the number of original elements as revolving may create two elements per layer for one
   // original element
   unique_id_type orig_unique_ids = input->parallel_max_unique_id() + orig_elem;
 #endif
 
   // get rotation vectors
   const auto rotation_vectors = rotationVectors(_axis_point, _axis_direction, input_centroid);
 
   unsigned int order = 1;
 
   BoundaryInfo & boundary_info = mesh->get_boundary_info();
   const BoundaryInfo & input_boundary_info = input->get_boundary_info();
 
   const unsigned int total_num_azimuthal_intervals =
       std::accumulate(_nums_azimuthal_intervals.begin(), _nums_azimuthal_intervals.end(), 0);
   // We know a priori how many elements we'll need
   // In the worst case, all quad elements will become two elements per layer
   mesh->reserve_elem(total_num_azimuthal_intervals * orig_elem * 2);
   const dof_id_type elem_id_shift = total_num_azimuthal_intervals * orig_elem;
 
   // Look for higher order elements which introduce an extra layer
   std::set<ElemType> higher_orders = {EDGE3, TRI6, TRI7, QUAD8, QUAD9};
   std::vector<ElemType> types;
   MeshTools::elem_types(*input, types);
   for (const auto elem_type : types)
     if (higher_orders.count(elem_type))
       order = 2;
   mesh->comm().max(order);
 
   // Collect azimuthal angles and use them to calculate the correction factor if applicable
   std::vector<Real> azi_array;
   for (const auto & i : index_range(_revolving_angles))
   {
     const Real section_start_angle =
         azi_array.empty() ? 0.0 : (azi_array.back() + _unit_angles.back());
     _unit_angles.push_back(_revolving_angles[i] / _nums_azimuthal_intervals[i] / order);
     for (unsigned int j = 0; j < _nums_azimuthal_intervals[i] * order; j++)
       azi_array.push_back(section_start_angle + _unit_angles.back() * (Real)j);
   }
   if (_preserve_volumes)
   {
     _radius_correction_factor = PolygonalMeshGenerationUtils::radiusCorrectionFactor(
         azi_array, _full_circle_revolving, order);
 
     // In the meanwhile, modify the input mesh for radius correction if applicable
     for (const auto & node : input->node_ptr_range())
       nodeModification(*node);
   }
 
   mesh->reserve_nodes(
       (order * total_num_azimuthal_intervals + 1 - (unsigned int)_full_circle_revolving) *
       orig_nodes);
 
   // Container to catch the boundary IDs handed back by the BoundaryInfo object
   std::vector<boundary_id_type> ids_to_copy;
 
   Point old_distance;
   Point current_distance;
   if (!_clockwise)
     std::transform(_unit_angles.begin(),
                    _unit_angles.end(),
                    _unit_angles.begin(),
                    [](auto & c) { return c * (-1.0) * M_PI / 180.0; });
   else
     std::transform(_unit_angles.begin(),
                    _unit_angles.end(),
                    _unit_angles.begin(),
                    [](auto & c) { return c * M_PI / 180.0; });
   std::vector<dof_id_type> nodes_on_axis;
 
   for (const auto & node : input->node_ptr_range())
   {
     // Calculate the radius and corresponding center point on the rotation axis
     // If the radius is 0, then the node is on the axis
     const auto radius_and_center = getRotationCenterAndRadius(*node, _axis_point, _axis_direction);
     const bool isOnAxis = MooseUtils::absoluteFuzzyEqual(radius_and_center.first, 0.0);
     if (isOnAxis)
     {
       nodes_on_axis.push_back(node->id());
     }
 
     unsigned int current_node_layer = 0;
 
     old_distance.zero();
 
     const unsigned int num_rotations = _revolving_angles.size();
     for (unsigned int e = 0; e < num_rotations; e++)
     {
       auto num_layers = _nums_azimuthal_intervals[e];
 
       auto angle = _unit_angles[e];
 
       const auto base_angle =
           std::accumulate(_revolving_angles.begin(), _revolving_angles.begin() + e, 0.0) / 180.0 *
           M_PI;
 
       for (unsigned int k = 0;
            k < order * num_layers + (e == 0 ? 1 : 0) -
                    (e == num_rotations - 1 ? (unsigned int)_full_circle_revolving : 0);
            ++k)
       {
         bool is_node_created(false);
         if (!isOnAxis)
         {
           // For the first layer we don't need to move
           if (e == 0 && k == 0)
             current_distance.zero();
           else
           {
             auto layer_index = (k - (e == 0 ? 1 : 0)) + 1;
 
             // Calculate the rotation angle in XY Plane
             const Point vector_xy =
                 Point(-2.0 * radius_and_center.first *
                           std::sin((base_angle + angle * (Real)layer_index) / 2.0) *
                           std::sin((base_angle + angle * (Real)layer_index) / 2.0),
                       2.0 * radius_and_center.first *
                           std::sin((base_angle + angle * (Real)layer_index) / 2.0) *
                           std::cos((base_angle + angle * (Real)layer_index) / 2.0),
                       0.0);
             current_distance = Point(rotation_vectors[0] * vector_xy,
                                      rotation_vectors[1] * vector_xy,
                                      rotation_vectors[2] * vector_xy);
           }
 
           is_node_created = true;
         }
         else if (e == 0 && k == 0)
         {
           // On-axis nodes are only added once
           current_distance.zero();
           is_node_created = true;
         }
 
         if (is_node_created)
         {
           Node * new_node = mesh->add_point(*node + current_distance,
                                             node->id() + (current_node_layer * orig_nodes),
                                             node->processor_id());
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
           // Let's give the base nodes of the revolved mesh the same
           // unique_ids as the source mesh, in case anyone finds that
           // a useful map to preserve.
           const unique_id_type uid =
               (current_node_layer == 0)
                   ? node->unique_id()
                   : (orig_unique_ids + (current_node_layer - 1) * (orig_nodes + orig_elem * 2) +
                      node->id());
           new_node->set_unique_id(uid);
 #endif
 
           input_boundary_info.boundary_ids(node, ids_to_copy);
           if (_boundary_swap_pairs.empty())
             boundary_info.add_node(new_node, ids_to_copy);
           else
             for (const auto & id_to_copy : ids_to_copy)
               boundary_info.add_node(new_node,
                                      _boundary_swap_pairs[e].count(id_to_copy)
                                          ? _boundary_swap_pairs[e][id_to_copy]
                                          : id_to_copy);
         }
 
         current_node_layer++;
       }
     }
   }
 
   for (const auto & elem : input->element_ptr_range())
   {
     const ElemType etype = elem->type();
 
     // revolving currently only works on coarse meshes
     mooseAssert(!elem->parent(), "RevolveGenerator only works on coarse meshes.");
 
     unsigned int current_layer = 0;
 
     const unsigned int num_rotations = _revolving_angles.size();
 
     for (unsigned int e = 0; e < num_rotations; e++)
     {
       auto num_layers = _nums_azimuthal_intervals[e];
 
       for (unsigned int k = 0; k < num_layers; ++k)
       {
         std::unique_ptr<Elem> new_elem;
         std::unique_ptr<Elem> new_elem_1;
         bool is_flipped(false);
         // In some cases, two elements per layer are generated by revolving one element. So we
         // reserve an additional flag for the potential second element.
         bool is_flipped_additional(false);
         dof_id_type axis_node_case(-1);
         std::vector<std::pair<dof_id_type, dof_id_type>> side_pairs;
         switch (etype)
         {
           case EDGE2:
           {
             // Possible scenarios:
             // 1. None of the nodes are on the axis
             //    Then a quad4 element is created
             // 2. One of the nodes is on the axis
             //    Then a tri3 element is created
             const auto nodes_cates = onAxisNodesIdentifier(*elem, nodes_on_axis);
             if (nodes_cates.first.empty())
             {
               createQUADfromEDGE(QUAD4,
                                  elem,
                                  mesh,
                                  new_elem,
                                  current_layer,
                                  orig_nodes,
                                  total_num_azimuthal_intervals,
                                  side_pairs,
                                  is_flipped);
             }
             else
             {
               createTRIfromEDGE(nodes_cates,
                                 TRI3,
                                 elem,
                                 mesh,
                                 new_elem,
                                 current_layer,
                                 orig_nodes,
                                 total_num_azimuthal_intervals,
                                 side_pairs,
                                 axis_node_case,
                                 is_flipped);
             }
             break;
           }
           case EDGE3:
           {
             // Possible scenarios:
             // 1. None of the nodes are on the axis
             //    Then a QUAD9 element is created
             // 2. One of the nodes is on the axis
             //    Then a TRI7 element is created
             const auto nodes_cates = onAxisNodesIdentifier(*elem, nodes_on_axis);
             if (nodes_cates.first.empty())
             {
               createQUADfromEDGE(QUAD9,
                                  elem,
                                  mesh,
                                  new_elem,
                                  current_layer,
                                  orig_nodes,
                                  total_num_azimuthal_intervals,
                                  side_pairs,
                                  is_flipped);
             }
             else
             {
               createTRIfromEDGE(nodes_cates,
                                 TRI7,
                                 elem,
                                 mesh,
                                 new_elem,
                                 current_layer,
                                 orig_nodes,
                                 total_num_azimuthal_intervals,
                                 side_pairs,
                                 axis_node_case,
                                 is_flipped);
             }
             break;
           }
           case TRI3:
           {
             // Possible scenarios:
             // 1. None of the nodes are on the axis
             //    Then a prism6 element is created
             // 2. One of the nodes is on the axis
             //    Then a pyramid5 element is created
             // 3. Two of the nodes are on the axis
             //    Then a tet4 element is created
             const auto nodes_cates = onAxisNodesIdentifier(*elem, nodes_on_axis);
             if (nodes_cates.first.empty())
             {
               createPRISMfromTRI(PRISM6,
                                  elem,
                                  mesh,
                                  new_elem,
                                  current_layer,
                                  orig_nodes,
                                  total_num_azimuthal_intervals,
                                  side_pairs,
                                  is_flipped);
             }
             else if (nodes_cates.first.size() == 1)
             {
               createPYRAMIDfromTRI(nodes_cates,
                                    PYRAMID5,
                                    elem,
                                    mesh,
                                    new_elem,
                                    current_layer,
                                    orig_nodes,
                                    total_num_azimuthal_intervals,
                                    side_pairs,
                                    axis_node_case,
                                    is_flipped);
             }
             else if (nodes_cates.first.size() == 2)
             {
               createTETfromTRI(nodes_cates,
                                TET4,
                                elem,
                                mesh,
                                new_elem,
                                current_layer,
                                orig_nodes,
                                total_num_azimuthal_intervals,
                                side_pairs,
                                axis_node_case,
                                is_flipped);
             }
             else
               mooseError("A degenerate TRI3 elements overlapped with the rotation axis cannot be "
                          "revolved.");
 
             break;
           }
           case TRI6:
           {
             // Possible scenarios:
             // 1. None of the nodes are on the axis
             //    Then a prism18 element is created
             // 2. One of the nodes is on the axis
             //    Then a pyramid13 element is created
             // 3. Three of the nodes are on the axis
             //    Then a tet10 element is created
             // NOTE: We do not support two nodes on the axis for tri6 elements
             const auto nodes_cates = onAxisNodesIdentifier(*elem, nodes_on_axis);
             if (nodes_cates.first.empty())
             {
               createPRISMfromTRI(PRISM18,
                                  elem,
                                  mesh,
                                  new_elem,
                                  current_layer,
                                  orig_nodes,
                                  total_num_azimuthal_intervals,
                                  side_pairs,
                                  is_flipped);
             }
             else if (nodes_cates.first.size() == 1)
             {
               createPYRAMIDfromTRI(nodes_cates,
                                    PYRAMID13,
                                    elem,
                                    mesh,
                                    new_elem,
                                    current_layer,
                                    orig_nodes,
                                    total_num_azimuthal_intervals,
                                    side_pairs,
                                    axis_node_case,
                                    is_flipped);
             }
             else if (nodes_cates.first.size() == 3)
             {
               createTETfromTRI(nodes_cates,
                                TET10,
                                elem,
                                mesh,
                                new_elem,
                                current_layer,
                                orig_nodes,
                                total_num_azimuthal_intervals,
                                side_pairs,
                                axis_node_case,
                                is_flipped);
             }
             else
               mooseError(
                   "You either have a degenerate TRI6 element, or the mid-point of the "
                   "on-axis edge is not colinear with the two vertices, which is not supported.");
             break;
           }
           case TRI7:
           {
             // Possible scenarios:
             // 1. None of the nodes are on the axis
             //    Then a prism21 element is created
             // 2. One of the nodes is on the axis
             //    Then a pyramid18 element is created
             // 3. Three of the nodes are on the axis
             //    Then a tet14 element is created
             // NOTE: We do not support two nodes on the axis for tri7 elements
             const auto nodes_cates = onAxisNodesIdentifier(*elem, nodes_on_axis);
             if (nodes_cates.first.empty())
             {
               createPRISMfromTRI(PRISM21,
                                  elem,
                                  mesh,
                                  new_elem,
                                  current_layer,
                                  orig_nodes,
                                  total_num_azimuthal_intervals,
                                  side_pairs,
                                  is_flipped);
             }
             else if (nodes_cates.first.size() == 1)
             {
               createPYRAMIDfromTRI(nodes_cates,
                                    PYRAMID18,
                                    elem,
                                    mesh,
                                    new_elem,
                                    current_layer,
                                    orig_nodes,
                                    total_num_azimuthal_intervals,
                                    side_pairs,
                                    axis_node_case,
                                    is_flipped);
             }
             else if (nodes_cates.first.size() == 3)
             {
               createTETfromTRI(nodes_cates,
                                TET14,
                                elem,
                                mesh,
                                new_elem,
                                current_layer,
                                orig_nodes,
                                total_num_azimuthal_intervals,
                                side_pairs,
                                axis_node_case,
                                is_flipped);
             }
             else
               mooseError("You either have a degenerate TRI6 element, or the mid-point of the "
                          "on-axis edge of the TRI6 element is not colinear with the two vertices, "
                          "which is not supported.");
             break;
           }
           case QUAD4:
           {
             // Possible scenarios:
             // 1. None of the nodes are on the axis
             //    Then a hex8 element is created
             // 2. One of the nodes is on the axis
             //    Then a pyramid5 element and a prism6 element are created
             // 3. Two of the nodes are on the axis
             //    Then a prism6 is created
             const auto nodes_cates = onAxisNodesIdentifier(*elem, nodes_on_axis);
             if (nodes_cates.first.empty())
             {
               createHEXfromQUAD(HEX8,
                                 elem,
                                 mesh,
                                 new_elem,
                                 current_layer,
                                 orig_nodes,
                                 total_num_azimuthal_intervals,
                                 side_pairs,
                                 is_flipped);
             }
             else if (nodes_cates.first.size() == 1)
             {
               createPYRAMIDPRISMfromQUAD(nodes_cates,
                                          PYRAMID5,
                                          PRISM6,
                                          elem,
                                          mesh,
                                          new_elem,
                                          new_elem_1,
                                          current_layer,
                                          orig_nodes,
                                          total_num_azimuthal_intervals,
                                          side_pairs,
                                          axis_node_case,
                                          is_flipped,
                                          is_flipped_additional);
             }
             else if (nodes_cates.first.size() == 2)
             {
               createPRISMfromQUAD(nodes_cates,
                                   PRISM6,
                                   elem,
                                   mesh,
                                   new_elem,
                                   current_layer,
                                   orig_nodes,
                                   total_num_azimuthal_intervals,
                                   side_pairs,
                                   axis_node_case,
                                   is_flipped);
             }
 
             else
               mooseError("Degenerate QUAD4 element with 3 or more aligned nodes cannot be "
                          "azimuthally revolved");
 
             break;
           }
           case QUAD8:
           {
             // Possible scenarios:
             // 1. None of the nodes are on the axis
             //    Then a hex20 element is created
             // 2. One of the nodes is on the axis
             //    In that case, it is already converted to a QUAD9 element before,
             //    SO we do not need to worry about this case
             // 3. Three of the nodes are on the axis
             //    Then a prism15 is created
             // NOTE: We do not support two nodes on the axis for quad8 elements
             const auto nodes_cates = onAxisNodesIdentifier(*elem, nodes_on_axis);
             if (nodes_cates.first.empty())
             {
               createHEXfromQUAD(HEX20,
                                 elem,
                                 mesh,
                                 new_elem,
                                 current_layer,
                                 orig_nodes,
                                 total_num_azimuthal_intervals,
                                 side_pairs,
                                 is_flipped);
             }
             else if (nodes_cates.first.size() == 3)
             {
               createPRISMfromQUAD(nodes_cates,
                                   PRISM15,
                                   elem,
                                   mesh,
                                   new_elem,
                                   current_layer,
                                   orig_nodes,
                                   total_num_azimuthal_intervals,
                                   side_pairs,
                                   axis_node_case,
                                   is_flipped);
             }
             else
               mooseError("You either have a degenerate QUAD8 element, or the mid-point of the "
                          "on-axis edge of the QUAD8 element is not colinear with the two vertices, "
                          "which is not supported.");
 
             break;
           }
           case QUAD9:
           {
             // Possible scenarios:
             // 1. None of the nodes are on the axis
             //    Then a hex27 element is created
             // 2. One of the nodes is on the axis
             //    Then a pyramid14 element and a prism18 element are created
             // 3. Two of the nodes are on the axis
             //    Then a prism18 is created
             // (we do not create prism20/21 here just to make prism18 the only possible prism
             // elements for simplicity)
             const auto nodes_cates = onAxisNodesIdentifier(*elem, nodes_on_axis);
             if (nodes_cates.first.empty())
             {
               createHEXfromQUAD(HEX27,
                                 elem,
                                 mesh,
                                 new_elem,
                                 current_layer,
                                 orig_nodes,
                                 total_num_azimuthal_intervals,
                                 side_pairs,
                                 is_flipped);
             }
             else if (nodes_cates.first.size() == 1)
             {
               createPYRAMIDPRISMfromQUAD(nodes_cates,
                                          PYRAMID14,
                                          PRISM18,
                                          elem,
                                          mesh,
                                          new_elem,
                                          new_elem_1,
                                          current_layer,
                                          orig_nodes,
                                          total_num_azimuthal_intervals,
                                          side_pairs,
                                          axis_node_case,
                                          is_flipped,
                                          is_flipped_additional);
             }
             else if (nodes_cates.first.size() == 3)
             {
               createPRISMfromQUAD(nodes_cates,
                                   PRISM18,
                                   elem,
                                   mesh,
                                   new_elem,
                                   current_layer,
                                   orig_nodes,
                                   total_num_azimuthal_intervals,
                                   side_pairs,
                                   axis_node_case,
                                   is_flipped);
             }
             else
               mooseError("You either have a degenerate QUAD9 element, or the mid-point of the "
                          "on-axis edge of the QUAD9 element is not colinear with the two vertices, "
                          "which is not supported.");
             break;
           }
           default:
             mooseError("The input mesh contains unsupported element type(s).");
         }
         new_elem->set_id(elem->id() + (current_layer * orig_elem));
         new_elem->processor_id() = elem->processor_id();
         if (new_elem_1)
         {
           new_elem_1->set_id(elem->id() + (current_layer * orig_elem) + elem_id_shift);
           new_elem_1->processor_id() = elem->processor_id();
         }
 
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
         // Let's give the base elements of the revolved mesh the same
         // unique_ids as the source mesh, in case anyone finds that
         // a useful map to preserve.
         const unique_id_type uid =
             (current_layer == 0)
                 ? elem->unique_id()
                 : (orig_unique_ids + (current_layer - 1) * (orig_nodes + orig_elem * 2) +
                    orig_nodes + elem->id());
 
         new_elem->set_unique_id(uid);
 
         // Special case for extra elements
         if (new_elem_1)
         {
           const unique_id_type uid_1 =
               (current_layer == 0)
                   ? (elem->id() + orig_unique_ids - orig_elem)
                   : (orig_unique_ids + (current_layer - 1) * (orig_nodes + orig_elem * 2) +
                      orig_nodes + orig_elem + elem->id());
 
           new_elem_1->set_unique_id(uid_1);
         }
 #endif
 
         // maintain the subdomain_id
         switch (etype)
         {
           case EDGE2:
             switch (new_elem->type())
             {
               case QUAD4:
                 new_elem->subdomain_id() = elem->subdomain_id();
                 break;
               case TRI3:
                 new_elem->subdomain_id() = edge_to_tri_subdomain_id_shift + elem->subdomain_id();
                 break;
               default:
                 mooseAssert(false,
                             "impossible element type generated by revolving an EDGE2 element");
             }
             break;
           case EDGE3:
             switch (new_elem->type())
             {
               case QUAD9:
                 new_elem->subdomain_id() = elem->subdomain_id();
                 break;
               case TRI7:
                 new_elem->subdomain_id() = edge_to_tri_subdomain_id_shift + elem->subdomain_id();
                 break;
               default:
                 mooseAssert(false,
                             "impossible element type generated by revolving an EDGE3 element");
             }
             break;
           case TRI3:
             switch (new_elem->type())
             {
               case PRISM6:
                 new_elem->subdomain_id() = elem->subdomain_id();
                 break;
               case PYRAMID5:
                 new_elem->subdomain_id() = tri_to_pyramid_subdomain_id_shift + elem->subdomain_id();
                 break;
               case TET4:
                 new_elem->subdomain_id() = tri_to_tet_subdomain_id_shift + elem->subdomain_id();
                 break;
               default:
                 mooseAssert(false, "impossible element type generated by revolving a TRI3 element");
             }
             break;
           case TRI6:
             switch (new_elem->type())
             {
               case PRISM18:
                 new_elem->subdomain_id() = elem->subdomain_id();
                 break;
               case PYRAMID13:
                 new_elem->subdomain_id() = tri_to_pyramid_subdomain_id_shift + elem->subdomain_id();
                 break;
               case TET10:
                 new_elem->subdomain_id() = tri_to_tet_subdomain_id_shift + elem->subdomain_id();
                 break;
               default:
                 mooseAssert(false, "impossible element type generated by revolving a TRI6 element");
             }
             break;
           case TRI7:
             switch (new_elem->type())
             {
               case PRISM21:
                 new_elem->subdomain_id() = elem->subdomain_id();
                 break;
               case PYRAMID18:
                 new_elem->subdomain_id() = tri_to_pyramid_subdomain_id_shift + elem->subdomain_id();
                 break;
               case TET14:
                 new_elem->subdomain_id() = tri_to_tet_subdomain_id_shift + elem->subdomain_id();
                 break;
               default:
                 mooseAssert(false, "impossible element type generated by revolving a TRI7 element");
             }
             break;
           case QUAD4:
             switch (new_elem->type())
             {
               case HEX8:
                 new_elem->subdomain_id() = elem->subdomain_id();
                 break;
               case PRISM6:
                 new_elem->subdomain_id() = quad_to_prism_subdomain_id_shift + elem->subdomain_id();
                 break;
               case PYRAMID5:
                 new_elem->subdomain_id() =
                     quad_to_pyramid_subdomain_id_shift + elem->subdomain_id();
                 new_elem_1->subdomain_id() =
                     quad_to_prism_subdomain_id_shift + elem->subdomain_id();
                 break;
               default:
                 mooseAssert(false,
                             "impossible element type generated by revolving a QUAD4 element");
             }
             break;
           case QUAD8:
             switch (new_elem->type())
             {
               case HEX20:
                 new_elem->subdomain_id() = elem->subdomain_id();
                 break;
               case PRISM15:
                 new_elem->subdomain_id() = quad_to_prism_subdomain_id_shift + elem->subdomain_id();
                 break;
               default:
                 mooseAssert(false,
                             "impossible element type generated by revolving a QUAD8 element");
             }
             break;
           case QUAD9:
             switch (new_elem->type())
             {
               case HEX27:
                 new_elem->subdomain_id() = elem->subdomain_id();
                 break;
               case PRISM18:
                 new_elem->subdomain_id() =
                     quad_to_hi_pyramid_subdomain_id_shift + elem->subdomain_id();
                 break;
               case PYRAMID14:
                 new_elem->subdomain_id() =
                     quad_to_pyramid_subdomain_id_shift + elem->subdomain_id();
                 new_elem_1->subdomain_id() =
                     quad_to_hi_pyramid_subdomain_id_shift + elem->subdomain_id();
                 break;
               default:
                 mooseAssert(false,
                             "impossible element type generated by revolving a QUAD9 element");
             }
             break;
           default:
             mooseAssert(false,
                         "The input mesh contains unsupported element type(s), which should have "
                         "been checked in prior steps in this code.");
         }
 
         if (_subdomain_swap_pairs.size())
         {
           auto & revolving_swap_pairs = _subdomain_swap_pairs[e];
 
           auto new_id_it = revolving_swap_pairs.find(elem->subdomain_id());
 
           if (new_id_it != revolving_swap_pairs.end())
           {
             new_elem->subdomain_id() =
                 new_elem->subdomain_id() - elem->subdomain_id() + new_id_it->second;
             if (new_elem_1)
               new_elem_1->subdomain_id() =
                   new_elem_1->subdomain_id() - elem->subdomain_id() + new_id_it->second;
           }
         }
 
         Elem * added_elem = mesh->add_elem(std::move(new_elem));
         Elem * added_elem_1 = NULL;
 
         if (new_elem_1)
           added_elem_1 = mesh->add_elem(std::move(new_elem_1));
 
         // maintain extra integers
         for (unsigned int i = 0; i < num_extra_elem_integers; i++)
         {
           added_elem->set_extra_integer(i, elem->get_extra_integer(i));
           if (added_elem_1)
             added_elem_1->set_extra_integer(i, elem->get_extra_integer(i));
         }
 
         if (_elem_integers_swap_pairs.size())
         {
           for (unsigned int i = 0; i < _elem_integer_indices_to_swap.size(); i++)
           {
             auto & elevation_extra_swap_pairs =
                 _elem_integers_swap_pairs[i * _nums_azimuthal_intervals.size() + e];
 
             auto new_extra_id_it = elevation_extra_swap_pairs.find(
                 elem->get_extra_integer(_elem_integer_indices_to_swap[i]));
 
             if (new_extra_id_it != elevation_extra_swap_pairs.end())
             {
               added_elem->set_extra_integer(_elem_integer_indices_to_swap[i],
                                             new_extra_id_it->second);
               if (added_elem_1)
                 added_elem_1->set_extra_integer(_elem_integer_indices_to_swap[i],
                                                 new_extra_id_it->second);
             }
           }
         }
 
         // Copy any old boundary ids on all sides
         for (auto s : elem->side_index_range())
         {
           input_boundary_info.boundary_ids(elem, s, ids_to_copy);
           std::vector<boundary_id_type> ids_to_copy_swapped;
           if (_boundary_swap_pairs.empty())
             ids_to_copy_swapped = ids_to_copy;
           else
             for (const auto & id_to_copy : ids_to_copy)
               ids_to_copy_swapped.push_back(_boundary_swap_pairs[e].count(id_to_copy)
                                                 ? _boundary_swap_pairs[e][id_to_copy]
                                                 : id_to_copy);
 
           switch (etype)
           {
             case EDGE2:
               switch (added_elem->type())
               {
                 case QUAD4:
                   boundary_info.add_side(
                       added_elem, cast_int<unsigned short>(s == 0 ? 3 : 1), ids_to_copy_swapped);
                   break;
                 case TRI3:
                   if (s != axis_node_case)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(s), ids_to_copy_swapped);
                   break;
                 default:
                   mooseAssert(false,
                               "impossible element type generated by revolving an EDGE2 element");
               }
               break;
             case EDGE3:
               switch (added_elem->type())
               {
                 case QUAD9:
                   boundary_info.add_side(
                       added_elem, cast_int<unsigned short>(s == 0 ? 3 : 1), ids_to_copy_swapped);
                   break;
                 case TRI7:
                   if (s != axis_node_case)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(s), ids_to_copy_swapped);
                   break;
                 default:
                   mooseAssert(false,
                               "impossible element type generated by revolving an EDGE3 element");
               }
               break;
             case TRI3:
               switch (added_elem->type())
               {
                 case PRISM6:
                   boundary_info.add_side(
                       added_elem, cast_int<unsigned short>(s + 1), ids_to_copy_swapped);
                   break;
                 case PYRAMID5:
                   if ((s + 3 - axis_node_case) % 3 == 0)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   else if ((s + 3 - axis_node_case) % 3 == 1)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(4), ids_to_copy_swapped);
                   else
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(1), ids_to_copy_swapped);
                   break;
                 case TET4:
                   if ((s + 3 - axis_node_case) % 3 == 0)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(2), ids_to_copy_swapped);
                   else if ((s + 3 - axis_node_case) % 3 == 2)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   break;
                 default:
                   mooseAssert(false,
                               "impossible element type generated by revolving a TRI3 element");
               }
               break;
             case TRI6:
               switch (added_elem->type())
               {
                 case PRISM18:
                   boundary_info.add_side(
                       added_elem, cast_int<unsigned short>(s + 1), ids_to_copy_swapped);
                   break;
                 case PYRAMID13:
                   if ((s + 3 - axis_node_case) % 3 == 0)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   else if ((s + 3 - axis_node_case) % 3 == 1)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(4), ids_to_copy_swapped);
                   else
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(1), ids_to_copy_swapped);
                   break;
                 case TET10:
                   if ((s + 3 - axis_node_case) % 3 == 0)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(2), ids_to_copy_swapped);
                   else if ((s + 3 - axis_node_case) % 3 == 2)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   break;
                 default:
                   mooseAssert(false,
                               "impossible element type generated by revolving a TRI6 element");
               }
               break;
             case TRI7:
               switch (added_elem->type())
               {
                 case PRISM21:
                   boundary_info.add_side(
                       added_elem, cast_int<unsigned short>(s + 1), ids_to_copy_swapped);
                   break;
                 case PYRAMID18:
                   if ((s + 3 - axis_node_case) % 3 == 0)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   else if ((s + 3 - axis_node_case) % 3 == 1)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(4), ids_to_copy_swapped);
                   else
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(1), ids_to_copy_swapped);
                   break;
                 case TET14:
                   if ((s + 3 - axis_node_case) % 3 == 0)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(2), ids_to_copy_swapped);
                   else if ((s + 3 - axis_node_case) % 3 == 2)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   break;
                 default:
                   mooseAssert(false,
                               "impossible element type generated by revolving a TRI7 element");
               }
               break;
             case QUAD4:
               switch (added_elem->type())
               {
                 case HEX8:
                   boundary_info.add_side(
                       added_elem, cast_int<unsigned short>(s + 1), ids_to_copy_swapped);
                   break;
                 case PRISM6:
                   if ((s + 4 - axis_node_case) % 4 == 1)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(4), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 2)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(2), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 3)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(0), ids_to_copy_swapped);
                   break;
                 case PYRAMID5:
                   if ((s + 4 - axis_node_case) % 4 == 3)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(1), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 0)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 1)
                     boundary_info.add_side(
                         added_elem_1, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   else
                     boundary_info.add_side(
                         added_elem_1, cast_int<unsigned short>(2), ids_to_copy_swapped);
                   break;
                 default:
                   mooseAssert(false,
                               "impossible element type generated by revolving a QUAD4 element");
               }
               break;
             case QUAD8:
               switch (added_elem->type())
               {
                 case HEX20:
                   boundary_info.add_side(
                       added_elem, cast_int<unsigned short>(s + 1), ids_to_copy_swapped);
                   break;
                 case PRISM15:
                   if ((s + 4 - axis_node_case) % 4 == 1)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(4), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 2)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(2), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 3)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(0), ids_to_copy_swapped);
                   break;
                 default:
                   mooseAssert(false,
                               "impossible element type generated by revolving a QUAD8 element");
               }
               break;
             case QUAD9:
               switch (added_elem->type())
               {
                 case HEX27:
                   boundary_info.add_side(
                       added_elem, cast_int<unsigned short>(s + 1), ids_to_copy_swapped);
                   break;
                 case PRISM18:
                   if ((s + 4 - axis_node_case) % 4 == 1)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(4), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 2)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(2), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 3)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(0), ids_to_copy_swapped);
                   break;
                 case PYRAMID14:
                   if ((s + 4 - axis_node_case) % 4 == 3)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(1), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 0)
                     boundary_info.add_side(
                         added_elem, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   else if ((s + 4 - axis_node_case) % 4 == 1)
                     boundary_info.add_side(
                         added_elem_1, cast_int<unsigned short>(3), ids_to_copy_swapped);
                   else
                     boundary_info.add_side(
                         added_elem_1, cast_int<unsigned short>(2), ids_to_copy_swapped);
                   break;
                 default:
                   mooseAssert(false,
                               "impossible element type generated by revolving a QUAD9 element");
               }
               break;
             default:
               mooseAssert(false,
                           "The input mesh contains unsupported element type(s), which should have "
                           "been checked in prior steps in this code.");
           }
         }
 
         if (current_layer == 0 && _has_start_boundary)
         {
           boundary_info.add_side(
               added_elem, is_flipped ? side_pairs[0].second : side_pairs[0].first, _start_boundary);
           if (side_pairs.size() > 1)
             boundary_info.add_side(added_elem_1,
                                    is_flipped_additional ? side_pairs[1].second
                                                          : side_pairs[1].first,
                                    _start_boundary);
         }
 
         if (current_layer == num_layers - 1 && _has_end_boundary)
         {
           boundary_info.add_side(
               added_elem, is_flipped ? side_pairs[0].first : side_pairs[0].second, _end_boundary);
           if (side_pairs.size() > 1)
             boundary_info.add_side(added_elem_1,
                                    is_flipped_additional ? side_pairs[1].first
                                                          : side_pairs[1].second,
                                    _end_boundary);
         }
         current_layer++;
       }
     }
   }
 
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
   // Update the value of next_unique_id based on newly created nodes and elements
   // Note: the calculation here is quite conservative to ensure uniqueness
   unsigned int total_new_node_layers = total_num_azimuthal_intervals * order;
   unsigned int new_unique_ids = orig_unique_ids + (total_new_node_layers - 1) * orig_elem * 2 +
                                 total_new_node_layers * orig_nodes;
   mesh->set_next_unique_id(new_unique_ids);
 #endif
 
   // Copy all the subdomain/sideset/nodeset name maps to the revolved mesh
   if (!input_subdomain_map.empty())
     mesh->set_subdomain_name_map().insert(input_subdomain_map.begin(), input_subdomain_map.end());
   if (!input_sideset_map.empty())
     mesh->get_boundary_info().set_sideset_name_map().insert(input_sideset_map.begin(),
                                                             input_sideset_map.end());
   if (!input_nodeset_map.empty())
     mesh->get_boundary_info().set_nodeset_name_map().insert(input_nodeset_map.begin(),
                                                             input_nodeset_map.end());
 
   mesh->remove_orphaned_nodes();
   mesh->renumber_nodes_and_elements();
   mesh->set_isnt_prepared();
 
   return mesh;
 }

◆ getInterfaceBoundaryIDs()

std::set< boundary_id_type > PolygonMeshGeneratorBase::getInterfaceBoundaryIDs	(	const std::vector< std::vector< unsigned int >> &	pattern,
		const std::vector< std::vector< boundary_id_type >> &	interface_boundary_id_shift_pattern,
		const std::set< boundary_id_type > &	boundary_ids,
		const std::vector< std::set< boundary_id_type >> &	input_interface_boundary_ids,
		const bool	use_interface_boundary_id_shift,
		const bool	create_interface_boundary_id,
		const unsigned int	num_extra_layers
	)		const

protectedinherited

returns a list of interface boundary IDs on the mesh generated by this mesh generator

Parameters

pattern	pattern of cells used in this mesh generator
interface_boundary_id_shift_pattern	2D pattern of shift values applied to the boundary IDs inside each pattern cells
boundary_ids	list of boundary IDs on the mesh generated by this mesh generator
input_interface_boundary_ids	list of interface boundary IDs of the pattern cells
use_interface_boundary_id_shift	whether ID shifts are applied to interface boundary IDs of the pattern cells
create_interface_boundary_id	whether interface boundary IDs are generated by this mesh generator
num_extra_layers	number of extra layers to define background and duct regions on the patterned mesh generated by this mesh generator

Definition at line 1722 of file PolygonMeshGeneratorBase.C.

Referenced by PatternedHexMeshGenerator::generate(), and PatternedCartesianMeshGenerator::generate().

 {
   std::set<boundary_id_type> interface_boundary_ids;
   // add existing interface boundary ids from input meshes
   if (use_interface_boundary_id_shift)
   {
     for (const auto i : make_range(pattern.size()))
       for (const auto j : make_range(pattern[i].size()))
       {
         const auto & ids = input_interface_boundary_ids[pattern[i][j]];
         for (const auto & id : ids)
         {
           const boundary_id_type new_id = id + interface_boundary_id_shift_pattern[i][j];
           auto it = boundary_ids.find(new_id);
           if (it != boundary_ids.end())
             interface_boundary_ids.insert(new_id);
         }
       }
   }
   else
   {
     for (const auto & ids : input_interface_boundary_ids)
       for (const auto & id : ids)
       {
         auto it = boundary_ids.find(id);
         if (it != boundary_ids.end())
           interface_boundary_ids.insert(id);
       }
   }
   // add unshifted interface boundary ids for the duct & background regions
   if (create_interface_boundary_id)
     for (const auto i : make_range(num_extra_layers))
     {
       boundary_id_type id = SLICE_ALT + i * 2 + 1;
       auto it = boundary_ids.find(id);
       if (it != boundary_ids.end())
         interface_boundary_ids.insert(id);
       id = SLICE_ALT + i * 2;
       it = boundary_ids.find(id);
       if (it != boundary_ids.end())
         interface_boundary_ids.insert(id);
     }
   return interface_boundary_ids;
 }

◆ getRotationCenterAndRadius()

std::pair< Real, Point > RevolveGenerator::getRotationCenterAndRadius	(	const Point &	p_ext,
		const Point &	p_axis,
		const Point &	dir_axis
	)		const

protected

Get the rotation center and radius of the circular rotation based on the rotation axis and the external point.

Parameters

p_ext	external point that needs to be rotated
p_axis	a point on the rotation axis
dir_axis	direction vector of the rotation axis

Returns: a pair of the rotation center and the radius of the circular rotation

Definition at line 1502 of file RevolveGenerator.C.

Referenced by generate().

 {
   // First use point product to get the distance between the axis point and the projection of the
   // external point on the axis
   const Real dist = (p_ext - p_axis) * dir_axis.unit();
   const Point center_pt = p_axis + dist * dir_axis.unit();
   // Then get the radius
   const Real radius = (p_ext - center_pt).norm();
   return std::make_pair(radius, center_pt);
 }

◆ modifiedMultiBdryLayerParamsCreator()

PolygonMeshGeneratorBase::multiBdryLayerParams PolygonMeshGeneratorBase::modifiedMultiBdryLayerParamsCreator	(	const multiBdryLayerParams &	original_multi_bdry_layer_params,
		const unsigned int	order
	)		const

protectedinherited

Modifies the input multi boundary layer parameters for node generation, especially for the quadratic elements.

Parameters

original_multi_bdry_layer_params	original multi boundary layer parameters
order	order of the elements

Returns: modified multi boundary layer parameters

Definition at line 1775 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice().

 {
   multiBdryLayerParams mod_multi_bdry_layer_params(original_multi_bdry_layer_params);
   std::for_each(mod_multi_bdry_layer_params.intervals.begin(),
                 mod_multi_bdry_layer_params.intervals.end(),
                 [&order](unsigned int & n) { n *= order; });
   std::for_each(mod_multi_bdry_layer_params.biases.begin(),
                 mod_multi_bdry_layer_params.biases.end(),
                 [&order](Real & n) { n = std::pow(n, 1.0 / order); });
   return mod_multi_bdry_layer_params;
 }

◆ modifiedSingleBdryLayerParamsCreator()

PolygonMeshGeneratorBase::singleBdryLayerParams PolygonMeshGeneratorBase::modifiedSingleBdryLayerParamsCreator	(	const singleBdryLayerParams &	original_single_bdry_layer_params,
		const unsigned int	order
	)		const

protectedinherited

Modifies the input single boundary layer parameters for node generation, especially for the quadratic elements.

Parameters

original_single_bdry_layer_params	original single boundary layer parameters
order	order of the elements

Returns: modified single boundary layer parameters

Definition at line 1789 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice().

 {
   singleBdryLayerParams mod_single_bdry_layer_params(original_single_bdry_layer_params);
   mod_single_bdry_layer_params.intervals *= order;
   mod_single_bdry_layer_params.bias = std::pow(mod_single_bdry_layer_params.bias, 1.0 / order);
   return mod_single_bdry_layer_params;
 }

◆ nodeCoordRotate()

void PolygonMeshGeneratorBase::nodeCoordRotate	(	Real &	x,
		Real &	y,
		const Real	theta
	)		const

protectedinherited

Calculates x and y coordinates after rotating by theta angle.

Parameters

x	x coordinate of the node to be rotated
y	y coordinate of the node to be rotated
theta	rotation angle

Returns: n/a

Definition at line 1320 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::cutOffPolyDeform(), FlexiblePatternGenerator::FlexiblePatternGenerator(), PolygonConcentricCircleMeshGeneratorBase::generate(), PatternedHexMeshGenerator::generate(), and PatternedCartesianMeshGenerator::generate().

 {
   const Real x_tmp = x;
   const Real y_tmp = y;
   x = x_tmp * std::cos(theta * M_PI / 180.0) - y_tmp * std::sin(theta * M_PI / 180.0);
   y = x_tmp * std::sin(theta * M_PI / 180.0) + y_tmp * std::cos(theta * M_PI / 180.0);
 }

◆ nodeModification()

void RevolveGenerator::nodeModification ( Node & node )

protected

Modify the position of a node to account for radius correction.

Parameters

node	the node to be modified

Definition at line 1556 of file RevolveGenerator.C.

Referenced by generate().

 {
   const Point axis_component =
       ((node - _axis_point) * _axis_direction.unit()) * _axis_direction.unit();
   const Point rad_component = ((node - _axis_point) - axis_component) * _radius_correction_factor;
   node = _axis_point + axis_component + rad_component;
 }

◆ onAxisNodesIdentifier()

std::pair< std::vector< dof_id_type >, std::vector< dof_id_type > > RevolveGenerator::onAxisNodesIdentifier	(	const Elem &	elem,
		const std::vector< dof_id_type > &	nodes_on_axis
	)		const

protected

Categorize the nodes of an element into two groups: nodes on the axis and nodes off the axis.

Parameters

elem	the element whose nodes are to be categorized
nodes_on_axis	a list of node IDs on the axis

Returns: a pair of lists of node IDs: the first list is for nodes on the axis, and the second list is for nodes off the axis

Definition at line 1535 of file RevolveGenerator.C.

Referenced by generate().

 {
   std::vector<dof_id_type> nodes_on_axis_in_elem;
   std::vector<dof_id_type> nodes_not_on_axis_in_elem;
   for (unsigned int i = 0; i < elem.n_nodes(); i++)
   {
     const auto node_id = elem.node_id(i);
     if (std::find(nodes_on_axis.begin(), nodes_on_axis.end(), node_id) != nodes_on_axis.end())
     {
       nodes_on_axis_in_elem.push_back(i);
     }
     else
     {
       nodes_not_on_axis_in_elem.push_back(i);
     }
   }
   return std::make_pair(nodes_on_axis_in_elem, nodes_not_on_axis_in_elem);
 }

◆ pitchMetaDataErrorGenerator()

std::string PolygonMeshGeneratorBase::pitchMetaDataErrorGenerator	(	const std::vector< MeshGeneratorName > &	input_names,
		const std::vector< Real > &	metadata_vals,
		const std::string &	metadata_name
	)		const

protectedinherited

Generate a string that contains the detailed metadata information for inconsistent input mesh metadata error messages.

Parameters

input_names	list of input mesh generator names
metadata_vals	list of input mesh metadata values
metadata_name	name of the input mesh metadata

Returns: a string that contains the detailed metadata information

Definition at line 1799 of file PolygonMeshGeneratorBase.C.

Referenced by PatternedHexMeshGenerator::generate(), and PatternedCartesianMeshGenerator::generate().

 {
   FormattedTable table;
   for (unsigned int i = 0; i < input_names.size(); i++)
   {
     table.addRow(i);
     table.addData<std::string>("input name", (std::string)input_names[i]);
     table.addData<Real>(metadata_name, metadata_vals[i]);
   }
   table.outputTimeColumn(false);
   std::stringstream detailed_error;
   table.printTable(detailed_error);
   return "\n" + detailed_error.str();
 }

◆ pointInterpolate()

std::pair< Real, Real > PolygonMeshGeneratorBase::pointInterpolate	(	const Real	pi_1_x,
		const Real	pi_1_y,
		const Real	po_1_x,
		const Real	po_1_y,
		const Real	pi_2_x,
		const Real	pi_2_y,
		const Real	po_2_x,
		const Real	po_2_y,
		const unsigned int	i,
		const unsigned int	j,
		const unsigned int	num_sectors_per_side,
		const unsigned int	peripheral_intervals
	)		const

protectedinherited

Calculates the point coordinates of within a parallelogram region using linear interpolation.

Parameters

pi_1_x	x coordinate of the first inner side point (parallelogram vertex)
pi_1_y	y coordinate of the first inner side point (parallelogram vertex)
po_1_x	x coordinate of the first outer side point (parallelogram vertex)
po_1_y	y coordinate of the first outer side point (parallelogram vertex)
pi_2_x	x coordinate of the second inner side point (parallelogram vertex)
pi_2_y	y coordinate of the second inner side point (parallelogram vertex)
po_2_x	x coordinate of the second outer side point (parallelogram vertex)
po_2_y	y coordinate of the second outer side point (parallelogram vertex)
i	passed loop index 1
j	passed loop index 2
num_sectors_per_side	number of azimuthal intervals
peripheral_invervals	number of radial intervals of the peripheral region

Returns: an interpolated position within a parallelogram

Definition at line 1293 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSimplePeripheral().

 {
   auto position_px_inner =
       (pi_1_x * (num_sectors_per_side / 2.0 - j) + pi_2_x * j) / (num_sectors_per_side / 2.0);
   auto position_py_inner =
       (pi_1_y * (num_sectors_per_side / 2.0 - j) + pi_2_y * j) / (num_sectors_per_side / 2.0);
   auto position_px_outer =
       (d_po_1_x * (num_sectors_per_side / 2.0 - j) + d_po_2_x * j) / (num_sectors_per_side / 2.0);
   auto position_py_outer =
       (d_po_1_y * (num_sectors_per_side / 2.0 - j) + d_po_2_y * j) / (num_sectors_per_side / 2.0);
   auto position_px = position_px_inner + position_px_outer * i / peripheral_intervals;
   auto position_py = position_py_inner + position_py_outer * i / peripheral_intervals;
   return std::make_pair(position_px, position_py);
 }

◆ quadElemDef()

void PolygonMeshGeneratorBase::quadElemDef	(	ReplicatedMesh &	mesh,
		const unsigned int	num_sectors_per_side,
		const std::vector< unsigned int >	subdomain_rings,
		const unsigned int	side_index,
		const std::vector< Real >	azimuthal_tangent = `std::vector<Real>()`,
		const subdomain_id_type	block_id_shift = `0`,
		const dof_id_type	nodeid_shift = `0`,
		const bool	create_inward_interface_boundaries = `false`,
		const bool	create_outward_interface_boundaries = `true`,
		const boundary_id_type	boundary_id_shift = `0`,
		const bool	generate_side_specific_boundaries = `true`,
		const QUAD_ELEM_TYPE	quad_elem_type = `QUAD_ELEM_TYPE::QUAD4`
	)		const

protectedinherited

Defines general quad elements for the polygon.

Parameters

mesh	input mesh to create the elements onto
num_sectors_per_side	number of azimuthal intervals
subdomain_rings	numbers of radial intervals of all involved subdomain layers
side_index	index of the polygon side
azimuthal_tangent	vector of tangent values of the azimuthal angles as reference for adaptive boundary matching
block_id_shift	shift of the subdomain ids generated by this function
nodeid_shift	shift of the node_ids of these elements
create_inward_interface_boundaries	whether inward interface boundary sidesets are created
create_outward_interface_boundaries	whether outward interface boundary sidesets are created
boundary_id_shift	shift of the interface boundary ids
generate_side_specific_boundaries	whether the side-specific external boundaries are generated or not
quad_elem_type	type of the quadrilateral elements to be generated

Definition at line 1053 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice().

 {
   const unsigned short order = quad_elem_type == QUAD_ELEM_TYPE::QUAD4 ? 1 : 2;
   unsigned int angle_number = azimuthal_tangent.size() == 0
                                   ? num_sectors_per_side
                                   : ((azimuthal_tangent.size() - 1) / order);
 
   BoundaryInfo & boundary_info = mesh.get_boundary_info();
   unsigned int j = 0;
   for (unsigned int k = 0; k < (subdomain_rings.size()); k++)
   {
     for (unsigned int m = 0; m < subdomain_rings[k]; m++)
     {
       for (unsigned int i = 1; i <= angle_number; i++)
       {
         std::unique_ptr<Elem> new_elem;
         if (quad_elem_type == QUAD_ELEM_TYPE::QUAD4)
         {
           new_elem = std::make_unique<Quad4>();
           new_elem->set_node(0, mesh.node_ptr(nodeid_shift + i + (angle_number + 1) * j));
           new_elem->set_node(1, mesh.node_ptr(nodeid_shift + i + 1 + (angle_number + 1) * j));
           new_elem->set_node(2, mesh.node_ptr(nodeid_shift + i + (angle_number + 1) * (j + 1) + 1));
           new_elem->set_node(3, mesh.node_ptr(nodeid_shift + i + (angle_number + 1) * (j + 1)));
         }
         else // QUAD8/QUAD9
         {
           new_elem = std::make_unique<Quad8>();
           if (quad_elem_type == QUAD_ELEM_TYPE::QUAD9)
           {
             new_elem = std::make_unique<Quad9>();
             new_elem->set_node(
                 8, mesh.node_ptr(nodeid_shift + i * 2 + (angle_number * 2 + 1) * (j * 2 + 2)));
           }
           new_elem->set_node(
               0,
               mesh.node_ptr(nodeid_shift + (i - 1) * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 1)));
           new_elem->set_node(
               1, mesh.node_ptr(nodeid_shift + i * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 1)));
           new_elem->set_node(
               2, mesh.node_ptr(nodeid_shift + i * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 3)));
           new_elem->set_node(
               3,
               mesh.node_ptr(nodeid_shift + (i - 1) * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 3)));
           new_elem->set_node(
               4, mesh.node_ptr(nodeid_shift + i * 2 + (angle_number * 2 + 1) * (j * 2 + 1)));
           new_elem->set_node(
               5, mesh.node_ptr(nodeid_shift + i * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 2)));
           new_elem->set_node(
               6, mesh.node_ptr(nodeid_shift + i * 2 + (angle_number * 2 + 1) * (j * 2 + 3)));
           new_elem->set_node(
               7,
               mesh.node_ptr(nodeid_shift + (i - 1) * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 2)));
         }
         Elem * elem = mesh.add_elem(std::move(new_elem));
         if (i == 1)
           boundary_info.add_side(elem, 3, SLICE_BEGIN);
         if (i == angle_number)
           boundary_info.add_side(elem, 1, SLICE_END);
 
         if (subdomain_rings[0] == 0)
           elem->subdomain_id() = k + 1 + block_id_shift;
         else
           elem->subdomain_id() = k + 2 + block_id_shift;
 
         if (m == 0 && create_inward_interface_boundaries && k > 0)
           boundary_info.add_side(elem, 0, k * 2 + boundary_id_shift);
         if (m == (subdomain_rings[k] - 1))
         {
           if (k == (subdomain_rings.size() - 1))
           {
             boundary_info.add_side(elem, 2, OUTER_SIDESET_ID);
             if (generate_side_specific_boundaries)
             {
               if (i <= angle_number / 2)
                 boundary_info.add_side(elem, 2, OUTER_SIDESET_ID + side_index);
               else
                 boundary_info.add_side(elem, 2, OUTER_SIDESET_ID_ALT + side_index);
             }
           }
           else if (create_outward_interface_boundaries)
             boundary_info.add_side(elem, 2, k * 2 + 1 + boundary_id_shift);
         }
       }
       j++;
     }
   }
 }

◆ reassignBoundaryIDs()

void PolygonMeshGeneratorBase::reassignBoundaryIDs	(	MeshBase &	mesh,
		const boundary_id_type	id_shift,
		const std::set< boundary_id_type > &	boundary_ids,
		const bool	reverse = `false`
	)

protectedinherited

reassign interface boundary IDs on the input mesh by applying the boundary ID shift

Parameters

mesh	input mesh
id_shift	ID shift value to be applied
boundary_ids	list of boundary IDs to be reassigned
reverse	remove boundary ID shift

Definition at line 1703 of file PolygonMeshGeneratorBase.C.

Referenced by PatternedHexMeshGenerator::generate(), and PatternedCartesianMeshGenerator::generate().

 {
   const std::set<boundary_id_type> existing_boundary_ids =
       mesh.get_boundary_info().get_boundary_ids();
   for (const auto id : boundary_ids)
   {
 
     const boundary_id_type old_id = (!reverse) ? id : id + id_shift;
     const boundary_id_type new_id = (!reverse) ? id + id_shift : id;
     auto it = existing_boundary_ids.find(old_id);
     if (it != existing_boundary_ids.end())
       MooseMesh::changeBoundaryId(mesh, old_id, new_id, true);
   }
 }

◆ ringNodes()

void PolygonMeshGeneratorBase::ringNodes	(	ReplicatedMesh &	mesh,
		const std::vector< Real >	ring_radii,
		const std::vector< unsigned int >	ring_layers,
		const std::vector< std::vector< Real >>	biased_terms,
		const unsigned int	num_sectors_per_side,
		const Real	corner_p[2][2],
		const Real	corner_to_corner,
		const std::vector< Real >	azimuthal_tangent = `std::vector<Real>()`
	)		const

protectedinherited

Creates nodes for the ring-geometry region of a single slice.

Parameters

mesh	input mesh to add the nodes onto
ring_radii	radii of the ring regions
ring_layers	numbers of radial intervals of the ring regions
biased_terms	normalized spacing values used for radial meshing biasing in ring regions
num_sectors_per_side	number of azimuthal intervals
corner_p[2][2]	array contains the coordinates of the corner positions
corner_to_corner	diameter of the circumscribed circle of the polygon
azimuthal_tangent	vector of tangent values of the azimuthal angles as reference for adaptive boundary matching

Definition at line 656 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonMeshGeneratorBase::buildSlice().

 {
   const unsigned int angle_number =
       azimuthal_tangent.size() == 0 ? num_sectors_per_side : (azimuthal_tangent.size() - 1);
 
   // Add nodes in pins regions
   for (unsigned int l = 0; l < ring_layers.size(); l++)
   {
     // the pin radius interval for each ring_radii/subdomain
     const Real pin_radius_interval_length =
         l == 0 ? ring_radii[l] / ring_layers[l]
                : (ring_radii[l] - ring_radii[l - 1]) / ring_layers[l];
 
     // add rings in each pin subdomain
     for (unsigned int k = 0; k < ring_layers[l]; k++)
     {
       const Real bin_radial_distance =
           l == 0 ? (biased_terms[l][k] * ring_layers[l] *
                     pin_radius_interval_length) // this is from the cell/pin center to
                                                 // the first circle
                  : (ring_radii[l - 1] +
                     biased_terms[l][k] * ring_layers[l] * pin_radius_interval_length);
       const Real pin_corner_p_x = corner_p[0][0] * bin_radial_distance / (0.5 * corner_to_corner);
       const Real pin_corner_p_y = corner_p[0][1] * bin_radial_distance / (0.5 * corner_to_corner);
 
       // pin_corner_p(s) are the points in the pin region, on the bins towards the six corners,
       // at different intervals
       mesh.add_point(Point(pin_corner_p_x, pin_corner_p_y, 0.0));
 
       for (unsigned int j = 1; j <= angle_number; j++)
       {
         const Real cell_boundary_p_x =
             corner_p[0][0] + (corner_p[1][0] - corner_p[0][0]) *
                                  (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
                                                                 : (azimuthal_tangent[j] / 2.0));
         const Real cell_boundary_p_y =
             corner_p[0][1] + (corner_p[1][1] - corner_p[0][1]) *
                                  (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
                                                                 : (azimuthal_tangent[j] / 2.0));
         // cell_boundary_p(s) are the points on the cell's six boundaries (flat sides) at
         // different azimuthal angles
         const Real pin_azimuthal_p_x =
             cell_boundary_p_x * bin_radial_distance /
             std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
         const Real pin_azimuthal_p_y =
             cell_boundary_p_y * bin_radial_distance /
             std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
 
         // pin_azimuthal_p are the points on the bins towards different azimuthal angles, at
         // different intervals; excluding the ones produced by pin_corner_p
         mesh.add_point(Point(pin_azimuthal_p_x, pin_azimuthal_p_y, 0.0));
       }
     }
   }
 }

◆ rotationVectors()

std::vector< Point > RevolveGenerator::rotationVectors	(	const Point &	p_axis,
		const Point &	dir_axis,
		const Point &	p_input
	)		const

protected

Calculate the transform matrix between the rotation coordinate system and the original coordinate system.

Parameters

p_axis	a point on the rotation axis
dir_axis	direction vector of the rotation axis
p_input	a point in the input mesh

Returns: a transform matrix, stored as 3 points in a vector (each point represents a row of the matrix)

Definition at line 1516 of file RevolveGenerator.C.

Referenced by generate().

 {
   // To make the rotation mathematically simple, we perform rotation in a coordination system
   // (x',y',z') defined by rotation axis and the mesh to be rotated.
   // z' is the rotation axis, which is trivial dir_axis.unit()
   const Point z_prime = dir_axis.unit();
   // the x' and z' should form the plane that accommodates input mesh
   const Point x_prime = ((p_input - p_axis) - ((p_input - p_axis) * z_prime) * z_prime).unit();
   const Point y_prime = z_prime.cross(x_prime);
   // Then we transform things back to the original coordination system (x,y,z), which is trivial
   // (1,0,0), (0,1,0), (0,0,1)
   return {{x_prime(0), y_prime(0), z_prime(0)},
           {x_prime(1), y_prime(1), z_prime(1)},
           {x_prime(2), y_prime(2), z_prime(2)}};
 }

◆ setRingExtraIDs()

void PolygonMeshGeneratorBase::setRingExtraIDs	(	MeshBase &	mesh,
		const std::string	id_name,
		const unsigned int	num_sides,
		const std::vector< unsigned int >	num_sectors_per_side,
		const std::vector< unsigned int >	ring_intervals,
		const bool	ring_wise_id,
		const bool	quad_center_elements
	)

protectedinherited

assign ring extra ids to polygon mesh

Parameters

mesh	input mesh where ring extra ids are assigned
id_name	ring extra id name
num_sides	number of polygon sides
num_sectors_per_side	number of sectors of each side of the polygon
ring_intervals	number of rings in each circle
ring_wise_id	whether ring ids are assigned to each ring or to each block
quad_center_elements	whether center elements are quad or triangular

Definition at line 1638 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate(), and TriPinHexAssemblyGenerator::generate().

 {
   // this function assumes that elements are ordered by rings (inner) then by sectors (outer
   // ordering)
   const auto extra_id_index = mesh.add_elem_integer(id_name);
   auto elem_it = mesh.elements_begin();
   for (unsigned int is = 0; is < num_sides; ++is)
   {
     // number of elements in the current sector
     unsigned int nelem = mesh.n_elem() * num_sectors_per_side[is] /
                          (accumulate(num_sectors_per_side.begin(), num_sectors_per_side.end(), 0));
     if (!ring_wise_id)
     {
       for (unsigned int ir : index_range(ring_intervals))
       {
         // number of elements in the current ring and sector
         unsigned int nelem_annular_ring = num_sectors_per_side[is] * ring_intervals[ir];
         // if _quad_center_elements is true, the number of elements in center ring are
         // _num_sectors_per_side[is] * _num_sectors_per_side[is] / 4
         if (quad_center_elements && ir == 0)
           nelem_annular_ring = num_sectors_per_side[is] * (ring_intervals[ir] - 1) +
                                num_sectors_per_side[is] * num_sectors_per_side[is] / 4;
         // assign ring id
         for (unsigned i = 0; i < nelem_annular_ring; ++i, ++elem_it)
           (*elem_it)->set_extra_integer(extra_id_index, ir + 1);
         // update number of elements in background region of current side.
         nelem -= nelem_annular_ring;
       }
     }
     else
     {
       unsigned int ir = 0;
       for (unsigned int ir0 : index_range(ring_intervals))
       {
         for (unsigned int ir1 = 0; ir1 < ring_intervals[ir0]; ++ir1)
         {
           // number of elements in the current ring and sector
           unsigned int nelem_annular_ring = num_sectors_per_side[is];
           // if _quad_center_elements is true, the number of elements in center ring are
           // _num_sectors_per_side[is] * _num_sectors_per_side[is] / 4
           if (quad_center_elements && ir == 0)
             nelem_annular_ring = num_sectors_per_side[is] * num_sectors_per_side[is] / 4;
           // assign ring id
           for (unsigned i = 0; i < nelem_annular_ring; ++i, ++elem_it)
             (*elem_it)->set_extra_integer(extra_id_index, ir + 1);
           // update ring id
           ++ir;
           // update number of elements in background region of current side.
           nelem -= nelem_annular_ring;
         }
       }
     }
     // assign ring id of 0 to the background region
     for (unsigned i = 0; i < nelem; ++i, ++elem_it)
       (*elem_it)->set_extra_integer(extra_id_index, 0);
   }
 }

◆ setSectorExtraIDs()

void PolygonMeshGeneratorBase::setSectorExtraIDs	(	MeshBase &	mesh,
		const std::string	id_name,
		const unsigned int	num_sides,
		const std::vector< unsigned int >	num_sectors_per_side
	)

protectedinherited

assign sector extra ids to polygon mesh

Parameters

mesh	input mesh where sector extra ids are assigned
id_name	sector extra ID name
num_side	number of polygon sides
num_sectors_per_side	number of sections of each side of the polygon

Definition at line 1613 of file PolygonMeshGeneratorBase.C.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate(), and TriPinHexAssemblyGenerator::generate().

 {
   const auto extra_id_index = mesh.add_elem_integer(id_name);
   // vector to store sector ids for each element
   auto elem_it = mesh.elements_begin();
   unsigned int id = 1;
   // starting element id of the current sector
   for (unsigned int is = 0; is < num_sides; ++is)
   {
     // number of elements in the current sector
     unsigned int nelem_sector =
         mesh.n_elem() * num_sectors_per_side[is] /
         (accumulate(num_sectors_per_side.begin(), num_sectors_per_side.end(), 0));
     // assign sector ids to mesh
     for (unsigned i = 0; i < nelem_sector; ++i, ++elem_it)
       (*elem_it)->set_extra_integer(extra_id_index, id);
     // update sector id
     ++id;
   }
 }

◆ validParams()

InputParameters RevolveGenerator::validParams ( )

static

Definition at line 42 of file RevolveGenerator.C.

 {
   InputParameters params = PolygonMeshGeneratorBase::validParams();
   params.addClassDescription("This RevolveGenerator object is designed to revolve a 1D mesh into "
                              "2D, or a 2D mesh into 3D based on an axis.");
 
   params.addRequiredParam<MeshGeneratorName>("input", "The mesh to revolve");
 
   params.addRequiredParam<Point>("axis_point", "A point on the axis of revolution");
 
   params.addRequiredParam<Point>("axis_direction", "The direction of the axis of revolution");
 
   params.addRangeCheckedParam<std::vector<Real>>(
       "revolving_angles",
       "revolving_angles<=360.0 & revolving_angles>0.0",
       "The angles delineating each azimuthal section of revolution around the axis in degrees");
 
   params.addParam<std::vector<std::vector<subdomain_id_type>>>(
       "subdomain_swaps",
       {},
       "For each row, every two entries are interpreted as a pair of "
       "'from' and 'to' to remap the subdomains for that azimuthal section");
 
   params.addParam<std::vector<std::vector<boundary_id_type>>>(
       "boundary_swaps",
       {},
       "For each row, every two entries are interpreted as a pair of "
       "'from' and 'to' to remap the boundaries for that elevation");
 
   params.addParam<std::vector<std::string>>(
       "elem_integer_names_to_swap",
       {},
       "Array of element extra integer names that need to be swapped during revolving.");
 
   params.addParam<std::vector<std::vector<std::vector<dof_id_type>>>>(
       "elem_integers_swaps",
       {},
       "For each row, every two entries are interpreted as a pair of 'from' and 'to' to remap the "
       "element extra integer for that elevation. If multiple element extra integers need to be "
       "swapped, the enties are stacked based on the order provided in "
       "'elem_integer_names_to_swap' to form the third dimension.");
 
   params.addParam<boundary_id_type>(
       "start_boundary",
       "The boundary ID to set on the starting boundary for a partial revolution.");
 
   params.addParam<boundary_id_type>(
       "end_boundary", "The boundary ID to set on the ending boundary for partial revolving.");
 
   params.addParam<bool>(
       "clockwise", true, "Revolve clockwise around the axis or not (i.e., counterclockwise)");
 
   params.addRequiredParam<std::vector<unsigned int>>(
       "nums_azimuthal_intervals",
       "List of the numbers of azimuthal interval discretization for each azimuthal section");
 
   params.addParam<bool>("preserve_volumes",
                         false,
                         "Whether the volume of the revolved mesh is preserving the circular area "
                         "by modifying (expanding) the radius to account for polygonization.");
 
   params.addParamNamesToGroup("start_boundary end_boundary", "Boundary Assignment");
   params.addParamNamesToGroup(
       "subdomain_swaps boundary_swaps elem_integer_names_to_swap elem_integers_swaps", "ID Swap");
 
   return params;
 }

Member Data Documentation

◆ _axis_direction

const Point& RevolveGenerator::_axis_direction

protected

A direction vector of the axis of revolution.

Definition at line 34 of file RevolveGenerator.h.

Referenced by generate(), and nodeModification().

◆ _axis_point

const Point& RevolveGenerator::_axis_point

protected

A point of the axis of revolution.

Definition at line 31 of file RevolveGenerator.h.

Referenced by generate(), and nodeModification().

◆ _boundary_swap_pairs

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

protected

Easier to work with version of _boundary_swaps.

Definition at line 74 of file RevolveGenerator.h.

Referenced by generate(), and RevolveGenerator().

◆ _boundary_swaps

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

protected

Boundaries to swap out for each elevation.

Definition at line 43 of file RevolveGenerator.h.

Referenced by RevolveGenerator().

◆ _clockwise

const bool& RevolveGenerator::_clockwise

protected

Revolving direction.

Definition at line 53 of file RevolveGenerator.h.

Referenced by generate().

◆ _elem_integer_indices_to_swap

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

protected

Definition at line 47 of file RevolveGenerator.h.

Referenced by generate().

◆ _elem_integer_names_to_swap

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

protected

Names and indices of extra element integers to swap.

Definition at line 46 of file RevolveGenerator.h.

Referenced by generate(), and RevolveGenerator().

◆ _elem_integers_swap_pairs

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

protected

Easier to work with version of _elem_integers_swaps.

Definition at line 77 of file RevolveGenerator.h.

Referenced by generate(), and RevolveGenerator().

◆ _elem_integers_swaps

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

protected

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

Definition at line 50 of file RevolveGenerator.h.

Referenced by RevolveGenerator().

◆ _end_boundary

boundary_id_type RevolveGenerator::_end_boundary

protected

Boundary ID of the ending boundary.

Definition at line 86 of file RevolveGenerator.h.

Referenced by generate().

◆ _full_circle_revolving

bool RevolveGenerator::_full_circle_revolving

protected

Whether to revolve for a full circle or not.

Definition at line 80 of file RevolveGenerator.h.

Referenced by createHEXfromQUAD(), createPRISMfromQUAD(), createPRISMfromTRI(), createPYRAMIDfromTRI(), createPYRAMIDPRISMfromQUAD(), createQUADfromEDGE(), createTETfromTRI(), createTRIfromEDGE(), generate(), and RevolveGenerator().

◆ _has_end_boundary

bool RevolveGenerator::_has_end_boundary

protected

Whether an ending boundary is specified.

Definition at line 68 of file RevolveGenerator.h.

Referenced by generate(), and RevolveGenerator().

◆ _has_start_boundary

bool RevolveGenerator::_has_start_boundary

protected

Whether a starting boundary is specified.

Definition at line 62 of file RevolveGenerator.h.

Referenced by generate(), and RevolveGenerator().

◆ _input

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

protected

Lower dimensional mesh from another generator.

Definition at line 28 of file RevolveGenerator.h.

Referenced by generate().

◆ _nums_azimuthal_intervals

const std::vector<unsigned int>& RevolveGenerator::_nums_azimuthal_intervals

protected

Numbers of azimuthal mesh intervals in each azimuthal section.

Definition at line 56 of file RevolveGenerator.h.

Referenced by generate(), and RevolveGenerator().

◆ _preserve_volumes

const bool RevolveGenerator::_preserve_volumes

protected

Volume preserving function is optional.

Definition at line 59 of file RevolveGenerator.h.

Referenced by generate().

◆ _radius_correction_factor

Real RevolveGenerator::_radius_correction_factor

protected

Radius correction factor.

Definition at line 89 of file RevolveGenerator.h.

Referenced by generate(), and nodeModification().

◆ _revolving_angles

const std::vector<Real> RevolveGenerator::_revolving_angles

protected

Angles of revolution delineating each azimuthal section.

Definition at line 37 of file RevolveGenerator.h.

Referenced by generate(), and RevolveGenerator().

◆ _start_boundary

boundary_id_type RevolveGenerator::_start_boundary

protected

Boundary ID of the starting boundary.

Definition at line 65 of file RevolveGenerator.h.

Referenced by generate().

◆ _subdomain_swap_pairs

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

protected

Easier to work with version of _sudomain_swaps.

Definition at line 71 of file RevolveGenerator.h.

Referenced by generate(), and RevolveGenerator().

◆ _subdomain_swaps

const std::vector<std::vector<subdomain_id_type> >& RevolveGenerator::_subdomain_swaps

protected

Subdomains to swap out for each azimuthal section.

Definition at line 40 of file RevolveGenerator.h.

Referenced by RevolveGenerator().

◆ _unit_angles

std::vector<Real> RevolveGenerator::_unit_angles

protected

Unit angles of all azimuthal sections of revolution.

Definition at line 83 of file RevolveGenerator.h.

Referenced by generate().

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

reactor/include/meshgenerators/RevolveGenerator.h
reactor/src/meshgenerators/RevolveGenerator.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ INTRINSIC_NUM_SIDES

◆ INTRINSIC_SIDESET_ID

◆ INTRISIC_SUBDOMAIN_ID

◆ MESH_TYPE

◆ PolygonSizeStyle

◆ QUAD_ELEM_TYPE

◆ RETURN_TYPE

◆ TRI_ELEM_TYPE

Constructor & Destructor Documentation

◆ RevolveGenerator()

Member Function Documentation

◆ addRingAndSectorIDParams()

◆ adjustPeripheralQuadraticElements()

◆ azimuthalAnglesCollector() [1/2]

◆ azimuthalAnglesCollector() [2/2]

◆ backgroundNodes()

◆ biasTermsCalculator() [1/2]

◆ biasTermsCalculator() [2/2]

◆ buildGeneralSlice()

◆ buildSimplePeripheral()

◆ buildSimpleSlice()

◆ buildSlice()

◆ cenQuadElemDef()

◆ centerNodes()

◆ cenTriElemDef()

◆ createHEXfromQUAD()

◆ createPRISMfromQUAD()

◆ createPRISMfromTRI()

◆ createPYRAMIDfromTRI()

◆ createPYRAMIDPRISMfromQUAD()

◆ createQUADfromEDGE()

◆ createTETfromTRI()

◆ createTRIfromEDGE()

◆ cutOffPolyDeform()

◆ ductNodes()

◆ fourPointIntercept()

◆ generate()

◆ getInterfaceBoundaryIDs()

◆ getRotationCenterAndRadius()

◆ modifiedMultiBdryLayerParamsCreator()

◆ modifiedSingleBdryLayerParamsCreator()

◆ nodeCoordRotate()

◆ nodeModification()

◆ onAxisNodesIdentifier()

◆ pitchMetaDataErrorGenerator()

◆ pointInterpolate()

◆ quadElemDef()

◆ reassignBoundaryIDs()

◆ ringNodes()

◆ rotationVectors()

◆ setRingExtraIDs()

◆ setSectorExtraIDs()

◆ validParams()

Member Data Documentation

◆ _axis_direction

◆ _axis_point

◆ _boundary_swap_pairs

◆ _boundary_swaps

◆ _clockwise

◆ _elem_integer_indices_to_swap

◆ _elem_integer_names_to_swap

◆ _elem_integers_swap_pairs

◆ _elem_integers_swaps

◆ _end_boundary

◆ _full_circle_revolving

◆ _has_end_boundary

◆ _has_start_boundary

◆ _input

◆ _nums_azimuthal_intervals

◆ _preserve_volumes