fe_values.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2004 - 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_hp_fe_values_h
#define dealii_hp_fe_values_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/fe/fe.h>
#include <deal.II/fe/fe_values.h>
 
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
 
#include <deal.II/hp/fe_collection.h>
#include <deal.II/hp/mapping_collection.h>
#include <deal.II/hp/q_collection.h>
 
#include <memory>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declaration
#ifndef DOXYGEN
template <int dim, int spacedim>
class FiniteElement;
#endif
 
 
namespace hp
{
  template <int dim, int q_dim, typename FEValuesType>
  class FEValuesBase : public EnableObserverPointer
  {
  public:
    FEValuesBase(
      const MappingCollection<dim, FEValuesType::space_dimension>
        &mapping_collection,
      const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
      const QCollection<q_dim>                               &q_collection,
      const UpdateFlags                                       update_flags);
 
    FEValuesBase(
      const MappingCollection<dim, FEValuesType::space_dimension>
        &mapping_collection,
      const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
      const std::vector<QCollection<q_dim>>                  &q_collection,
      const UpdateFlags                                       update_flags);
 
    FEValuesBase(
      const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
      const QCollection<q_dim>                               &q_collection,
      const UpdateFlags                                       update_flags);
 
    FEValuesBase(
      const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
      const std::vector<QCollection<q_dim>>                  &q_collection,
      const UpdateFlags                                       update_flags);
 
    FEValuesBase(const FEValuesBase<dim, q_dim, FEValuesType> &other);
 
    FEValuesBase &
    operator=(const FEValuesBase &) = delete;
 
    void
    precalculate_fe_values(const std::vector<unsigned int> &fe_indices,
                           const std::vector<unsigned int> &mapping_indices,
                           const std::vector<unsigned int> &q_indices);
 
    void
    precalculate_fe_values();
 
    const FECollection<dim, FEValuesType::space_dimension> &
    get_fe_collection() const;
 
    const MappingCollection<dim, FEValuesType::space_dimension> &
    get_mapping_collection() const;
 
    const QCollection<q_dim> &
    get_quadrature_collection() const;
 
    UpdateFlags
    get_update_flags() const;
 
    const FEValuesType &
    get_present_fe_values() const;
 
  protected:
    FEValuesType &
    select_fe_values(const unsigned int fe_index,
                     const unsigned int mapping_index,
                     const unsigned int q_index);
 
  protected:
    const ObserverPointer<
      const FECollection<dim, FEValuesType::space_dimension>,
      FEValuesBase<dim, q_dim, FEValuesType>>
      fe_collection;
 
    const ObserverPointer<
      const MappingCollection<dim, FEValuesType::space_dimension>,
      FEValuesBase<dim, q_dim, FEValuesType>>
      mapping_collection;
 
    const QCollection<q_dim> q_collection;
 
    const std::vector<QCollection<q_dim>> q_collections;
 
  private:
    Table<3, std::unique_ptr<FEValuesType>> fe_values_table;
 
    TableIndices<3> present_fe_values_index;
 
    const UpdateFlags update_flags;
  };
 
} // namespace hp
 
 
namespace hp
{
  template <int dim, int spacedim = dim>
  class FEValues
    : public hp::FEValuesBase<dim, dim, ::FEValues<dim, spacedim>>
  {
  public:
    static constexpr unsigned int dimension = dim;
 
    static constexpr unsigned int space_dimension = spacedim;
 
    FEValues(const MappingCollection<dim, spacedim> &mapping_collection,
             const FECollection<dim, spacedim>      &fe_collection,
             const QCollection<dim>                 &q_collection,
             const UpdateFlags                       update_flags);
 
 
    FEValues(const FECollection<dim, spacedim> &fe_collection,
             const QCollection<dim>            &q_collection,
             const UpdateFlags                  update_flags);
 
 
    template <bool lda>
    void
    reinit(const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell,
           const unsigned int q_index       = numbers::invalid_unsigned_int,
           const unsigned int mapping_index = numbers::invalid_unsigned_int,
           const unsigned int fe_index      = numbers::invalid_unsigned_int);
 
    void
    reinit(const typename Triangulation<dim, spacedim>::cell_iterator &cell,
           const unsigned int q_index       = numbers::invalid_unsigned_int,
           const unsigned int mapping_index = numbers::invalid_unsigned_int,
           const unsigned int fe_index      = numbers::invalid_unsigned_int);
  };
 
 
 
