fe_values.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2021 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_non_matching_fe_values
#define dealii_non_matching_fe_values
 
#include <deal.II/base/bounding_box.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/std_cxx17/optional.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/fe/fe_interface_values.h>
#include <deal.II/fe/fe_update_flags.h>
#include <deal.II/fe/fe_values.h>
 
#include <deal.II/grid/tria_iterator.h>
 
#include <deal.II/hp/fe_collection.h>
#include <deal.II/hp/mapping_collection.h>
#include <deal.II/hp/q_collection.h>
 
#include <deal.II/non_matching/fe_immersed_values.h>
#include <deal.II/non_matching/mesh_classifier.h>
#include <deal.II/non_matching/quadrature_generator.h>
 
#include <deque>
 
DEAL_II_NAMESPACE_OPEN
 
namespace NonMatching
{
  struct RegionUpdateFlags
  {
    RegionUpdateFlags();
 
    UpdateFlags inside;
 
    UpdateFlags outside;
 
    UpdateFlags surface;
  };
 
 
  template <int dim>
  class FEValues
  {
  public:
    using AdditionalData = typename QuadratureGenerator<dim>::AdditionalData;
 
    template <class VectorType>
    FEValues(const hp::FECollection<dim> &fe_collection,
             const Quadrature<1> &        quadrature,
             const RegionUpdateFlags      region_update_flags,
             const MeshClassifier<dim> &  mesh_classifier,
             const DoFHandler<dim> &      dof_handler,
             const VectorType &           level_set,
             const AdditionalData &       additional_data = AdditionalData());
 
    template <class VectorType>
    FEValues(const hp::MappingCollection<dim> &mapping_collection,
             const hp::FECollection<dim> &     fe_collection,
             const hp::QCollection<dim> &      q_collection,
             const hp::QCollection<1> &        q_collection_1d,
             const RegionUpdateFlags           region_update_flags,
             const MeshClassifier<dim> &       mesh_classifier,
             const DoFHandler<dim> &           dof_handler,
             const VectorType &                level_set,
             const AdditionalData &additional_data = AdditionalData());
 
    template <bool level_dof_access>
    void
    reinit(
      const TriaIterator<DoFCellAccessor<dim, dim, level_dof_access>> &cell);
 
    const std_cxx17::optional<::FEValues<dim>> &
    get_inside_fe_values() const;
 
    const std_cxx17::optional<::FEValues<dim>> &
    get_outside_fe_values() const;
 
    const std_cxx17::optional<FEImmersedSurfaceValues<dim>> &
    get_surface_fe_values() const;
 
  private:
    void
    initialize(const hp::QCollection<dim> &q_collection);
 
    const SmartPointer<const hp::MappingCollection<dim>> mapping_collection;
 
    const SmartPointer<const hp::FECollection<dim>> fe_collection;
 
    const hp::QCollection<1> q_collection_1D;
 
    LocationToLevelSet current_cell_location;
 
    unsigned int active_fe_index;
 
    const RegionUpdateFlags region_update_flags;
 
    const SmartPointer<const MeshClassifier<dim>> mesh_classifier;
 
    std::deque<std_cxx17::optional<::FEValues<dim>>>
      fe_values_inside_full_quadrature;
 
    std::deque<std_cxx17::optional<::FEValues<dim>>>
      fe_values_outside_full_quadrature;
 
    std_cxx17::optional<::FEValues<dim>> fe_values_inside;
 
    std_cxx17::optional<::FEValues<dim>> fe_values_outside;
 
    std_cxx17::optional<NonMatching::FEImmersedSurfaceValues<dim>>
      fe_values_surface;
 
    DiscreteQuadratureGenerator<dim> quadrature_generator;
  };
 
 
 
  template <int dim>
  class FEInterfaceValues
  {
  public:
    using AdditionalData =
      typename FaceQuadratureGenerator<dim>::AdditionalData;
 
    template <class VectorType>
    FEInterfaceValues(const hp::FECollection<dim> &fe_collection,
                      const Quadrature<1> &        quadrature,
                      const RegionUpdateFlags      region_update_flags,
                      const MeshClassifier<dim> &  mesh_classifier,
                      const DoFHandler<dim> &      dof_handler,
                      const VectorType &           level_set,
                      const AdditionalData &additional_data = AdditionalData());
 
