Refactor vdW XC name normalization (consistent with what libdftd4 does)

Author: Growl1234

source/source_hamilt/module_vdw/CMakeLists.txt

@@ -1,4 +1,5 @@
 set(vdw_sources
+    vdw_xcname.cpp
     vdwd2_parameters.cpp
     vdwd2.cpp
     vdwd3_data.cpp

source/source_hamilt/module_vdw/test/vdw_test.cpp

@@ -425,6 +425,15 @@ TEST_F(vdwd3Test, D30GetEnergy)
     EXPECT_NEAR(ene, -0.022043153033290883, 1E-10);
 }
 
+TEST_F(vdwd3Test, D30LibxcFunctionalName)
+{
+    input.dft_functional = "XC_GGA_X_PBE+XC_GGA_C_PBE";
+
+    auto vdw_solver = vdw::make_vdw(ucell, input);
+    const vdw::VdwResult result = vdw_solver->evaluate(vdw::VdwRequest(false, false));
+    EXPECT_NEAR(result.energy, -0.022043153033290883, 1E-10);
+}
+
 TEST_F(vdwd3Test, D30GetForce)
 {
     auto vdw_solver = vdw::make_vdw(ucell, input);
@@ -678,6 +687,16 @@ TEST_F(vdwd4Test, D4GetEnergy)
     EXPECT_NEAR(ene, -0.049988405722573105, 1E-10);
 }
 
+TEST_F(vdwd4Test, D4LibxcFunctionalName)
+{
+    input.vdw_d4_xc = "default";
+    input.dft_functional = "XC_GGA_X_PBE+XC_GGA_C_PBE";
+
+    auto vdw_solver = vdw::make_vdw(ucell, input);
+    const vdw::VdwResult result = vdw_solver->evaluate(vdw::VdwRequest(false, false));
+    EXPECT_NEAR(result.energy, -0.049988405722573105, 1E-10);
+}
+
 TEST_F(vdwd4Test, D4GetEnergyForChargedSystem)
 {
     input.nelec = 7.0;

source/source_hamilt/module_vdw/test/vdwd3_evaluator_test.cpp

@@ -1,6 +1,7 @@
 #include "source_hamilt/module_vdw/vdwd3_data.h"
 #include "source_hamilt/module_vdw/vdwd3_evaluator.h"
 #include "source_hamilt/module_vdw/vdwd3_parameters.h"
+#include "source_hamilt/module_vdw/vdw_xcname.h"
 
 #include "gtest/gtest.h"
 
@@ -204,6 +205,18 @@ Structure x23_acetic()
 
 } // namespace
 
+TEST(VdwXcName, NormalizesAbacusAndLibxcSpellings)
+{
+    EXPECT_EQ(vdw::normalize_xc_name("PBE"), "pbe");
+    EXPECT_EQ(vdw::normalize_xc_name(" XC_HYB_GGA_XC_PBEH "), "hyb_gga_xc_pbeh");
+    EXPECT_EQ(vdw::normalize_xc_name("GGA_X_PBE+GGA_C_PBE"),
+              "gga_x_pbe:gga_c_pbe");
+    EXPECT_EQ(vdw::normalize_xc_name("XC_GGA_X_PBE + XC_GGA_C_PBE"),
+              "gga_x_pbe:gga_c_pbe");
+    EXPECT_EQ(vdw::normalize_xc_name("XC_GGA_X_PBE_R:XC_GGA_C_PBE"),
+              "gga_x_pbe_r:gga_c_pbe");
+}
+
 TEST(D3Parameters, PbeAndLibxcAliases)
 {
     Parameters zero;
@@ -236,6 +249,12 @@ TEST(D3Parameters, PbeAndLibxcAliases)
     EXPECT_EQ(canonical, "bop");
     EXPECT_DOUBLE_EQ(rational.a1, 0.487);
 
+    ASSERT_TRUE(vdw::d3::lookup_parameters("XC_GGA_X_PBE_R+XC_GGA_C_PBE",
+                                           Damping::Rational,
+                                           rational,
+                                           canonical));
+    EXPECT_EQ(canonical, "revpbe");
+
     // Legacy ABACUS LibXC spellings: the numerical parameter set is stored
     // under `wb97x` by s-dftd3, but only for the corresponding damping form.
     ASSERT_TRUE(vdw::d3::lookup_parameters("XC_HYB_GGA_XC_WB97X_V",

source/source_hamilt/module_vdw/vdw_xcname.cpp

@@ -0,0 +1,59 @@
+#include "vdw_xcname.h"
+
+#include <algorithm>
+#include <cctype>
+#include <string>
+
+namespace vdw
+{
+namespace
+{
+
+std::string trim_ascii(const std::string& value)
+{
+    const auto first = std::find_if_not(value.begin(), value.end(), [](unsigned char character) {
+        return std::isspace(character) != 0;
+    });
+    if (first == value.end())
+    {
+        return std::string();
+    }
+
+    const auto last = std::find_if_not(value.rbegin(), value.rend(), [](unsigned char character) {
+        return std::isspace(character) != 0;
+    }).base();
+    return std::string(first, last);
+}
+
+std::string normalize_component(std::string value)
+{
+    value = trim_ascii(value);
+    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char character) {
+        return static_cast<char>(std::tolower(character));
+    });
+
+    if (value.compare(0, 3, "xc_") == 0)
+    {
+        value.erase(0, 3);
+    }
+    return value;
+}
+
+} // namespace
+
+std::string normalize_xc_name(const std::string& input)
+{
+    const std::size_t plus = input.find('+');
+    const std::size_t colon = input.find(':');
+    const std::size_t separator = plus != std::string::npos ? plus : colon;
+
+    if (separator == std::string::npos)
+    {
+        return normalize_component(input);
+    }
+
+    return normalize_component(input.substr(0, separator)) + ":"
+           + normalize_component(input.substr(separator + 1));
+}
+
+} // namespace vdw

source/source_hamilt/module_vdw/vdw_xcname.h

@@ -0,0 +1,30 @@
+#ifndef ABACUS_VDW_XCNAME_H
+#define ABACUS_VDW_XCNAME_H
+
+#include <string>
+
+namespace vdw
+{
+
+/**
+ * @brief Normalize an XC-functional spelling at the ABACUS/libXC boundary.
+ *
+ * This function intentionally performs syntax normalization only. It lowercases
+ * ASCII names, removes an optional leading "XC_" from each libXC component,
+ * trims surrounding whitespace, and writes two-component libXC functionals
+ * with ':' as the separator used by libdftd4.
+ *
+ * Examples:
+ *   "PBE"                              -> "pbe"
+ *   "XC_HYB_GGA_XC_PBEH"              -> "hyb_gga_xc_pbeh"
+ *   "GGA_X_PBE+GGA_C_PBE"             -> "gga_x_pbe:gga_c_pbe"
+ *   "XC_GGA_X_PBE+XC_GGA_C_PBE"       -> "gga_x_pbe:gga_c_pbe"
+ *
+ * Semantic aliases (for example revPBE or damping-specific wB97X aliases)
+ * belong to the dispersion-model parameter layer rather than here.
+ */
+std::string normalize_xc_name(const std::string& input);
+
+} // namespace vdw
+
+#endif // ABACUS_VDW_XCNAME_H

source/source_hamilt/module_vdw/vdwd3_parameters.cpp

@@ -1,4 +1,5 @@
 #include "vdwd3_parameters.h"
+#include "vdw_xcname.h"
 
 #include <algorithm>
 #include <cctype>
@@ -72,9 +73,9 @@ std::string libxc_component(const std::string& component, const std::string& mar
 
 std::string canonicalize_libxc_pair(const std::string& input)
 {
-    const std::size_t plus = input.find('+');
-    std::string first = input.substr(0, plus);
-    std::string second = input.substr(plus + 1);
+    const std::size_t separator = input.find(':');
+    std::string first = input.substr(0, separator);
+    std::string second = input.substr(separator + 1);
     const std::string first_lower = lower_ascii(first);
     if (first_lower.find("_c_") != std::string::npos)
     {
@@ -92,25 +93,26 @@ std::string canonicalize_libxc_pair(const std::string& input)
     // libxc_component(). Only mixed exchange/correlation names need an
     // explicit mapping; identical component names are handled above.
     static const std::map<std::string, std::string> special = {
-        {"b88+lyp", "blyp"}, {"b88+p86", "bp86"},
-        {"b88+pbe", "bpbe"}, {"pber+pbe", "revpbe"},
-        {"rpbe+pbe", "rpbe"}, {"optx+lyp", "olyp"},
-        {"mpw91+pw91", "mpwpw"}, {"ms2+regtpss", "ms2"},
-        {"ms2h+regtpss", "ms2h"}, {"pbe+oppbe", "pbeop"},
-        {"b88+opb88", "bop"},
+        {"b88:p86", "bp86"},       {"b88:lyp", "blyp"},
+        {"b88:pbe", "bpbe"},       {"pber:pbe", "revpbe"},
+        {"rpbe:pbe", "rpbe"},      {"optx:lyp", "olyp"},
+        {"mpw91:pw91", "mpwpw"},  {"ms2:regtpss", "ms2"},
+        {"ms2h:regtpss", "ms2h"}, {"pbe:oppbe", "pbeop"},
+        {"b88:opb88", "bop"},
     };
-    const auto found = special.find(exchange + "+" + correlation);
+    const auto found = special.find(exchange + ":" + correlation);
     return found == special.end() ? std::string() : found->second;
 }
 
 } // namespace
 
 std::string canonicalize_method_name(const std::string& input)
 {
+    const std::string xc_name = normalize_xc_name(input);
     std::string canonical;
-    if (input.find('+') != std::string::npos)
+    if (xc_name.find(':') != std::string::npos)
     {
-        const std::string pair = canonicalize_libxc_pair(input);
+        const std::string pair = canonicalize_libxc_pair(xc_name);
         if (!pair.empty())
         {
             canonical = pair;
@@ -119,10 +121,9 @@ std::string canonicalize_method_name(const std::string& input)
 
     if (canonical.empty())
     {
-        const std::string lower = lower_ascii(input);
-        const std::size_t xc = lower.find("_xc_");
-        canonical = xc == std::string::npos ? normalized(input)
-                                             : normalized(input.substr(xc + 4));
+        const std::size_t xc = xc_name.find("_xc_");
+        canonical = xc == std::string::npos ? normalized(xc_name)
+                                             : normalized(xc_name.substr(xc + 4));
     }
 
     // ABACUS calls its HSE06 implementation "HSE" in user input and

source/source_hamilt/module_vdw/vdwd4.cpp

@@ -1,4 +1,5 @@
 #include "vdwd4.h"
+#include "vdw_xcname.h"
 
 #include "source_base/constants.h"
 #include "source_base/element_name.h"
@@ -81,7 +82,7 @@ double cutoff_to_bohr(const std::string& value, const std::string& unit)
 } // namespace
 
 Vdwd4::Vdwd4(const UnitCell& unit_in, const std::string& xc_name, const Input_para& input)
-    : Vdw(unit_in), xc_name_(to_lower(xc_name)), model_name_(to_lower(input.vdw_d4_model))
+    : Vdw(unit_in), xc_name_(normalize_xc_name(xc_name)), model_name_(to_lower(input.vdw_d4_model))
 {
     cutoff_disp2_ = cutoff_to_bohr(input.vdw_cutoff_radius, input.vdw_radius_unit);
     cutoff_disp3_ = std::min(40.0, cutoff_disp2_);