quadrature.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 1998 - 2024 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_quadrature_h
#define dealii_quadrature_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/array_view.h>
#include <deal.II/base/enable_observer_pointer.h>
#include <deal.II/base/point.h>
 
#include <array>
#include <memory>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
template <int dim>
class Quadrature : public EnableObserverPointer
{
public:
  using SubQuadrature = Quadrature<dim == 0 ? 0 : dim - 1>;
 
  Quadrature();
 
  Quadrature(const SubQuadrature &, const Quadrature<1> &);
 
  explicit Quadrature(const Quadrature<dim != 1 ? 1 : 0> &quadrature_1d);
 
  Quadrature(const Quadrature<dim> &q);
 
  Quadrature(Quadrature<dim> &&) noexcept = default;
 
  Quadrature(const std::vector<Point<dim>> &points,
             const std::vector<double>     &weights);
 
  Quadrature(std::vector<Point<dim>> &&points, std::vector<double> &&weights);
 
  Quadrature(const std::vector<Point<dim>> &points);
 
  Quadrature(const Point<dim> &point);
 
  virtual ~Quadrature() override = default;
 
  Quadrature &
  operator=(const Quadrature<dim> &);
 
  Quadrature &
  operator=(Quadrature<dim> &&) = default; // NOLINT
 
  bool
  operator==(const Quadrature<dim> &p) const;
 
  void
  initialize(const ArrayView<const Point<dim>> &points,
             const ArrayView<const double>     &weights = {});
 
  unsigned int
  size() const;
 
  bool
  empty() const;
 
  const Point<dim> &
  point(const unsigned int i) const;
 
  const std::vector<Point<dim>> &
  get_points() const;
 
  double
  weight(const unsigned int i) const;
 
  const std::vector<double> &
  get_weights() const;
 
  std::size_t
  memory_consumption() const;
 
  template <class Archive>
  void
  serialize(Archive &ar, const unsigned int version);
 
  bool
  is_tensor_product() const;
 
#ifndef DOXYGEN
  std::conditional_t<dim == 1,
                     std::array<Quadrature<1>, dim>,
                     const std::array<Quadrature<1>, dim> &>
#else
  const std::array<Quadrature<1>, dim> &
#endif
  get_tensor_basis() const;
 
protected:
  explicit Quadrature(const unsigned int n_quadrature_points);
 
  std::vector<Point<dim>> quadrature_points;
 
  std::vector<double> weights;
 
  bool is_tensor_product_flag;
 
  std::unique_ptr<std::array<Quadrature<1>, dim>> tensor_basis;
};
 
 
template <int dim>
class QAnisotropic : public Quadrature<dim>
{
public:
  QAnisotropic(const Quadrature<1> &qx);
 
  QAnisotropic(const Quadrature<1> &qx, const Quadrature<1> &qy);
 
  QAnisotropic(const Quadrature<1> &qx,
               const Quadrature<1> &qy,
               const Quadrature<1> &qz);
};
 
 
template <int dim>
class QIterated : public Quadrature<dim>
{
public:
  QIterated(const Quadrature<1> &base_quadrature, const unsigned int n_copies);
 
  QIterated(const Quadrature<1>         &base_quadrature,
            const std::vector<Point<1>> &intervals);
 
  DeclExceptionMsg(ExcInvalidQuadratureFormula,
                   "The quadrature formula you provided cannot be used "
                   "as the basis for iteration.");
};
 
 
 
#ifndef DOXYGEN
 
// -------------------  inline and template functions ----------------
 
 
template <int dim>
inline unsigned int
Quadrature<dim>::size() const
{
  return weights.size();
}
 
 
 
template <int dim>
inline bool
Quadrature<dim>::empty() const
{
  return weights.empty();
}
 
 
 
template <int dim>
inline const Point<dim> &
Quadrature<dim>::point(const unsigned int i) const
{
  AssertIndexRange(i, size());
  return quadrature_points[i];
}
 
 
 
template <int dim>
double
Quadrature<dim>::weight(const unsigned int i) const
{
  AssertIndexRange(i, size());
  return weights[i];
}
 
 
 
template <int dim>
inline const std::vector<Point<dim>> &
Quadrature<dim>::get_points() const
{
  return quadrature_points;
}
 
 
 
template <int dim>
inline const std::vector<double> &
Quadrature<dim>::get_weights() const
{
  return weights;
}
 
 
 
template <int dim>
inline bool
Quadrature<dim>::is_tensor_product() const
{
  return is_tensor_product_flag;
}
 
 
 
template <int dim>
template <class Archive>
inline void
Quadrature<dim>::serialize(Archive &ar, const unsigned int)
{
  // forward to serialization
  // function in the base class.
  ar &static_cast<EnableObserverPointer &>(*this);
 
  ar &quadrature_points &weights;
}
 
 
 
/* -------------- declaration of explicit specializations ------------- */
 
template <>
Quadrature<0>::Quadrature(const unsigned int);
template <>
Quadrature<0>::Quadrature(const Quadrature<0>::SubQuadrature &,
                          const Quadrature<1> &);
template <>
Quadrature<0>::Quadrature(const Quadrature<1> &);
template <>
Quadrature<0>::Quadrature(const Point<0> &);
 
template <>
Quadrature<1>::Quadrature(const Quadrature<0> &, const Quadrature<1> &);
 
template <>
Quadrature<1>::Quadrature(const Quadrature<0> &);
 
template <>
QIterated<1>::QIterated(const Quadrature<1> &base_quadrature,
                        const unsigned int   n_copies);
 
#endif // DOXYGEN
DEAL_II_NAMESPACE_CLOSE
 
#endif