dof_info.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2012 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
 
#ifndef dealii_matrix_free_dof_info_h
#define dealii_matrix_free_dof_info_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/vectorization.h>
 
#include <deal.II/matrix_free/face_info.h>
#include <deal.II/matrix_free/shape_info.h>
 
#include <array>
#include <memory>
 
 
DEAL_II_NAMESPACE_OPEN
 
#ifndef DOXYGEN
 
// forward declarations
 
namespace internal
{
  namespace MatrixFreeFunctions
  {
    template <int dim>
    class HangingNodes;
 
    struct TaskInfo;
 
    template <typename Number>
    struct ConstraintValues;
 
    namespace VectorDataExchange
    {
      class Base;
    }
  } // namespace MatrixFreeFunctions
} // namespace internal
 
template <typename>
class AffineConstraints;
 
class DynamicSparsityPattern;
 
template <typename>
class TriaIterator;
 
template <int, int, bool>
class DoFCellAccessor;
 
namespace Utilities
{
  namespace MPI
  {
    class Partitioner;
  }
} // namespace Utilities
 
#endif
 
namespace internal
{
  namespace MatrixFreeFunctions
  {
    using compressed_constraint_kind = std::uint8_t;
 
    struct DoFInfo
    {
      static const unsigned int chunk_size_zero_vector = 64;
 
      DoFInfo();
 
      DoFInfo(const DoFInfo &) = default;
 
      DoFInfo(DoFInfo &&) noexcept = default;
 
      ~DoFInfo() = default;
 
      DoFInfo &
      operator=(const DoFInfo &) = default;
 
      DoFInfo &
      operator=(DoFInfo &&) noexcept = default;
 
      void
      clear();
 
      unsigned int
      fe_index_from_degree(const unsigned int first_selected_component,
                           const unsigned int fe_degree) const;
 
      void
      get_dof_indices_on_cell_batch(std::vector<unsigned int> &local_indices,
                                    const unsigned int         cell_batch,
                                    const bool with_constraints = true) const;
 
      template <typename number>
      void
      read_dof_indices(
        const std::vector<types::global_dof_index> &local_indices_resolved,
        const std::vector<types::global_dof_index> &local_indices,
        const bool                                  cell_has_hanging_nodes,
        const ::AffineConstraints<number>    &constraints,
        const unsigned int                          cell_number,
        ConstraintValues<double>                   &constraint_values,
        bool                                       &cell_at_boundary);
 
      template <int dim>
      bool
      process_hanging_node_constraints(
        const HangingNodes<dim>                      &hanging_nodes,
        const std::vector<std::vector<unsigned int>> &lexicographic_mapping,
        const unsigned int                            cell_number,
        const TriaIterator<DoFCellAccessor<dim, dim, false>> &cell,
        std::vector<types::global_dof_index>                 &dof_indices);
 
      void
      assign_ghosts(const std::vector<unsigned int> &boundary_cells,
                    const MPI_Comm                   communicator_sm,
                    const bool use_vector_data_exchanger_full);
 
      void
      reorder_cells(const TaskInfo                   &task_info,
                    const std::vector<unsigned int>  &renumbering,
                    const std::vector<unsigned int>  &constraint_pool_row_index,
                    const std::vector<unsigned char> &irregular_cells);
 
      void
      compute_cell_index_compression(
        const std::vector<unsigned char> &irregular_cells);
 
      template <int length>
      void
      compute_face_index_compression(
        const std::vector<FaceToCellTopology<length>> &faces);
 
      void
      make_connectivity_graph(const TaskInfo                  &task_info,
                              const std::vector<unsigned int> &renumbering,
                              DynamicSparsityPattern &connectivity) const;
 
      void
      compute_tight_partitioners(
        const Table<2, ShapeInfo<double>>        &shape_info,
        const unsigned int                        n_owned_cells,
        const unsigned int                        n_lanes,
        const std::vector<FaceToCellTopology<1>> &inner_faces,
        const std::vector<FaceToCellTopology<1>> &ghosted_faces,
        const bool                                fill_cell_centric,
        const MPI_Comm                            communicator_sm,
        const bool use_vector_data_exchanger_full);
 
      void
      compute_shared_memory_contiguous_indices(
        std::array<std::vector<std::pair<unsigned int, unsigned int>>, 3>
          &cell_indices_contiguous_sm);
 
      void
      compute_dof_renumbering(
        std::vector<types::global_dof_index> &renumbering);
 
      template <int length>
      void
      compute_vector_zero_access_pattern(
        const TaskInfo                                &task_info,
        const std::vector<FaceToCellTopology<length>> &faces);
 
      std::size_t
      memory_consumption() const;
 
      template <typename StreamType>
      void
      print_memory_consumption(StreamType     &out,
                               const TaskInfo &size_info) const;
 
      template <typename Number>
      void
      print(const std::vector<Number>       &constraint_pool_data,
            const std::vector<unsigned int> &constraint_pool_row_index,
            std::ostream                    &out) const;
 
      enum class IndexStorageVariants : unsigned char
      {
        full,
        interleaved,
        contiguous,
        interleaved_contiguous,
        interleaved_contiguous_strided,
        interleaved_contiguous_mixed_strides
      };
 
      enum DoFAccessIndex : unsigned char
      {
        dof_access_face_interior = 0,
        dof_access_face_exterior = 1,
        dof_access_cell = 2
      };
 
      unsigned int vectorization_length;
 
      std::array<std::vector<IndexStorageVariants>, 3> index_storage_variants;
 
      std::vector<std::pair<unsigned int, unsigned int>> row_starts;
 
      std::vector<unsigned int> dof_indices;
 
      std::vector<std::vector<bool>> hanging_node_constraint_masks_comp;
 
      std::vector<compressed_constraint_kind> hanging_node_constraint_masks;
 
      std::vector<std::pair<unsigned short, unsigned short>>
        constraint_indicator;
 
      std::vector<unsigned int> dof_indices_interleaved;
 
      std::array<std::vector<unsigned int>, 3> dof_indices_contiguous;
 
      std::array<std::vector<std::pair<unsigned int, unsigned int>>, 3>
        dof_indices_contiguous_sm;
 
      std::array<std::vector<unsigned int>, 3> dof_indices_interleave_strides;
 
      std::array<std::vector<unsigned char>, 3> n_vectorization_lanes_filled;
 
      std::shared_ptr<const Utilities::MPI::Partitioner> vector_partitioner;
 
      std::shared_ptr<
        const internal::MatrixFreeFunctions::VectorDataExchange::Base>
        vector_exchanger;
 
      std::array<
        std::shared_ptr<
          const internal::MatrixFreeFunctions::VectorDataExchange::Base>,
        5>
        vector_exchanger_face_variants;
 
      std::vector<unsigned int> constrained_dofs;
 
      std::vector<unsigned int> row_starts_plain_indices;
 
      std::vector<unsigned int> plain_dof_indices;
 
      unsigned int global_base_element_offset;
 
      unsigned int n_base_elements;
 
      std::vector<unsigned int> n_components;
 
      std::vector<unsigned int> start_components;
 
      std::vector<unsigned int> component_to_base_index;
 
      std::vector<std::vector<unsigned int>> component_dof_indices_offset;
 
      std::vector<unsigned int> dofs_per_cell;
 
      std::vector<unsigned int> dofs_per_face;
 
      bool store_plain_indices;
 
      std::vector<unsigned int> cell_active_fe_index;
 
      unsigned int max_fe_index;
 
      std::vector<std::vector<unsigned int>> fe_index_conversion;
 
      std::vector<types::global_dof_index> ghost_dofs;
 
      std::vector<unsigned int> vector_zero_range_list_index;
 
      std::vector<std::pair<unsigned int, unsigned int>> vector_zero_range_list;
 
      std::vector<unsigned int> cell_loop_pre_list_index;
 
      std::vector<std::pair<unsigned int, unsigned int>> cell_loop_pre_list;
 
      std::vector<unsigned int> cell_loop_post_list_index;
 
      std::vector<std::pair<unsigned int, unsigned int>> cell_loop_post_list;
    };
 
 
    /*-------------------------- Inline functions ---------------------------*/
 
#ifndef DOXYGEN
 
 
    inline unsigned int
    DoFInfo::fe_index_from_degree(const unsigned int first_selected_component,
                                  const unsigned int fe_degree) const
    {
      const unsigned int n_indices = fe_index_conversion.size();
      if (n_indices <= 1)
        return 0;
      for (unsigned int i = 0; i < n_indices; ++i)
        if (fe_index_conversion[i][first_selected_component] == fe_degree)
          return i;
      return numbers::invalid_unsigned_int;
    }
 
#endif // ifndef DOXYGEN
 
  } // end of namespace MatrixFreeFunctions
} // end of namespace internal
 
DEAL_II_NAMESPACE_CLOSE
 
#endif