    template <class VectorType>
    FEInterfaceValues(const hp::MappingCollection<dim> &mapping_collection,
                      const hp::FECollection<dim> &     fe_collection,
                      const hp::QCollection<dim - 1> &  q_collection,
                      const hp::QCollection<1> &        q_collection_1d,
                      const RegionUpdateFlags           region_update_flags,
                      const MeshClassifier<dim> &       mesh_classifier,
                      const DoFHandler<dim> &           dof_handler,
                      const VectorType &                level_set,
                      const AdditionalData &additional_data = AdditionalData());
 
    template <class CellIteratorType, class 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);
 
 
    template <class CellIteratorType>
    void
    reinit(const CellIteratorType &cell, const unsigned int face_no);
 
    const std_cxx17::optional<::FEInterfaceValues<dim>> &
    get_inside_fe_values() const;
 
    const std_cxx17::optional<::FEInterfaceValues<dim>> &
    get_outside_fe_values() const;
 
  private:
    void
    initialize(const hp::QCollection<dim - 1> &q_collection);
 
    template <bool level_dof_access>
    void
    do_reinit(
      const TriaIterator<DoFCellAccessor<dim, dim, level_dof_access>> &cell,
      const unsigned int                                               face_no,
      const std::function<void(::FEInterfaceValues<dim> &)> &call_reinit);
 
    const SmartPointer<const hp::MappingCollection<dim>> mapping_collection;
 
    const SmartPointer<const hp::FECollection<dim>> fe_collection;
 
    const hp::QCollection<1> q_collection_1D;
 
    LocationToLevelSet current_face_location;
 
    unsigned int active_fe_index;
 
    const RegionUpdateFlags region_update_flags;
 
    const SmartPointer<const MeshClassifier<dim>> mesh_classifier;
 
    std::deque<std_cxx17::optional<::FEInterfaceValues<dim>>>
      fe_values_inside_full_quadrature;
 
    std::deque<std_cxx17::optional<::FEInterfaceValues<dim>>>
      fe_values_outside_full_quadrature;
 
    std_cxx17::optional<::FEInterfaceValues<dim>> fe_values_inside;
 
    std_cxx17::optional<::FEInterfaceValues<dim>> fe_values_outside;
 
    DiscreteFaceQuadratureGenerator<dim> face_quadrature_generator;
  };
 
 
#ifndef DOXYGEN
 
  /*---------------------- Inline functions ---------------------*/
 
  template <int dim>
  template <class CellIteratorType>
  inline void
  FEInterfaceValues<dim>::reinit(const CellIteratorType &cell,
                                 const unsigned int      face_no)
  {
    // Lambda describing how we should call reinit on a single
    // ::FEInterfaceValues object.
    const auto reinit_operation =
      [&cell, face_no](::FEInterfaceValues<dim> &fe_interface_values) {
        fe_interface_values.reinit(cell, face_no);
      };
 
    do_reinit(cell, face_no, reinit_operation);
  }
 
 
 
  template <int dim>
  template <class CellIteratorType, class CellNeighborIteratorType>
  inline void
  FEInterfaceValues<dim>::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)
  {
    Assert(sub_face_no == numbers::invalid_unsigned_int, ExcNotImplemented());
    Assert(sub_face_no_neighbor == numbers::invalid_unsigned_int,
           ExcNotImplemented());
 
    // Lambda describing how we should call reinit on a single
    // ::FEInterfaceValues object.
    const auto reinit_operation =
      [&cell,
       face_no,
       sub_face_no,
       &cell_neighbor,
       face_no_neighbor,
       sub_face_no_neighbor](
        ::FEInterfaceValues<dim> &fe_interface_values) {
        fe_interface_values.reinit(cell,
                                   face_no,
                                   sub_face_no,
                                   cell_neighbor,
                                   face_no_neighbor,
                                   sub_face_no_neighbor);
      };
 
    do_reinit(cell, face_no, reinit_operation);
  }
 
#endif
 
} // namespace NonMatching
DEAL_II_NAMESPACE_CLOSE
 
#endif