dof_info.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2011 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------


#ifndef dealii_matrix_free_dof_info_h
#define dealii_matrix_free_dof_info_h


#include <deal.II/base/exceptions.h>
#include <deal.II/base/vectorization.h>
#include <deal.II/base/partitioner.h>
#include <deal.II/lac/constraint_matrix.h>
#include <deal.II/lac/dynamic_sparsity_pattern.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/matrix_free/task_info.h>
#include <deal.II/matrix_free/face_info.h>

#include <array>
#include <memory>


DEAL_II_NAMESPACE_OPEN

namespace internal
{
  namespace MatrixFreeFunctions
  {
    template <typename Number> struct ConstraintValues;

    struct DoFInfo
    {
      static const unsigned int chunk_size_zero_vector = 8192;

      DoFInfo ();

      DoFInfo (const DoFInfo &) = default;

      void clear ();

      unsigned int fe_index_from_degree (const unsigned int first_selected_component,
                                         const unsigned int fe_degree) const;

      void read_dof_indices (const std::vector<types::global_dof_index> &local_indices,
                             const std::vector<unsigned int> &lexicographic_inv,
                             const ConstraintMatrix          &constraints,
                             const unsigned int               cell_number,
                             ConstraintValues<double>        &constraint_values,
                             bool                            &cell_at_boundary);

      void assign_ghosts(const std::vector<unsigned int> &boundary_cells);

      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_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
      };

      enum DoFAccessIndex : unsigned char
      {
        dof_access_face_interior = 0,
        dof_access_face_exterior = 1,
        dof_access_cell = 2
      };

      unsigned int dimension;

      unsigned int vectorization_length;

      std::vector<IndexStorageVariants> index_storage_variants[3];

      std::vector<std::pair<unsigned int, unsigned int> > row_starts;

      std::vector<unsigned int> dof_indices;

      std::vector<std::pair<unsigned short,unsigned short> > constraint_indicator;

      std::vector<unsigned int> dof_indices_interleaved;

      std::vector<unsigned int> dof_indices_contiguous[3];

      std::vector<unsigned char> n_vectorization_lanes_filled[3];

      std::shared_ptr<const Utilities::MPI::Partitioner> vector_partitioner;

      std::array<std::shared_ptr<const Utilities::MPI::Partitioner>, 3> vector_partitioner_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<unsigned int> vector_zero_range_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