fe_interface_values.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2019 - 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_fe_interface_values_h
#define dealii_fe_interface_values_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/std_cxx20/iota_view.h>
 
#include <deal.II/fe/fe_values.h>
#include <deal.II/fe/mapping.h>
 
#include <deal.II/hp/fe_collection.h>
#include <deal.II/hp/fe_values.h>
#include <deal.II/hp/q_collection.h>
 
DEAL_II_NAMESPACE_OPEN
 
#ifndef DOXYGEN
template <int dim, int spacedim>
class FEInterfaceValues;
#endif
 
namespace FEInterfaceViews
{
  template <int dim, int spacedim = dim>
  class Base
  {
  public:
    Base(const FEInterfaceValues<dim, spacedim> &fe_interface);
 
  protected:
    const FEInterfaceValues<dim, spacedim> *fe_interface;
 
    template <class InputVector, class OutputVector>
    void
    get_local_dof_values(const InputVector &dof_values,
                         OutputVector      &local_dof_values) const;
  };
 
 
 
  template <int dim, int spacedim = dim>
  class Scalar : public Base<dim, spacedim>
  {
  public:
    using value_type = double;
 
    using gradient_type =
      typename FEValuesViews::Scalar<dim, spacedim>::gradient_type;
 
    using hessian_type =
      typename FEValuesViews::Scalar<dim, spacedim>::hessian_type;
 
    using third_derivative_type =
      typename FEValuesViews::Scalar<dim, spacedim>::third_derivative_type;
 
    template <typename Number>
    using solution_value_type = typename ProductType<Number, value_type>::type;
 
    template <typename Number>
    using solution_gradient_type =
      typename ProductType<Number, gradient_type>::type;
 
    template <typename Number>
    using solution_hessian_type =
      typename ProductType<Number, hessian_type>::type;
 
    template <typename Number>
    using solution_third_derivative_type =
      typename ProductType<Number, third_derivative_type>::type;
 
    Scalar(const FEInterfaceValues<dim, spacedim> &fe_interface,
           const unsigned int                      component);
 
    value_type
    value(const bool         here_or_there,
          const unsigned int interface_dof_index,
          const unsigned int q_point) const;
 
    value_type
    jump_in_values(const unsigned int interface_dof_index,
                   const unsigned int q_point) const;
 
    gradient_type
    jump_in_gradients(const unsigned int interface_dof_index,
                      const unsigned int q_point) const;
 
    hessian_type
    jump_in_hessians(const unsigned int interface_dof_index,
                     const unsigned int q_point) const;
 
    third_derivative_type
    jump_in_third_derivatives(const unsigned int interface_dof_index,
                              const unsigned int q_point) const;
 
    value_type
    average_of_values(const unsigned int interface_dof_index,
                      const unsigned int q_point) const;
 
    gradient_type
    average_of_gradients(const unsigned int interface_dof_index,
                         const unsigned int q_point) const;
 
    hessian_type
    average_of_hessians(const unsigned int interface_dof_index,
                        const unsigned int q_point) const;
 
