block_indices.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2000 - 2024 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_block_indices_h
#define dealii_block_indices_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/logstream.h>
#include <deal.II/base/subscriptor.h>
 
#include <algorithm>
#include <cstddef>
#include <string>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
 
class BlockIndices : public Subscriptor
{
public:
  using size_type = types::global_dof_index;
 
  BlockIndices();
 
  BlockIndices(const std::vector<size_type> &block_sizes);
 
  BlockIndices(BlockIndices &&b) noexcept;
 
  BlockIndices(const BlockIndices &) = default;
 
  explicit BlockIndices(const unsigned int n_blocks,
                        const size_type    block_size = 0);
 
  void
  reinit(const unsigned int n_blocks, const size_type n_elements_per_block);
 
  void
  reinit(const std::vector<size_type> &block_sizes);
 
  void
  push_back(const size_type size);
 
  unsigned int
  size() const;
 
  size_type
  total_size() const;
 
  size_type
  block_size(const unsigned int i) const;
 
  std::string
  to_string() const;
 
  std::pair<unsigned int, size_type>
  global_to_local(const size_type i) const;
 
  size_type
  local_to_global(const unsigned int block, const size_type index) const;
 
  size_type
  block_start(const unsigned int i) const;
  BlockIndices &
  operator=(const BlockIndices &b);
 
  BlockIndices &
  operator=(BlockIndices &&) noexcept;
 
  bool
  operator==(const BlockIndices &b) const;
 
  void
  swap(BlockIndices &b) noexcept;
 
  std::size_t
  memory_consumption() const;
 
private:
  unsigned int n_blocks;
 
  std::vector<size_type> start_indices;
};
 
 
inline LogStream &
operator<<(LogStream &s, const BlockIndices &bi)
{
  const unsigned int n = bi.size();
  s << n << ":[";
  // Write first size without leading space
  if (n > 0)
    s << bi.block_size(0);
  // Write all other sizes
  for (unsigned int i = 1; i < n; ++i)
    s << ' ' << bi.block_size(i);
  s << "]->" << bi.total_size();
  return s;
}
 
 
 
/* ---------------------- template and inline functions ------------------- */
 
inline void
BlockIndices::reinit(const unsigned int nb, const size_type block_size)
{
  n_blocks = nb;
  start_indices.resize(n_blocks + 1);
  for (size_type i = 0; i <= n_blocks; ++i)
    start_indices[i] = i * block_size;
}
 
 
 
inline void
BlockIndices::reinit(const std::vector<size_type> &block_sizes)
{
  if (start_indices.size() != block_sizes.size() + 1)
    {
      n_blocks = static_cast<unsigned int>(block_sizes.size());
      start_indices.resize(n_blocks + 1);
    }
  start_indices[0] = 0;
  for (size_type i = 1; i <= n_blocks; ++i)
    start_indices[i] = start_indices[i - 1] + block_sizes[i - 1];
}
 
 
inline BlockIndices::BlockIndices()
  : n_blocks(0)
  , start_indices(1, 0)
{}
 
 
 
inline BlockIndices::BlockIndices(const unsigned int n_blocks,
                                  const size_type    block_size)
  : n_blocks(n_blocks)
  , start_indices(n_blocks + 1)
{
  for (size_type i = 0; i <= n_blocks; ++i)
    start_indices[i] = i * block_size;
}
 
 
 
inline BlockIndices::BlockIndices(const std::vector<size_type> &block_sizes)
  : n_blocks(static_cast<unsigned int>(block_sizes.size()))
  , start_indices(block_sizes.size() + 1)
{
  reinit(block_sizes);
}
 
 
 
inline BlockIndices::BlockIndices(BlockIndices &&b) noexcept
  : n_blocks(b.n_blocks)
  , start_indices(std::move(b.start_indices))
{
  b.n_blocks      = 0;
  b.start_indices = std::vector<size_type>(1, 0);
}
 
 
 
inline void
BlockIndices::push_back(const size_type sz)
{
  start_indices.push_back(start_indices[n_blocks] + sz);
  ++n_blocks;
  AssertDimension(start_indices.size(), n_blocks + 1);
}
 
 
inline std::pair<unsigned int, BlockIndices::size_type>
BlockIndices::global_to_local(const size_type i) const
{
  AssertIndexRange(i, total_size());
  Assert(n_blocks > 0, ExcLowerRangeType<size_type>(i, size_type(1)));
 
  // start_indices[0] == 0 so we might as well start from the next one
  const auto it = std::prev(
    std::upper_bound(std::next(start_indices.begin()), start_indices.end(), i));
 
  return {std::distance(start_indices.begin(), it), i - *it};
}
 
 
inline BlockIndices::size_type
BlockIndices::local_to_global(const unsigned int block,
                              const size_type    index) const
{
  AssertIndexRange(block, n_blocks);
  AssertIndexRange(index, start_indices[block + 1] - start_indices[block]);
 
  return start_indices[block] + index;
}
 
 
inline unsigned int
BlockIndices::size() const
{
  return n_blocks;
}
 
 
 
inline BlockIndices::size_type
BlockIndices::total_size() const
{
  if (n_blocks == 0)
    return 0;
  return start_indices[n_blocks];
}
 
 
 
inline BlockIndices::size_type
BlockIndices::block_size(const unsigned int block) const
{
  AssertIndexRange(block, n_blocks);
  return start_indices[block + 1] - start_indices[block];
}
 
 
 
inline std::string
BlockIndices::to_string() const
{
  std::string result = "[" + std::to_string(n_blocks) + "->";
  for (unsigned int i = 0; i < n_blocks; ++i)
    {
      if (i > 0)
        result += ',';
      result += std::to_string(block_size(i));
    }
  result += "|" + std::to_string(total_size()) + ']';
  return result;
}
 
 
 
inline BlockIndices::size_type
BlockIndices::block_start(const unsigned int block) const
{
  AssertIndexRange(block, n_blocks);
  return start_indices[block];
}
 
 
 
inline BlockIndices &
BlockIndices::operator=(const BlockIndices &b)
{
  start_indices = b.start_indices;
  n_blocks      = b.n_blocks;
  return *this;
}
 
 
 
inline BlockIndices &
BlockIndices::operator=(BlockIndices &&b) noexcept
{
  start_indices = std::move(b.start_indices);
  n_blocks      = b.n_blocks;
 
  b.start_indices = std::vector<size_type>(1, 0);
  b.n_blocks      = 0;
 
  return *this;
}
 
 
 
inline bool
BlockIndices::operator==(const BlockIndices &b) const
{
  if (n_blocks != b.n_blocks)
    return false;
 
  for (size_type i = 0; i <= n_blocks; ++i)
    if (start_indices[i] != b.start_indices[i])
      return false;
 
  return true;
}
 
 
 
inline void
BlockIndices::swap(BlockIndices &b) noexcept
{
  std::swap(n_blocks, b.n_blocks);
  std::swap(start_indices, b.start_indices);
}
 
 
 
inline std::size_t
BlockIndices::memory_consumption() const
{
  return (sizeof(*this) + start_indices.size() * sizeof(start_indices[0]));
}
 
 
 
/* ----------------- global functions ---------------------------- */
 
 
inline void
swap(BlockIndices &u, BlockIndices &v) noexcept
{
  u.swap(v);
}
 
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif