Geometry.h

// Copyright (C) 2006-2020 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 <concepts>
#include <dolfinx/common/MPI.h>
#include <dolfinx/fem/CoordinateElement.h>
#include <dolfinx/graph/AdjacencyList.h>
#include <functional>
#include <memory>
#include <span>
#include <vector>
 
namespace dolfinx::common
{
class IndexMap;
}
 
namespace dolfinx::mesh
{
class Topology;
 
class Geometry
{
public:
  template <std::convertible_to<graph::AdjacencyList<std::int32_t>> U,
            std::convertible_to<std::vector<double>> V,
            std::convertible_to<std::vector<std::int64_t>> W>
  Geometry(std::shared_ptr<const common::IndexMap> index_map, U&& dofmap,
           const fem::CoordinateElement& element, V&& x, int dim,
           W&& input_global_indices)
      : _dim(dim), _dofmap(std::forward<U>(dofmap)), _index_map(index_map),
        _cmap(element), _x(std::forward<V>(x)),
        _input_global_indices(std::forward<W>(input_global_indices))
  {
    assert(_x.size() % 3 == 0);
    if (_x.size() / 3 != _input_global_indices.size())
      throw std::runtime_error("Geometry size mis-match");
  }
 
  Geometry(const Geometry&) = default;
 
  Geometry(Geometry&&) = default;
 
  ~Geometry() = default;
 
  Geometry& operator=(const Geometry&) = delete;
 
  Geometry& operator=(Geometry&&) = default;
 
  int dim() const;
 
  const graph::AdjacencyList<std::int32_t>& dofmap() const;
 
  std::shared_ptr<const common::IndexMap> index_map() const;
 
  std::span<const double> x() const;
 
  std::span<double> x();
 
  const fem::CoordinateElement& cmap() const;
 
  const std::vector<std::int64_t>& input_global_indices() const;
 
private:
  // Geometric dimension
  int _dim;
 
  // Map per cell for extracting coordinate data
  graph::AdjacencyList<std::int32_t> _dofmap;
 
  // IndexMap for geometry 'dofmap'
  std::shared_ptr<const common::IndexMap> _index_map;
 
  // The coordinate element
  fem::CoordinateElement _cmap;
 
  // Coordinates for all points stored as a contiguous array (row-major,
  // column size = 3)
  std::vector<double> _x;
 
  // Global indices as provided on Geometry creation
  std::vector<std::int64_t> _input_global_indices;
};
 
mesh::Geometry
create_geometry(MPI_Comm comm, const Topology& topology,
                const fem::CoordinateElement& element,
                const graph::AdjacencyList<std::int64_t>& cells,
                std::span<const double> x, int dim,
                const std::function<std::vector<int>(
                    const graph::AdjacencyList<std::int32_t>&)>& reorder_fn
                = nullptr);
 
} // namespace dolfinx::mesh