q_collection.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2005 - 2020 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/fe/fe.h>
 
#include <memory>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
namespace hp
{
  template <int dim>
  class QCollection : public Subscriptor
  {
  public:
    QCollection() = default;
 
    explicit QCollection(const Quadrature<dim> &quadrature);
 
    template <class... QTypes>
    explicit QCollection(const QTypes &... quadrature_objects);
 
    void
    push_back(const Quadrature<dim> &new_quadrature);
 
    const Quadrature<dim> &operator[](const unsigned int index) const;
 
    bool
    operator==(const QCollection<dim> &q_collection) const;
 
    unsigned int
    size() const;
 
    unsigned int
    max_n_quadrature_points() const;
 
    std::size_t
    memory_consumption() const;
 
    DeclException0(ExcNoQuadrature);
 
  private:
    std::vector<std::shared_ptr<const Quadrature<dim>>> quadratures;
  };
 
 
 
  /* --------------- inline functions ------------------- */
 
  template <int dim>
  template <class... QTypes>
  QCollection<dim>::QCollection(const QTypes &... quadrature_objects)
  {
    static_assert(is_base_of_all<Quadrature<dim>, QTypes...>::value,
                  "Not all of the input arguments of this function "
                  "are derived from Quadrature<dim>!");
 
    // 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:
    const auto q_pointers = {
      (static_cast<const Quadrature<dim> *>(&quadrature_objects))...};
    for (const auto p : q_pointers)
      push_back(*p);
  }
 
 
 
  template <int dim>
  inline unsigned int
  QCollection<dim>::size() const
  {
    return quadratures.size();
  }
 
 
 
  template <int dim>
  inline unsigned int
  QCollection<dim>::max_n_quadrature_points() const
  {
    Assert(quadratures.size() > 0,
           ExcMessage("You can't call this function for an empty collection"));
 
    unsigned int m = 0;
    for (unsigned int i = 0; i < quadratures.size(); ++i)
      if (quadratures[i]->size() > m)
        m = quadratures[i]->size();
 
    return m;
  }
 
 
 
  template <int dim>
  inline const Quadrature<dim> &QCollection<dim>::
                                operator[](const unsigned int index) const
  {
    AssertIndexRange(index, quadratures.size());
    return *quadratures[index];
  }
 
 
 
  template <int dim>
  inline bool
  QCollection<dim>::operator==(const QCollection<dim> &q_collection) const
  {
    const unsigned int n_quadratures = size();
    if (n_quadratures != q_collection.size())
      return false;
 
    for (unsigned int i = 0; i < n_quadratures; ++i)
      if (!(*quadratures[i] == q_collection[i]))
        return false;
 
    return true;
  }
 
 
 
  template <int dim>
  inline QCollection<dim>::QCollection(const Quadrature<dim> &quadrature)
  {
    quadratures.push_back(std::make_shared<const Quadrature<dim>>(quadrature));
  }
 
 
 
  template <int dim>
  inline std::size_t
  QCollection<dim>::memory_consumption() const
  {
    return (sizeof(*this) + MemoryConsumption::memory_consumption(quadratures));
  }
 
 
  template <int dim>
  inline void
  QCollection<dim>::push_back(const Quadrature<dim> &new_quadrature)
  {
    quadratures.push_back(
      std::make_shared<const Quadrature<dim>>(new_quadrature));
  }
 
} // namespace hp
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif