PatternedHexMeshGenerator Class Reference

This PatternedHexMeshGenerator source code assembles hexagonal meshes into a hexagonal grid and optionally forces the outer boundary to be hexagonal and/or adds a duct. More...

#include <PatternedHexMeshGenerator.h>

Inheritance diagram for PatternedHexMeshGenerator:

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
	PatternedHexMeshGenerator (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
void	addPeripheralMesh (ReplicatedMesh &mesh, const unsigned int pattern, const Real pitch, const std::vector< Real > &extra_dist, const std::vector< unsigned int > &num_sectors_per_side_array, const std::vector< unsigned int > &peripheral_duct_intervals, const Real rotation_angle, const unsigned int mesh_type)
	Adds background and duct region mesh to stitched hexagon meshes. More...
void	positionSetup (std::vector< std::pair< Real, Real >> &positions_inner, std::vector< std::pair< Real, Real >> &d_positions_outer, const Real extra_dist_in, const Real extra_dist_out, const Real pitch, const unsigned int radial_index) const
	Computes the inner and outer node positions of the peripheral region for a single layer. More...
void	addReportingIDs (MeshBase &mesh, const std::vector< std::unique_ptr< ReplicatedMesh >> &from_meshes) const
	Adds the reporting IDs onto the input mesh. 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
const std::vector< std::unique_ptr< MeshBase > * >	_mesh_ptrs
	The input meshes. More...
const std::vector< MeshGeneratorName > &	_input_names
	Names of input meshes. More...
const std::vector< std::vector< unsigned int > > &	_pattern
	2D vector of the hexagonal pattern More...
const MooseEnum	_pattern_boundary
	Type of the external boundary shape. More...
const bool	_generate_core_metadata
	Whether a reactor core mesh with core metadata is generated. More...
const unsigned int	_background_intervals
	Number of radial intervals in the background region. More...
const bool	_has_assembly_duct
	Whether the hexagonal pattern has external duct(s) More...
std::vector< Real >	_duct_sizes
	Size parameter(s) of duct(s) More...
const PolygonSizeStyle	_duct_sizes_style
	Style of the duct size parameter(s) More...
const std::vector< unsigned int >	_duct_intervals
	Number(s) of radial intervals of duct layer(s) More...
const bool	_uniform_mesh_on_sides
	Whether the nodes on the external boundary are uniformly distributed. More...
const bool	_generate_control_drum_positions_file
	Whether a text file containing control drum positions is generated. More...
const bool	_assign_control_drum_id
	Wheter control drum IDs are assigned as an extra element integer. More...
const Real	_rotate_angle
	The mesh rotation angle after mesh generation. More...
const std::vector< subdomain_id_type >	_duct_block_ids
	Subdomain IDs of the duct layers. More...
const std::vector< SubdomainName >	_duct_block_names
	Subdomain Names of the duct layers. More...
const boundary_id_type	_external_boundary_id
	Boundary ID of mesh's external boundary. More...
const BoundaryName	_external_boundary_name
	Boundary name of mesh's external boundary. More...
const bool	_create_inward_interface_boundaries
	Whether inward interface boundaries are created. More...
const bool	_create_outward_interface_boundaries
	Whether outward interface boundaries are created. More...
const PolygonSizeStyle	_hexagon_size_style
	Style of the polygon size parameter. More...
const bool	_deform_non_circular_region
	Whether the non-circular region (outside the rings) can be deformed. More...
Real	_pattern_pitch
	Pitch size of the input assembly mesh. More...
std::vector< subdomain_id_type >	_peripheral_block_ids
	Subdomain IDs of the peripheral regions. More...
std::vector< SubdomainName >	_peripheral_block_names
	Subdomain Names of the peripheral regions. More...
const bool	_use_reporting_id
	Whether reporting ID is added to mesh. More...
std::vector< std::string >	_reporting_id_names
	names of reporting ID More...
std::vector< ReportingIDGeneratorUtils::AssignType >	_assign_types
	reporting ID assignment type More...
const bool	_use_exclude_id
	flag to indicate if exclude_id is defined More...
std::vector< bool >	_exclude_ids
	vector indicating which ids in the pattern to exclude (true at pattern positions to exclude) More...
std::map< std::string, std::vector< std::vector< dof_id_type > > >	_id_patterns
	hold ID patterns for each manual reporting ID. Individual ID pattern contains ID values for each pattern cell. More...
const bool	_use_interface_boundary_id_shift
	whether the interface boundary ids from input meshes are shifted, using a user-defined pattern of values for each pattern cell More...
std::vector< std::vector< boundary_id_type > >	_interface_boundary_id_shift_pattern
	hold user-defined shift values for each pattern cell More...
QUAD_ELEM_TYPE	_boundary_quad_elem_type
	Type of quadrilateral elements to be generated in the periphery region. More...
const bool	_allow_unused_inputs
	Whether to allow additional assembly types to be passed to "inputs" parameter without being used in lattice. 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 PatternedHexMeshGenerator source code assembles hexagonal meshes into a hexagonal grid and optionally forces the outer boundary to be hexagonal and/or adds a duct.

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

PatternedHexMeshGenerator()

PatternedHexMeshGenerator::PatternedHexMeshGenerator

(

const InputParameters &

parameters

)

Definition at line 150 of file PatternedHexMeshGenerator.C.

  : PolygonMeshGeneratorBase(parameters),
    _mesh_ptrs(getMeshes("inputs")),
    _input_names(getParam<std::vector<MeshGeneratorName>>("inputs")),
    _pattern(getParam<std::vector<std::vector<unsigned int>>>("pattern")),
    _pattern_boundary(getParam<MooseEnum>("pattern_boundary")),
    _generate_core_metadata(getParam<bool>("generate_core_metadata")),
    _background_intervals(getParam<unsigned int>("background_intervals")),
    _has_assembly_duct(isParamValid("duct_sizes")),
    _duct_sizes(isParamValid("duct_sizes") ? getParam<std::vector<Real>>("duct_sizes")
                                           : std::vector<Real>()),
    _duct_sizes_style(getParam<MooseEnum>("duct_sizes_style").template getEnum<PolygonSizeStyle>()),
    _duct_intervals(isParamValid("duct_intervals")
                        ? getParam<std::vector<unsigned int>>("duct_intervals")
                        : std::vector<unsigned int>()),
    _uniform_mesh_on_sides(getParam<bool>("uniform_mesh_on_sides")),
    _generate_control_drum_positions_file(getParam<bool>("generate_control_drum_positions_file")),
    _assign_control_drum_id(getParam<bool>("assign_control_drum_id")),
    _rotate_angle(getParam<Real>("rotate_angle")),
    _duct_block_ids(isParamValid("duct_block_ids")
                        ? getParam<std::vector<subdomain_id_type>>("duct_block_ids")
                        : std::vector<subdomain_id_type>()),
    _duct_block_names(getParam<std::vector<SubdomainName>>("duct_block_names")),
    _external_boundary_id(isParamValid("external_boundary_id")
                              ? getParam<boundary_id_type>("external_boundary_id")
                              : 0),
    _external_boundary_name(getParam<BoundaryName>("external_boundary_name")),
    _create_inward_interface_boundaries(getParam<bool>("create_inward_interface_boundaries")),
    _create_outward_interface_boundaries(getParam<bool>("create_outward_interface_boundaries")),
    _hexagon_size_style(
        getParam<MooseEnum>("hexagon_size_style").template getEnum<PolygonSizeStyle>()),
    _deform_non_circular_region(getParam<bool>("deform_non_circular_region")),
    _use_reporting_id(isParamValid("id_name")),
    _use_exclude_id(isParamValid("exclude_id")),
    _use_interface_boundary_id_shift(isParamValid("interface_boundary_id_shift_pattern")),
    _boundary_quad_elem_type(
        getParam<MooseEnum>("boundary_region_element_type").template getEnum<QUAD_ELEM_TYPE>()),
    _allow_unused_inputs(getParam<bool>("allow_unused_inputs"))
{
  declareMeshProperty("pattern_pitch_meta", 0.0);
  declareMeshProperty("input_pitch_meta", 0.0);
  declareMeshProperty<bool>("is_control_drum_meta", false);
  declareMeshProperty<std::vector<Point>>("control_drum_positions", std::vector<Point>());
  declareMeshProperty<std::vector<Real>>("control_drum_angles", std::vector<Real>());
  declareMeshProperty<std::vector<std::vector<Real>>>("control_drums_azimuthal_meta",
                                                      std::vector<std::vector<Real>>());
  declareMeshProperty<std::string>("position_file_name", getParam<std::string>("position_file"));
  declareMeshProperty<bool>("hexagon_peripheral_trimmability", !_generate_core_metadata);
  declareMeshProperty<bool>("hexagon_center_trimmability", true);
  declareMeshProperty<bool>("peripheral_modifier_compatible", _pattern_boundary == "hexagon");

  const unsigned int n_pattern_layers = _pattern.size();
  declareMeshProperty("pattern_size", n_pattern_layers);
  if (n_pattern_layers % 2 == 0)
    paramError(
        "pattern",
        "The length (layer number) of this parameter must be odd to ensure a hexagonal shape.");
  if (n_pattern_layers == 1)
    paramError("pattern", "The length (layer number) of this parameter must be larger than unity.");
  std::vector<unsigned int> pattern_max_array;
  std::vector<unsigned int> pattern_1d;
  for (unsigned int i = 0; i <= n_pattern_layers / 2; i++)
  {
    pattern_max_array.push_back(*std::max_element(_pattern[i].begin(), _pattern[i].end()));
    pattern_max_array.push_back(*std::max_element(_pattern[n_pattern_layers - 1 - i].begin(),
                                                  _pattern[n_pattern_layers - 1 - i].end()));
    pattern_1d.insert(pattern_1d.end(), _pattern[i].begin(), _pattern[i].end());
    pattern_1d.insert(pattern_1d.end(),
                      _pattern[n_pattern_layers - 1 - i].begin(),
                      _pattern[n_pattern_layers - 1 - i].end());
    if (_pattern[i].size() != n_pattern_layers / 2 + i + 1 ||
        _pattern[n_pattern_layers - 1 - i].size() != n_pattern_layers / 2 + i + 1)
      paramError(
          "pattern",
          "The two-dimentional array parameter pattern must have a correct hexagonal shape.");
  }
  if (*std::max_element(pattern_max_array.begin(), pattern_max_array.end()) >= _input_names.size())
    paramError("pattern",
               "Elements of this parameter must be smaller than the length of input_name.");
  if (std::set<unsigned int>(pattern_1d.begin(), pattern_1d.end()).size() < _input_names.size() &&
      !_allow_unused_inputs)
    paramError("pattern",
               "All the meshes provided in inputs must be used in the lattice pattern. To bypass "
               "this requirement, set 'allow_unused_inputs = true'");

  if (isParamValid("background_block_id"))
  {
    _peripheral_block_ids.push_back(getParam<subdomain_id_type>("background_block_id"));
    _peripheral_block_ids.insert(
        _peripheral_block_ids.end(), _duct_block_ids.begin(), _duct_block_ids.end());
  }
  else if (!_duct_block_ids.empty())
    paramError("background_block_id",
               "This parameter and duct_block_ids must be "
               "provided simultaneously.");
  if (isParamValid("background_block_name"))
  {
    _peripheral_block_names.push_back(getParam<SubdomainName>("background_block_name"));
    _peripheral_block_names.insert(
        _peripheral_block_names.end(), _duct_block_names.begin(), _duct_block_names.end());
  }
  else if (!_duct_block_names.empty())
    paramError("background_block_name",
               "This parameter and duct_block_names must be provided simultaneously.");

  if (_pattern_boundary == "hexagon")
  {
    for (unsigned int i = 1; i < _duct_sizes.size(); i++)
      if (_duct_sizes[i] <= _duct_sizes[i - 1])
        paramError("duct_sizes", "This parameter must be strictly ascending.");
    if (!_peripheral_block_ids.empty() && _peripheral_block_ids.size() != _duct_sizes.size() + 1)
      paramError("duct_block_ids",
                 "This parameter, if provided, must have a length equal to length of duct_sizes.");
    if (!_peripheral_block_names.empty() &&
        _peripheral_block_names.size() != _duct_sizes.size() + 1)
      paramError("duct_block_names",
                 "This parameter, if provided, must have a length equal to length of duct_sizes.");
  }
  else
  {
    if (!_peripheral_block_ids.empty() || !_peripheral_block_names.empty())
      paramError("background_block_id",
                 "This parameter and background_block_name must not be set when the "
                 "pattern_boundary is none.");
  }

  if (_use_interface_boundary_id_shift)
  {
    // check "interface_boundary_id_shift_pattern" parameter
    _interface_boundary_id_shift_pattern =
        getParam<std::vector<std::vector<boundary_id_type>>>("interface_boundary_id_shift_pattern");
    if (_interface_boundary_id_shift_pattern.size() != _pattern.size())
      paramError("interface_boundary_id_shift_pattern",
                 "This parameter, if provided, should have the same two-dimensional array shape as "
                 "the 'pattern' parameter. First dimension does not match");
    for (const auto i : make_range(_pattern.size()))
      if (_interface_boundary_id_shift_pattern[i].size() != _pattern[i].size())
        paramError("interface_boundary_id_shift_pattern",
                   "This parameter, if provided, should have the same two-dimensional array shape "
                   "as the 'pattern' parameter.");
  }
  // declare metadata for internal interface boundaries
  declareMeshProperty<bool>("interface_boundaries", false);
  declareMeshProperty<std::set<boundary_id_type>>("interface_boundary_ids", {});

  if (_use_reporting_id)
  {
    // get reporting id name input
    _reporting_id_names = getParam<std::vector<std::string>>("id_name");
    const unsigned int num_reporting_ids = _reporting_id_names.size();
    // get reporting id assign type input
    const auto input_assign_types = getParam<std::vector<MooseEnum>>("assign_type");
    if (input_assign_types.size() != num_reporting_ids)
      paramError("assign_type", "This parameter must have a length equal to length of id_name.");
    // list of reporting id names using manual id patterns;
    std::vector<std::string> manual_ids;
    for (const auto i : make_range(num_reporting_ids))
    {
      _assign_types.push_back(
          input_assign_types[i].getEnum<ReportingIDGeneratorUtils::AssignType>());
      if (_assign_types[i] == ReportingIDGeneratorUtils::AssignType::manual)
        manual_ids.push_back(_reporting_id_names[i]);
    }
    // processing "id_pattern" input parameter
    if (manual_ids.size() > 0 && !isParamValid("id_pattern"))
      paramError("id_pattern", "required when 'manual' is defined in \"assign_type\"");
    if (isParamValid("id_pattern"))
    {
      const auto input_id_patterns =
          getParam<std::vector<std::vector<std::vector<dof_id_type>>>>("id_pattern");
      if (input_id_patterns.size() != manual_ids.size())
        paramError("id_pattern",
                   "The number of patterns must be equal to the number of 'manual' types defined "
                   "in \"assign_type\".");
      for (unsigned int i = 0; i < manual_ids.size(); ++i)
        _id_patterns[manual_ids[i]] = input_id_patterns[i];
    }
    // processing exlude id
    _exclude_ids.resize(_input_names.size());
    if (_use_exclude_id)
    {
      std::vector<MeshGeneratorName> exclude_id_name =
          getParam<std::vector<MeshGeneratorName>>("exclude_id");
      for (unsigned int i = 0; i < _input_names.size(); ++i)
      {
        _exclude_ids[i] = false;
        for (auto input_name : exclude_id_name)
          if (_input_names[i] == input_name)
          {
            _exclude_ids[i] = true;
            break;
          }
      }
    }
    else
      for (unsigned int i = 0; i < _input_names.size(); ++i)
        _exclude_ids[i] = false;
  }
}

Member Function Documentation

addPeripheralMesh()

void PatternedHexMeshGenerator::addPeripheralMesh ( ReplicatedMesh &  mesh, const unsigned int  pattern, const Real  pitch, const std::vector< Real > &  extra_dist, const std::vector< unsigned int > &  num_sectors_per_side_array, const std::vector< unsigned int > &  peripheral_duct_intervals, const Real  rotation_angle, const unsigned int  mesh_type  )

protected

Adds background and duct region mesh to stitched hexagon meshes.

Note that the function works for single unit hexagon mesh (corner or edge) separately before stitching.

Parameters

mesh	input mesh to add the peripheral region onto
pattern	index of the input mesh for patterning
pitch	pitch size of the input mesh
extra_dist	extra distances from inner boundary to define background and ducts layer locations that are needed to create the peripheral region
num_sectors_per_side_array	numbers of azimuthal intervals of all input unit meshes
peripheral_duct_intervals	numbers of radial intervals of the duct regions
rotation_angle	angle that the generated mesh will be rotated by
mesh_type	whether the peripheral region is for a corner or a side hexagon mesh

Returns

a mesh of the hexagon unit mesh with peripheral region added.

Definition at line 1030 of file PatternedHexMeshGenerator.C.

Referenced by generate().

{
  std::vector<std::pair<Real, Real>> positions_inner;
  std::vector<std::pair<Real, Real>> d_positions_outer;

  std::vector<std::vector<unsigned int>> peripheral_point_index;
  std::vector<std::pair<Real, Real>> sub_positions_inner;
  std::vector<std::pair<Real, Real>> sub_d_positions_outer;

  if (mesh_type == CORNER_MESH)
    // corner mesh has three sides that need peripheral meshes.
    // each element has three sub-elements, representing beginning, middle, and ending azimuthal
    // points
    peripheral_point_index = {{0, 1, 2}, {2, 3, 4}, {4, 5, 6}};
  else
    // side mesh has two sides that need peripheral meshes.
    peripheral_point_index = {{0, 1, 2}, {2, 7, 8}};

  // extra_dist includes background and ducts.
  // Loop to calculate the positions of the boundaries.
  for (unsigned int i = 0; i < extra_dist.size(); i++)
  {
    positionSetup(positions_inner,
                  d_positions_outer,
                  i == 0 ? 0.0 : extra_dist[i - 1],
                  extra_dist[i],
                  pitch,
                  i);

    // Loop for all applicable sides that need peripheral mesh (3 for corner and 2 for edge)
    for (unsigned int peripheral_index = 0; peripheral_index < peripheral_point_index.size();
         peripheral_index++)
    {
      // Loop for beginning, middle and ending positions of a side
      for (unsigned int vector_index = 0; vector_index < 3; vector_index++)
      {
        sub_positions_inner.push_back(
            positions_inner[peripheral_point_index[peripheral_index][vector_index]]);
        sub_d_positions_outer.push_back(
            d_positions_outer[peripheral_point_index[peripheral_index][vector_index]]);
      }
      auto meshp0 = buildSimplePeripheral(num_sectors_per_side_array[pattern],
                                          peripheral_duct_intervals[i],
                                          sub_positions_inner,
                                          sub_d_positions_outer,
                                          i,
                                          _boundary_quad_elem_type,
                                          _create_inward_interface_boundaries,
                                          (i != extra_dist.size() - 1) &&
                                              _create_outward_interface_boundaries);

      // The other_mesh must be prepared before stitching
      meshp0->prepare_for_use();

      // rotate the peripheral mesh to the desired side of the hexagon.
      MeshTools::Modification::rotate(*meshp0, rotation_angle, 0, 0);
      mesh.stitch_meshes(*meshp0, OUTER_SIDESET_ID, OUTER_SIDESET_ID, TOLERANCE, true, false);
      sub_positions_inner.resize(0);
      sub_d_positions_outer.resize(0);
    }
  }
}

addReportingIDs()

void PatternedHexMeshGenerator::addReportingIDs ( MeshBase &  mesh, const std::vector< std::unique_ptr< ReplicatedMesh >> &  from_meshes  ) const

protected

Adds the reporting IDs onto the input mesh.

Parameters

mesh	input mesh to add the reporting IDs onto
from_meshes	meshes to take reporting IDs from

Definition at line 1212 of file PatternedHexMeshGenerator.C.

Referenced by generate().

{
  const unsigned int num_reporting_ids = _reporting_id_names.size();
  for (unsigned int i = 0; i < num_reporting_ids; ++i)
  {
    const std::string element_id_name = _reporting_id_names[i];
    unsigned int extra_id_index;
    if (!mesh.has_elem_integer(element_id_name))
      extra_id_index = mesh.add_elem_integer(element_id_name);
    else
    {
      extra_id_index = mesh.get_elem_integer_index(element_id_name);
      paramWarning(
          "id_name", "An element integer with the name '", element_id_name, "' already exists");
    }

    // assign reporting IDs to individual elements
    // NOTE: background block id should be set "PERIPHERAL_ID_SHIFT" because this function is called
    // before assigning the user-defined background block id
    std::set<subdomain_id_type> background_block_ids =
        (isParamValid("background_block_id")) ? std::set<subdomain_id_type>({PERIPHERAL_ID_SHIFT})
                                              : std::set<subdomain_id_type>();

    const bool using_manual_id =
        (_assign_types[i] == ReportingIDGeneratorUtils::AssignType::manual);
    ReportingIDGeneratorUtils::assignReportingIDs(mesh,
                                                  extra_id_index,
                                                  _assign_types[i],
                                                  _use_exclude_id,
                                                  _exclude_ids,
                                                  _pattern_boundary == "hexagon",
                                                  background_block_ids,
                                                  from_meshes,
                                                  _pattern,
                                                  (using_manual_id)
                                                      ? _id_patterns.at(element_id_name)
                                                      : std::vector<std::vector<dof_id_type>>());
  }
}

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

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

overridevirtual

Reimplemented from PolygonMeshGeneratorBase.

Definition at line 351 of file PatternedHexMeshGenerator.C.

Referenced by HexIDPatternedMeshGenerator::generate().

{
  std::vector<std::unique_ptr<ReplicatedMesh>> meshes(_input_names.size());
  for (const auto i : index_range(_input_names))
  {
    meshes[i] = dynamic_pointer_cast<ReplicatedMesh>(std::move(*_mesh_ptrs[i]));
    if (!meshes[i])
      paramError("inputs",
                 "Mesh '",
                 _input_names[i],
                 "' is not a replicated mesh. Only replicated meshes are supported");

    // throw an error message if the input mesh has a flat side up
    if (hasMeshProperty<bool>("flat_side_up", _input_names[i]))
      if (getMeshProperty<bool>("flat_side_up", _input_names[i]))
        paramError("inputs",
                   "Mesh '",
                   _input_names[i],
                   "' has a flat side facing up, which is not supported.");
  }

  std::vector<Real> pitch_array;
  std::vector<unsigned int> num_sectors_per_side_array;
  std::vector<unsigned int> num_sectors_per_side_array_tmp;
  std::vector<std::vector<Real>> control_drum_azimuthal_array;
  std::vector<unsigned int> background_intervals_array;
  std::vector<dof_id_type> node_id_background_array;
  std::vector<Real> max_radius_array;
  std::vector<bool> is_control_drum_array;
  Real max_radius_global(0.0);
  std::vector<Real> pattern_pitch_array;

  if (_pattern_boundary == "none" && _generate_core_metadata)
  {
    for (MooseIndex(_input_names) i = 0; i < _input_names.size(); ++i)
    {
      // throw an error message if the input mesh does not contain the required meta data
      if (!hasMeshProperty<Real>("pattern_pitch_meta", _input_names[i]))
        mooseError(
            "In PatternedHexMeshGenerator ",
            _name,
            ": the unit hexagonal input mesh does not contain appropriate meta data "
            "required for generating a core mesh. Involved input mesh: ",
            _input_names[i],
            "; metadata issue: 'pattern_pitch_meta' is missing. Note that "
            "'generate_core_metadata' is set to true, which"
            "means that the mesh generator is producing a core mesh by stitching the input "
            "assembly meshes together. Therefore,"
            "the input meshes must contain the metadata of assembly meshes, which can "
            "usually be either automatically assigned "
            "by using another PatternedHexMeshGenerator with 'generate_core_metadata' set as "
            "false and 'pattern_boundary' set as hexagon, or manually assigned by "
            "AddMetaDataGenerator.");
      pattern_pitch_array.push_back(getMeshProperty<Real>("pattern_pitch_meta", _input_names[i]));
      // throw an error message if the input mesh contains non-sense meta data
      if (pattern_pitch_array.back() == 0.0)
        mooseError(
            "In PatternedHexMeshGenerator ",
            _name,
            ": the unit hexagonal input mesh does not contain appropriate meta data "
            "required for generating a core mesh. Involved input mesh: ",
            _input_names[i],
            "; metadata issue: 'pattern_pitch_meta' is zero. Note that "
            "'generate_core_metadata' is set to true, which"
            "means that the mesh generator is producing a core mesh by stitching the input "
            "assembly meshes together. Therefore,"
            "the input meshes must contain the metadata of assembly meshes, which can "
            "usually be either automatically assigned "
            "by using another PatternedHexMeshGenerator with 'generate_core_metadata' set as "
            "false and 'pattern_boundary' set as hexagon, or manually assigned by "
            "AddMetaDataGenerator.");
      is_control_drum_array.push_back(
          getMeshProperty<bool>("is_control_drum_meta", _input_names[i]));
      control_drum_azimuthal_array.push_back(
          getMeshProperty<bool>("is_control_drum_meta", _input_names[i])
              ? getMeshProperty<std::vector<Real>>("azimuthal_angle_meta", _input_names[i])
              : std::vector<Real>());
    }
    if (!MooseUtils::absoluteFuzzyEqual(
            *std::max_element(pattern_pitch_array.begin(), pattern_pitch_array.end()),
            *std::min_element(pattern_pitch_array.begin(), pattern_pitch_array.end())))
      mooseError(
          "In PatternedHexMeshGenerator ",
          _name,
          ": pattern_pitch metadata values of all input mesh generators must be identical "
          "when pattern_boundary is 'none' and generate_core_metadata is true. Please check the "
          "parameters of the mesh generators that produce the input meshes."
          "Note that some of these mesh generators, such as "
          "HexagonConcentricCircleAdaptiveBoundaryMeshGenerator and FlexiblePatternGenerator,"
          "may have different definitions of hexagon size in their input parameters. Please refer "
          "to the documentation of these mesh generators.",
          pitchMetaDataErrorGenerator(_input_names, pattern_pitch_array, "pattern_pitch_meta"));
    else
    {
      _pattern_pitch = pattern_pitch_array.front();
      setMeshProperty("input_pitch_meta", _pattern_pitch);
    }
  }
  else
  {
    if (_pattern_boundary == "hexagon")
    {
      if (!isParamValid("hexagon_size"))
        paramError("hexagon_size",
                   "This parameter must be provided when pattern_boundary is hexagon.");
      else
        _pattern_pitch = 2.0 * (_hexagon_size_style == PolygonSizeStyle::apothem
                                    ? getParam<Real>("hexagon_size")
                                    : getParam<Real>("hexagon_size") * std::cos(M_PI / 6.0));
    }
    for (MooseIndex(_input_names) i = 0; i < _input_names.size(); ++i)
    {
      // throw an error message if the input mesh does not contain the required meta data
      if (!hasMeshProperty<Real>("pitch_meta", _input_names[i]))
        mooseError("In PatternedHexMeshGenerator ",
                   _name,
                   ": the unit hexagonal input mesh does not contain appropriate meta data "
                   "required for generating an assembly. Involved input mesh: ",
                   _input_names[i],
                   "; metadata issue: 'pitch_meta' is missing");
      pitch_array.push_back(getMeshProperty<Real>("pitch_meta", _input_names[i]));

      num_sectors_per_side_array_tmp =
          getMeshProperty<std::vector<unsigned int>>("num_sectors_per_side_meta", _input_names[i]);
      if (*std::max_element(num_sectors_per_side_array_tmp.begin(),
                            num_sectors_per_side_array_tmp.end()) !=
          *std::min_element(num_sectors_per_side_array_tmp.begin(),
                            num_sectors_per_side_array_tmp.end()))
        mooseError("In PatternedHexMeshGenerator ",
                   _name,
                   ": num_sectors_per_side metadata values of all six sides of each input mesh "
                   "generator must be identical.");
      if (num_sectors_per_side_array_tmp.front() == 1 && _pattern_boundary == "hexagon")
        paramError(
            "inputs",
            "for each input mesh, the number of sectors on each side must be greater than unity.");
      num_sectors_per_side_array.push_back(*num_sectors_per_side_array_tmp.begin());
      background_intervals_array.push_back(
          getMeshProperty<unsigned int>("background_intervals_meta", _input_names[i]));
      node_id_background_array.push_back(
          getMeshProperty<dof_id_type>("node_id_background_meta", _input_names[i]));
      max_radius_array.push_back(getMeshProperty<Real>("max_radius_meta", _input_names[i]));
    }
    max_radius_global = *max_element(max_radius_array.begin(), max_radius_array.end());
    if (!MooseUtils::absoluteFuzzyEqual(*std::max_element(pitch_array.begin(), pitch_array.end()),
                                        *std::min_element(pitch_array.begin(), pitch_array.end())))
      mooseError("In PatternedHexMeshGenerator ",
                 _name,
                 ": pitch metadata values of all input mesh generators must be identical. Please "
                 "check the "
                 "parameters of the mesh generators that produce the input meshes.",
                 pitchMetaDataErrorGenerator(_input_names, pitch_array, "pitch_meta"));
    setMeshProperty("input_pitch_meta", pitch_array.front());
    if (*std::max_element(num_sectors_per_side_array.begin(), num_sectors_per_side_array.end()) !=
        *std::min_element(num_sectors_per_side_array.begin(), num_sectors_per_side_array.end()))
      mooseError(
          "In PatternedHexMeshGenerator ",
          _name,
          ": num_sectors_per_side metadata values of all input mesh generators must be identical.");
  }

  std::vector<Real> extra_dist;
  Real extra_dist_shift(0.0);
  Real y_min(0.0);
  Real y_max_0(0.0);
  Real y_max_n(0.0);
  const Real extra_dist_tol = _pattern_boundary == "hexagon" ? pitch_array.front() / 10.0 : 0.0;
  const Real extra_dist_shift_0 = _pattern_boundary == "hexagon" ? pitch_array.front() / 5.0 : 0.0;
  std::vector<unsigned int> peripheral_duct_intervals;
  if (_pattern_boundary == "hexagon")
  {
    if (_has_assembly_duct)
    {
      for (unsigned int i = 0; i < _duct_sizes.size(); i++)
      {
        if (_duct_sizes_style == PolygonSizeStyle::radius)
          _duct_sizes[i] /= std::cos(M_PI / 6.0);
        extra_dist.push_back(0.5 *
                             (_duct_sizes[i] * 2.0 - pitch_array.front() / std::sqrt(3.0) *
                                                         (Real)((_pattern.size() / 2) * 3 + 2)));
        peripheral_duct_intervals.push_back(_duct_intervals[i]);
      }
      if (_duct_sizes.back() >= _pattern_pitch / 2.0)
        paramError("duct_sizes",
                   "The duct sizes should not exceed the size of the hexagonal boundary.");
    }
    // calculate the distance between the larger hexagon boundary and the boundary of stitched unit
    // hexagons this is used to decide whether deformation is needed when cut-off happens or when
    // the distance is small.
    extra_dist.push_back(0.5 * (_pattern_pitch - pitch_array.front() / std::sqrt(3.0) *
                                                     (Real)((_pattern.size() / 2) * 3 + 2)));
    peripheral_duct_intervals.insert(peripheral_duct_intervals.begin(), _background_intervals);

    // In same cases, when the external hexagon size is small enough, the external hexagon boundary
    // may either be very close to the input hexagon meshes that are near the boundary or even cut
    // off the these hexagons. As long as the ring regions are not cut off, the input hexagons can
    // be deformed to accommodate the external hexagon shape. This block sets up the range of mesh
    // region that needs to be deformed.
    if (extra_dist.front() <= extra_dist_tol)
    {
      extra_dist_shift = extra_dist_shift_0 - extra_dist.front();
      for (Real & d : extra_dist)
        d += extra_dist_shift;
      y_min = _deform_non_circular_region
                  ? max_radius_global // Currently use this, ideally this should be the max of the
                                      // outer layer radii
                  : (pitch_array.front() / std::sqrt(3.0));
      y_max_0 = pitch_array.front() / std::sqrt(3.0) + extra_dist.front();
      y_max_n = y_max_0 - extra_dist_shift;
      if (y_max_n <= y_min)
        mooseError("In PatternedHexMeshGenerator ",
                   _name,
                   ": the assembly is cut off so much that the internal structure that should not "
                   "be altered is compromised.");
    }
  }

  setMeshProperty("pattern_pitch_meta", _pattern_pitch);

  // create a list of interface boundary ids for each input mesh
  // NOTE: list of interface boundary ids is stored in mesh metadata
  std::vector<std::set<boundary_id_type>> input_interface_boundary_ids;
  input_interface_boundary_ids.resize(_input_names.size());
  if (_use_interface_boundary_id_shift)
  {
    for (const auto i : make_range(_input_names.size()))
    {
      if (!hasMeshProperty<bool>("interface_boundaries", _input_names[i]))
        mooseError("Metadata 'interface_boundaries' could not be found on the input mesh: ",
                   _input_names[i]);
      if (!getMeshProperty<bool>("interface_boundaries", _input_names[i]))
        mooseError("Interface boundary ids were not constructed in the input mesh",
                   _input_names[i]);
      if (!hasMeshProperty<std::set<boundary_id_type>>("interface_boundary_ids", _input_names[i]))
        mooseError("Metadata 'interface_boundary_ids' could not be found on the input mesh: ",
                   _input_names[i]);
    }
  }
  for (const auto i : make_range(_input_names.size()))
    if (_use_interface_boundary_id_shift ||
        hasMeshProperty<std::set<boundary_id_type>>("interface_boundary_ids", _input_names[i]))
      input_interface_boundary_ids[i] =
          getMeshProperty<std::set<boundary_id_type>>("interface_boundary_ids", _input_names[i]);

  int x_mov = 0;

  const Real input_pitch((_pattern_boundary == "hexagon" || !_generate_core_metadata)
                             ? pitch_array.front()
                             : _pattern_pitch);
  std::vector<Real> control_drum_positions_x;
  std::vector<Real> control_drum_positions_y;
  std::vector<std::vector<Real>> control_drum_azimuthals;

  std::unique_ptr<ReplicatedMesh> out_mesh;

  for (unsigned i = 0; i < _pattern.size(); i++)
  {
    Real deltax = -x_mov * input_pitch / 2;
    if (i == _pattern.size() - 1)
      x_mov--;
    else if (_pattern[i].size() < _pattern[i + 1].size())
      x_mov++;
    else
      x_mov--;
    Real deltay = -(Real)(i)*input_pitch * std::sin(M_PI / 3);

    for (unsigned int j = 0; j < _pattern[i].size(); j++)
    {
      const auto pattern = _pattern[i][j];
      ReplicatedMesh & pattern_mesh = *meshes[pattern];

      // No pattern boundary, so no need to wrap with a peripheral mesh
      // Use the inputs as they stand and translate accordingly later
      if (_pattern_boundary == "none")
      {
        if (_generate_core_metadata && is_control_drum_array[pattern] == 1)
        {
          control_drum_positions_x.push_back(deltax + j * input_pitch);
          control_drum_positions_y.push_back(deltay);
          control_drum_azimuthals.push_back(control_drum_azimuthal_array[pattern]);
        }

        if (j == 0 && i == 0)
        {
          out_mesh = dynamic_pointer_cast<ReplicatedMesh>(pattern_mesh.clone());
          if (_assign_control_drum_id && _generate_core_metadata)
            out_mesh->add_elem_integer(
                "control_drum_id",
                true,
                is_control_drum_array[pattern] ? control_drum_azimuthals.size() : 0);
          // Reassign interface boundary ids
          if (_use_interface_boundary_id_shift)
            reassignBoundaryIDs(*out_mesh,
                                _interface_boundary_id_shift_pattern[i][j],
                                input_interface_boundary_ids[pattern]);
          continue;
        }
      }
      // Has a pattern boundary so we need to wrap with a peripheral mesh
      else // has a pattern boundary
      {
        Real rotation_angle = std::numeric_limits<Real>::max();
        Real orientation = std::numeric_limits<Real>::max();
        unsigned int mesh_type = std::numeric_limits<unsigned int>::max();
        bool on_periphery = true;

        if (j == 0 && i == 0)
        {
          rotation_angle = 60.;
          mesh_type = CORNER_MESH;
          orientation = 0.;
        }
        else if (j == 0 && i == _pattern.size() - 1)
        {
          rotation_angle = 180.;
          mesh_type = CORNER_MESH;
          orientation = -120.;
        }
        else if (j == 0 && i == (_pattern.size() - 1) / 2)
        {
          rotation_angle = 120.;
          mesh_type = CORNER_MESH;
          orientation = -60.;
        }
        else if (j == _pattern[i].size() - 1 && i == 0)
        {
          rotation_angle = 0.;
          mesh_type = CORNER_MESH;
          orientation = 60.;
        }
        else if (j == _pattern[i].size() - 1 && i == _pattern.size() - 1)
        {
          rotation_angle = -120.;
          mesh_type = CORNER_MESH;
          orientation = 180.;
        }
        else if (j == _pattern[i].size() - 1 && i == (_pattern.size() - 1) / 2)
        {
          rotation_angle = -60.;
          mesh_type = CORNER_MESH;
          orientation = 120.;
        }
        else if (i == 0)
        {
          rotation_angle = 0.;
          mesh_type = BOUNDARY_MESH;
          orientation = 0.;
        }
        else if (i == _pattern.size() - 1)
        {
          rotation_angle = 180.;
          mesh_type = BOUNDARY_MESH;
          orientation = -180.;
        }
        else if (j == 0 && i < (_pattern.size() - 1) / 2)
        {
          rotation_angle = 60.;
          mesh_type = BOUNDARY_MESH;
          orientation = -60.;
        }
        else if (j == 0 && i > (_pattern.size() - 1) / 2)
        {
          rotation_angle = 120.;
          mesh_type = BOUNDARY_MESH;
          orientation = -120.;
        }
        else if (j == _pattern[i].size() - 1 && i < (_pattern.size() - 1) / 2)
        {
          rotation_angle = -60.;
          mesh_type = BOUNDARY_MESH;
          orientation = 60.;
        }
        else if (j == _pattern[i].size() - 1 && i > (_pattern.size() - 1) / 2)
        {
          rotation_angle = -120.;
          mesh_type = BOUNDARY_MESH;
          orientation = 120;
        }
        else
          on_periphery = false;

        if (on_periphery)
        {
          auto tmp_peripheral_mesh = dynamic_pointer_cast<ReplicatedMesh>(pattern_mesh.clone());
          addPeripheralMesh(*tmp_peripheral_mesh,
                            pattern,
                            pitch_array.front(),
                            extra_dist,
                            num_sectors_per_side_array,
                            peripheral_duct_intervals,
                            rotation_angle,
                            mesh_type);

          if (extra_dist_shift != 0)
            cutOffPolyDeform(*tmp_peripheral_mesh, orientation, y_max_0, y_max_n, y_min, mesh_type);

          // Reassign interface boundary ids
          if (_use_interface_boundary_id_shift)
            reassignBoundaryIDs(*tmp_peripheral_mesh,
                                _interface_boundary_id_shift_pattern[i][j],
                                input_interface_boundary_ids[pattern]);

          if (i == 0 && j == 0)
            out_mesh = std::move(tmp_peripheral_mesh);
          else
          {
            // Retrieve subdomain name map from the mesh to be stitched and insert it to the main
            // subdomain map
            const auto & increment_subdomain_map = tmp_peripheral_mesh->get_subdomain_name_map();
            out_mesh->set_subdomain_name_map().insert(increment_subdomain_map.begin(),
                                                      increment_subdomain_map.end());

            MeshTools::Modification::translate(
                *tmp_peripheral_mesh, deltax + j * input_pitch, deltay, 0);
            out_mesh->stitch_meshes(*tmp_peripheral_mesh,
                                    OUTER_SIDESET_ID,
                                    OUTER_SIDESET_ID,
                                    TOLERANCE,
                                    /*clear_stitched_boundary_ids=*/true,
                                    /*verbose=*/false);
          }

          continue;
        }
      }

      if (_assign_control_drum_id && _pattern_boundary == "none" && _generate_core_metadata)
        pattern_mesh.add_elem_integer(
            "control_drum_id",
            true,
            is_control_drum_array[pattern] ? control_drum_azimuthals.size() : 0);

      // Translate to correct position
      MeshTools::Modification::translate(pattern_mesh, deltax + j * input_pitch, deltay, 0);

      // Define a reference map variable for subdomain map
      auto & main_subdomain_map = out_mesh->set_subdomain_name_map();
      // Retrieve subdomain name map from the mesh to be stitched and insert it to the main
      // subdomain map
      const auto & increment_subdomain_map = pattern_mesh.get_subdomain_name_map();
      main_subdomain_map.insert(increment_subdomain_map.begin(), increment_subdomain_map.end());
      // Check if one SubdomainName is shared by more than one subdomain ids
      std::set<SubdomainName> main_subdomain_map_name_list;
      for (auto const & id_name_pair : main_subdomain_map)
        main_subdomain_map_name_list.emplace(id_name_pair.second);
      if (main_subdomain_map.size() != main_subdomain_map_name_list.size())
        paramError("inputs", "The input meshes contain subdomain name maps with conflicts.");
      // Shift interface boundary ids
      if (_use_interface_boundary_id_shift)
        reassignBoundaryIDs(pattern_mesh,
                            _interface_boundary_id_shift_pattern[i][j],
                            input_interface_boundary_ids[pattern]);

      out_mesh->stitch_meshes(pattern_mesh,
                              OUTER_SIDESET_ID,
                              OUTER_SIDESET_ID,
                              TOLERANCE,
                              /*clear_stitched_boundary_ids=*/false,
                              /*verbose=*/false);

      // Translate back now that we've stitched so that anyone else that uses this mesh has it at
      // the origin
      MeshTools::Modification::translate(pattern_mesh, -(deltax + j * input_pitch), -deltay, 0);
      // Roll back the changes in interface boundary ids for the same reason
      if (_use_interface_boundary_id_shift)
        reassignBoundaryIDs(pattern_mesh,
                            _interface_boundary_id_shift_pattern[i][j],
                            input_interface_boundary_ids[pattern],
                            true);
    }
  }

  // Check if OUTER_SIDESET_ID is really the external boundary. Correct if needed.
  auto side_list = out_mesh->get_boundary_info().build_side_list();
  for (auto & sl : side_list)
  {
    if (std::get<2>(sl) == OUTER_SIDESET_ID)
      if (out_mesh->elem_ptr(std::get<0>(sl))->neighbor_ptr(std::get<1>(sl)) != nullptr)
        out_mesh->get_boundary_info().remove_side(
            out_mesh->elem_ptr(std::get<0>(sl)), std::get<1>(sl), std::get<2>(sl));
  }
  out_mesh->get_boundary_info().clear_boundary_node_ids();

  out_mesh->get_boundary_info().build_node_list_from_side_list();
  const auto node_list = out_mesh->get_boundary_info().build_node_list();

  std::vector<Real> bd_x_list;
  std::vector<Real> bd_y_list;
  std::vector<std::pair<Real, dof_id_type>> node_azi_list;
  const Point origin_pt = MooseMeshUtils::meshCentroidCalculator(*out_mesh);
  const Real origin_x = origin_pt(0);
  const Real origin_y = origin_pt(1);

  MeshTools::Modification::translate(*out_mesh, -origin_x, -origin_y, 0);

  if (_uniform_mesh_on_sides)
  {
    const Real azi_tol = 1E-8;
    for (unsigned int i = 0; i < node_list.size(); ++i)
    {
      if (std::get<1>(node_list[i]) == OUTER_SIDESET_ID)
      {
        node_azi_list.push_back(
            std::make_pair(atan2(out_mesh->node_ref(std::get<0>(node_list[i]))(1),
                                 out_mesh->node_ref(std::get<0>(node_list[i]))(0)) *
                               180.0 / M_PI,
                           std::get<0>(node_list[i])));
        // correct the last node's angle value (180.0) if it becomes a negative value.
        if (node_azi_list.back().first + 180.0 <= azi_tol)
          node_azi_list.back().first = 180;
      }
    }
    std::sort(node_azi_list.begin(), node_azi_list.end());
    const unsigned int side_intervals = node_azi_list.size() / HEXAGON_NUM_SIDES;
    for (unsigned int i = 0; i < HEXAGON_NUM_SIDES; i++)
    {
      for (unsigned int j = 1; j <= side_intervals; j++)
      {
        Real azi_corr_tmp = atan2((Real)j * 2.0 / (Real)side_intervals - 1.0, std::sqrt(3.0));
        Real x_tmp = _pattern_pitch / 2.0;
        Real y_tmp = x_tmp * std::tan(azi_corr_tmp);
        nodeCoordRotate(x_tmp, y_tmp, (Real)i * 60.0 - 150.0);
        Point p_tmp = Point(x_tmp, y_tmp, 0.0);
        out_mesh->add_point(p_tmp, node_azi_list[i * side_intervals + j - 1].second);
      }
    }

    // if quadratic elements are used, additional nodes need to be adjusted based on the new
    // boundary node locations. adjust side mid-edge nodes to the midpoints of the corner
    // points, and if QUAD9, adjust center point to new centroid.
    if (_boundary_quad_elem_type != QUAD_ELEM_TYPE::QUAD4)
      adjustPeripheralQuadraticElements(*out_mesh, _boundary_quad_elem_type);
  }

  MeshTools::Modification::rotate(*out_mesh, _rotate_angle, 0.0, 0.0);

  // This combination of input parameters is usually used for core mesh generation by stitching
  // assembly meshes together.
  if (_pattern_boundary == "none" && _generate_core_metadata)
  {
    const Real azi_tol = 1E-8;
    std::vector<std::tuple<Real, Point, std::vector<Real>, dof_id_type>> control_drum_tmp;
    std::vector<dof_id_type> control_drum_id_sorted;
    for (unsigned int i = 0; i < control_drum_positions_x.size(); ++i)
    {
      control_drum_positions_x[i] -= origin_x;
      control_drum_positions_y[i] -= origin_y;
      nodeCoordRotate(control_drum_positions_x[i], control_drum_positions_y[i], _rotate_angle);
      Real cd_angle = atan2(control_drum_positions_y[i], control_drum_positions_x[i]);

      for (unsigned int j = 0; j < control_drum_azimuthals[i].size(); j++)
      {
        control_drum_azimuthals[i][j] += _rotate_angle;
        control_drum_azimuthals[i][j] =
            atan2(std::sin(control_drum_azimuthals[i][j] / 180.0 * M_PI),
                  std::cos(control_drum_azimuthals[i][j] / 180.0 * M_PI)) /
            M_PI * 180.0; // quick way to move to -M_PI to M_PI
      }
      std::sort(control_drum_azimuthals[i].begin(), control_drum_azimuthals[i].end());

      if (std::abs(cd_angle) < azi_tol)
        cd_angle = 0;
      else if (cd_angle < 0.0)
        cd_angle += 2 * M_PI;
      control_drum_tmp.push_back(
          std::make_tuple(cd_angle,
                          Point(control_drum_positions_x[i], control_drum_positions_y[i], 0.0),
                          control_drum_azimuthals[i],
                          i + 1)); // control drum index to help sort control_drum_id
    }
    std::sort(control_drum_tmp.begin(), control_drum_tmp.end());
    std::vector<Point> control_drum_positions;
    std::vector<Real> control_drum_angles;
    std::vector<std::vector<Real>> control_drums_azimuthal_meta;
    for (unsigned int i = 0; i < control_drum_tmp.size(); ++i)
    {
      control_drum_positions.push_back(std::get<1>(control_drum_tmp[i]));
      control_drum_angles.push_back(std::get<0>(control_drum_tmp[i]));
      control_drums_azimuthal_meta.push_back(std::get<2>(control_drum_tmp[i]));
      control_drum_id_sorted.push_back(std::get<3>(control_drum_tmp[i]));
    }
    setMeshProperty("control_drum_positions", control_drum_positions);
    setMeshProperty("control_drum_angles", control_drum_angles);
    setMeshProperty("control_drums_azimuthal_meta", control_drums_azimuthal_meta);

    if (_assign_control_drum_id)
    {
      unsigned int id = out_mesh->get_elem_integer_index("control_drum_id");
      for (const auto & elem : out_mesh->element_ptr_range())
      {
        dof_id_type unsorted_control_drum_id = elem->get_extra_integer(id);
        if (unsorted_control_drum_id != 0)
        {
          auto sorted_iter = std::find(control_drum_id_sorted.begin(),
                                       control_drum_id_sorted.end(),
                                       unsorted_control_drum_id);
          elem->set_extra_integer(id,
                                  std::distance(control_drum_id_sorted.begin(), sorted_iter) + 1);
        }
      }
    }

    if (_generate_control_drum_positions_file)
    {
      std::string position_file_name = getMeshProperty<std::string>("position_file_name", name());
      std::ofstream pos_file(position_file_name);
      for (unsigned int i = 0; i < control_drum_positions.size(); ++i)
        pos_file << control_drum_positions[i](0) << " " << control_drum_positions[i](1) << " 0.0\n";
      pos_file.close();
    }
  }

  // before return, add reporting IDs if _use_reporting_id is set true
  if (_use_reporting_id)
    addReportingIDs(*out_mesh, meshes);

  // Assign customized peripheral block ids and names
  if (!_peripheral_block_ids.empty())
    for (const auto & elem : out_mesh->active_element_ptr_range())
      for (subdomain_id_type i = PERIPHERAL_ID_SHIFT; i <= PERIPHERAL_ID_SHIFT + _duct_sizes.size();
           i++)
        if (elem->subdomain_id() == i)
        {
          elem->subdomain_id() = _peripheral_block_ids[i - PERIPHERAL_ID_SHIFT];
          break;
        }
  if (!_peripheral_block_names.empty())
  {
    for (unsigned i = 0; i < _peripheral_block_names.size(); i++)
      out_mesh->subdomain_name(_peripheral_block_ids.empty() ? (PERIPHERAL_ID_SHIFT + i)
                                                             : _peripheral_block_ids[i]) =
          _peripheral_block_names[i];
  }
  // Assign customized outer surface boundary id and name
  if (_external_boundary_id > 0)
    MooseMesh::changeBoundaryId(*out_mesh, OUTER_SIDESET_ID, _external_boundary_id, false);
  if (!_external_boundary_name.empty())
  {
    out_mesh->get_boundary_info().sideset_name(
        _external_boundary_id > 0 ? _external_boundary_id : (boundary_id_type)OUTER_SIDESET_ID) =
        _external_boundary_name;
    out_mesh->get_boundary_info().nodeset_name(
        _external_boundary_id > 0 ? _external_boundary_id : (boundary_id_type)OUTER_SIDESET_ID) =
        _external_boundary_name;
  }
  // Merge the boundary name maps of all the input meshed to generate the output mesh's boundary
  // name maps
  auto & new_sideset_map = out_mesh->get_boundary_info().set_sideset_name_map();
  auto & new_nodeset_map = out_mesh->get_boundary_info().set_nodeset_name_map();
  for (unsigned int i = 0; i < meshes.size(); i++)
  {
    const auto input_sideset_map = meshes[i]->get_boundary_info().get_sideset_name_map();
    new_sideset_map.insert(input_sideset_map.begin(), input_sideset_map.end());
    const auto input_nodeset_map = meshes[i]->get_boundary_info().get_nodeset_name_map();
    new_nodeset_map.insert(input_nodeset_map.begin(), input_nodeset_map.end());
  }

  // set mesh metadata related with interface boundary ids
  const std::set<boundary_id_type> boundary_ids = out_mesh->get_boundary_info().get_boundary_ids();
  const std::set<boundary_id_type> interface_boundary_ids = getInterfaceBoundaryIDs(
      _pattern,
      _interface_boundary_id_shift_pattern,
      boundary_ids,
      input_interface_boundary_ids,
      _use_interface_boundary_id_shift,
      _create_inward_interface_boundaries || _create_outward_interface_boundaries,
      extra_dist.size());
  if (interface_boundary_ids.size() > 0)
  {
    setMeshProperty("interface_boundaries", true);
    setMeshProperty("interface_boundary_ids", interface_boundary_ids);
  }

  out_mesh->set_isnt_prepared();
  auto mesh = dynamic_pointer_cast<MeshBase>(out_mesh);
  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 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;
}

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

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

positionSetup()

void PatternedHexMeshGenerator::positionSetup ( std::vector< std::pair< Real, Real >> &  positions_inner, std::vector< std::pair< Real, Real >> &  d_positions_outer, const Real  extra_dist_in, const Real  extra_dist_out, const Real  pitch, const unsigned int  radial_index  ) const

protected

Computes the inner and outer node positions of the peripheral region for a single layer.

Parameters

positions_inner	key positions (i.e., vertices and mid-points) of the inner side of the peripheral region
d_positions_outer	key incremental positions (i.e., vertices and mid-points) of the outer side of the peripheral region
extra_dist_in	extra distance applied to the inner side
extra_dist_out	extra distance applied to the outer side
pitch	pitch size of the involved hexagon mesh
radial_index	radial layer index

Definition at line 1102 of file PatternedHexMeshGenerator.C.

Referenced by addPeripheralMesh().

{
  positions_inner.resize(0);
  d_positions_outer.resize(0);

  // Nine sets of positions are generated here, as shown below.
  // CORNER MESH Peripheral {0 1 2}, {2 3 4} and {4 5 6}
  //           3       2   1   0
  //            \      :   :   :
  //             \     :   :   :
  //      4.       .       :   :
  //         ` .               :
  //      5.   |               |
  //         ` |               |
  //      6.   |               |
  //         ` |               |
  //               .       .
  //                   .
  //
  // EDGE MESH Peripheral {0 1 2} and {2 7 8}
  //           8   7   2   1   0
  //           :   :   :   :   :
  //           :   :   :   :   :
  //           :   :       :   :
  //           :               :
  //           |               |
  //           |               |
  //           |               |
  //           |               |
  //               .       .
  //                   .

  positions_inner.push_back(
      std::make_pair(-pitch / 2.0,
                     std::sqrt(3.0) * pitch / 6.0 +
                         (radial_index != 0 ? std::sqrt(3.0) * pitch / 6.0 + extra_dist_in : 0.0)));
  positions_inner.push_back(std::make_pair(
      -pitch / 4.0,
      std::sqrt(3.0) * pitch / 4.0 +
          (radial_index != 0 ? std::sqrt(3.0) * pitch / 12.0 + extra_dist_in : 0.0)));
  positions_inner.push_back(std::make_pair(
      0.0, std::sqrt(3.0) * pitch / 3.0 + (radial_index != 0 ? extra_dist_in : 0.0)));
  positions_inner.push_back(std::make_pair(
      pitch / 4.0 + (radial_index != 0 ? pitch / 12.0 + std::sqrt(3.0) * extra_dist_in / 3.0 : 0.0),
      std::sqrt(3.0) * pitch / 4.0 +
          (radial_index != 0 ? pitch * std::sqrt(3.0) / 12.0 + extra_dist_in : 0.0)));
  positions_inner.push_back(std::make_pair(
      pitch / 2.0 + (radial_index != 0 ? std::sqrt(3.0) * extra_dist_in / 2.0 : 0.0),
      std::sqrt(3.0) * pitch / 6.0 + (radial_index != 0 ? extra_dist_in / 2.0 : 0.0)));
  positions_inner.push_back(std::make_pair(
      pitch / 2.0 + (radial_index != 0 ? pitch / 8.0 + std::sqrt(3.0) * extra_dist_in / 2.0 : 0.0),
      0.0 + (radial_index != 0 ? std::sqrt(3.0) * pitch / 24.0 + extra_dist_in / 2.0 : 0.0)));
  positions_inner.push_back(std::make_pair(
      pitch / 2.0 + (radial_index != 0 ? pitch / 4.0 + std::sqrt(3.0) * extra_dist_in / 2.0 : 0.0),
      -std::sqrt(3.0) * pitch / 6.0 +
          (radial_index != 0 ? std::sqrt(3.0) * pitch / 12.0 + extra_dist_in / 2.0 : 0.0)));
  positions_inner.push_back(std::make_pair(
      pitch / 4.0,
      std::sqrt(3.0) * pitch / 4.0 +
          (radial_index != 0 ? std::sqrt(3.0) * pitch / 12.0 + extra_dist_in : 0.0)));
  positions_inner.push_back(
      std::make_pair(pitch / 2.0,
                     std::sqrt(3.0) * pitch / 6.0 +
                         (radial_index != 0 ? std::sqrt(3.0) * pitch / 6.0 + extra_dist_in : 0.0)));

  d_positions_outer.push_back(
      std::make_pair(0.0,
                     std::sqrt(3.0) * pitch / 6.0 + extra_dist_out -
                         (radial_index != 0 ? std::sqrt(3.0) * pitch / 6.0 + extra_dist_in : 0.0)));
  d_positions_outer.push_back(std::make_pair(
      0.0,
      std::sqrt(3.0) * pitch / 12.0 + extra_dist_out -
          (radial_index != 0 ? std::sqrt(3.0) * pitch / 12.0 + extra_dist_in : 0.0)));
  d_positions_outer.push_back(
      std::make_pair(0.0, extra_dist_out - (radial_index != 0 ? extra_dist_in : 0.0)));
  d_positions_outer.push_back(std::make_pair(
      pitch / 12.0 + std::sqrt(3.0) * extra_dist_out / 3.0 -
          (radial_index != 0 ? pitch / 12.0 + std::sqrt(3.0) * extra_dist_in / 3.0 : 0.0),
      pitch * std::sqrt(3.0) / 12.0 + extra_dist_out -
          (radial_index != 0 ? pitch * std::sqrt(3.0) / 12.0 + extra_dist_in : 0.0)));
  d_positions_outer.push_back(
      std::make_pair(std::sqrt(3.0) * extra_dist_out / 2.0 -
                         (radial_index != 0 ? std::sqrt(3.0) * extra_dist_in / 2.0 : 0.0),
                     extra_dist_out / 2.0 - (radial_index != 0 ? extra_dist_in / 2.0 : 0.0)));
  d_positions_outer.push_back(std::make_pair(
      pitch / 8.0 + std::sqrt(3.0) * extra_dist_out / 2.0 -
          (radial_index != 0 ? pitch / 8.0 + std::sqrt(3.0) * extra_dist_in / 2.0 : 0.0),
      std::sqrt(3.0) * pitch / 24.0 + extra_dist_out / 2.0 -
          (radial_index != 0 ? std::sqrt(3.0) * pitch / 24.0 + extra_dist_in / 2.0 : 0.0)));
  d_positions_outer.push_back(std::make_pair(
      pitch / 4.0 + std::sqrt(3.0) * extra_dist_out / 2.0 -
          (radial_index != 0 ? pitch / 4.0 + std::sqrt(3.0) * extra_dist_in / 2.0 : 0.0),
      std::sqrt(3.0) * pitch / 12.0 + extra_dist_out / 2.0 -
          (radial_index != 0 ? std::sqrt(3.0) * pitch / 12.0 + extra_dist_in / 2.0 : 0.0)));
  d_positions_outer.push_back(std::make_pair(
      0.0,
      std::sqrt(3.0) * pitch / 12.0 + extra_dist_out -
          (radial_index != 0 ? std::sqrt(3.0) * pitch / 12.0 + extra_dist_in : 0.0)));
  d_positions_outer.push_back(
      std::make_pair(0.0,
                     std::sqrt(3.0) * pitch / 6.0 + extra_dist_out -
                         (radial_index != 0 ? std::sqrt(3.0) * pitch / 6.0 + extra_dist_in : 0.0)));
}

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

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

static

Definition at line 22 of file PatternedHexMeshGenerator.C.

Referenced by HexIDPatternedMeshGenerator::validParams().

{
  InputParameters params = PolygonMeshGeneratorBase::validParams();
  params.addRequiredParam<std::vector<MeshGeneratorName>>("inputs", "The input MeshGenerators.");
  params.addRequiredRangeCheckedParam<std::vector<std::vector<unsigned int>>>(
      "pattern",
      "pattern>=0",
      "A double-indexed hexagonal-shaped array starting with the upper-left corner.");
  MooseEnum pattern_boundary("none hexagon", "hexagon");
  params.addParam<MooseEnum>(
      "pattern_boundary", pattern_boundary, "The boundary shape of the patterned mesh.");
  params.addParam<bool>(
      "generate_core_metadata",
      false,
      "A Boolean parameter that controls whether the core related metadata "
      "is generated for other MOOSE objects such as 'MultiControlDrumFunction' or not.");
  params.addRangeCheckedParam<unsigned int>("background_intervals",
                                            3,
                                            "background_intervals>0",
                                            "Radial intervals in the assembly peripheral region.");
  params.addRangeCheckedParam<Real>("hexagon_size",
                                    "hexagon_size>0.0",
                                    "Size of the outmost hexagon boundary to be generated; this is "
                                    "required only when pattern type is 'hexagon'.");
  MooseEnum hexagon_size_style("apothem radius", "apothem");
  params.addParam<MooseEnum>(
      "hexagon_size_style",
      hexagon_size_style,
      "Style in which the hexagon size is given (default: apothem i.e. half-pitch).");
  params.addRangeCheckedParam<std::vector<Real>>(
      "duct_sizes", "duct_sizes>0.0", "Distance(s) from center to duct(s) inner boundaries.");
  MooseEnum duct_sizes_style("apothem radius", "apothem");
  params.addParam<MooseEnum>("duct_sizes_style",
                             duct_sizes_style,
                             "Style in which hexagon center to duct distance(s) is given (apothem "
                             "= center-to-face, radius = center-to-vertex).");
  params.addRangeCheckedParam<std::vector<unsigned int>>(
      "duct_intervals", "duct_intervals>0", "Number of meshing intervals in each enclosing duct.");
  params.addParam<bool>("uniform_mesh_on_sides",
                        false,
                        "Whether the side elements are reorganized to have a uniform size.");
  params.addParam<bool>("generate_control_drum_positions_file",
                        false,
                        "Whether a positions file is generated in the core mesh mode.");
  params.addParam<bool>("assign_control_drum_id",
                        false,
                        "Whether control drum id is assigned to the mesh as an extra integer.");
  std::string position_file_default = "positions_meta.data";
  params.addParam<std::string>(
      "position_file", position_file_default, "Data file name to store control drum positions.");
  // A hexagon pattern_boundary mesh can be used in "inputs" of `PatternedHexMeshGenerator` after a
  // 90-degree rotation.
  params.addParam<Real>(
      "rotate_angle",
      90.0,
      "Rotate the entire patterned mesh by a certain degrees that is defined here.");
  params.addParam<subdomain_id_type>(
      "background_block_id",
      "Optional customized block id for the background block in 'assembly' mode; must be provided "
      "along with 'duct_block_ids' if 'duct_sizes' is provided.");
  params.addParam<SubdomainName>(
      "background_block_name",
      "Optional customized block name for the background block in 'assembly' mode; must be "
      "provided along with 'duct_block_names' if 'duct_sizes' is provided.");
  params.addParam<std::vector<subdomain_id_type>>(
      "duct_block_ids",
      "Optional customized block ids for each duct geometry block in 'assembly' mode; must be "
      "provided along with 'background_block_id'.");
  params.addParam<std::vector<SubdomainName>>(
      "duct_block_names",
      std::vector<SubdomainName>(),
      "Optional customized block names for each duct geometry block in 'assembly' mode; must be "
      "provided along with 'background_block_name'.");
  params.addRangeCheckedParam<boundary_id_type>("external_boundary_id",
                                                "external_boundary_id>0",
                                                "Optional customized external boundary id.");
  params.addParam<bool>("create_inward_interface_boundaries",
                        false,
                        "Whether the inward interface boundary sidesets are created.");
  params.addParam<bool>("create_outward_interface_boundaries",
                        true,
                        "Whether the outward interface boundary sidesets are created.");
  params.addParam<BoundaryName>(
      "external_boundary_name", BoundaryName(), "Optional customized external boundary name.");
  params.addParam<bool>("deform_non_circular_region",
                        true,
                        "Whether the non-circular region (outside the rings) can be deformed.");
  params.addParam<std::vector<std::string>>("id_name", "List of extra integer ID set names");
  params.addParam<std::vector<MeshGeneratorName>>(
      "exclude_id", "Name of input meshes to be excluded in ID generation");
  std::vector<MooseEnum> option = {MooseEnum("cell pattern manual", "cell")};
  params.addParam<std::vector<MooseEnum>>(
      "assign_type", option, "List of integer ID assignment types");
  params.addParam<std::vector<std::vector<std::vector<dof_id_type>>>>(
      "id_pattern",
      "User-defined element IDs. A double-indexed array starting with the upper-left corner. When "
      "providing multiple patterns, each pattern should be separated using '|'");
  params.addParam<std::vector<std::vector<boundary_id_type>>>(
      "interface_boundary_id_shift_pattern",
      "User-defined shift values for each pattern cell. A double-indexed array starting with the "
      "upper-left corner.");
  MooseEnum quad_elem_type("QUAD4 QUAD8 QUAD9", "QUAD4");
  params.addParam<MooseEnum>(
      "boundary_region_element_type",
      quad_elem_type,
      "Type of the quadrilateral elements to be generated in the boundary region.");
  params.addParam<bool>(
      "allow_unused_inputs",
      false,
      "Whether additional input assemblies can be part of inputs without being used in lattice");
  params.addParamNamesToGroup(
      "background_block_id background_block_name duct_block_ids boundary_region_element_type "
      "duct_block_names external_boundary_id external_boundary_name "
      "create_inward_interface_boundaries create_outward_interface_boundaries",
      "Customized Subdomain/Boundary");
  params.addParamNamesToGroup(
      "generate_control_drum_positions_file assign_control_drum_id position_file", "Control Drum");
  params.addParamNamesToGroup(
      "background_intervals duct_intervals uniform_mesh_on_sides deform_non_circular_region",
      "Mesh Density");
  params.addParamNamesToGroup("id_name exclude_id assign_type id_pattern", "Reporting ID");
  params.addClassDescription(
      "This PatternedHexMeshGenerator source code assembles hexagonal meshes into a hexagonal grid "
      "and optionally forces the outer boundary to be hexagonal and/or adds a duct.");

  return params;
}

Member Data Documentation

_allow_unused_inputs

const bool PatternedHexMeshGenerator::_allow_unused_inputs

protected

Whether to allow additional assembly types to be passed to "inputs" parameter without being used in lattice.

Definition at line 100 of file PatternedHexMeshGenerator.h.

Referenced by PatternedHexMeshGenerator().

_assign_control_drum_id

const bool PatternedHexMeshGenerator::_assign_control_drum_id

protected

Wheter control drum IDs are assigned as an extra element integer.

Definition at line 56 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_assign_types

std::vector<ReportingIDGeneratorUtils::AssignType> PatternedHexMeshGenerator::_assign_types

protected

reporting ID assignment type

Definition at line 86 of file PatternedHexMeshGenerator.h.

Referenced by addReportingIDs(), and PatternedHexMeshGenerator().

_background_intervals

const unsigned int PatternedHexMeshGenerator::_background_intervals

protected

Number of radial intervals in the background region.

Definition at line 42 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_boundary_quad_elem_type

QUAD_ELEM_TYPE PatternedHexMeshGenerator::_boundary_quad_elem_type

protected

Type of quadrilateral elements to be generated in the periphery region.

Definition at line 98 of file PatternedHexMeshGenerator.h.

Referenced by addPeripheralMesh(), and generate().

_create_inward_interface_boundaries

const bool PatternedHexMeshGenerator::_create_inward_interface_boundaries

protected

Whether inward interface boundaries are created.

Definition at line 68 of file PatternedHexMeshGenerator.h.

Referenced by addPeripheralMesh(), and generate().

_create_outward_interface_boundaries

const bool PatternedHexMeshGenerator::_create_outward_interface_boundaries

protected

Whether outward interface boundaries are created.

Definition at line 70 of file PatternedHexMeshGenerator.h.

Referenced by addPeripheralMesh(), and generate().

_deform_non_circular_region

const bool PatternedHexMeshGenerator::_deform_non_circular_region

protected

Whether the non-circular region (outside the rings) can be deformed.

Definition at line 74 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_duct_block_ids

const std::vector<subdomain_id_type> PatternedHexMeshGenerator::_duct_block_ids

protected

Subdomain IDs of the duct layers.

Definition at line 60 of file PatternedHexMeshGenerator.h.

Referenced by PatternedHexMeshGenerator().

_duct_block_names

const std::vector<SubdomainName> PatternedHexMeshGenerator::_duct_block_names

protected

Subdomain Names of the duct layers.

Definition at line 62 of file PatternedHexMeshGenerator.h.

Referenced by PatternedHexMeshGenerator().

_duct_intervals

const std::vector<unsigned int> PatternedHexMeshGenerator::_duct_intervals

protected

Number(s) of radial intervals of duct layer(s)

Definition at line 50 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_duct_sizes

std::vector<Real> PatternedHexMeshGenerator::_duct_sizes

protected

Size parameter(s) of duct(s)

Definition at line 46 of file PatternedHexMeshGenerator.h.

Referenced by generate(), and PatternedHexMeshGenerator().

_duct_sizes_style

const PolygonSizeStyle PatternedHexMeshGenerator::_duct_sizes_style

protected

Style of the duct size parameter(s)

Definition at line 48 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_exclude_ids

std::vector<bool> PatternedHexMeshGenerator::_exclude_ids

protected

vector indicating which ids in the pattern to exclude (true at pattern positions to exclude)

Definition at line 90 of file PatternedHexMeshGenerator.h.

Referenced by addReportingIDs(), and PatternedHexMeshGenerator().

_external_boundary_id

const boundary_id_type PatternedHexMeshGenerator::_external_boundary_id

protected

Boundary ID of mesh's external boundary.

Definition at line 64 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_external_boundary_name

const BoundaryName PatternedHexMeshGenerator::_external_boundary_name

protected

Boundary name of mesh's external boundary.

Definition at line 66 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_generate_control_drum_positions_file

const bool PatternedHexMeshGenerator::_generate_control_drum_positions_file

protected

Whether a text file containing control drum positions is generated.

Definition at line 54 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_generate_core_metadata

const bool PatternedHexMeshGenerator::_generate_core_metadata

protected

Whether a reactor core mesh with core metadata is generated.

Definition at line 40 of file PatternedHexMeshGenerator.h.

Referenced by generate(), and PatternedHexMeshGenerator().

_has_assembly_duct

const bool PatternedHexMeshGenerator::_has_assembly_duct

protected

Whether the hexagonal pattern has external duct(s)

Definition at line 44 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_hexagon_size_style

const PolygonSizeStyle PatternedHexMeshGenerator::_hexagon_size_style

protected

Style of the polygon size parameter.

Definition at line 72 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_id_patterns

std::map<std::string, std::vector<std::vector<dof_id_type> > > PatternedHexMeshGenerator::_id_patterns

protected

hold ID patterns for each manual reporting ID. Individual ID pattern contains ID values for each pattern cell.

Definition at line 92 of file PatternedHexMeshGenerator.h.

Referenced by addReportingIDs(), and PatternedHexMeshGenerator().

_input_names

const std::vector<MeshGeneratorName>& PatternedHexMeshGenerator::_input_names

protected

Names of input meshes.

Definition at line 34 of file PatternedHexMeshGenerator.h.

Referenced by generate(), and PatternedHexMeshGenerator().

_interface_boundary_id_shift_pattern

std::vector<std::vector<boundary_id_type> > PatternedHexMeshGenerator::_interface_boundary_id_shift_pattern

protected

hold user-defined shift values for each pattern cell

Definition at line 96 of file PatternedHexMeshGenerator.h.

Referenced by generate(), and PatternedHexMeshGenerator().

_mesh_ptrs

const std::vector<std::unique_ptr<MeshBase> *> PatternedHexMeshGenerator::_mesh_ptrs

protected

The input meshes.

Definition at line 31 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_pattern

const std::vector<std::vector<unsigned int> >& PatternedHexMeshGenerator::_pattern

protected

2D vector of the hexagonal pattern

Definition at line 36 of file PatternedHexMeshGenerator.h.

Referenced by addReportingIDs(), generate(), and PatternedHexMeshGenerator().

_pattern_boundary

const MooseEnum PatternedHexMeshGenerator::_pattern_boundary

protected

Type of the external boundary shape.

Definition at line 38 of file PatternedHexMeshGenerator.h.

Referenced by addReportingIDs(), generate(), and PatternedHexMeshGenerator().

_pattern_pitch

Real PatternedHexMeshGenerator::_pattern_pitch

protected

Pitch size of the input assembly mesh.

Definition at line 76 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_peripheral_block_ids

std::vector<subdomain_id_type> PatternedHexMeshGenerator::_peripheral_block_ids

protected

Subdomain IDs of the peripheral regions.

Definition at line 78 of file PatternedHexMeshGenerator.h.

Referenced by generate(), and PatternedHexMeshGenerator().

_peripheral_block_names

std::vector<SubdomainName> PatternedHexMeshGenerator::_peripheral_block_names

protected

Subdomain Names of the peripheral regions.

Definition at line 80 of file PatternedHexMeshGenerator.h.

Referenced by generate(), and PatternedHexMeshGenerator().

_reporting_id_names

std::vector<std::string> PatternedHexMeshGenerator::_reporting_id_names

protected

names of reporting ID

Definition at line 84 of file PatternedHexMeshGenerator.h.

Referenced by addReportingIDs(), and PatternedHexMeshGenerator().

_rotate_angle

const Real PatternedHexMeshGenerator::_rotate_angle

protected

The mesh rotation angle after mesh generation.

Definition at line 58 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_uniform_mesh_on_sides

const bool PatternedHexMeshGenerator::_uniform_mesh_on_sides

protected

Whether the nodes on the external boundary are uniformly distributed.

Definition at line 52 of file PatternedHexMeshGenerator.h.

Referenced by generate().

_use_exclude_id

const bool PatternedHexMeshGenerator::_use_exclude_id

protected

flag to indicate if exclude_id is defined

Definition at line 88 of file PatternedHexMeshGenerator.h.

Referenced by addReportingIDs(), and PatternedHexMeshGenerator().

_use_interface_boundary_id_shift

const bool PatternedHexMeshGenerator::_use_interface_boundary_id_shift

protected

whether the interface boundary ids from input meshes are shifted, using a user-defined pattern of values for each pattern cell

Definition at line 94 of file PatternedHexMeshGenerator.h.

Referenced by generate(), and PatternedHexMeshGenerator().

_use_reporting_id

const bool PatternedHexMeshGenerator::_use_reporting_id

protected

Whether reporting ID is added to mesh.

Definition at line 82 of file PatternedHexMeshGenerator.h.

Referenced by generate(), and PatternedHexMeshGenerator().

---

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

• reactor/include/meshgenerators/PatternedHexMeshGenerator.h
• reactor/src/meshgenerators/PatternedHexMeshGenerator.C