cells.h

// Copyright (C) 2019 Jorgen S. Dokken
// Copyright (C) 2026 Garth N. Wells
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include <array>
#include <cstdint>
#include <dolfinx/mesh/cell_types.h>
#include <span>
#include <stdexcept>
#include <tuple>
#include <vector>


namespace dolfinx::io::cells
{

int cell_degree(mesh::CellType type, int num_nodes);

std::vector<std::uint16_t> perm_vtk(mesh::CellType type, int num_nodes);

std::vector<std::uint16_t> perm_gmsh(mesh::CellType type, int num_nodes);

std::vector<std::uint16_t> transpose(std::span<const std::uint16_t> map);

std::vector<std::int64_t> apply_permutation(std::span<const std::int64_t> cells,
                                            std::array<std::size_t, 2> shape,
                                            std::span<const std::uint16_t> p);

std::int8_t get_vtk_cell_type(mesh::CellType cell, int num_nodes);

inline std::tuple<mesh::CellType, std::int8_t>
vtk_to_dolfinx(std::int8_t vtk_cell_type)
{
  {
    // For a complete overview of VTK cell types, see
    // https://vtk.org/doc/nightly/html/vtkCellType_8h_source.html
    switch (vtk_cell_type)
    {
      using enum mesh::CellType;
    case 1:
      return {point, -1};
    case 3:
      return {interval, 1};
    case 5:
      return {triangle, 1};
    case 9:
      return {quadrilateral, 1};
    case 10:
      return {tetrahedron, 1};
    case 12:
      return {hexahedron, 1};
    case 13:
      return {prism, 1};
    case 14:
      return {pyramid, 1};
    case 21:
      return {interval, 2};
    case 22:
      return {triangle, 2};
    case 23:
      return {quadrilateral, 2};
    case 24:
      return {tetrahedron, 2};
    case 25:
      return {hexahedron, 2};
    case 26:
      return {prism, 2};
    case 27:
      return {pyramid, 2};
    case 35:
      return {interval, 3};
    case 68:
      return {interval, -1};
    case 69:
      return {triangle, -1};
    case 70:
      return {quadrilateral, -1};
    case 71:
      return {tetrahedron, -1};
    case 72:
      return {hexahedron, -1};
    case 73:
      return {prism, -1};
    case 74:
      return {pyramid,
              -1}; // Not implemented in VTK yet, but added as placeholder.
    default:
      break;
    }
    throw std::invalid_argument("Unknown VTK cell type");
  }
}
 
} // namespace dolfinx::io::cells