Reference documentation for deal.II version GIT edc7d5c3ce 2023-09-25 07:10:03+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
quadrature_generator.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2021 - 2023 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii_non_matching_quadrature_generator_h
17 #define dealii_non_matching_quadrature_generator_h
18 
19 #include <deal.II/base/config.h>
20 
22 #include <deal.II/base/function.h>
25 
27 
28 #include <deal.II/grid/tria.h>
29 
31 
33 
34 #include <functional>
35 #include <optional>
36 
38 namespace NonMatching
39 {
40  namespace internal
41  {
42  namespace QuadratureGeneratorImplementation
43  {
44  template <int dim, int spacedim>
45  class QGenerator;
46  } // namespace QuadratureGeneratorImplementation
47 
48 
49  namespace DiscreteQuadratureGeneratorImplementation
50  {
51  template <int dim>
52  class CellWiseFunction;
53  } // namespace DiscreteQuadratureGeneratorImplementation
54  } // namespace internal
55 
56 
61  {
65  AdditionalQGeneratorData(const unsigned int max_box_splits = 4,
66  const double lower_bound_implicit_function = 1e-11,
67  const double min_distance_between_roots = 1e-12,
68  const double limit_to_be_definite = 1e-11,
69  const double root_finder_tolerance = 1e-12,
70  const unsigned int max_root_finder_splits = 2,
71  bool split_in_half = true);
72 
77  unsigned int max_box_splits;
78 
97 
103 
112 
117 
123 
130  };
131 
132 
133 
187  template <int dim>
189  {
190  public:
192 
201  const hp::QCollection<1> &quadratures1D,
202  const AdditionalData &additional_data = AdditionalData());
203 
207  void
209 
222  void
223  generate(const Function<dim> &level_set, const BoundingBox<dim> &box);
224 
229  void
230  generate_append(const Function<dim> &level_set,
231  const BoundingBox<dim> &box);
232 
239  const Quadrature<dim> &
240  get_inside_quadrature() const;
241 
248  const Quadrature<dim> &
249  get_outside_quadrature() const;
250 
260  get_surface_quadrature() const;
261 
266  void
267  set_1D_quadrature(const unsigned int q_index);
268 
269  private:
276  };
277 
278 
305  template <int dim>
307  {
308  public:
310 
319  const hp::QCollection<1> &quadratures1D,
320  const AdditionalData &additional_data = AdditionalData());
321 
325  void
327 
340  void
341  generate(const Function<dim> &level_set,
342  const BoundingBox<dim> &box,
343  const unsigned int face_index);
344 
349  void
350  generate_append(const Function<dim> &level_set,
351  const BoundingBox<dim> &box,
352  const unsigned int face_index);
353 
360  const Quadrature<dim - 1> &
361  get_inside_quadrature() const;
362 
369  const Quadrature<dim - 1> &
370  get_outside_quadrature() const;
371 
380  const ImmersedSurfaceQuadrature<dim - 1, dim> &
381  get_surface_quadrature() const;
382 
387  void
388  set_1D_quadrature(const unsigned int q_index);
389 
390  private:
396 
402  };
403 
404 
421  template <>
423  {
424  public:
426 
432  const hp::QCollection<1> &quadratures1D,
433  const AdditionalData &additional_data = AdditionalData());
434 
438  void
440 
450  void
451  generate(const Function<1> &level_set,
452  const BoundingBox<1> &box,
453  const unsigned int face_index);
454 
459  void
460  generate_append(const Function<1> &level_set,
461  const BoundingBox<1> &box,
462  const unsigned int face_index);
463 
467  const Quadrature<0> &
468  get_inside_quadrature() const;
469 
473  const Quadrature<0> &
474  get_outside_quadrature() const;
475 
484  get_surface_quadrature() const;
485 
490  void
491  set_1D_quadrature(const unsigned int q_index);
492 
493  private:
500 
507 
514  };
515 
516 
534  template <int dim>
536  {
537  public:
539 
547  template <typename VectorType>
549  const hp::QCollection<1> &quadratures1D,
550  const DoFHandler<dim> &dof_handler,
551  const VectorType &level_set,
552  const AdditionalData &additional_data = AdditionalData());
553 
561  void
563 
564  private:
568  void
569  generate_fe_q_iso_q1(const BoundingBox<dim> &unit_box);
570 
574  std::unique_ptr<internal::DiscreteQuadratureGeneratorImplementation::
575  CellWiseFunction<dim>>
577  };
578 
596  template <int dim>
598  {
599  public:
601 
609  template <typename VectorType>
611  const hp::QCollection<1> &quadratures1D,
612  const DoFHandler<dim> &dof_handler,
613  const VectorType &level_set,
614  const AdditionalData &additional_data = AdditionalData());
615 
623  void
625  const unsigned int face_index);
626 
627  private:
631  void
632  generate_fe_q_iso_q1(const BoundingBox<dim> &unit_box,
633  unsigned int face_index);
634 
638  std::unique_ptr<internal::DiscreteQuadratureGeneratorImplementation::
639  CellWiseFunction<dim>>
641  };
642 
643 
644  namespace internal
645  {
646  namespace QuadratureGeneratorImplementation
647  {
666  {
667  public:
672  {
676  AdditionalData(const double tolerance = 1e-12,
677  const unsigned int max_recursion_depth = 2,
678  const unsigned int max_iterations = 500);
679 
684  double tolerance;
685 
690  unsigned int max_recursion_depth;
691 
696  unsigned int max_iterations;
697  };
698 
699 
703  RootFinder(const AdditionalData &data = AdditionalData());
704 
712  void
713  find_roots(const std::vector<std::reference_wrapper<const Function<1>>>
714  &functions,
715  const BoundingBox<1> &interval,
716  std::vector<double> &roots);
717 
718  private:
724  void
725  find_roots(const Function<1> &function,
726  const BoundingBox<1> &interval,
727  const unsigned int recursion_depth,
728  std::vector<double> &roots);
729 
731  };
732 
733 
746  template <int dim>
747  class ExtendableQuadrature : public Quadrature<dim>
748  {
749  public:
754  ExtendableQuadrature() = default;
755 
759  ExtendableQuadrature(const Quadrature<dim> &quadrature);
760 
764  void
765  clear();
766 
770  void
771  push_back(const Point<dim> &point, const double weight);
772  };
773 
774 
778  enum class Definiteness
779  {
780  negative,
781  positive,
782  indefinite
783  };
784 
785 
815  template <int dim>
817  {
818  public:
824  quadrature_by_definiteness(const Definiteness definiteness);
825 
829  void
830  clear();
831 
837 
843 
849 
855  };
856 
857 
896  template <int dim, int spacedim>
898  {
899  public:
906 
912  void
913  generate(const std::vector<std::reference_wrapper<const Function<dim>>>
914  &level_sets,
915  const BoundingBox<dim> &box,
916  const Quadrature<dim - 1> &low_dim_quadrature,
917  const unsigned int height_function_direction,
918  QPartitioning<dim> &q_partitioning);
919 
924  void
925  set_1D_quadrature(const unsigned int q_index);
926 
927  private:
936  void
938  const Point<dim - 1> &point,
939  const double weight,
940  const std::vector<std::reference_wrapper<const Function<dim>>>
941  &level_sets,
942  const BoundingBox<dim> &box,
943  const unsigned int height_function_direction,
944  ImmersedSurfaceQuadrature<dim> &surface_quadrature);
945 
951 
956 
961  unsigned int q_index;
962 
968 
973 
980  std::vector<double> roots;
981  };
982 
983 
1001  {
1007 
1008 
1012  unsigned int direction;
1013 
1019  };
1020 
1021 
1026  template <int dim, int spacedim>
1028  {
1029  public:
1032 
1036  void
1038 
1042  const QPartitioning<dim> &
1043  get_quadratures() const;
1044 
1045  protected:
1050 
1055  unsigned int q_index;
1056 
1062 
1067  };
1068 
1069 
1153  template <int dim, int spacedim>
1154  class QGenerator : public QGeneratorBase<dim, spacedim>
1155  {
1156  public:
1162 
1173  void
1174  generate(const std::vector<std::reference_wrapper<const Function<dim>>>
1175  &level_sets,
1176  const BoundingBox<dim> &box,
1177  const unsigned int n_box_splits);
1178 
1183  void
1184  set_1D_quadrature(const unsigned int q_index);
1185 
1186  private:
1193  void
1195  const unsigned int height_function_direction,
1196  const std::vector<std::reference_wrapper<const Function<dim>>>
1197  &level_sets,
1198  const BoundingBox<dim> &box,
1199  const unsigned int n_box_splits);
1200 
1206  void
1208  const unsigned int height_function_direction,
1209  const std::vector<std::reference_wrapper<const Function<dim>>>
1210  &level_sets,
1211  const BoundingBox<dim> &box);
1212 
1218  void
1220  const std::vector<std::reference_wrapper<const Function<dim>>>
1221  &level_sets,
1222  const BoundingBox<dim> &box,
1223  const std::optional<HeightDirectionData> &direction_data,
1224  const unsigned int n_box_splits);
1225 
1235  void
1237  const std::vector<std::reference_wrapper<const Function<dim>>>
1238  &level_sets,
1239  const BoundingBox<dim> &box);
1240 
1245  QGenerator<dim - 1, spacedim> low_dim_algorithm;
1246 
1252 
1258  };
1259 
1260 
1276  template <int spacedim>
1277  class QGenerator<1, spacedim> : public QGeneratorBase<1, spacedim>
1278  {
1279  public:
1283  QGenerator(const hp::QCollection<1> &quadratures1D,
1285 
1292  void
1293  generate(const std::vector<std::reference_wrapper<const Function<1>>>
1294  &level_sets,
1295  const BoundingBox<1> &box,
1296  const unsigned int n_box_splits);
1297 
1302  void
1303  set_1D_quadrature(const unsigned int q_index);
1304 
1305  private:
1310  void
1311  create_surface_points(
1312  const std::vector<std::reference_wrapper<const Function<1>>>
1313  &level_sets);
1314 
1319 
1323  std::vector<double> roots;
1324 
1329  const unsigned int direction = 0;
1330 
1336  const double unit_weight = 1;
1337  };
1338 
1339 
1348  template <int dim>
1349  void
1351  const double weight,
1352  const Quadrature<1> &quadrature1D,
1353  const double start,
1354  const double end,
1355  const unsigned int component_in_dim,
1356  ExtendableQuadrature<dim> &quadrature);
1357 
1358 
1365  template <int dim>
1366  Definiteness
1368  const std::vector<std::reference_wrapper<const Function<dim>>>
1369  &functions,
1370  const Point<dim> &point);
1371 
1372 
1377  template <int dim>
1379  {
1380  public:
1384  std::pair<double, double> value;
1385 
1389  std::array<std::pair<double, double>, dim> gradient;
1390  };
1391 
1392 
1400  template <int dim>
1401  std::pair<double, double>
1403  const std::vector<FunctionBounds<dim>> &all_function_bounds);
1404 
1405 
1438  template <int dim>
1439  std::optional<HeightDirectionData>
1441  const std::vector<FunctionBounds<dim>> &all_function_bounds);
1442 
1443  } // namespace QuadratureGeneratorImplementation
1444 
1445 
1446  namespace DiscreteQuadratureGeneratorImplementation
1447  {
1453  template <int dim>
1454  class CellWiseFunction : public Function<dim>
1455  {
1456  public:
1460  virtual ~CellWiseFunction() = default;
1461 
1465  virtual void
1467  const typename Triangulation<dim>::active_cell_iterator &cell) = 0;
1468 
1473  virtual void
1474  set_subcell(const std::vector<unsigned int> &mask,
1475  const BoundingBox<dim> &subcell_box) = 0;
1476 
1480  virtual bool
1481  is_fe_q_iso_q1() const = 0;
1482 
1486  virtual unsigned int
1487  n_subdivisions() const = 0;
1488  };
1489 
1490  } // namespace DiscreteQuadratureGeneratorImplementation
1491  } // namespace internal
1492 
1493 } // namespace NonMatching
1495 
1496 #endif /* dealii_non_matching_quadrature_generator_h */
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)
std::unique_ptr< internal::DiscreteQuadratureGeneratorImplementation::CellWiseFunction< dim > > reference_space_level_set
void generate_fe_q_iso_q1(const BoundingBox< dim > &unit_box, unsigned int face_index)
void generate(const typename Triangulation< dim >::active_cell_iterator &cell)
std::unique_ptr< internal::DiscreteQuadratureGeneratorImplementation::CellWiseFunction< dim > > reference_space_level_set
void generate_fe_q_iso_q1(const BoundingBox< dim > &unit_box)
DiscreteQuadratureGenerator(const hp::QCollection< 1 > &quadratures1D, const DoFHandler< dim > &dof_handler, const VectorType &level_set, const AdditionalData &additional_data=AdditionalData())
const ImmersedSurfaceQuadrature< 0, 1 > surface_quadrature
const Quadrature< dim - 1 > & get_inside_quadrature() const
void generate(const Function< dim > &level_set, const BoundingBox< dim > &box, const unsigned int face_index)
ImmersedSurfaceQuadrature< dim - 1, dim > surface_quadrature
void set_1D_quadrature(const unsigned int q_index)
void generate_append(const Function< dim > &level_set, const BoundingBox< dim > &box, const unsigned int face_index)
FaceQuadratureGenerator(const hp::QCollection< 1 > &quadratures1D, const AdditionalData &additional_data=AdditionalData())
const ImmersedSurfaceQuadrature< dim - 1, dim > & get_surface_quadrature() const
QuadratureGenerator< dim - 1 > quadrature_generator
const Quadrature< dim - 1 > & get_outside_quadrature() const
void generate_append(const Function< dim > &level_set, const BoundingBox< dim > &box)
void set_1D_quadrature(const unsigned int q_index)
AdditionalQGeneratorData AdditionalData
QuadratureGenerator(const hp::QCollection< 1 > &quadratures1D, const AdditionalData &additional_data=AdditionalData())
const Quadrature< dim > & get_inside_quadrature() const
const Quadrature< dim > & get_outside_quadrature() const
internal::QuadratureGeneratorImplementation::QGenerator< dim, dim > q_generator
const ImmersedSurfaceQuadrature< dim > & get_surface_quadrature() const
void generate(const Function< dim > &level_set, const BoundingBox< dim > &box)
virtual void set_subcell(const std::vector< unsigned int > &mask, const BoundingBox< dim > &subcell_box)=0
virtual void set_active_cell(const typename Triangulation< dim >::active_cell_iterator &cell)=0
QGeneratorBase(const hp::QCollection< 1 > &q_collection1D, const AdditionalQGeneratorData &additional_data)
void split_box_and_recurse(const std::vector< std::reference_wrapper< const Function< dim >>> &level_sets, const BoundingBox< dim > &box, const std::optional< HeightDirectionData > &direction_data, const unsigned int n_box_splits)
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 use_midpoint_method(const std::vector< std::reference_wrapper< const Function< dim >>> &level_sets, const BoundingBox< dim > &box)
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 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)
ExtendableQuadrature< dim > & quadrature_by_definiteness(const Definiteness definiteness)
void find_roots(const std::vector< std::reference_wrapper< const Function< 1 >>> &functions, const BoundingBox< 1 > &interval, std::vector< double > &roots)
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)
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)
UpThroughDimensionCreator(const hp::QCollection< 1 > &q_collection1D, const AdditionalQGeneratorData &additional_data)
Definition: point.h:112
double weight(const unsigned int i) const
const Point< dim > & point(const unsigned int i) const
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:477
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:478
std::optional< HeightDirectionData > find_best_height_direction(const std::vector< FunctionBounds< dim >> &all_function_bounds)
std::pair< double, double > find_extreme_values(const std::vector< FunctionBounds< dim >> &all_function_bounds)
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)
Definiteness pointwise_definiteness(const std::vector< std::reference_wrapper< const Function< dim >>> &functions, const Point< dim > &point)
Point< spacedim > point(const gp_Pnt &p, const double tolerance=1e-10)
Definition: utilities.cc:192
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
VectorType::value_type * end(VectorType &V)
int(&) functions(const void *v1, const void *v2)
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)
AdditionalData(const double tolerance=1e-12, const unsigned int max_recursion_depth=2, const unsigned int max_iterations=500)