block_info.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2009 - 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_block_info_h
#define dealii_block_info_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/subscriptor.h>
 
#include <deal.II/lac/block_indices.h>
 
#include <iomanip>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
template <int dim, int spacedim>
class DoFHandler;
namespace hp
{
  template <int dim, int spacedim>
  class DoFHandler;
}
#endif
 
 
class BlockInfo : public Subscriptor
{
public:
  template <int dim, int spacedim>
  void
  initialize(const DoFHandler<dim, spacedim> &,
             bool levels_only = false,
             bool active_only = false);
 
  template <int dim, int spacedim>
  void
  initialize(const hp::DoFHandler<dim, spacedim> &,
             bool levels_only = false,
             bool active_only = false);
 
  template <int dim, int spacedim>
  void
  initialize_local(const DoFHandler<dim, spacedim> &);
 
  template <int dim, int spacedim>
  void
  initialize_local(const hp::DoFHandler<dim, spacedim> &);
 
  const BlockIndices &
  global() const;
 
  const BlockIndices &
  local() const;
 
  const BlockIndices &
  level(unsigned int level) const;
 
  types::global_dof_index
  renumber(const unsigned int i) const;
 
  unsigned int
  n_base_elements() const;
 
  unsigned int
  base_element(const unsigned int i) const;
 
  template <class OS>
  void
  print(OS &stream) const;
 
  std::size_t
  memory_consumption() const;
 
  template <class Archive>
  void
  serialize(Archive &ar, const unsigned int /*version*/);
 
private:
  BlockIndices bi_global;
  std::vector<BlockIndices> levels;
 
  BlockIndices bi_local;
 
  std::vector<unsigned int> base_elements;
 
  std::vector<types::global_dof_index> local_renumbering;
};
 
 
 
//----------------------------------------------------------------------//
 
inline const BlockIndices &
BlockInfo::global() const
{
  return bi_global;
}
 
 
inline const BlockIndices &
BlockInfo::local() const
{
  return bi_local;
}
 
 
inline const BlockIndices &
BlockInfo::level(const unsigned int l) const
{
  AssertIndexRange(l, levels.size());
  return levels[l];
}
 
 
inline types::global_dof_index
BlockInfo::renumber(const unsigned int i) const
{
  AssertIndexRange(i, static_cast<unsigned int>(local_renumbering.size()));
  return local_renumbering[i];
}
 
 
inline unsigned int
BlockInfo::base_element(const unsigned int i) const
{
  AssertIndexRange(i, base_elements.size());
 
  return base_elements[i];
}
 
 
inline unsigned int
BlockInfo::n_base_elements() const
{
  return base_elements.size();
}
 
 
 
template <class OS>
inline void
BlockInfo::print(OS &os) const
{
  os << "global   dofs " << std::setw(5) << global().total_size() << " blocks";
  for (unsigned int i = 0; i < global().size(); ++i)
    os << ' ' << std::setw(5) << global().block_size(i);
  os << std::endl;
 
  if (local().size() == 0)
    {
      os << "local dofs not initialized" << std::endl;
    }
  else
    {
      os << "local    dofs " << std::setw(5) << local().total_size()
         << " blocks";
      for (unsigned int i = 0; i < local().size(); ++i)
        os << ' ' << std::setw(5) << local().block_size(i);
      os << std::endl;
    }
 
  for (unsigned int l = 0; l < levels.size(); ++l)
    {
      os << "level " << std::setw(2) << l << " dofs " << std::setw(5)
         << level(l).total_size() << " blocks";
      for (unsigned int i = 0; i < level(l).size(); ++i)
        os << ' ' << std::setw(5) << level(l).block_size(i);
      os << std::endl;
    }
}
 
 
inline std::size_t
BlockInfo::memory_consumption() const
{
  return (MemoryConsumption::memory_consumption(bi_global) +
          MemoryConsumption::memory_consumption(levels) +
          MemoryConsumption::memory_consumption(bi_local) +
          MemoryConsumption::memory_consumption(base_elements));
}
 
 
template <class Archive>
void
BlockInfo::serialize(Archive &ar, const unsigned int /*version*/)
{
  ar &bi_global;
  ar &levels;
  ar &bi_local;
  ar &base_elements;
  ar &local_renumbering;
}
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif