Function build_basic_dofmaps

cpp/dolfinx/fem/dofmapbuilder.cpp:152–380

----------------------------------------------------------------------------- Build a simple dofmap from ElementDofmap based on mesh entity indices (local and global) @param [in] mesh The mesh to build the dofmap on @param [in] topology The mesh topology @param [in] element_dof_layout The layout of dofs on each cell type @return Returns: * dofmaps for each cell type (local to the process) local-t

/// @note Entities in the local-to-entity map are represented by the pair:
/// [index_map number, mesh entity index].
std::tuple<std::vector<dofmap_t>, std::vector<std::int64_t>,
           std::vector<std::pair<std::int8_t, std::int32_t>>,
           std::vector<std::shared_ptr<const common::IndexMap>>, std::int64_t>
build_basic_dofmaps(
    const mesh::Topology& topology,
    const std::vector<fem::ElementDofLayout>& element_dof_layouts)
{
  // Start timer for dofmap initialization
  common::Timer t0("Dofmap builder: init dofmap from element dofmap");

  // Topological dimension
  const std::size_t D = topology.dim();
  const std::size_t num_cell_types = topology.entity_types(D).size();

  spdlog::info("Checking required entities per dimension");

  // Find which dimensions (d) and entity types (et) are required
  // and the number of dofs which are required for each (d, et) combination.
  // Also store the IndexMaps and local offsets for each.
  std::vector<std::pair<std::int8_t, std::int8_t>> required_dim_et;
  std::vector<std::int32_t> num_entity_dofs_et;
  std::vector<std::shared_ptr<const common::IndexMap>> topo_index_maps;
  std::vector<std::int32_t> local_entity_offsets{0};

  std::vector<std::vector<mesh::CellType>> entity_types(D + 1);
  for (std::size_t d = 0; d <= D; ++d)
    entity_types[d] = topology.entity_types(d);

  for (std::size_t i = 0; i < num_cell_types; ++i)
  {
    mesh::CellType cell_type = entity_types[D][i];
    const std::vector<std::vector<std::vector<int>>>& entity_dofs
        = element_dof_layouts[i].entity_dofs_all();

    for (std::size_t d = 0; d <= D; ++d)
    {
      const std::vector<std::vector<int>>& entity_dofs_d = entity_dofs[d];
      for (std::size_t e = 0; e < entity_dofs_d.size(); ++e)
      {
        if (!entity_dofs_d[e].empty())
        {
          // There is a dof on this entity... find entity type index
          auto et_it = std::find(entity_types[d].begin(), entity_types[d].end(),
                                 mesh::cell_entity_type(cell_type, d, e));
          assert(et_it != entity_types[d].end());
          int et_index = std::distance(entity_types[d].begin(), et_it);

          auto required_entity_it
              = std::find(required_dim_et.begin(), required_dim_et.end(),
                          std::pair<std::int8_t, std::int8_t>{d, et_index});
          if (required_entity_it == required_dim_et.end())
          {
            // Save information for this (d, et) combination
            required_dim_et.push_back({d, et_index});
            const std::int32_t num_entity_dofs = entity_dofs_d[e].size();
            num_entity_dofs_et.push_back(num_entity_dofs);
            auto im = topology.index_maps(d)[et_index];
            topo_index_maps.push_back(im);