shape_info.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2012 - 2024 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_shape_info_h
#define dealii_matrix_free_shape_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/quadrature.h>
#include <deal.II/base/table.h>
#include <deal.II/base/vectorization.h>
 
 
DEAL_II_NAMESPACE_OPEN
 
 
// forward declaration
template <int dim, int spacedim>
class FiniteElement;
 
 
namespace internal
{
  namespace MatrixFreeFunctions
  {
    enum ElementType
    {
      tensor_symmetric_collocation = 0,
 
      tensor_symmetric_hermite = 1,
 
      tensor_symmetric = 2,
 
      tensor_symmetric_no_collocation = 3,
 
      tensor_general = 4,
 
      truncated_tensor = 5,
 
      tensor_symmetric_plus_dg0 = 6,
 
      tensor_raviart_thomas = 7,
 
      tensor_none = 8
 
 
    };
 
 
 
    template <typename Number>
    struct UnivariateShapeData
    {
      UnivariateShapeData();
 
      std::size_t
      memory_consumption() const;
 
      template <int dim, int spacedim>
      void
      evaluate_shape_functions(const FiniteElement<dim, spacedim> &fe,
                               const Quadrature<1>                &quad,
                               const std::vector<unsigned int> &lexicographic,
                               const unsigned int               direction);
 
      template <int dim, int spacedim>
      void
      evaluate_collocation_space(const FiniteElement<dim, spacedim> &fe,
                                 const Quadrature<1>                &quad,
                                 const std::vector<unsigned int> &lexicographic,
                                 const unsigned int               direction);
 
      bool
      check_and_set_shapes_symmetric();
 
      bool
      check_shapes_collocation() const;
 
      ElementType element_type;
 
      AlignedVector<Number> shape_values;
 
      AlignedVector<Number> shape_gradients;
 
      AlignedVector<Number> shape_hessians;
 
      AlignedVector<Number> shape_gradients_collocation;
 
      AlignedVector<Number> shape_hessians_collocation;
 
      AlignedVector<Number> shape_values_eo;
 
      AlignedVector<Number> shape_gradients_eo;
 
      AlignedVector<Number> shape_hessians_eo;
 
      AlignedVector<Number> shape_gradients_collocation_eo;
 
      AlignedVector<Number> shape_hessians_collocation_eo;
 
      AlignedVector<Number> inverse_shape_values;
 
      AlignedVector<Number> inverse_shape_values_eo;
 
      std::array<AlignedVector<Number>, 2> shape_data_on_face;
 
      std::array<AlignedVector<Number>, 2> quadrature_data_on_face;
 
      std::array<AlignedVector<Number>, 2> values_within_subface;
 
      std::array<AlignedVector<Number>, 2> gradients_within_subface;
 
      std::array<AlignedVector<Number>, 2> hessians_within_subface;
 
      std::array<AlignedVector<Number>, 2> subface_interpolation_matrices;
 
      std::array<AlignedVector<typename ::internal::VectorizedArrayTrait<
                   Number>::value_type>,
                 2>
        subface_interpolation_matrices_scalar;
 
      Quadrature<1> quadrature;
 
      unsigned int fe_degree;
 
      unsigned int n_q_points_1d;
 
      bool nodal_at_cell_boundaries;
 
      Table<3, Number> shape_values_face;
 
      Table<3, Number> shape_gradients_face;
    };
 
 
 
    template <typename Number>
    struct ShapeInfo
    {
      ElementType element_type;
 
      ShapeInfo();
 
      template <int dim, int spacedim, int dim_q>
      ShapeInfo(const Quadrature<dim_q>            &quad,
                const FiniteElement<dim, spacedim> &fe,
                const unsigned int                  base_element = 0);
 
      template <int dim, int spacedim, int dim_q>
      void
      reinit(const Quadrature<dim_q>            &quad,
             const FiniteElement<dim, spacedim> &fe_dim,
             const unsigned int                  base_element = 0);
 
      template <int dim, int spacedim>
      static bool
      is_supported(const FiniteElement<dim, spacedim> &fe);
 
      static Table<2, unsigned int>
      compute_orientation_table(const unsigned int n_points_per_dim);
 
      const UnivariateShapeData<Number> &
      get_shape_data(const unsigned int dimension = 0,
                     const unsigned int component = 0) const;
 
      std::size_t
      memory_consumption() const;
 
      std::vector<unsigned int> lexicographic_numbering;
 
      std::vector<UnivariateShapeData<Number>> data;
 
      ::Table<2, UnivariateShapeData<Number> *> data_access;
 
      unsigned int n_dimensions;
 
      unsigned int n_components;
 
      unsigned int n_q_points;
 
      unsigned int dofs_per_component_on_cell;
 
      unsigned int n_q_points_face;
 
      std::vector<unsigned int> n_q_points_faces;
 
      unsigned int dofs_per_component_on_face;
 
      ::Table<2, unsigned int> face_to_cell_index_nodal;
 
      ::Table<2, unsigned int> face_to_cell_index_hermite;
 
      ::Table<2, unsigned int> face_orientations_dofs;
 
      ::Table<2, unsigned int> face_orientations_quad;
    };
 
 
 
    // ------------------------------------------ inline functions
 
    template <typename Number>
    inline const UnivariateShapeData<Number> &
    ShapeInfo<Number>::get_shape_data(const unsigned int dimension,
                                      const unsigned int component) const
    {
      AssertDimension(n_dimensions, data_access.size(0));
      AssertDimension(n_components, data_access.size(1));
      AssertIndexRange(dimension, n_dimensions);
      AssertIndexRange(component, n_components);
      return *(data_access(dimension, component));
    }
 
  } // end of namespace MatrixFreeFunctions
 
} // end of namespace internal
 
DEAL_II_NAMESPACE_CLOSE
 
#endif