fe_values.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2003 - 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_hp_fe_values_h
#define dealii_hp_fe_values_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/fe/fe.h>
#include <deal.II/fe/fe_values.h>
 
#include <deal.II/hp/fe_collection.h>
#include <deal.II/hp/mapping_collection.h>
#include <deal.II/hp/q_collection.h>
 
#include <map>
#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, class FEValuesType>
  class FEValuesBase
  {
  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 FECollection<dim, FEValuesType::space_dimension> &fe_collection,
      const 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 SmartPointer<const FECollection<dim, FEValuesType::space_dimension>,
                       FEValuesBase<dim, q_dim, FEValuesType>>
      fe_collection;
 
    const SmartPointer<
      const MappingCollection<dim, FEValuesType::space_dimension>,
      FEValuesBase<dim, q_dim, FEValuesType>>
      mapping_collection;
 
    const QCollection<q_dim> q_collection;
 
  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 const unsigned int dimension = dim;
 
    static const 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 <typename DoFHandlerType, bool lda>
    void
    reinit(const TriaIterator<DoFCellAccessor<DoFHandlerType, 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::FECollection<dim, spacedim> &fe_collection,
                 const hp::QCollection<dim - 1> &       q_collection,
                 const UpdateFlags                      update_flags);
 
    template <typename DoFHandlerType, bool lda>
    void
    reinit(const TriaIterator<DoFCellAccessor<DoFHandlerType, 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);
 
    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);
  };
 
 
 
  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 <typename DoFHandlerType, bool lda>
    void
    reinit(const TriaIterator<DoFCellAccessor<DoFHandlerType, 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, class FEValuesType>
  inline const FEValuesType &
  FEValuesBase<dim, q_dim, FEValuesType>::get_present_fe_values() const
  {
    return *fe_values_table(present_fe_values_index);
  }
 
 
 
  template <int dim, int q_dim, class 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, class 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, class FEValuesType>
  inline const QCollection<q_dim> &
  FEValuesBase<dim, q_dim, FEValuesType>::get_quadrature_collection() const
  {
    return q_collection;
  }
 
 
 
  template <int dim, int q_dim, class FEValuesType>
  inline UpdateFlags
  FEValuesBase<dim, q_dim, FEValuesType>::get_update_flags() const
  {
    return update_flags;
  }
} // namespace hp
 
DEAL_II_NAMESPACE_CLOSE
 
#endif