q_collection.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2005 - 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_q_collection_h
#define dealii_q_collection_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/base/subscriptor.h>
 
#include <deal.II/hp/collection.h>
 
#include <memory>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
namespace hp
{
  template <int dim>
  class QCollection : public Collection<Quadrature<dim>>
  {
  public:
    QCollection() = default;
 
    template <int dim_in>
    QCollection(const QCollection<dim_in> &other);
 
    template <int dim_in>
    explicit QCollection(const Quadrature<dim_in> &quadrature);
 
    template <class... QTypes>
    explicit QCollection(const QTypes &...quadrature_objects);
 
    template <int dim_in>
    void
    push_back(const Quadrature<dim_in> &new_quadrature);
 
    bool
    operator==(const QCollection<dim> &q_collection) const;
 
    unsigned int
    max_n_quadrature_points() const;
 
    DeclException0(ExcNoQuadrature);
  };
 
 
 
  /* --------------- inline functions ------------------- */
 
  template <int dim>
  template <int dim_in>
  QCollection<dim>::QCollection(const QCollection<dim_in> &other)
  {
    for (unsigned int i = 0; i < other.size(); ++i)
      push_back(other[i]);
  }
 
 
 
  template <int dim>
  template <class... QTypes>
  QCollection<dim>::QCollection(const QTypes &...quadrature_objects)
  {
    // loop over all of the given arguments and add the quadrature objects to
    // this collection. Inlining the definition of q_pointers causes internal
    // compiler errors on GCC 7.1.1 so we define it separately:
    if (is_base_of_all<Quadrature<dim>, QTypes...>::value)
      {
        const auto q_pointers = {
          (reinterpret_cast<const Quadrature<dim> *>(&quadrature_objects))...};
        for (const auto p : q_pointers)
          push_back(*p);
      }
    else if (is_base_of_all<Quadrature<1>, QTypes...>::value)
      {
        const auto q_pointers = {
          (reinterpret_cast<const Quadrature<1> *>(&quadrature_objects))...};
        for (const auto p : q_pointers)
          push_back(*p);
      }
    else
      {
        DEAL_II_NOT_IMPLEMENTED();
      }
  }
 
 
 
  template <int dim>
  inline unsigned int
  QCollection<dim>::max_n_quadrature_points() const
  {
    Assert(this->size() > 0,
           ExcMessage("You can't call this function for an empty collection"));
 
    unsigned int max = 0;
    for (unsigned int i = 0; i < this->size(); ++i)
      max = std::max(max, this->operator[](i).size());
 
    return max;
  }
 
 
 
  template <int dim>
  inline bool
  QCollection<dim>::operator==(const QCollection<dim> &q_collection) const
  {
    const unsigned int n_quadratures = this->size();
    if (n_quadratures != q_collection.size())
      return false;
 
    for (unsigned int i = 0; i < n_quadratures; ++i)
      if ((this->operator[](i) == q_collection[i]) == false)
        return false;
 
    return true;
  }
 
 
 
  template <int dim>
  template <int dim_in>
  inline QCollection<dim>::QCollection(const Quadrature<dim_in> &quadrature)
  {
    this->push_back(quadrature);
  }
 
 
  template <int dim>
  template <int dim_in>
  inline void
  QCollection<dim>::push_back(const Quadrature<dim_in> &new_quadrature)
  {
    Collection<Quadrature<dim>>::push_back(
      std::make_shared<const Quadrature<dim>>(new_quadrature));
  }
 
} // namespace hp
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif