Mesh.h

// Copyright (C) 2006-2023 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 <concepts>
#include <dolfinx/common/MPI.h>
#include <string>
 
namespace dolfinx::mesh
{
class Topology;
 
template <std::floating_point T>
class Mesh
{
public:
  using geometry_type = Geometry<T>;
 
  template <typename V>
    requires std::is_convertible_v<std::remove_cvref_t<V>, Geometry<T>>
  Mesh(MPI_Comm comm, std::shared_ptr<Topology> topology, V&& geometry)
      : _topology(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.
  std::shared_ptr<Topology> topology() { return _topology; }
 
  std::shared_ptr<const Topology> topology() const { return _topology; }
 
  std::shared_ptr<Topology> topology_mutable() const { return _topology; }
 
  Geometry<T>& geometry() { return _geometry; }
 
  const Geometry<T>& geometry() const { return _geometry; }
 
  MPI_Comm comm() const { return _comm.comm(); }
 
  std::string name = "mesh";
 
private:
  // Mesh topology
  // Note: 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()).
  std::shared_ptr<Topology> _topology;
 
  // Mesh geometry
  Geometry<T> _geometry;
 
  // MPI communicator
  dolfinx::MPI::Comm _comm;
};
 
template <typename V>
Mesh(MPI_Comm, std::shared_ptr<Topology>, V)
    -> Mesh<typename std::remove_cvref_t<typename V::value_type>>;
 
} // namespace dolfinx::mesh