src/arcane/cartesianmesh/NodeDirectionMng.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* NodeDirectionMng.cc                                         (C) 2000-2022 */
/*                                                                           */
/* Infos sur les noeuds d'une direction X Y ou Z d'un maillage structuré.    */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CARTESIANMESH_NODEDIRECTIONMNG_H
#define ARCANE_CARTESIANMESH_NODEDIRECTIONMNG_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/ArcaneTypes.h"
#include "arcane/Item.h"
#include "arcane/ItemEnumerator.h"
#include "arcane/VariableTypedef.h"
#include "arcane/IndexedItemConnectivityView.h"
 
#include "arcane/cartesianmesh/CartesianMeshGlobal.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT DirNode
{
  friend NodeDirectionMng;
  friend class DirNodeLocalId;
 
 private:
 
  typedef signed char IndexType;
  static constexpr IndexType NULL_CELL = -1;
 
  struct DirNodeCellIndex
  {
   public:
 
    ARCCORE_HOST_DEVICE IndexType operator[](Int32 i) const
    {
      ARCANE_CHECK_AT(i, 8);
      return m_indexes[i];
    }
 
   public:
 
    IndexType m_indexes[8];
  };
 
 private:
 
  // Seul NodeDirectionMng à le droit de construire un DirNode.
  DirNode(Node current, Node next, Node prev, DirNodeCellIndex idx)
  : m_current(current)
  , m_previous(prev)
  , m_next(next)
  , m_cell_index(idx)
  {}
 
 public:
 
  Node previous() const { return m_previous; }
  NodeLocalId previousId() const { return m_previous.itemLocalId(); }
  Node next() const { return m_next; }
  NodeLocalId nextId() const { return m_next.itemLocalId(); }
  Int32 cellIndex(Int32 position) const { return m_cell_index[position]; }
  CellLocalId cellId(Int32 position) const
  {
    Int32 x = cellIndex(position);
    return (x == NULL_CELL) ? CellLocalId(NULL_ITEM_LOCAL_ID) : CellLocalId(m_current.cellId(x));
  }
  Cell cell(Int32 position) const
  {
    Int32 x = cellIndex(position);
    return (x == NULL_CELL) ? Cell() : Cell(m_current.cell(x));
  }
 
  Cell nextLeftCell() const { return cell(CNP_NextLeft); }
  Cell nextRightCell() const { return cell(CNP_NextRight); }
  Cell previousRightCell() const { return cell(CNP_PreviousRight); }
  Cell previousLeftCell() const { return cell(CNP_PreviousLeft); }
 
  CellLocalId nextLeftCellId() const { return cellId(CNP_NextLeft); }
  CellLocalId nextRightCellId() const { return cellId(CNP_NextRight); }
  CellLocalId previousRightCellId() const { return cellId(CNP_PreviousRight); }
  CellLocalId previousLeftCellId() const { return cellId(CNP_PreviousLeft); }
 
  Cell topNextLeftCell() const { return cell(CNP_TopNextLeft); }
  Cell topNextRightCell() const { return cell(CNP_TopNextRight); }
  Cell topPreviousRightCell() const { return cell(CNP_TopPreviousRight); }
  Cell topPreviousLeftCell() const { return cell(CNP_TopPreviousLeft); }
 
  CellLocalId topNextLeftCellId() const { return cellId(CNP_TopNextLeft); }
  CellLocalId topNextRightCellId() const { return cellId(CNP_TopNextRight); }
  CellLocalId topPreviousRightCellId() const { return cellId(CNP_TopPreviousRight); }
  CellLocalId topPreviousLeftCellId() const { return cellId(CNP_TopPreviousLeft); }
 
 private:
 
  Node m_current;
  Node m_previous;
  Node m_next;
  DirNodeCellIndex m_cell_index;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT DirNodeLocalId
{
  friend NodeDirectionMng;
 
 private:
 
  typedef signed char IndexType;
  static constexpr IndexType NULL_CELL = -1;
 
 private:
 
  // Seul NodeDirectionMng à le droit de construire un DirNode.
  ARCCORE_HOST_DEVICE DirNodeLocalId(NodeLocalId current, NodeLocalId next, NodeLocalId prev,
                                     DirNode::DirNodeCellIndex idx,
                                     IndexedNodeCellConnectivityView view)
  : m_current(current)
  , m_previous(prev)
  , m_next(next)
  , m_cell_index(idx)
  , m_view(view)
  {}
 
 public:
 
  ARCCORE_HOST_DEVICE NodeLocalId previous() const { return m_previous; }
  ARCCORE_HOST_DEVICE NodeLocalId previousId() const { return m_previous; }
  ARCCORE_HOST_DEVICE NodeLocalId next() const { return m_next; }
  ARCCORE_HOST_DEVICE NodeLocalId nextId() const { return m_next; }
  ARCCORE_HOST_DEVICE Int32 cellIndex(Int32 position) const { return m_cell_index[position]; }
  ARCCORE_HOST_DEVICE CellLocalId cellId(Int32 position) const
  {
    Int32 x = cellIndex(position);
    return (x == NULL_CELL) ? CellLocalId(NULL_ITEM_LOCAL_ID) : m_view.cellId(m_current, x);
  }
 
  ARCCORE_HOST_DEVICE CellLocalId nextLeftCellId() const { return cellId(CNP_NextLeft); }
  ARCCORE_HOST_DEVICE CellLocalId nextRightCellId() const { return cellId(CNP_NextRight); }
  ARCCORE_HOST_DEVICE CellLocalId previousRightCellId() const { return cellId(CNP_PreviousRight); }
  ARCCORE_HOST_DEVICE CellLocalId previousLeftCellId() const { return cellId(CNP_PreviousLeft); }
 
  ARCCORE_HOST_DEVICE CellLocalId topNextLeftCellId() const { return cellId(CNP_TopNextLeft); }
  ARCCORE_HOST_DEVICE CellLocalId topNextRightCellId() const { return cellId(CNP_TopNextRight); }
  ARCCORE_HOST_DEVICE CellLocalId topPreviousRightCellId() const { return cellId(CNP_TopPreviousRight); }
  ARCCORE_HOST_DEVICE CellLocalId topPreviousLeftCellId() const { return cellId(CNP_TopPreviousLeft); }
 
 private:
 
  NodeLocalId m_current;
  NodeLocalId m_previous;
  NodeLocalId m_next;
  DirNode::DirNodeCellIndex m_cell_index;
  IndexedNodeCellConnectivityView m_view;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CARTESIANMESH_EXPORT NodeDirectionMng
{
  friend CartesianMeshImpl;
  friend CartesianMeshPatch;
  class Impl;
  using IndexType = DirNode::IndexType;
  using DirNodeCellIndex = DirNode::DirNodeCellIndex;
 
 private:
 
  struct ItemDirectionInfo
  {
   public:
 
    ItemDirectionInfo() = default;
    ItemDirectionInfo(Int32 next_lid, Int32 prev_lid)
    : m_next_lid(next_lid)
    , m_previous_lid(prev_lid)
    {}
 
   public:
 
    NodeLocalId m_next_lid;
    NodeLocalId m_previous_lid;
 
   public:
 
    void setCellIndexes(IndexType idx[8])
    {
      for (int i = 0; i < 8; ++i)
        m_cell_index.m_indexes[i] = idx[i];
    }
    DirNodeCellIndex m_cell_index;
  };
 
 public:
 
  NodeDirectionMng();
 
 public:
 
  DirNode node(Node n) const
  {
    return _node(n.localId());
  }
 
  DirNode node(NodeLocalId n) const
  {
    return _node(n.localId());
  }
 
  DirNode dirNode(NodeLocalId n) const
  {
    return _node(n.localId());
  }
 
  ARCCORE_HOST_DEVICE DirNodeLocalId dirNodeId(NodeLocalId n) const
  {
    return _dirNodeId(n);
  }
 
  NodeGroup allNodes() const;
 
  NodeGroup innerNodes() const;
 
  NodeGroup outerNodes() const;
 
  DirNode operator[](Node n)
  {
    return _node(n.localId());
  }
 
  DirNode operator[](NodeLocalId n) const
  {
    return _node(n.localId());
  }
 
  DirNode operator[](NodeEnumerator inode) const
  {
    return _node(inode.itemLocalId());
  }
 
  eMeshDirection direction() const
  {
    return m_direction;
  }
 
 protected:
 
  void _internalComputeInfos(const CellDirectionMng& cell_dm, const NodeGroup& all_nodes,
                             const VariableCellReal3& cells_center);
 
  void _internalInit(ICartesianMesh* cm, eMeshDirection dir, Integer patch_index);
 
  void _internalDestroy();
 
  void _internalResizeInfos(Int32 new_size);
 
 private:
 
  SmallSpan<ItemDirectionInfo> m_infos_view;
  NodeInfoListView m_nodes;
  eMeshDirection m_direction;
  IndexedNodeCellConnectivityView m_node_cell_view;
  Impl* m_p;
 
 private:
 
  DirNode _node(Int32 local_id) const
  {
    ItemDirectionInfo d = m_infos_view[local_id];
    return DirNode(m_nodes[local_id], m_nodes[d.m_next_lid], m_nodes[d.m_previous_lid], d.m_cell_index);
  }
 
  ARCCORE_HOST_DEVICE DirNodeLocalId _dirNodeId(NodeLocalId local_id) const
  {
    ItemDirectionInfo d = m_infos_view[local_id.localId()];
    return DirNodeLocalId(local_id, d.m_next_lid, d.m_previous_lid, d.m_cell_index, m_node_cell_view);
  }
 
  void _computeNodeCellInfos(const CellDirectionMng& cell_dm,
                             const VariableCellReal3& cells_center);
  void _filterNodes();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif