decomposition_neighbors.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#pragma once
 
#include <map>
#include <openpfc/core/decomposition.hpp>
#include <openpfc/core/types.hpp>
#include <optional>
 
namespace pfc {
namespace decomposition {
 
inline int get_neighbor_rank(const Decomposition &decomp, int rank,
                             const Int3 &direction) {
  const auto &grid = get_grid(decomp);
  int num_domains = get_num_domains(decomp);
 
  if (rank < 0 || rank >= num_domains) {
    return -1; // Invalid rank
  }
 
  // Convert rank to 3D grid coordinates
  int rank_z = rank / (grid[0] * grid[1]);
  int rank_y = (rank % (grid[0] * grid[1])) / grid[0];
  int rank_x = rank % grid[0];
 
  // Calculate neighbor coordinates
  int neighbor_x = rank_x + direction[0];
  int neighbor_y = rank_y + direction[1];
  int neighbor_z = rank_z + direction[2];
 
  // Wrap around for periodic boundary conditions
  // This ensures every rank has neighbors in all directions
  neighbor_x = (neighbor_x + grid[0]) % grid[0];
  neighbor_y = (neighbor_y + grid[1]) % grid[1];
  neighbor_z = (neighbor_z + grid[2]) % grid[2];
 
  // Convert neighbor coordinates back to rank
  int neighbor_rank =
      neighbor_z * (grid[0] * grid[1]) + neighbor_y * grid[0] + neighbor_x;
 
  return neighbor_rank;
}
 
inline std::map<Int3, int> find_face_neighbors(const Decomposition &decomp,
                                               int rank) {
  std::map<Int3, int> neighbors;
 
  // 6 face directions: ±X, ±Y, ±Z
  std::vector<Int3> directions = {{1, 0, 0},  {-1, 0, 0}, {0, 1, 0},
                                  {0, -1, 0}, {0, 0, 1},  {0, 0, -1}};
 
  for (const auto &dir : directions) {
    int neighbor_rank = get_neighbor_rank(decomp, rank, dir);
    // With periodic boundaries, neighbor_rank is always valid (>= 0)
    neighbors[dir] = neighbor_rank;
  }
 
  return neighbors;
}
 
inline std::map<Int3, int> find_all_neighbors(const Decomposition &decomp,
                                              int rank) {
  std::map<Int3, int> neighbors;
 
  // All 26 directions in 3D: {-1,0,1} × {-1,0,1} × {-1,0,1} excluding {0,0,0}
  for (int dx = -1; dx <= 1; ++dx) {
    for (int dy = -1; dy <= 1; ++dy) {
      for (int dz = -1; dz <= 1; ++dz) {
        if (dx == 0 && dy == 0 && dz == 0) {
          continue; // Skip self
        }
 
        Int3 direction{dx, dy, dz};
        int neighbor_rank = get_neighbor_rank(decomp, rank, direction);
        // With periodic boundaries, neighbor_rank is always valid (>= 0)
        neighbors[direction] = neighbor_rank;
      }
    }
  }
 
  return neighbors;
}
 
} // namespace decomposition
} // namespace pfc