fe_interface_values.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2019 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#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;

    gradient_type
    gradient(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;

    gradient_type
    gradient(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:
  struct InterfaceData
  {
    InterfaceData(const unsigned int face_no,
                  const unsigned int sub_face_no,
                  const unsigned int face_no_neighbor,
                  const unsigned int sub_face_no_neighbor)
      : face_no(face_no)
      , sub_face_no(sub_face_no)
      , face_no_neighbor(face_no_neighbor)
      , sub_face_no_neighbor(sub_face_no_neighbor)
    {}
 
    // mandatory
    unsigned int face_no;
    unsigned int sub_face_no;
    unsigned int face_no_neighbor;
    unsigned int sub_face_no_neighbor;
 
    // optional
    unsigned int fe_index               = numbers::invalid_unsigned_int;
    unsigned int q_index                = numbers::invalid_unsigned_int;
    unsigned int mapping_index          = numbers::invalid_unsigned_int;
    unsigned int fe_index_neighbor      = numbers::invalid_unsigned_int;
    unsigned int q_index_neighbor       = numbers::invalid_unsigned_int;
    unsigned int mapping_index_neighbor = numbers::invalid_unsigned_int;
  };

  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, typename CellNeighborIteratorType>
  void
  reinit(const CellIteratorType         &cell,
         const CellNeighborIteratorType &cell_neighbor,
         const InterfaceData            &interface_data);

  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;

  DEAL_II_DEPRECATED_WITH_COMMENT("Use the function normal_vector().")
  Tensor<1, spacedim>
  normal(const unsigned int q_point_index) const;

  Tensor<1, spacedim>
  normal_vector(const unsigned int q_point_index) 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 Point<spacedim> &
  quadrature_point(const unsigned int q_point) 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;



  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;

  Tensor<1, spacedim>
  shape_grad(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<std::pair<types::global_dof_index, std::array<unsigned int, 2>>>
    interface_dof_data;

  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<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)
{
  InterfaceData data(face_no,
                     sub_face_no,
                     face_no_neighbor,
                     sub_face_no_neighbor);
  data.q_index           = q_index;
  data.mapping_index     = mapping_index;
  data.fe_index          = fe_index_in;
  data.fe_index_neighbor = fe_index_neighbor_in;
 
  reinit(cell, cell_neighbor, data);
}
 
 
 
template <int dim, int spacedim>
template <typename CellIteratorType, typename CellNeighborIteratorType>
void
FEInterfaceValues<dim, spacedim>::reinit(
  const CellIteratorType         &cell,
  const CellNeighborIteratorType &cell_neighbor,
  const InterfaceData            &interface_data)
{
  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>;
 
  const unsigned int face_no              = interface_data.face_no;
  const unsigned int sub_face_no          = interface_data.sub_face_no;
  const unsigned int face_no_neighbor     = interface_data.face_no_neighbor;
  const unsigned int sub_face_no_neighbor = interface_data.sub_face_no_neighbor;
 
  unsigned int active_fe_index          = 0;
  unsigned int active_fe_index_neighbor = 0;
 
  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)
    {
      active_fe_index = interface_data.fe_index;
      active_fe_index_neighbor =
        (interface_data.fe_index_neighbor == numbers::invalid_unsigned_int) ?
          interface_data.fe_index :
          interface_data.fe_index_neighbor;
 
      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       = interface_data.q_index;
      unsigned int used_mapping_index = interface_data.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.
      if ((used_q_index == numbers::invalid_unsigned_int) ||
          (used_mapping_index == numbers::invalid_unsigned_int))
        {
          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;
            }
        }
 
      // If q_index_neighbor is given use it, if not use the values determined
      // before
      const unsigned int used_q_index_neighbor =
        (interface_data.q_index_neighbor == numbers::invalid_unsigned_int) ?
          used_q_index :
          interface_data.q_index_neighbor;
      // Same as for q_index_neighbor
      const unsigned int used_mapping_index_neighbor =
        (interface_data.mapping_index_neighbor ==
         numbers::invalid_unsigned_int) ?
          used_mapping_index :
          interface_data.mapping_index_neighbor;
 
      // 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_neighbor,
            used_mapping_index_neighbor,
            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_neighbor,
            used_mapping_index_neighbor,
            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_1(
        fe_face_values->get_fe().n_dofs_per_cell());
      cell->get_active_or_mg_dof_indices(v_1);
      std::vector<types::global_dof_index> v_2(
        fe_face_values_neighbor->get_fe().n_dofs_per_cell());
      cell_neighbor->get_active_or_mg_dof_indices(v_2);
 
      interface_dof_data.resize(v_1.size() + v_2.size());
 
      // First create a mapping for the DoFs on the first side
      // of the interface:
      for (unsigned int i = 0; i < v_1.size(); ++i)
        interface_dof_data[i] = {v_1[i], {{i, numbers::invalid_unsigned_int}}};
 
      // Then we need to add the DoFs on the second side. We need
      // to merge this information with the mapping on the first
      // side, which if we left things as is, would result in an O(N^2)
      // complexity: For each DoF on the second side, we'd have to search
      // all of the ones on the first side. But we can reduce this to
      // O(N*log(N)) by sorting the DoFs on the first side, in which
      // case finding whether a second-side DoF already exists on the
      // first side only requires log(N) steps. So sort the information
      // we added above.
      //
      // In practice, DoF indices on many cells are already sorted
      // (because we number them in the first place in the same order
      // as we encounter them here). So guard the sorting step by a cheap
      // check for whether the data is already sorted:
      const auto compare_interface_dofs = [](const auto &interface_dof_1,
                                             const auto &interface_dof_2) {
        return (interface_dof_1.first < interface_dof_2.first);
      };
      const auto interface_dof_data_end_after_v_1 =
        interface_dof_data.begin() + v_1.size();
      if (std::is_sorted(interface_dof_data.begin(),
                         interface_dof_data_end_after_v_1,
                         compare_interface_dofs) == false)
        std::sort(interface_dof_data.begin(),
                  interface_dof_data_end_after_v_1,
                  compare_interface_dofs);
 
      // Now add the second set of DoFs:
      unsigned int idx = v_1.size();
      for (unsigned int i = 0; i < v_2.size(); ++i)
        {
          // Find out whether v2[i] is a DoF that also exists on the first side
          // of the interface. If it does, we need to record 'i' in the second
          // slot of the map. If it doesn't, record an {invalid,i} entry.
          //
          // Because we sorted the first set of interface DoFs, finding whether
          // a given v_2[i] already exists can be done via std::lower_bound(),
          // rather than requiring the much more expensive std::find().
          const auto it =
            std::lower_bound(interface_dof_data.begin(),
                             interface_dof_data_end_after_v_1,
                             v_2[i],
                             [](const auto &interface_dof_1,
                                const auto &index) {
                               return (interface_dof_1.first < index);
                             });
          if ((it != interface_dof_data_end_after_v_1) && (it->first == v_2[i]))
            {
              it->second[1] = i;
            }
          else
            {
              interface_dof_data[idx] = {v_2[i],
                                         {{numbers::invalid_unsigned_int, i}}};
              ++idx;
            }
        }
      interface_dof_data.resize(idx);
    }
  else
    // We don't have DoF indices associated with at least one of the two
    // cells. In that case, only build the mapping from the local numbering
    // on the interface to the local numbering on either side, without
    // reference to global DoF indices.
    {
      const unsigned int n_dofs_per_cell_1 = fe_face_values->dofs_per_cell;
      const unsigned int n_dofs_per_cell_2 =
        fe_face_values_neighbor->dofs_per_cell;
 
      interface_dof_data.resize(n_dofs_per_cell_1 + n_dofs_per_cell_2);
 
      for (unsigned int i = 0; i < n_dofs_per_cell_1; ++i)
        {
          interface_dof_data[i] = {numbers::invalid_dof_index,
                                   {{i, numbers::invalid_unsigned_int}}};
        }
 
      for (unsigned int i = 0; i < n_dofs_per_cell_2; ++i)
        {
          interface_dof_data[i + n_dofs_per_cell_1] = {
            numbers::invalid_dof_index, {{numbers::invalid_unsigned_int, i}}};
        }
    }
}
 
 
 
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, spacedim> &>(
        internal_hp_fe_face_values->get_present_fe_values());
      fe_face_values_neighbor = nullptr;
    }
 
  std::vector<types::global_dof_index> interface_dof_indices(
    fe_face_values->get_fe().n_dofs_per_cell());
 
  if constexpr (std::is_same_v<typename CellIteratorType::AccessorType,
                               DoFCellAccessor<dim, spacedim, true>> ||
                std::is_same_v<typename CellIteratorType::AccessorType,
                               DoFCellAccessor<dim, spacedim, false>>)
    {
      cell->get_active_or_mg_dof_indices(interface_dof_indices);
    }
  else
    {
      for (auto &i : interface_dof_indices)
        i = numbers::invalid_dof_index;
    }
 
  interface_dof_data.resize(interface_dof_indices.size());
  for (unsigned int i = 0; i < interface_dof_indices.size(); ++i)
    interface_dof_data[i] = {interface_dof_indices[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 std_cxx20::ranges::iota_view<unsigned int, unsigned int>(
    0U, n_quadrature_points);
}
 
 
 
template <int dim, int spacedim>
const Point<spacedim> &
FEInterfaceValues<dim, spacedim>::quadrature_point(
  const unsigned int q_point) const
{
  Assert(fe_face_values != nullptr,
         ExcMessage("This call requires a call to reinit() first."));
  return fe_face_values->quadrature_point(q_point);
}
 
 
 
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_data.size() > 0,
    ExcMessage(
      "n_current_interface_dofs() is only available after a call to reinit()."));
  return interface_dof_data.size();
}
 
 
 
