mapping_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_mapping_info_h
#define dealii_matrix_free_mapping_info_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/aligned_vector.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/vectorization.h>
 
#include <deal.II/fe/fe.h>
#include <deal.II/fe/mapping.h>
 
#include <deal.II/grid/reference_cell.h>
 
#include <deal.II/hp/mapping_collection.h>
#include <deal.II/hp/q_collection.h>
 
#include <deal.II/matrix_free/face_info.h>
#include <deal.II/matrix_free/mapping_info_storage.h>
 
#include <memory>
 
 
DEAL_II_NAMESPACE_OPEN
 
 
namespace internal
{
  namespace MatrixFreeFunctions
  {
    template <int dim, typename Number, typename VectorizedArrayType>
    struct MappingInfo
    {
      void
      initialize(
        const ::Triangulation<dim>                         &tria,
        const std::vector<std::pair<unsigned int, unsigned int>> &cells,
        const FaceInfo<VectorizedArrayType::size()>              &face_info,
        const std::vector<unsigned int> &active_fe_index,
        const std::shared_ptr<::hp::MappingCollection<dim>> &mapping,
        const std::vector<::hp::QCollection<dim>>           &quad,
        const UpdateFlags update_flags_cells,
        const UpdateFlags update_flags_boundary_faces,
        const UpdateFlags update_flags_inner_faces,
        const UpdateFlags update_flags_faces_by_cells,
        const bool        piola_transform);
 
      void
      update_mapping(
        const ::Triangulation<dim>                         &tria,
        const std::vector<std::pair<unsigned int, unsigned int>> &cells,
        const FaceInfo<VectorizedArrayType::size()>              &face_info,
        const std::vector<unsigned int> &active_fe_index,
        const std::shared_ptr<::hp::MappingCollection<dim>> &mapping);
 
      GeometryType
      get_cell_type(const unsigned int cell_chunk_no) const;
 
      void
      clear();
 
      std::size_t
      memory_consumption() const;
 
      template <typename StreamType>
      void
      print_memory_consumption(StreamType     &out,
                               const TaskInfo &task_info) const;
 
      UpdateFlags update_flags_cells;
 
      UpdateFlags update_flags_boundary_faces;
 
      UpdateFlags update_flags_inner_faces;
 
      UpdateFlags update_flags_faces_by_cells;
 
      std::vector<GeometryType> cell_type;
 
      std::vector<GeometryType> face_type;
 
      std::vector<std::array<GeometryType, GeometryInfo<dim>::faces_per_cell>>
        faces_by_cells_type;
 
      std::vector<MappingInfoStorage<dim, dim, VectorizedArrayType>> cell_data;
 
      std::vector<MappingInfoStorage<dim - 1, dim, VectorizedArrayType>>
        face_data;
 
      std::vector<MappingInfoStorage<dim - 1, dim, VectorizedArrayType>>
        face_data_by_cells;
 
      std::shared_ptr<::hp::MappingCollection<dim>> mapping_collection;
 
      SmartPointer<const Mapping<dim>> mapping;
 
      std::vector<std::vector<ReferenceCell>> reference_cell_types;
 
      void
      compute_mapping_q(
        const ::Triangulation<dim>                         &tria,
        const std::vector<std::pair<unsigned int, unsigned int>> &cells,
        const FaceInfo<VectorizedArrayType::size()>              &face_info);
 
      void
      initialize_cells(
        const ::Triangulation<dim>                         &tria,
        const std::vector<std::pair<unsigned int, unsigned int>> &cells,
        const std::vector<unsigned int>          &active_fe_index,
        const ::hp::MappingCollection<dim> &mapping);
 
      void
      initialize_faces(
        const ::Triangulation<dim>                         &tria,
        const std::vector<std::pair<unsigned int, unsigned int>> &cells,
        const std::vector<FaceToCellTopology<VectorizedArrayType::size()>>
                                                 &faces,
        const std::vector<unsigned int>          &active_fe_index,
        const ::hp::MappingCollection<dim> &mapping);
 
      void
      initialize_faces_by_cells(
        const ::Triangulation<dim>                         &tria,
        const std::vector<std::pair<unsigned int, unsigned int>> &cells,
        const FaceInfo<VectorizedArrayType::size()>              &face_info,
        const ::hp::MappingCollection<dim>                 &mapping);
    };
 
 
 
    template <int, typename, bool, typename>
    struct MappingInfoCellsOrFaces;
 
    template <int dim, typename Number, typename VectorizedArrayType>
    struct MappingInfoCellsOrFaces<dim, Number, false, VectorizedArrayType>
    {
      static const MappingInfoStorage<dim, dim, VectorizedArrayType> &
      get(const MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
          const unsigned int                                   quad_no)
      {
        AssertIndexRange(quad_no, mapping_info.cell_data.size());
        return mapping_info.cell_data[quad_no];
      }
    };
 
    template <int dim, typename Number, typename VectorizedArrayType>
    struct MappingInfoCellsOrFaces<dim, Number, true, VectorizedArrayType>
    {
      static const MappingInfoStorage<dim - 1, dim, VectorizedArrayType> &
      get(const MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
          const unsigned int                                   quad_no)
      {
        AssertIndexRange(quad_no, mapping_info.face_data.size());
        return mapping_info.face_data[quad_no];
      }
    };
 
 
    /* ------------------- inline functions ----------------------------- */
 
    template <int dim, typename Number, typename VectorizedArrayType>
    inline GeometryType
    MappingInfo<dim, Number, VectorizedArrayType>::get_cell_type(
      const unsigned int cell_no) const
    {
      AssertIndexRange(cell_no, cell_type.size());
      return cell_type[cell_no];
    }
 
  } // end of namespace MatrixFreeFunctions
} // end of namespace internal
 
DEAL_II_NAMESPACE_CLOSE
 
#endif