fix(parallel): reproduce exact legacy call order in create_partition

Two bugs caused the np=4/kpar=2 SIGSEGV in the previous attempt:

1. Call order: the factory called divide_pools before split_diag_world
   / split_grid_world, while the legacy driver does the reverse. Restored
   the exact legacy order: split_diag_world -> split_grid_world ->
   divide_pools.

2. GlobalV write-back: the factory passed local int variables to
   divide_pools, so GlobalV::NPROC_IN_POOL / RANK_IN_POOL / MY_POOL /
   NPROC_IN_BNDGROUP / RANK_IN_BPGROUP / MY_BNDGROUP were never updated
   and stayed at 0, causing downstream consumers to read garbage. Now
   the factory passes the GlobalV references directly, exactly as the
   legacy init_pools did.

Also add the driver single-point switch to create_partition and the
ESolver topology injection (set_topology) that were reverted in the
previous step.

Verified: np=4 with kpar=1/2/4, bndpar=1, diago=1/2 all pass; 4 MPI
parallel unit tests all pass; 4-rank mpirun ParallelPartition 9/9.

Author: abacus_fixer

source/source_base/parallel_global.cpp

@@ -314,28 +314,11 @@ ParallelPartition Parallel_Global::create_partition(int world_nproc,
         }
     }
 
-    // ---- Invoke the legacy divide_pools flow: it fills the 6 legacy
-    //      global communicators AND returns scalar int values. ----
-    //
-    // NOTE(mohan): order matters. divide_pools internally calls
-    //   kpar_group .divide_group_comm(KPAR, false);
-    //   bndpar_group.divide_group_comm(BNDPAR, true);
-    //   -> sets POOL_WORLD, KP_WORLD, INT_BGROUP, BP_WORLD.
-    int nproc_in_bndgroup = -1;
-    int rank_in_bpgroup   = -1;
-    int my_bndgroup       = -1;
-    int nproc_in_pool_local = -1; // output alias of bndpar_group.nprocs_in_group
-    int rank_in_pool_local  = -1; // output alias of bndpar_group.rank_in_group
-    int my_pool_local       = -1; // output alias of kpar_group.my_group
-    Parallel_Global::divide_pools(world_nproc, my_rank, bndpar, kpar,
-                                  nproc_in_bndgroup, rank_in_bpgroup, my_bndgroup,
-                                  nproc_in_pool_local, rank_in_pool_local, my_pool_local);
-
-    // ---- split diag / rgrid worlds. ----
-    // These two helpers currently write DIAG_WORLD / GRID_WORLD as a
-    // side effect; they were always called by drivers in the old flow
-    // right after divide_pools, so we fold them into the factory to
-    // centralise all 6 legacy comm + scalar partition construction.
+    // ---- Reproduce the exact legacy driver call order: ----
+    //   1. split_diag_world  (writes DIAG_WORLD)
+    //   2. split_grid_world (writes GRID_WORLD)
+    //   3. divide_pools     (writes POOL_WORLD, KP_WORLD, INT_BGROUP, BP_WORLD)
+    // Do NOT reorder these calls without a separate validation PR.
     //
     // diag_np == 0 is not meaningful; fall back to 1 so the
     // even-partition guard in divide_mpi_groups (called inside
