integration_domains.h

Go to the documentation of this file.

// Copyright (C) 2013-2026 Johan Hake, Jan Blechta, Garth N. Wells and Paul T.
// Kühner
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include "Form.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <cstdint>
#include <dolfinx/graph/AdjacencyList.h>
#include <dolfinx/mesh/Topology.h>
#include <ranges>
#include <span>
#include <vector>

 
namespace dolfinx::fem
{
namespace impl
{
template <int num_cells>
std::array<std::int32_t, 2 * num_cells>
get_cell_facet_pairs(std::int32_t f, std::span<const std::int32_t> cells,
                     const graph::AdjacencyList<std::int32_t>& c_to_f)
{
  // Loop over cells sharing facet
  assert(cells.size() == num_cells);
  std::array<std::int32_t, 2 * num_cells> cell_local_facet_pairs;
  for (int c = 0; c < num_cells; ++c)
  {
    // Get local index of facet with respect to the cell
    std::int32_t cell = cells[c];
    auto cell_facets = c_to_f.links(cell);
    auto facet_it = std::find(cell_facets.begin(), cell_facets.end(), f);
    assert(facet_it != cell_facets.end());
    int local_f = std::ranges::distance(cell_facets.begin(), facet_it);
    cell_local_facet_pairs[2 * c] = cell;
    cell_local_facet_pairs[2 * c + 1] = local_f;
  }
 
  return cell_local_facet_pairs;
}

template <int num_cells>
std::array<std::int32_t, 2 * num_cells>
get_cell_entity_pairs(std::int32_t e, std::span<const std::int32_t> cells,
                      const graph::AdjacencyList<std::int32_t>& c_to_e)
{
  static_assert(num_cells == 1); // Patch assembly not supported.
 
  assert(cells.size() > 0);
 
  // Use first cell for assembly over by default
  std::int32_t cell = cells[0];
 
  // Find local index of entity within cell
  auto cell_entities = c_to_e.links(cell);
  auto it = std::ranges::find(cell_entities, e);
  assert(it != cell_entities.end());
  std::int32_t local_index = std::ranges::distance(cell_entities.begin(), it);
 
  return {cell, local_index};
}
 
} // namespace impl

std::vector<std::int32_t>
compute_integration_domains(IntegralType integral_type,
                            const mesh::Topology& topology,
                            std::span<const std::int32_t> entities);
} // namespace dolfinx::fem