Topology.h

// Copyright (C) 2006-2019 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 "cell_types.h"
#include <array>
#include <cstdint>
#include <dolfinx/common/MPI.h>
#include <memory>
#include <vector>
#include <xtl/xspan.hpp>
 
namespace dolfinx::common
{
class IndexMap;
}
 
namespace dolfinx::fem
{
class ElementDofLayout;
}
 
namespace dolfinx::graph
{
template <typename T>
class AdjacencyList;
}
 
namespace dolfinx::mesh
{
enum class GhostMode : int;
 
enum class CellType;
class Topology;
 
std::vector<bool> compute_boundary_facets(const Topology& topology);
 
class Topology
{
public:
  Topology(MPI_Comm comm, mesh::CellType type);
 
  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,
                     const std::shared_ptr<const common::IndexMap>& map);
 
  std::shared_ptr<const common::IndexMap> index_map(int dim) const;
 
  std::shared_ptr<const graph::AdjacencyList<std::int32_t>>
  connectivity(int d0, int d1) const;
 
  void set_connectivity(std::shared_ptr<graph::AdjacencyList<std::int32_t>> c,
                        int d0, int d1);
 
  const std::vector<std::uint32_t>& get_cell_permutation_info() const;
 
  const std::vector<std::uint8_t>& get_facet_permutations() const;
 
  mesh::CellType cell_type() const noexcept;
 
  // TODO: Rework memory management and associated API
  // Currently, there is no clear caching policy implemented and no way of
  // discarding cached data.
 
  std::int32_t create_entities(int dim);
 
  void create_connectivity(int d0, int d1);
 
  void create_entity_permutations();
 
  MPI_Comm mpi_comm() const;
 
private:
  // MPI communicator
  dolfinx::MPI::Comm _mpi_comm;
 
  // Cell type
  mesh::CellType _cell_type;
 
  // Parallel layout of entities for each dimension
  std::array<std::shared_ptr<const common::IndexMap>, 4> _index_map;
 
  // AdjacencyList for pairs [d0][d1] == d0 -> d1 connectivity
  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;
};
 
Topology
create_topology(MPI_Comm comm, const graph::AdjacencyList<std::int64_t>& cells,
                const xtl::span<const std::int64_t>& original_cell_index,
                const xtl::span<const int>& ghost_owners,
                const CellType& cell_type, mesh::GhostMode ghost_mode);
} // namespace dolfinx::mesh