utils.h

// Copyright (C) 2019-2020 Garth N. Wells
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include <dolfinx/graph/AdjacencyList.h>
#include <dolfinx/graph/partition.h>
#include <functional>
#include <mpi.h>
#include <xtl/xspan.hpp>
 
namespace dolfinx::fem
{
class ElementDofLayout;
}
 
namespace dolfinx::mesh
{
enum class CellType;
class Mesh;
 
enum class GhostMode : int
{
  none,
  shared_facet,
  shared_vertex
};
 
using CellPartitionFunction
    = std::function<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)>;
 
graph::AdjacencyList<std::int64_t>
extract_topology(const CellType& cell_type, const fem::ElementDofLayout& layout,
                 const graph::AdjacencyList<std::int64_t>& cells);
 
std::vector<double> h(const Mesh& mesh,
                      const xtl::span<const std::int32_t>& entities, int dim);
 
xt::xtensor<double, 2>
cell_normals(const Mesh& mesh, int dim,
             const xtl::span<const std::int32_t>& entities);
 
xt::xtensor<double, 2>
compute_midpoints(const Mesh& mesh, int dim,
                  const xtl::span<const std::int32_t>& entities);
 
std::vector<std::int32_t> locate_entities(
    const Mesh& mesh, int dim,
    const std::function<xt::xtensor<bool, 1>(const xt::xtensor<double, 2>&)>&
        marker);
 
std::vector<std::int32_t> locate_entities_boundary(
    const Mesh& mesh, int dim,
    const std::function<xt::xtensor<bool, 1>(const xt::xtensor<double, 2>&)>&
        marker);
 
xt::xtensor<std::int32_t, 2>
entities_to_geometry(const Mesh& mesh, int dim,
                     const xtl::span<const std::int32_t>& entity_list,
                     bool orient);
 
std::vector<std::int32_t> exterior_facet_indices(const Mesh& mesh);
 
CellPartitionFunction create_cell_partitioner(const graph::partition_fn& partfn
                                              = &graph::partition_graph);
 
std::vector<std::int32_t>
compute_incident_entities(const Mesh& mesh,
                          const xtl::span<const std::int32_t>& entities, int d0,
                          int d1);
 
} // namespace dolfinx::mesh