cell_id.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_cell_id_h
#define dealii_cell_id_h

#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>

#include <array>
#include <vector>
#include <iostream>
#include <cstdint>

#ifdef DEAL_II_WITH_P4EST
#include <deal.II/distributed/p4est_wrappers.h>
#endif

DEAL_II_NAMESPACE_OPEN

template <int, int> class Triangulation;

class CellId
{
public:
  typedef std::array<unsigned int, 4> binary_type;

  CellId(const unsigned int coarse_cell_id,
         const std::vector<std::uint8_t> &child_indices);

  CellId(const unsigned int  coarse_cell_id,
         const unsigned int  n_child_indices,
         const std::uint8_t *child_indices);

  CellId(const binary_type &binary_representation);

  CellId();

  std::string to_string() const;

  template <int dim>
  binary_type to_binary() const;

  template <int dim, int spacedim>
  typename Triangulation<dim,spacedim>::cell_iterator
  to_cell(const Triangulation<dim,spacedim> &tria) const;

  bool operator== (const CellId &other) const;

  bool operator!= (const CellId &other) const;

  bool operator<(const CellId &other) const;

  template<class Archive>
  void serialize(Archive &ar, const unsigned int version );

private:
  unsigned int coarse_cell_id;

  unsigned int n_child_indices;

#ifdef DEAL_II_WITH_P4EST
  std::array<std::uint8_t,internal::p4est::functions<2>::max_level> child_indices;
#else
  std::array<std::uint8_t,30> child_indices;
#endif

  friend std::istream &operator>> (std::istream &is, CellId &cid);
  friend std::ostream &operator<< (std::ostream &os, const CellId &cid);
};




inline
std::ostream &operator<< (std::ostream &os,
                          const CellId &cid)
{
  os << cid.coarse_cell_id << '_' << cid.n_child_indices << ':';
  for (unsigned int i=0; i<cid.n_child_indices; ++i)
    // write the child indices. because they are between 0 and 2^dim-1, they all
    // just have one digit, so we could write them as one character
    // objects. it's probably clearer to write them as one-digit characters
    // starting at '0'
    os << static_cast<unsigned char>('0' + cid.child_indices[i]);
  return os;
}



template<class Archive>
void CellId::serialize(Archive &ar, const unsigned int /*version*/)
{
  ar &coarse_cell_id;
  ar &n_child_indices;
  ar &child_indices;
}

inline
std::istream &operator>> (std::istream &is,
                          CellId &cid)
{
  unsigned int cellid;
  is >> cellid;
  if (is.eof())
    return is;

  cid.coarse_cell_id = cellid;
  char dummy;
  is >> dummy;
  Assert(dummy=='_', ExcMessage("invalid CellId"));
  is >> cid.n_child_indices;
  is >> dummy;
  Assert(dummy==':', ExcMessage("invalid CellId"));

  unsigned char value;
  for (unsigned int i=0; i<cid.n_child_indices; ++i)
    {
      // read the one-digit child index (as an integer number) and
      // convert it back into unsigned integer type
      is >> value;
      cid.child_indices[i] = value-'0';
    }
  return is;
}



inline bool
CellId::operator== (const CellId &other) const
{
  if (this->coarse_cell_id != other.coarse_cell_id)
    return false;
  if (n_child_indices != other.n_child_indices)
    return false;

  for (unsigned int i=0; i<n_child_indices; ++i)
    if (child_indices[i] != other.child_indices[i])
      return false;

  return true;
}



inline bool
CellId::operator!= (const CellId &other) const
{
  return !(*this == other);
}



inline
bool CellId::operator<(const CellId &other) const
{
  if (this->coarse_cell_id != other.coarse_cell_id)
    return this->coarse_cell_id < other.coarse_cell_id;

  unsigned int idx = 0;
  while (idx < n_child_indices)
    {
      if (idx>=other.n_child_indices)
        return false;

      if (child_indices[idx] != other.child_indices[idx])
        return child_indices[idx] < other.child_indices[idx];

      ++idx;
    }

  if (n_child_indices == other.n_child_indices)
    return false;
  return true; // other.id is longer
}

DEAL_II_NAMESPACE_CLOSE

#endif