shape_info.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2011 - 2020 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_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_lib.h>

#include <deal.II/fe/fe.h>


DEAL_II_NAMESPACE_OPEN

namespace internal
{
  namespace MatrixFreeFunctions
  {
    enum ElementType
    {
      tensor_symmetric_collocation = 0,

      tensor_symmetric_hermite = 1,

      tensor_symmetric = 2,

      tensor_general = 3,

      truncated_tensor = 4,

      tensor_symmetric_plus_dg0 = 5
    };



    template <typename Number>
    struct UnivariateShapeData
    {
      UnivariateShapeData();

      std::size_t
      memory_consumption() 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;

      AlignedVector<Number> shape_data_on_face[2];

      AlignedVector<Number> values_within_subface[2];

      AlignedVector<Number> gradients_within_subface[2];

      AlignedVector<Number> hessians_within_subface[2];

      Quadrature<1> quadrature;

      unsigned int fe_degree;

      unsigned int n_q_points_1d;

      bool nodal_at_cell_boundaries;
    };



    template <typename Number>
    struct ShapeInfo
    {
      ElementType element_type;

      ShapeInfo();

      template <int dim>
      ShapeInfo(const Quadrature<1> &     quad,
                const FiniteElement<dim> &fe,
                const unsigned int        base_element = 0);

      template <int dim>
      void
      reinit(const Quadrature<1> &     quad,
             const FiniteElement<dim> &fe_dim,
             const unsigned int        base_element = 0);

      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;

      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;

    private:
      bool
      check_1d_shapes_symmetric(
        UnivariateShapeData<Number> &univariate_shape_data);

      bool
      check_1d_shapes_collocation(
        const UnivariateShapeData<Number> &univariate_shape_data) const;
    };



    // ------------------------------------------ inline functions

    template <typename Number>
    template <int dim>
    inline ShapeInfo<Number>::ShapeInfo(const Quadrature<1> &     quad,
                                        const FiniteElement<dim> &fe_in,
                                        const unsigned int base_element_number)
      : element_type(tensor_general)
      , n_dimensions(0)
      , n_components(0)
      , n_q_points(0)
      , dofs_per_component_on_cell(0)
      , n_q_points_face(0)
      , dofs_per_component_on_face(0)
    {
      reinit(quad, fe_in, base_element_number);
    }

    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