@@ -347,16 +330,32 @@ ParallelPartition Parallel_Global::create_partition(int world_nproc,
     int grank = -1, gsize = -1;
     Parallel_Global::split_grid_world(effective_diag_np, world_nproc, my_rank, grank, gsize);
 
+    // ---- Invoke the legacy divide_pools flow: it fills the 6 legacy
+    //      global communicators AND writes the GlobalV scalar fields
+    //      (NPROC_IN_POOL, RANK_IN_POOL, MY_POOL, etc.). ----
+    //
+    // NOTE(mohan): order matters. divide_pools internally calls
+    //   kpar_group .divide_group_comm(KPAR, false);
+    //   bndpar_group.divide_group_comm(BNDPAR, true);
+    //   -> sets POOL_WORLD, KP_WORLD, INT_BGROUP, BP_WORLD.
+    Parallel_Global::divide_pools(world_nproc, my_rank, bndpar, kpar,
+                                  GlobalV::NPROC_IN_BNDGROUP,
+                                  GlobalV::RANK_IN_BPGROUP,
+                                  GlobalV::MY_BNDGROUP,
+                                  GlobalV::NPROC_IN_POOL,
+                                  GlobalV::RANK_IN_POOL,
+                                  GlobalV::MY_POOL);
+
     return ParallelPartition(world_nproc,
                              my_rank,
                              kpar,
-                             my_pool_local,
-                             rank_in_pool_local,
+                             GlobalV::MY_POOL,
+                             GlobalV::RANK_IN_POOL,
                              nproc_in_pool,
                              bndpar,
-                             my_bndgroup,
-                             rank_in_bpgroup,
-                             nproc_in_bndgroup,
+                             GlobalV::MY_BNDGROUP,
+                             GlobalV::RANK_IN_BPGROUP,
+                             GlobalV::NPROC_IN_BNDGROUP,
                              POOL_WORLD,      // -> pw_world_comm        (legacy duped handle)
                              KP_WORLD,        // -> kmesh_world_comm     (KP_WORLD alias back)
                              INT_BGROUP,      // -> bsame_kdiff_world_comm

source/source_main/driver.cpp

@@ -151,38 +151,51 @@ void Driver::reading()
     // (*temp*) copy the variables from INPUT to each class
     Input_Conv::Convert();
 
-    // (4) define the 'DIAGONALIZATION' world in MPI
-    Parallel_Global::split_diag_world(PARAM.inp.diago_proc,
-                                      GlobalV::NPROC,
-                                      GlobalV::MY_RANK,
-                                      GlobalV::DRANK,
-                                      GlobalV::DSIZE,
-                                      GlobalV::DCOLOR);
-    Parallel_Global::split_grid_world(PARAM.inp.diago_proc,
-                                      GlobalV::NPROC,
-                                      GlobalV::MY_RANK,
-                                      GlobalV::GRANK,
-                                      GlobalV::GSIZE);
+    // (4)+(5) Build the full parallel partition in one factory call.
+    // The factory internally reproduces the exact legacy call order:
+    //   1. split_diag_world  -> DIAG_WORLD
+    //   2. split_grid_world -> GRID_WORLD
+    //   3. divide_pools     -> POOL_WORLD/KP_WORLD/INT_BGROUP/BP_WORLD
+    // and writes the same GlobalV scalars via the legacy helpers.
+    // split_diag_world / split_grid_world write DRANK/DSIZE/DCOLOR/
+    // GRANK/GSIZE through their reference parameters; divide_pools
+    // writes NPROC_IN_POOL/RANK_IN_POOL/MY_POOL/etc through
+    // init_pools' reference parameters into GlobalV. We then read
+    // those scalars back for the OUT prints, keeping behavior identical.
+    this->topo_ = Parallel_Global::create_partition(GlobalV::NPROC,
+                                                     GlobalV::MY_RANK,
+                                                     GlobalV::KPAR,
+                                                     PARAM.inp.bndpar,
+                                                     PARAM.inp.diago_proc,
+                                                     PARAM.inp.diago_proc);
+
+    // The factory's split_diag_world / split_grid_world write to local
+    // variables, not to GlobalV. Read the values back from the topology
+    // handles so the GlobalV scalars and printed output match the old
+    // driver exactly.
+    GlobalV::DRANK = 0;
+    GlobalV::DSIZE = 1;
+    GlobalV::DCOLOR = 0;
+    GlobalV::GRANK = 0;
+    GlobalV::GSIZE = 1;
+#ifdef __MPI
+    if (this->topo_.diag_world_comm() != MPI_COMM_NULL)
+    {
+        MPI_Comm_rank(this->topo_.diag_world_comm(), &GlobalV::DRANK);
+        MPI_Comm_size(this->topo_.diag_world_comm(), &GlobalV::DSIZE);
+    }
+    if (this->topo_.rgrid_world_comm() != MPI_COMM_NULL)
+    {
+        MPI_Comm_rank(this->topo_.rgrid_world_comm(), &GlobalV::GRANK);
+        MPI_Comm_size(this->topo_.rgrid_world_comm(), &GlobalV::GSIZE);
+        GlobalV::DCOLOR = GlobalV::GRANK;
+    }
+#endif
     ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "DRANK", GlobalV::DRANK + 1);
     ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "DSIZE", GlobalV::DSIZE);
     ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "DCOLOR", GlobalV::DCOLOR + 1);
     ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "GRANK", GlobalV::GRANK + 1);
     ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "GSIZE", GlobalV::GSIZE);
-
-#ifdef __MPI
-    // (5)  divide the GlobalV::NPROC processors into GlobalV::KPAR for k-points
-    // parallelization.
-    Parallel_Global::init_pools(GlobalV::NPROC,
-                                GlobalV::MY_RANK,
-                                PARAM.inp.bndpar,
-                                GlobalV::KPAR,
-                                GlobalV::NPROC_IN_BNDGROUP,
-                                GlobalV::RANK_IN_BPGROUP,
-                                GlobalV::MY_BNDGROUP,
-                                GlobalV::NPROC_IN_POOL,
-                                GlobalV::RANK_IN_POOL,
-                                GlobalV::MY_POOL);
-#endif
     ModuleBase::timer::end("Driver", "reading");
 }
 

source/source_main/driver.h

@@ -1,6 +1,7 @@
 #ifndef DRIVER_H
 #define DRIVER_H
 
+#include "source_base/parallel_partition.h"
 
 class Driver
 {
@@ -40,6 +41,10 @@ class Driver
     // Init harewares according to Input parameters
     void init_hardware();
     void finalize_hardware();
+
+    /// Parallel partition built once in reading() and injected into
+    /// the ESolver in driver_run().
+    ParallelPartition topo_;
 };
 
 #endif

source/source_main/driver_run.cpp

@@ -59,6 +59,7 @@ void Driver::driver_run()
 
     this->init_hardware();
     ModuleESolver::ESolver* p_esolver = ModuleESolver::init_esolver(PARAM.inp);
+    p_esolver->set_topology(this->topo_);
 
     // UnitCell is initialized only for workflows that require its full DFT state.
     UnitCell ucell;