DofMap.h

Go to the documentation of this file.

// Copyright (C) 2007-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 "ElementDofLayout.h"
#include <basix/mdspan.hpp>
#include <concepts>
#include <cstdlib>
#include <dolfinx/common/MPI.h>
#include <dolfinx/graph/AdjacencyList.h>
#include <dolfinx/graph/ordering.h>
#include <functional>
#include <memory>
#include <mpi.h>
#include <span>
#include <utility>
#include <vector>
 
namespace dolfinx::common
{
class IndexMap;
}
 
namespace dolfinx::mesh
{
class Topology;
}
 
namespace dolfinx::fem
{
 
graph::AdjacencyList<std::int32_t>
transpose_dofmap(MDSPAN_IMPL_STANDARD_NAMESPACE::mdspan<
                     const std::int32_t,
                     MDSPAN_IMPL_STANDARD_NAMESPACE::dextents<std::size_t, 2>>
                     dofmap,
                 std::int32_t num_cells);
 
class DofMap
{
public:
  template <typename E, typename U>
    requires std::is_convertible_v<std::remove_cvref_t<E>,
                                   fem::ElementDofLayout>
                 and std::is_convertible_v<std::remove_cvref_t<U>,
                                           std::vector<std::int32_t>>
  DofMap(E&& element, std::shared_ptr<const common::IndexMap> index_map,
         int index_map_bs, U&& dofmap, int bs)
      : index_map(index_map), _index_map_bs(index_map_bs),
        _element_dof_layout(std::forward<E>(element)),
        _dofmap(std::forward<U>(dofmap)), _bs(bs),
        _shape1(_element_dof_layout.num_dofs()
                * _element_dof_layout.block_size() / _bs)
  {
    // Do nothing
  }
 
  // Copy constructor
  DofMap(const DofMap& dofmap) = delete;
 
  DofMap(DofMap&& dofmap) = default;
 
  // Destructor
  ~DofMap() = default;
 
  // Copy assignment
  DofMap& operator=(const DofMap& dofmap) = delete;
 
  DofMap& operator=(DofMap&& dofmap) = default;
 
  bool operator==(const DofMap& map) const;
 
  std::span<const std::int32_t> cell_dofs(std::int32_t c) const
  {
    return std::span<const std::int32_t>(_dofmap.data() + _shape1 * c, _shape1);
  }
 
  int bs() const noexcept;
 
  DofMap extract_sub_dofmap(std::span<const int> component) const;
 
  std::pair<DofMap, std::vector<std::int32_t>> collapse(
      MPI_Comm comm, const mesh::Topology& topology,
      const std::function<std::vector<int>(
          const graph::AdjacencyList<std::int32_t>&)>& reorder_fn
      = [](const graph::AdjacencyList<std::int32_t>& g)
      { return graph::reorder_gps(g); }) const;
 
  MDSPAN_IMPL_STANDARD_NAMESPACE::mdspan<
      const std::int32_t,
      MDSPAN_IMPL_STANDARD_NAMESPACE::dextents<std::size_t, 2>>
  map() const;
 
  const ElementDofLayout& element_dof_layout() const
  {
    return _element_dof_layout;
  }
 
  std::shared_ptr<const common::IndexMap> index_map;
 
  int index_map_bs() const;
 
private:
  // Block size for the IndexMap
  int _index_map_bs = -1;
 
  // Layout of dofs on a cell
  ElementDofLayout _element_dof_layout;
 
  // Cell local-to-dof map
  std::vector<std::int32_t> _dofmap;
 
  // Block size for the dofmap
  int _bs = -1;
 
  // Number of columns in _dofmap
  int _shape1 = -1;
};
} // namespace dolfinx::fem