https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
PolygonConcentricCircleMeshGenerator Class Reference

This PolygonConcentricCircleMeshGenerator object is designed to mesh a polygon geometry with optional rings centered inside. More...

#include <PolygonConcentricCircleMeshGenerator.h>

Inheritance diagram for PolygonConcentricCircleMeshGenerator:
[legend]

Public Types

enum class  PolygonSizeStyle { apothem , 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 class  TRI_ELEM_TYPE { TRI3 , TRI6 , TRI7 }
 
enum class  QUAD_ELEM_TYPE { QUAD4 , QUAD8 , QUAD9 }
 
typedef DataFileName DataFileParameterType
 

Public Member Functions

 PolygonConcentricCircleMeshGenerator (const InputParameters &parameters)
 
std::unique_ptr< MeshBase > generate () override
 
std::unique_ptr< CSG::CSGBase > generateInternalCSG ()
 
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 hasGenerateCSG () const
 
bool isDataOnly () const
 
virtual bool enabled () const
 
std::shared_ptr< MooseObject > getSharedPtr ()
 
std::shared_ptr< const MooseObject > getSharedPtr () const
 
bool isKokkosObject () const
 
MooseApp & getMooseApp () const
 
const std::string & type () const
 
const std::string & name () const
 
std::string typeAndName () const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
MooseObjectName uniqueName () const
 
const InputParameters & parameters () const
 
const hit::Node * getHitNode () const
 
bool hasBase () const
 
const std::string & getBase () 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 &name) const
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void paramError (const std::string &param, Args... args) const
 
void paramWarning (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
 
std::string messagePrefix (const bool hit_prefix=true) const
 
std::string errorPrefix (const std::string &) const
 
void mooseError (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecatedNoTrace (Args &&... args) const
 
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
 
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 bool hasGenerateCSG (const InputParameters &params)
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
 
static void setHasGenerateData (InputParameters &params)
 
static void setHasGenerateCSG (InputParameters &params)
 

Public Attributes

 usingCombinedWarningSolutionWarnings
 
const ConsoleStream _console
 

Static Public Attributes

static const std::string data_only_param
 
static const std::string type_param
 
static const std::string name_param
 
static const std::string unique_name_param
 
static const std::string app_param
 
static const std::string moose_base_param
 
static const std::string kokkos_object_param
 
static constexpr auto SYSTEM
 
static constexpr auto NAME
 

Protected Member Functions

void assignInterfaceBoundaryNames (ReplicatedMesh &mesh) const
 Assign interface boundary names to the mesh if applicable.
 
void assignBlockIdsNames (ReplicatedMesh &mesh, std::vector< subdomain_id_type > &block_ids_old, std::vector< subdomain_id_type > &block_ids_new, std::vector< SubdomainName > &block_names, const std::string &generator_name) const
 Assign block IDs and names to the mesh if applicable.
 
void ringBlockIdsNamesPreparer (unsigned int &block_counter, unsigned int &ring_block_num, std::vector< subdomain_id_type > &block_ids_old, std::vector< subdomain_id_type > &block_ids_new, std::vector< SubdomainName > &block_names) const
 Prepare user-defined ring block IDs and names to replace the default ones.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
void nodeCoordRotate (Real &x, Real &y, const Real theta) const
 Calculates x and y coordinates after rotating by theta angle.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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
 
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
 
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
 
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
 
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.
 
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.
 
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.
 
virtual void generateData ()
 
virtual std::unique_ptr< CSG::CSGBase > generateCSG ()
 
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)
 
std::unique_ptr< CSG::CSGBase > & getCSGBase (const std::string &param_name)
 
std::unique_ptr< CSG::CSGBase > & getCSGBaseByName (const MeshGeneratorName &mesh_generator_name)
 
std::vector< std::unique_ptr< CSG::CSGBase > * > getCSGBases (const std::string &param_name)
 
std::vector< std::unique_ptr< CSG::CSGBase > * > getCSGBasesByName (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)
 
void flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
 
InvalidSolutionID registerInvalidSolutionInternal (const std::string &message, const bool warning) const
 
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.
 
static std::string meshPropertyName (const std::string &data_name, const std::string &prefix)
 

Protected Attributes

const unsigned int _num_sides
 Number of polygon sides.
 
const PolygonSizeStyle _duct_sizes_style
 Thickness of each enclosing duct.
 
std::vector< Real > _duct_sizes
 Size parameters of the duct regions.
 
const std::vector< unsigned int > _duct_intervals
 Number of layers in each enclosing duct.
 
const std::vector< Real > _duct_radial_biases
 Bias values used to induce biasing to radial meshing in duct regions.
 
multiBdryLayerParams _duct_inner_boundary_layer_params
 Widths, fractions, radial sectors and growth factors of the inner boundary layers of the duct regions.
 
multiBdryLayerParams _duct_outer_boundary_layer_params
 Widths, fractions, radial sectors and growth factors of the inner boundary layers of the duct regions.
 
const std::vector< subdomain_id_type > _duct_block_ids
 Subdomain IDs of the duct regions.
 
const std::vector< SubdomainName > _duct_block_names
 Subdomain Names of the duct regions.
 
const bool _has_rings
 Whether the generated mesh contains ring regions.
 
const bool _has_ducts
 Whether the generated mesh contains duct regions.
 
const PolygonSizeStyle _polygon_size_style
 Type of polygon size parameter.
 
const Real _polygon_size
 Polygon size parameter.
 
const std::vector< unsigned int > _num_sectors_per_side
 Mesh sector number of each polygon side.
 
const unsigned int _background_intervals
 Numbers of radial intervals of the background regions.
 
const Real _background_radial_bias
 Bias value used to induce biasing to radial meshing in background region.
 
singleBdryLayerParams _background_inner_boundary_layer_params
 Width, fraction, radiation sectors and growth factor of the inner boundary layer of the background region.
 
singleBdryLayerParams _background_outer_boundary_layer_params
 Width, fraction, radiation sectors and growth factor of the outer boundary layer of the background region.
 
std::vector< subdomain_id_type > _background_block_ids
 Subdomain IDs of the background regions.
 
std::vector< SubdomainName > _background_block_names
 Subdomain Names of the background regions.
 
const bool _uniform_mesh_on_sides
 Whether the nodes on the external boundary needs to be uniformly distributed.
 
const bool _quad_center_elements
 Whether the central elements need to be QUAD4.
 
const Real _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)
 
const unsigned int _smoothing_max_it
 Maximum smooth iteration number.
 
const std::vector< unsigned int > _sides_to_adapt
 Indices of the hexagon sides that need to adapt.
 
std::vector< std::unique_ptr< MeshBase > * > _input_ptrs
 Pointers to input mesh pointers.
 
bool _is_general_polygon
 MeshMetaData: whether this produced mesh is a general polygon (or a hexagon)
 
dof_id_type & _node_id_background_meta
 MeshMetaData: maximum node id of the background region.
 
bool & _is_control_drum_meta
 MeshMetaData: whether this produced mesh is a control drum.
 
Real _pitch
 Pitch size of the produced polygon.
 
std::vector< std::vector< Real > > _azimuthal_angles_array
 Azimuthal angles of all radial nodes for volume preservation.
 
const std::vector< Real > _ring_radii
 Radii of concentric circles.
 
const std::vector< unsigned int > _ring_intervals
 Number of rings in each circle or in the enclosing square.
 
const std::vector< Real > _ring_radial_biases
 Bias values used to induce biasing to radial meshing in ring regions.
 
multiBdryLayerParams _ring_inner_boundary_layer_params
 Widths, fractions, radial sectors and growth factors of the inner boundary layers of the ring regions.
 
multiBdryLayerParams _ring_outer_boundary_layer_params
 Widths, fractions, radial sectors and growth factors of the outer boundary layers of the ring regions.
 
std::vector< subdomain_id_type > _ring_block_ids
 Subdomain IDs of the ring regions.
 
std::vector< SubdomainName > _ring_block_names
 Subdomain Names of the ring regions.
 
const bool _preserve_volumes
 Volume preserving function is optional.
 
const subdomain_id_type _block_id_shift
 Shift in default subdomain IDs to avert potential conflicts with other meshes.
 
const bool _create_inward_interface_boundaries
 Whether inward interface boundaries are created.
 
const bool _create_outward_interface_boundaries
 Whether outward interface boundaries are created.
 
const boundary_id_type _interface_boundary_id_shift
 Shift in default boundary IDs of interfaces to avert potential conflicts.
 
const bool _generate_side_specific_boundaries
 Whether the side-specific external boundaries are generated or not.
 
const boundary_id_type _external_boundary_id
 Boundary ID of the mesh's external boundary.
 
const BoundaryName _external_boundary_name
 Boundary Name of the mesh's external boundary.
 
const std::vector< std::string > _inward_interface_boundary_names
 Boundary Names of the mesh's inward interface boundaries.
 
const std::vector< std::string > _outward_interface_boundary_names
 Boundary Names of the mesh's outward interface boundaries.
 
TRI_ELEM_TYPE _tri_elem_type
 Type of triangular elements to be generated.
 
QUAD_ELEM_TYPE _quad_elem_type
 Type of quadrilateral elements to be generated.
 
unsigned short _order
 Order of the elements to be generated.
 
MooseMesh *const _mesh
 
const bool & _enabled
 
MooseApp & _app
 
Factory & _factory
 
ActionFactory & _action_factory
 
const std::string & _type
 
const std::string & _name
 
const InputParameters & _pars
 
const Parallel::Communicator & _communicator
 

Private Member Functions

virtual std::string meshPropertyPrefix (const std::string &) const override final
 
void checkGetMesh (const MeshGeneratorName &mesh_generator_name, const std::string &param_name) const
 
const MeshGeneratorName * getMeshGeneratorNameFromParam (const std::string &param_name, const bool allow_invalid) const
 
const std::vector< MeshGeneratorName > & getMeshGeneratorNamesFromParam (const std::string &param_name) const
 
RestartableDataValue & setMeshPropertyHelper (const std::string &data_name)
 
const RestartableDataValue & getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const
 
void mooseErrorInternal (Args &&... args) const
 

Static Private Member Functions

static const hit::Node * getHitNode (const InputParameters &params)
 
static std::string messagePrefix (const InputParameters &params, const bool hit_prefix)
 

Private Attributes

std::set< MeshGeneratorName > _requested_mesh_generators
 
std::set< MeshGeneratorName > _requested_mesh_generators_for_sub
 
std::vector< std::pair< std::string, std::unique_ptr< MeshBase > * > > _requested_meshes
 
std::vector< std::pair< std::string, std::unique_ptr< CSG::CSGBase > * > > _requested_csg_bases
 
std::unique_ptr< MeshBase > _null_mesh
 
std::unique_ptr< CSG::CSGBase > _null_csg_base
 
std::set< const MeshGenerator *, Comparator > _parent_mesh_generators
 
std::set< const MeshGenerator *, Comparator > _child_mesh_generators
 
std::set< const MeshGenerator *, Comparator > _sub_mesh_generators
 
std::set< std::string > _null_mesh_names
 
const std::string & _save_with_name
 
const bool _data_only
 
const ParallelParamObject & _parent
 
const MooseBase & _si_moose_base
 
const FEProblemBase * _si_problem
 
MooseApp & _meta_data_app
 
const MooseObject *const _meta_data_object
 

Detailed Description

This PolygonConcentricCircleMeshGenerator object is designed to mesh a polygon geometry with optional rings centered inside.

Definition at line 18 of file PolygonConcentricCircleMeshGenerator.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.

76 {
77 HEXAGON_NUM_SIDES = 6,
78 SQUARE_NUM_SIDES = 4
79 };

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

67 {
68 OUTER_SIDESET_ID = 10000,
69 OUTER_SIDESET_ID_ALT = 15000,
70 SLICE_BEGIN = 30000,
71 SLICE_END = 31000,
72 SLICE_ALT = 30500
73 };

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

61 {
62 PERIPHERAL_ID_SHIFT = 1000,
63 TRANSITION_LAYER_DEFAULT = 10000
64 };

◆ MESH_TYPE

enum PolygonMeshGeneratorBase::MESH_TYPE
inherited
Enumerator
CORNER_MESH 
BOUNDARY_MESH 
INNER_MESH 

Definition at line 47 of file PolygonMeshGeneratorBase.h.

48 {
49 CORNER_MESH = 1,
50 BOUNDARY_MESH = 2,
51 INNER_MESH = 3
52 };

◆ PolygonSizeStyle

enum class PolygonMeshGeneratorBase::PolygonSizeStyle
stronginherited

An enum class for style of input polygon size.

Enumerator
apothem 
radius 

Definition at line 41 of file PolygonMeshGeneratorBase.h.

42 {
43 apothem,
44 radius
45 };

◆ QUAD_ELEM_TYPE

enum class PolygonMeshGeneratorBase::QUAD_ELEM_TYPE
stronginherited
Enumerator
QUAD4 
QUAD8 
QUAD9 

Definition at line 88 of file PolygonMeshGeneratorBase.h.

89 {
90 QUAD4,
91 QUAD8,
92 QUAD9
93 };

◆ RETURN_TYPE

enum PolygonMeshGeneratorBase::RETURN_TYPE
inherited
Enumerator
ANGLE_DEGREE 
ANGLE_TANGENT 

Definition at line 54 of file PolygonMeshGeneratorBase.h.

55 {
56 ANGLE_DEGREE = 1,
57 ANGLE_TANGENT = 2
58 };

◆ TRI_ELEM_TYPE

enum class PolygonMeshGeneratorBase::TRI_ELEM_TYPE
stronginherited
Enumerator
TRI3 
TRI6 
TRI7 

Definition at line 81 of file PolygonMeshGeneratorBase.h.

82 {
83 TRI3,
84 TRI6,
85 TRI7
86 };

Constructor & Destructor Documentation

◆ PolygonConcentricCircleMeshGenerator()

PolygonConcentricCircleMeshGenerator::PolygonConcentricCircleMeshGenerator ( const InputParameters &  parameters)

Definition at line 36 of file PolygonConcentricCircleMeshGenerator.C.

38 : PolygonConcentricCircleMeshGeneratorBase(parameters)
39{
40 _is_general_polygon = true;
41 if (_quad_center_elements && (_num_sectors_per_side.front() != _num_sectors_per_side.back()))
42 paramError("quad_center_elements",
43 "This parameter must be false if different side sector numbers are set.");
44}
MeshGenerator::parameters
const InputParameters & parameters() const
MeshGenerator::paramError
void paramError(const std::string &param, Args... args) const
PolygonConcentricCircleMeshGeneratorBase
This PolygonConcentricCircleMeshGeneratorBase object is a base class to be inherited for polygon mesh...
Definition PolygonConcentricCircleMeshGeneratorBase.h:19
PolygonConcentricCircleMeshGeneratorBase::_quad_center_elements
const bool _quad_center_elements
Whether the central elements need to be QUAD4.
Definition PolygonConcentricCircleMeshGeneratorBase.h:71
PolygonConcentricCircleMeshGeneratorBase::_is_general_polygon
bool _is_general_polygon
MeshMetaData: whether this produced mesh is a general polygon (or a hexagon)
Definition PolygonConcentricCircleMeshGeneratorBase.h:81
PolygonConcentricCircleMeshGeneratorBase::_num_sectors_per_side
const std::vector< unsigned int > _num_sectors_per_side
Mesh sector number of each polygon side.
Definition PolygonConcentricCircleMeshGeneratorBase.h:55

Member Function Documentation

◆ addRingAndSectorIDParams()

void PolygonMeshGeneratorBase::addRingAndSectorIDParams ( InputParameters &  params)
staticprotectedinherited

Add InputParameters which are used by ring and sector IDs.

Parameters
paramsInputParameters to be modified with the added params

Definition at line 1598 of file PolygonMeshGeneratorBase.C.

1599{
1600 params.addParam<std::string>("sector_id_name",
1601 "Name of integer (reporting) ID for sector regions to use the "
1602 "reporting ID for azimuthal sector regions of ring geometry block.");
1603 params.addParam<std::string>("ring_id_name",
1604 "Name of integer (reporting) ID for ring regions to use the "
1605 "reporting ID for annular regions of ring geometry block.");
1606 MooseEnum ring_id_option("block_wise ring_wise", "block_wise");
1607 params.addParam<MooseEnum>(
1608 "ring_id_assign_type", ring_id_option, "Type of ring ID assignment: block_wise or ring_wise");
1609 params.addParamNamesToGroup("sector_id_name ring_id_name ring_id_assign_type", "Ring/Sector IDs");
1610}
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)

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

◆ 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_meshmesh to be adjusted.
boundary_quad_elem_typeboundary quad element type.

Definition at line 1253 of file PolygonMeshGeneratorBase.C.

1255{
1256 const auto side_list = out_mesh.get_boundary_info().build_side_list();
1257
1258 // select out elements on outer boundary
1259 // std::set used to filter duplicate elem_ids
1260 std::set<dof_id_type> elem_set;
1261 for (auto side_item : side_list)
1262 {
1263 boundary_id_type boundary_id = std::get<2>(side_item);
1264 dof_id_type elem_id = std::get<0>(side_item);
1265
1266 if (boundary_id == OUTER_SIDESET_ID)
1267 elem_set.insert(elem_id);
1268 }
1269
1270 // adjust nodes for outer boundary elements
1271 for (const auto elem_id : elem_set)
1272 {
1273 Elem * elem = out_mesh.elem_ptr(elem_id);
1274
1275 // adjust right side mid-edge node
1276 Point pt_5 = (elem->point(1) + elem->point(2)) / 2.0;
1277 out_mesh.add_point(pt_5, elem->node_ptr(5)->id());
1278
1279 // adjust left side mid-edge node
1280 Point pt_7 = (elem->point(0) + elem->point(3)) / 2.0;
1281 out_mesh.add_point(pt_7, elem->node_ptr(7)->id());
1282
1283 // adjust central node when using QUAD9
1284 if (boundary_quad_elem_type == QUAD_ELEM_TYPE::QUAD9)
1285 {
1286 Point pt_8 = elem->true_centroid();
1287 out_mesh.add_point(pt_8, elem->node_ptr(8)->id());
1288 }
1289 }
1290}
libMesh::BoundaryInfo::build_side_list
std::vector< BCTuple > build_side_list(BCTupleSortBy sort_by=BCTupleSortBy::ELEM_ID) const
libMesh::Node::id
dof_id_type id() const
libMesh::Elem::point
const Point & point(const unsigned int i) const
libMesh::Elem::true_centroid
virtual Point true_centroid() const
libMesh::Elem::node_ptr
const Node * node_ptr(const unsigned int i) const
libMesh::MeshBase::get_boundary_info
const BoundaryInfo & get_boundary_info() const
libMesh::MeshBase::add_point
virtual Node * add_point(const Point &p, const dof_id_type id=DofObject::invalid_id, const processor_id_type proc_id=DofObject::invalid_processor_id)=0
libMesh::MeshBase::elem_ptr
virtual const Elem * elem_ptr(const dof_id_type i) const=0
libMesh::boundary_id_type
int8_t boundary_id_type
libMesh::dof_id_type
uint8_t dof_id_type

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

◆ assignBlockIdsNames()

void ConcentricCircleGeneratorBase::assignBlockIdsNames ( ReplicatedMesh &  mesh,
std::vector< subdomain_id_type > &  block_ids_old,
std::vector< subdomain_id_type > &  block_ids_new,
std::vector< SubdomainName > &  block_names,
const std::string &  generator_name 
) const
protectedinherited

Assign block IDs and names to the mesh if applicable.

Parameters
meshMesh to which the block IDs and names are assigned
block_ids_oldold block ids that are assigned by default
block_ids_newnew block ids that are user-defined
block_namesblock names that are user-defined
generator_nameclass name of the mesh generator

Definition at line 224 of file ConcentricCircleGeneratorBase.C.

