refactor(dftu): rename 'locale' to 'occ_mat' in DFT+U tests and input docs

The DFTU tests and input parameter docs used 'locale' as a variable
and annotation name for the occupation matrix. This is confusing
because 'locale' is also a C++ standard library concept
(std::locale, localization). The actual physical quantity is the
occupation matrix n_{mm'}, so rename to 'occ_mat' for clarity and
consistency with the existing Plus_U_Base member 'occ_mat' and
'get_occ_mat()' accessor.

Renames (variable scope limited to tests + comments):
* dftu_pw_test.cpp: locale_c / locale_up / locale_dn -> occ_mat_c /
  occ_mat_up / occ_mat_dn (flattened occupation matrix passed to
  compute_pot_onsite_scalar); comments updated.
* dftu_core_test.cpp: function parameters locale_up / locale_dn ->
  occ_mat_up / occ_mat_dn (Matrix2D per-atom occupation matrices).
* dftu_lcao_op.cpp:192 comment 'Reads locale ...' -> 'Reads occ_mat ...'
* input_parameter.h:115 annotation 'mix locale' -> 'mix occ_mat'
  (parameter name 'mixing_dftu' unchanged, no INPUT behavior change).
* read_inp_estruc.cpp:760 annotation 'mix locale' -> 'mix occ_mat'

Out of scope (intentionally untouched):
* Plus_U_Base::occ_mat member -- already named 'occ_mat', no change.
* Non-DFTU 'locale' occurrences (input_parameter.h is touched only for
  the DFT+U annotation line).

Verification:
- rg '\blocale\b' over DFTU scope + module_parameter returns no matches.
- python3 tools/03_code_analysis/agent_governance_check.py --staged
  passes with no findings.

Test/Doc plan:
* Tests: pure rename of test-local variables and comments; no
  semantic change; existing tests in dftu_pw_test.cpp and
  dftu_core_test.cpp updated in lock-step.
* Docs: no INPUT parameter name change (still 'mixing_dftu'); only
  the annotation string is reworded for clarity. parameters.yaml
  and input-main.md do not mention 'locale' so no update required
  there.

Author: abacus_fixer

source/source_io/module_parameter/input_parameter.h

@@ -112,7 +112,7 @@ struct Input_para
     double mixing_gg0_min = 0.1;
     double mixing_angle = -10.0;
     bool mixing_tau = false;  ///< whether to mix tau in mgga
-    bool mixing_dftu = false; ///< whether to mix locale in DFT+U
+    bool mixing_dftu = false; ///< whether to mix occ_mat in DFT+U
     bool mixing_dmr = false;  ///< whether to mix real space density matrix
 
     bool gamma_only = false;   ///< for plane wave.

source/source_io/module_parameter/read_inp_estruc.cpp

@@ -757,7 +757,7 @@ This setting takes effect only when the selected exchange-correlation functional
     }
     {
         Input_Item item("mixing_dftu");
-        item.annotation = "whether to mix locale in DFT+U calculation";
+        item.annotation = "whether to mix occ_mat in DFT+U calculation";
         item.category = "Electronic structure";
         item.type = "Boolean";
         item.description = R"(Whether to mix the occupation matrices.

source/source_lcao/module_dftu/dftu_lcao_op.cpp

@@ -189,7 +189,7 @@ void hamilt::DFTU<hamilt::OperatorLCAO<TK, TR>>::cal_nlm_all(const Parallel_Orbi
  * Case 2: Occ_mat IS initialized (is_occ_mat_initialized, i.e., read from dm_onsite.txt file)
  *   - First electronic iteration: uses pre-read occ_mat directly without DMR calculation
  *     * Skips DMR-based occ calculation entirely
- *     * Reads locale from stored data via get_occ_mat()
+ *     * Reads occ_mat from stored data via get_occ_mat()
  *     * Different indexing for nspin=4 vs nspin=1/2 (see below)
  *   - After first iteration: mark_occ_mat_dirty() is called to force recomputation
  * 

source/source_lcao/module_dftu/test/dftu_core_test.cpp

@@ -104,81 +104,81 @@ struct Matrix2D {
 };
 
 static void copy_occ_mat_to_flat(
-    const std::vector<Matrix2D>& locale_up,
-    const std::vector<Matrix2D>& locale_dn,
+    const std::vector<Matrix2D>& occ_mat_up,
+    const std::vector<Matrix2D>& occ_mat_dn,
     std::vector<double>& uom_save,
     const std::vector<int>& pot_uterm_pw_index,
     int nspin)
 {
     if (nspin == 4)
     {
-        for (size_t iat = 0; iat < locale_up.size(); iat++)
+        for (size_t iat = 0; iat < occ_mat_up.size(); iat++)
         {
-            int size = locale_up[iat].nr * locale_up[iat].nc;
+            int size = occ_mat_up[iat].nr * occ_mat_up[iat].nc;
             for (int mm = 0; mm < size; mm++)
-                uom_save[pot_uterm_pw_index[iat] + mm] = locale_up[iat].data[mm];
+                uom_save[pot_uterm_pw_index[iat] + mm] = occ_mat_up[iat].data[mm];
         }
     }
     else if (nspin == 2) // split layout: [up | dn]
     {
         int half_size = uom_save.size() / 2;
-        for (size_t iat = 0; iat < locale_up.size(); iat++)
+        for (size_t iat = 0; iat < occ_mat_up.size(); iat++)
         {
-            int size = locale_up[iat].nr * locale_up[iat].nc;
+            int size = occ_mat_up[iat].nr * occ_mat_up[iat].nc;
             for (int mm = 0; mm < size; mm++)
             {
-                uom_save[pot_uterm_pw_index[iat] + mm] = locale_up[iat].data[mm];
-                uom_save[half_size + pot_uterm_pw_index[iat] + mm] = locale_dn[iat].data[mm];
+                uom_save[pot_uterm_pw_index[iat] + mm] = occ_mat_up[iat].data[mm];
+                uom_save[half_size + pot_uterm_pw_index[iat] + mm] = occ_mat_dn[iat].data[mm];
             }
         }
     }
     else // nspin=1: single spin channel
     {
-        for (size_t iat = 0; iat < locale_up.size(); iat++)
+        for (size_t iat = 0; iat < occ_mat_up.size(); iat++)
         {
-            int size = locale_up[iat].nr * locale_up[iat].nc;
+            int size = occ_mat_up[iat].nr * occ_mat_up[iat].nc;
             for (int mm = 0; mm < size; mm++)
-                uom_save[pot_uterm_pw_index[iat] + mm] = locale_up[iat].data[mm];
+                uom_save[pot_uterm_pw_index[iat] + mm] = occ_mat_up[iat].data[mm];
         }
     }
 }
 
 static void set_occ_mat_from_flat(
     const std::vector<double>& uom_array,
-    std::vector<Matrix2D>& locale_up,
-    std::vector<Matrix2D>& locale_dn,
+    std::vector<Matrix2D>& occ_mat_up,
+    std::vector<Matrix2D>& occ_mat_dn,
     const std::vector<int>& pot_uterm_pw_index,
     int nspin)
 {
     if (nspin == 4)
     {
-        for (size_t iat = 0; iat < locale_up.size(); iat++)
+        for (size_t iat = 0; iat < occ_mat_up.size(); iat++)
         {
-            int size = locale_up[iat].nr * locale_up[iat].nc;
+            int size = occ_mat_up[iat].nr * occ_mat_up[iat].nc;
             for (int mm = 0; mm < size; mm++)
-                locale_up[iat].data[mm] = uom_array[pot_uterm_pw_index[iat] + mm];
+                occ_mat_up[iat].data[mm] = uom_array[pot_uterm_pw_index[iat] + mm];
         }
     }
     else if (nspin == 2)
     {
         int half_size = uom_array.size() / 2;
-        for (size_t iat = 0; iat < locale_up.size(); iat++)
+        for (size_t iat = 0; iat < occ_mat_up.size(); iat++)
         {
-            int size = locale_up[iat].nr * locale_up[iat].nc;
+            int size = occ_mat_up[iat].nr * occ_mat_up[iat].nc;
             for (int mm = 0; mm < size; mm++)
             {
-                locale_up[iat].data[mm] = uom_array[pot_uterm_pw_index[iat] + mm];
-                locale_dn[iat].data[mm] = uom_array[half_size + pot_uterm_pw_index[iat] + mm];
+                occ_mat_up[iat].data[mm] = uom_array[pot_uterm_pw_index[iat] + mm];
+                occ_mat_dn[iat].data[mm] = uom_array[half_size + pot_uterm_pw_index[iat] + mm];
             }
         }
     }
     else // nspin=1
     {
-        for (size_t iat = 0; iat < locale_up.size(); iat++)
+        for (size_t iat = 0; iat < occ_mat_up.size(); iat++)
         {
-            int size = locale_up[iat].nr * locale_up[iat].nc;
+            int size = occ_mat_up[iat].nr * occ_mat_up[iat].nc;
             for (int mm = 0; mm < size; mm++)
-                locale_up[iat].data[mm] = uom_array[pot_uterm_pw_index[iat] + mm];
+                occ_mat_up[iat].data[mm] = uom_array[pot_uterm_pw_index[iat] + mm];
         }
     }
 }
@@ -195,38 +195,38 @@ TEST_F(OccMatRoundtripTest, Nspin1and2_SingleAndSplitLayout)
     const int l = 2;
     const int size = (2 * l + 1) * (2 * l + 1); // 25
 
-    std::vector<Matrix2D> locale_up(1, Matrix2D(2 * l + 1, 2 * l + 1));
-    std::vector<Matrix2D> locale_dn(1, Matrix2D(2 * l + 1, 2 * l + 1));
+    std::vector<Matrix2D> occ_mat_up(1, Matrix2D(2 * l + 1, 2 * l + 1));
+    std::vector<Matrix2D> occ_mat_dn(1, Matrix2D(2 * l + 1, 2 * l + 1));
     for (int i = 0; i < size; i++)
-        locale_up[0].data[i] = static_cast<double>(i + 1);
+        occ_mat_up[0].data[i] = static_cast<double>(i + 1);
 
     std::vector<int> pot_uterm_pw_index = {0};
     std::vector<double> uom_save(size, 0.0);
-    copy_occ_mat_to_flat(locale_up, locale_dn, uom_save, pot_uterm_pw_index, 1);
-    set_occ_mat_from_flat(uom_save, locale_up, locale_dn, pot_uterm_pw_index, 1);
+    copy_occ_mat_to_flat(occ_mat_up, occ_mat_dn, uom_save, pot_uterm_pw_index, 1);
+    set_occ_mat_from_flat(uom_save, occ_mat_up, occ_mat_dn, pot_uterm_pw_index, 1);
     for (int i = 0; i < size; i++)
-        EXPECT_DOUBLE_EQ(locale_up[0].data[i], static_cast<double>(i + 1));
+        EXPECT_DOUBLE_EQ(occ_mat_up[0].data[i], static_cast<double>(i + 1));
 
     // nspin=2: split layout [up | dn] with distinct values
     const int total = size * 2;
     for (int i = 0; i < size; i++)
     {
-        locale_up[0].data[i] = static_cast<double>(i + 1);
-        locale_dn[0].data[i] = static_cast<double>(i + 100);
+        occ_mat_up[0].data[i] = static_cast<double>(i + 1);
+        occ_mat_dn[0].data[i] = static_cast<double>(i + 100);
     }
     uom_save.assign(total, 0.0);
-    copy_occ_mat_to_flat(locale_up, locale_dn, uom_save, pot_uterm_pw_index, 2);
+    copy_occ_mat_to_flat(occ_mat_up, occ_mat_dn, uom_save, pot_uterm_pw_index, 2);
     // Verify split layout
     for (int i = 0; i < size; i++)
     {
         EXPECT_DOUBLE_EQ(uom_save[i], static_cast<double>(i + 1));
         EXPECT_DOUBLE_EQ(uom_save[size + i], static_cast<double>(i + 100));
     }
-    set_occ_mat_from_flat(uom_save, locale_up, locale_dn, pot_uterm_pw_index, 2);
+    set_occ_mat_from_flat(uom_save, occ_mat_up, occ_mat_dn, pot_uterm_pw_index, 2);
     for (int i = 0; i < size; i++)
     {
-        EXPECT_DOUBLE_EQ(locale_up[0].data[i], static_cast<double>(i + 1));
-        EXPECT_DOUBLE_EQ(locale_dn[0].data[i], static_cast<double>(i + 100));
+        EXPECT_DOUBLE_EQ(occ_mat_up[0].data[i], static_cast<double>(i + 1));
+        EXPECT_DOUBLE_EQ(occ_mat_dn[0].data[i], static_cast<double>(i + 100));
     }
 }
 
@@ -253,39 +253,39 @@ TEST_F(OccMatRoundtripTest, Nspin4_PauliBlocks)
         offset += sizes[i];
     }
 
-    std::vector<Matrix2D> locale(specs.size());
+    std::vector<Matrix2D> occ_mat(specs.size());
     for (size_t i = 0; i < specs.size(); i++)
     {
         int dim = (2 * specs[i].l + 1) * npol;
-        locale[i] = Matrix2D(dim, dim);
+        occ_mat[i] = Matrix2D(dim, dim);
         for (int j = 0; j < sizes[i]; j++)
-            locale[i].data[j] = static_cast<double>(i * 1000 + j + 1);
+            occ_mat[i].data[j] = static_cast<double>(i * 1000 + j + 1);
     }
 
     std::vector<double> uom_array(total, 0.0);
-    std::vector<Matrix2D> locale_dn(specs.size()); // unused for nspin=4
+    std::vector<Matrix2D> occ_mat_dn(specs.size()); // unused for nspin=4
 
-    copy_occ_mat_to_flat(locale, locale_dn, uom_array, pot_uterm_pw_index, 4);
-    set_occ_mat_from_flat(uom_array, locale, locale_dn, pot_uterm_pw_index, 4);
+    copy_occ_mat_to_flat(occ_mat, occ_mat_dn, uom_array, pot_uterm_pw_index, 4);
+    set_occ_mat_from_flat(uom_array, occ_mat, occ_mat_dn, pot_uterm_pw_index, 4);
 
     for (size_t i = 0; i < specs.size(); i++)
         for (int j = 0; j < sizes[i]; j++)
-            EXPECT_DOUBLE_EQ(locale[i].data[j], static_cast<double>(i * 1000 + j + 1));
+            EXPECT_DOUBLE_EQ(occ_mat[i].data[j], static_cast<double>(i * 1000 + j + 1));
 }
 
 // =====================================================================
 // 3. pot_onsite effective potential formula (cal_type=3, FLL)
 //
-// pot_onsite[m0,m1] = U * (0.5*delta(m0,m1) - locale[m0,m1])  (diagonal)
-// pot_onsite[m0,m1] = -U * locale[m0,m1]                       (off-diagonal)
+// pot_onsite[m0,m1] = U * (0.5*delta(m0,m1) - occ_mat[m0,m1])  (diagonal)
+// pot_onsite[m0,m1] = -U * occ_mat[m0,m1]                       (off-diagonal)
 // =====================================================================
 
-static double compute_pot_onsite(double U_val, int m0, int m1, double locale_val)
+static double compute_pot_onsite(double U_val, int m0, int m1, double occ_mat_val)
 {
     if (m0 == m1)
-        return U_val * (0.5 - locale_val);
+        return U_val * (0.5 - occ_mat_val);
     else
-        return -U_val * locale_val;
+        return -U_val * occ_mat_val;
 }
 
 class PotOnsitePotentialTest : public ::testing::Test
