FaceDirectionMng.cc

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* FaceDirectionMng.cc                                         (C) 2000-2026 */
/*                                                                           */
/* Information about the faces of a direction X Y or Z of a structured mesh. */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/cartesianmesh/FaceDirectionMng.h"
 
#include "arcane/utils/FatalErrorException.h"
#include "arcane/utils/Real3.h"
#include "arcane/utils/PlatformUtils.h"
 
#include "arcane/core/IItemFamily.h"
#include "arcane/core/ItemGroup.h"
#include "arcane/core/IMesh.h"
#include "arcane/core/VariableTypes.h"
 
#include "arcane/cartesianmesh/ICartesianMesh.h"
#include "arcane/cartesianmesh/CellDirectionMng.h"
#include "arcane/cartesianmesh/internal/ICartesianMeshInternal.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class FaceDirectionMng::Impl
{
 public:
 
  Impl()
  : m_infos(platform::getDefaultDataAllocator())
  {}
 
 public:
 
  FaceGroup m_inner_all_items;
  FaceGroup m_outer_all_items;
  FaceGroup m_inpatch_all_items;
  FaceGroup m_overlap_all_items;
  FaceGroup m_all_items;
  ICartesianMesh* m_cartesian_mesh = nullptr;
  Integer m_patch_index = -1;
  UniqueArray<ItemDirectionInfo> m_infos;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceDirectionMng::
FaceDirectionMng()
: m_direction(MD_DirInvalid)
, m_p(nullptr)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void FaceDirectionMng::
_internalInit(ICartesianMesh* cm, eMeshDirection dir, Integer patch_index)
{
  if (m_p)
    ARCANE_FATAL("Initialisation already done");
  m_p = new Impl();
  m_direction = dir;
  m_p->m_cartesian_mesh = cm;
  m_p->m_patch_index = patch_index;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void FaceDirectionMng::
_internalDestroy()
{
  delete m_p;
  m_p = nullptr;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void FaceDirectionMng::
_internalResizeInfos(Int32 new_size)
{
  m_p->m_infos.resize(new_size);
  m_infos_view = m_p->m_infos.view();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void FaceDirectionMng::
_internalComputeInfos(const CellDirectionMng& cell_dm, const VariableCellReal3& cells_center,
                      const VariableFaceReal3& faces_center)
{
  IMesh* mesh = m_p->m_cartesian_mesh->mesh();
  IItemFamily* face_family = mesh->faceFamily();
  IItemFamily* cell_family = mesh->cellFamily();
  int dir = (int)m_direction;
  String base_group_name = String("Direction") + dir;
  if (m_p->m_patch_index >= 0)
    base_group_name = base_group_name + String("AMRPatch") + m_p->m_patch_index;
 
  // Calculates the list of faces in a given direction.
  // For each cell, it is necessary to add to the list of faces
  // the two faces in the desired direction, taking care
  // not to add the same face twice.
  UniqueArray<Int32> faces_lid;
  {
    CellGroup all_cells = cell_dm.allCells();
    faces_lid.reserve(all_cells.size());
    // Set of faces already added
    UniqueArray<bool> done_faces(face_family->maxLocalId(), false);
    ENUMERATE_CELL (icell, all_cells) {
      DirCellFace dcf(cell_dm.cellFace(*icell));
      Face next_face = dcf.next();
      Face prev_face = dcf.previous();

      Int32 prev_lid = prev_face.localId();
      if (!done_faces[prev_lid]) {
        faces_lid.add(prev_lid);
        done_faces[prev_lid] = true;
      }
      Int32 next_lid = next_face.localId();
      if (!done_faces[next_lid]) {
        faces_lid.add(next_lid);
        done_faces[next_lid] = true;
      }
    }
  }
 
  FaceGroup all_faces = face_family->createGroup(String("AllFaces") + base_group_name, Int32ConstArrayView(), true);
  all_faces.setItems(faces_lid, true);
 
  UniqueArray<Int32> inner_lids;
  UniqueArray<Int32> outer_lids;
  ENUMERATE_FACE (iitem, all_faces) {
    Int32 lid = iitem.itemLocalId();
    Face face = *iitem;
    // TODO: do not use nbCell() but do this via the marker used previously
    if (face.nbCell() == 1)
      outer_lids.add(lid);
    else
      inner_lids.add(lid);
  }
  m_p->m_inner_all_items = face_family->createGroup(String("AllInner") + base_group_name, inner_lids, true);
  m_p->m_outer_all_items = face_family->createGroup(String("AllOuter") + base_group_name, outer_lids, true);
  m_p->m_all_items = all_faces;
  m_cells = CellInfoListView(cell_family);
 
  _computeCellInfos(cell_dm, cells_center, faces_center);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void FaceDirectionMng::
_internalComputeInfos(const CellDirectionMng& cell_dm)
{
  IMesh* mesh = m_p->m_cartesian_mesh->mesh();
  IItemFamily* face_family = mesh->faceFamily();
  IItemFamily* cell_family = mesh->cellFamily();
  int dir = (int)m_direction;
  String base_group_name = String("Direction") + dir;
  if (m_p->m_patch_index >= 0)
    base_group_name = base_group_name + String("AMRPatch") + m_p->m_patch_index;
 
  // Calculates the list of faces in a given direction.
  // For each cell, it is necessary to add to the list of faces
  // the two faces in the desired direction, taking care
  // not to add the same face twice.
  UniqueArray<Int32> faces_lid;
  {
    CellGroup all_cells = cell_dm.allCells();
    faces_lid.reserve(all_cells.size());
    // Set of faces already added
    UniqueArray<bool> done_faces(face_family->maxLocalId(), false);
    ENUMERATE_ (Cell, icell, all_cells) {
      DirCellFace dcf(cell_dm.cellFace(*icell));
      Face next_face = dcf.next();
      Face prev_face = dcf.previous();

      Int32 prev_lid = prev_face.localId();
      if (!done_faces[prev_lid]) {
        faces_lid.add(prev_lid);
        done_faces[prev_lid] = true;
      }
      Int32 next_lid = next_face.localId();
      if (!done_faces[next_lid]) {
        faces_lid.add(next_lid);
        done_faces[next_lid] = true;
      }
    }
  }
 
  FaceGroup all_faces = face_family->createGroup(String("AllFaces") + base_group_name, Int32ConstArrayView(), true);
  all_faces.setItems(faces_lid, true);
 
  UniqueArray<Int32> inner_cells_lid;
  UniqueArray<Int32> outer_cells_lid;
  cell_dm.innerCells().view().fillLocalIds(inner_cells_lid);
  cell_dm.outerCells().view().fillLocalIds(outer_cells_lid);
 
  UniqueArray<Int32> inner_lids;
  UniqueArray<Int32> outer_lids;
  UniqueArray<Int32> inpatch_lids;
  UniqueArray<Int32> overlap_lids;
  ENUMERATE_ (Face, iface, all_faces) {
    Int32 lid = iface.itemLocalId();
    Face face = *iface;
    if (face.nbCell() == 1) {
      if (inner_cells_lid.contains(face.cell(0).localId())) {
        inner_lids.add(lid);
        inpatch_lids.add(lid);
      }
      else if (outer_cells_lid.contains(face.cell(0).localId())) {
        outer_lids.add(lid);
        inpatch_lids.add(lid);
      }
      else {
        overlap_lids.add(lid);
      }
    }
    else {
      bool c0_inner_cell = inner_cells_lid.contains(face.cell(0).localId());
      bool c1_inner_cell = inner_cells_lid.contains(face.cell(1).localId());
      if (c0_inner_cell || c1_inner_cell) {
        inner_lids.add(lid);
        inpatch_lids.add(lid);
      }
      else {
        bool c0_outer_cell = outer_cells_lid.contains(face.cell(0).localId());
        bool c1_outer_cell = outer_cells_lid.contains(face.cell(1).localId());
        if (c0_outer_cell || c1_outer_cell) {
          outer_lids.add(lid);
          inpatch_lids.add(lid);
        }
        else {
          overlap_lids.add(lid);
        }
      }
    }
  }
  m_p->m_inner_all_items = face_family->createGroup(String("AllInner") + base_group_name, inner_lids, true);
  m_p->m_outer_all_items = face_family->createGroup(String("AllOuter") + base_group_name, outer_lids, true);
  m_p->m_inpatch_all_items = face_family->createGroup(String("AllInPatch") + base_group_name, inpatch_lids, true);
  m_p->m_overlap_all_items = face_family->createGroup(String("AllOverlap") + base_group_name, overlap_lids, true);
  m_p->m_all_items = all_faces;
  m_cells = CellInfoListView(cell_family);
 
  _computeCellInfos();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool FaceDirectionMng::
_hasFace(Cell cell, Int32 face_local_id) const
{
  for (FaceLocalId iface_lid : cell.faceIds()) {
    if (iface_lid == face_local_id)
      return true;
  }
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void FaceDirectionMng::
_computeCellInfos(const CellDirectionMng& cell_dm, const VariableCellReal3& cells_center,
                  const VariableFaceReal3& faces_center)
{
  eMeshDirection dir = m_direction;
 
  // Create the set of cells in the patch and use it
  // to ensure that every front/back cell is in
  // this set
  UniqueArray<bool> is_patch_cell(cell_dm.allCells().itemFamily()->maxLocalId(), false);
  ENUMERATE_CELL (icell, cell_dm.allCells()) {
    is_patch_cell[icell.itemLocalId()] = true;
  }
 
  ENUMERATE_FACE (iface, m_p->m_all_items) {
    Face face = *iface;
    Int32 face_lid = iface.itemLocalId();
    Real3 face_coord = faces_center[iface];
    Cell front_cell = face.frontCell();
    Cell back_cell = face.backCell();
 
    // Checks that the cells are in our patch.
    if (!front_cell.null())
      if (!is_patch_cell[front_cell.localId()])
        front_cell = Cell();
    if (!back_cell.null())
      if (!is_patch_cell[back_cell.localId()])
        back_cell = Cell();
 
    bool is_inverse = false;
    if (!front_cell.null()) {
      Real3 front_coord = cells_center[front_cell];
      if (dir == MD_DirX) {
        if (front_coord.x < face_coord.x)
          is_inverse = true;
      }
      else if (dir == MD_DirY) {
        if (front_coord.y < face_coord.y)
          is_inverse = true;
      }
      else if (dir == MD_DirZ) {
        if (front_coord.z < face_coord.z)
          is_inverse = true;
      }
    }
    else {
      Real3 back_coord = cells_center[back_cell];
      if (dir == MD_DirX) {
        if (back_coord.x > face_coord.x)
          is_inverse = true;
      }
      else if (dir == MD_DirY) {
        if (back_coord.y > face_coord.y)
          is_inverse = true;
      }
      else if (dir == MD_DirZ) {
        if (back_coord.z > face_coord.z)
          is_inverse = true;
      }
    }
    // If the face has two connected cells, look at the AMR level of these
    // two cells and if they are different, only keep the cell
    // whose AMR level is that of the face.
    if (!back_cell.null() && !front_cell.null()) {
      Int32 back_level = back_cell.level();
      Int32 front_level = front_cell.level();
      if (back_level != front_level) {
        // The face does not have its level information, but if the two
        // cells are not of the same level, the face belongs only to one
        // of the two cells. We therefore only keep that one.
        if (!_hasFace(back_cell, face_lid))
          back_cell = Cell();
        if (!_hasFace(front_cell, face_lid))
          front_cell = Cell();
      }
    }
    if (is_inverse)
      m_infos_view[face_lid] = ItemDirectionInfo(back_cell, front_cell);
    else
      m_infos_view[face_lid] = ItemDirectionInfo(front_cell, back_cell);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void FaceDirectionMng::
_computeCellInfos() const
{
  Ref<ICartesianMeshNumberingMngInternal> numbering = m_p->m_cartesian_mesh->_internalApi()->cartesianMeshNumberingMngInternal();
  eMeshDirection dir = m_direction;
  // ITraceMng* tm = m_p->m_cartesian_mesh->traceMng();
 
  ENUMERATE_ (Face, iface, m_p->m_all_items) {
    Face face = *iface;
    Cell front_cell = face.frontCell();
    Cell back_cell = face.backCell();
    // tm->info() << "FaceUID : " << face.uniqueId()
    //            << " -- backCellUID : " << back_cell.uniqueId()
    //            << " -- backCellLevel : " << back_cell.level()
    //            << " -- frontCellUID : " << front_cell.uniqueId()
    //            << " -- frontCellLevel : " << front_cell.level()
    //            << " -- dir : " << dir;
    bool is_inverse = false;
    if (!front_cell.null() && !back_cell.null()) {
 
      // If the face has two connected cells, look at the AMR level of these
      // two cells and if they are different, only keep the cell
      // whose AMR level is that of the face.
      Int32 front_cell_level = front_cell.level();
      Int32 back_cell_level = back_cell.level();
      if (front_cell_level != back_cell_level) {
        Int32 face_level = numbering->faceLevel(face.uniqueId());
        if (front_cell_level != face_level) {
          front_cell = Cell();
        }
        else {
          back_cell = Cell();
        }
      }
 
      if (back_cell.uniqueId() > front_cell.uniqueId()) {
        is_inverse = true;
      }
    }
    // The order of numbering is described in the file
    // CartesianMeshAMRPatchMng.cc (tag #priority_owner_2d).
    if (back_cell.null()) {
      Int64 uids[6];
      ArrayView av_uids(numbering->nbFaceByCell(), uids);
      numbering->cellFaceUniqueIds(front_cell, av_uids);
      if (m_p->m_cartesian_mesh->mesh()->dimension() == 2) {
        if (dir == MD_DirX) {
          if (face.uniqueId() == av_uids[1])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[3])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[3], face.uniqueId());
        }
        else if (dir == MD_DirY) {
          if (face.uniqueId() == av_uids[2])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[0])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[0], face.uniqueId());
        }
      }
      else if (m_p->m_cartesian_mesh->mesh()->dimension() == 3) {
        if (dir == MD_DirX) {
          if (face.uniqueId() == av_uids[4])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[1])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[1], face.uniqueId());
        }
        else if (dir == MD_DirY) {
          if (face.uniqueId() == av_uids[5])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[2])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[2], face.uniqueId());
        }
        else if (dir == MD_DirZ) {
          if (face.uniqueId() == av_uids[3])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[0])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[0], face.uniqueId());
        }
      }
    }
    else if (front_cell.null()) {
      Int64 uids[6];
      ArrayView av_uids(numbering->nbFaceByCell(), uids);
      numbering->cellFaceUniqueIds(back_cell, av_uids);
      if (m_p->m_cartesian_mesh->mesh()->dimension() == 2) {
        if (dir == MD_DirX) {
          if (face.uniqueId() == av_uids[3])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[1])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[1], face.uniqueId());
        }
        else if (dir == MD_DirY) {
          if (face.uniqueId() == av_uids[0])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[2])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[2], face.uniqueId());
        }
      }
      else if (m_p->m_cartesian_mesh->mesh()->dimension() == 3) {
        if (dir == MD_DirX) {
          if (face.uniqueId() == av_uids[1])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[4])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[4], face.uniqueId());
        }
        else if (dir == MD_DirY) {
          if (face.uniqueId() == av_uids[2])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[5])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[5], face.uniqueId());
        }
        else if (dir == MD_DirZ) {
          if (face.uniqueId() == av_uids[0])
            is_inverse = true;
          else if (face.uniqueId() != av_uids[3])
            ARCANE_FATAL("Bad connectivity, did you call computeDirection() ? -- Expected : {0} -- Found : {1}", av_uids[3], face.uniqueId());
        }
      }
    }
    // tm->info() << "FaceUID : " << face.uniqueId()
    //            << " -- backCellUID : " << back_cell.uniqueId()
    //            << " -- frontCellUID : " << front_cell.uniqueId()
    //            << " -- is_inverse : " << is_inverse
    //            << " -- dir : " << dir;
 
    if (is_inverse)
      m_infos_view[iface.itemLocalId()] = ItemDirectionInfo(back_cell, front_cell);
    else
      m_infos_view[iface.itemLocalId()] = ItemDirectionInfo(front_cell, back_cell);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup FaceDirectionMng::
allFaces() const
{
  return m_p->m_all_items;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup FaceDirectionMng::
overlapFaces() const
{
  return m_p->m_overlap_all_items;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup FaceDirectionMng::
inPatchFaces() const
{
  return m_p->m_inpatch_all_items;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup FaceDirectionMng::
innerFaces() const
{
  return m_p->m_inner_all_items;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
FaceGroup FaceDirectionMng::
outerFaces() const
{
  return m_p->m_outer_all_items;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/