    template <class InputVector>
    void
    get_function_values(
      const bool         here_or_there,
      const InputVector &fe_function,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_function_values_from_local_dof_values(
      const bool         here_or_there,
      const InputVector &local_dof_values,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_jump_in_function_values(
      const InputVector &fe_function,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_jump_in_function_values_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_jump_in_function_gradients(
      const InputVector &fe_function,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const;
 
    template <class InputVector>
    void
    get_jump_in_function_gradients_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const;
 
    template <class InputVector>
    void
    get_jump_in_function_hessians(
      const InputVector &fe_function,
      std::vector<solution_hessian_type<typename InputVector::value_type>>
        &hessians) const;
 
    template <class InputVector>
    void
    get_jump_in_function_hessians_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_hessian_type<typename InputVector::value_type>>
        &hessians) const;
 
    template <class InputVector>
    void
    get_jump_in_function_third_derivatives(
      const InputVector &fe_function,
      std::vector<
        solution_third_derivative_type<typename InputVector::value_type>>
        &third_derivatives) const;
 
    template <class InputVector>
    void
    get_jump_in_function_third_derivatives_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<
        solution_third_derivative_type<typename InputVector::value_type>>
        &third_derivatives) const;
 
    template <class InputVector>
    void
    get_average_of_function_values(
      const InputVector &fe_function,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_average_of_function_values_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_average_of_function_gradients(
      const InputVector &fe_function,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const;
 
    template <class InputVector>
    void
    get_average_of_function_gradients_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const;
 
    template <class InputVector>
    void
    get_average_of_function_hessians(
      const InputVector &fe_function,
      std::vector<solution_hessian_type<typename InputVector::value_type>>
        &hessians) const;
 
    template <class InputVector>
    void
    get_average_of_function_hessians_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_hessian_type<typename InputVector::value_type>>
        &hessians) const;
 
  private:
    const FEValuesExtractors::Scalar extractor;
  };
 
 
 
  template <int dim, int spacedim = dim>
  class Vector : public Base<dim, spacedim>
  {
  public:
    using value_type =
      typename FEValuesViews::Vector<dim, spacedim>::value_type;
 
    using gradient_type =
      typename FEValuesViews::Vector<dim, spacedim>::gradient_type;
 
    using hessian_type =
      typename FEValuesViews::Vector<dim, spacedim>::hessian_type;
 
    using third_derivative_type =
      typename FEValuesViews::Vector<dim, spacedim>::third_derivative_type;
 
    template <typename Number>
    using solution_value_type = typename ProductType<Number, value_type>::type;
 
    template <typename Number>
    using solution_gradient_type =
      typename ProductType<Number, gradient_type>::type;
 
    template <typename Number>
    using solution_hessian_type =
      typename ProductType<Number, hessian_type>::type;
 
    template <typename Number>
    using solution_third_derivative_type =
      typename ProductType<Number, third_derivative_type>::type;
 
    Vector(const FEInterfaceValues<dim, spacedim> &fe_interface,
           const unsigned int                      first_vector_component);
 
    value_type
    value(const bool         here_or_there,
          const unsigned int interface_dof_index,
          const unsigned int q_point) const;
 
    value_type
    jump_in_values(const unsigned int interface_dof_index,
                   const unsigned int q_point) const;
 
    gradient_type
    jump_in_gradients(const unsigned int interface_dof_index,
                      const unsigned int q_point) const;
 
    gradient_type
    jump_gradient(const unsigned int interface_dof_index,
                  const unsigned int q_point) const;
 
    hessian_type
    jump_in_hessians(const unsigned int interface_dof_index,
                     const unsigned int q_point) const;
 
    hessian_type
    jump_hessian(const unsigned int interface_dof_index,
                 const unsigned int q_point) const;
 
    third_derivative_type
    jump_in_third_derivatives(const unsigned int interface_dof_index,
                              const unsigned int q_point) const;
 
    value_type
    average_of_values(const unsigned int interface_dof_index,
                      const unsigned int q_point) const;
 
    gradient_type
    average_of_gradients(const unsigned int interface_dof_index,
                         const unsigned int q_point) const;
 
    hessian_type
    average_of_hessians(const unsigned int interface_dof_index,
                        const unsigned int q_point) const;
 
    hessian_type
    average_hessian(const unsigned int interface_dof_index,
                    const unsigned int q_point) const;
 
    template <class InputVector>
    void
    get_function_values(
      const bool         here_or_there,
      const InputVector &fe_function,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_function_values_from_local_dof_values(
      const bool         here_or_there,
      const InputVector &local_dof_values,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_jump_in_function_values(
      const InputVector &fe_function,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_jump_in_function_values_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_jump_in_function_gradients(
      const InputVector &fe_function,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const;
 
    template <class InputVector>
    void
    get_jump_in_function_gradients_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const;
 
    template <class InputVector>
    void
    get_jump_in_function_hessians(
      const InputVector &fe_function,
      std::vector<solution_hessian_type<typename InputVector::value_type>>
        &hessians) const;
 
    template <class InputVector>
    void
    get_jump_in_function_hessians_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_hessian_type<typename InputVector::value_type>>
        &hessians) const;
 
    template <class InputVector>
    void
    get_jump_in_function_third_derivatives(
      const InputVector &fe_function,
      std::vector<
        solution_third_derivative_type<typename InputVector::value_type>>
        &third_derivatives) const;
 
    template <class InputVector>
    void
    get_jump_in_function_third_derivatives_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<
        solution_third_derivative_type<typename InputVector::value_type>>
        &third_derivatives) const;
 
    template <class InputVector>
    void
    get_average_of_function_values(
      const InputVector &fe_function,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_average_of_function_values_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_value_type<typename InputVector::value_type>>
        &values) const;
 
    template <class InputVector>
    void
    get_average_of_function_gradients(
      const InputVector &fe_function,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const;
 
    template <class InputVector>
    void
    get_average_of_function_gradients_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const;
 
    template <class InputVector>
    void
    get_average_of_function_hessians(
      const InputVector &fe_function,
      std::vector<solution_hessian_type<typename InputVector::value_type>>
        &hessians) const;
 
    template <class InputVector>
    void
    get_average_of_function_hessians_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_hessian_type<typename InputVector::value_type>>
        &hessians) const;
 
  private:
    const FEValuesExtractors::Vector extractor;
  };
} // namespace FEInterfaceViews
 
 
namespace internal
{
  namespace FEInterfaceViews
  {
    template <int dim, int spacedim, typename Extractor>
    struct ViewType
    {};
 
    template <int dim, int spacedim>
    struct ViewType<dim, spacedim, FEValuesExtractors::Scalar>
    {
      using type = typename ::FEInterfaceViews::Scalar<dim, spacedim>;
    };
 
    template <int dim, int spacedim>
    struct ViewType<dim, spacedim, FEValuesExtractors::Vector>
    {
      using type = typename ::FEInterfaceViews::Vector<dim, spacedim>;
    };
  } // namespace FEInterfaceViews
} // namespace internal
 
namespace FEInterfaceViews
{
  template <int dim, int spacedim, typename Extractor>
  using View = typename ::internal::FEInterfaceViews::
    ViewType<dim, spacedim, Extractor>::type;
} // namespace FEInterfaceViews
 
 
 
template <int dim, int spacedim = dim>
class FEInterfaceValues
{
public:
  const unsigned int n_quadrature_points;
 
  FEInterfaceValues(const Mapping<dim, spacedim>       &mapping,
                    const FiniteElement<dim, spacedim> &fe,
                    const Quadrature<dim - 1>          &quadrature,
                    const UpdateFlags                   update_flags);
 
  FEInterfaceValues(const Mapping<dim, spacedim>       &mapping,
                    const FiniteElement<dim, spacedim> &fe,
                    const hp::QCollection<dim - 1>     &quadrature,
                    const UpdateFlags                   update_flags);
 
  FEInterfaceValues(const FiniteElement<dim, spacedim> &fe,
                    const Quadrature<dim - 1>          &quadrature,
                    const UpdateFlags                   update_flags);
 
  FEInterfaceValues(
    const hp::MappingCollection<dim, spacedim> &mapping_collection,
    const hp::FECollection<dim, spacedim>      &fe_collection,
    const hp::QCollection<dim - 1>             &quadrature_collection,
    const UpdateFlags                           update_flags);
 
  FEInterfaceValues(const hp::FECollection<dim, spacedim> &fe_collection,
                    const hp::QCollection<dim - 1> &quadrature_collection,
                    const UpdateFlags               update_flags);
 
  template <typename CellIteratorType, typename CellNeighborIteratorType>
  void
  reinit(const CellIteratorType         &cell,
         const unsigned int              face_no,
         const unsigned int              sub_face_no,
         const CellNeighborIteratorType &cell_neighbor,
         const unsigned int              face_no_neighbor,
         const unsigned int              sub_face_no_neighbor,
         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,
         const unsigned int fe_index_neighbor = numbers::invalid_unsigned_int);
 
  template <typename CellIteratorType>
  void
  reinit(const CellIteratorType &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);
 
  const FEFaceValuesBase<dim, spacedim> &
  get_fe_face_values(const unsigned int cell_index) const;
 
  const Mapping<dim, spacedim> &
  get_mapping() const;
 
  const FiniteElement<dim, spacedim> &
  get_fe() const;
 
  const Quadrature<dim - 1> &
  get_quadrature() const;
 
  const hp::MappingCollection<dim, spacedim> &
  get_mapping_collection() const;
 
  const hp::FECollection<dim, spacedim> &
  get_fe_collection() const;
 
  const hp::QCollection<dim - 1> &
  get_quadrature_collection() const;
 
  bool
  has_hp_capabilities() const;
 
  UpdateFlags
  get_update_flags() const;
 
  typename Triangulation<dim, spacedim>::cell_iterator
  get_cell(const unsigned int cell_index) const;
 
  unsigned int
  get_face_number(const unsigned int cell_index) const;
 
  bool
  at_boundary() const;
 
  double
  JxW(const unsigned int quadrature_point) const;
 
  const std::vector<double> &
  get_JxW_values() const;
 
  const std::vector<Tensor<1, spacedim>> &
  get_normal_vectors() const;
 
  std_cxx20::ranges::iota_view<unsigned int, unsigned int>
  quadrature_point_indices() const;
 
  const std::vector<Point<spacedim>> &
  get_quadrature_points() const;
 
  unsigned
  n_current_interface_dofs() const;
 
  std_cxx20::ranges::iota_view<unsigned int, unsigned int>
  dof_indices() const;
 
  std::vector<types::global_dof_index>
  get_interface_dof_indices() const;
 
  std::array<unsigned int, 2>
  interface_dof_to_dof_indices(const unsigned int interface_dof_index) const;
 
  Tensor<1, spacedim>
  normal(const unsigned int q_point_index) const;
 
  double
  shape_value(const bool         here_or_there,
              const unsigned int interface_dof_index,
              const unsigned int q_point,
              const unsigned int component = 0) const;
 
  double
  jump_in_shape_values(const unsigned int interface_dof_index,
                       const unsigned int q_point,
                       const unsigned int component = 0) const;
 
  Tensor<1, spacedim>
  jump_in_shape_gradients(const unsigned int interface_dof_index,
                          const unsigned int q_point,
                          const unsigned int component = 0) const;
 
  Tensor<2, spacedim>
  jump_in_shape_hessians(const unsigned int interface_dof_index,
                         const unsigned int q_point,
                         const unsigned int component = 0) const;
 
  Tensor<3, spacedim>
  jump_in_shape_3rd_derivatives(const unsigned int interface_dof_index,
                                const unsigned int q_point,
                                const unsigned int component = 0) const;
 
  double
  average_of_shape_values(const unsigned int interface_dof_index,
                          const unsigned int q_point,
                          const unsigned int component = 0) const;
 
  Tensor<1, spacedim>
  average_of_shape_gradients(const unsigned int interface_dof_index,
                             const unsigned int q_point,
                             const unsigned int component = 0) const;
 
  Tensor<2, spacedim>
  average_of_shape_hessians(const unsigned int interface_dof_index,
                            const unsigned int q_point,
                            const unsigned int component = 0) const;
 
  template <class InputVector>
  void
  get_jump_in_function_values(
    const InputVector                             &fe_function,
    std::vector<typename InputVector::value_type> &values) const;
 
  template <class InputVector>
  void
  get_jump_in_function_gradients(
    const InputVector &fe_function,
    std::vector<Tensor<1, spacedim, typename InputVector::value_type>>
      &gradients) const;
 
  template <class InputVector>
  void
  get_jump_in_function_hessians(
    const InputVector &fe_function,
    std::vector<Tensor<2, spacedim, typename InputVector::value_type>>
      &hessians) const;
 
  template <class InputVector>
  void
  get_jump_in_function_third_derivatives(
    const InputVector &fe_function,
    std::vector<Tensor<3, spacedim, typename InputVector::value_type>>
      &third_derivatives) const;
 
  template <class InputVector>
  void
  get_average_of_function_values(
    const InputVector                             &fe_function,
    std::vector<typename InputVector::value_type> &values) const;
 
  template <class InputVector>
  void
  get_average_of_function_gradients(
    const InputVector &fe_function,
    std::vector<Tensor<1, spacedim, typename InputVector::value_type>>
      &gradients) const;
 
  template <class InputVector>
  void
  get_average_of_function_hessians(
    const InputVector &fe_function,
    std::vector<Tensor<2, spacedim, typename InputVector::value_type>>
      &hessians) const;
 
  FEInterfaceViews::Scalar<dim, spacedim>
  operator[](const FEValuesExtractors::Scalar &scalar) const;
 
  FEInterfaceViews::Vector<dim, spacedim>
  operator[](const FEValuesExtractors::Vector &vector) const;
 
private:
  std::vector<types::global_dof_index> interface_dof_indices;
 
  std::vector<std::array<unsigned int, 2>> dofmap;
 
  FEFaceValuesBase<dim, spacedim> *fe_face_values;
 
  FEFaceValuesBase<dim, spacedim> *fe_face_values_neighbor;
 
 // non-hp data
 
  std::unique_ptr<FEFaceValues<dim, spacedim>> internal_fe_face_values;
 
  std::unique_ptr<FESubfaceValues<dim, spacedim>> internal_fe_subface_values;
 
  std::unique_ptr<FEFaceValues<dim, spacedim>> internal_fe_face_values_neighbor;
 
  std::unique_ptr<FESubfaceValues<dim, spacedim>>
    internal_fe_subface_values_neighbor;
 
 // non-hp data
 
 // hp data
 
  std::unique_ptr<hp::FEFaceValues<dim, spacedim>> internal_hp_fe_face_values;
 
  std::unique_ptr<hp::FESubfaceValues<dim, spacedim>>
    internal_hp_fe_subface_values;
 
  std::unique_ptr<hp::FEFaceValues<dim, spacedim>>
    internal_hp_fe_face_values_neighbor;
 
  std::unique_ptr<hp::FESubfaceValues<dim, spacedim>>
    internal_hp_fe_subface_values_neighbor;
 
  DeclExceptionMsg(ExcOnlyAvailableWithoutHP,
                   "The current function doesn't make sense when used with a "
                   "FEInterfaceValues object with hp-capabilities.");
 
  DeclExceptionMsg(ExcOnlyAvailableWithHP,
                   "The current function doesn't make sense when used with a "
                   "FEInterfaceValues object without hp-capabilities.");
 
 // hp data
 
  /*
   * Make the view classes friends of this class, since they
   * access internal data.
   */
  template <int, int>
  friend class FEInterfaceViews::Scalar;
  template <int, int>
  friend class FEInterfaceViews::Vector;
};
 
 
 
#ifndef DOXYGEN
 
/*---------------------- Inline functions ---------------------*/
 
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
  const Mapping<dim, spacedim>       &mapping,
  const FiniteElement<dim, spacedim> &fe,
  const Quadrature<dim - 1>          &quadrature,
  const UpdateFlags                   update_flags)
  : n_quadrature_points(quadrature.size())
  , fe_face_values(nullptr)
  , fe_face_values_neighbor(nullptr)
  , internal_fe_face_values(
      std::make_unique<FEFaceValues<dim, spacedim>>(mapping,
                                                    fe,
                                                    quadrature,
                                                    update_flags))
  , internal_fe_subface_values(
      std::make_unique<FESubfaceValues<dim, spacedim>>(mapping,
                                                       fe,
                                                       quadrature,
                                                       update_flags))
  , internal_fe_face_values_neighbor(
      std::make_unique<FEFaceValues<dim, spacedim>>(mapping,
                                                    fe,
                                                    quadrature,
                                                    update_flags))
  , internal_fe_subface_values_neighbor(
      std::make_unique<FESubfaceValues<dim, spacedim>>(mapping,
                                                       fe,
                                                       quadrature,
                                                       update_flags))
{}
 
 
 
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
  const FiniteElement<dim, spacedim> &fe,
  const Quadrature<dim - 1>          &quadrature,
  const UpdateFlags                   update_flags)
  : FEInterfaceValues(
      fe.reference_cell().template get_default_linear_mapping<dim, spacedim>(),
      fe,
      quadrature,
      update_flags)
{}
 
 
 
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
  const Mapping<dim, spacedim>       &mapping,
  const FiniteElement<dim, spacedim> &fe,
  const hp::QCollection<dim - 1>     &quadrature,
  const UpdateFlags                   update_flags)
  : n_quadrature_points(quadrature.max_n_quadrature_points())
  , fe_face_values(nullptr)
  , fe_face_values_neighbor(nullptr)
  , internal_fe_face_values(
      std::make_unique<FEFaceValues<dim, spacedim>>(mapping,
                                                    fe,
                                                    quadrature,
                                                    update_flags))
  , internal_fe_subface_values(
      std::make_unique<FESubfaceValues<dim, spacedim>>(mapping,
                                                       fe,
                                                       quadrature,
                                                       update_flags))
  , internal_fe_face_values_neighbor(
      std::make_unique<FEFaceValues<dim, spacedim>>(mapping,
                                                    fe,
                                                    quadrature[0],
                                                    update_flags))
  , internal_fe_subface_values_neighbor(
      std::make_unique<FESubfaceValues<dim, spacedim>>(mapping,
                                                       fe,
                                                       quadrature[0],
                                                       update_flags))
{}
 
 
 
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
  const hp::MappingCollection<dim, spacedim> &mapping_collection,
  const hp::FECollection<dim, spacedim>      &fe_collection,
  const hp::QCollection<dim - 1>             &quadrature_collection,
  const UpdateFlags                           update_flags)
  : n_quadrature_points(quadrature_collection.max_n_quadrature_points())
  , fe_face_values(nullptr)
  , fe_face_values_neighbor(nullptr)
  , internal_hp_fe_face_values(
      std::make_unique<hp::FEFaceValues<dim, spacedim>>(mapping_collection,
                                                        fe_collection,
                                                        quadrature_collection,
                                                        update_flags))
  , internal_hp_fe_subface_values(
      std::make_unique<hp::FESubfaceValues<dim, spacedim>>(
        mapping_collection,
        fe_collection,
        quadrature_collection,
        update_flags))
  , internal_hp_fe_face_values_neighbor(
      std::make_unique<hp::FEFaceValues<dim, spacedim>>(mapping_collection,
                                                        fe_collection,
                                                        quadrature_collection,
                                                        update_flags))
  , internal_hp_fe_subface_values_neighbor(
      std::make_unique<hp::FESubfaceValues<dim, spacedim>>(
        mapping_collection,
        fe_collection,
        quadrature_collection,
        update_flags))
{
  AssertDimension(dim, spacedim);
}
 
 
 
template <int dim, int spacedim>
FEInterfaceValues<dim, spacedim>::FEInterfaceValues(
  const hp::FECollection<dim, spacedim> &fe_collection,
  const hp::QCollection<dim - 1>        &quadrature_collection,
  const UpdateFlags                      update_flags)
  : FEInterfaceValues(fe_collection.get_reference_cell_default_linear_mapping(),
                      fe_collection,
                      quadrature_collection,
                      update_flags)
{}
 
 
 
template <int dim, int spacedim>
template <typename CellIteratorType, typename CellNeighborIteratorType>
void
FEInterfaceValues<dim, spacedim>::reinit(
  const CellIteratorType         &cell,
  const unsigned int              face_no,
  const unsigned int              sub_face_no,
  const CellNeighborIteratorType &cell_neighbor,
  const unsigned int              face_no_neighbor,
  const unsigned int              sub_face_no_neighbor,
  const unsigned int              q_index,
  const unsigned int              mapping_index,
  const unsigned int              fe_index_in,
  const unsigned int              fe_index_neighbor_in)
{
  Assert(internal_fe_face_values || internal_hp_fe_face_values,
         ExcNotInitialized());
 
  constexpr bool is_dof_cell_accessor =
    std::is_same_v<DoFCellAccessor<dim, spacedim, true>,
                   typename CellIteratorType::AccessorType> ||
    std::is_same_v<DoFCellAccessor<dim, spacedim, false>,
                   typename CellIteratorType::AccessorType>;
 
  constexpr bool is_dof_cell_accessor_neighbor =
    std::is_same_v<DoFCellAccessor<dim, spacedim, true>,
                   typename CellNeighborIteratorType::AccessorType> ||
    std::is_same_v<DoFCellAccessor<dim, spacedim, false>,
                   typename CellNeighborIteratorType::AccessorType>;
 
  if (internal_fe_face_values)
    {
      if (sub_face_no == numbers::invalid_unsigned_int)
        {
          internal_fe_face_values->reinit(cell, face_no);
          fe_face_values = internal_fe_face_values.get();
        }
      else
        {
          internal_fe_subface_values->reinit(cell, face_no, sub_face_no);
          fe_face_values = internal_fe_subface_values.get();
        }
      if (sub_face_no_neighbor == numbers::invalid_unsigned_int)
        {
          internal_fe_face_values_neighbor->reinit(cell_neighbor,
                                                   face_no_neighbor);
          fe_face_values_neighbor = internal_fe_face_values_neighbor.get();
        }
      else
        {
          internal_fe_subface_values_neighbor->reinit(cell_neighbor,
                                                      face_no_neighbor,
                                                      sub_face_no_neighbor);
          fe_face_values_neighbor = internal_fe_subface_values_neighbor.get();
        }
 
      AssertDimension(fe_face_values->n_quadrature_points,
                      fe_face_values_neighbor->n_quadrature_points);
 
      const_cast<unsigned int &>(this->n_quadrature_points) =
        fe_face_values->n_quadrature_points;
    }
  else if (internal_hp_fe_face_values)
    {
      unsigned int active_fe_index = fe_index_in;
      unsigned int active_fe_index_neighbor =
        (fe_index_neighbor_in != numbers::invalid_unsigned_int) ?
          fe_index_neighbor_in :
          fe_index_in;
 
      if (active_fe_index == numbers::invalid_unsigned_int)
        {
          if constexpr (is_dof_cell_accessor)
            active_fe_index = cell->active_fe_index();
          else
            active_fe_index = 0;
        }
 
      if (active_fe_index_neighbor == numbers::invalid_unsigned_int)
        {
          if constexpr (is_dof_cell_accessor_neighbor)
            active_fe_index_neighbor = cell_neighbor->active_fe_index();
          else
            active_fe_index_neighbor = 0;
        }
 
      unsigned int used_q_index       = q_index;
      unsigned int used_mapping_index = mapping_index;
 
      // First check. If there is only one element in a collection, and if none
      // had been specified explicitly, then that's clearly the one to take:
      if (used_q_index == numbers::invalid_unsigned_int)
        if (internal_hp_fe_face_values->get_quadrature_collection().size() == 1)
          used_q_index = 0;
 
      if (used_mapping_index == numbers::invalid_unsigned_int)
        if (internal_hp_fe_face_values->get_mapping_collection().size() == 1)
          used_mapping_index = 0;
 
      // Second check: See if the two quadrature objects are the same, because
      // in that case it does not matter which one we use. Unfortunately, we
      // currently have no way of testing that two mapping objects are the
      // same :-(
      if (used_q_index == numbers::invalid_unsigned_int)
        if (internal_hp_fe_face_values
              ->get_quadrature_collection()[active_fe_index] ==
            internal_hp_fe_face_values
              ->get_quadrature_collection()[active_fe_index_neighbor])
          used_q_index = active_fe_index;
 
      // Third check, if the above did not already suffice. We see if we
      // can get somewhere via the dominated's finite element index.
      const unsigned int dominated_fe_index =
        ((used_q_index == numbers::invalid_unsigned_int) ||
             (used_mapping_index == numbers::invalid_unsigned_int) ?
           internal_hp_fe_face_values->get_fe_collection().find_dominated_fe(
             {active_fe_index, active_fe_index_neighbor}) :
           numbers::invalid_unsigned_int);
 
      if (used_q_index == numbers::invalid_unsigned_int)
        {
          Assert(dominated_fe_index != numbers::invalid_fe_index,
                 ExcMessage(
                   "You called this function with 'q_index' left at its "
                   "default value, but this can only work if one of "
                   "the two finite elements adjacent to this face "
                   "dominates the other. See the documentation "
                   "of this function for more information of how "
                   "to deal with this situation."));
          used_q_index = dominated_fe_index;
        }
 
      if (used_mapping_index == numbers::invalid_unsigned_int)
        {
          Assert(dominated_fe_index != numbers::invalid_fe_index,
                 ExcMessage(
                   "You called this function with 'mapping_index' left "
                   "at its default value, but this can only work if one "
                   "of the two finite elements adjacent to this face "
                   "dominates the other. See the documentation "
                   "of this function for more information of how "
                   "to deal with this situation."));
          used_mapping_index = dominated_fe_index;
        }
 
      // Same as if above, but when hp is enabled.
      if (sub_face_no == numbers::invalid_unsigned_int)
        {
          internal_hp_fe_face_values->reinit(
            cell, face_no, used_q_index, used_mapping_index, active_fe_index);
          fe_face_values = &const_cast<FEFaceValues<dim, spacedim> &>(
            internal_hp_fe_face_values->get_present_fe_values());
        }
      else
        {
          internal_hp_fe_subface_values->reinit(cell,
                                                face_no,
                                                sub_face_no,
                                                used_q_index,
                                                used_mapping_index,
                                                active_fe_index);
 
          fe_face_values = &const_cast<FESubfaceValues<dim, spacedim> &>(
            internal_hp_fe_subface_values->get_present_fe_values());
        }
      if (sub_face_no_neighbor == numbers::invalid_unsigned_int)
        {
          internal_hp_fe_face_values_neighbor->reinit(cell_neighbor,
                                                      face_no_neighbor,
                                                      used_q_index,
                                                      used_mapping_index,
                                                      active_fe_index_neighbor);
 
          fe_face_values_neighbor = &const_cast<FEFaceValues<dim, spacedim> &>(
            internal_hp_fe_face_values_neighbor->get_present_fe_values());
        }
      else
        {
          internal_hp_fe_subface_values_neighbor->reinit(
            cell_neighbor,
            face_no_neighbor,
            sub_face_no_neighbor,
            used_q_index,
            used_mapping_index,
            active_fe_index_neighbor);
 
          fe_face_values_neighbor =
            &const_cast<FESubfaceValues<dim, spacedim> &>(
              internal_hp_fe_subface_values_neighbor->get_present_fe_values());
        }
 
      AssertDimension(fe_face_values->n_quadrature_points,
                      fe_face_values_neighbor->n_quadrature_points);
 
      const_cast<unsigned int &>(this->n_quadrature_points) =
        fe_face_values->n_quadrature_points;
    }
 
  // Set up dof mapping and remove duplicates (for continuous elements).
  if constexpr (is_dof_cell_accessor_neighbor && is_dof_cell_accessor)
    {
      // Get dof indices first:
      std::vector<types::global_dof_index> v(
        fe_face_values->get_fe().n_dofs_per_cell());
      cell->get_active_or_mg_dof_indices(v);
      std::vector<types::global_dof_index> v2(
        fe_face_values_neighbor->get_fe().n_dofs_per_cell());
      cell_neighbor->get_active_or_mg_dof_indices(v2);
 
      // Fill a map from the global dof index to the left and right
      // local index.
      std::map<types::global_dof_index, std::pair<unsigned int, unsigned int>>
                                            tempmap;
      std::pair<unsigned int, unsigned int> invalid_entry(
        numbers::invalid_unsigned_int, numbers::invalid_unsigned_int);
 
      for (unsigned int i = 0; i < v.size(); ++i)
        {
          // If not already existing, add an invalid entry:
          auto result = tempmap.insert(std::make_pair(v[i], invalid_entry));
          result.first->second.first = i;
        }
 
      for (unsigned int i = 0; i < v2.size(); ++i)
        {
          // If not already existing, add an invalid entry:
          auto result = tempmap.insert(std::make_pair(v2[i], invalid_entry));
          result.first->second.second = i;
        }
 
      // Transfer from the map to the sorted std::vectors.
      dofmap.resize(tempmap.size());
      interface_dof_indices.resize(tempmap.size());
      unsigned int idx = 0;
      for (auto &x : tempmap)
        {
          interface_dof_indices[idx] = x.first;
          dofmap[idx]                = {{x.second.first, x.second.second}};
          ++idx;
        }
    }
}
 
 
 
template <int dim, int spacedim>
template <typename CellIteratorType>
void
FEInterfaceValues<dim, spacedim>::reinit(const CellIteratorType &cell,
                                         const unsigned int      face_no,
                                         const unsigned int      q_index,
                                         const unsigned int      mapping_index,
                                         const unsigned int      fe_index)
{
  Assert(internal_fe_face_values || internal_hp_fe_face_values,
         ExcNotInitialized());
 
  if (internal_fe_face_values)
    {
      Assert((q_index == 0 || q_index == numbers::invalid_unsigned_int),
             ExcNotImplemented());
      Assert((mapping_index == 0 ||
              mapping_index == numbers::invalid_unsigned_int),
             ExcNotImplemented());
      Assert((fe_index == 0 || fe_index == numbers::invalid_unsigned_int),
             ExcNotImplemented());
 
      internal_fe_face_values->reinit(cell, face_no);
      fe_face_values          = internal_fe_face_values.get();
      fe_face_values_neighbor = nullptr;
    }
  else if (internal_hp_fe_face_values)
    {
      internal_hp_fe_face_values->reinit(
        cell, face_no, q_index, mapping_index, fe_index);
      fe_face_values = &const_cast<FEFaceValues<dim> &>(
        internal_hp_fe_face_values->get_present_fe_values());
      fe_face_values_neighbor = nullptr;
    }
 
  if constexpr (std::is_same_v<typename CellIteratorType::AccessorType,
                               DoFCellAccessor<dim, spacedim, true>> ||
                std::is_same_v<typename CellIteratorType::AccessorType,
                               DoFCellAccessor<dim, spacedim, false>>)
    {
      if (internal_fe_face_values)
        {
          interface_dof_indices.resize(
            fe_face_values->get_fe().n_dofs_per_cell());
          cell->get_active_or_mg_dof_indices(interface_dof_indices);
        }
      else if (internal_hp_fe_face_values)
        {
          interface_dof_indices.resize(
            fe_face_values->get_fe().n_dofs_per_cell());
          cell->get_active_or_mg_dof_indices(interface_dof_indices);
        }
 
      dofmap.resize(interface_dof_indices.size());
      for (unsigned int i = 0; i < interface_dof_indices.size(); ++i)
        {
          dofmap[i] = {{i, numbers::invalid_unsigned_int}};
        }
    }
}
 
 
 
template <int dim, int spacedim>
inline double
FEInterfaceValues<dim, spacedim>::JxW(const unsigned int q) const
{
  Assert(fe_face_values != nullptr,
         ExcMessage("This call requires a call to reinit() first."));
  return fe_face_values->JxW(q);
}
 
 
 
template <int dim, int spacedim>
const std::vector<double> &
FEInterfaceValues<dim, spacedim>::get_JxW_values() const
{
  Assert(fe_face_values != nullptr,
         ExcMessage("This call requires a call to reinit() first."));
  return fe_face_values->get_JxW_values();
}
 
 
 
template <int dim, int spacedim>
const std::vector<Tensor<1, spacedim>> &
FEInterfaceValues<dim, spacedim>::get_normal_vectors() const
{
  Assert(fe_face_values != nullptr,
         ExcMessage("This call requires a call to reinit() first."));
  return fe_face_values->get_normal_vectors();
}
 
 
 
template <int dim, int spacedim>
const Mapping<dim, spacedim> &
FEInterfaceValues<dim, spacedim>::get_mapping() const
{
  Assert(!has_hp_capabilities(), ExcOnlyAvailableWithoutHP());
  return internal_fe_face_values->get_mapping();
}
 
 
 
template <int dim, int spacedim>
const FiniteElement<dim, spacedim> &
FEInterfaceValues<dim, spacedim>::get_fe() const
{
  Assert(!has_hp_capabilities(), ExcOnlyAvailableWithoutHP());
  return internal_fe_face_values->get_fe();
}
 
 
 
template <int dim, int spacedim>
const Quadrature<dim - 1> &
FEInterfaceValues<dim, spacedim>::get_quadrature() const
{
  Assert(!has_hp_capabilities(), ExcOnlyAvailableWithoutHP());
  return internal_fe_face_values->get_quadrature();
}
 
 
 
template <int dim, int spacedim>
const hp::MappingCollection<dim, spacedim> &
FEInterfaceValues<dim, spacedim>::get_mapping_collection() const
{
  Assert(has_hp_capabilities(), ExcOnlyAvailableWithHP());
  return internal_hp_fe_face_values->get_mapping_collection();
}
 
 
 
template <int dim, int spacedim>
const hp::FECollection<dim, spacedim> &
FEInterfaceValues<dim, spacedim>::get_fe_collection() const
{
  Assert(has_hp_capabilities(), ExcOnlyAvailableWithHP());
  return internal_hp_fe_face_values->get_fe_collection();
}
 
 
 
template <int dim, int spacedim>
const hp::QCollection<dim - 1> &
FEInterfaceValues<dim, spacedim>::get_quadrature_collection() const
{
  Assert(has_hp_capabilities(), ExcOnlyAvailableWithHP());
  return internal_hp_fe_face_values->get_quadrature_collection();
}
 
 
 
template <int dim, int spacedim>
bool
FEInterfaceValues<dim, spacedim>::has_hp_capabilities() const
{
  if (internal_hp_fe_face_values || internal_hp_fe_subface_values ||
      internal_hp_fe_face_values_neighbor ||
      internal_hp_fe_subface_values_neighbor)
    {
      Assert(!internal_fe_face_values, ExcInternalError());
      Assert(!internal_fe_subface_values, ExcInternalError());
      Assert(!internal_fe_face_values_neighbor, ExcInternalError());
      Assert(!internal_fe_subface_values_neighbor, ExcInternalError());
 
      return true;
    }
 
  Assert(internal_fe_face_values || internal_fe_subface_values ||
           internal_fe_face_values_neighbor ||
           internal_fe_subface_values_neighbor,
         ExcInternalError());
  Assert(!internal_hp_fe_face_values, ExcInternalError());
  Assert(!internal_hp_fe_subface_values, ExcInternalError());
  Assert(!internal_hp_fe_face_values_neighbor, ExcInternalError());
  Assert(!internal_hp_fe_subface_values_neighbor, ExcInternalError());
 
  return false;
}
 
 
 
template <int dim, int spacedim>
inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
FEInterfaceValues<dim, spacedim>::quadrature_point_indices() const
{
  return {0U, n_quadrature_points};
}
 
 
 
template <int dim, int spacedim>
const std::vector<Point<spacedim>> &
FEInterfaceValues<dim, spacedim>::get_quadrature_points() const
{
  Assert(fe_face_values != nullptr,
         ExcMessage("This call requires a call to reinit() first."));
  return fe_face_values->get_quadrature_points();
}
 
 
 
template <int dim, int spacedim>
UpdateFlags
FEInterfaceValues<dim, spacedim>::get_update_flags() const
{
  if (has_hp_capabilities())
    return internal_hp_fe_face_values->get_update_flags();
  else
    return internal_fe_face_values->get_update_flags();
}
 
 
 
template <int dim, int spacedim>
typename Triangulation<dim, spacedim>::cell_iterator
FEInterfaceValues<dim, spacedim>::get_cell(const unsigned int cell_index) const
{
  return get_fe_face_values(cell_index).get_cell();
}
 
 
 
template <int dim, int spacedim>
inline unsigned int
FEInterfaceValues<dim, spacedim>::get_face_number(
  const unsigned int cell_index) const
{
  return get_fe_face_values(cell_index).get_face_number();
}
 
 
 
template <int dim, int spacedim>
unsigned
FEInterfaceValues<dim, spacedim>::n_current_interface_dofs() const
{
  Assert(
    interface_dof_indices.size() > 0,
    ExcMessage(
      "n_current_interface_dofs() is only available after a call to reinit()."));
  return interface_dof_indices.size();
}
 
 
 
template <int dim, int spacedim>
inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
FEInterfaceValues<dim, spacedim>::dof_indices() const
{
  return {0U, n_current_interface_dofs()};
}
 
 
 
template <int dim, int spacedim>
bool
FEInterfaceValues<dim, spacedim>::at_boundary() const
{
  return fe_face_values_neighbor == nullptr;
}
 
 
 
template <int dim, int spacedim>
std::vector<types::global_dof_index>
FEInterfaceValues<dim, spacedim>::get_interface_dof_indices() const
{
  return interface_dof_indices;
}
 
 
 
template <int dim, int spacedim>
std::array<unsigned int, 2>
FEInterfaceValues<dim, spacedim>::interface_dof_to_dof_indices(
  const unsigned int interface_dof_index) const
{
  AssertIndexRange(interface_dof_index, n_current_interface_dofs());
  return dofmap[interface_dof_index];
}
 
 
 
template <int dim, int spacedim>
const FEFaceValuesBase<dim, spacedim> &
FEInterfaceValues<dim, spacedim>::get_fe_face_values(
  const unsigned int cell_index) const
{
  AssertIndexRange(cell_index, 2);
  Assert(
    cell_index == 0 || !at_boundary(),
    ExcMessage(
      "You are on a boundary, so you can only ask for the first FEFaceValues object."));
 
  return (cell_index == 0) ? *fe_face_values : *fe_face_values_neighbor;
}
 
 
 
template <int dim, int spacedim>
Tensor<1, spacedim>
FEInterfaceValues<dim, spacedim>::normal(const unsigned int q_point_index) const
{
  return fe_face_values->normal_vector(q_point_index);
}
 
 
 
template <int dim, int spacedim>
double
FEInterfaceValues<dim, spacedim>::shape_value(
  const bool         here_or_there,
  const unsigned int interface_dof_index,
  const unsigned int q_point,
  const unsigned int component) const
{
  const auto dof_pair = dofmap[interface_dof_index];
 
  if (here_or_there && dof_pair[0] != numbers::invalid_unsigned_int)
    return get_fe_face_values(0).shape_value_component(dof_pair[0],
                                                       q_point,
                                                       component);
  if (!here_or_there && dof_pair[1] != numbers::invalid_unsigned_int)
    return get_fe_face_values(1).shape_value_component(dof_pair[1],
                                                       q_point,
                                                       component);
 
  return 0.0;
}
 
 
 
template <int dim, int spacedim>
double
FEInterfaceValues<dim, spacedim>::jump_in_shape_values(
  const unsigned int interface_dof_index,
  const unsigned int q_point,
  const unsigned int component) const
{
  const auto dof_pair = dofmap[interface_dof_index];
 
  double value = 0.0;
 
  if (dof_pair[0] != numbers::invalid_unsigned_int)
    value += get_fe_face_values(0).shape_value_component(dof_pair[0],
                                                         q_point,
                                                         component);
  if (dof_pair[1] != numbers::invalid_unsigned_int)
    value -= get_fe_face_values(1).shape_value_component(dof_pair[1],
                                                         q_point,
                                                         component);
  return value;
}
 
 
 
template <int dim, int spacedim>
double
FEInterfaceValues<dim, spacedim>::average_of_shape_values(
  const unsigned int interface_dof_index,
  const unsigned int q_point,
  const unsigned int component) const
{
  const auto dof_pair = dofmap[interface_dof_index];
 
  if (at_boundary())
    return get_fe_face_values(0).shape_value_component(dof_pair[0],
                                                       q_point,
                                                       component);
 
  double value = 0.0;
 
  if (dof_pair[0] != numbers::invalid_unsigned_int)
    value += 0.5 * get_fe_face_values(0).shape_value_component(dof_pair[0],
                                                               q_point,
                                                               component);
  if (dof_pair[1] != numbers::invalid_unsigned_int)
    value += 0.5 * get_fe_face_values(1).shape_value_component(dof_pair[1],
                                                               q_point,
                                                               component);
 
  return value;
}
 
 
 
template <int dim, int spacedim>
Tensor<1, spacedim>
FEInterfaceValues<dim, spacedim>::average_of_shape_gradients(
  const unsigned int interface_dof_index,
  const unsigned int q_point,
  const unsigned int component) const
{
  const auto dof_pair = dofmap[interface_dof_index];
 
  if (at_boundary())
    return get_fe_face_values(0).shape_grad_component(dof_pair[0],
                                                      q_point,
                                                      component);
 
  Tensor<1, spacedim> value;
 
  if (dof_pair[0] != numbers::invalid_unsigned_int)
    value += 0.5 * get_fe_face_values(0).shape_grad_component(dof_pair[0],
                                                              q_point,
                                                              component);
  if (dof_pair[1] != numbers::invalid_unsigned_int)
    value += 0.5 * get_fe_face_values(1).shape_grad_component(dof_pair[1],
                                                              q_point,
                                                              component);
 
  return value;
}
 
 
 
template <int dim, int spacedim>
Tensor<2, spacedim>
FEInterfaceValues<dim, spacedim>::average_of_shape_hessians(
  const unsigned int interface_dof_index,
  const unsigned int q_point,
  const unsigned int component) const
{
  const auto dof_pair = dofmap[interface_dof_index];
 
  if (at_boundary())
    return get_fe_face_values(0).shape_hessian_component(dof_pair[0],
                                                         q_point,
                                                         component);
 
  Tensor<2, spacedim> value;
 
  if (dof_pair[0] != numbers::invalid_unsigned_int)
    value += 0.5 * get_fe_face_values(0).shape_hessian_component(dof_pair[0],
                                                                 q_point,
                                                                 component);
  if (dof_pair[1] != numbers::invalid_unsigned_int)
    value += 0.5 * get_fe_face_values(1).shape_hessian_component(dof_pair[1],
                                                                 q_point,
                                                                 component);
 
  return value;
}
 
 
 
template <int dim, int spacedim>
Tensor<1, spacedim>
FEInterfaceValues<dim, spacedim>::jump_in_shape_gradients(
  const unsigned int interface_dof_index,
  const unsigned int q_point,
  const unsigned int component) const
{
  const auto dof_pair = dofmap[interface_dof_index];
 
  if (at_boundary())
    return get_fe_face_values(0).shape_grad_component(dof_pair[0],
                                                      q_point,
                                                      component);
 
  Tensor<1, spacedim> value;
 
  if (dof_pair[0] != numbers::invalid_unsigned_int)
    value += get_fe_face_values(0).shape_grad_component(dof_pair[0],
                                                        q_point,
                                                        component);
  if (dof_pair[1] != numbers::invalid_unsigned_int)
    value -= get_fe_face_values(1).shape_grad_component(dof_pair[1],
                                                        q_point,
                                                        component);
 
  return value;
}
 
 
 
template <int dim, int spacedim>
Tensor<2, spacedim>
FEInterfaceValues<dim, spacedim>::jump_in_shape_hessians(
  const unsigned int interface_dof_index,
  const unsigned int q_point,
  const unsigned int component) const
{
  const auto dof_pair = dofmap[interface_dof_index];
 
  if (at_boundary())
    return get_fe_face_values(0).shape_hessian_component(dof_pair[0],
                                                         q_point,
                                                         component);
 
  Tensor<2, spacedim> value;
 
  if (dof_pair[0] != numbers::invalid_unsigned_int)
    value += get_fe_face_values(0).shape_hessian_component(dof_pair[0],
                                                           q_point,
                                                           component);
  if (dof_pair[1] != numbers::invalid_unsigned_int)
    value -= get_fe_face_values(1).shape_hessian_component(dof_pair[1],
                                                           q_point,
                                                           component);
 
  return value;
}
 
 
 
template <int dim, int spacedim>
Tensor<3, spacedim>
FEInterfaceValues<dim, spacedim>::jump_in_shape_3rd_derivatives(
  const unsigned int interface_dof_index,
  const unsigned int q_point,
  const unsigned int component) const
{
  const auto dof_pair = dofmap[interface_dof_index];
 
  if (at_boundary())
    return get_fe_face_values(0).shape_3rd_derivative_component(dof_pair[0],
                                                                q_point,
                                                                component);
 
  Tensor<3, spacedim> value;
 
  if (dof_pair[0] != numbers::invalid_unsigned_int)
    value += get_fe_face_values(0).shape_3rd_derivative_component(dof_pair[0],
                                                                  q_point,
                                                                  component);
  if (dof_pair[1] != numbers::invalid_unsigned_int)
    value -= get_fe_face_values(1).shape_3rd_derivative_component(dof_pair[1],
                                                                  q_point,
                                                                  component);
 
  return value;
}
 
 
 
template <int dim, int spacedim>
template <class InputVector>
void
FEInterfaceValues<dim, spacedim>::get_jump_in_function_values(
  const InputVector                             &fe_function,
  std::vector<typename InputVector::value_type> &values) const
{
  AssertDimension(values.size(), n_quadrature_points);
 
  const FEValuesExtractors::Scalar scalar(0);
  this->operator[](scalar).get_jump_in_function_values(fe_function, values);
}
 
 
 
template <int dim, int spacedim>
template <class InputVector>
void
FEInterfaceValues<dim, spacedim>::get_jump_in_function_gradients(
  const InputVector &fe_function,
  std::vector<Tensor<1, spacedim, typename InputVector::value_type>> &gradients)
  const
{
  AssertDimension(gradients.size(), n_quadrature_points);
 
  const FEValuesExtractors::Scalar scalar(0);
  this->operator[](scalar).get_jump_in_function_gradients(fe_function,
                                                          gradients);
}
 
 
 
template <int dim, int spacedim>
template <class InputVector>
void
FEInterfaceValues<dim, spacedim>::get_jump_in_function_hessians(
  const InputVector &fe_function,
  std::vector<Tensor<2, spacedim, typename InputVector::value_type>> &hessians)
  const
{
  AssertDimension(hessians.size(), n_quadrature_points);
 
  const FEValuesExtractors::Scalar scalar(0);
  this->operator[](scalar).get_jump_in_function_hessians(fe_function, hessians);
}
 
 
 
template <int dim, int spacedim>
template <class InputVector>
void
FEInterfaceValues<dim, spacedim>::get_jump_in_function_third_derivatives(
  const InputVector &fe_function,
  std::vector<Tensor<3, spacedim, typename InputVector::value_type>>
    &third_derivatives) const
{
  AssertDimension(third_derivatives.size(), n_quadrature_points);
 
  const FEValuesExtractors::Scalar scalar(0);
  this->operator[](scalar).get_jump_in_function_third_derivatives(
    fe_function, third_derivatives);
}
 
 
 
template <int dim, int spacedim>
template <class InputVector>
void
FEInterfaceValues<dim, spacedim>::get_average_of_function_values(
  const InputVector                             &fe_function,
  std::vector<typename InputVector::value_type> &values) const
{
  AssertDimension(values.size(), n_quadrature_points);
 
  const FEValuesExtractors::Scalar scalar(0);
  this->operator[](scalar).get_average_of_function_values(fe_function, values);
}
 
 
 
template <int dim, int spacedim>
template <class InputVector>
void
FEInterfaceValues<dim, spacedim>::get_average_of_function_gradients(
  const InputVector &fe_function,
  std::vector<Tensor<1, spacedim, typename InputVector::value_type>> &gradients)
  const
{
  AssertDimension(gradients.size(), n_quadrature_points);
 
  const FEValuesExtractors::Scalar scalar(0);
  this->operator[](scalar).get_average_of_function_gradients(fe_function,
                                                             gradients);
}
 
 
 
template <int dim, int spacedim>
template <class InputVector>
void
FEInterfaceValues<dim, spacedim>::get_average_of_function_hessians(
  const InputVector &fe_function,
  std::vector<Tensor<2, spacedim, typename InputVector::value_type>> &hessians)
  const
{
  AssertDimension(hessians.size(), n_quadrature_points);
 
  const FEValuesExtractors::Scalar scalar(0);
  this->operator[](scalar).get_average_of_function_hessians(fe_function,
                                                            hessians);
}
 
 
 
/*------------ Inline functions: FEInterfaceValues------------*/
template <int dim, int spacedim>
inline FEInterfaceViews::Scalar<dim, spacedim>
FEInterfaceValues<dim, spacedim>::operator[](
  const FEValuesExtractors::Scalar &scalar) const
{
  const unsigned int n_components =
    (this->has_hp_capabilities() ? this->get_fe_collection().n_components() :
                                   this->get_fe().n_components());
  (void)n_components;
  AssertIndexRange(scalar.component, n_components);
  return FEInterfaceViews::Scalar<dim, spacedim>(*this, scalar.component);
}
 
 
 
template <int dim, int spacedim>
inline FEInterfaceViews::Vector<dim, spacedim>
FEInterfaceValues<dim, spacedim>::operator[](
  const FEValuesExtractors::Vector &vector) const
{
  const unsigned int n_components =
    (this->has_hp_capabilities() ? this->get_fe_collection().n_components() :
                                   this->get_fe().n_components());
  const unsigned int n_vectors =
    (n_components >= Tensor<1, spacedim>::n_independent_components ?
       n_components - Tensor<1, spacedim>::n_independent_components + 1 :
       0);
  (void)n_components;
  (void)n_vectors;
  AssertIndexRange(vector.first_vector_component, n_vectors);
  return FEInterfaceViews::Vector<dim, spacedim>(*this,
                                                 vector.first_vector_component);
}
 
 
 
namespace FEInterfaceViews
{
  template <int dim, int spacedim>
  Base<dim, spacedim>::Base(
    const FEInterfaceValues<dim, spacedim> &fe_interface)
    : fe_interface(&fe_interface)
  {}
 
 
 
