mg_level_object.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2003 - 2018 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_mg_level_object_h
#define dealii_mg_level_object_h

#include <deal.II/base/subscriptor.h>

#include <memory>
#include <vector>

DEAL_II_NAMESPACE_OPEN


template <class Object>
class MGLevelObject : public Subscriptor
{
public:
  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;

  void
  resize(const unsigned int new_minlevel, const unsigned int new_maxlevel);

  MGLevelObject<Object> &
  operator=(const double d);

  DEAL_II_DEPRECATED
  void
  clear();

  void
  clear_elements();

  unsigned int
  min_level() const;

  unsigned int
  max_level() 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>
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>
void
MGLevelObject<Object>::resize(const unsigned int new_minlevel,
                              const unsigned int new_maxlevel)
{
  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>());
}


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() // DEPRECATED
{
  // Avoid code duplication in deprecated call by calling replacing function
  clear_elements();
}


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>
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