mapping_info.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2011 - 2021 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.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/helper_functions.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);
 
      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];
      }
    };
 
 
 
    template <typename Number,
              typename VectorizedArrayType = VectorizedArray<Number>>
    struct FPArrayComparator
    {
      FPArrayComparator(const Number scaling);
 
      bool
      operator()(const std::vector<Number> &v1,
                 const std::vector<Number> &v2) const;
 
      bool
      operator()(
        const Tensor<1, VectorizedArrayType::size(), Number> &t1,
        const Tensor<1, VectorizedArrayType::size(), Number> &t2) const;
 
      template <int dim>
      bool
      operator()(
        const Tensor<1, dim, Tensor<1, VectorizedArrayType::size(), Number>>
          &t1,
        const Tensor<1, dim, Tensor<1, VectorizedArrayType::size(), Number>>
          &t2) const;
 
      template <int dim>
      bool
      operator()(
        const Tensor<2, dim, Tensor<1, VectorizedArrayType::size(), Number>>
          &t1,
        const Tensor<2, dim, Tensor<1, VectorizedArrayType::size(), Number>>
          &t2) const;
 
      template <int dim>
      bool
      operator()(const std::array<Tensor<2, dim, Number>, dim + 1> &t1,
                 const std::array<Tensor<2, dim, Number>, dim + 1> &t2) const;
 
      Number tolerance;
    };
 
 
 
    /* ------------------- 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