@@ -297,25 +297,25 @@ class PotOnsitePotentialTest : public ::testing::Test
 TEST_F(PotOnsitePotentialTest, Diagonal_HalfFilled)
 {
     double U = 4.0;
-    double locale = 0.5; // half-filled
-    double pot_onsite = compute_pot_onsite(U, 0, 0, locale);
+    double occ_mat = 0.5; // half-filled
+    double pot_onsite = compute_pot_onsite(U, 0, 0, occ_mat);
     EXPECT_DOUBLE_EQ(pot_onsite, 0.0); // U * (0.5 - 0.5) = 0
 }
 
 TEST_F(PotOnsitePotentialTest, Diagonal_FullyOccupied)
 {
     double U = 4.0;
-    double locale = 1.0; // fully occupied
-    double pot_onsite = compute_pot_onsite(U, 0, 0, locale);
+    double occ_mat = 1.0; // fully occupied
+    double pot_onsite = compute_pot_onsite(U, 0, 0, occ_mat);
     EXPECT_DOUBLE_EQ(pot_onsite, -2.0); // U * (0.5 - 1.0) = -2.0
 }
 
 TEST_F(PotOnsitePotentialTest, OffDiagonal)
 {
     double U = 5.0;
-    double locale = 0.3;
-    double pot_onsite = compute_pot_onsite(U, 0, 1, locale);
-    EXPECT_DOUBLE_EQ(pot_onsite, -1.5); // -U * locale = -1.5
+    double occ_mat = 0.3;
+    double pot_onsite = compute_pot_onsite(U, 0, 1, occ_mat);
+    EXPECT_DOUBLE_EQ(pot_onsite, -1.5); // -U * occ_mat = -1.5
 }
 
 // =====================================================================
@@ -327,14 +327,14 @@ TEST_F(PotOnsitePotentialTest, OffDiagonal)
 class EnergyCorrectionTest : public ::testing::Test
 {
   protected:
-    static double compute_energy(const std::vector<double>& locale_flat, int m_size, double U)
+    static double compute_energy(const std::vector<double>& occ_mat_flat, int m_size, double U)
     {
         double nm_trace = 0.0, nm2_trace = 0.0;
         for (int m0 = 0; m0 < m_size; m0++)
         {
-            nm_trace += locale_flat[m0 * m_size + m0];
+            nm_trace += occ_mat_flat[m0 * m_size + m0];
             for (int m1 = 0; m1 < m_size; m1++)
-                nm2_trace += locale_flat[m0 * m_size + m1] * locale_flat[m1 * m_size + m0];
+                nm2_trace += occ_mat_flat[m0 * m_size + m1] * occ_mat_flat[m1 * m_size + m0];
         }
         return 0.5 * U * (nm_trace - nm2_trace);
     }
@@ -343,24 +343,24 @@ class EnergyCorrectionTest : public ::testing::Test
 TEST_F(EnergyCorrectionTest, HalfFilled_DOrbital)
 {
     const int m_size = 5;
-    std::vector<double> locale(m_size * m_size, 0.0);
+    std::vector<double> occ_mat(m_size * m_size, 0.0);
     for (int m = 0; m < m_size; m++)
-        locale[m * m_size + m] = 0.5;
+        occ_mat[m * m_size + m] = 0.5;
 
-    double energy = compute_energy(locale, m_size, 4.0);
+    double energy = compute_energy(occ_mat, m_size, 4.0);
     // Tr(n) = 2.5, Tr(n^2) = 1.25, E = 0.5 * 4 * 1.25 = 2.5
     EXPECT_DOUBLE_EQ(energy, 2.5);
 }
 
 TEST_F(EnergyCorrectionTest, OffDiagonal_Contribution)
 {
     const int m_size = 2;
-    std::vector<double> locale = {
+    std::vector<double> occ_mat = {
         0.3, 0.1,
         0.1, 0.3
     };
 
-    double energy = compute_energy(locale, m_size, 4.0);
+    double energy = compute_energy(occ_mat, m_size, 4.0);
     // Tr(n) = 0.6, Tr(n^2) = 0.3^2 + 0.1^2 + 0.1^2 + 0.3^2 = 0.20
     // E = 0.5 * 4 * (0.6 - 0.20) = 0.8
     EXPECT_DOUBLE_EQ(energy, 0.8);
@@ -371,7 +371,7 @@ TEST_F(EnergyCorrectionTest, DoubleCounting_Energy)
     // E_dc = sum_{m1,m2,spin} pot_onsite[m1,m2] * n[m2,m1]
     const int m_size = 3;
     double U = 4.0;
-    std::vector<double> locale = {
+    std::vector<double> occ_mat = {
         0.5, 0.0, 0.0,
         0.0, 0.3, 0.0,
         0.0, 0.0, 0.2
@@ -381,9 +381,9 @@ TEST_F(EnergyCorrectionTest, DoubleCounting_Energy)
     for (int m1 = 0; m1 < m_size; m1++)
         for (int m2 = 0; m2 < m_size; m2++)
         {
-            double pot_onsite = (m1 == m2) ? U * (0.5 - locale[m1 * m_size + m2])
-                                   : -U * locale[m1 * m_size + m2];
-            e_dc += pot_onsite * locale[m2 * m_size + m1];
+            double pot_onsite = (m1 == m2) ? U * (0.5 - occ_mat[m1 * m_size + m2])
+                                   : -U * occ_mat[m1 * m_size + m2];
+            e_dc += pot_onsite * occ_mat[m2 * m_size + m1];
         }
 
     // Only diagonal: m=0: 0*0.5=0, m=1: 0.8*0.3=0.24, m=2: 1.2*0.2=0.24