template <int dim, int spacedim>
inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
FEInterfaceValues<dim, spacedim>::dof_indices() const
{
  return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(
    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
{
  std::vector<types::global_dof_index> interface_dof_indices(
    interface_dof_data.size());
 
  for (const unsigned int i : dof_indices())
    interface_dof_indices[i] = interface_dof_data[i].first;
 
  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 interface_dof_data[interface_dof_index].second;
}
 
 
 
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 normal_vector(q_point_index);
}
 
 
 
template <int dim, int spacedim>
Tensor<1, spacedim>
FEInterfaceValues<dim, spacedim>::normal_vector(
  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 = interface_dof_to_dof_indices(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>
Tensor<1, spacedim>
FEInterfaceValues<dim, spacedim>::shape_grad(
  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 = interface_dof_to_dof_indices(interface_dof_index);
 
  Tensor<1, dim> value;
 
  if (here_or_there && dof_pair[0] != numbers::invalid_unsigned_int)
    value = get_fe_face_values(0).shape_grad_component(dof_pair[0],
                                                       q_point,
                                                       component);
  if (!here_or_there && 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>
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 = interface_dof_to_dof_indices(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 = interface_dof_to_dof_indices(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 = interface_dof_to_dof_indices(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 = interface_dof_to_dof_indices(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 = interface_dof_to_dof_indices(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 = interface_dof_to_dof_indices(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 = interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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>::gradient_type
  Scalar<dim, spacedim>::gradient(const bool         here_or_there,
                                  const unsigned int interface_dof_index,
                                  const unsigned int q_point) const
  {
    const auto dof_pair =
      this->fe_interface->interface_dof_to_dof_indices(interface_dof_index);
 
    gradient_type value;
 
    if (here_or_there && dof_pair[0] != numbers::invalid_unsigned_int)
      return (*(this->fe_interface->fe_face_values))[extractor].gradient(
        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]
        .gradient(dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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>::gradient_type
  Vector<dim, spacedim>::gradient(const bool         here_or_there,
                                  const unsigned int interface_dof_index,
                                  const unsigned int q_point) const
  {
    const auto dof_pair =
      this->fe_interface->interface_dof_to_dof_indices(interface_dof_index);
 
    gradient_type value;
 
    if (here_or_there && dof_pair[0] != numbers::invalid_unsigned_int)
      return (*(this->fe_interface->fe_face_values))[extractor].gradient(
        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]
        .gradient(dof_pair[1], q_point);
 
    return value;
  }
 
 
 
  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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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->interface_dof_to_dof_indices(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