mapping_info_storage.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2011 - 2022 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_storage_h
#define dealii_matrix_free_mapping_info_storage_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/aligned_vector.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/vectorization.h>
 
#include <deal.II/fe/fe_update_flags.h>
 
#include <deal.II/hp/q_collection.h>
 
#include <memory>
 
 
DEAL_II_NAMESPACE_OPEN
 
 
namespace internal
{
  namespace MatrixFreeFunctions
  {
    // forward declaration
    struct TaskInfo;
 
    enum GeometryType : unsigned char
    {
      cartesian = 0,
 
      affine = 1,
 
      flat_faces = 2,
 
      general = 3
    };
 
 
 
    template <int structdim, int spacedim, typename Number>
    struct MappingInfoStorage
    {
      struct QuadratureDescriptor
      {
        using ScalarNumber = typename VectorizedArrayTrait<Number>::value_type;
 
        QuadratureDescriptor();
 
        template <int dim_q>
        void
        initialize(const Quadrature<dim_q> &quadrature);
 
        void
        initialize(const Quadrature<1> &quadrature_1d);
 
        std::size_t
        memory_consumption() const;
 
        unsigned int n_q_points;
 
        Quadrature<1> quadrature_1d;
 
        Quadrature<structdim> quadrature;
 
        std::array<AlignedVector<ScalarNumber>, structdim>
          tensor_quadrature_weights;
 
        AlignedVector<ScalarNumber> quadrature_weights;
      };
 
      std::vector<QuadratureDescriptor> descriptor;
 
      std::vector<::hp::QCollection<structdim>> q_collection;
 
      AlignedVector<unsigned int> data_index_offsets;
 
      AlignedVector<Number> JxW_values;
 
      AlignedVector<Tensor<1, spacedim, Number>> normal_vectors;
 
      std::array<AlignedVector<Tensor<2, spacedim, Number>>, 2> jacobians;
 
      std::array<
        AlignedVector<
          Tensor<1, spacedim *(spacedim + 1) / 2, Tensor<1, spacedim, Number>>>,
        2>
        jacobian_gradients;
 
      std::array<
        AlignedVector<
          Tensor<1, spacedim *(spacedim + 1) / 2, Tensor<1, spacedim, Number>>>,
        2>
        jacobian_gradients_non_inverse;
 
      std::array<AlignedVector<Tensor<1, spacedim, Number>>, 2>
        normals_times_jacobians;
 
      AlignedVector<unsigned int> quadrature_point_offsets;
 
      AlignedVector<Point<spacedim, Number>> quadrature_points;
 
      void
      clear_data_fields();
 
      unsigned int
      quad_index_from_n_q_points(const unsigned int n_q_points) const;
 
      static UpdateFlags
      compute_update_flags(
        const UpdateFlags                                     update_flags,
        const std::vector<::hp::QCollection<spacedim>> &quads =
          std::vector<::hp::QCollection<spacedim>>(),
        const bool piola_transform = false);
 
      template <typename StreamType>
      void
      print_memory_consumption(StreamType &    out,
                               const TaskInfo &task_info) const;
 
      std::size_t
      memory_consumption() const;
    };
 
 
 
    /* ------------------- inline functions ----------------------------- */
 
    template <int structdim, int spacedim, typename Number>
    inline unsigned int
    MappingInfoStorage<structdim, spacedim, Number>::quad_index_from_n_q_points(
      const unsigned int n_q_points) const
    {
      for (unsigned int i = 0; i < descriptor.size(); ++i)
        if (n_q_points == descriptor[i].n_q_points)
          return i;
      return 0;
    }
 
  } // end of namespace MatrixFreeFunctions
} // end of namespace internal
 
DEAL_II_NAMESPACE_CLOSE
 
#endif