test(integration): add parallel scaling tests

Add domain decomposition, global coverage, and halo pattern
tests to validate MPI decomposition and halo exchange.

- Tagged [integration][parallel_scaling][mpi]

Author: ahojukka5

tests/integration/scenarios/parallel_scaling/test_domain_decomposition.cpp

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+#include <catch2/catch_test_macros.hpp>
+#include <mpi.h>
+#include <openpfc/core/decomposition.hpp>
+#include <openpfc/core/world.hpp>
+#include <openpfc/fft.hpp>
+
+using namespace pfc;
+
+TEST_CASE("Domain decomposition basic properties",
+          "[integration][mpi][decomposition]") {
+  int rank = 0, size = 1;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  auto world = world::uniform(32, 1.0);
+  auto decomp = decomposition::create(world, size);
+  auto fft = fft::create(decomp);
+
+  // Validate local subdomain for this rank
+  const auto &local_world = decomposition::get_subworld(decomp, rank);
+  auto local_size = world::get_size(local_world);
+  REQUIRE(local_size[0] > 0);
+  REQUIRE(local_size[1] > 0);
+  REQUIRE(local_size[2] > 0);
+
+  // Inbox size matches local domain cell count
+  const std::size_t local_cells = static_cast<std::size_t>(local_size[0]) *
+                                  static_cast<std::size_t>(local_size[1]) *
+                                  static_cast<std::size_t>(local_size[2]);
+  REQUIRE(fft.size_inbox() == local_cells);
+}

tests/integration/scenarios/parallel_scaling/test_global_coverage.cpp

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+#include <catch2/catch_test_macros.hpp>
+#include <mpi.h>
+#include <openpfc/core/decomposition.hpp>
+#include <openpfc/core/world.hpp>
+
+using namespace pfc;
+
+TEST_CASE("Global coverage equals sum of local coverage",
+          "[integration][mpi][decomposition]") {
+  int rank = 0, size = 1;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  auto world = world::uniform(24, 1.0);
+  auto decomp = decomposition::create(world, size);
+
+  const auto &local_world = decomposition::get_subworld(decomp, rank);
+  auto local_size = world::get_size(local_world);
+  long long local_cells = static_cast<long long>(local_size[0]) *
+                          static_cast<long long>(local_size[1]) *
+                          static_cast<long long>(local_size[2]);
+
+  long long global_sum = 0;
+  MPI_Allreduce(&local_cells, &global_sum, 1, MPI_LONG_LONG, MPI_SUM,
+                MPI_COMM_WORLD);
+
+  auto global_size = world::get_size(world);
+  long long global_cells = static_cast<long long>(global_size[0]) *
+                           static_cast<long long>(global_size[1]) *
+                           static_cast<long long>(global_size[2]);
+
+  if (rank == 0) {
+    REQUIRE(global_sum == global_cells);
+  }
+
+  // Every rank should have non-zero local coverage when size > 1
+  if (size > 1) {
+    REQUIRE(local_cells > 0);
+  } else {
+    SUCCEED("Single rank run - multi-rank coverage check skipped");
+  }
+}

tests/integration/scenarios/parallel_scaling/test_halo_patterns.cpp

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+#include <catch2/catch_test_macros.hpp>
+#include <mpi.h>
+#include <openpfc/core/decomposition.hpp>
+#include <openpfc/core/halo_pattern.hpp>
+#include <openpfc/core/world.hpp>
+
+using namespace pfc;
+
+TEST_CASE("Halo send/recv sizes match expected face areas",
+          "[integration][mpi][halo]") {
+  int rank = 0, size = 1;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  auto world = world::uniform(24, 1.0);
+  auto decomp = decomposition::create(world, size);
+
+  const auto &local_world = decomposition::get_subworld(decomp, rank);
+  auto local_size = world::get_size(local_world);
+  auto local_lower = world::get_lower(local_world);
+  auto local_upper = world::get_upper(local_world);
+
+  const int halo_width = 1;
+  auto patterns = halo::create_halo_patterns(decomp, rank, halo::Connectivity::Faces,
+                                             halo_width);
+
+  for (const auto &entry : patterns) {
+    const auto &dir = entry.first;
+    const auto &send_recv = entry.second;
+    const auto &send = send_recv.first;
+    const auto &recv = send_recv.second;
+
+    // Expected indices count based on direction
+    // Compute lengths directly from bounds used by halo implementation
+    const long long nx = static_cast<long long>(local_upper[0] - local_lower[0]);
+    const long long ny = static_cast<long long>(local_upper[1] - local_lower[1]);
+    const long long nz = static_cast<long long>(local_upper[2] - local_lower[2]);
+
+    long long expected = 0;
+    if (dir[0] != 0) {
+      expected = static_cast<long long>(halo_width) * ny * nz;
+    } else if (dir[1] != 0) {
+      expected = nx * static_cast<long long>(halo_width) * nz;
+    } else if (dir[2] != 0) {
+      expected = nx * ny * static_cast<long long>(halo_width);
+    }
+
+    REQUIRE(static_cast<long long>(send.size()) == expected);
+    REQUIRE(static_cast<long long>(recv.size()) == expected);
+  }
+}