MooseMeshElementConversionUtils.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 "libmesh/replicated_mesh.h"

#include "MooseTypes.h"

namespace MooseMeshElementConversionUtils
{
// Define for comparing the key value of BCTuple
struct BCTupleKeyComp
{
  bool operator()(const libMesh::BoundaryInfo::BCTuple & s, dof_id_type i) const
  {
    return std::get<0>(s) < i;
  }
  bool operator()(dof_id_type i, const libMesh::BoundaryInfo::BCTuple & s) const
  {
    return i < std::get<0>(s);
  }
};

void hexElemSplitter(MeshBase & mesh,
                     const std::vector<libMesh::BoundaryInfo::BCTuple> & bdry_side_list,
                     const dof_id_type elem_id,
                     std::vector<dof_id_type> & converted_elems_ids);

void pyramidElemSplitter(MeshBase & mesh,
                         const std::vector<libMesh::BoundaryInfo::BCTuple> & bdry_side_list,
                         const dof_id_type elem_id,
                         std::vector<dof_id_type> & converted_elems_ids);

void prismElemSplitter(MeshBase & mesh,
                       const std::vector<libMesh::BoundaryInfo::BCTuple> & bdry_side_list,
                       const dof_id_type elem_id,
                       std::vector<dof_id_type> & converted_elems_ids);

void polyhedronElemSplitter(MeshBase & mesh,
                            const std::vector<libMesh::BoundaryInfo::BCTuple> & bdry_side_list,
                            const dof_id_type elem_id,
                            std::vector<dof_id_type> & converted_elems_ids);

void nodeRotationHEX8(const unsigned int min_id_index,
                      const unsigned int sec_min_pos,
                      std::vector<unsigned int> & face_rotation,
                      std::vector<unsigned int> & node_rotation);

std::vector<unsigned int> neighborNodeIndicesHEX8(unsigned int min_id_index);

void hexNodesToTetNodesDeterminer(std::vector<const Node *> & hex_nodes,
                                  std::vector<std::vector<unsigned int>> & rotated_tet_face_indices,
                                  std::vector<std::vector<const Node *>> & tet_nodes_list);

std::vector<bool> quadFaceDiagonalDirectionsHex(const std::vector<const Node *> & hex_nodes);

bool quadFaceDiagonalDirection(const std::vector<const Node *> & quad_nodes);

std::vector<std::vector<unsigned int>>
tetNodesForHex(const std::vector<bool> diagonal_directions,
               std::vector<std::vector<unsigned int>> & tet_face_indices);

void nodeRotationPRISM6(unsigned int min_id_index,
                        std::vector<unsigned int> & face_rotation,
                        std::vector<unsigned int> & node_rotation);

void
prismNodesToTetNodesDeterminer(std::vector<const Node *> & prism_nodes,
                               std::vector<std::vector<unsigned int>> & rotated_tet_face_indices,
                               std::vector<std::vector<const Node *>> & tet_nodes_list);

std::vector<std::vector<unsigned int>>
tetNodesForPrism(const bool diagonal_direction,
                 std::vector<std::vector<unsigned int>> & tet_face_indices);

void nodeRotationPYRAMID5(unsigned int min_id_index,
                          std::vector<unsigned int> & face_rotation,
                          std::vector<unsigned int> & node_rotation);

void
pyramidNodesToTetNodesDeterminer(std::vector<const Node *> & pyramid_nodes,
                                 std::vector<std::vector<unsigned int>> & rotated_tet_face_indices,
                                 std::vector<std::vector<const Node *>> & tet_nodes_list);

void convert3DMeshToAllTet4(MeshBase & mesh,
                            const std::vector<std::pair<dof_id_type, bool>> & elems_to_process,
                            std::vector<dof_id_type> & converted_elems_ids_to_track,
                            const subdomain_id_type block_id_to_remove,
                            const bool delete_block_to_remove);

void convert3DMeshToAllTet4(MeshBase & mesh);

void
elementBoundaryInfoCollector(const std::vector<libMesh::BoundaryInfo::BCTuple> & bdry_side_list,
                             const dof_id_type elem_id,
                             const unsigned short n_elem_sides,
                             std::vector<std::vector<boundary_id_type>> & elem_side_list);

void convertElem(MeshBase & mesh,
                 const dof_id_type & elem_id,
                 const std::vector<unsigned int> & side_indices,
                 const std::vector<std::vector<boundary_id_type>> & elem_side_info,
                 const SubdomainID & subdomain_id_shift_base);

void convertHex8Elem(MeshBase & mesh,
                     const dof_id_type & elem_id,
                     const std::vector<unsigned int> & side_indices,
                     const std::vector<std::vector<boundary_id_type>> & elem_side_info,
                     const SubdomainID & subdomain_id_shift_base);

void createUnitPyramid5FromHex8(MeshBase & mesh,
                                const dof_id_type & elem_id,
                                const unsigned int & side_index,
                                const Node * new_node,
                                const std::vector<boundary_id_type> & side_info,
                                const SubdomainID & subdomain_id_shift_base);

void createUnitTet4FromHex8(MeshBase & mesh,
                            const dof_id_type & elem_id,
                            const unsigned int & side_index,
                            const Node * new_node,
                            const std::vector<boundary_id_type> & side_info,
                            const SubdomainID & subdomain_id_shift_base);

void convertPrism6Elem(MeshBase & mesh,
                       const dof_id_type & elem_id,
                       const std::vector<unsigned int> & side_indices,
                       const std::vector<std::vector<boundary_id_type>> & elem_side_info,
                       const SubdomainID & subdomain_id_shift_base);
void createUnitTet4FromPrism6(MeshBase & mesh,
                              const dof_id_type & elem_id,
                              const unsigned int & side_index,
                              const Node * new_node,
                              const std::vector<boundary_id_type> & side_info,
                              const SubdomainID & subdomain_id_shift_base);

void createUnitPyramid5FromPrism6(MeshBase & mesh,
                                  const dof_id_type & elem_id,
                                  const unsigned int & side_index,
                                  const Node * new_node,
                                  const std::vector<boundary_id_type> & side_info,
                                  const SubdomainID & subdomain_id_shift_base);

void convertPyramid5Elem(MeshBase & mesh,
                         const dof_id_type & elem_id,
                         const std::vector<std::vector<boundary_id_type>> & elem_side_info,
                         const SubdomainID & subdomain_id_shift_base);

void retainEEID(MeshBase & mesh, const dof_id_type & elem_id, Elem * new_elem_ptr);

void transitionLayerGenerator(MeshBase & mesh,
                              const std::vector<BoundaryName> & boundary_names,
                              const unsigned int conversion_element_layer_number,
                              const bool external_boundaries_checking);

void assignConvertedElementsSubdomainNameSuffix(
    MeshBase & mesh,
    const std::set<subdomain_id_type> & original_subdomain_ids,
    const subdomain_id_type sid_shift_base,
    const SubdomainName & tet_suffix,
    const SubdomainName & pyramid_suffix);
}