  template <int dim, int spacedim>
  Scalar<dim, spacedim>::Scalar(
    const FEInterfaceValues<dim, spacedim> &fe_interface,
    const unsigned int                      component)
    : Base<dim, spacedim>(fe_interface)
    , extractor(component)
  {}
 
 
 
  template <int dim, int spacedim>
  template <class InputVector, class OutputVector>
  void
  Base<dim, spacedim>::get_local_dof_values(
    const InputVector &dof_values,
    OutputVector      &local_dof_values) const
  {
    const auto &interface_dof_indices =
      this->fe_interface->get_interface_dof_indices();
 
    AssertDimension(interface_dof_indices.size(), local_dof_values.size());
 
    for (const unsigned int i : this->fe_interface->dof_indices())
      local_dof_values[i] = dof_values(interface_dof_indices[i]);
  }
 
 
 
  template <int dim, int spacedim>
  typename Scalar<dim, spacedim>::value_type
  Scalar<dim, spacedim>::value(const bool         here_or_there,
                               const unsigned int interface_dof_index,
                               const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (here_or_there && dof_pair[0] != numbers::invalid_unsigned_int)
      return (*(this->fe_interface->fe_face_values))[extractor].value(
        dof_pair[0], q_point);
 
    if (!here_or_there && dof_pair[1] != numbers::invalid_unsigned_int)
      return (*(this->fe_interface->fe_face_values_neighbor))[extractor].value(
        dof_pair[1], q_point);
 
    return 0.0;
  }
 
 
 