229{
230 if (block_ids_old.size() != block_ids_new.size() || block_ids_old.size() != block_names.size())
231 mooseError("In ",
232 generator_name,
233 " ",
234 _name,
235 ": block_ids_old, block_ids_new and block_names must have the same size.");
236
237 for (auto it = block_names.begin(); it != block_names.end() - 1; it++)
238 {
239 auto it_tmp = std::find(block_names.begin(), it + 1, *(it + 1));
240 if (it_tmp != it + 1 && block_ids_new[std::distance(block_names.begin(), it + 1)] !=
241 block_ids_new[std::distance(block_names.begin(), it_tmp)])
242 mooseError("In ",
243 generator_name,
244 " ",
245 _name,
246 ": blocks with different ids cannot have the same block name.");
247 }
248 for (const auto & elem : mesh.element_ptr_range())
249 for (unsigned i = 0; i < block_ids_old.size(); ++i)
250 if (elem->subdomain_id() == block_ids_old[i])
251 {
252 elem->subdomain_id() = block_ids_new[i];
253 break;
254 }
255 for (unsigned i = 0; i < block_ids_new.size(); ++i)
256 mesh.set_subdomain_name(block_ids_new[i], block_names[i]);
257}
for
for(PetscInt i=0;i< nvars;++i)
MeshGenerator::mooseError
void mooseError(Args &&... args) const
MeshGenerator::_name
const std::string & _name
mesh
MeshBase & mesh

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

◆ assignInterfaceBoundaryNames()

void ConcentricCircleGeneratorBase::assignInterfaceBoundaryNames ( ReplicatedMesh &  mesh) const
protectedinherited

Assign interface boundary names to the mesh if applicable.

Parameters
meshMesh to which the interface boundary names are assigned

Definition at line 199 of file ConcentricCircleGeneratorBase.C.

200{
201 if (!_inward_interface_boundary_names.empty())
202 {
203 for (unsigned int i = 0; i < _inward_interface_boundary_names.size(); i++)
204 {
205 mesh.get_boundary_info().sideset_name(i * 2 + 2 + _interface_boundary_id_shift) =
206 _inward_interface_boundary_names[i];
207 mesh.get_boundary_info().nodeset_name(i * 2 + 2 + _interface_boundary_id_shift) =
208 _inward_interface_boundary_names[i];
209 }
210 }
211 if (!_outward_interface_boundary_names.empty())
212 {
213 for (unsigned int i = 0; i < _outward_interface_boundary_names.size(); i++)
214 {
215 mesh.get_boundary_info().sideset_name(i * 2 + 1 + _interface_boundary_id_shift) =
216 _outward_interface_boundary_names[i];
217 mesh.get_boundary_info().nodeset_name(i * 2 + 1 + _interface_boundary_id_shift) =
218 _outward_interface_boundary_names[i];
219 }
220 }
221}
ConcentricCircleGeneratorBase::_interface_boundary_id_shift
const boundary_id_type _interface_boundary_id_shift
Shift in default boundary IDs of interfaces to avert potential conflicts.
Definition ConcentricCircleGeneratorBase.h:51
ConcentricCircleGeneratorBase::_inward_interface_boundary_names
const std::vector< std::string > _inward_interface_boundary_names
Boundary Names of the mesh's inward interface boundaries.
Definition ConcentricCircleGeneratorBase.h:59
ConcentricCircleGeneratorBase::_outward_interface_boundary_names
const std::vector< std::string > _outward_interface_boundary_names
Boundary Names of the mesh's outward interface boundaries.
Definition ConcentricCircleGeneratorBase.h:61

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

