PolygonMeshGeneratorBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "MeshGenerator.h"
#include "MooseEnum.h"
#include "CastUniquePointer.h"
#include "MooseMeshUtils.h"
#include "libmesh/replicated_mesh.h"
#include "libmesh/mesh_modification.h"
#include "libmesh/face_quad4.h"
#include "libmesh/face_quad8.h"
#include "libmesh/face_quad9.h"
#include "libmesh/face_tri3.h"
#include "libmesh/face_tri6.h"
#include "libmesh/face_tri7.h"
#include "libmesh/serial_mesh.h"
#include "libmesh/boundary_info.h"
#include "libmesh/utility.h"
 
class PolygonMeshGeneratorBase : public MeshGenerator
{
public:
  static InputParameters validParams();
 
  PolygonMeshGeneratorBase(const InputParameters & parameters);
 
  virtual std::unique_ptr<MeshBase> generate() override;
 
  enum class PolygonSizeStyle
  {
    apothem,
    radius
  };
 
  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
  };
  // boundary_id_type is short int so max is 32,767
  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
  };
 
  struct multiBdryLayerParams
  {
    std::vector<Real> widths;
    std::vector<Real> fractions;
    std::vector<unsigned int> intervals;
    std::vector<Real> biases;
  };
  struct singleBdryLayerParams
  {
    Real width;
    Real fraction;
    unsigned int intervals;
    Real bias;
  };
 
protected:
  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);
 
  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);
 
  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);
 
  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;
 
  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;
 
  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;
 
  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;
 
  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;
 
  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;
 
  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;
 
  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);
 
  void adjustPeripheralQuadraticElements(MeshBase & out_mesh,
                                         const QUAD_ELEM_TYPE boundary_quad_elem_type) const;
 
  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;
 
  void nodeCoordRotate(Real & x, Real & y, const Real theta) const;
 
  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;
 
  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;
 
  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;
 
  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;
 
  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;
 
  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;
 
  static void addRingAndSectorIDParams(InputParameters & params);
 
  void setSectorExtraIDs(MeshBase & mesh,
                         const std::string id_name,
                         const unsigned int num_sides,
                         const std::vector<unsigned int> num_sectors_per_side);
 
  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);
 
  void reassignBoundaryIDs(MeshBase & mesh,
                           const boundary_id_type id_shift,
                           const std::set<boundary_id_type> & boundary_ids,
                           const bool reverse = false);
 
  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;
 
  multiBdryLayerParams
  modifiedMultiBdryLayerParamsCreator(const multiBdryLayerParams & original_multi_bdry_layer_params,
                                      const unsigned int order) const;
 
  singleBdryLayerParams modifiedSingleBdryLayerParamsCreator(
      const singleBdryLayerParams & original_single_bdry_layer_params,
      const unsigned int order) const;
 
  std::string pitchMetaDataErrorGenerator(const std::vector<MeshGeneratorName> & input_names,
                                          const std::vector<Real> & metadata_vals,
                                          const std::string & metadata_name) const;
};