  template <int dim, int spacedim>
  typename Scalar<dim, spacedim>::value_type
  Scalar<dim, spacedim>::jump_in_values(const unsigned int interface_dof_index,
                                        const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    value_type value = 0.0;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        (*(this->fe_interface->fe_face_values))[extractor].value(dof_pair[0],
                                                                 q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value -=
        (*(this->fe_interface->fe_face_values_neighbor))[extractor].value(
          dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Scalar<dim, spacedim>::value_type
  Scalar<dim, spacedim>::average_of_values(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].value(
        dof_pair[0], q_point);
 
    value_type value = 0.0;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        0.5 *
        (*(this->fe_interface->fe_face_values))[extractor].value(dof_pair[0],
                                                                 q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value +=
        0.5 * (*(this->fe_interface->fe_face_values_neighbor))[extractor].value(
                dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Scalar<dim, spacedim>::gradient_type
  Scalar<dim, spacedim>::average_of_gradients(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].gradient(
        dof_pair[0], q_point);
 
    gradient_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        0.5 *
        (*(this->fe_interface->fe_face_values))[extractor].gradient(dof_pair[0],
                                                                    q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value += 0.5 * (*(this->fe_interface->fe_face_values_neighbor))[extractor]
                       .gradient(dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Scalar<dim, spacedim>::gradient_type
  Scalar<dim, spacedim>::jump_in_gradients(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].gradient(
        dof_pair[0], q_point);
 
    gradient_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        (*(this->fe_interface->fe_face_values))[extractor].gradient(dof_pair[0],
                                                                    q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value -=
        (*(this->fe_interface->fe_face_values_neighbor))[extractor].gradient(
          dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Scalar<dim, spacedim>::hessian_type
  Scalar<dim, spacedim>::average_of_hessians(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].hessian(
        dof_pair[0], q_point);
 
    hessian_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        0.5 *
        (*(this->fe_interface->fe_face_values))[extractor].hessian(dof_pair[0],
                                                                   q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value += 0.5 * (*(this->fe_interface->fe_face_values_neighbor))[extractor]
                       .hessian(dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Scalar<dim, spacedim>::third_derivative_type
  Scalar<dim, spacedim>::jump_in_third_derivatives(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor]
        .third_derivative(dof_pair[0], q_point);
 
    third_derivative_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        (*(this->fe_interface->fe_face_values))[extractor].third_derivative(
          dof_pair[0], q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value -= (*(this->fe_interface->fe_face_values_neighbor))[extractor]
                 .third_derivative(dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Scalar<dim, spacedim>::hessian_type
  Scalar<dim, spacedim>::jump_in_hessians(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].hessian(
        dof_pair[0], q_point);
 
    hessian_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        (*(this->fe_interface->fe_face_values))[extractor].hessian(dof_pair[0],
                                                                   q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value -=
        (*(this->fe_interface->fe_face_values_neighbor))[extractor].hessian(
          dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_function_values_from_local_dof_values(
    const bool         here_or_there,
    const InputVector &local_dof_values,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    AssertDimension(values.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            values[q_index] = 0.;
 
          values[q_index] += local_dof_values[dof_index] *
                             value(here_or_there, dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_function_values(
    const bool         here_or_there,
    const InputVector &fe_function,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_function_values_from_local_dof_values(here_or_there,
                                              local_dof_values,
                                              values);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_jump_in_function_values_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    AssertDimension(values.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            values[q_index] = 0.;
 
          values[q_index] +=
            local_dof_values[dof_index] * jump_in_values(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_jump_in_function_values(
    const InputVector &fe_function,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_jump_in_function_values_from_local_dof_values(local_dof_values, values);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_jump_in_function_gradients_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_gradient_type<typename InputVector::value_type>>
      &gradients) const
  {
    AssertDimension(gradients.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            gradients[q_index] = 0.;
 
          gradients[q_index] +=
            local_dof_values[dof_index] * jump_in_gradients(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_jump_in_function_gradients(
    const InputVector &fe_function,
    std::vector<solution_gradient_type<typename InputVector::value_type>>
      &gradients) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_jump_in_function_gradients_from_local_dof_values(local_dof_values,
                                                         gradients);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_average_of_function_values_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    AssertDimension(values.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            values[q_index] = 0.;
 
          values[q_index] +=
            local_dof_values[dof_index] * average_of_values(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_average_of_function_values(
    const InputVector &fe_function,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_average_of_function_values_from_local_dof_values(local_dof_values,
                                                         values);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::
    get_average_of_function_gradients_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const
  {
    AssertDimension(gradients.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            gradients[q_index] = 0.;
 
          gradients[q_index] += local_dof_values[dof_index] *
                                average_of_gradients(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_average_of_function_gradients(
    const InputVector &fe_function,
    std::vector<solution_gradient_type<typename InputVector::value_type>>
      &gradients) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_average_of_function_gradients_from_local_dof_values(local_dof_values,
                                                            gradients);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_jump_in_function_hessians_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_hessian_type<typename InputVector::value_type>>
      &hessians) const
  {
    AssertDimension(hessians.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            hessians[q_index] = 0.;
 
          hessians[q_index] +=
            local_dof_values[dof_index] * jump_in_hessians(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_jump_in_function_hessians(
    const InputVector &fe_function,
    std::vector<solution_hessian_type<typename InputVector::value_type>>
      &hessians) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_jump_in_function_hessians_from_local_dof_values(local_dof_values,
                                                        hessians);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_average_of_function_hessians_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_hessian_type<typename InputVector::value_type>>
      &hessians) const
  {
    AssertDimension(hessians.size(), this->fe_interface->n_quadrature_points);
 
    for (const unsigned int dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            hessians[q_index] = 0.;
 
          hessians[q_index] += local_dof_values[dof_index] *
                               average_of_hessians(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_average_of_function_hessians(
    const InputVector &fe_function,
    std::vector<solution_hessian_type<typename InputVector::value_type>>
      &hessians) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_average_of_function_hessians_from_local_dof_values(local_dof_values,
                                                           hessians);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::
    get_jump_in_function_third_derivatives_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<
        solution_third_derivative_type<typename InputVector::value_type>>
        &third_derivatives) const
  {
    AssertDimension(third_derivatives.size(),
                    this->fe_interface->n_quadrature_points);
 
    for (const unsigned int dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            third_derivatives[q_index] = 0.;
 
          third_derivatives[q_index] +=
            local_dof_values[dof_index] *
            jump_in_third_derivatives(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Scalar<dim, spacedim>::get_jump_in_function_third_derivatives(
    const InputVector &fe_function,
    std::vector<
      solution_third_derivative_type<typename InputVector::value_type>>
      &third_derivatives) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_jump_in_function_third_derivatives_from_local_dof_values(
      local_dof_values, third_derivatives);
  }
 
 
 
  template <int dim, int spacedim>
  Vector<dim, spacedim>::Vector(
    const FEInterfaceValues<dim, spacedim> &fe_interface,
    const unsigned int                      first_vector_component)
    : Base<dim, spacedim>(fe_interface)
    , extractor(first_vector_component)
  {}
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::value_type
  Vector<dim, spacedim>::value(const bool         here_or_there,
                               const unsigned int interface_dof_index,
                               const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (here_or_there && dof_pair[0] != numbers::invalid_unsigned_int)
      return (*(this->fe_interface->fe_face_values))[extractor].value(
        dof_pair[0], q_point);
 
    if (!here_or_there && dof_pair[1] != numbers::invalid_unsigned_int)
      return (*(this->fe_interface->fe_face_values_neighbor))[extractor].value(
        dof_pair[1], q_point);
 
    return value_type();
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::value_type
  Vector<dim, spacedim>::jump_in_values(const unsigned int interface_dof_index,
                                        const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    value_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        (*(this->fe_interface->fe_face_values))[extractor].value(dof_pair[0],
                                                                 q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value -=
        (*(this->fe_interface->fe_face_values_neighbor))[extractor].value(
          dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::value_type
  Vector<dim, spacedim>::average_of_values(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].value(
        dof_pair[0], q_point);
 
    value_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        0.5 *
        (*(this->fe_interface->fe_face_values))[extractor].value(dof_pair[0],
                                                                 q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value +=
        0.5 * (*(this->fe_interface->fe_face_values_neighbor))[extractor].value(
                dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::gradient_type
  Vector<dim, spacedim>::average_of_gradients(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].gradient(
        dof_pair[0], q_point);
 
    gradient_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        0.5 *
        (*(this->fe_interface->fe_face_values))[extractor].gradient(dof_pair[0],
                                                                    q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value += 0.5 * (*(this->fe_interface->fe_face_values_neighbor))[extractor]
                       .gradient(dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::gradient_type
  Vector<dim, spacedim>::jump_in_gradients(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].gradient(
        dof_pair[0], q_point);
 
    gradient_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        (*(this->fe_interface->fe_face_values))[extractor].gradient(dof_pair[0],
                                                                    q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value -=
        (*(this->fe_interface->fe_face_values_neighbor))[extractor].gradient(
          dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::gradient_type
  Vector<dim, spacedim>::jump_gradient(const unsigned int interface_dof_index,
                                       const unsigned int q_point) const
  {
    return jump_in_gradients(interface_dof_index, q_point);
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::hessian_type
  Vector<dim, spacedim>::average_of_hessians(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].hessian(
        dof_pair[0], q_point);
 
    hessian_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        0.5 *
        (*(this->fe_interface->fe_face_values))[extractor].hessian(dof_pair[0],
                                                                   q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value += 0.5 * (*(this->fe_interface->fe_face_values_neighbor))[extractor]
                       .hessian(dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::hessian_type
  Vector<dim, spacedim>::average_hessian(const unsigned int interface_dof_index,
                                         const unsigned int q_point) const
  {
    return average_of_hessians(interface_dof_index, q_point);
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::hessian_type
  Vector<dim, spacedim>::jump_in_hessians(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor].hessian(
        dof_pair[0], q_point);
 
    hessian_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        (*(this->fe_interface->fe_face_values))[extractor].hessian(dof_pair[0],
                                                                   q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value -=
        (*(this->fe_interface->fe_face_values_neighbor))[extractor].hessian(
          dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::hessian_type
  Vector<dim, spacedim>::jump_hessian(const unsigned int interface_dof_index,
                                      const unsigned int q_point) const
  {
    return jump_in_hessians(interface_dof_index, q_point);
  }
 
 
 
  template <int dim, int spacedim>
  typename Vector<dim, spacedim>::third_derivative_type
  Vector<dim, spacedim>::jump_in_third_derivatives(
    const unsigned int interface_dof_index,
    const unsigned int q_point) const
  {
    const auto dof_pair = this->fe_interface->dofmap[interface_dof_index];
 
    if (this->fe_interface->at_boundary())
      return (*(this->fe_interface->fe_face_values))[extractor]
        .third_derivative(dof_pair[0], q_point);
 
    third_derivative_type value;
 
    if (dof_pair[0] != numbers::invalid_unsigned_int)
      value +=
        (*(this->fe_interface->fe_face_values))[extractor].third_derivative(
          dof_pair[0], q_point);
 
    if (dof_pair[1] != numbers::invalid_unsigned_int)
      value -= (*(this->fe_interface->fe_face_values_neighbor))[extractor]
                 .third_derivative(dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_function_values_from_local_dof_values(
    const bool         here_or_there,
    const InputVector &local_dof_values,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    AssertDimension(values.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            values[q_index] = 0.;
 
          values[q_index] += local_dof_values[dof_index] *
                             value(here_or_there, dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_function_values(
    const bool         here_or_there,
    const InputVector &fe_function,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_function_values_from_local_dof_values(here_or_there,
                                              local_dof_values,
                                              values);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_jump_in_function_values_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    AssertDimension(values.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            values[q_index] = 0.;
 
          values[q_index] +=
            local_dof_values[dof_index] * jump_in_values(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_jump_in_function_values(
    const InputVector &fe_function,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_jump_in_function_values_from_local_dof_values(local_dof_values, values);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_jump_in_function_gradients_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_gradient_type<typename InputVector::value_type>>
      &gradients) const
  {
    AssertDimension(gradients.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            gradients[q_index] = 0.;
 
          gradients[q_index] +=
            local_dof_values[dof_index] * jump_in_gradients(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_jump_in_function_gradients(
    const InputVector &fe_function,
    std::vector<solution_gradient_type<typename InputVector::value_type>>
      &gradients) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_jump_in_function_gradients_from_local_dof_values(local_dof_values,
                                                         gradients);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_average_of_function_values_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    AssertDimension(values.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            values[q_index] = 0.;
 
          values[q_index] +=
            local_dof_values[dof_index] * average_of_values(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_average_of_function_values(
    const InputVector &fe_function,
    std::vector<solution_value_type<typename InputVector::value_type>> &values)
    const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_average_of_function_values_from_local_dof_values(local_dof_values,
                                                         values);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::
    get_average_of_function_gradients_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<solution_gradient_type<typename InputVector::value_type>>
        &gradients) const
  {
    AssertDimension(gradients.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            gradients[q_index] = 0.;
 
          gradients[q_index] += local_dof_values[dof_index] *
                                average_of_gradients(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_average_of_function_gradients(
    const InputVector &fe_function,
    std::vector<solution_gradient_type<typename InputVector::value_type>>
      &gradients) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_average_of_function_gradients_from_local_dof_values(local_dof_values,
                                                            gradients);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_jump_in_function_hessians_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_hessian_type<typename InputVector::value_type>>
      &hessians) const
  {
    AssertDimension(hessians.size(), this->fe_interface->n_quadrature_points);
 
    for (const auto dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            hessians[q_index] = 0.;
 
          hessians[q_index] +=
            local_dof_values[dof_index] * jump_in_hessians(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_jump_in_function_hessians(
    const InputVector &fe_function,
    std::vector<solution_hessian_type<typename InputVector::value_type>>
      &hessians) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_jump_in_function_hessians_from_local_dof_values(local_dof_values,
                                                        hessians);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_average_of_function_hessians_from_local_dof_values(
    const InputVector &local_dof_values,
    std::vector<solution_hessian_type<typename InputVector::value_type>>
      &hessians) const
  {
    AssertDimension(hessians.size(), this->fe_interface->n_quadrature_points);
 
    for (const unsigned int dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            hessians[q_index] = 0.;
 
          hessians[q_index] += local_dof_values[dof_index] *
                               average_of_hessians(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_average_of_function_hessians(
    const InputVector &fe_function,
    std::vector<solution_hessian_type<typename InputVector::value_type>>
      &hessians) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_average_of_function_hessians_from_local_dof_values(local_dof_values,
                                                           hessians);
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::
    get_jump_in_function_third_derivatives_from_local_dof_values(
      const InputVector &local_dof_values,
      std::vector<
        solution_third_derivative_type<typename InputVector::value_type>>
        &third_derivatives) const
  {
    AssertDimension(third_derivatives.size(),
                    this->fe_interface->n_quadrature_points);
 
    for (const unsigned int dof_index : this->fe_interface->dof_indices())
      for (const auto q_index : this->fe_interface->quadrature_point_indices())
        {
          if (dof_index == 0)
            third_derivatives[q_index] = 0.;
 
          third_derivatives[q_index] +=
            local_dof_values[dof_index] *
            jump_in_third_derivatives(dof_index, q_index);
        }
  }
 
 
 
  template <int dim, int spacedim>
  template <class InputVector>
  void
  Vector<dim, spacedim>::get_jump_in_function_third_derivatives(
    const InputVector &fe_function,
    std::vector<
      solution_third_derivative_type<typename InputVector::value_type>>
      &third_derivatives) const
  {
    std::vector<typename InputVector::value_type> local_dof_values(
      this->fe_interface->n_current_interface_dofs());
    this->get_local_dof_values(fe_function, local_dof_values);
 
    get_jump_in_function_third_derivatives_from_local_dof_values(
      local_dof_values, third_derivatives);
  }
} // namespace FEInterfaceViews
 
#endif // DOXYGEN
 
DEAL_II_NAMESPACE_CLOSE
 
#endif