◆ azimuthalAnglesCollector() [1/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
meshinput mesh whose boundary node azimuthal angles need to be collected
lower_azilower boundary of the azimuthal angles to be collected
upper_aziupper boundary of the azimuthal angles to be collected
return_typewhether angle values or tangent values are returned
num_sidesnumber of sides of the input mesh (only used if return type is ANGLE_TANGENT)
bidid of the boundary of which the nodes' azimuthal angles are collected
calculate_originwhether the mesh origin is calculated based on the centroid position
input_origin_xprecalculated mesh origin coordinate x
input_origin_yprecalculated mesh origin coordinate y
toltolerence 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

Definition at line 1497 of file PolygonMeshGeneratorBase.C.

1507{
1508 std::vector<Point> boundary_points;
1509 return azimuthalAnglesCollector(mesh,
1510 boundary_points,
1511 lower_azi,
1512 upper_azi,
1513 return_type,
1514 num_sides,
1515 bid,
1516 calculate_origin,
1517 input_origin_x,
1518 input_origin_y,
1519 tol);
1520}
tol
const double tol
Definition EquilibriumConstantFitTest.C:16
PolygonMeshGeneratorBase::azimuthalAnglesCollector
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.
Definition PolygonMeshGeneratorBase.C:1419

◆ azimuthalAnglesCollector() [2/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
meshinput mesh whose boundary node azimuthal angles need to be collected
boundary_pointsreference vector to contain the Points corresponding to the collected azimuthal angles
lower_azilower boundary of the azimuthal angles to be collected
upper_aziupper boundary of the azimuthal angles to be collected
return_typewhether angle values or tangent values are returned
num_sidesnumber of sides of the input mesh (only used if return type is ANGLE_TANGENT)
bidid of the boundary of which the nodes' azimuthal angles are collected
calculate_originwhether the mesh origin is calculated based on the centroid position
input_origin_xprecalculated mesh origin coordinate x
input_origin_yprecalculated mesh origin coordinate y
toltolerance 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

Definition at line 1419 of file PolygonMeshGeneratorBase.C.

1430{
1431 std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> side_list =
1432 mesh.get_boundary_info().build_side_list();
1433 mesh.get_boundary_info().build_node_list_from_side_list();
1434 std::vector<std::tuple<dof_id_type, boundary_id_type>> node_list =
1435 mesh.get_boundary_info().build_node_list();
1436
1437 std::vector<Real> bd_x_list;
1438 std::vector<Real> bd_y_list;
1439 std::vector<Point> bd_p_list;
1440 Real origin_x = 0.0;
1441 Real origin_y = 0.0;
1442 Real tmp_azi;
1443 const Real mid_azi = lower_azi <= upper_azi ? (lower_azi + upper_azi) / 2.0
1444 : (lower_azi + upper_azi + 360.0) / 2.0;
1445 for (unsigned int i = 0; i < node_list.size(); ++i)
1446 if (std::get<1>(node_list[i]) == bid)
1447 {
1448 bd_x_list.push_back((mesh.node_ref(std::get<0>(node_list[i])))(0));
1449 bd_y_list.push_back((mesh.node_ref(std::get<0>(node_list[i])))(1));
1450 bd_p_list.push_back((mesh.node_ref(std::get<0>(node_list[i]))));
1451 }
1452
1453 if (calculate_origin)
1454 {
1455 const Point origin_pt = MooseMeshUtils::meshCentroidCalculator(mesh);
1456 origin_x = origin_pt(0);
1457 origin_y = origin_pt(1);
1458 }
1459 else
1460 {
1461 origin_x = input_origin_x;
1462 origin_y = input_origin_y;
1463 }
1464
1465 std::vector<std::pair<Real, Point>> azi_point_pairs;
1466
1467 for (unsigned int i = 0; i < bd_x_list.size(); ++i)
1468 {
1469 tmp_azi = atan2(bd_y_list[i] - origin_y, bd_x_list[i] - origin_x) * 180.0 / M_PI;
1470 if ((lower_azi <= upper_azi && (tmp_azi >= lower_azi - tol && tmp_azi <= upper_azi + tol)) ||
1471 (lower_azi > upper_azi && (tmp_azi >= lower_azi - tol || tmp_azi <= upper_azi + tol)))
1472 {
1473 azi_point_pairs.push_back(
1474 std::make_pair(return_type == ANGLE_DEGREE
1475 ? (tmp_azi - mid_azi)
1476 : (1.0 + std::cos(M_PI / num_sides) / std::sin(M_PI / num_sides) *
1477 std::tan((tmp_azi - mid_azi) / 180.0 * M_PI)),
1478 bd_p_list[i]));
1479 }
1480 }
1481 std::sort(azi_point_pairs.begin(), azi_point_pairs.end());
1482
1483 std::vector<Real> azimuthal_output;
1484 for (auto it = std::make_move_iterator(azi_point_pairs.begin()),
1485 end = std::make_move_iterator(azi_point_pairs.end());
1486 it != end;
1487 it++)
1488 {
1489 azimuthal_output.push_back(std::move(it->first));
1490 boundary_points.push_back(std::move(it->second));
1491 }
1492
1493 return azimuthal_output;
1494}
libMesh::BoundaryInfo::build_node_list
std::vector< NodeBCTuple > build_node_list(NodeBCTupleSortBy sort_by=NodeBCTupleSortBy::NODE_ID) const
libMesh::BoundaryInfo::build_node_list_from_side_list
void build_node_list_from_side_list(const std::set< boundary_id_type > &sideset_list={})
libMesh::MeshBase::node_ref
virtual const Node & node_ref(const dof_id_type i) const
CompileTimeDerivatives::sin
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sin(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tan
CompileTimeDerivatives::cos
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template cos(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cos
MooseMeshUtils::meshCentroidCalculator
Point meshCentroidCalculator(const MeshBase &mesh)
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

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

◆ 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
meshinput mesh to add the nodes onto
num_sectors_per_sidenumber of azimuthal intervals
background_intervalsnumber of radial intervals of the background region
biased_termsnormalized spacing values used for radial meshing biasing in background region
background_corner_distancecenter to duct (innermost duct) corner distance
background_corner_radial_interval_lengthradial interval distance
corner_p[2][2]array contains the coordinates of the corner positions
corner_to_cornerdiameter of the circumscribed circle of the polygon
background_inradius of the inner boundary of the background region
azimuthal_tangentvector 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.

730{
731 unsigned int angle_number =
732 azimuthal_tangent.size() == 0 ? num_sectors_per_side : (azimuthal_tangent.size() - 1);
733 for (unsigned int k = 0; k < (background_intervals); k++)
734 {
735 const Real background_corner_p_x =
736 background_corner_distance / (0.5 * corner_to_corner) * corner_p[0][0] *
737 (background_in +
738 biased_terms[k] * background_intervals * background_corner_radial_interval_length) /
739 background_corner_distance;
740 const Real background_corner_p_y =
741 background_corner_distance / (0.5 * corner_to_corner) * corner_p[0][1] *
742 (background_in +
743 biased_terms[k] * background_intervals * background_corner_radial_interval_length) /
744 background_corner_distance;
745
746 // background_corner_p(s) are the points in the background region, on the bins towards the six
747 // corners, at different intervals
748 mesh.add_point(Point(background_corner_p_x, background_corner_p_y, 0.0));
749
750 for (unsigned int j = 1; j <= angle_number; j++)
751 {
752 const Real cell_boundary_p_x =
753 background_corner_distance / (0.5 * corner_to_corner) *
754 (corner_p[0][0] + (corner_p[1][0] - corner_p[0][0]) *
755 (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
756 : (azimuthal_tangent[j] / 2.0)));
757 const Real cell_boundary_p_y =
758 background_corner_distance / (0.5 * corner_to_corner) *
759 (corner_p[0][1] + (corner_p[1][1] - corner_p[0][1]) *
760 (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
761 : (azimuthal_tangent[j] / 2.0)));
762 // cell_boundary_p(s) are the points on the cell's six boundaries (flat sides) at different
763 // azimuthal angles
764 const Real pin_boundary_p_x =
765 cell_boundary_p_x * background_in /
766 std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
767 const Real pin_boundary_p_y =
768 cell_boundary_p_y * background_in /
769 std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
770 // pin_boundary_p(s) are the points on pin boundary (outside ring) at different azimuthal
771 // angles
772 const Real background_radial_interval =
773 std::sqrt(Utility::pow<2>(cell_boundary_p_x - pin_boundary_p_x) +
774 Utility::pow<2>(cell_boundary_p_y - pin_boundary_p_y)) /
775 background_intervals;
776 const Real background_azimuthal_p_x =
777 cell_boundary_p_x *
778 (background_in + biased_terms[k] * background_intervals * background_radial_interval) /
779 std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
780 const Real background_azimuthal_p_y =
781 cell_boundary_p_y *
782 (background_in + biased_terms[k] * background_intervals * background_radial_interval) /
783 std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
784 // background_azimuthal_p are the points on the bins towards different azimuthal angles, at
785 // different intervals; excluding the ones produced by background_corner_p
786 mesh.add_point(Point(background_azimuthal_p_x, background_azimuthal_p_y, 0.0));
787 }
788 }
789}

Referenced by PolygonMeshGeneratorBase::buildSlice().

◆ biasTermsCalculator() [1/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_biasbias growth factor of the elements within the main region of the block
intervalsradial interval number of the main region of the block
inner_boundary_layer_paramswidth, radial fraction, radial sector, and growth factor of the inner boundary layer
outer_boundary_layer_paramswidth, 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.

1550{
1551 // To get biased indices:
1552 // If no bias is involved, namely bias factor = 1.0, the increment in indices is uniform.
1553 // Thus, (i + 1) is used to get such linearly increasing indices.
1554 // If a non-trivial bias factor q is used, the increment in the indices is geometric
1555 // progression. So, if first (i = 0) increment is 1.0, second (i = 1) is q, third (i = 2) is
1556 // q^2,..., last or n_interval'th is q^(n_interval - 1). Then, the summation of the first (i +
1557 // 1) increments over the summation of all n_interval increments is the (i + 1)th index The
1558 // summation of the first (i + 1) increments is (1.0 - q^(i + 1)) / (1 - q); The summation of
1559 // all n_interval increments is (1.0 - q^n_interval) / (1 - q); Thus, the index is (1.0 - q^(i +
1560 // 1)) / (1.0 - q^n_interval)
1561 // This approach is used by inner boundary layer, main region, outer boundary layer separately.
1562
1563 std::vector<Real> biased_terms;
1564 for (unsigned int i = 0; i < inner_boundary_layer_params.intervals; i++)
1565 biased_terms.push_back(
1566 MooseUtils::absoluteFuzzyEqual(inner_boundary_layer_params.bias, 1.0)
1567 ? ((Real)(i + 1) * inner_boundary_layer_params.fraction /
1568 (Real)inner_boundary_layer_params.intervals)
1569 : ((1.0 - std::pow(inner_boundary_layer_params.bias, (Real)(i + 1))) /
1570 (1.0 - std::pow(inner_boundary_layer_params.bias,
1571 (Real)(inner_boundary_layer_params.intervals))) *
1572 inner_boundary_layer_params.fraction));
1573 for (unsigned int i = 0; i < intervals; i++)
1574 biased_terms.push_back(inner_boundary_layer_params.fraction +
1575 (MooseUtils::absoluteFuzzyEqual(radial_bias, 1.0)
1576 ? ((Real)(i + 1) *
1577 (1.0 - inner_boundary_layer_params.fraction -
1578 outer_boundary_layer_params.fraction) /
1579 (Real)intervals)
1580 : ((1.0 - std::pow(radial_bias, (Real)(i + 1))) /
1581 (1.0 - std::pow(radial_bias, (Real)(intervals))) *
1582 (1.0 - inner_boundary_layer_params.fraction -
1583 outer_boundary_layer_params.fraction))));
1584 for (unsigned int i = 0; i < outer_boundary_layer_params.intervals; i++)
1585 biased_terms.push_back(
1586 1.0 - outer_boundary_layer_params.fraction +
1587 (MooseUtils::absoluteFuzzyEqual(outer_boundary_layer_params.bias, 1.0)
1588 ? ((Real)(i + 1) * outer_boundary_layer_params.fraction /
1589 (Real)outer_boundary_layer_params.intervals)
1590 : ((1.0 - std::pow(outer_boundary_layer_params.bias, (Real)(i + 1))) /
1591 (1.0 - std::pow(outer_boundary_layer_params.bias,
1592 (Real)(outer_boundary_layer_params.intervals))) *
1593 outer_boundary_layer_params.fraction)));
1594 return biased_terms;
1595}
pow
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)
Definition ExpressionBuilder.h:690

◆ biasTermsCalculator() [2/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_biasesbias growth factors of the elements within the main regions of the blocks
intervalsradial interval numbers of the main regions of the blocks
inner_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the inner boundary layers
outer_boundary_layer_paramswidths, 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.

1528{
1529 std::vector<std::vector<Real>> bias_terms_vec;
1530 for (unsigned int i = 0; i < radial_biases.size(); i++)
1531 bias_terms_vec.push_back(biasTermsCalculator(radial_biases[i],
1532 intervals[i],
1533 {0.0,
1534 inner_boundary_layer_params.fractions[i],
1535 inner_boundary_layer_params.intervals[i],
1536 inner_boundary_layer_params.biases[i]},
1537 {0.0,
1538 outer_boundary_layer_params.fractions[i],
1539 outer_boundary_layer_params.intervals[i],
1540 outer_boundary_layer_params.biases[i]}));
1541 return bias_terms_vec;
1542}
PolygonMeshGeneratorBase::biasTermsCalculator
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.
Definition PolygonMeshGeneratorBase.C:1523

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

◆ 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_radiiradii of the ring regions
ring_layersnumbers of radial intervals of the ring regions
ring_radial_biasesvalues used for radial meshing biasing in ring regions
ring_inner_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the ring regions
ring_outer_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the ring regions
ducts_center_distdistance parameters of the duct regions
ducts_layersnumbers of radial intervals of the duct regions
duct_radial_biasesvalues used for radial meshing biasing in duct regions
duct_inner_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the duct regions
duct_outer_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the duct regions
primary_side_lengthlength 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_lengthlength of the second side (obtained by clockwise rotating the fist side by azimuthal_angle) that involves the ring center vertex
num_sectors_per_sidenumber of azimuthal intervals
background_intervalsnumber of radial intervals of the background region
background_radial_biasvalue used for radial meshing biasing in background region
background_inner_boundary_layer_paramswidth, radial sectors, and growth factor of the inner boundary layer of the background region
background_outer_boundary_layer_paramswidth, radial sectors, and growth factor of the outer boundary layer of the background region
node_id_background_metapointer to the first node's id of the background region
azimuthal_anglethe angle defined by the primary and secondary sides
azimuthal_tangentvector of tangent values of the azimuthal angles as reference for adaptive boundary matching
side_indexindex of the polygon side
quad_center_elementswhether the central region contains quad elements or not
center_quad_factorA 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_angleazimuthal angle of the primary side
generate_side_specific_boundarieswhether the side-specific external boundaries are generated or not
Returns
a mesh of a general slice

Definition at line 42 of file PolygonMeshGeneratorBase.C.

68{
69 const Real virtual_pitch = 2.0 * primary_side_length * cos(azimuthal_angle / 360.0 * M_PI);
70 const Real virtual_side_number = 360.0 / azimuthal_angle;
71 const Real pitch_scale_factor = secondary_side_length / primary_side_length;
72
73 auto mesh = buildSlice(ring_radii,
74 ring_layers,
75 ring_radial_biases,
76 ring_inner_boundary_layer_params,
77 ring_outer_boundary_layer_params,
78 ducts_center_dist,
79 ducts_layers,
80 duct_radial_biases,
81 duct_inner_boundary_layer_params,
82 duct_outer_boundary_layer_params,
83 virtual_pitch,
84 num_sectors_per_side,
85 background_intervals,
86 background_radial_bias,
87 background_inner_boundary_layer_params,
88 background_outer_boundary_layer_params,
89 node_id_background_meta,
90 virtual_side_number,
91 side_index,
92 azimuthal_tangent,
93 0,
94 quad_center_elements,
95 center_quad_factor,
96 false,
97 true,
98 0,
99 pitch_scale_factor,
100 generate_side_specific_boundaries);
101 MeshTools::Modification::rotate(*mesh, rotation_angle, 0, 0);
102 return mesh;
103}
PolygonMeshGeneratorBase::buildSlice
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 buildSimpl...
Definition PolygonMeshGeneratorBase.C:170
libMesh::MeshTools::Modification::rotate
RealTensorValue rotate(MeshBase &mesh, const Real phi, const Real theta=0., const Real psi=0.)

Referenced by TriPinHexAssemblyGenerator::buildSinglePinSection().

◆ 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
meshinput mesh to create the peripheral area mesh onto
num_sectors_per_sidenumber of azimuthal intervals
peripheral_invervalsnumber of radial intervals of the peripheral region
position_innerkey positions of the inner side of the peripheral region
d_position_outerkey inremental positions of the outer side of the peripheral region
id_shiftshift of subdomain id of the peripheral region
create_inward_interface_boundarieswhether inward interface boundary sidesets are created
create_outward_interface_boundarieswhether outward interface boundary sidesets are created
quad_elem_typetype 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.

1162{
1163 auto mesh = buildReplicatedMesh(2);
1164 std::pair<Real, Real> positions_p;
1165
1166 // generate node positions
1167 for (unsigned int i = 0; i <= peripheral_invervals; i++)
1168 {
1169 for (unsigned int j = 0; j <= num_sectors_per_side / 2; j++)
1170 {
1171 positions_p = pointInterpolate(positions_inner[0].first,
1172 positions_inner[0].second,
1173 d_positions_outer[0].first,
1174 d_positions_outer[0].second,
1175 positions_inner[1].first,
1176 positions_inner[1].second,
1177 d_positions_outer[1].first,
1178 d_positions_outer[1].second,
1179 i,
1180 j,
1181 num_sectors_per_side,
1182 peripheral_invervals);
1183 mesh->add_point(Point(positions_p.first, positions_p.second, 0.0));
1184 }
1185 for (unsigned int j = 1; j <= num_sectors_per_side / 2; j++)
1186 {
1187 positions_p = pointInterpolate(positions_inner[1].first,
1188 positions_inner[1].second,
1189 d_positions_outer[1].first,
1190 d_positions_outer[1].second,
1191 positions_inner[2].first,
1192 positions_inner[2].second,
1193 d_positions_outer[2].first,
1194 d_positions_outer[2].second,
1195 i,
1196 j,
1197 num_sectors_per_side,
1198 peripheral_invervals);
1199 mesh->add_point(Point(positions_p.first, positions_p.second, 0.0));
1200 }
1201 }
1202
1203 // element definition
1204 BoundaryInfo & boundary_info = mesh->get_boundary_info();
1205
1206 for (unsigned int i = 0; i < peripheral_invervals; i++)
1207 {
1208 for (unsigned int j = 0; j < num_sectors_per_side; j++)
1209 {
1210 std::unique_ptr<Elem> new_elem;
1211
1212 new_elem = std::make_unique<Quad4>();
1213 new_elem->set_node(0, mesh->node_ptr(j + (num_sectors_per_side + 1) * (i)));
1214 new_elem->set_node(1, mesh->node_ptr(j + 1 + (num_sectors_per_side + 1) * (i)));
1215 new_elem->set_node(2, mesh->node_ptr(j + 1 + (num_sectors_per_side + 1) * (i + 1)));
1216 new_elem->set_node(3, mesh->node_ptr(j + (num_sectors_per_side + 1) * (i + 1)));
1217
1218 Elem * elem = mesh->add_elem(std::move(new_elem));
1219
1220 // add subdoamin and boundary IDs
1221 elem->subdomain_id() = PERIPHERAL_ID_SHIFT + id_shift;
1222 if (i == 0)
1223 {
1224 boundary_info.add_side(elem, 0, OUTER_SIDESET_ID);
1225 if (create_inward_interface_boundaries)
1226 boundary_info.add_side(elem, 0, SLICE_ALT + id_shift * 2);
1227 }
1228 if (i == peripheral_invervals - 1)
1229 {
1230 boundary_info.add_side(elem, 2, OUTER_SIDESET_ID);
1231 if (create_outward_interface_boundaries)
1232 boundary_info.add_side(elem, 2, SLICE_ALT + id_shift * 2 + 1);
1233 }
1234 if (j == 0)
1235 boundary_info.add_side(elem, 3, OUTER_SIDESET_ID);
1236 if (j == num_sectors_per_side - 1)
1237 boundary_info.add_side(elem, 1, OUTER_SIDESET_ID);
1238 }
1239 }
1240
1241 // convert element to second order if needed
1242 if (quad_elem_type != QUAD_ELEM_TYPE::QUAD4)
1243 {
1244 // full_ordered 2nd order element --> QUAD9, otherwise QUAD8
1245 const bool full_ordered = (quad_elem_type == QUAD_ELEM_TYPE::QUAD9);
1246 mesh->all_second_order(full_ordered);
1247 }
1248
1249 return mesh;
1250}
MeshGenerator::buildReplicatedMesh
std::unique_ptr< ReplicatedMesh > buildReplicatedMesh(unsigned int dim=libMesh::invalid_uint)
PolygonMeshGeneratorBase::pointInterpolate
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.
Definition PolygonMeshGeneratorBase.C:1293
libMesh::BoundaryInfo::add_side
void add_side(const dof_id_type elem, const unsigned short int side, const boundary_id_type id)
libMesh::Elem::subdomain_id
subdomain_id_type subdomain_id() const
libMesh::MeshBase::node_ptr
virtual const Node * node_ptr(const dof_id_type i) const=0
libMesh::MeshBase::all_second_order
void all_second_order(const bool full_ordered=true)
libMesh::MeshBase::add_elem
virtual Elem * add_elem(Elem *e)=0

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

◆ 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_radiiradii of the ring regions
ring_layersnumbers of radial intervals of the ring regions
ring_radial_biasesvalues used for radial meshing biasing in ring regions
ring_inner_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the ring regions
ring_outer_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the ring regions
ducts_center_distdistance parameters of the duct regions
ducts_layersnumbers of radial intervals of the duct regions
duct_radial_biasesvalues used for radial meshing biasing in duct regions
duct_inner_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the duct regions
duct_outer_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the duct regions
pitchtwice the distance from the ring center vertex to the side defined by the other vertices
num_sectors_per_sidenumber of azimuthal intervals
background_intervalsnumber of radial intervals of the background region
background_radial_biasvalue used for radial meshing biasing in background region
background_inner_boundary_layer_paramswidth, radial sectors, and growth factor of the inner boundary layer of the background region
background_outer_boundary_layer_paramswidth, radial sectors, and growth factor of the outer boundary layer of the background region
node_id_background_metapointer to the first node's id of the background region
side_numbernumber of sides of the polygon
side_indexindex of the polygon side
azimuthal_tangentvector of tangent values of the azimuthal angles as reference for adaptive boundary matching
block_id_shiftshift of the subdomain ids generated by this function
quad_center_elementswhether the central region contrains quad elements or not
center_quad_factorA 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_boundarieswhether inward interface boundary sidesets are created
create_outward_interface_boundarieswhether outward interface boundary sidesets are created
boundary_id_shiftshift of the interface boundary ids
generate_side_specific_boundarieswhether the side-specific external boundaries are generated or not
tri_elem_typetype of the triangular elements to be generated
quad_elem_typetype of the quadrilateral elements to be generated
Returns
a mesh of a polygon slice

Definition at line 106 of file PolygonMeshGeneratorBase.C.

136{
137 return buildSlice(ring_radii,
138 ring_layers,
139 ring_radial_biases,
140 ring_inner_boundary_layer_params,
141 ring_outer_boundary_layer_params,
142 ducts_center_dist,
143 ducts_layers,
144 duct_radial_biases,
145 duct_inner_boundary_layer_params,
146 duct_outer_boundary_layer_params,
147 pitch,
148 num_sectors_per_side,
149 background_intervals,
150 background_radial_bias,
151 background_inner_boundary_layer_params,
152 background_outer_boundary_layer_params,
153 node_id_background_meta,
154 side_number,
155 side_index,
156 azimuthal_tangent,
157 block_id_shift,
158 quad_center_elements,
159 center_quad_factor,
160 create_inward_interface_boundaries,
161 create_outward_interface_boundaries,
162 boundary_id_shift,
163 1.0,
164 generate_side_specific_boundaries,
165 tri_elem_type,
166 quad_elem_type);
167}

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ 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_radiiradii of the ring regions
ring_layersnumbers of radial intervals of the ring regions
ring_radial_biasesvalues used for radial meshing biasing in ring regions
ring_inner_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the ring regions
ring_outer_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the ring regions
ducts_center_distdistance parameters of the duct regions
ducts_layersnumbers of radial intervals of the duct regions
duct_radial_biasesvalues used for radial meshing biasing in duct regions
duct_inner_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the inner boundary layer of the duct regions
duct_outer_boundary_layer_paramswidths, radial fractions, radial sectors, and growth factors of the outer boundary layer of the duct regions
pitchtwice of the length of the first side times cosine of the azimuthal angle
num_sectors_per_sidenumber of azimuthal intervals
background_intervalsnumber of radial intervals of the background region
background_radial_biasvalue used for radial meshing biasing in background region
background_inner_boundary_layer_paramswidth, radial sectors, and growth factor of the inner boundary layer of the background region
background_outer_boundary_layer_paramswidth, radial sectors, and growth factor of the outer boundary layer of the background region
node_id_background_metapointer to the first node's id of the background region
virtual_side_number360.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_indexindex of the polygon side
azimuthal_tangentvector of tangent values of the azimuthal angles as reference for adaptive boundary matching
block_id_shiftshift of the subdomain ids generated by this function
quad_center_elementswhether the central region contrains quad elements or not
center_quad_factorA 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_boundarieswhether inward interface boundary sidesets are created
create_outward_interface_boundarieswhether outward interface boundary sidesets are created
boundary_id_shiftshift of the interface boundary ids
pitch_scale_factorthe ratio between the secondary side length to the primary side length.
generate_side_specific_boundarieswhether the side-specific external boundaries are generated or not
tri_elem_typetype of the triangular elements to be generated
quad_elem_typetype of the quadrilateral elements to be generated
Returns
a mesh of a slice

Definition at line 170 of file PolygonMeshGeneratorBase.C.

201{
202 const unsigned short order = quad_elem_type == QUAD_ELEM_TYPE::QUAD4 ? 1 : 2;
203 if (order != (tri_elem_type == TRI_ELEM_TYPE::TRI3 ? 1 : 2))
204 mooseError("In mesh generator ",
205 this->name(),
206 ", an incompatible elements type combination is used when calling "
207 "PolygonMeshGeneratorBase::buildSlice().");
208 // In order to create quadratic elements (i.e., order = 2), we creates nodes with double mesh
209 // density. Thus, the related parameters need to be modified accordingly. A prefix "mod_" is used
210 // to indicate the modified parameters.
211
212 // For ring_layers, modification is to double the number of layers for order = 2
213 std::vector<unsigned int> mod_ring_layers(ring_layers);
214 std::for_each(
215 mod_ring_layers.begin(), mod_ring_layers.end(), [&order](unsigned int & n) { n *= order; });
216 // For ring_radial_biases, modification is to take the square root of the original biases for
217 // order = 2
218 std::vector<Real> mod_ring_radial_biases(ring_radial_biases);
219 std::for_each(mod_ring_radial_biases.begin(),
220 mod_ring_radial_biases.end(),
221 [&order](Real & n) { n = std::pow(n, 1.0 / order); });
222 // ducts_layers is similar to ring_layers
223 std::vector<unsigned int> mod_ducts_layers(ducts_layers);
224 std::for_each(
225 mod_ducts_layers.begin(), mod_ducts_layers.end(), [&order](unsigned int & n) { n *= order; });
226 // duct_radial_biases is similar to ring_radial_biases
227 std::vector<Real> mod_duct_radial_biases(duct_radial_biases);
228 std::for_each(mod_duct_radial_biases.begin(),
229 mod_duct_radial_biases.end(),
230 [&order](Real & n) { n = std::pow(n, 1.0 / order); });
231 // Azimuthal mesh density is also doubled for order = 2
232 const unsigned int mod_num_sectors_per_side = num_sectors_per_side * order;
233 const unsigned int mod_background_intervals = background_intervals * order;
234 // background_radial_bias is similar to ring_radial_biases
235 const Real mod_background_radial_bias = std::pow(background_radial_bias, 1.0 / order);
236 // Perform similar modifications for boundary layer parameters
237 const auto mod_ring_inner_boundary_layer_params =
238 modifiedMultiBdryLayerParamsCreator(ring_inner_boundary_layer_params, order);
239 const auto mod_ring_outer_boundary_layer_params =
240 modifiedMultiBdryLayerParamsCreator(ring_outer_boundary_layer_params, order);
241 const auto mod_duct_inner_boundary_layer_params =
242 modifiedMultiBdryLayerParamsCreator(duct_inner_boundary_layer_params, order);
243 const auto mod_duct_outer_boundary_layer_params =
244 modifiedMultiBdryLayerParamsCreator(duct_outer_boundary_layer_params, order);
245
246 const auto mod_background_inner_boundary_layer_params =
247 modifiedSingleBdryLayerParamsCreator(background_inner_boundary_layer_params, order);
248 const auto mod_background_outer_boundary_layer_params =
249 modifiedSingleBdryLayerParamsCreator(background_outer_boundary_layer_params, order);
250
251 // The distance parameters of the rings and duct need to be modified too as they may be involved
252 // in the boundary layer cases.
253 std::vector<Real> mod_ducts_center_dist(ducts_center_dist);
254 std::vector<Real> mod_ring_radii(ring_radii);
255 bool has_rings(ring_radii.size());
256 bool has_ducts(ducts_center_dist.size());
257 bool has_background(background_intervals);
258 auto mesh = buildReplicatedMesh(2);
259
260 // Calculate biasing terms
261 // background region needs to be split into three parts
262 const auto main_background_bias_terms =
263 biasTermsCalculator(background_radial_bias, background_intervals);
264 const auto inner_background_bias_terms =
265 biasTermsCalculator(background_inner_boundary_layer_params.bias,
266 background_inner_boundary_layer_params.intervals);
267 const auto outer_background_bias_terms =
268 biasTermsCalculator(background_outer_boundary_layer_params.bias,
269 background_outer_boundary_layer_params.intervals);
270 auto rings_bias_terms = biasTermsCalculator(ring_radial_biases,
271 ring_layers,
272 ring_inner_boundary_layer_params,
273 ring_outer_boundary_layer_params);
274 auto duct_bias_terms = biasTermsCalculator(duct_radial_biases,
275 ducts_layers,
276 duct_inner_boundary_layer_params,
277 duct_outer_boundary_layer_params);
278 // Equivalent "mod_" parts
279 const auto mod_main_background_bias_terms =
280 biasTermsCalculator(mod_background_radial_bias, mod_background_intervals);
281 const auto mod_inner_background_bias_terms =
282 biasTermsCalculator(mod_background_inner_boundary_layer_params.bias,
283 mod_background_inner_boundary_layer_params.intervals);
284 const auto mod_outer_background_bias_terms =
285 biasTermsCalculator(mod_background_outer_boundary_layer_params.bias,
286 mod_background_outer_boundary_layer_params.intervals);
287 auto mod_rings_bias_terms = biasTermsCalculator(mod_ring_radial_biases,
288 mod_ring_layers,
289 mod_ring_inner_boundary_layer_params,
290 mod_ring_outer_boundary_layer_params);
291 auto mod_duct_bias_terms = biasTermsCalculator(mod_duct_radial_biases,
292 mod_ducts_layers,
293 mod_duct_inner_boundary_layer_params,
294 mod_duct_outer_boundary_layer_params);
295
296 std::vector<unsigned int> total_ring_layers;
297 for (unsigned int i = 0; i < ring_layers.size(); i++)
298 total_ring_layers.push_back(ring_layers[i] + ring_inner_boundary_layer_params.intervals[i] +
299 ring_outer_boundary_layer_params.intervals[i]);
300
301 if (background_inner_boundary_layer_params.intervals)
302 {
303 total_ring_layers.push_back(background_inner_boundary_layer_params.intervals);
304 rings_bias_terms.push_back(inner_background_bias_terms);
305 ring_radii.push_back((ring_radii.empty() ? 0.0 : ring_radii.back()) +
306 background_inner_boundary_layer_params.width);
307 has_rings = true;
308 }
309 std::vector<unsigned int> mod_total_ring_layers;
310 for (unsigned int i = 0; i < mod_ring_layers.size(); i++)
311 mod_total_ring_layers.push_back(mod_ring_layers[i] +
312 mod_ring_inner_boundary_layer_params.intervals[i] +
313 mod_ring_outer_boundary_layer_params.intervals[i]);
314
315 if (mod_background_inner_boundary_layer_params.intervals)
316 {
317 mod_total_ring_layers.push_back(mod_background_inner_boundary_layer_params.intervals);
318 mod_rings_bias_terms.push_back(mod_inner_background_bias_terms);
319 mod_ring_radii.push_back((mod_ring_radii.empty() ? 0.0 : mod_ring_radii.back()) +
320 mod_background_inner_boundary_layer_params.width);
321 // has_rings should be modified before in the none "mod_" part
322 }
323
324 std::vector<unsigned int> total_ducts_layers;
325 if (background_outer_boundary_layer_params.intervals)
326 {
327 total_ducts_layers.push_back(background_outer_boundary_layer_params.intervals);
328 duct_bias_terms.insert(duct_bias_terms.begin(), outer_background_bias_terms);
329 ducts_center_dist.insert(ducts_center_dist.begin(),
330 (ducts_center_dist.empty()
331 ? pitch / 2.0 / std::cos(M_PI / virtual_side_number)
332 : ducts_center_dist.front()) -
333 background_outer_boundary_layer_params.width);
334 has_ducts = true;
335 }
336 for (unsigned int i = 0; i < ducts_layers.size(); i++)
337 total_ducts_layers.push_back(ducts_layers[i] + duct_inner_boundary_layer_params.intervals[i] +
338 duct_outer_boundary_layer_params.intervals[i]);
339
340 std::vector<unsigned int> mod_total_ducts_layers;
341 if (mod_background_outer_boundary_layer_params.intervals)
342 {
343 mod_total_ducts_layers.push_back(mod_background_outer_boundary_layer_params.intervals);
344 mod_duct_bias_terms.insert(mod_duct_bias_terms.begin(), mod_outer_background_bias_terms);
345 mod_ducts_center_dist.insert(mod_ducts_center_dist.begin(),
346 (mod_ducts_center_dist.empty()
347 ? pitch / 2.0 / std::cos(M_PI / virtual_side_number)
348 : mod_ducts_center_dist.front()) -
349 mod_background_outer_boundary_layer_params.width);
350 // has_ducts should be modified before in the none "mod_" part
351 }
352 for (unsigned int i = 0; i < mod_ducts_layers.size(); i++)
353 mod_total_ducts_layers.push_back(mod_ducts_layers[i] +
354 mod_duct_inner_boundary_layer_params.intervals[i] +
355 mod_duct_outer_boundary_layer_params.intervals[i]);
356
357 unsigned int angle_number = azimuthal_tangent.size() == 0
358 ? num_sectors_per_side
359 : ((azimuthal_tangent.size() - 1) / order);
360 unsigned int mod_angle_number =
361 azimuthal_tangent.size() == 0 ? mod_num_sectors_per_side : (azimuthal_tangent.size() - 1);
362
363 // Geometries
364 const Real corner_to_corner =
365 pitch / std::cos(M_PI / virtual_side_number); // distance of bin center to cell corner
366 const Real corner_p[2][2] = {
367 {0.0, 0.5 * corner_to_corner},
368 {0.5 * corner_to_corner * pitch_scale_factor * std::sin(2.0 * M_PI / virtual_side_number),
369 0.5 * corner_to_corner * pitch_scale_factor * std::cos(2.0 * M_PI / virtual_side_number)}};
370 const unsigned int div_num = angle_number / 2 + 1;
371 const unsigned int mod_div_num = mod_angle_number / 2 + 1;
372
373 // From now on, we work on the nodes, which need the "mod_" parameters
374 std::vector<std::vector<Node *>> nodes(mod_div_num, std::vector<Node *>(mod_div_num));
375 if (quad_center_elements)
376 {
377 Real ring_radii_0;
378
379 if (has_rings)
380 ring_radii_0 = ring_radii.front() * mod_rings_bias_terms.front()[order - 1];
381 else if (has_ducts)
382 ring_radii_0 = mod_ducts_center_dist.front() * std::cos(M_PI / virtual_side_number) *
383 mod_main_background_bias_terms[order - 1];
384 else
385 ring_radii_0 = pitch / 2.0 * mod_main_background_bias_terms[order - 1];
386 // If center_quad_factor is zero, default value (div_num - 1)/div_num is used.
387 // We use div_num instead of mod_div_num because we are dealing wth elements here
388 // This approach ensures that the order = 2 mesh elements are consistent with the order = 1
389 ring_radii_0 *=
390 center_quad_factor == 0.0 ? (((Real)div_num - 1.0) / (Real)div_num) : center_quad_factor;
391
392 centerNodes(*mesh, virtual_side_number, mod_div_num, ring_radii_0, nodes);
393 }
394 else // pin-cell center
395 mesh->add_point(Point(0.0, 0.0, 0.0));
396
397 // create nodes for the ring regions
398 if (has_rings)
399 ringNodes(*mesh,
400 ring_radii,
401 mod_total_ring_layers,
402 mod_rings_bias_terms,
403 mod_num_sectors_per_side,
404 corner_p,
405 corner_to_corner,
406 azimuthal_tangent);
407
408 if (has_background)
409 {
410 // add nodes in background region; the background region is defined as the area between the
411 // outermost pin (if there is a pin; if no pin, the center) and the innermost hex/duct; if
412 // _has_ducts is false, the background region is the area between the pin and enclosing hexagon
413 Real background_corner_radial_interval_length;
414 Real background_corner_distance;
415 Real background_in;
416 Real background_out; // background outer frontier
417 if (has_rings)
418 background_in = ring_radii.back();
419 else
420 background_in = 0;
421
422 if (has_ducts)
423 {
424 background_out = mod_ducts_center_dist.front();
425 background_corner_distance =
426 mod_ducts_center_dist
427 .front(); // it is the center to duct (innermost duct) corner distance
428 }
429 else
430 {
431 background_out = 0.5 * corner_to_corner;
432 background_corner_distance =
433 0.5 * corner_to_corner; // it is the center to hex corner distance
434 }
435
436 background_corner_radial_interval_length =
437 (background_out - background_in) / mod_background_intervals;
438
439 node_id_background_meta = mesh->n_nodes();
440
441 // create nodes for background region
442 backgroundNodes(*mesh,
443 mod_num_sectors_per_side,
444 mod_background_intervals,
445 mod_main_background_bias_terms,
446 background_corner_distance,
447 background_corner_radial_interval_length,
448 corner_p,
449 corner_to_corner,
450 background_in,
451 azimuthal_tangent);
452 }
453
454 // create nodes for duct regions
455 if (has_ducts)
456 ductNodes(*mesh,
457 &mod_ducts_center_dist,
458 mod_total_ducts_layers,
459 mod_duct_bias_terms,
460 mod_num_sectors_per_side,
461 corner_p,
462 corner_to_corner,
463 azimuthal_tangent);
464
465 // See if the central region is the only part of the innermost part
466 // The central region of the slice is special.
467 // Unlike the outer regions, which are layered quad elements,
468 // the central region is either a layer of tri elements or a specially-patterned quad elements.
469 // If there is at least one `ring` defined in the slice,
470 // the central region must belong to the innermost (first) ring.
471 // Otherwise the central region belongs to the `background`
472 // In either case, if the innermost ring or background has only one radial interval,
473 // the central region is an independent ring or background
474 // Otherwise, the central region and one or several quad element layers together form the
475 // innermost ring or background
476 bool is_central_region_independent;
477 if (ring_layers.empty())
478 is_central_region_independent = mod_background_inner_boundary_layer_params.intervals +
479 mod_background_intervals +
480 mod_background_outer_boundary_layer_params.intervals ==
481 1;
482 else
483 is_central_region_independent = mod_ring_layers[0] +
484 mod_ring_inner_boundary_layer_params.intervals[0] +
485 mod_ring_outer_boundary_layer_params.intervals[0] ==
486 1;
487
488 // From now on, we work on the elements, which need the none "mod_" parameters
489 // Assign elements, boundaries, and subdomains;
490 // Add Tri3/Tri6/Tri7 or Quad4/Quad8/Quad9 mesh into innermost (central) region
491 if (quad_center_elements)
492 cenQuadElemDef(*mesh,
493 div_num,
494 block_id_shift,
495 create_outward_interface_boundaries && is_central_region_independent,
496 boundary_id_shift,
497 nodes,
498 (!has_rings) && (!has_ducts) && (background_intervals == 1),
499 // Note here, has_ring means either there are ring regions or background inner
500 // boundary layer; has_ducts means either there are duct regions or background
501 // outer boundary layer. Same in cenTriElemDef()
502 side_index,
503 generate_side_specific_boundaries,
504 quad_elem_type);
505 else
506 cenTriElemDef(
507 *mesh,
508 num_sectors_per_side,
509 azimuthal_tangent,
510 block_id_shift,
511 create_outward_interface_boundaries && is_central_region_independent,
512 boundary_id_shift,
513 ((!has_rings) && (!has_ducts) && (background_intervals == 1)) ||
514 ((!has_background) &&
515 (std::accumulate(total_ring_layers.begin(), total_ring_layers.end(), 0) == 1)),
516 // Only for ACCG, it is possible that the entire mesh is a single-layer ring.
517 // cenQuadElemDef() does not need this as it does not work for ACCG.
518 side_index,
519 generate_side_specific_boundaries,
520 tri_elem_type);
521
522 // Add Quad4 mesh into outer circle
523 // total number of mesh should be all the rings for pin regions + background regions;
524 // total number of quad mesh should be total number of mesh -1 (-1 is because the inner circle for
525 // tri/quad mesh has been added above)
526
527 std::vector<unsigned int> subdomain_rings;
528 if (has_rings) // define the rings in each subdomain
529 {
530 subdomain_rings = total_ring_layers;
531 subdomain_rings.front() -= 1; // remove the inner TRI mesh subdomain
532 if (background_inner_boundary_layer_params.intervals)
533 {
534 subdomain_rings.back() =
535 background_inner_boundary_layer_params.intervals + background_intervals +
536 background_outer_boundary_layer_params.intervals; // add the background region
537 if (ring_radii.size() == 1)
538 subdomain_rings.back() -= 1; // remove the inner TRI mesh subdomain
539 }
540 else if (has_background)
541 subdomain_rings.push_back(background_inner_boundary_layer_params.intervals +
542 background_intervals +
543 background_outer_boundary_layer_params.intervals);
544 }
545 else
546 {
547 subdomain_rings.push_back(
548 background_inner_boundary_layer_params.intervals + background_intervals +
549 background_outer_boundary_layer_params.intervals); // add the background region
550 subdomain_rings[0] -= 1; // remove the inner TRI mesh subdomain
551 }
552
553 if (has_ducts)
554 for (unsigned int i = (background_outer_boundary_layer_params.intervals > 0);
555 i < total_ducts_layers.size();
556 i++)
557 subdomain_rings.push_back(total_ducts_layers[i]);
558
559 quadElemDef(*mesh,
560 num_sectors_per_side,
561 subdomain_rings,
562 side_index,
563 azimuthal_tangent,
564 block_id_shift,
565 quad_center_elements ? (mod_div_num * mod_div_num - 1) : 0,
566 create_inward_interface_boundaries,
567 create_outward_interface_boundaries,
568 boundary_id_shift,
569 generate_side_specific_boundaries,
570 quad_elem_type);
571 if (tri_elem_type == TRI_ELEM_TYPE::TRI6 || quad_elem_type == QUAD_ELEM_TYPE::QUAD8)
572 mesh->remove_orphaned_nodes();
573 return mesh;
574}
MeshGenerator::name
const std::string & name() const
PolygonMeshGeneratorBase::cenTriElemDef
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.
Definition PolygonMeshGeneratorBase.C:989
PolygonMeshGeneratorBase::backgroundNodes
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.
Definition PolygonMeshGeneratorBase.C:720
PolygonMeshGeneratorBase::modifiedSingleBdryLayerParamsCreator
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...
Definition PolygonMeshGeneratorBase.C:1789
PolygonMeshGeneratorBase::modifiedMultiBdryLayerParamsCreator
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 ...
Definition PolygonMeshGeneratorBase.C:1775
PolygonMeshGeneratorBase::ringNodes
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.
Definition PolygonMeshGeneratorBase.C:656
PolygonMeshGeneratorBase::quadElemDef
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.
Definition PolygonMeshGeneratorBase.C:1053
PolygonMeshGeneratorBase::centerNodes
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.
Definition PolygonMeshGeneratorBase.C:577
PolygonMeshGeneratorBase::ductNodes
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.
Definition PolygonMeshGeneratorBase.C:792
PolygonMeshGeneratorBase::cenQuadElemDef
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.
Definition PolygonMeshGeneratorBase.C:853
libMesh::MeshBase::n_nodes
virtual dof_id_type n_nodes() const=0
libMesh::MeshBase::remove_orphaned_nodes
void remove_orphaned_nodes()

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

◆ 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
meshinput mesh to create the elements onto
div_numdivision number of the central mesh layer
block_id_shiftshift of the subdomain ids generated by this function
create_outward_interface_boundarieswhether outward interface boundary sidesets are created
boundary_id_shiftshift of the interface boundary ids
id_arraypointer to a vector that contains the node_ids with basic geometry information
assign_external_boundarywhether the external boundary ids are assigned
side_indexindex of the polygon side (only used if external boundary ids are assigned)
generate_side_specific_boundarieswhether the side-specific external boundaries are generated or not
quad_elem_typetype of the quadrilateral elements to be generated

Definition at line 853 of file PolygonMeshGeneratorBase.C.

863{
864
865 BoundaryInfo & boundary_info = mesh.get_boundary_info();
866
867 // This loop defines quad elements for the central regions except for the outermost layer
868 for (unsigned int i = 0; i < div_num - 1; i++)
869 {
870 unsigned int id_x = 0;
871 unsigned int id_y = i;
872 for (unsigned int j = 0; j < 2 * i + 1; j++)
873 {
874 std::unique_ptr<Elem> new_elem;
875 if (quad_elem_type == QUAD_ELEM_TYPE::QUAD4)
876 {
877 new_elem = std::make_unique<Quad4>();
878 new_elem->set_node(0, nodes[id_x][id_y]);
879 new_elem->set_node(3, nodes[id_x][id_y + 1]);
880 new_elem->set_node(2, nodes[id_x + 1][id_y + 1]);
881 new_elem->set_node(1, nodes[id_x + 1][id_y]);
882 new_elem->subdomain_id() = 1 + block_id_shift;
883 }
884 else // QUAD8/QUAD9
885 {
886 new_elem = std::make_unique<Quad8>();
887 if (quad_elem_type == QUAD_ELEM_TYPE::QUAD9)
888 {
889 new_elem = std::make_unique<Quad9>();
890 new_elem->set_node(8, nodes[id_x * 2 + 1][id_y * 2 + 1]);
891 }
892 new_elem->set_node(0, nodes[id_x * 2][id_y * 2]);
893 new_elem->set_node(3, nodes[id_x * 2][id_y * 2 + 2]);
894 new_elem->set_node(2, nodes[id_x * 2 + 2][id_y * 2 + 2]);
895 new_elem->set_node(1, nodes[id_x * 2 + 2][id_y * 2]);
896 new_elem->set_node(4, nodes[id_x * 2 + 1][id_y * 2]);
897 new_elem->set_node(5, nodes[id_x * 2 + 2][id_y * 2 + 1]);
898 new_elem->set_node(6, nodes[id_x * 2 + 1][id_y * 2 + 2]);
899 new_elem->set_node(7, nodes[id_x * 2][id_y * 2 + 1]);
900 new_elem->subdomain_id() = 1 + block_id_shift;
901 }
902 Elem * elem_Quad = mesh.add_elem(std::move(new_elem));
903
904 if (id_x == 0)
905 boundary_info.add_side(elem_Quad, 3, SLICE_BEGIN);
906 if (id_y == 0)
907 boundary_info.add_side(elem_Quad, 0, SLICE_END);
908 if (j < i)
909 id_x++;
910 if (j >= i)
911 id_y--;
912 }
913 }
914 // This loop defines the outermost layer quad elements of the central region
915 for (unsigned int i = (div_num - 1) * (div_num - 1); i < div_num * div_num - 1; i++)
916 {
917 std::unique_ptr<Elem> new_elem;
918 if (quad_elem_type == QUAD_ELEM_TYPE::QUAD4)
919 {
920 new_elem = std::make_unique<Quad4>();
921 new_elem->set_node(0, mesh.node_ptr(i));
922 new_elem->set_node(3, mesh.node_ptr(i + 2 * div_num - 1));
923 new_elem->set_node(2, mesh.node_ptr(i + 2 * div_num));
924 new_elem->set_node(1, mesh.node_ptr(i + 1));
925 }
926 else // QUAD8/QUAD9
927 {
928 new_elem = std::make_unique<Quad8>();
929 if (quad_elem_type == QUAD_ELEM_TYPE::QUAD9)
930 {
931 new_elem = std::make_unique<Quad9>();
932 new_elem->set_node(8,
933 mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
934 (i - (div_num - 1) * (div_num - 1)) * 2 + 1 +
935 ((div_num - 1) * 4 + 1)));
936 }
937 new_elem->set_node(0,
938 mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
939 (i - (div_num - 1) * (div_num - 1)) * 2));
940 new_elem->set_node(3,
941 mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
942 (i - (div_num - 1) * (div_num - 1)) * 2 +
943 ((div_num - 1) * 4 + 1) * 2));
944 new_elem->set_node(2,
945 mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
946 (i - (div_num - 1) * (div_num - 1)) * 2 + 2 +
947 ((div_num - 1) * 4 + 1) * 2));
948 new_elem->set_node(1,
949 mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
950 (i - (div_num - 1) * (div_num - 1)) * 2 + 2));
951 new_elem->set_node(4,
952 mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
953 (i - (div_num - 1) * (div_num - 1)) * 2 + 1));
954 new_elem->set_node(5,
955 mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
956 (i - (div_num - 1) * (div_num - 1)) * 2 + 2 +
957 ((div_num - 1) * 4 + 1)));
958 new_elem->set_node(6,
959 mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
960 (i - (div_num - 1) * (div_num - 1)) * 2 + 1 +
961 ((div_num - 1) * 4 + 1) * 2));
962 new_elem->set_node(7,
963 mesh.node_ptr((div_num - 1) * (div_num - 1) * 4 +
964 (i - (div_num - 1) * (div_num - 1)) * 2 +
965 ((div_num - 1) * 4 + 1)));
966 }
967
968 Elem * elem_Quad = mesh.add_elem(std::move(new_elem));
969 elem_Quad->subdomain_id() = 1 + block_id_shift;
970 if (create_outward_interface_boundaries)
971 boundary_info.add_side(elem_Quad, 2, 1 + boundary_id_shift);
972 if (i == (div_num - 1) * (div_num - 1))
973 boundary_info.add_side(elem_Quad, 3, SLICE_BEGIN);
974 if (i == div_num * div_num - 2)
975 boundary_info.add_side(elem_Quad, 1, SLICE_END);
976 if (assign_external_boundary)
977 {
978 boundary_info.add_side(elem_Quad, 2, OUTER_SIDESET_ID);
979 if (generate_side_specific_boundaries)
980 boundary_info.add_side(
981 elem_Quad,
982 2,
983 (i < div_num * (div_num - 1) ? OUTER_SIDESET_ID : OUTER_SIDESET_ID_ALT) + side_index);
984 }
985 }
986}

Referenced by PolygonMeshGeneratorBase::buildSlice().

◆ 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
meshinput mesh to add the nodes onto
virtual_side_numbervirtual number of sides of the polygon (360/slice_azimuthal)
div_numdivision number of the central mesh layer
ring_radii_0radius of the central mesh layer
nodespointer to the mesh's nodes
nodesvector that contains the nodes with basic geometry information

Definition at line 577 of file PolygonMeshGeneratorBase.C.

582{
583 const std::pair<Real, Real> p_origin = std::make_pair(0.0, 0.0);
584 const std::pair<Real, Real> p_bottom =
585 std::make_pair(0.0, ring_radii_0 * std::cos(M_PI / virtual_side_number));
586 const std::pair<Real, Real> p_top =
587 std::make_pair(p_bottom.second * std::sin(2.0 * M_PI / virtual_side_number),
588 p_bottom.second * std::cos(2.0 * M_PI / virtual_side_number));
589 const std::pair<Real, Real> p_diag =
590 std::make_pair(ring_radii_0 * std::sin(M_PI / virtual_side_number),
591 ring_radii_0 * std::cos(M_PI / virtual_side_number));
592
593 // The four vertices of the central quad region are defined above.
594 // The following loops transverse all the nodes within this central quad region by moving p1 thru
595 // p4 and calculate the four-point intercept (pc).
596 // p_top------o-------p4--------o-----p_diag
597 // | | | | |
598 // | | | | |
599 // o--------o--------o--------o--------o
600 // | | | | |
601 // | | | | |
602 // p1--------o-------pc--------o-------p2
603 // | | | | |
604 // | | | | |
605 // o--------o--------o--------o--------o
606 // | | | | |
607 // | | | | |
608 // p_origin-----o-------p3--------o----p_bottom
609 //
610 // The loops are designed to transverse the nodes as shown below to facilitate elements
611 // and sides creation.
612 //
613 // 25-------24-------23-------22-------21
614 // | | | | |
615 // | | | | |
616 // 16-------15-------14-------13-------20
617 // | | | | |
618 // | | | | |
619 // 9--------8------- 7-------12-------19
620 // | | | | |
621 // | | | | |
622 // 4--------3--------6-------11-------18
623 // | | | | |
624 // | | | | |
625 // 1--------2--------5-------10-------17
626
627 for (unsigned int i = 0; i < div_num; i++)
628 {
629 unsigned int id_x = 0;
630 unsigned int id_y = i;
631 for (unsigned int j = 0; j < 2 * i + 1; j++)
632 {
633 std::pair<Real, Real> p1 = std::make_pair(
634 (p_origin.first * (div_num - 1 - id_x) + p_top.first * id_x) / (div_num - 1),
635 (p_origin.second * (div_num - 1 - id_x) + p_top.second * id_x) / (div_num - 1));
636 std::pair<Real, Real> p2 = std::make_pair(
637 (p_bottom.first * (div_num - 1 - id_x) + p_diag.first * id_x) / (div_num - 1),
638 (p_bottom.second * (div_num - 1 - id_x) + p_diag.second * id_x) / (div_num - 1));
639 std::pair<Real, Real> p3 = std::make_pair(
640 (p_origin.first * (div_num - 1 - id_y) + p_bottom.first * id_y) / (div_num - 1),
641 (p_origin.second * (div_num - 1 - id_y) + p_bottom.second * id_y) / (div_num - 1));
642 std::pair<Real, Real> p4 = std::make_pair(
643 (p_top.first * (div_num - 1 - id_y) + p_diag.first * id_y) / (div_num - 1),
644 (p_top.second * (div_num - 1 - id_y) + p_diag.second * id_y) / (div_num - 1));
645 std::pair<Real, Real> pc = fourPointIntercept(p1, p2, p3, p4);
646 nodes[id_x][id_y] = mesh.add_point(Point(pc.first, pc.second, 0.0));
647 if (j < i)
648 id_x++;
649 if (j >= i)
650 id_y--;
651 }
652 }
653}
PolygonMeshGeneratorBase::fourPointIntercept
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.
Definition PolygonMeshGeneratorBase.C:1396

Referenced by PolygonMeshGeneratorBase::buildSlice().

◆ 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
meshinput mesh to create the elements onto
num_sectors_per_sidenumber of azimuthal intervals
azimuthal_tangentvector of tangent values of the azimuthal angles as reference for adaptive boundary matching
block_id_shiftshift of the subdomain ids generated by this function
create_outward_interface_boundarieswhether outward interface boundary sidesets are created
boundary_id_shiftshift of the interface boundary ids
assign_external_boundarywhether the external boundary ids are assigned
side_indexindex of the polygon side (only used if external boundary ids are assigned)
generate_side_specific_boundarieswhether the side-specific external boundaries are generated or not
tri_elem_typetype of the triangular elements to be generated

Definition at line 989 of file PolygonMeshGeneratorBase.C.

999{
1000 const unsigned short order = tri_elem_type == TRI_ELEM_TYPE::TRI3 ? 1 : 2;
1001 unsigned int angle_number = azimuthal_tangent.size() == 0
1002 ? num_sectors_per_side
1003 : ((azimuthal_tangent.size() - 1) / order);
1004
1005 BoundaryInfo & boundary_info = mesh.get_boundary_info();
1006 for (unsigned int i = 1; i <= angle_number; i++)
1007 {
1008 std::unique_ptr<Elem> new_elem;
1009 if (tri_elem_type == TRI_ELEM_TYPE::TRI3)
1010 {
1011 new_elem = std::make_unique<Tri3>();
1012 new_elem->set_node(0, mesh.node_ptr(0));
1013 new_elem->set_node(2, mesh.node_ptr(i));
1014 new_elem->set_node(1, mesh.node_ptr(i + 1));
1015 }
1016 else // TRI6/TRI7
1017 {
1018 new_elem = std::make_unique<Tri6>();
1019 if (tri_elem_type == TRI_ELEM_TYPE::TRI7)
1020 {
1021 new_elem = std::make_unique<Tri7>();
1022 new_elem->set_node(6, mesh.node_ptr(i * 2));
1023 }
1024 new_elem->set_node(0, mesh.node_ptr(0));
1025 new_elem->set_node(2, mesh.node_ptr(i * 2 + angle_number * order));
1026 new_elem->set_node(1, mesh.node_ptr((i + 1) * 2 + angle_number * order));
1027 new_elem->set_node(3, mesh.node_ptr(i * 2 + 1));
1028 new_elem->set_node(5, mesh.node_ptr(i * 2 - 1));
1029 new_elem->set_node(4, mesh.node_ptr(i * 2 + 1 + angle_number * order));
1030 }
1031
1032 Elem * elem = mesh.add_elem(std::move(new_elem));
1033 if (create_outward_interface_boundaries)
1034 boundary_info.add_side(elem, 1, 1 + boundary_id_shift);
1035 elem->subdomain_id() = 1 + block_id_shift;
1036 if (i == 1)
1037 boundary_info.add_side(elem, 2, SLICE_BEGIN);
1038 if (i == angle_number)
1039 boundary_info.add_side(elem, 0, SLICE_END);
1040 if (assign_external_boundary)
1041 {
1042 boundary_info.add_side(elem, 1, OUTER_SIDESET_ID);
1043 if (generate_side_specific_boundaries)
1044 boundary_info.add_side(elem,
1045 1,
1046 (i <= angle_number / 2 ? OUTER_SIDESET_ID : OUTER_SIDESET_ID_ALT) +
1047 side_index);
1048 }
1049 }
1050}

Referenced by PolygonMeshGeneratorBase::buildSlice().

◆ 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
meshinput mesh to be deformed
orientationorientation angle of the input mesh (move the deformation direction to y)
y_max_0original maximum y position
y_max_nmaximum y position after deformation
y_minminimum y position that is affected by the deformation
mesh_typewhether the peripheral region is for a corner or a side hexagon mesh.
tolstolerance used to determine the boundary of deformation region
unit_angleunit 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.

1337{
1338 for (auto & node_ptr : as_range(mesh.nodes_begin(), mesh.nodes_end()))
1339 {
1340 // This function can definitely be optimized in future for better efficiency.
1341 Real & x = (*node_ptr)(0);
1342 Real & y = (*node_ptr)(1);
1343 if (mesh_type == CORNER_MESH)
1344 {
1345 nodeCoordRotate(x, y, orientation);
1346 if (x >= 0.0 && y > y_max_0)
1347 y = y - y_max_0 + y_max_n;
1348 else if (x >= 0.0 && y >= y_min)
1349 y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
1350 else if (y > -x / std::tan(unit_angle / 360.0 * M_PI) + tols && y > y_max_0)
1351 {
1352 x /= y;
1353 y = y - y_max_0 + y_max_n;
1354 x *= y;
1355 }
1356 else if (y > -x / std::tan(unit_angle / 360.0 * M_PI) + tols && y >= y_min)
1357 {
1358 x /= y;
1359 y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
1360 x *= y;
1361 }
1362 nodeCoordRotate(x, y, -orientation);
1363
1364 nodeCoordRotate(x, y, orientation - unit_angle);
1365 if (x <= 0 && y > y_max_0)
1366 y = y - y_max_0 + y_max_n;
1367 else if (x <= 0 && y >= y_min)
1368 y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
1369 else if (y >= x / std::tan(unit_angle / 360.0 * M_PI) - tols && y > y_max_0)
1370 {
1371 x /= y;
1372 y = y - y_max_0 + y_max_n;
1373 x *= y;
1374 }
1375 else if (y >= x / std::tan(unit_angle / 360.0 * M_PI) - tols && y >= y_min)
1376 {
1377 x /= y;
1378 y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
1379 x *= y;
1380 }
1381 nodeCoordRotate(x, y, unit_angle - orientation);
1382 }
1383 else
1384 {
1385 nodeCoordRotate(x, y, orientation);
1386 if (y > y_max_0)
1387 y = y - y_max_0 + y_max_n;
1388 else if (y >= y_min)
1389 y = (y - y_min) / (y_max_0 - y_min) * (y_max_n - y_min) + y_min;
1390 nodeCoordRotate(x, y, -orientation);
1391 }
1392 }
1393}
y
const std::vector< double > y
Definition EquilibriumConstantFitTest.C:18
x
const std::vector< double > x
Definition EquilibriumConstantFitTest.C:17
PolygonMeshGeneratorBase::nodeCoordRotate
void nodeCoordRotate(Real &x, Real &y, const Real theta) const
Calculates x and y coordinates after rotating by theta angle.
Definition PolygonMeshGeneratorBase.C:1320
libMesh::as_range
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)

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

◆ 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
meshinput mesh to add the nodes onto
ducts_center_distdistance parameters of the duct regions
ducts_layersnumbers of radial intervals of the duct regions
biased_termsnormalized spacing values used for radial meshing biasing in duct region
num_sectors_per_sidenumber of azimuthal intervals
corner_p[2][2]array contains the coordinates of the corner positions
corner_to_cornerdiameter of the circumscribed circle of the polygon
azimuthal_tangentvector of tangent values of the azimuthal angles as reference for adaptive boundary matching

Definition at line 792 of file PolygonMeshGeneratorBase.C.

800{
801 unsigned int angle_number =
802 azimuthal_tangent.size() == 0 ? num_sectors_per_side : (azimuthal_tangent.size() - 1);
803 // Add nodes in ducts regions
804 (*ducts_center_dist)
805 .push_back(0.5 * corner_to_corner); // add hex boundary as the last element in this vector
806 std::vector<Real> duct_radius_interval_length(ducts_layers.size());
807
808 Real bin_radial_distance;
809 for (unsigned int l = 0; l < ducts_layers.size(); l++)
810 {
811 duct_radius_interval_length[l] =
812 ((*ducts_center_dist)[l + 1] - (*ducts_center_dist)[l]) /
813 ducts_layers[l]; // the pin radius interval for each ring_radii/subdomain
814
815 // add rings in each pin subdomain
816 for (unsigned int k = 0; k < ducts_layers[l]; k++)
817 {
818 bin_radial_distance = ((*ducts_center_dist)[l] +
819 biased_terms[l][k] * ducts_layers[l] * duct_radius_interval_length[l]);
820 const Real pin_corner_p_x = corner_p[0][0] * bin_radial_distance / (0.5 * corner_to_corner);
821 const Real pin_corner_p_y = corner_p[0][1] * bin_radial_distance / (0.5 * corner_to_corner);
822
823 // pin_corner_p(s) are the points in the pin region, on the bins towards the six corners,
824 // at different intervals
825 mesh.add_point(Point(pin_corner_p_x, pin_corner_p_y, 0.0));
826
827 for (unsigned int j = 1; j <= angle_number; j++)
828 {
829 const Real cell_boundary_p_x =
830 corner_p[0][0] + (corner_p[1][0] - corner_p[0][0]) *
831 (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
832 : (azimuthal_tangent[j] / 2.0));
833 const Real cell_boundary_p_y =
834 corner_p[0][1] + (corner_p[1][1] - corner_p[0][1]) *
835 (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
836 : (azimuthal_tangent[j] / 2.0));
837 // cell_boundary_p(s) are the points on the cell's six boundaries (flat sides) at
838 // different azimuthal angles
839 const Real pin_azimuthal_p_x =
840 cell_boundary_p_x * bin_radial_distance / (0.5 * corner_to_corner);
841 const Real pin_azimuthal_p_y =
842 cell_boundary_p_y * bin_radial_distance / (0.5 * corner_to_corner);
843
844 // pin_azimuthal_p are the points on the bins towards different azimuthal angles, at
845 // different intervals; excluding the ones produced by pin_corner_p
846 mesh.add_point(Point(pin_azimuthal_p_x, pin_azimuthal_p_y, 0.0));
847 }
848 }
849 }
850}

Referenced by PolygonMeshGeneratorBase::buildSlice().

◆ 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
p1vertex 1
p2vertex 2
p3vertex 3
p4vertex 4
Returns
the intecept point coordinate x and y

Definition at line 1396 of file PolygonMeshGeneratorBase.C.

1400{
1401 const Real x1 = p1.first;
1402 const Real y1 = p1.second;
1403 const Real x2 = p2.first;
1404 const Real y2 = p2.second;
1405 const Real x3 = p3.first;
1406 const Real y3 = p3.second;
1407 const Real x4 = p4.first;
1408 const Real y4 = p4.second;
1409
1410 Real x = -((x1 - x2) * (y3 * x4 - x3 * y4) - (x3 - x4) * (y1 * x2 - x1 * y2)) /
1411 ((y1 - y2) * (x3 - x4) - (y3 - y4) * (x1 - x2));
1412 Real y = -((y1 - y2) * (y3 * x4 - x3 * y4) - (y3 - y4) * (y1 * x2 - x1 * y2)) /
1413 ((y1 - y2) * (x3 - x4) - (y3 - y4) * (x1 - x2));
1414
1415 return std::make_pair(x, y);
1416}

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

◆ generate()

std::unique_ptr< MeshBase > PolygonConcentricCircleMeshGeneratorBase::generate ( )
overridevirtualinherited

Implements ConcentricCircleGeneratorBase.

Definition at line 613 of file PolygonConcentricCircleMeshGeneratorBase.C.

614{
615 std::vector<std::unique_ptr<ReplicatedMesh>> input(_input_ptrs.size());
616 for (const auto i : index_range(_input_ptrs))
617 {
618 input[i] = dynamic_pointer_cast<ReplicatedMesh>(std::move(*_input_ptrs[i]));
619 if (!input[i])
620 mooseError("A non-replicated mesh input was supplied but replicated meshes are required.");
621 if ((_order == 1 && (*input[i]->elements_begin())->default_order() != FIRST) ||
622 (_order == 2 && (*input[i]->elements_begin())->default_order() == FIRST))
623 paramError("tri_element_type",
624 "The order of the input mesh to be adapted to does not match the order of the "
625 "mesh to be generated.");
626 }
627
628 unsigned int mesh_input_counter = 0;
629 // azimuthal array used for radius radius_correction
630 std::vector<Real> azimuthal_list;
631 // loop over all sides of the polygon to collect azimuthal angles of all nodes
632 for (unsigned int mesh_index = 0; mesh_index < _num_sides; mesh_index++)
633 {
634 // When adaptive boundaries exist (only possible for hexagon meshes thru
635 // `HexagonConcentricCircleAdaptiveBoundaryMeshGenerator` or square meshes thru
636 // `CartesianConcentricCircleAdaptiveBoundaryMeshGenerator`), nodes' azimuthal angle cannot be
637 // arithmetically obtained. Instead, `azimuthalAnglesCollector() is used to get this
638 // information from the mesh directly.`
639 if (std::find(_sides_to_adapt.begin(), _sides_to_adapt.end(), mesh_index) !=
640 _sides_to_adapt.end())
641 {
642 // The following lines only work for hexagon and square; and only a hexagon or a square needs
643 // such functionality.
644 Real lower_azi =
645 _num_sides == 6 ? ((Real)mesh_index * 60.0 - 150.0) : ((Real)mesh_index * 90.0 - 135.0);
646 Real upper_azi = _num_sides == 6 ? ((Real)((mesh_index + 1) % 6) * 60.0 - 150.0)
647 : ((Real)((mesh_index + 1) % 4) * 90.0 - 135.0);
648 _azimuthal_angles_array.push_back(azimuthalAnglesCollector(
649 *input[mesh_input_counter], lower_azi, upper_azi, ANGLE_TANGENT, _num_sides));
650 // loop over the _azimuthal_angles_array just collected to convert tangent to azimuthal
651 // angles.
652 for (unsigned int i = 1; i < _azimuthal_angles_array.back().size(); i++)
653 {
654 azimuthal_list.push_back(
655 _num_sides == 6
656 ? ((Real)mesh_index * 60.0 - 150.0 +
657 std::atan((_azimuthal_angles_array.back()[i - 1] - 1.0) / std::sqrt(3.0)) *
658 180.0 / M_PI)
659 : ((Real)mesh_index * 90.0 - 135.0 +
660 std::atan((_azimuthal_angles_array.back()[i - 1] - 1.0)) * 180.0 / M_PI));
661 }
662 mesh_input_counter++;
663 }
664 else
665 {
666 _azimuthal_angles_array.push_back(std::vector<Real>());
667 for (unsigned int i = 0; i < _num_sectors_per_side[mesh_index] * _order; i++)
668 {
669 azimuthal_list.push_back(
670 std::atan(
671 std::tan(M_PI / _num_sides) *
672 (2.0 * (Real)i / (Real)_num_sectors_per_side[mesh_index] / (Real)_order - 1.0)) *
673 180.0 / M_PI +
674 (Real)mesh_index * (360.0 / (Real)_num_sides) - (180.0 - 180.0 / (Real)_num_sides));
675 }
676 }
677 }
678 std::vector<Real> ring_radii_corr;
679 if (_has_rings)
680 {
681 if (_preserve_volumes)
682 {
683 Real corr_factor =
684 PolygonalMeshGenerationUtils::radiusCorrectionFactor(azimuthal_list, true, _order);
685 for (unsigned int i = 0; i < _ring_radii.size(); i++)
686 ring_radii_corr.push_back(_ring_radii[i] * corr_factor);
687 }
688 else
689 ring_radii_corr = _ring_radii;
690 if (ring_radii_corr.back() >= _pitch / 2.0)
691 paramError("ring_radii",
692 "Elements of this parameter must be smaller than polygon apothem (after volume "
693 "preserve correction if applicable).");
694 setMeshProperty("max_radius_meta", ring_radii_corr.back());
695 }
696 // build the first slice of the polygon.
697 auto mesh0 = buildSimpleSlice(ring_radii_corr,
698 _ring_intervals,
699 _ring_radial_biases,
700 _ring_inner_boundary_layer_params,
701 _ring_outer_boundary_layer_params,
702 _duct_sizes,
703 _duct_intervals,
704 _duct_radial_biases,
705 _duct_inner_boundary_layer_params,
706 _duct_outer_boundary_layer_params,
707 _pitch,
708 _num_sectors_per_side[0],
709 _background_intervals,
710 _background_radial_bias,
711 _background_inner_boundary_layer_params,
712 _background_outer_boundary_layer_params,
713 _node_id_background_meta,
714 _num_sides,
715 1,
716 _azimuthal_angles_array[0],
717 _block_id_shift,
718 _quad_center_elements,
719 _center_quad_factor,
720 _create_inward_interface_boundaries,
721 _create_outward_interface_boundaries,
722 _interface_boundary_id_shift,
723 _generate_side_specific_boundaries,
724 _tri_elem_type,
725 _quad_elem_type);
726 // This loop builds add-on slices and stitches them to the first slice
727 for (unsigned int mesh_index = 1; mesh_index < _num_sides; mesh_index++)
728 {
729 auto mesh_tmp = buildSimpleSlice(ring_radii_corr,
730 _ring_intervals,
731 _ring_radial_biases,
732 _ring_inner_boundary_layer_params,
733 _ring_outer_boundary_layer_params,
734 _duct_sizes,
735 _duct_intervals,
736 _duct_radial_biases,
737 _duct_inner_boundary_layer_params,
738 _duct_outer_boundary_layer_params,
739 _pitch,
740 _num_sectors_per_side[mesh_index],
741 _background_intervals,
742 _background_radial_bias,
743 _background_inner_boundary_layer_params,
744 _background_outer_boundary_layer_params,
745 _node_id_background_meta,
746 _num_sides,
747 mesh_index + 1,
748 _azimuthal_angles_array[mesh_index],
749 _block_id_shift,
750 _quad_center_elements,
751 _center_quad_factor,
752 _create_inward_interface_boundaries,
753 _create_outward_interface_boundaries,
754 _interface_boundary_id_shift,
755 _generate_side_specific_boundaries,
756 _tri_elem_type,
757 _quad_elem_type);
758
759 ReplicatedMesh other_mesh(*mesh_tmp);
760 MeshTools::Modification::rotate(other_mesh, 360.0 / _num_sides * mesh_index, 0, 0);
761 mesh0->prepare_for_use();
762 other_mesh.prepare_for_use();
763 mesh0->stitch_meshes(other_mesh, SLICE_BEGIN, SLICE_END, TOLERANCE, true, false);
764 other_mesh.clear();
765 }
766
767 // An extra step to stich the first and last slices together
768 mesh0->stitch_surfaces(SLICE_BEGIN, SLICE_END, TOLERANCE, true, false);
769
770 if (!_has_rings && !_has_ducts && _background_intervals == 1)
771 MooseMesh::changeBoundaryId(*mesh0, 1 + _interface_boundary_id_shift, OUTER_SIDESET_ID, false);
772
773 if (!_is_general_polygon)
774 {
775 setMeshProperty("azimuthal_angle_meta",
776 azimuthalAnglesCollector(*mesh0, -180.0, 180.0, ANGLE_DEGREE));
777 setMeshProperty("pattern_pitch_meta", _pitch);
778 }
779
780 // Move nodes on the external boundary for force uniform spacing.
781 if (_uniform_mesh_on_sides)
782 {
783 const Real angle_tol = 1.0e-5;
784 std::vector<std::pair<Real, unsigned int>> node_azi_list;
785 MeshTools::Modification::rotate(*mesh0, -(270.0 - 360.0 / (Real)_num_sides), 0.0, 0.0);
786 std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> side_list =
787 mesh0->get_boundary_info().build_side_list();
788 mesh0->get_boundary_info().build_node_list_from_side_list();
789 std::vector<std::tuple<dof_id_type, boundary_id_type>> node_list =
790 mesh0->get_boundary_info().build_node_list();
791
792 for (unsigned int i = 0; i < node_list.size(); ++i)
793 {
794 if (std::get<1>(node_list[i]) == OUTER_SIDESET_ID)
795 {
796 node_azi_list.push_back(
797 std::make_pair(atan2((*mesh0->node_ptr(std::get<0>(node_list[i])))(1),
798 (*mesh0->node_ptr(std::get<0>(node_list[i])))(0)) *
799 180.0 / M_PI,
800 std::get<0>(node_list[i])));
801 if (std::abs(node_azi_list.back().first + 180.0) <= angle_tol)
802 node_azi_list.back().first = 180.0;
803 }
804 }
805 std::sort(node_azi_list.begin(), node_azi_list.end());
806 for (unsigned int i = 0; i < _num_sides; i++)
807 {
808 for (unsigned int j = 1; j <= _num_sectors_per_side[i]; j++)
809 {
810 Real azi_corr_tmp = atan2((Real)j * 2.0 / (Real)_num_sectors_per_side[i] - 1.0,
811 1.0 / std::tan(M_PI / (Real)_num_sides));
812 Real x_tmp = _pitch / 2.0;
813 Real y_tmp = x_tmp * std::tan(azi_corr_tmp);
814 nodeCoordRotate(
815 x_tmp, y_tmp, (Real)i * 360.0 / (Real)_num_sides - (180.0 - 180.0 / (Real)_num_sides));
816 Point p_tmp = Point(x_tmp, y_tmp, 0.0);
817 mesh0->add_point(
818 p_tmp,
819 node_azi_list[std::accumulate(
820 _num_sectors_per_side.begin(), _num_sectors_per_side.begin() + i, 0) +
821 j - 1]
822 .second);
823 }
824 }
825 MeshTools::Modification::rotate(*mesh0, (270.0 - 360.0 / (Real)_num_sides), 0.0, 0.0);
826 }
827
828 setMeshProperty("background_intervals_meta", _background_intervals);
829
830 if (!_has_ducts && _sides_to_adapt.empty())
831 {
832 libMesh::LaplaceMeshSmoother lms(*mesh0, _smoothing_max_it);
833 lms.smooth();
834 }
835
836 // Set up customized Block Names and/or IDs
837 unsigned int block_it = 0;
838 unsigned ring_block_num = 0;
839 std::vector<subdomain_id_type> block_ids_old;
840 std::vector<subdomain_id_type> block_ids_new;
841 std::vector<SubdomainName> block_names;
842 if (_has_rings)
843 {
844 ringBlockIdsNamesPreparer(block_it, ring_block_num, block_ids_old, block_ids_new, block_names);
845 }
846 else
847 {
848 if (_background_intervals > 1)
849 {
850 block_ids_old.push_back(_block_id_shift + 1 + block_it);
851 block_ids_new.push_back(_background_block_ids.empty() ? block_ids_old.back()
852 : _background_block_ids.front());
853 block_names.push_back(_background_block_names.empty()
854 ? (SubdomainName)std::to_string(block_ids_new.back())
855 : _background_block_names.front());
856 block_it++;
857 }
858 }
859 block_ids_old.push_back(_block_id_shift + 1 + block_it);
860 block_ids_new.push_back(_background_block_ids.empty() ? block_ids_old.back()
861 : _background_block_ids.back());
862 block_names.push_back(_background_block_names.empty()
863 ? (SubdomainName)std::to_string(block_ids_new.back())
864 : _background_block_names.back());
865 block_it++;
866 if (_has_ducts)
867 {
868 for (unsigned int i = 0; i < _duct_intervals.size(); i++)
869 {
870 block_ids_old.push_back(_block_id_shift + 1 + block_it);
871 block_ids_new.push_back(_duct_block_ids.empty() ? block_ids_old.back() : _duct_block_ids[i]);
872 block_names.push_back(_duct_block_names.empty()
873 ? (SubdomainName)std::to_string(block_ids_new.back())
874 : _duct_block_names[i]);
875 block_it++;
876 }
877 }
878
879 assignBlockIdsNames(
880 *mesh0, block_ids_old, block_ids_new, block_names, "ConcentricCircleMeshGenerator");
881
882 if (_external_boundary_id > 0)
883 MooseMesh::changeBoundaryId(*mesh0, OUTER_SIDESET_ID, _external_boundary_id, false);
884 if (!_external_boundary_name.empty())
885 {
886 mesh0->get_boundary_info().sideset_name(
887 _external_boundary_id > 0 ? _external_boundary_id : (boundary_id_type)OUTER_SIDESET_ID) =
888 _external_boundary_name;
889 mesh0->get_boundary_info().nodeset_name(
890 _external_boundary_id > 0 ? _external_boundary_id : (boundary_id_type)OUTER_SIDESET_ID) =
891 _external_boundary_name;
892 }
893
894 assignInterfaceBoundaryNames(*mesh0);
895
896 // add sector ids
897 if (isParamValid("sector_id_name"))
898 setSectorExtraIDs(
899 *mesh0, getParam<std::string>("sector_id_name"), _num_sides, _num_sectors_per_side);
900
901 // add ring ids
902 if (isParamValid("ring_id_name"))
903 setRingExtraIDs(*mesh0,
904 getParam<std::string>("ring_id_name"),
905 _num_sides,
906 _num_sectors_per_side,
907 _ring_intervals,
908 getParam<MooseEnum>("ring_id_assign_type") == "ring_wise",
909 _quad_center_elements);
910
911 // add internal side set info to metadata
912 if (_create_inward_interface_boundaries || _create_outward_interface_boundaries)
913 {
914 setMeshProperty("interface_boundaries", true);
915 // lists boundary ids assigned to interfaces
916 std::set<boundary_id_type> boundary_ids = mesh0->get_boundary_info().get_boundary_ids();
917 std::set<boundary_id_type> interface_boundary_ids;
918 if (_create_outward_interface_boundaries)
919 {
920 const unsigned int num_boundary_ids = boundary_ids.size();
921 for (const auto i : make_range(num_boundary_ids))
922 {
923 const unsigned int id = i * 2 + 1 + _interface_boundary_id_shift;
924 auto it = boundary_ids.find(id);
925 if (it != boundary_ids.end())
926 {
927 boundary_ids.erase(it);
928 interface_boundary_ids.insert(id);
929 }
930 }
931 }
932 if (_create_inward_interface_boundaries)
933 {
934 const unsigned int num_boundary_ids = boundary_ids.size();
935 for (const auto i : make_range(num_boundary_ids))
936 {
937 const unsigned int id = i * 2 + 2 + _interface_boundary_id_shift;
938 auto it = boundary_ids.find(id);
939 if (it != boundary_ids.end())
940 {
941 boundary_ids.erase(it);
942 interface_boundary_ids.insert(id);
943 }
944 }
945 }
946 setMeshProperty("interface_boundary_ids", interface_boundary_ids);
947 }
948
949 bool flat_side_up = getMeshProperty<bool>("flat_side_up", name());
950 if (flat_side_up)
951 MeshTools::Modification::rotate(*mesh0, 180.0 / (Real)_num_sides, 0.0, 0.0);
952 mesh0->unset_is_prepared();
953
954 if (_has_rings && getParam<bool>("replace_inner_ring_with_delaunay_mesh"))
955 {
956 if (isParamSetByUser("quad_center_elements"))
957 paramError("quad_center_elements",
958 "Should not be set because the center elements of the inner ring will be replaced "
959 "by a Delaunay mesh with 'replace_inner_ring_with_delaunay_mesh=true'");
960
961 // remove elements of the inner ring and create an inner-ring external boundary side set
962 std::set<Elem *> deleteable_elems;
963 for (auto & elem : mesh0->element_ptr_range())
964 if (elem->vertex_average().norm() < ring_radii_corr[0])
965 deleteable_elems.insert(elem);
966
967 const boundary_id_type boundary_id = MooseMeshUtils::getBoundaryIDs(*mesh0, {"_foo"}, true)[0];
968 BoundaryInfo & boundary_info = mesh0->get_boundary_info();
969 for (auto & elem : deleteable_elems)
970 {
971 unsigned int n_sides = elem->n_sides();
972 for (unsigned int n = 0; n != n_sides; ++n)
973 {
974 Elem * neighbor = elem->neighbor_ptr(n);
975 if (!neighbor)
976 continue;
977
978 const unsigned int return_side = neighbor->which_neighbor_am_i(elem);
979
980 if (neighbor->neighbor_ptr(return_side) == elem)
981 {
982 neighbor->set_neighbor(return_side, nullptr);
983 boundary_info.add_side(neighbor, return_side, boundary_id);
984 }
985 }
986
987 mesh0->delete_elem(elem);
988 }
989
990 // build the 1d mesh from the new boundary
991 auto poly_mesh = MooseMeshUtils::buildBoundaryMesh(*mesh0, boundary_id);
992 Real min_side = std::numeric_limits<Real>::max();
993 for (auto & elem : poly_mesh->element_ptr_range())
994 {
995 Real l = elem->volume();
996 if (l < min_side)
997 min_side = l;
998 }
999
1000 // triangulate with the 1d mesh
1001 libMesh::Poly2TriTriangulator poly2tri(*poly_mesh);
1002 poly2tri.triangulation_type() = libMesh::TriangulatorInterface::PSLG;
1003 poly2tri.set_interpolate_boundary_points(0);
1004 poly2tri.set_refine_boundary_allowed(false);
1005 poly2tri.set_verify_hole_boundaries(false);
1006 const auto desired_area = getParam<std::string>("inner_ring_desired_area");
1007 if (desired_area != "")
1008 {
1009 poly2tri.desired_area() = 0;
1010 libMesh::ParsedFunction<Real> area_func{desired_area};
1011 poly2tri.set_desired_area_function(&area_func);
1012 }
1013 else
1014 poly2tri.desired_area() = min_side * min_side;
1015 poly2tri.minimum_angle() = 0;
1016 poly2tri.smooth_after_generating() = true;
1017 // poly2tri.elem_type() is TRI3 by default
1018 if (_tri_elem_type == TRI_ELEM_TYPE::TRI6)
1019 poly2tri.elem_type() = libMesh::ElemType::TRI6;
1020 else if (_tri_elem_type == TRI_ELEM_TYPE::TRI7)
1021 poly2tri.elem_type() = libMesh::ElemType::TRI7;
1022 // let us keep the center point
1023 poly_mesh->add_point(libMesh::Point());
1024 poly2tri.triangulate();
1025 // keep the old subdomain id
1026 for (auto elem : poly_mesh->element_ptr_range())
1027 elem->subdomain_id() = block_ids_new[0];
1028
1029 if (isParamValid("ring_id_name"))
1030 {
1031 if (_ring_intervals[0] != 1 && getParam<MooseEnum>("ring_id_assign_type") == "ring_wise")
1032 paramError("replace_inner_ring_with_delaunay_mesh",
1033 "Inner ring has multple intervals with each being assigned with a different "
1034 "ring id, replacing inner ring with Delaunay mesh will remove this ring id "
1035 "assign type. Either change 'ring_id_assign_type' to block_wise or set the "
1036 "first element of 'ring_intervals' to 1 or set "
1037 "'replace_inner_ring_with_delaunay_mesh' to false to avoid this error.");
1038 auto id_name = getParam<std::string>("ring_id_name");
1039 const auto extra_id_index = poly_mesh->add_elem_integer(id_name);
1040 for (auto elem : poly_mesh->element_ptr_range())
1041 elem->set_extra_integer(extra_id_index, 1);
1042 }
1043 if (isParamValid("sector_id_name"))
1044 {
1045 // we will assign all elements in the inner ring with zero sector id
1046 auto id_name = getParam<std::string>("sector_id_name");
1047 const auto extra_id_index = poly_mesh->add_elem_integer(id_name);
1048 for (auto elem : poly_mesh->element_ptr_range())
1049 elem->set_extra_integer(extra_id_index, 0);
1050 }
1051
1052 // stitch the triangulated mesh and the original mesh without the inner ring
1053 mesh0->stitch_meshes(*poly_mesh, boundary_id, 0, TOLERANCE, true, false);
1054 }
1055
1056 return dynamic_pointer_cast<MeshBase>(mesh0);
1057}
ConcentricCircleGeneratorBase::_order
unsigned short _order
Order of the elements to be generated.
Definition ConcentricCircleGeneratorBase.h:67
ConcentricCircleGeneratorBase::_ring_radial_biases
const std::vector< Real > _ring_radial_biases
Bias values used to induce biasing to radial meshing in ring regions.
Definition ConcentricCircleGeneratorBase.h:33
ConcentricCircleGeneratorBase::_quad_elem_type
QUAD_ELEM_TYPE _quad_elem_type
Type of quadrilateral elements to be generated.
Definition ConcentricCircleGeneratorBase.h:65
ConcentricCircleGeneratorBase::_external_boundary_name
const BoundaryName _external_boundary_name
Boundary Name of the mesh's external boundary.
Definition ConcentricCircleGeneratorBase.h:57
ConcentricCircleGeneratorBase::_ring_inner_boundary_layer_params
multiBdryLayerParams _ring_inner_boundary_layer_params
Widths, fractions, radial sectors and growth factors of the inner boundary layers of the ring regions...
Definition ConcentricCircleGeneratorBase.h:35
ConcentricCircleGeneratorBase::_external_boundary_id
const boundary_id_type _external_boundary_id
Boundary ID of the mesh's external boundary.
Definition ConcentricCircleGeneratorBase.h:55
ConcentricCircleGeneratorBase::_preserve_volumes
const bool _preserve_volumes
Volume preserving function is optional.
Definition ConcentricCircleGeneratorBase.h:43
ConcentricCircleGeneratorBase::_block_id_shift
const subdomain_id_type _block_id_shift
Shift in default subdomain IDs to avert potential conflicts with other meshes.
Definition ConcentricCircleGeneratorBase.h:45
ConcentricCircleGeneratorBase::_ring_outer_boundary_layer_params
multiBdryLayerParams _ring_outer_boundary_layer_params
Widths, fractions, radial sectors and growth factors of the outer boundary layers of the ring regions...
Definition ConcentricCircleGeneratorBase.h:37
ConcentricCircleGeneratorBase::_ring_intervals
const std::vector< unsigned int > _ring_intervals
Number of rings in each circle or in the enclosing square.
Definition ConcentricCircleGeneratorBase.h:31
ConcentricCircleGeneratorBase::ringBlockIdsNamesPreparer
void ringBlockIdsNamesPreparer(unsigned int &block_counter, unsigned int &ring_block_num, std::vector< subdomain_id_type > &block_ids_old, std::vector< subdomain_id_type > &block_ids_new, std::vector< SubdomainName > &block_names) const
Prepare user-defined ring block IDs and names to replace the default ones.
Definition ConcentricCircleGeneratorBase.C:260
ConcentricCircleGeneratorBase::_ring_radii
const std::vector< Real > _ring_radii
Radii of concentric circles.
Definition ConcentricCircleGeneratorBase.h:29
ConcentricCircleGeneratorBase::_generate_side_specific_boundaries
const bool _generate_side_specific_boundaries
Whether the side-specific external boundaries are generated or not.
Definition ConcentricCircleGeneratorBase.h:53
ConcentricCircleGeneratorBase::assignInterfaceBoundaryNames
void assignInterfaceBoundaryNames(ReplicatedMesh &mesh) const
Assign interface boundary names to the mesh if applicable.
Definition ConcentricCircleGeneratorBase.C:199
ConcentricCircleGeneratorBase::_create_inward_interface_boundaries
const bool _create_inward_interface_boundaries
Whether inward interface boundaries are created.
Definition ConcentricCircleGeneratorBase.h:47
ConcentricCircleGeneratorBase::assignBlockIdsNames
void assignBlockIdsNames(ReplicatedMesh &mesh, std::vector< subdomain_id_type > &block_ids_old, std::vector< subdomain_id_type > &block_ids_new, std::vector< SubdomainName > &block_names, const std::string &generator_name) const
Assign block IDs and names to the mesh if applicable.
Definition ConcentricCircleGeneratorBase.C:224
ConcentricCircleGeneratorBase::_create_outward_interface_boundaries
const bool _create_outward_interface_boundaries
Whether outward interface boundaries are created.
Definition ConcentricCircleGeneratorBase.h:49
ConcentricCircleGeneratorBase::_tri_elem_type
TRI_ELEM_TYPE _tri_elem_type
Type of triangular elements to be generated.
Definition ConcentricCircleGeneratorBase.h:63
MeshGenerator::setMeshProperty
T & setMeshProperty(const std::string &data_name, Args &&... args)
MeshGenerator::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
MeshGenerator::isParamValid
bool isParamValid(const std::string &name) const
MooseMesh::changeBoundaryId
void changeBoundaryId(const boundary_id_type old_id, const boundary_id_type new_id, bool delete_prev)
PolygonConcentricCircleMeshGeneratorBase::_duct_block_names
const std::vector< SubdomainName > _duct_block_names
Subdomain Names of the duct regions.
Definition PolygonConcentricCircleMeshGeneratorBase.h:45
PolygonConcentricCircleMeshGeneratorBase::_has_ducts
const bool _has_ducts
Whether the generated mesh contains duct regions.
Definition PolygonConcentricCircleMeshGeneratorBase.h:49
PolygonConcentricCircleMeshGeneratorBase::_duct_outer_boundary_layer_params
multiBdryLayerParams _duct_outer_boundary_layer_params
Widths, fractions, radial sectors and growth factors of the inner boundary layers of the duct regions...
Definition PolygonConcentricCircleMeshGeneratorBase.h:41
PolygonConcentricCircleMeshGeneratorBase::_center_quad_factor
const Real _center_quad_factor
A fractional radius factor used to determine the radial positions of transition nodes in the center r...
Definition PolygonConcentricCircleMeshGeneratorBase.h:73
PolygonConcentricCircleMeshGeneratorBase::_duct_block_ids
const std::vector< subdomain_id_type > _duct_block_ids
Subdomain IDs of the duct regions.
Definition PolygonConcentricCircleMeshGeneratorBase.h:43
PolygonConcentricCircleMeshGeneratorBase::_background_block_names
std::vector< SubdomainName > _background_block_names
Subdomain Names of the background regions.
Definition PolygonConcentricCircleMeshGeneratorBase.h:67
PolygonConcentricCircleMeshGeneratorBase::_background_inner_boundary_layer_params
singleBdryLayerParams _background_inner_boundary_layer_params
Width, fraction, radiation sectors and growth factor of the inner boundary layer of the background re...
Definition PolygonConcentricCircleMeshGeneratorBase.h:61
PolygonConcentricCircleMeshGeneratorBase::_duct_sizes
std::vector< Real > _duct_sizes
Size parameters of the duct regions.
Definition PolygonConcentricCircleMeshGeneratorBase.h:33
PolygonConcentricCircleMeshGeneratorBase::_uniform_mesh_on_sides
const bool _uniform_mesh_on_sides
Whether the nodes on the external boundary needs to be uniformly distributed.
Definition PolygonConcentricCircleMeshGeneratorBase.h:69
PolygonConcentricCircleMeshGeneratorBase::_has_rings
const bool _has_rings
Whether the generated mesh contains ring regions.
Definition PolygonConcentricCircleMeshGeneratorBase.h:47
PolygonConcentricCircleMeshGeneratorBase::_background_outer_boundary_layer_params
singleBdryLayerParams _background_outer_boundary_layer_params
Width, fraction, radiation sectors and growth factor of the outer boundary layer of the background re...
Definition PolygonConcentricCircleMeshGeneratorBase.h:63
PolygonConcentricCircleMeshGeneratorBase::_background_block_ids
std::vector< subdomain_id_type > _background_block_ids
Subdomain IDs of the background regions.
Definition PolygonConcentricCircleMeshGeneratorBase.h:65
PolygonConcentricCircleMeshGeneratorBase::_background_radial_bias
const Real _background_radial_bias
Bias value used to induce biasing to radial meshing in background region.
Definition PolygonConcentricCircleMeshGeneratorBase.h:59
PolygonConcentricCircleMeshGeneratorBase::_duct_intervals
const std::vector< unsigned int > _duct_intervals
Number of layers in each enclosing duct.
Definition PolygonConcentricCircleMeshGeneratorBase.h:35
PolygonConcentricCircleMeshGeneratorBase::_node_id_background_meta
dof_id_type & _node_id_background_meta
MeshMetaData: maximum node id of the background region.
Definition PolygonConcentricCircleMeshGeneratorBase.h:83
PolygonConcentricCircleMeshGeneratorBase::_duct_inner_boundary_layer_params
multiBdryLayerParams _duct_inner_boundary_layer_params
Widths, fractions, radial sectors and growth factors of the inner boundary layers of the duct regions...
Definition PolygonConcentricCircleMeshGeneratorBase.h:39
PolygonConcentricCircleMeshGeneratorBase::_duct_radial_biases
const std::vector< Real > _duct_radial_biases
Bias values used to induce biasing to radial meshing in duct regions.
Definition PolygonConcentricCircleMeshGeneratorBase.h:37
PolygonConcentricCircleMeshGeneratorBase::_input_ptrs
std::vector< std::unique_ptr< MeshBase > * > _input_ptrs
Pointers to input mesh pointers.
Definition PolygonConcentricCircleMeshGeneratorBase.h:79
PolygonConcentricCircleMeshGeneratorBase::_background_intervals
const unsigned int _background_intervals
Numbers of radial intervals of the background regions.
Definition PolygonConcentricCircleMeshGeneratorBase.h:57
PolygonConcentricCircleMeshGeneratorBase::_smoothing_max_it
const unsigned int _smoothing_max_it
Maximum smooth iteration number.
Definition PolygonConcentricCircleMeshGeneratorBase.h:75
PolygonConcentricCircleMeshGeneratorBase::_azimuthal_angles_array
std::vector< std::vector< Real > > _azimuthal_angles_array
Azimuthal angles of all radial nodes for volume preservation.
Definition PolygonConcentricCircleMeshGeneratorBase.h:89
PolygonConcentricCircleMeshGeneratorBase::_sides_to_adapt
const std::vector< unsigned int > _sides_to_adapt
Indices of the hexagon sides that need to adapt.
Definition PolygonConcentricCircleMeshGeneratorBase.h:77
PolygonMeshGeneratorBase::setRingExtraIDs
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
Definition PolygonMeshGeneratorBase.C:1638
PolygonMeshGeneratorBase::setSectorExtraIDs
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
Definition PolygonMeshGeneratorBase.C:1613
PolygonMeshGeneratorBase::buildSimpleSlice
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.
Definition PolygonMeshGeneratorBase.C:106
MooseMeshUtils::buildBoundaryMesh
std::unique_ptr< ReplicatedMesh > buildBoundaryMesh(const MeshBase &input_mesh, const boundary_id_type boundary_id)
MooseMeshUtils::getBoundaryIDs
std::vector< BoundaryID > getBoundaryIDs(const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown, const std::set< BoundaryID > &mesh_boundary_ids)
PolygonalMeshGenerationUtils::radiusCorrectionFactor
Real radiusCorrectionFactor(const std::vector< Real > &azimuthal_list, const bool full_circle=true, const unsigned int order=1, const bool is_first_value_vertex=true)
Makes radial correction to preserve ring area.
Definition PolygonalMeshGenerationUtils.C:54
libMesh::TensorTools::norm
auto norm(const T &a)
libMesh::index_range
auto index_range(const T &sizable)
libMesh::if
if(subdm)
libMesh::make_range
IntRange< T > make_range(T beg, T end)

◆ 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
patternpattern of cells used in this mesh generator
interface_boundary_id_shift_pattern2D pattern of shift values applied to the boundary IDs inside each pattern cells
boundary_idslist of boundary IDs on the mesh generated by this mesh generator
input_interface_boundary_idslist of interface boundary IDs of the pattern cells
use_interface_boundary_id_shiftwhether ID shifts are applied to interface boundary IDs of the pattern cells
create_interface_boundary_idwhether interface boundary IDs are generated by this mesh generator
num_extra_layersnumber 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.

1730{
1731 std::set<boundary_id_type> interface_boundary_ids;
1732 // add existing interface boundary ids from input meshes
1733 if (use_interface_boundary_id_shift)
1734 {
1735 for (const auto i : make_range(pattern.size()))
1736 for (const auto j : make_range(pattern[i].size()))
1737 {
1738 const auto & ids = input_interface_boundary_ids[pattern[i][j]];
1739 for (const auto & id : ids)
1740 {
1741 const boundary_id_type new_id = id + interface_boundary_id_shift_pattern[i][j];
1742 auto it = boundary_ids.find(new_id);
1743 if (it != boundary_ids.end())
1744 interface_boundary_ids.insert(new_id);
1745 }
1746 }
1747 }
1748 else
1749 {
1750 for (const auto & ids : input_interface_boundary_ids)
1751 for (const auto & id : ids)
1752 {
1753 auto it = boundary_ids.find(id);
1754 if (it != boundary_ids.end())
1755 interface_boundary_ids.insert(id);
1756 }
1757 }
1758 // add unshifted interface boundary ids for the duct & background regions
1759 if (create_interface_boundary_id)
1760 for (const auto i : make_range(num_extra_layers))
1761 {
1762 boundary_id_type id = SLICE_ALT + i * 2 + 1;
1763 auto it = boundary_ids.find(id);
1764 if (it != boundary_ids.end())
1765 interface_boundary_ids.insert(id);
1766 id = SLICE_ALT + i * 2;
1767 it = boundary_ids.find(id);
1768 if (it != boundary_ids.end())
1769 interface_boundary_ids.insert(id);
1770 }
1771 return interface_boundary_ids;
1772}
ReportingIDGeneratorUtils::AssignType::pattern
@ pattern
assign the same reporting IDs for all tiles in the pattern with same input

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

◆ 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_paramsoriginal multi boundary layer parameters
orderorder of the elements
Returns
modified multi boundary layer parameters

Definition at line 1775 of file PolygonMeshGeneratorBase.C.

1777{
1778 multiBdryLayerParams mod_multi_bdry_layer_params(original_multi_bdry_layer_params);
1779 std::for_each(mod_multi_bdry_layer_params.intervals.begin(),
1780 mod_multi_bdry_layer_params.intervals.end(),
1781 [&order](unsigned int & n) { n *= order; });
1782 std::for_each(mod_multi_bdry_layer_params.biases.begin(),
1783 mod_multi_bdry_layer_params.biases.end(),
1784 [&order](Real & n) { n = std::pow(n, 1.0 / order); });
1785 return mod_multi_bdry_layer_params;
1786}

Referenced by PolygonMeshGeneratorBase::buildSlice().

◆ 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_paramsoriginal single boundary layer parameters
orderorder of the elements
Returns
modified single boundary layer parameters

Definition at line 1789 of file PolygonMeshGeneratorBase.C.

1791{
1792 singleBdryLayerParams mod_single_bdry_layer_params(original_single_bdry_layer_params);
1793 mod_single_bdry_layer_params.intervals *= order;
1794 mod_single_bdry_layer_params.bias = std::pow(mod_single_bdry_layer_params.bias, 1.0 / order);
1795 return mod_single_bdry_layer_params;
1796}

Referenced by PolygonMeshGeneratorBase::buildSlice().

◆ nodeCoordRotate()

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

Calculates x and y coordinates after rotating by theta angle.

Parameters
xx coordinate of the node to be rotated
yy coordinate of the node to be rotated
thetarotation angle
Returns
n/a

Definition at line 1320 of file PolygonMeshGeneratorBase.C.

1321{
1322 const Real x_tmp = x;
1323 const Real y_tmp = y;
1324 x = x_tmp * std::cos(theta * M_PI / 180.0) - y_tmp * std::sin(theta * M_PI / 180.0);
1325 y = x_tmp * std::sin(theta * M_PI / 180.0) + y_tmp * std::cos(theta * M_PI / 180.0);
1326}

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

◆ 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_nameslist of input mesh generator names
metadata_valslist of input mesh metadata values
metadata_namename of the input mesh metadata
Returns
a string that contains the detailed metadata information

Definition at line 1799 of file PolygonMeshGeneratorBase.C.

1803{
1804 FormattedTable table;
1805 for (unsigned int i = 0; i < input_names.size(); i++)
1806 {
1807 table.addRow(i);
1808 table.addData<std::string>("input name", (std::string)input_names[i]);
1809 table.addData<Real>(metadata_name, metadata_vals[i]);
1810 }
1811 table.outputTimeColumn(false);
1812 std::stringstream detailed_error;
1813 table.printTable(detailed_error);
1814 return "\n" + detailed_error.str();
1815}
FormattedTable::printTable
void printTable(std::ostream &out, unsigned int last_n_entries=0)
FormattedTable::addData
void addData(const std::string &name, const T &value)
FormattedTable::addRow
void addRow(Real time)
FormattedTable::outputTimeColumn
void outputTimeColumn(bool output_time)

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

◆ 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_xx coordinate of the first inner side point (parallelogram vertex)
pi_1_yy coordinate of the first inner side point (parallelogram vertex)
po_1_xx coordinate of the first outer side point (parallelogram vertex)
po_1_yy coordinate of the first outer side point (parallelogram vertex)
pi_2_xx coordinate of the second inner side point (parallelogram vertex)
pi_2_yy coordinate of the second inner side point (parallelogram vertex)
po_2_xx coordinate of the second outer side point (parallelogram vertex)
po_2_yy coordinate of the second outer side point (parallelogram vertex)
ipassed loop index 1
jpassed loop index 2
num_sectors_per_sidenumber of azimuthal intervals
peripheral_invervalsnumber of radial intervals of the peripheral region
Returns
an interpolated position within a parallelogram

Definition at line 1293 of file PolygonMeshGeneratorBase.C.

1305{
1306 auto position_px_inner =
1307 (pi_1_x * (num_sectors_per_side / 2.0 - j) + pi_2_x * j) / (num_sectors_per_side / 2.0);
1308 auto position_py_inner =
1309 (pi_1_y * (num_sectors_per_side / 2.0 - j) + pi_2_y * j) / (num_sectors_per_side / 2.0);
1310 auto position_px_outer =
1311 (d_po_1_x * (num_sectors_per_side / 2.0 - j) + d_po_2_x * j) / (num_sectors_per_side / 2.0);
1312 auto position_py_outer =
1313 (d_po_1_y * (num_sectors_per_side / 2.0 - j) + d_po_2_y * j) / (num_sectors_per_side / 2.0);
1314 auto position_px = position_px_inner + position_px_outer * i / peripheral_intervals;
1315 auto position_py = position_py_inner + position_py_outer * i / peripheral_intervals;
1316 return std::make_pair(position_px, position_py);
1317}

Referenced by PolygonMeshGeneratorBase::buildSimplePeripheral().

◆ 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
meshinput mesh to create the elements onto
num_sectors_per_sidenumber of azimuthal intervals
subdomain_ringsnumbers of radial intervals of all involved subdomain layers
side_indexindex of the polygon side
azimuthal_tangentvector of tangent values of the azimuthal angles as reference for adaptive boundary matching
block_id_shiftshift of the subdomain ids generated by this function
nodeid_shiftshift of the node_ids of these elements
create_inward_interface_boundarieswhether inward interface boundary sidesets are created
create_outward_interface_boundarieswhether outward interface boundary sidesets are created
boundary_id_shiftshift of the interface boundary ids
generate_side_specific_boundarieswhether the side-specific external boundaries are generated or not
quad_elem_typetype of the quadrilateral elements to be generated

Definition at line 1053 of file PolygonMeshGeneratorBase.C.

1065{
1066 const unsigned short order = quad_elem_type == QUAD_ELEM_TYPE::QUAD4 ? 1 : 2;
1067 unsigned int angle_number = azimuthal_tangent.size() == 0
1068 ? num_sectors_per_side
1069 : ((azimuthal_tangent.size() - 1) / order);
1070
1071 BoundaryInfo & boundary_info = mesh.get_boundary_info();
1072 unsigned int j = 0;
1073 for (unsigned int k = 0; k < (subdomain_rings.size()); k++)
1074 {
1075 for (unsigned int m = 0; m < subdomain_rings[k]; m++)
1076 {
1077 for (unsigned int i = 1; i <= angle_number; i++)
1078 {
1079 std::unique_ptr<Elem> new_elem;
1080 if (quad_elem_type == QUAD_ELEM_TYPE::QUAD4)
1081 {
1082 new_elem = std::make_unique<Quad4>();
1083 new_elem->set_node(0, mesh.node_ptr(nodeid_shift + i + (angle_number + 1) * j));
1084 new_elem->set_node(1, mesh.node_ptr(nodeid_shift + i + 1 + (angle_number + 1) * j));
1085 new_elem->set_node(2, mesh.node_ptr(nodeid_shift + i + (angle_number + 1) * (j + 1) + 1));
1086 new_elem->set_node(3, mesh.node_ptr(nodeid_shift + i + (angle_number + 1) * (j + 1)));
1087 }
1088 else // QUAD8/QUAD9
1089 {
1090 new_elem = std::make_unique<Quad8>();
1091 if (quad_elem_type == QUAD_ELEM_TYPE::QUAD9)
1092 {
1093 new_elem = std::make_unique<Quad9>();
1094 new_elem->set_node(
1095 8, mesh.node_ptr(nodeid_shift + i * 2 + (angle_number * 2 + 1) * (j * 2 + 2)));
1096 }
1097 new_elem->set_node(
1098 0,
1099 mesh.node_ptr(nodeid_shift + (i - 1) * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 1)));
1100 new_elem->set_node(
1101 1, mesh.node_ptr(nodeid_shift + i * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 1)));
1102 new_elem->set_node(
1103 2, mesh.node_ptr(nodeid_shift + i * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 3)));
1104 new_elem->set_node(
1105 3,
1106 mesh.node_ptr(nodeid_shift + (i - 1) * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 3)));
1107 new_elem->set_node(
1108 4, mesh.node_ptr(nodeid_shift + i * 2 + (angle_number * 2 + 1) * (j * 2 + 1)));
1109 new_elem->set_node(
1110 5, mesh.node_ptr(nodeid_shift + i * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 2)));
1111 new_elem->set_node(
1112 6, mesh.node_ptr(nodeid_shift + i * 2 + (angle_number * 2 + 1) * (j * 2 + 3)));
1113 new_elem->set_node(
1114 7,
1115 mesh.node_ptr(nodeid_shift + (i - 1) * 2 + 1 + (angle_number * 2 + 1) * (j * 2 + 2)));
1116 }
1117 Elem * elem = mesh.add_elem(std::move(new_elem));
1118 if (i == 1)
1119 boundary_info.add_side(elem, 3, SLICE_BEGIN);
1120 if (i == angle_number)
1121 boundary_info.add_side(elem, 1, SLICE_END);
1122
1123 if (subdomain_rings[0] == 0)
1124 elem->subdomain_id() = k + 1 + block_id_shift;
1125 else
1126 elem->subdomain_id() = k + 2 + block_id_shift;
1127
1128 if (m == 0 && create_inward_interface_boundaries && k > 0)
1129 boundary_info.add_side(elem, 0, k * 2 + boundary_id_shift);
1130 if (m == (subdomain_rings[k] - 1))
1131 {
1132 if (k == (subdomain_rings.size() - 1))
1133 {
1134 boundary_info.add_side(elem, 2, OUTER_SIDESET_ID);
1135 if (generate_side_specific_boundaries)
1136 {
1137 if (i <= angle_number / 2)
1138 boundary_info.add_side(elem, 2, OUTER_SIDESET_ID + side_index);
1139 else
1140 boundary_info.add_side(elem, 2, OUTER_SIDESET_ID_ALT + side_index);
1141 }
1142 }
1143 else if (create_outward_interface_boundaries)
1144 boundary_info.add_side(elem, 2, k * 2 + 1 + boundary_id_shift);
1145 }
1146 }
1147 j++;
1148 }
1149 }
1150}

Referenced by PolygonMeshGeneratorBase::buildSlice().

◆ 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
meshinput mesh
id_shiftID shift value to be applied
boundary_idslist of boundary IDs to be reassigned
reverseremove boundary ID shift

Definition at line 1703 of file PolygonMeshGeneratorBase.C.

1707{
1708 const std::set<boundary_id_type> existing_boundary_ids =
1709 mesh.get_boundary_info().get_boundary_ids();
1710 for (const auto id : boundary_ids)
1711 {
1712
1713 const boundary_id_type old_id = (!reverse) ? id : id + id_shift;
1714 const boundary_id_type new_id = (!reverse) ? id + id_shift : id;
1715 auto it = existing_boundary_ids.find(old_id);
1716 if (it != existing_boundary_ids.end())
1717 MooseMesh::changeBoundaryId(mesh, old_id, new_id, true);
1718 }
1719}
libMesh::BoundaryInfo::get_boundary_ids
const std::set< boundary_id_type > & get_boundary_ids() const

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

◆ ringBlockIdsNamesPreparer()

void ConcentricCircleGeneratorBase::ringBlockIdsNamesPreparer ( unsigned int &  block_counter,
unsigned int &  ring_block_num,
std::vector< subdomain_id_type > &  block_ids_old,
std::vector< subdomain_id_type > &  block_ids_new,
std::vector< SubdomainName > &  block_names 
) const
protectedinherited

Prepare user-defined ring block IDs and names to replace the default ones.

Parameters
block_countera counter to keep track of the number of blocks
ring_block_numnumber of blocks in the ring region
block_ids_oldold block ids that are assigned by default
block_ids_newnew block ids that are user-defined
block_namesblock names that are user-defined

Definition at line 260 of file ConcentricCircleGeneratorBase.C.

266{
267 if (_ring_intervals.front() == 1)
268 ring_block_num = _ring_intervals.size();
269 else
270 {
271 ring_block_num = _ring_intervals.size() + 1;
272 block_ids_old.push_back(_block_id_shift + 1);
273 block_ids_new.push_back(_ring_block_ids.empty() ? block_ids_old.back()
274 : _ring_block_ids.front());
275 block_names.push_back(_ring_block_names.empty()
276 ? (SubdomainName)std::to_string(block_ids_new.back())
277 : _ring_block_names.front());
278 block_counter++;
279 }
280 for (unsigned int i = ring_block_num - _ring_intervals.size(); i < ring_block_num; i++)
281 {
282 block_ids_old.push_back(_block_id_shift + 1 + i);
283 block_ids_new.push_back(_ring_block_ids.empty() ? block_ids_old.back() : _ring_block_ids[i]);
284 block_names.push_back(_ring_block_names.empty()
285 ? (SubdomainName)std::to_string(block_ids_new.back())
286 : _ring_block_names[i]);
287 block_counter++;
288 }
289}
ConcentricCircleGeneratorBase::_ring_block_ids
std::vector< subdomain_id_type > _ring_block_ids
Subdomain IDs of the ring regions.
Definition ConcentricCircleGeneratorBase.h:39
ConcentricCircleGeneratorBase::_ring_block_names
std::vector< SubdomainName > _ring_block_names
Subdomain Names of the ring regions.
Definition ConcentricCircleGeneratorBase.h:41

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

◆ 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
meshinput mesh to add the nodes onto
ring_radiiradii of the ring regions
ring_layersnumbers of radial intervals of the ring regions
biased_termsnormalized spacing values used for radial meshing biasing in ring regions
num_sectors_per_sidenumber of azimuthal intervals
corner_p[2][2]array contains the coordinates of the corner positions
corner_to_cornerdiameter of the circumscribed circle of the polygon
azimuthal_tangentvector of tangent values of the azimuthal angles as reference for adaptive boundary matching

Definition at line 656 of file PolygonMeshGeneratorBase.C.

664{
665 const unsigned int angle_number =
666 azimuthal_tangent.size() == 0 ? num_sectors_per_side : (azimuthal_tangent.size() - 1);
667
668 // Add nodes in pins regions
669 for (unsigned int l = 0; l < ring_layers.size(); l++)
670 {
671 // the pin radius interval for each ring_radii/subdomain
672 const Real pin_radius_interval_length =
673 l == 0 ? ring_radii[l] / ring_layers[l]
674 : (ring_radii[l] - ring_radii[l - 1]) / ring_layers[l];
675
676 // add rings in each pin subdomain
677 for (unsigned int k = 0; k < ring_layers[l]; k++)
678 {
679 const Real bin_radial_distance =
680 l == 0 ? (biased_terms[l][k] * ring_layers[l] *
681 pin_radius_interval_length) // this is from the cell/pin center to
682 // the first circle
683 : (ring_radii[l - 1] +
684 biased_terms[l][k] * ring_layers[l] * pin_radius_interval_length);
685 const Real pin_corner_p_x = corner_p[0][0] * bin_radial_distance / (0.5 * corner_to_corner);
686 const Real pin_corner_p_y = corner_p[0][1] * bin_radial_distance / (0.5 * corner_to_corner);
687
688 // pin_corner_p(s) are the points in the pin region, on the bins towards the six corners,
689 // at different intervals
690 mesh.add_point(Point(pin_corner_p_x, pin_corner_p_y, 0.0));
691
692 for (unsigned int j = 1; j <= angle_number; j++)
693 {
694 const Real cell_boundary_p_x =
695 corner_p[0][0] + (corner_p[1][0] - corner_p[0][0]) *
696 (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
697 : (azimuthal_tangent[j] / 2.0));
698 const Real cell_boundary_p_y =
699 corner_p[0][1] + (corner_p[1][1] - corner_p[0][1]) *
700 (azimuthal_tangent.size() == 0 ? ((Real)j / (Real)angle_number)
701 : (azimuthal_tangent[j] / 2.0));
702 // cell_boundary_p(s) are the points on the cell's six boundaries (flat sides) at
703 // different azimuthal angles
704 const Real pin_azimuthal_p_x =
705 cell_boundary_p_x * bin_radial_distance /
706 std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
707 const Real pin_azimuthal_p_y =
708 cell_boundary_p_y * bin_radial_distance /
709 std::sqrt(Utility::pow<2>(cell_boundary_p_x) + Utility::pow<2>(cell_boundary_p_y));
710
711 // pin_azimuthal_p are the points on the bins towards different azimuthal angles, at
712 // different intervals; excluding the ones produced by pin_corner_p
713 mesh.add_point(Point(pin_azimuthal_p_x, pin_azimuthal_p_y, 0.0));
714 }
715 }
716 }
717}

Referenced by PolygonMeshGeneratorBase::buildSlice().

◆ 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
meshinput mesh where ring extra ids are assigned
id_namering extra id name
num_sidesnumber of polygon sides
num_sectors_per_sidenumber of sectors of each side of the polygon
ring_intervalsnumber of rings in each circle
ring_wise_idwhether ring ids are assigned to each ring or to each block
quad_center_elementswhether center elements are quad or triangular

Definition at line 1638 of file PolygonMeshGeneratorBase.C.

