src/arcane/cartesianmesh/CellDirectionMng.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* CellDirectionMng.cc                                         (C) 2000-2023 */
/*                                                                           */
/* Infos sur les mailles d'une direction X Y ou Z d'un maillage structuré.   */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CARTESIANMESH_CELLDIRECTIONMNG_H
#define ARCANE_CARTESIANMESH_CELLDIRECTIONMNG_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/ArcaneTypes.h"
 
#include "arcane/Item.h"
#include "arcane/ItemEnumerator.h"
#include "arcane/IndexedItemConnectivityView.h"
 
#include "arcane/cartesianmesh/CartesianMeshGlobal.h"
#include "arcane/cartesianmesh/CartesianItemDirectionInfo.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT DirCell
{
 public:
 
  DirCell(Cell n, Cell p)
  : m_previous(p)
  , m_next(n)
  {}
 
 public:
 
  Cell previous() const { return m_previous; }
  CellLocalId previousId() const { return CellLocalId(m_previous.localId()); }
  Cell next() const { return m_next; }
  CellLocalId nextId() const { return CellLocalId(m_next.localId()); }
 
 private:
 
  Cell m_previous;
  Cell m_next;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT DirCellLocalId
{
 public:
 
  constexpr ARCCORE_HOST_DEVICE DirCellLocalId(CellLocalId n, CellLocalId p)
  : m_previous(p)
  , m_next(n)
  {}
 
 public:
 
  constexpr ARCCORE_HOST_DEVICE CellLocalId previous() const { return m_previous; }
  constexpr ARCCORE_HOST_DEVICE CellLocalId previousId() const { return m_previous; }
  constexpr ARCCORE_HOST_DEVICE CellLocalId next() const { return m_next; }
  constexpr ARCCORE_HOST_DEVICE CellLocalId nextId() const { return m_next; }
 
 private:
 
  CellLocalId m_previous;
  CellLocalId m_next;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT DirCellNode
{
  friend CellDirectionMng;
  using Int8 = std::int8_t;
 
 private:
 
  DirCellNode(Cell c, const Int8* nodes_indirection)
  : m_cell(c)
  , m_nodes_indirection(nodes_indirection)
  {}
 
 public:
 
  Cell cell() const { return m_cell; }
  CellLocalId cellId() const { return CellLocalId(m_cell.localId()); }
 
  Node nextLeft() const { return m_cell.node(m_nodes_indirection[CNP_NextLeft]); }
  Node nextRight() const { return m_cell.node(m_nodes_indirection[CNP_NextRight]); }
  Node previousRight() const { return m_cell.node(m_nodes_indirection[CNP_PreviousRight]); }
  Node previousLeft() const { return m_cell.node(m_nodes_indirection[CNP_PreviousLeft]); }
 
  NodeLocalId nextLeftId() const { return NodeLocalId(m_cell.nodeId(m_nodes_indirection[CNP_NextLeft])); }
  NodeLocalId nextRightId() const { return NodeLocalId(m_cell.nodeId(m_nodes_indirection[CNP_NextRight])); }
  NodeLocalId previousRightId() const { return NodeLocalId(m_cell.nodeId(m_nodes_indirection[CNP_PreviousRight])); }
  NodeLocalId previousLeftId() const { return NodeLocalId(m_cell.nodeId(m_nodes_indirection[CNP_PreviousLeft])); }
 
  Node topNextLeft() const { return m_cell.node(m_nodes_indirection[CNP_TopNextLeft]); }
  Node topNextRight() const { return m_cell.node(m_nodes_indirection[CNP_TopNextRight]); }
  Node topPreviousRight() const { return m_cell.node(m_nodes_indirection[CNP_TopPreviousRight]); }
  Node topPreviousLeft() const { return m_cell.node(m_nodes_indirection[CNP_TopPreviousLeft]); }
 
  NodeLocalId topNextLeftId() const { return NodeLocalId(m_cell.nodeId(m_nodes_indirection[CNP_TopNextLeft])); }
  NodeLocalId topNextRightId() const { return NodeLocalId(m_cell.nodeId(m_nodes_indirection[CNP_TopNextRight])); }
  NodeLocalId topPreviousRightId() const { return NodeLocalId(m_cell.nodeId(m_nodes_indirection[CNP_TopPreviousRight])); }
  NodeLocalId topPreviousLeftId() const { return NodeLocalId(m_cell.nodeId(m_nodes_indirection[CNP_TopPreviousLeft])); }
 
 private:
 
  Cell m_cell;
  const Int8* m_nodes_indirection;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT DirCellNodeLocalId
{
  friend CellDirectionMng;
  using Int8 = std::int8_t;
 
 private:
 
  ARCCORE_HOST_DEVICE DirCellNodeLocalId(CellLocalId c, const Int8* nodes_indirection, IndexedCellNodeConnectivityView view)
  : m_cell(c)
  , m_nodes_indirection(nodes_indirection)
  , m_view(view)
  {}
 
 public:
 
  ARCCORE_HOST_DEVICE CellLocalId cellId() const { return m_cell; }
 
  ARCCORE_HOST_DEVICE NodeLocalId nextLeftId() const { return m_view.nodeId(m_cell, m_nodes_indirection[CNP_NextLeft]); }
  ARCCORE_HOST_DEVICE NodeLocalId nextRightId() const { return m_view.nodeId(m_cell, m_nodes_indirection[CNP_NextRight]); }
  ARCCORE_HOST_DEVICE NodeLocalId previousRightId() const { return m_view.nodeId(m_cell, m_nodes_indirection[CNP_PreviousRight]); }
  ARCCORE_HOST_DEVICE NodeLocalId previousLeftId() const { return m_view.nodeId(m_cell, m_nodes_indirection[CNP_PreviousLeft]); }
 
  ARCCORE_HOST_DEVICE NodeLocalId topNextLeftId() const { return m_view.nodeId(m_cell, m_nodes_indirection[CNP_TopNextLeft]); }
  ARCCORE_HOST_DEVICE NodeLocalId topNextRightId() const { return m_view.nodeId(m_cell, m_nodes_indirection[CNP_TopNextRight]); }
  ARCCORE_HOST_DEVICE NodeLocalId topPreviousRightId() const { return m_view.nodeId(m_cell, m_nodes_indirection[CNP_TopPreviousRight]); }
  ARCCORE_HOST_DEVICE NodeLocalId topPreviousLeftId() const { return m_view.nodeId(m_cell, m_nodes_indirection[CNP_TopPreviousLeft]); }
 
 private:
 
  CellLocalId m_cell;
  const Int8* m_nodes_indirection;
  IndexedCellNodeConnectivityView m_view;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT DirCellFace
{
  friend CellDirectionMng;
 
 private:
 
  DirCellFace(Cell c, Int32 next_face_index, Int32 previous_face_index)
  : m_cell(c)
  , m_next_face_index(next_face_index)
  , m_previous_face_index(previous_face_index)
  {
  }
 
 public:
 
  Cell cell() const { return m_cell; }
  CellLocalId cellId() const { return m_cell.itemLocalId(); }
 
  Face next() const { return m_cell.face(m_next_face_index); }
  FaceLocalId nextId() const { return m_cell.faceId(m_next_face_index); }
 
  Face previous() const { return m_cell.face(m_previous_face_index); }
  FaceLocalId previousId() const { return m_cell.faceId(m_previous_face_index); }
 
  Int32 nextLocalIndex() const { return m_next_face_index; }
 
  Int32 previousLocalIndex() const { return m_previous_face_index; }
 
 private:
 
  Cell m_cell;
  Int32 m_next_face_index;
  Int32 m_previous_face_index;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT DirCellFaceLocalId
{
  friend CellDirectionMng;
 
 private:
 
  ARCCORE_HOST_DEVICE DirCellFaceLocalId(CellLocalId c, Int32 next_face_index,
                                         Int32 previous_face_index,
                                         IndexedCellFaceConnectivityView view)
  : m_cell(c)
  , m_next_face_index(next_face_index)
  , m_previous_face_index(previous_face_index)
  , m_view(view)
  {
  }
 
 public:
 
  ARCCORE_HOST_DEVICE CellLocalId cell() const { return m_cell; }
  ARCCORE_HOST_DEVICE CellLocalId cellId() const { return m_cell; }
 
  ARCCORE_HOST_DEVICE FaceLocalId next() const { return m_view.faceId(m_cell, m_next_face_index); }
  ARCCORE_HOST_DEVICE FaceLocalId nextId() const { return m_view.faceId(m_cell, m_next_face_index); }
 
  ARCCORE_HOST_DEVICE FaceLocalId previous() const { return m_view.faceId(m_cell, m_previous_face_index); }
  ARCCORE_HOST_DEVICE FaceLocalId previousId() const { return m_view.faceId(m_cell, m_previous_face_index); }
 
  ARCCORE_HOST_DEVICE Int32 nextLocalIndex() const { return m_next_face_index; }
 
  ARCCORE_HOST_DEVICE Int32 previousLocalIndex() const { return m_previous_face_index; }
 
 private:
 
  CellLocalId m_cell;
  Int32 m_next_face_index;
  Int32 m_previous_face_index;
  IndexedCellFaceConnectivityView m_view;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT CellDirectionMng
{
  friend CartesianMeshImpl;
  friend CartesianMeshPatch;
  class Impl;
  static const int MAX_NB_NODE = 8;
  using Int8 = std::int8_t;
 
 private:
 
  using ItemDirectionInfo = impl::CartesianItemDirectionInfo;
 
 public:
 
  CellDirectionMng();
 
 public:
 
  DirCell cell(Cell c) const
  {
    return _cell(c.localId());
  }
  DirCell cell(CellLocalId c) const
  {
    return _cell(c.localId());
  }
  DirCell dirCell(CellLocalId c) const
  {
    return _cell(c.localId());
  }
  ARCCORE_HOST_DEVICE DirCellLocalId dirCellId(CellLocalId c) const
  {
    return _dirCellId(c);
  }
 
  DirCellNode cellNode(Cell c) const
  {
    return DirCellNode(c, m_nodes_indirection);
  }
 
  DirCellNode cellNode(CellLocalId c) const
  {
    return DirCellNode(m_cells[c.localId()], m_nodes_indirection);
  }
 
  DirCellNode dirCellNode(CellLocalId c) const
  {
    return DirCellNode(m_cells[c.localId()], m_nodes_indirection);
  }
 
  ARCCORE_HOST_DEVICE DirCellNodeLocalId dirCellNodeId(CellLocalId c) const
  {
    return DirCellNodeLocalId(c, m_nodes_indirection, m_cell_node_view);
  }
 
  DirCellFace cellFace(Cell c) const
  {
    return DirCellFace(c, m_next_face_index, m_previous_face_index);
  }
  DirCellFace cellFace(CellLocalId c) const
  {
    return DirCellFace(m_cells[c.localId()], m_next_face_index, m_previous_face_index);
  }
 
  ARCCORE_HOST_DEVICE DirCellFaceLocalId dirCellFaceId(CellLocalId c) const
  {
    return DirCellFaceLocalId(c, m_next_face_index, m_previous_face_index, m_cell_face_view);
  }
 
  CellGroup allCells() const;
 
  CellGroup innerCells() const;
  CellGroup outerCells() const;
 
  DirCell operator[](Cell c) const
  {
    return _cell(c.localId());
  }
 
  DirCell operator[](CellLocalId c) const
  {
    return _cell(c.localId());
  }
 
  DirCell operator[](CellEnumerator icell) const
  {
    return _cell(icell.itemLocalId());
  }
 
  Int64 globalNbCell() const;
 
  Int32 ownNbCell() const;
 
  Int32 subDomainOffset() const;
 
  Int64 ownCellOffset() const;
 
 private:
 
  DirCell _cell(Int32 local_id) const
  {
    ItemDirectionInfo d = m_infos_view[local_id];
    return DirCell(m_cells[d.m_next_lid], m_cells[d.m_previous_lid]);
  }
 
  ARCCORE_HOST_DEVICE DirCellLocalId _dirCellId(Int32 local_id) const
  {
    ItemDirectionInfo d = m_infos_view[local_id];
    return DirCellLocalId(CellLocalId(d.m_next_lid), CellLocalId(d.m_previous_lid));
  }
 
  void setNodesIndirection(ConstArrayView<Int8> nodes_indirection);
 
 protected:
 
  void _internalComputeInnerAndOuterItems(const ItemGroup& items);
 
  void _internalInit(ICartesianMesh* cm, eMeshDirection dir, Integer patch_index);
 
  void _internalDestroy();
 
  void _internalSetLocalFaceIndex(Int32 next_index, Int32 previous_index)
  {
    m_next_face_index = next_index;
    m_previous_face_index = previous_index;
  }
 
  void _internalResizeInfos(Int32 new_size);
 
  void _internalSetOffsetAndNbCellInfos(Int64 global_nb_cell, Int32 own_nb_cell,
                                        Int32 sub_domain_offset, Int64 own_cell_offset);
 
 public:
 
  eMeshDirection direction() const
  {
    return m_direction;
  }
 
 private:
 
  SmallSpan<ItemDirectionInfo> m_infos_view;
  CellInfoListView m_cells;
  eMeshDirection m_direction;
  Int32 m_next_face_index;
  Int32 m_previous_face_index;
  Int8 m_nodes_indirection[MAX_NB_NODE];
  Impl* m_p = nullptr;
  IndexedCellNodeConnectivityView m_cell_node_view;
  IndexedCellFaceConnectivityView m_cell_face_view;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif