q_collection.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2005 - 2021 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_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);
 
  private:
    std::vector<std::shared_ptr<const Quadrature<dim>>> quadratures;
  };
 
 
 
  /* --------------- 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
      {
        Assert(false, ExcNotImplemented());
      }
  }
 
 
 
  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