Mesh.h

// Copyright (C) 2006-2020 Anders Logg, Chris Richardson 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 "Geometry.h"
#include "Topology.h"
#include "cell_types.h"
#include "utils.h"
#include <dolfinx/common/MPI.h>
#include <dolfinx/common/UniqueIdGenerator.h>
#include <string>
#include <utility>
 
namespace dolfinx::fem
{
class CoordinateElement;
}
 
namespace dolfinx::graph
{
template <typename T>
class AdjacencyList;
}
 
namespace dolfinx::mesh
{
 
using CellPartitionFunction
    = std::function<const dolfinx::graph::AdjacencyList<std::int32_t>(
        MPI_Comm comm, int nparts, int tdim,
        const dolfinx::graph::AdjacencyList<std::int64_t>& cells,
        dolfinx::mesh::GhostMode ghost_mode)>;
 
enum class GhostMode : int
{
  none,
  shared_facet,
  shared_vertex
};
 
class Mesh
{
public:
  template <typename Topology, typename Geometry>
  Mesh(MPI_Comm comm, Topology&& topology, Geometry&& geometry)
      : _topology(std::forward<Topology>(topology)),
        _geometry(std::forward<Geometry>(geometry)), _mpi_comm(comm)
  {
    // Do nothing
  }
 
  Mesh(const Mesh& mesh) = default;
 
  Mesh(Mesh&& mesh) = default;
 
  ~Mesh() = default;
 
  // Assignment operator
  Mesh& operator=(const Mesh& mesh) = delete;
 
  Mesh& operator=(Mesh&& mesh) = default;
 
  // TODO: Is there any use for this? In many situations one has to get the
  // topology of a const Mesh, which is done by Mesh::topology_mutable. Note
  // that the python interface (calls Mesh::topology()) may still rely on it.
  Topology& topology();
 
  const Topology& topology() const;
 
  Topology& topology_mutable() const;
 
  Geometry& geometry();
 
  const Geometry& geometry() const;
 
  std::size_t id() const { return _unique_id; }
 
  MPI_Comm mpi_comm() const;
 
  std::string name = "mesh";
 
private:
  // Mesh topology:
  // TODO: This is mutable because of the current memory management within
  // mesh::Topology. It allows to obtain a non-const Topology from a
  // const mesh (via Mesh::topology_mutable()).
  //
  mutable Topology _topology;
 
  // Mesh geometry
  Geometry _geometry;
 
  // MPI communicator
  dolfinx::MPI::Comm _mpi_comm;
 
  // Unique identifier
  std::size_t _unique_id = common::UniqueIdGenerator::id();
};
 
Mesh create_mesh(MPI_Comm comm, const graph::AdjacencyList<std::int64_t>& cells,
                 const fem::CoordinateElement& element,
                 const xt::xtensor<double, 2>& x, GhostMode ghost_mode);
 
Mesh create_mesh(MPI_Comm comm, const graph::AdjacencyList<std::int64_t>& cells,
                 const fem::CoordinateElement& element,
                 const xt::xtensor<double, 2>& x, GhostMode ghost_mode,
                 const CellPartitionFunction& cell_partitioner);
 
} // namespace dolfinx::mesh