rename: lr_init_xc_kernel

Author: maki49

docs/advanced/input_files/input-main.md

@@ -3917,7 +3917,7 @@ These parameters are used to solve the excited states using. e.g. LR-TDDFT.
 Currently supported: `RPA`, `LDA`, `PBE`, `HSE`, `HF`.
 - **Default**: LDA
 
-### init_xc_kernel
+### lr_init_xc_kernel
 
 - **Type**: String
 - **Description**: The method to initalize the xc kernel. 

source/module_io/read_input_item_tddft.cpp

@@ -310,17 +310,17 @@ void ReadInput::item_lr_tddft()
         this->add_item(item);
     }
     {
-        Input_Item item("init_xc_kernel");
+        Input_Item item("lr_init_xc_kernel");
         item.annotation = "The method to initalize the xc kernel";
         item.read_value = [](const Input_Item& item, Parameter& para) {
             size_t count = item.get_size();
-            auto& ifxc = para.input.init_xc_kernel;
+            auto& ifxc = para.input.lr_init_xc_kernel;
             for (int i = 0; i < count; i++) { ifxc.push_back(item.str_values[i]); }
             };
         item.reset_value = [](const Input_Item& item, Parameter& para) {
-            if (para.input.init_xc_kernel.empty()) { para.input.init_xc_kernel.push_back("from_chg_groundstate"); }
+            if (para.input.lr_init_xc_kernel.empty()) { para.input.lr_init_xc_kernel.push_back("from_chg_groundstate"); }
             };
-        sync_stringvec(input.init_xc_kernel, para.input.init_xc_kernel.size(), "from_chg_groundstate");
+        sync_stringvec(input.lr_init_xc_kernel, para.input.lr_init_xc_kernel.size(), "from_chg_groundstate");
         this->add_item(item);
     }
     {

source/module_io/test/read_input_ptest.cpp

@@ -417,7 +417,7 @@ TEST_F(InputParaTest, ParaRead)
     EXPECT_EQ(param.inp.nocc, param.inp.nbands);
     EXPECT_EQ(param.inp.nvirt, 1);
     EXPECT_EQ(param.inp.xc_kernel, "LDA");
-    EXPECT_EQ(param.inp.init_xc_kernel[0], "from_chg_groundstate");
+    EXPECT_EQ(param.inp.lr_init_xc_kernel[0], "from_chg_groundstate");
     EXPECT_EQ(param.inp.lr_solver, "dav");
     EXPECT_DOUBLE_EQ(param.inp.lr_thr, 1e-2);
     EXPECT_FALSE(param.inp.lr_unrestricted);

source/module_lr/esolver_lrtd_lcao.cpp

@@ -603,11 +603,11 @@ void LR::ESolver_LR<T, TR>::init_pot(const Charge& chg_gs)
     {
         using ST = PotHxcLR::SpinType;
     case 1:
-        this->pot[0] = std::make_shared<PotHxcLR>(xc_kernel, this->pw_rho, &ucell, &chg_gs, GlobalC::Pgrid, ST::S1, input.init_xc_kernel);
+        this->pot[0] = std::make_shared<PotHxcLR>(xc_kernel, this->pw_rho, &ucell, &chg_gs, GlobalC::Pgrid, ST::S1, input.lr_init_xc_kernel);
         break;
     case 2:
-        this->pot[0] = std::make_shared<PotHxcLR>(xc_kernel, this->pw_rho, &ucell, &chg_gs, GlobalC::Pgrid, openshell ? ST::S2_updown : ST::S2_singlet, input.init_xc_kernel);
-        this->pot[1] = std::make_shared<PotHxcLR>(xc_kernel, this->pw_rho, &ucell, &chg_gs, GlobalC::Pgrid, openshell ? ST::S2_updown : ST::S2_triplet, input.init_xc_kernel);
+        this->pot[0] = std::make_shared<PotHxcLR>(xc_kernel, this->pw_rho, &ucell, &chg_gs, GlobalC::Pgrid, openshell ? ST::S2_updown : ST::S2_singlet, input.lr_init_xc_kernel);
+        this->pot[1] = std::make_shared<PotHxcLR>(xc_kernel, this->pw_rho, &ucell, &chg_gs, GlobalC::Pgrid, openshell ? ST::S2_updown : ST::S2_triplet, input.lr_init_xc_kernel);
         break;
     default:
         throw std::invalid_argument("ESolver_LR: nspin must be 1 or 2");

source/module_lr/potentials/pot_hxc_lrtd.cpp

@@ -15,7 +15,7 @@ namespace LR
     // constructor for exchange-correlation kernel
     PotHxcLR::PotHxcLR(const std::string& xc_kernel_in, const ModulePW::PW_Basis* rho_basis_in, const UnitCell* ucell_in,
         const Charge* chg_gs/*ground state*/, const Parallel_Grid& pgrid,
-        const SpinType& st_in, const std::vector<std::string>& init_xc_kernel)
+        const SpinType& st_in, const std::vector<std::string>& lr_init_xc_kernel)
         :xc_kernel(xc_kernel_in), tpiba_(ucell_in->tpiba), spin_type_(st_in),
         xc_kernel_components_(*rho_basis_in)
     {
@@ -32,20 +32,20 @@ namespace LR
             this->xc_type_ = XCType(XC_Functional::get_func_type());
             this->set_integral_func(this->spin_type_, this->xc_type_);
 
-            if (init_xc_kernel[0] == "file")
+            if (lr_init_xc_kernel[0] == "file")
             {
                 std::set<std::string> lda_xc = { "lda", "pwlda" };
                 assert(lda_xc.count(this->xc_kernel));
                 const int spinsize = (1 == nspin) ? 1 : 3;
                 std::vector<double> v2rho2(spinsize * nrxx);
                 // read fxc adn add to xc_kernel_components
-                assert(init_xc_kernel.size() >= spinsize + 1);
+                assert(lr_init_xc_kernel.size() >= spinsize + 1);
                 for (int is = 0;is < spinsize;++is)
                 {
                     double ef = 0.0;
                     int prenspin = 1;
                     std::vector<double> v2rho2_tmp(nrxx);
-                    ModuleIO::read_vdata_palgrid(pgrid, GlobalV::MY_RANK, GlobalV::ofs_running, init_xc_kernel[is + 1],
+                    ModuleIO::read_vdata_palgrid(pgrid, GlobalV::MY_RANK, GlobalV::ofs_running, lr_init_xc_kernel[is + 1],
                         v2rho2_tmp.data(), ucell_in->nat);
                     for (int ir = 0;ir < nrxx;++ir) { v2rho2[ir * spinsize + is] = v2rho2_tmp[ir]; }
                 }
@@ -54,16 +54,16 @@ namespace LR
             }
 
 #ifdef USE_LIBXC
-            if (init_xc_kernel[0] == "from_chg_file")
+            if (lr_init_xc_kernel[0] == "from_chg_file")
             {
-                assert(init_xc_kernel.size() >= 2);
+                assert(lr_init_xc_kernel.size() >= 2);
                 double** rho_for_fxc;
                 LR_Util::new_p2(rho_for_fxc, nspin, nrxx);
                 double ef = 0.0;
                 int prenspin = 1;
                 for (int is = 0;is < nspin;++is)
                 {
-                    const std::string file = init_xc_kernel[init_xc_kernel.size() > nspin ? 1 + is : 1];
+                    const std::string file = lr_init_xc_kernel[lr_init_xc_kernel.size() > nspin ? 1 + is : 1];
                     ModuleIO::read_vdata_palgrid(pgrid, GlobalV::MY_RANK, GlobalV::ofs_running, file,
                         rho_for_fxc[is], ucell_in->nat);
                 }

source/module_lr/potentials/pot_hxc_lrtd.h

@@ -20,7 +20,7 @@ namespace LR
         /// constructor for exchange-correlation kernel
         PotHxcLR(const std::string& xc_kernel_in, const ModulePW::PW_Basis* rho_basis_in,
             const UnitCell* ucell_in, const Charge* chg_gs/*ground state*/, const Parallel_Grid& pgrid,
-            const SpinType& st_in = SpinType::S1, const std::vector<std::string>& init_xc_kernel = { "from_chg_groundstate" });
+            const SpinType& st_in = SpinType::S1, const std::vector<std::string>& lr_init_xc_kernel = { "from_chg_groundstate" });
         ~PotHxcLR() {}
         void cal_v_eff(const Charge* chg/*excited state*/, const UnitCell* ucell, ModuleBase::matrix& v_eff) override {};
         void cal_v_eff(double** rho, const UnitCell* ucell, ModuleBase::matrix& v_eff, const std::vector<int>& ispin_op = { 0,0 });

source/module_parameter/input_parameter.h

@@ -296,7 +296,7 @@ struct Input_para
 
     // ==============   #Parameters (10.lr-tddft) ===========================
     int lr_nstates = 1; ///< the number of 2-particle states to be solved
-    std::vector<std::string> init_xc_kernel = {};    ///< The method to initalize the xc kernel
+    std::vector<std::string> lr_init_xc_kernel = {};    ///< The method to initalize the xc kernel
     int nocc = -1;      ///< the number of occupied orbitals to form the 2-particle basis
     int nvirt = 1;      ///< the number of virtual orbitals to form the 2-particle basis (nocc + nvirt <= nbands)
     std::string xc_kernel = "LDA"; ///< exchange correlation (XC) kernel for LR-TDDFT