1645{
1646 // this function assumes that elements are ordered by rings (inner) then by sectors (outer
1647 // ordering)
1648 const auto extra_id_index = mesh.add_elem_integer(id_name);
1649 auto elem_it = mesh.elements_begin();
1650 for (unsigned int is = 0; is < num_sides; ++is)
1651 {
1652 // number of elements in the current sector
1653 unsigned int nelem = mesh.n_elem() * num_sectors_per_side[is] /
1654 (accumulate(num_sectors_per_side.begin(), num_sectors_per_side.end(), 0));
1655 if (!ring_wise_id)
1656 {
1657 for (unsigned int ir : index_range(ring_intervals))
1658 {
1659 // number of elements in the current ring and sector
1660 unsigned int nelem_annular_ring = num_sectors_per_side[is] * ring_intervals[ir];
1661 // if _quad_center_elements is true, the number of elements in center ring are
1662 // _num_sectors_per_side[is] * _num_sectors_per_side[is] / 4
1663 if (quad_center_elements && ir == 0)
1664 nelem_annular_ring = num_sectors_per_side[is] * (ring_intervals[ir] - 1) +
1665 num_sectors_per_side[is] * num_sectors_per_side[is] / 4;
1666 // assign ring id
1667 for (unsigned i = 0; i < nelem_annular_ring; ++i, ++elem_it)
1668 (*elem_it)->set_extra_integer(extra_id_index, ir + 1);
1669 // update number of elements in background region of current side.
1670 nelem -= nelem_annular_ring;
1671 }
1672 }
1673 else
1674 {
1675 unsigned int ir = 0;
1676 for (unsigned int ir0 : index_range(ring_intervals))
1677 {
1678 for (unsigned int ir1 = 0; ir1 < ring_intervals[ir0]; ++ir1)
1679 {
1680 // number of elements in the current ring and sector
1681 unsigned int nelem_annular_ring = num_sectors_per_side[is];
1682 // if _quad_center_elements is true, the number of elements in center ring are
1683 // _num_sectors_per_side[is] * _num_sectors_per_side[is] / 4
1684 if (quad_center_elements && ir == 0)
1685 nelem_annular_ring = num_sectors_per_side[is] * num_sectors_per_side[is] / 4;
1686 // assign ring id
1687 for (unsigned i = 0; i < nelem_annular_ring; ++i, ++elem_it)
1688 (*elem_it)->set_extra_integer(extra_id_index, ir + 1);
1689 // update ring id
1690 ++ir;
1691 // update number of elements in background region of current side.
1692 nelem -= nelem_annular_ring;
1693 }
1694 }
1695 }
1696 // assign ring id of 0 to the background region
1697 for (unsigned i = 0; i < nelem; ++i, ++elem_it)
1698 (*elem_it)->set_extra_integer(extra_id_index, 0);
1699 }
1700}
libMesh::MeshBase::n_elem
virtual dof_id_type n_elem() const=0
libMesh::MeshBase::add_elem_integer
unsigned int add_elem_integer(std::string name, bool allocate_data=true, dof_id_type default_value=DofObject::invalid_id)
libMesh::is
PetscErrorCode PetscInt const PetscInt IS * is

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

◆ 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
meshinput mesh where sector extra ids are assigned
id_namesector extra ID name
num_sidenumber of polygon sides
num_sectors_per_sidenumber of sections of each side of the polygon

Definition at line 1613 of file PolygonMeshGeneratorBase.C.

1617{
1618 const auto extra_id_index = mesh.add_elem_integer(id_name);
1619 // vector to store sector ids for each element
1620 auto elem_it = mesh.elements_begin();
1621 unsigned int id = 1;
1622 // starting element id of the current sector
1623 for (unsigned int is = 0; is < num_sides; ++is)
1624 {
1625 // number of elements in the current sector
1626 unsigned int nelem_sector =
1627 mesh.n_elem() * num_sectors_per_side[is] /
1628 (accumulate(num_sectors_per_side.begin(), num_sectors_per_side.end(), 0));
1629 // assign sector ids to mesh
1630 for (unsigned i = 0; i < nelem_sector; ++i, ++elem_it)
1631 (*elem_it)->set_extra_integer(extra_id_index, id);
1632 // update sector id
1633 ++id;
1634 }
1635}

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

◆ validParams()

InputParameters PolygonConcentricCircleMeshGenerator::validParams ( )
static

Definition at line 17 of file PolygonConcentricCircleMeshGenerator.C.

18{
19 InputParameters params = PolygonConcentricCircleMeshGeneratorBase::validParams();
20 params.addRequiredRangeCheckedParam<Real>("polygon_size",
21 "polygon_size>0.0",
22 "Size of the polygon to be generated (given as either "
23 "apothem or radius depending on polygon_size_style).");
24 MooseEnum polygon_size_style("apothem radius", "apothem");
25 params.addParam<MooseEnum>("polygon_size_style",
26 polygon_size_style,
27 "Style in which polygon size is given (default: apothem).");
28 params.addRangeCheckedParam<unsigned int>(
29 "num_sides", 6, "num_sides>=3", "Number of sides of the polygon.");
30 params.addClassDescription("This PolygonConcentricCircleMeshGenerator object is designed to mesh "
31 "a polygon geometry with optional rings centered inside.");
32
33 return params;
34}
InputParameters::addRequiredRangeCheckedParam
void addRequiredRangeCheckedParam(const std::string &name, const std::string &parsed_function, const std::string &doc_string)
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
InputParameters::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)

Member Data Documentation

◆ _azimuthal_angles_array

std::vector<std::vector<Real> > PolygonConcentricCircleMeshGeneratorBase::_azimuthal_angles_array
protectedinherited

Azimuthal angles of all radial nodes for volume preservation.

Definition at line 89 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _background_block_ids

std::vector<subdomain_id_type> PolygonConcentricCircleMeshGeneratorBase::_background_block_ids
protectedinherited

Subdomain IDs of the background regions.

Definition at line 65 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _background_block_names

std::vector<SubdomainName> PolygonConcentricCircleMeshGeneratorBase::_background_block_names
protectedinherited

Subdomain Names of the background regions.

Definition at line 67 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _background_inner_boundary_layer_params

singleBdryLayerParams PolygonConcentricCircleMeshGeneratorBase::_background_inner_boundary_layer_params
protectedinherited

Width, fraction, radiation sectors and growth factor of the inner boundary layer of the background region.

Definition at line 61 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _background_intervals

const unsigned int PolygonConcentricCircleMeshGeneratorBase::_background_intervals
protectedinherited

Numbers of radial intervals of the background regions.

Definition at line 57 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _background_outer_boundary_layer_params

singleBdryLayerParams PolygonConcentricCircleMeshGeneratorBase::_background_outer_boundary_layer_params
protectedinherited

Width, fraction, radiation sectors and growth factor of the outer boundary layer of the background region.

Definition at line 63 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _background_radial_bias

const Real PolygonConcentricCircleMeshGeneratorBase::_background_radial_bias
protectedinherited

Bias value used to induce biasing to radial meshing in background region.

Definition at line 59 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _block_id_shift

const subdomain_id_type ConcentricCircleGeneratorBase::_block_id_shift
protectedinherited

Shift in default subdomain IDs to avert potential conflicts with other meshes.

Definition at line 45 of file ConcentricCircleGeneratorBase.h.

Referenced by AdvancedConcentricCircleGenerator::generate(), PolygonConcentricCircleMeshGeneratorBase::generate(), and ConcentricCircleGeneratorBase::ringBlockIdsNamesPreparer().

◆ _center_quad_factor

const Real PolygonConcentricCircleMeshGeneratorBase::_center_quad_factor
protectedinherited

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)

Definition at line 73 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _create_inward_interface_boundaries

const bool ConcentricCircleGeneratorBase::_create_inward_interface_boundaries
protectedinherited

Whether inward interface boundaries are created.

Definition at line 47 of file ConcentricCircleGeneratorBase.h.

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

◆ _create_outward_interface_boundaries

const bool ConcentricCircleGeneratorBase::_create_outward_interface_boundaries
protectedinherited

Whether outward interface boundaries are created.

Definition at line 49 of file ConcentricCircleGeneratorBase.h.

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

◆ _duct_block_ids

const std::vector<subdomain_id_type> PolygonConcentricCircleMeshGeneratorBase::_duct_block_ids
protectedinherited

Subdomain IDs of the duct regions.

Definition at line 43 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _duct_block_names

const std::vector<SubdomainName> PolygonConcentricCircleMeshGeneratorBase::_duct_block_names
protectedinherited

Subdomain Names of the duct regions.

Definition at line 45 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _duct_inner_boundary_layer_params

multiBdryLayerParams PolygonConcentricCircleMeshGeneratorBase::_duct_inner_boundary_layer_params
protectedinherited

Widths, fractions, radial sectors and growth factors of the inner boundary layers of the duct regions.

Definition at line 39 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _duct_intervals

const std::vector<unsigned int> PolygonConcentricCircleMeshGeneratorBase::_duct_intervals
protectedinherited

Number of layers in each enclosing duct.

Definition at line 35 of file PolygonConcentricCircleMeshGeneratorBase.h.

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

◆ _duct_outer_boundary_layer_params

multiBdryLayerParams PolygonConcentricCircleMeshGeneratorBase::_duct_outer_boundary_layer_params
protectedinherited

Widths, fractions, radial sectors and growth factors of the inner boundary layers of the duct regions.

Definition at line 41 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _duct_radial_biases

const std::vector<Real> PolygonConcentricCircleMeshGeneratorBase::_duct_radial_biases
protectedinherited

Bias values used to induce biasing to radial meshing in duct regions.

Definition at line 37 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _duct_sizes

std::vector<Real> PolygonConcentricCircleMeshGeneratorBase::_duct_sizes
protectedinherited

Size parameters of the duct regions.

Definition at line 33 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _duct_sizes_style

const PolygonSizeStyle PolygonConcentricCircleMeshGeneratorBase::_duct_sizes_style
protectedinherited

Thickness of each enclosing duct.

Definition at line 31 of file PolygonConcentricCircleMeshGeneratorBase.h.

◆ _external_boundary_id

const boundary_id_type ConcentricCircleGeneratorBase::_external_boundary_id
protectedinherited

Boundary ID of the mesh's external boundary.

Definition at line 55 of file ConcentricCircleGeneratorBase.h.

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

◆ _external_boundary_name

const BoundaryName ConcentricCircleGeneratorBase::_external_boundary_name
protectedinherited

Boundary Name of the mesh's external boundary.

Definition at line 57 of file ConcentricCircleGeneratorBase.h.

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

◆ _generate_side_specific_boundaries

const bool ConcentricCircleGeneratorBase::_generate_side_specific_boundaries
protectedinherited

Whether the side-specific external boundaries are generated or not.

Definition at line 53 of file ConcentricCircleGeneratorBase.h.

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

◆ _has_ducts

const bool PolygonConcentricCircleMeshGeneratorBase::_has_ducts
protectedinherited

Whether the generated mesh contains duct regions.

Definition at line 49 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _has_rings

const bool PolygonConcentricCircleMeshGeneratorBase::_has_rings
protectedinherited

Whether the generated mesh contains ring regions.

Definition at line 47 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _input_ptrs

std::vector<std::unique_ptr<MeshBase> *> PolygonConcentricCircleMeshGeneratorBase::_input_ptrs
protectedinherited

Pointers to input mesh pointers.

Definition at line 79 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by CartesianConcentricCircleAdaptiveBoundaryMeshGenerator::CartesianConcentricCircleAdaptiveBoundaryMeshGenerator(), PolygonConcentricCircleMeshGeneratorBase::generate(), and HexagonConcentricCircleAdaptiveBoundaryMeshGenerator::HexagonConcentricCircleAdaptiveBoundaryMeshGenerator().

◆ _interface_boundary_id_shift

const boundary_id_type ConcentricCircleGeneratorBase::_interface_boundary_id_shift
protectedinherited

Shift in default boundary IDs of interfaces to avert potential conflicts.

Definition at line 51 of file ConcentricCircleGeneratorBase.h.

Referenced by ConcentricCircleGeneratorBase::assignInterfaceBoundaryNames(), AdvancedConcentricCircleGenerator::generate(), and PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _inward_interface_boundary_names

const std::vector<std::string> ConcentricCircleGeneratorBase::_inward_interface_boundary_names
protectedinherited

Boundary Names of the mesh's inward interface boundaries.

Definition at line 59 of file ConcentricCircleGeneratorBase.h.

Referenced by AdvancedConcentricCircleGenerator::AdvancedConcentricCircleGenerator(), and ConcentricCircleGeneratorBase::assignInterfaceBoundaryNames().

◆ _is_control_drum_meta

bool& PolygonConcentricCircleMeshGeneratorBase::_is_control_drum_meta
protectedinherited

MeshMetaData: whether this produced mesh is a control drum.

Definition at line 85 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by CartesianConcentricCircleAdaptiveBoundaryMeshGenerator::CartesianConcentricCircleAdaptiveBoundaryMeshGenerator(), and HexagonConcentricCircleAdaptiveBoundaryMeshGenerator::HexagonConcentricCircleAdaptiveBoundaryMeshGenerator().

◆ _is_general_polygon

bool PolygonConcentricCircleMeshGeneratorBase::_is_general_polygon
protectedinherited

MeshMetaData: whether this produced mesh is a general polygon (or a hexagon)

Definition at line 81 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by CartesianConcentricCircleAdaptiveBoundaryMeshGenerator::CartesianConcentricCircleAdaptiveBoundaryMeshGenerator(), PolygonConcentricCircleMeshGeneratorBase::generate(), HexagonConcentricCircleAdaptiveBoundaryMeshGenerator::HexagonConcentricCircleAdaptiveBoundaryMeshGenerator(), and PolygonConcentricCircleMeshGenerator().

◆ _node_id_background_meta

dof_id_type& PolygonConcentricCircleMeshGeneratorBase::_node_id_background_meta
protectedinherited

MeshMetaData: maximum node id of the background region.

Definition at line 83 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _num_sectors_per_side

const std::vector<unsigned int> PolygonConcentricCircleMeshGeneratorBase::_num_sectors_per_side
protectedinherited

Mesh sector number of each polygon side.

Definition at line 55 of file PolygonConcentricCircleMeshGeneratorBase.h.

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

◆ _num_sides

const unsigned int PolygonConcentricCircleMeshGeneratorBase::_num_sides
protectedinherited

Number of polygon sides.

Definition at line 29 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _order

unsigned short ConcentricCircleGeneratorBase::_order
protectedinherited

Order of the elements to be generated.

Definition at line 67 of file ConcentricCircleGeneratorBase.h.

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

◆ _outward_interface_boundary_names

const std::vector<std::string> ConcentricCircleGeneratorBase::_outward_interface_boundary_names
protectedinherited

Boundary Names of the mesh's outward interface boundaries.

Definition at line 61 of file ConcentricCircleGeneratorBase.h.

Referenced by AdvancedConcentricCircleGenerator::AdvancedConcentricCircleGenerator(), and ConcentricCircleGeneratorBase::assignInterfaceBoundaryNames().

◆ _pitch

Real PolygonConcentricCircleMeshGeneratorBase::_pitch
protectedinherited

Pitch size of the produced polygon.

Definition at line 87 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _polygon_size

const Real PolygonConcentricCircleMeshGeneratorBase::_polygon_size
protectedinherited

Polygon size parameter.

Definition at line 53 of file PolygonConcentricCircleMeshGeneratorBase.h.

◆ _polygon_size_style

const PolygonSizeStyle PolygonConcentricCircleMeshGeneratorBase::_polygon_size_style
protectedinherited

Type of polygon size parameter.

Definition at line 51 of file PolygonConcentricCircleMeshGeneratorBase.h.

◆ _preserve_volumes

const bool ConcentricCircleGeneratorBase::_preserve_volumes
protectedinherited

Volume preserving function is optional.

Definition at line 43 of file ConcentricCircleGeneratorBase.h.

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

◆ _quad_center_elements

const bool PolygonConcentricCircleMeshGeneratorBase::_quad_center_elements
protectedinherited

Whether the central elements need to be QUAD4.

Definition at line 71 of file PolygonConcentricCircleMeshGeneratorBase.h.

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

◆ _quad_elem_type

QUAD_ELEM_TYPE ConcentricCircleGeneratorBase::_quad_elem_type
protectedinherited

Type of quadrilateral elements to be generated.

Definition at line 65 of file ConcentricCircleGeneratorBase.h.

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

◆ _ring_block_ids

std::vector<subdomain_id_type> ConcentricCircleGeneratorBase::_ring_block_ids
protectedinherited

Subdomain IDs of the ring regions.

Definition at line 39 of file ConcentricCircleGeneratorBase.h.

Referenced by AdvancedConcentricCircleGenerator::AdvancedConcentricCircleGenerator(), and ConcentricCircleGeneratorBase::ringBlockIdsNamesPreparer().

◆ _ring_block_names

std::vector<SubdomainName> ConcentricCircleGeneratorBase::_ring_block_names
protectedinherited

Subdomain Names of the ring regions.

Definition at line 41 of file ConcentricCircleGeneratorBase.h.

Referenced by AdvancedConcentricCircleGenerator::AdvancedConcentricCircleGenerator(), and ConcentricCircleGeneratorBase::ringBlockIdsNamesPreparer().

◆ _ring_inner_boundary_layer_params

multiBdryLayerParams ConcentricCircleGeneratorBase::_ring_inner_boundary_layer_params
protectedinherited

Widths, fractions, radial sectors and growth factors of the inner boundary layers of the ring regions.

Definition at line 35 of file ConcentricCircleGeneratorBase.h.

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

◆ _ring_intervals

const std::vector<unsigned int> ConcentricCircleGeneratorBase::_ring_intervals
protectedinherited

Number of rings in each circle or in the enclosing square.

Definition at line 31 of file ConcentricCircleGeneratorBase.h.

Referenced by AdvancedConcentricCircleGenerator::AdvancedConcentricCircleGenerator(), ConcentricCircleGeneratorBase::ConcentricCircleGeneratorBase(), AdvancedConcentricCircleGenerator::generate(), PolygonConcentricCircleMeshGeneratorBase::generate(), and ConcentricCircleGeneratorBase::ringBlockIdsNamesPreparer().

◆ _ring_outer_boundary_layer_params

multiBdryLayerParams ConcentricCircleGeneratorBase::_ring_outer_boundary_layer_params
protectedinherited

Widths, fractions, radial sectors and growth factors of the outer boundary layers of the ring regions.

Definition at line 37 of file ConcentricCircleGeneratorBase.h.

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

◆ _ring_radial_biases

const std::vector<Real> ConcentricCircleGeneratorBase::_ring_radial_biases
protectedinherited

Bias values used to induce biasing to radial meshing in ring regions.

Definition at line 33 of file ConcentricCircleGeneratorBase.h.

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

◆ _ring_radii

const std::vector<Real> ConcentricCircleGeneratorBase::_ring_radii
protectedinherited

Radii of concentric circles.

Definition at line 29 of file ConcentricCircleGeneratorBase.h.

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

◆ _sides_to_adapt

const std::vector<unsigned int> PolygonConcentricCircleMeshGeneratorBase::_sides_to_adapt
protectedinherited

Indices of the hexagon sides that need to adapt.

Definition at line 77 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by CartesianConcentricCircleAdaptiveBoundaryMeshGenerator::CartesianConcentricCircleAdaptiveBoundaryMeshGenerator(), PolygonConcentricCircleMeshGeneratorBase::generate(), and HexagonConcentricCircleAdaptiveBoundaryMeshGenerator::HexagonConcentricCircleAdaptiveBoundaryMeshGenerator().

◆ _smoothing_max_it

const unsigned int PolygonConcentricCircleMeshGeneratorBase::_smoothing_max_it
protectedinherited

Maximum smooth iteration number.

Definition at line 75 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

◆ _tri_elem_type

TRI_ELEM_TYPE ConcentricCircleGeneratorBase::_tri_elem_type
protectedinherited

Type of triangular elements to be generated.

Definition at line 63 of file ConcentricCircleGeneratorBase.h.

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

◆ _uniform_mesh_on_sides

const bool PolygonConcentricCircleMeshGeneratorBase::_uniform_mesh_on_sides
protectedinherited

Whether the nodes on the external boundary needs to be uniformly distributed.

Definition at line 69 of file PolygonConcentricCircleMeshGeneratorBase.h.

Referenced by PolygonConcentricCircleMeshGeneratorBase::generate().

The documentation for this class was generated from the following files:
Generated on Fri Aug 21 2026 13:43:33 for https://mooseframework.inl.gov by doxygen 1.9.8