Reference documentation for deal.II version GIT relicensing-468-ge3ce94fd06 2024-04-23 15:40:02+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\}}\)
Loading...
Searching...
No Matches
quadrature.h
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 1998 - 2023 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15#ifndef dealii_quadrature_h
16#define dealii_quadrature_h
17
18
19#include <deal.II/base/config.h>
20
22#include <deal.II/base/point.h>
24
25#include <array>
26#include <memory>
27#include <vector>
28
30
121template <int dim>
123{
124public:
130 using SubQuadrature = Quadrature<dim == 0 ? 0 : dim - 1>;
131
140 explicit Quadrature(const unsigned int n_quadrature_points = 0);
141
150 Quadrature(const SubQuadrature &, const Quadrature<1> &);
151
171 explicit Quadrature(const Quadrature<dim != 1 ? 1 : 0> &quadrature_1d);
172
176 Quadrature(const Quadrature<dim> &q);
177
182 Quadrature(Quadrature<dim> &&) noexcept = default;
183
189 Quadrature(const std::vector<Point<dim>> &points,
190 const std::vector<double> &weights);
191
197 Quadrature(std::vector<Point<dim>> &&points, std::vector<double> &&weights);
198
206 Quadrature(const std::vector<Point<dim>> &points);
207
212 Quadrature(const Point<dim> &point);
213
217 virtual ~Quadrature() override = default;
218
223 Quadrature &
224 operator=(const Quadrature<dim> &);
225
230 Quadrature &
231 operator=(Quadrature<dim> &&) = default; // NOLINT
232
236 bool
237 operator==(const Quadrature<dim> &p) const;
238
247 void
248 initialize(const ArrayView<const Point<dim>> &points,
249 const ArrayView<const double> &weights = {});
250
254 unsigned int
255 size() const;
256
260 bool
261 empty() const;
262
266 const Point<dim> &
267 point(const unsigned int i) const;
268
272 const std::vector<Point<dim>> &
273 get_points() const;
274
278 double
279 weight(const unsigned int i) const;
280
284 const std::vector<double> &
285 get_weights() const;
286
291 std::size_t
292 memory_consumption() const;
293
299 template <class Archive>
300 void
301 serialize(Archive &ar, const unsigned int version);
302
308 bool
310
329#ifndef DOXYGEN
330 std::conditional_t<dim == 1,
331 std::array<Quadrature<1>, dim>,
332 const std::array<Quadrature<1>, dim> &>
333#else
334 const std::array<Quadrature<1>, dim> &
335#endif
336 get_tensor_basis() const;
337
338protected:
343 std::vector<Point<dim>> quadrature_points;
344
349 std::vector<double> weights;
350
359
364 std::unique_ptr<std::array<Quadrature<1>, dim>> tensor_basis;
365};
366
367
376template <int dim>
377class QAnisotropic : public Quadrature<dim>
378{
379public:
384 QAnisotropic(const Quadrature<1> &qx);
385
389 QAnisotropic(const Quadrature<1> &qx, const Quadrature<1> &qy);
390
394 QAnisotropic(const Quadrature<1> &qx,
395 const Quadrature<1> &qy,
396 const Quadrature<1> &qz);
397};
398
399
423template <int dim>
424class QIterated : public Quadrature<dim>
425{
426public:
433 QIterated(const Quadrature<1> &base_quadrature, const unsigned int n_copies);
434
446 QIterated(const Quadrature<1> &base_quadrature,
447 const std::vector<Point<1>> &intervals);
448
453 "The quadrature formula you provided cannot be used "
454 "as the basis for iteration.");
455};
456
457
458
461#ifndef DOXYGEN
462
463// ------------------- inline and template functions ----------------
464
465
466template <int dim>
467inline unsigned int
469{
470 return weights.size();
471}
472
473
474
475template <int dim>
476inline bool
478{
479 return weights.empty();
480}
481
482
483
484template <int dim>
485inline const Point<dim> &
486Quadrature<dim>::point(const unsigned int i) const
487{
488 AssertIndexRange(i, size());
489 return quadrature_points[i];
490}
491
492
493
494template <int dim>
495double
496Quadrature<dim>::weight(const unsigned int i) const
497{
498 AssertIndexRange(i, size());
499 return weights[i];
500}
501
502
503
504template <int dim>
505inline const std::vector<Point<dim>> &
507{
508 return quadrature_points;
509}
510
511
512
513template <int dim>
514inline const std::vector<double> &
516{
517 return weights;
518}
519
520
521
522template <int dim>
523inline bool
525{
526 return is_tensor_product_flag;
527}
528
529
530
531template <int dim>
532template <class Archive>
533inline void
534Quadrature<dim>::serialize(Archive &ar, const unsigned int)
535{
536 // forward to serialization
537 // function in the base class.
538 ar &static_cast<Subscriptor &>(*this);
539
540 ar &quadrature_points &weights;
541}
542
543
544
545/* -------------- declaration of explicit specializations ------------- */
546
547template <>
548Quadrature<0>::Quadrature(const unsigned int);
549template <>
551 const Quadrature<1> &);
552template <>
554template <>
556
557template <>
559
560template <>
562
563template <>
564QIterated<1>::QIterated(const Quadrature<1> &base_quadrature,
565 const unsigned int n_copies);
566
567#endif // DOXYGEN
569
570#endif
Definition point.h:111
QIterated(const Quadrature< 1 > &base_quadrature, const unsigned int n_copies)
std::vector< Point< dim > > quadrature_points
Definition quadrature.h:343
void initialize(const ArrayView< const Point< dim > > &points, const ArrayView< const double > &weights={})
Definition quadrature.cc:51
std::unique_ptr< std::array< Quadrature< 1 >, dim > > tensor_basis
Definition quadrature.h:364
bool is_tensor_product() const
std::size_t memory_consumption() const
const Point< dim > & point(const unsigned int i) const
bool is_tensor_product_flag
Definition quadrature.h:358
Quadrature(const unsigned int n_quadrature_points=0)
Definition quadrature.cc:41
double weight(const unsigned int i) const
const std::vector< double > & get_weights() const
const std::array< Quadrature< 1 >, dim > & get_tensor_basis() const
Quadrature(Quadrature< dim > &&) noexcept=default
std::vector< double > weights
Definition quadrature.h:349
const std::vector< Point< dim > > & get_points() const
bool empty() const
unsigned int size() const
void serialize(Archive &ar, const unsigned int version)
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:502
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:503
static ::ExceptionBase & ExcInvalidQuadratureFormula()
#define AssertIndexRange(index, range)
#define DeclExceptionMsg(Exception, defaulttext)
Definition exceptions.h:494
void quadrature_points(const Triangulation< dim, spacedim > &triangulation, const Quadrature< dim > &quadrature, const std::vector< std::vector< BoundingBox< spacedim > > > &global_bounding_boxes, ParticleHandler< dim, spacedim > &particle_handler, const Mapping< dim, spacedim > &mapping=(ReferenceCells::get_hypercube< dim >() .template get_default_linear_mapping< dim, spacedim >()), const std::vector< std::vector< double > > &properties={})
STL namespace.