mg_level_object.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2003 - 2024 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_mg_level_object_h
#define dealii_mg_level_object_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/enable_observer_pointer.h>
 
#include <memory>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
 
template <class Object>
class MGLevelObject : public EnableObserverPointer
{
public:
  template <class... Args>
  MGLevelObject(const unsigned int minlevel,
                const unsigned int maxlevel,
                Args &&...args);
 
  MGLevelObject(const unsigned int minlevel = 0,
                const unsigned int maxlevel = 0);
 
  Object &
  operator[](const unsigned int level);
 
  const Object &
  operator[](const unsigned int level) const;
 
  const Object &
  back() const;
 
  template <class... Args>
  void
  resize(const unsigned int new_minlevel,
         const unsigned int new_maxlevel,
         Args &&...args);
 
  MGLevelObject<Object> &
  operator=(const double d);
 
  void
  clear();
 
  void
  clear_elements();
 
  unsigned int
  min_level() const;
 
  unsigned int
  max_level() const;
 
  unsigned int
  n_levels() const;
 
  template <typename ActionFunctionObjectType>
  void
  apply(ActionFunctionObjectType action);
 
  std::size_t
  memory_consumption() const;
 
private:
  unsigned int minlevel;
 
  std::vector<std::shared_ptr<Object>> objects;
};
 
 
/* ------------------------------------------------------------------- */
 
 
template <class Object>
template <class... Args>
MGLevelObject<Object>::MGLevelObject(const unsigned int min,
                                     const unsigned int max,
                                     Args &&...args)
  : minlevel(0)
{
  resize(min, max, std::forward<Args>(args)...);
}
 
 
template <class Object>
MGLevelObject<Object>::MGLevelObject(const unsigned int min,
                                     const unsigned int max)
  : minlevel(0)
{
  resize(min, max);
}
 
 
template <class Object>
Object &
MGLevelObject<Object>::operator[](const unsigned int i)
{
  Assert((i >= minlevel) && (i < minlevel + objects.size()),
         ExcIndexRange(i, minlevel, minlevel + objects.size()));
  return *objects[i - minlevel];
}
 
 
template <class Object>
const Object &
MGLevelObject<Object>::operator[](const unsigned int i) const
{
  Assert((i >= minlevel) && (i < minlevel + objects.size()),
         ExcIndexRange(i, minlevel, minlevel + objects.size()));
  return *objects[i - minlevel];
}
 
 
template <class Object>
const Object &
MGLevelObject<Object>::back() const
{
  return this->operator[](this->max_level());
}
 
 
template <class Object>
template <class... Args>
void
MGLevelObject<Object>::resize(const unsigned int new_minlevel,
                              const unsigned int new_maxlevel,
                              Args &&...args)
{
  Assert(new_minlevel <= new_maxlevel, ExcInternalError());
  // note that on clear(), the
  // shared_ptr class takes care of
  // deleting the object it points to
  // by itself
  objects.clear();
 
  minlevel = new_minlevel;
  for (unsigned int i = 0; i < new_maxlevel - new_minlevel + 1; ++i)
    objects.push_back(std::make_shared<Object>(std::forward<Args>(args)...));
}
 
 
template <class Object>
MGLevelObject<Object> &
MGLevelObject<Object>::operator=(const double d)
{
  typename std::vector<std::shared_ptr<Object>>::iterator v;
  for (v = objects.begin(); v != objects.end(); ++v)
    **v = d;
  return *this;
}
 
 
template <class Object>
void
MGLevelObject<Object>::clear()
{
  minlevel = 0;
  objects.clear();
}
 
 
template <class Object>
void
MGLevelObject<Object>::clear_elements()
{
  typename std::vector<std::shared_ptr<Object>>::iterator v;
  for (v = objects.begin(); v != objects.end(); ++v)
    (*v)->clear();
}
 
 
template <class Object>
unsigned int
MGLevelObject<Object>::min_level() const
{
  return minlevel;
}
 
 
template <class Object>
unsigned int
MGLevelObject<Object>::max_level() const
{
  return minlevel + objects.size() - 1;
}
 
 
template <class Object>
unsigned int
MGLevelObject<Object>::n_levels() const
{
  return objects.size();
}
 
template <class Object>
template <typename ActionFunctionObjectType>
void
MGLevelObject<Object>::apply(ActionFunctionObjectType action)
{
  for (unsigned int lvl = min_level(); lvl <= max_level(); ++lvl)
    {
      action(lvl, (*this)[lvl]);
    }
}
 
 
template <class Object>
std::size_t
MGLevelObject<Object>::memory_consumption() const
{
  std::size_t result = sizeof(*this);
  using Iter = typename std::vector<std::shared_ptr<Object>>::const_iterator;
  const Iter end = objects.end();
  for (Iter o = objects.begin(); o != end; ++o)
    result += (*o)->memory_consumption();
 
  return result;
}
 
DEAL_II_NAMESPACE_CLOSE
 
#endif