CartesianNumbering.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* CartesianNumbering.h                                        (C) 2000-2021 */
/*                                                                           */
/* Handling of Cartesian numbering on a grid of entities.                    */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CARTESIANMESH_CARTESIANNUMBERING_H
#define ARCANE_CARTESIANMESH_CARTESIANNUMBERING_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/cartesianmesh/CartesianMeshGlobal.h"
#include "arcane/cartesianmesh/v2/CartesianTypes.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::CartesianMesh::V2
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename IdType>
class CartesianNumbering
{
 public:

  using IdType3 = IdType[3];
 
 public:
 
  CartesianNumbering() {}
 
  ARCCORE_HOST_DEVICE CartesianNumbering(const CartesianNumbering<IdType>& rhs)
  {
    m_dimension = rhs.m_dimension;
    for (Integer d(0); d < 3; ++d) {
      m_nitems_dir[d] = rhs.m_nitems_dir[d];
      m_coef[d] = rhs.m_coef[d];
    }
    m_nitems = rhs.m_nitems;
    m_first_item_id = rhs.m_first_item_id;
  }
 
  void initNumbering(const IdType3& nitems_dir, Integer dimension, IdType first_item_id = 0)
  {
    m_dimension = dimension;
    m_nitems = 1;
    m_first_item_id = first_item_id;
 
    for (Integer d(0); d < m_dimension; ++d) {
      m_nitems_dir[d] = nitems_dir[d];
      m_nitems *= m_nitems_dir[d];
    }
 
    for (Integer d(m_dimension); d < 3; ++d) {
      m_nitems_dir[d] = 1;
    }
 
    m_coef[0] = m_coef[1] = m_coef[2] = 1;
 
    // Numbering according to i, then j, then k
    m_coef[0] = 1;
    for (Integer d(1); d < m_dimension; ++d) {
      m_coef[d] = m_coef[d - 1] * m_nitems_dir[d - 1];
    }
  }

  Integer dimension() const
  {
    return m_dimension;
  }

  const IdType3& nbItem3() const
  {
    return m_nitems_dir;
  }

  // Equal to nbItem3()[dir]
  IdType nbItemDir(Integer dir) const
  {
    return m_nitems_dir[dir];
  }

  IdType nbItem() const
  {
    return m_nitems;
  }

  IdType firstId() const
  {
    return m_first_item_id;
  }

  // Equal to delta3()[dir]
  // id(item_ijk) + deltaDir(1) = id({item_ijk[0],item_ijk[1]+1,item_ijk[0]})
  IdType deltaDir(Integer dir) const
  {
    return m_coef[dir];
  }

  const IdType3& delta3() const
  {
    return m_coef;
  }

  ARCCORE_HOST_DEVICE inline IdType id(IdType i, IdType j, IdType k) const
  {
    // m_coef[0] is 1
    // TODO : specialization via template
    IdType item_id;
    if (m_dimension < 3) {
      item_id = m_first_item_id + i /*m_coef[0]*/ + j * m_coef[1];
    }
    else {
      item_id = m_first_item_id + i /*m_coef[0]*/ + j * m_coef[1] + k * m_coef[2];
    }
    return item_id;
  }

  inline IdType id(const IdType3& item_ijk) const
  {
    return id(item_ijk[0], item_ijk[1], item_ijk[2]);
  }

  // NOTE : IdxType is a triplet of Int64 while IdType may be an Int32 or an Int64
  ARCCORE_HOST_DEVICE inline IdType id(IdxType idx) const
  {
    return id(static_cast<IdType>(idx[0]), static_cast<IdType>(idx[1]), static_cast<IdType>(idx[2]));
  }

  void ijk(IdType item_id, IdType3& item_ijk) const
  {
    item_id -= m_first_item_id;
    // TODO : specialization via template
    if (m_dimension < 3) {
      item_ijk[2] = 0;
      item_ijk[1] = item_id / m_coef[1];
      item_ijk[0] = item_id % m_coef[1];
    }
    else {
      item_ijk[2] = item_id / m_coef[2];
      IdType tmp = item_id % m_coef[2];
      item_ijk[1] = tmp / m_coef[1];
      item_ijk[0] = tmp % m_coef[1];
    }
  }

  ARCCORE_HOST_DEVICE IdxType ijk(IdType item_id) const
  {
    item_id -= m_first_item_id;
    Int64 i, j, k;
    // TODO : specialization via template
    if (m_dimension < 3) {
      k = 0;
      j = item_id / m_coef[1];
      i = item_id % m_coef[1];
    }
    else {
      k = item_id / m_coef[2];
      IdType tmp = item_id % m_coef[2];
      j = tmp / m_coef[1];
      i = tmp % m_coef[1];
    }
    return { i, j, k };
  }
 
  // TODO : use specialized template
  IdType idxDir0(IdType item_id) const
  {
    return (item_id - m_first_item_id) % m_coef[1];
  }

  IdType idxDir1(IdType item_id) const
  {
    return (m_dimension == 3 ? ((item_id - m_first_item_id) % m_coef[2] / m_coef[1]) : (item_id - m_first_item_id) / m_coef[1]);
  }

  IdType idxDir2(IdType item_id) const
  {
    return (item_id - m_first_item_id) / m_coef[2];
  }
 
 protected:
 
  Integer m_dimension = 0;
 
  IdType3 m_nitems_dir = { 1, 1, 1 }; // Number of elements per direction
  IdType m_nitems = 0; // Total number of elements
 
  IdType m_first_item_id = 0; 
 
  IdType3 m_coef = { 0, 0, 0 };
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::CartesianMesh::V2
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif