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 "utils.h"
#include <concepts>
#include <dolfinx/common/MPI.h>
#include <string>
#include <utility>
 
namespace dolfinx::fem
{
class CoordinateElement;
}
 
namespace dolfinx::graph
{
template <typename T>
class AdjacencyList;
}
 
namespace dolfinx::mesh
{
 
class Mesh
{
public:
  template <std::convertible_to<Topology> U, std::convertible_to<Geometry> V>
  Mesh(MPI_Comm comm, U&& topology, V&& geometry)
      : _topology(std::forward<U>(topology)),
        _geometry(std::forward<V>(geometry)), _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;
 
  MPI_Comm 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 _comm;
};
 
Mesh create_mesh(MPI_Comm comm, const graph::AdjacencyList<std::int64_t>& cells,
                 const fem::CoordinateElement& element,
                 std::span<const double> x, std::array<std::size_t, 2> xshape,
                 GhostMode ghost_mode);
 
Mesh create_mesh(MPI_Comm comm, const graph::AdjacencyList<std::int64_t>& cells,
                 const fem::CoordinateElement& element,
                 std::span<const double> x, std::array<std::size_t, 2> xshape,
                 const CellPartitionFunction& cell_partitioner);
 
std::tuple<Mesh, std::vector<std::int32_t>, std::vector<std::int32_t>,
           std::vector<std::int32_t>>
create_submesh(const Mesh& mesh, int dim,
               std::span<const std::int32_t> entities);
 
} // namespace dolfinx::mesh