RevolveGenerator.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 "PolygonMeshGeneratorBase.h"

class RevolveGenerator : public PolygonMeshGeneratorBase
{
public:
  static InputParameters validParams();

  RevolveGenerator(const InputParameters & parameters);

  std::unique_ptr<MeshBase> generate() override;

protected:
  std::unique_ptr<MeshBase> & _input;

  const Point & _axis_point;

  const Point & _axis_direction;

  const std::vector<Real> _revolving_angles;

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

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

  const std::vector<std::string> & _elem_integer_names_to_swap;
  std::vector<unsigned int> _elem_integer_indices_to_swap;

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

  const bool & _clockwise;

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

  const bool _preserve_volumes;

  bool _has_start_boundary;

  boundary_id_type _start_boundary;

  bool _has_end_boundary;

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

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

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

  bool _full_circle_revolving;

  std::vector<Real> _unit_angles;

  boundary_id_type _end_boundary;

  Real _radius_correction_factor;

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

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

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

  void nodeModification(Node & node);

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

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

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

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

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

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

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

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