Add runtime validation for ELPA complex BLOCK2 kernels

Author: Growl1234

source/source_hsolver/module_genelpa/CMakeLists.txt

@@ -1,4 +1,10 @@
-add_library(genelpa OBJECT elpa_new.cpp elpa_new_real.cpp elpa_new_complex.cpp utils.cpp)
+add_library(genelpa OBJECT
+  elpa_new.cpp
+  elpa_new_real.cpp
+  elpa_new_complex.cpp
+  elpa_runtime_check.cpp
+  utils.cpp
+)
 
 if(ENABLE_COVERAGE)
   add_coverage(genelpa)

source/source_hsolver/module_genelpa/elpa_new.cpp

@@ -1,15 +1,19 @@
 #include "elpa_new.h"
 
+#include "elpa_runtime_check.h"
+
 #include "elpa_solver.h"
 extern "C"
 {
 #include "Cblacs.h"
 }
 #include "utils.h"
+#include "source_base/tool_quit.h"
 #include <cfloat>
 #include <complex>
 #include <cstring>
 #include <fstream>
+#include <iomanip>
 #include <iostream>
 #include <map>
 #include <mpi.h>
@@ -208,11 +212,71 @@ void ELPA_Solver::setLoglevel(int loglevel)
 void ELPA_Solver::setKernel(bool isReal, int kernel)
 {
     this->kernel_id = kernel;
-    int error;
+    int error = ELPA_OK;
     if (isReal)
+    {
         elpa_set(NEW_ELPA_HANDLE_POOL[handle_id], "real_kernel", kernel, &error);
+    }
     else
+    {
         elpa_set(NEW_ELPA_HANDLE_POOL[handle_id], "complex_kernel", kernel, &error);
+    }
+
+    int local_set_failed = error == ELPA_OK ? 0 : 1;
+    int any_set_failed = 0;
+    MPI_Allreduce(&local_set_failed, &any_set_failed, 1, MPI_INT, MPI_MAX, comm);
+    if (any_set_failed != 0)
+    {
+        ModuleBase::WARNING_QUIT("ELPA_Solver::setKernel",
+                                 "Failed to select the requested ELPA kernel on at least one MPI rank.");
+    }
+
+    if (isReal)
+    {
+        return;
+    }
+
+    int local_check_required = needs_elpa_complex_block2_runtime_check(kernel) ? 1 : 0;
+    int any_check_required = 0;
+    MPI_Allreduce(&local_check_required, &any_check_required, 1, MPI_INT, MPI_MAX, comm);
+    if (any_check_required == 0)
+    {
+        return;
+    }
+
+    ElpaRuntimeCheckResult result{true, 0.0, 0.0};
+    if (local_check_required != 0)
+    {
+        static std::map<int, ElpaRuntimeCheckResult> checked_kernels;
+        std::map<int, ElpaRuntimeCheckResult>::iterator it = checked_kernels.find(kernel);
+        if (it == checked_kernels.end())
+        {
+            const ElpaRuntimeCheckResult checked_result = check_elpa_complex_block2_kernel(kernel);
+            it = checked_kernels.emplace(kernel, checked_result).first;
+        }
+        result = it->second;
+    }
+
+    int local_failed = result.passed ? 0 : 1;
+    int any_failed = 0;
+    MPI_Allreduce(&local_failed, &any_failed, 1, MPI_INT, MPI_MAX, comm);
+
+    if (any_failed != 0)
+    {
+        double max_residual = result.max_residual;
+        double max_orthogonality = result.orthogonality;
+        MPI_Allreduce(MPI_IN_PLACE, &max_residual, 1, MPI_DOUBLE, MPI_MAX, comm);
+        MPI_Allreduce(MPI_IN_PLACE, &max_orthogonality, 1, MPI_DOUBLE, MPI_MAX, comm);
+
+        std::ostringstream message;
+        message << "The selected ELPA complex 2-stage BLOCK2 kernel failed a runtime correctness check. "
+                << "The linked ELPA library may return incorrect eigenvectors. "
+                << "Maximum residual = " << std::scientific << std::setprecision(6) << max_residual
+                << ", orthogonality error = " << max_orthogonality << ". "
+                << "Please rebuild ELPA, select a BLOCK1 kernel, or use another eigensolver. "
+                << "For ELPA built with GCC 15.2, -fno-tree-slp-vectorize is a known workaround.";
+        ModuleBase::WARNING_QUIT("ELPA_Solver::setKernel", message.str());
+    }
 }
 
 void ELPA_Solver::setQR(int useQR)