  template <int dim, int spacedim = dim>
  class FEFaceValues
    : public hp::FEValuesBase<dim, dim - 1, ::FEFaceValues<dim, spacedim>>
  {
  public:
    FEFaceValues(const hp::MappingCollection<dim, spacedim> &mapping_collection,
                 const hp::FECollection<dim, spacedim>      &fe_collection,
                 const hp::QCollection<dim - 1>             &q_collection,
                 const UpdateFlags                           update_flags);
 
    FEFaceValues(const hp::MappingCollection<dim, spacedim> &mapping_collection,
                 const hp::FECollection<dim, spacedim>      &fe_collection,
                 const std::vector<hp::QCollection<dim - 1>> &q_collections,
                 const UpdateFlags                            update_flags);
 
 
    FEFaceValues(const hp::FECollection<dim, spacedim> &fe_collection,
                 const hp::QCollection<dim - 1>        &q_collection,
                 const UpdateFlags                      update_flags);
 
    FEFaceValues(const hp::FECollection<dim, spacedim>       &fe_collection,
                 const std::vector<hp::QCollection<dim - 1>> &q_collections,
                 const UpdateFlags                            update_flags);
 
    template <bool lda>
    void
    reinit(const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell,
           const unsigned int                                       face_no,
           const unsigned int q_index       = numbers::invalid_unsigned_int,
           const unsigned int mapping_index = numbers::invalid_unsigned_int,
           const unsigned int fe_index      = numbers::invalid_unsigned_int);
 
    template <bool lda>
    void
    reinit(const TriaIterator<DoFCellAccessor<dim, spacedim, lda>>    &cell,
           const typename Triangulation<dim, spacedim>::face_iterator &face,
           const unsigned int q_index       = numbers::invalid_unsigned_int,
           const unsigned int mapping_index = numbers::invalid_unsigned_int,
           const unsigned int fe_index      = numbers::invalid_unsigned_int);
 
    void
    reinit(const typename Triangulation<dim, spacedim>::cell_iterator &cell,
           const unsigned int                                          face_no,
           const unsigned int q_index       = numbers::invalid_unsigned_int,
           const unsigned int mapping_index = numbers::invalid_unsigned_int,
           const unsigned int fe_index      = numbers::invalid_unsigned_int);
 
    void
    reinit(const typename Triangulation<dim, spacedim>::cell_iterator &cell,
           const typename Triangulation<dim, spacedim>::face_iterator &face,
           const unsigned int q_index       = numbers::invalid_unsigned_int,
           const unsigned int mapping_index = numbers::invalid_unsigned_int,
           const unsigned int fe_index      = numbers::invalid_unsigned_int);
  };
 
 
 
  template <int dim, int spacedim = dim>
  class FESubfaceValues
    : public hp::
        FEValuesBase<dim, dim - 1, ::FESubfaceValues<dim, spacedim>>
  {
  public:
    FESubfaceValues(
      const hp::MappingCollection<dim, spacedim> &mapping_collection,
      const hp::FECollection<dim, spacedim>      &fe_collection,
      const hp::QCollection<dim - 1>             &q_collection,
      const UpdateFlags                           update_flags);
 
 
    FESubfaceValues(const hp::FECollection<dim, spacedim> &fe_collection,
                    const hp::QCollection<dim - 1>        &q_collection,
                    const UpdateFlags                      update_flags);
 
    template <bool lda>
    void
    reinit(const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell,
           const unsigned int                                       face_no,
           const unsigned int                                       subface_no,
           const unsigned int q_index       = numbers::invalid_unsigned_int,
           const unsigned int mapping_index = numbers::invalid_unsigned_int,
           const unsigned int fe_index      = numbers::invalid_unsigned_int);
 
    void
    reinit(const typename Triangulation<dim, spacedim>::cell_iterator &cell,
           const unsigned int                                          face_no,
           const unsigned int subface_no,
           const unsigned int q_index       = numbers::invalid_unsigned_int,
           const unsigned int mapping_index = numbers::invalid_unsigned_int,
           const unsigned int fe_index      = numbers::invalid_unsigned_int);
  };
 
} // namespace hp
 
 
// -------------- inline and template functions --------------
 
namespace hp
{
  template <int dim, int q_dim, typename FEValuesType>
  inline const FEValuesType &
  FEValuesBase<dim, q_dim, FEValuesType>::get_present_fe_values() const
  {
    Assert(
      present_fe_values_index != TableIndices<3>(numbers::invalid_unsigned_int,
                                                 numbers::invalid_unsigned_int,
                                                 numbers::invalid_unsigned_int),
      ExcMessage(
        "The indices of the present FEValues object are all invalid. The reason"
        " is likely that you have forgotten to call the reinit() function."));
 
    return *fe_values_table(present_fe_values_index);
  }
 
 
 
  template <int dim, int q_dim, typename FEValuesType>
  inline const FECollection<dim, FEValuesType::space_dimension> &
  FEValuesBase<dim, q_dim, FEValuesType>::get_fe_collection() const
  {
    return *fe_collection;
  }
 
 
 
  template <int dim, int q_dim, typename FEValuesType>
  inline const MappingCollection<dim, FEValuesType::space_dimension> &
  FEValuesBase<dim, q_dim, FEValuesType>::get_mapping_collection() const
  {
    return *mapping_collection;
  }
 
 
 
  template <int dim, int q_dim, typename FEValuesType>
  inline const QCollection<q_dim> &
  FEValuesBase<dim, q_dim, FEValuesType>::get_quadrature_collection() const
  {
    return q_collection;
  }
 
 
 
  template <int dim, int q_dim, typename FEValuesType>
  inline UpdateFlags
  FEValuesBase<dim, q_dim, FEValuesType>::get_update_flags() const
  {
    return update_flags;
  }
} // namespace hp
 
DEAL_II_NAMESPACE_CLOSE
 
#endif