Topology.h

// Copyright (C) 2006-2022 Anders Logg and 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/common/MPI.h>
#include <memory>
#include <optional>
#include <span>
#include <tuple>
#include <vector>
 
namespace dolfinx::common
{
class IndexMap;
}
 
namespace dolfinx::graph
{
template <typename T>
class AdjacencyList;
}
 
namespace dolfinx::mesh
{
enum class CellType;
 
class Topology
{
public:
  Topology(MPI_Comm comm, CellType cell_type,
           std::shared_ptr<const common::IndexMap> vertex_map,
           std::shared_ptr<const common::IndexMap> cell_map,
           std::shared_ptr<graph::AdjacencyList<std::int32_t>> cells,
           const std::optional<std::vector<std::int64_t>>& original_index
           = std::nullopt);
 
  Topology(
      MPI_Comm comm, std::vector<CellType> cell_types,
      std::shared_ptr<const common::IndexMap> vertex_map,
      std::vector<std::shared_ptr<const common::IndexMap>> cell_maps,
      std::vector<std::shared_ptr<graph::AdjacencyList<std::int32_t>>> cells,
      const std::optional<std::vector<std::vector<std::int64_t>>>&
          original_cell_index
      = std::nullopt);
 
  Topology(const Topology& topology) = default;
 
  Topology(Topology&& topology) = default;
 
  ~Topology() = default;
 
  Topology& operator=(const Topology& topology) = delete;
 
  Topology& operator=(Topology&& topology) = default;
 
  int dim() const noexcept;
 
  void set_index_map(int dim, std::shared_ptr<const common::IndexMap> map);
 
  void set_index_map(std::int8_t dim, std::int8_t i,
                     std::shared_ptr<const common::IndexMap> map);
 
  std::shared_ptr<const common::IndexMap> index_map(int dim) const;
 
  std::vector<std::shared_ptr<const common::IndexMap>>
  index_maps(std::int8_t dim) const;
 
  std::shared_ptr<const graph::AdjacencyList<std::int32_t>>
  connectivity(int d0, int d1) const;
 
  std::shared_ptr<const graph::AdjacencyList<std::int32_t>>
  connectivity(std::pair<std::int8_t, std::int8_t> d0,
               std::pair<std::int8_t, std::int8_t> d1) const;
 
  void set_connectivity(std::shared_ptr<graph::AdjacencyList<std::int32_t>> c,
                        int d0, int d1);
 
  void set_connectivity(std::shared_ptr<graph::AdjacencyList<std::int32_t>> c,
                        std::pair<std::int8_t, std::int8_t> d0,
                        std::pair<std::int8_t, std::int8_t> d1);
 
  const std::vector<std::uint32_t>& get_cell_permutation_info() const;
 
  const std::vector<std::uint8_t>& get_facet_permutations() const;
 
  CellType cell_type() const;
 
  std::vector<CellType> entity_types(std::int8_t dim) const;
 
  std::int32_t create_entities(int dim);
 
  void create_connectivity(int d0, int d1);
 
  void create_entity_permutations();
 
  const std::vector<std::int32_t>& interprocess_facets() const;
 
  const std::vector<std::int32_t>& interprocess_facets(std::int8_t index) const;
 
  std::vector<std::vector<std::int64_t>> original_cell_index;
 
  MPI_Comm comm() const;
 
private:
  // MPI communicator
  dolfinx::MPI::Comm _comm;
 
  // Cell types for entites in Topology, as follows:
  // [CellType::point, edge_types..., facet_types..., cell_types...]
  // Only one type is expected for vertices, (and usually edges), but facets
  // and cells can be a list of multiple types, e.g. [quadrilateral, triangle]
  // for facets.
  // Offsets are position in the list for each entity dimension, in
  // AdjacencyList style.
  std::vector<CellType> _entity_types;
  std::vector<std::int8_t> _entity_type_offsets;
 
  // Parallel layout of entities for each dimension and cell type
  // flattened in the same layout as _entity_types above.
  std::vector<std::shared_ptr<const common::IndexMap>> _index_map;
 
  // Connectivity between entity dimensions and cell types, arranged as
  // a 2D array. The indexing follows the order in _entity_types, i.e.
  // increasing in topological dimension. There may be multiple types in each
  // dimension, e.g. triangle and quadrilateral facets.
  // Connectivity between different entity types of same dimension will always
  // be nullptr.
  std::vector<std::vector<std::shared_ptr<graph::AdjacencyList<std::int32_t>>>>
      _connectivity;
 
  // The facet permutations (local facet, cell))
  // [cell0_0, cell0_1, ,cell0_2, cell1_0, cell1_1, ,cell1_2, ...,
  // celln_0, celln_1, ,celln_2,]
  std::vector<std::uint8_t> _facet_permutations;
 
  // Cell permutation info. See the documentation for
  // get_cell_permutation_info for documentation of how this is encoded.
  std::vector<std::uint32_t> _cell_permutations;
 
  // List of facets that are on the inter-process boundary for each facet type
  std::vector<std::vector<std::int32_t>> _interprocess_facets;
};
 
Topology create_topology(MPI_Comm comm, std::span<const std::int64_t> cells,
                         std::span<const std::int64_t> original_cell_index,
                         std::span<const int> ghost_owners, CellType cell_type,
                         std::span<const std::int64_t> boundary_vertices);
 
Topology
create_topology(MPI_Comm comm, const std::vector<CellType>& cell_type,
                std::vector<std::span<const std::int64_t>> cells,
                std::vector<std::span<const std::int64_t>> original_cell_index,
                std::vector<std::span<const int>> ghost_owners,
                std::span<const std::int64_t> boundary_vertices);
 
std::tuple<Topology, std::vector<int32_t>, std::vector<int32_t>>
create_subtopology(const Topology& topology, int dim,
                   std::span<const std::int32_t> entities);
 
std::vector<std::int32_t>
entities_to_index(const Topology& topology, int dim,
                  std::span<const std::int32_t> entities);
} // namespace dolfinx::mesh