quadrature_generator.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2021 - 2022 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_quadrature_generator_h
#define dealii_non_matching_quadrature_generator_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/bounding_box.h>
#include <deal.II/base/function.h>
#include <deal.II/base/function_restriction.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/base/std_cxx17/optional.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/grid/tria.h>
 
#include <deal.II/hp/q_collection.h>
 
#include <deal.II/non_matching/immersed_surface_quadrature.h>
 
#include <functional>
 
DEAL_II_NAMESPACE_OPEN
namespace NonMatching
{
  namespace internal
  {
    namespace QuadratureGeneratorImplementation
    {
      template <int dim, int spacedim>
      class QGenerator;
    } // namespace QuadratureGeneratorImplementation
 
 
    namespace DiscreteQuadratureGeneratorImplementation
    {
      template <int dim>
      class CellWiseFunction;
    } // namespace DiscreteQuadratureGeneratorImplementation
  }   // namespace internal
 
 
  struct AdditionalQGeneratorData
  {
    AdditionalQGeneratorData(const unsigned int max_box_splits          = 4,
                             const double lower_bound_implicit_function = 1e-11,
                             const double min_distance_between_roots    = 1e-12,
                             const double limit_to_be_definite          = 1e-11,
                             const double root_finder_tolerance         = 1e-12,
                             const unsigned int max_root_finder_splits  = 2,
                             bool               split_in_half           = true);
 
    unsigned int max_box_splits;
 
    double lower_bound_implicit_function;
 
    double min_distance_between_roots;
 
    double limit_to_be_definite;
 
    double root_finder_tolerance;
 
    unsigned int max_root_finder_splits;
 
    bool split_in_half;
  };
 
 
 
  template <int dim>
  class QuadratureGenerator
  {
  public:
    using AdditionalData = AdditionalQGeneratorData;
 
    QuadratureGenerator(
      const hp::QCollection<1> &quadratures1D,
      const AdditionalData &    additional_data = AdditionalData());
 
    void
    generate(const Function<dim> &level_set, const BoundingBox<dim> &box);
 
    const Quadrature<dim> &
    get_inside_quadrature() const;
 
    const Quadrature<dim> &
    get_outside_quadrature() const;
 
    const ImmersedSurfaceQuadrature<dim> &
    get_surface_quadrature() const;
 
    void
    set_1D_quadrature(const unsigned int q_index);
 
  private:
    internal::QuadratureGeneratorImplementation::QGenerator<dim, dim>
      q_generator;
  };
 
 
  template <int dim>
  class FaceQuadratureGenerator
  {
  public:
    using AdditionalData = AdditionalQGeneratorData;
 
    FaceQuadratureGenerator(
      const hp::QCollection<1> &quadratures1D,
      const AdditionalData &    additional_data = AdditionalData());
 
    void
    generate(const Function<dim> &   level_set,
             const BoundingBox<dim> &box,
             const unsigned int      face_index);
 
    const Quadrature<dim - 1> &
    get_inside_quadrature() const;
 
    const Quadrature<dim - 1> &
    get_outside_quadrature() const;
 
    const ImmersedSurfaceQuadrature<dim - 1, dim> &
    get_surface_quadrature() const;
 
    void
    set_1D_quadrature(const unsigned int q_index);
 
  private:
    QuadratureGenerator<dim - 1> quadrature_generator;
 
    ImmersedSurfaceQuadrature<dim - 1, dim> surface_quadrature;
  };
 
 
  template <>
  class FaceQuadratureGenerator<1>
  {
  public:
    using AdditionalData = AdditionalQGeneratorData;
 
    FaceQuadratureGenerator(
      const hp::QCollection<1> &quadratures1D,
      const AdditionalData &    additional_data = AdditionalData());
 
    void
    generate(const Function<1> &   level_set,
             const BoundingBox<1> &box,
             const unsigned int    face_index);
 
    const Quadrature<0> &
    get_inside_quadrature() const;
 
    const Quadrature<0> &
    get_outside_quadrature() const;
 
    const ImmersedSurfaceQuadrature<0, 1> &
    get_surface_quadrature() const;
 
    void
    set_1D_quadrature(const unsigned int q_index);
 
  private:
    Quadrature<0> inside_quadrature;
 
    Quadrature<0> outside_quadrature;
 
    const ImmersedSurfaceQuadrature<0, 1> surface_quadrature;
  };
 
 
  template <int dim>
  class DiscreteQuadratureGenerator : public QuadratureGenerator<dim>
  {
  public:
    using AdditionalData = AdditionalQGeneratorData;
 
    template <class VectorType>
    DiscreteQuadratureGenerator(
      const hp::QCollection<1> &quadratures1D,
      const DoFHandler<dim> &   dof_handler,
      const VectorType &        level_set,
      const AdditionalData &    additional_data = AdditionalData());
 
    void
    generate(const typename Triangulation<dim>::active_cell_iterator &cell);
 
  private:
    std::unique_ptr<internal::DiscreteQuadratureGeneratorImplementation::
                      CellWiseFunction<dim>>
      reference_space_level_set;
  };
 
  template <int dim>
  class DiscreteFaceQuadratureGenerator : public FaceQuadratureGenerator<dim>
  {
  public:
    using AdditionalData = AdditionalQGeneratorData;
 
    template <class VectorType>
    DiscreteFaceQuadratureGenerator(
      const hp::QCollection<1> &quadratures1D,
      const DoFHandler<dim> &   dof_handler,
      const VectorType &        level_set,
      const AdditionalData &    additional_data = AdditionalData());
 
    void
    generate(const typename Triangulation<dim>::active_cell_iterator &cell,
             const unsigned int face_index);
 
  private:
    std::unique_ptr<internal::DiscreteQuadratureGeneratorImplementation::
                      CellWiseFunction<dim>>
      reference_space_level_set;
  };
 
 
  namespace internal
  {
    namespace QuadratureGeneratorImplementation
    {
      class RootFinder
      {
      public:
        struct AdditionalData
        {
          AdditionalData(const double       tolerance           = 1e-12,
                         const unsigned int max_recursion_depth = 2,
                         const unsigned int max_iterations      = 500);
 
          double tolerance;
 
          unsigned int max_recursion_depth;
 
          unsigned int max_iterations;
        };
 
 
        RootFinder(const AdditionalData &data = AdditionalData());
 
        void
        find_roots(const std::vector<std::reference_wrapper<const Function<1>>>
                     &                   functions,
                   const BoundingBox<1> &interval,
                   std::vector<double> & roots);
 
      private:
        void
        find_roots(const Function<1> &   function,
                   const BoundingBox<1> &interval,
                   const unsigned int    recursion_depth,
                   std::vector<double> & roots);
 
        const AdditionalData additional_data;
      };
 
 
      template <int dim>
      class ExtendableQuadrature : public Quadrature<dim>
      {
      public:
        ExtendableQuadrature() = default;
 
        ExtendableQuadrature(const Quadrature<dim> &quadrature);
 
        void
        push_back(const Point<dim> &point, const double weight);
      };
 
 
      enum class Definiteness
      {
        negative,
        positive,
        indefinite
      };
 
 
      template <int dim>
      class QPartitioning
      {
      public:
        ExtendableQuadrature<dim> &
        quadrature_by_definiteness(const Definiteness definiteness);
 
        ExtendableQuadrature<dim> negative;
 
        ExtendableQuadrature<dim> positive;
 
        ExtendableQuadrature<dim> indefinite;
 
        ImmersedSurfaceQuadrature<dim> surface;
      };
 
 
      template <int dim, int spacedim>
      class UpThroughDimensionCreator
      {
      public:
        UpThroughDimensionCreator(
          const hp::QCollection<1> &      q_collection1D,
          const AdditionalQGeneratorData &additional_data);
 
        void
        generate(const std::vector<std::reference_wrapper<const Function<dim>>>
                   &                        level_sets,
                 const BoundingBox<dim> &   box,
                 const Quadrature<dim - 1> &low_dim_quadrature,
                 const unsigned int         height_function_direction,
                 QPartitioning<dim> &       q_partitioning);
 
        void
        set_1D_quadrature(const unsigned int q_index);
 
      private:
        void
        create_surface_point(
          const Point<dim - 1> &point,
          const double          weight,
          const std::vector<std::reference_wrapper<const Function<dim>>>
            &                             level_sets,
          const BoundingBox<dim> &        box,
          const unsigned int              height_function_direction,
          ImmersedSurfaceQuadrature<dim> &surface_quadrature);
 
        const SmartPointer<const hp::QCollection<1>> q_collection1D;
 
        const AdditionalQGeneratorData additional_data;
 
        unsigned int q_index;
 
        std::vector<Functions::PointRestriction<dim - 1>> point_restrictions;
 
        RootFinder root_finder;
 
        std::vector<double> roots;
      };
 
 
      struct HeightDirectionData
      {
        HeightDirectionData();
 
 
        unsigned int direction;
 
        double min_abs_dfdx;
      };
 
 
      template <int dim, int spacedim>
      class QGeneratorBase
      {
      public:
        QGeneratorBase(const hp::QCollection<1> &      q_collection1D,
                       const AdditionalQGeneratorData &additional_data);
 
        void
        clear_quadratures();
 
        const QPartitioning<dim> &
        get_quadratures() const;
 
      protected:
        const AdditionalQGeneratorData additional_data;
 
        unsigned int q_index;
 
        const SmartPointer<const hp::QCollection<1>> q_collection1D;
 
        QPartitioning<dim> q_partitioning;
      };
 
 
      template <int dim, int spacedim>
      class QGenerator : public QGeneratorBase<dim, spacedim>
      {
      public:
        QGenerator(const hp::QCollection<1> &      q_collection1D,
                   const AdditionalQGeneratorData &additional_data);
 
        void
        generate(const std::vector<std::reference_wrapper<const Function<dim>>>
                   &                     level_sets,
                 const BoundingBox<dim> &box,
                 const unsigned int      n_box_splits);
 
        void
        set_1D_quadrature(const unsigned int q_index);
 
      private:
        void
        create_low_dim_quadratures(
          const unsigned int height_function_direction,
          const std::vector<std::reference_wrapper<const Function<dim>>>
            &                     level_sets,
          const BoundingBox<dim> &box,
          const unsigned int      n_box_splits);
 
        void
        create_high_dim_quadratures(
          const unsigned int height_function_direction,
          const std::vector<std::reference_wrapper<const Function<dim>>>
            &                     level_sets,
          const BoundingBox<dim> &box);
 
        void
        split_box_and_recurse(
          const std::vector<std::reference_wrapper<const Function<dim>>>
            &                                             level_sets,
          const BoundingBox<dim> &                        box,
          const std_cxx17::optional<HeightDirectionData> &direction_data,
          const unsigned int                              n_box_splits);
 
        void
        use_midpoint_method(
          const std::vector<std::reference_wrapper<const Function<dim>>>
            &                     level_sets,
          const BoundingBox<dim> &box);
 
        QGenerator<dim - 1, spacedim> low_dim_algorithm;
 
        UpThroughDimensionCreator<dim, spacedim> up_through_dimension_creator;
 
        hp::QCollection<dim> tensor_products;
      };
 
 
      template <int spacedim>
      class QGenerator<1, spacedim> : public QGeneratorBase<1, spacedim>
      {
      public:
        QGenerator(const hp::QCollection<1> &      quadratures1D,
                   const AdditionalQGeneratorData &additional_data);
 
        void
        generate(const std::vector<std::reference_wrapper<const Function<1>>>
                   &                   level_sets,
                 const BoundingBox<1> &box,
                 const unsigned int    n_box_splits);
 
        void
        set_1D_quadrature(const unsigned int q_index);
 
      private:
        void
        create_surface_points(
          const std::vector<std::reference_wrapper<const Function<1>>>
            &level_sets);
 
        RootFinder root_finder;
 
        std::vector<double> roots;
 
        const unsigned int direction = 0;
 
        const Point<0> zero_dim_point;
        const double   unit_weight = 1;
      };
 
 
      template <int dim>
      void
      tensor_point_with_1D_quadrature(const Point<dim - 1> &point,
                                      const double          weight,
                                      const Quadrature<1> & quadrature1D,
                                      const double          start,
                                      const double          end,
                                      const unsigned int    component_in_dim,
                                      ExtendableQuadrature<dim> &quadrature);
 
 
      template <int dim>
      Definiteness
      pointwise_definiteness(
        const std::vector<std::reference_wrapper<const Function<dim>>>
          &               functions,
        const Point<dim> &point);
 
 
      template <int dim>
      struct FunctionBounds
      {
      public:
        std::pair<double, double> value;
 
        std::array<std::pair<double, double>, dim> gradient;
      };
 
 
      template <int dim>
      std::pair<double, double>
      find_extreme_values(
        const std::vector<FunctionBounds<dim>> &all_function_bounds);
 
 
      template <int dim>
      std_cxx17::optional<HeightDirectionData>
      find_best_height_direction(
        const std::vector<FunctionBounds<dim>> &all_function_bounds);
 
    } // namespace QuadratureGeneratorImplementation
 
 
    namespace DiscreteQuadratureGeneratorImplementation
    {
      template <int dim>
      class CellWiseFunction : public Function<dim>
      {
      public:
        virtual ~CellWiseFunction() = default;
 
        virtual void
        set_active_cell(
          const typename Triangulation<dim>::active_cell_iterator &cell) = 0;
      };
 
    } // namespace DiscreteQuadratureGeneratorImplementation
  }   // namespace internal
 
} // namespace NonMatching
DEAL_II_NAMESPACE_CLOSE
 
#endif /* dealii_non_matching_quadrature_generator_h */