update

ESROAMER · ESROAMER · commit 472f6efee8a3 · 2025-07-09T18:52:02.000+08:00
diff --git a/docs/advanced/input_files/input-main.md b/docs/advanced/input_files/input-main.md
@@ -375,6 +375,8 @@
     - [out\_wannier\_unk](#out_wannier_unk)
     - [out\_wannier\_wvfn\_formatted](#out_wannier_wvfn_formatted)
   - [rt-TDDFT: Real-time time dependent density functional theory](#tddft-time-dependent-density-functional-theory)
+    - [estep\_per\_md](#estep_per_md)
+    - [td\_dt](#td_dt)
     - [td\_edm](#td_edm)
     - [td\_print\_eij](#td_print_eij)
     - [td\_propagator](#td_propagator)
@@ -3687,6 +3689,18 @@ These variables are used to control berry phase and wannier90 interface paramete
 
 ## TDDFT: time dependent density functional theory
 
+### estep_per_md
+
+- **Type**: Integer
+- **Description**: The number of electron propagation steps between two ionic steps.
+- **Default**: 1
+
+### td_dt
+
+- **Type**: Real
+- **Description**: The time step used in electron propagation. Setting td_dt will reset the md_dt value to td_dt * estep_per_md.
+- **Default**: md_dt/estep_per_md
+
 ### td_edm
 
 - **Type**: Integer
@@ -3739,6 +3753,7 @@ These variables are used to control berry phase and wannier90 interface paramete
   Type of electric field in space domain
   - 0: length gauge.
   - 1: velocity gauge.
+  - 2: hybrid gauge.
 - **Default**: 0
 
 ### td_ttype
diff --git a/source/source_esolver/esolver_ks_lcao_tddft.cpp b/source/source_esolver/esolver_ks_lcao_tddft.cpp
@@ -144,9 +144,9 @@ void ESolver_KS_LCAO_TDDFT<TR, Device>::runner(UnitCell& ucell, const int istep)
         {
             elecstate::H_TDDFT_pw::update_At();
             td_p->cal_cart_At(elecstate::H_TDDFT_pw::At);
-            ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Ax(t)", td_p->cart_At[0]);
-            ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Ay(t)", td_p->cart_At[1]);
-            ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Az(t)", td_p->cart_At[2]);
+            ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Ax(t)", TD_info::cart_At[0]);
+            ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Ay(t)", TD_info::cart_At[1]);
+            ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Az(t)", TD_info::cart_At[2]);
         }
 
         if(estep!=0)
@@ -588,7 +588,7 @@ void ESolver_KS_LCAO_TDDFT<TR, Device>::weight_dm_rho(const UnitCell& ucell)
     elecstate::cal_dm_psi(_pes->DM->get_paraV_pointer(), _pes->wg, this->psi[0], *(_pes->DM));
     if(PARAM.inp.td_stype == 2)
     {
-        _pes->DM->cal_DMR_td(ucell, td_p->cart_At);
+        _pes->DM->cal_DMR_td(ucell, TD_info::cart_At);
     }
     else
     {
diff --git a/source/source_io/td_current_io.cpp b/source/source_io/td_current_io.cpp
@@ -58,7 +58,7 @@ void ModuleIO::write_current(const UnitCell& ucell,
     {
         if (TD_info::td_vel_op == nullptr)
         {
-            ModuleBase::WARNING_QUIT("ModuleIO::write_current", "velocity gauge infos is null!");
+            ModuleBase::WARNING_QUIT("ModuleIO::write_current", "velocity gague infos is null!");
         }
         for (int dir = 0; dir < 3; dir++)
         {
@@ -250,12 +250,12 @@ void ModuleIO::cal_tmp_DM_k(const UnitCell& ucell,
                 double arg_td = 0.0;
                 if(elecstate::H_TDDFT_pw::stype == 2)
                 {
-                    //cal tddft phase for hybrid gauge
+                    //cal tddft phase for hybrid gague
                     const int iat1 = tmp_ap_real.get_atom_i();
                     const int iat2 = tmp_ap_real.get_atom_j();
                     ModuleBase::Vector3<double> dtau = ucell.cal_dtau(iat1, iat2, r_index);
                     double& tmp_lat0 = ucell.lat0;
-                    arg_td = TD_info::td_vel_op->cart_At * dtau * tmp_lat0;
+                    arg_td = TD_info::cart_At * dtau * tmp_lat0;
                 }
                 // cal k_phase
                 // if TK==std::complex<double>, kphase is e^{ikR}
@@ -320,12 +320,12 @@ void ModuleIO::cal_tmp_DM_k(const UnitCell& ucell,
                     if(elecstate::H_TDDFT_pw::stype == 2)
                     {
                         //new
-                        //cal tddft phase for mixing gauge
+                        //cal tddft phase for mixing gague
                         const int iat1 = tmp_ap_real.get_atom_i();
                         const int iat2 = tmp_ap_real.get_atom_j();
                         ModuleBase::Vector3<double> dtau = ucell.cal_dtau(iat1, iat2, r_index);
                         double& tmp_lat0 = ucell.lat0;
-                        arg_td = TD_info::td_vel_op->cart_At * dtau * tmp_lat0;
+                        arg_td = TD_info::cart_At * dtau * tmp_lat0;
                     }
                     const double arg = (DM_real.get_kvec_d()[ik] * dR) * ModuleBase::TWO_PI + arg_td;
                     double sinp, cosp;
@@ -424,7 +424,7 @@ void ModuleIO::write_current_eachk(const UnitCell& ucell,
     {
         if (TD_info::td_vel_op == nullptr)
         {
-            ModuleBase::WARNING_QUIT("ModuleIO::write_current", "velocity gauge infos is null!");
+            ModuleBase::WARNING_QUIT("ModuleIO::write_current", "velocity gague infos is null!");
         }
         for (int dir = 0; dir < 3; dir++)
         {
diff --git a/source/source_lcao/module_deepks/test/CMakeLists.txt b/source/source_lcao/module_deepks/test/CMakeLists.txt
@@ -37,6 +37,9 @@ add_executable(
     ../../../source_lcao/module_operator_lcao/deepks_lcao.cpp
     ../../../source_lcao/module_operator_lcao/operator_lcao.cpp
     ../../../source_hamilt/operator.cpp
+    ../../../source_lcao/module_rt/td_info.cpp
+    ../../../source_lcao/module_rt/td_folding.cpp
+    ../../../source_estate/module_pot/H_TDDFT_pw.cpp
 )
 
 target_link_libraries(
diff --git a/source/source_lcao/module_operator_lcao/operator_lcao.cpp b/source/source_lcao/module_operator_lcao/operator_lcao.cpp
@@ -13,6 +13,7 @@
 #endif
 
 #include "source_lcao/module_rt/td_info.h"
+#include "source_lcao/module_rt/td_folding.h"
 
 namespace hamilt {
 
@@ -268,7 +269,7 @@ void OperatorLCAO<TK, TR>::contributeHk(int ik) {
         const int nrow = this->hsk->get_pv()->get_row_size();
         if(PARAM.inp.td_stype == 2)
         {
-            TD_info::td_vel_op->folding_HR_td(*this->hR, this->hsk->get_hk(), this->kvec_d[ik], nrow, 1);
+            module_rt::folding_HR_td(*this->hR, this->hsk->get_hk(), this->kvec_d[ik], nrow, 1, TD_info::td_vel_op->get_ucell(), TD_info::cart_At);
         }
         else
         {
@@ -280,7 +281,7 @@ void OperatorLCAO<TK, TR>::contributeHk(int ik) {
         const int ncol = this->hsk->get_pv()->get_col_size();
         if(PARAM.inp.td_stype == 2)
         {
-            TD_info::td_vel_op->folding_HR_td(*this->hR, this->hsk->get_hk(), this->kvec_d[ik], ncol, 0);
+            module_rt::folding_HR_td(*this->hR, this->hsk->get_hk(), this->kvec_d[ik], ncol, 0, TD_info::td_vel_op->get_ucell(), TD_info::cart_At);
         }
         else
         {
diff --git a/source/source_lcao/module_operator_lcao/overlap_new.cpp b/source/source_lcao/module_operator_lcao/overlap_new.cpp
@@ -8,6 +8,7 @@
 #include "source_lcao/module_hcontainer/hcontainer_funcs.h"
 #include <vector>
 #include "source_lcao/module_rt/td_info.h"
+#include "source_lcao/module_rt/td_folding.h"
 
 template <typename TK, typename TR>
 hamilt::OverlapNew<hamilt::OperatorLCAO<TK, TR>>::OverlapNew(HS_Matrix_K<TK>* hsk_in,
@@ -231,7 +232,7 @@ void hamilt::OverlapNew<hamilt::OperatorLCAO<TK, TR>>::contributeHk(int ik)
         const int nrow = this->SR->get_atom_pair(0).get_paraV()->get_row_size();
         if(PARAM.inp.td_stype == 2)
         {
-            TD_info::td_vel_op->folding_HR_td(*this->SR, this->hsk->get_sk(), this->kvec_d[ik], nrow, 1);
+            module_rt::folding_HR_td(*this->SR, this->hsk->get_sk(), this->kvec_d[ik], nrow, 1, ucell, TD_info::cart_At);
         }
         else
         {
@@ -243,7 +244,7 @@ void hamilt::OverlapNew<hamilt::OperatorLCAO<TK, TR>>::contributeHk(int ik)
         const int ncol = this->SR->get_atom_pair(0).get_paraV()->get_col_size();
         if(PARAM.inp.td_stype == 2)
         {
-            TD_info::td_vel_op->folding_HR_td(*this->SR, this->hsk->get_sk(), this->kvec_d[ik], ncol, 0);
+            module_rt::folding_HR_td(*this->SR, this->hsk->get_sk(), this->kvec_d[ik], ncol, 0, ucell, TD_info::cart_At);
         }
         else
         {
diff --git a/source/source_lcao/module_operator_lcao/td_ekinetic_lcao.cpp b/source/source_lcao/module_operator_lcao/td_ekinetic_lcao.cpp
@@ -227,7 +227,7 @@ template <typename TK, typename TR>
 void TDEkinetic<OperatorLCAO<TK, TR>>::update_td()
 {
     //std::cout<<"velocity"<<std::endl;
-    this->cart_At = TD_info::td_vel_op->cart_At;
+    this->cart_At = TD_info::cart_At;
 }
 
 template <typename TK, typename TR>
diff --git a/source/source_lcao/module_operator_lcao/td_nonlocal_lcao.cpp b/source/source_lcao/module_operator_lcao/td_nonlocal_lcao.cpp
@@ -45,7 +45,7 @@ template <typename TK, typename TR>
 void hamilt::TDNonlocal<hamilt::OperatorLCAO<TK, TR>>::update_td()
 {
     // calculate At in cartesian coorinates.
-    this->cart_At = TD_info::td_vel_op->cart_At;
+    this->cart_At = TD_info::cart_At;
 }
 // initialize_HR()
 template <typename TK, typename TR>
diff --git a/source/source_lcao/module_operator_lcao/td_pot_hybrid.cpp b/source/source_lcao/module_operator_lcao/td_pot_hybrid.cpp
@@ -238,8 +238,8 @@ void hamilt::TD_pot_hybrid<hamilt::OperatorLCAO<TK, TR>>::init_td()
 template <typename TK, typename TR>
 void hamilt::TD_pot_hybrid<hamilt::OperatorLCAO<TK, TR>>::update_td()
 {
-    //std::cout<<"hybrid gauge" <<std::endl;
-    this->cart_At = TD_info::td_vel_op->cart_At;
+    //std::cout<<"hybrid gague" <<std::endl;
+    this->cart_At = TD_info::cart_At;
     //std::cout<<"At: "<< TD_info::td_vel_op->cart_At[0] <<" "<<TD_info::td_vel_op->cart_At[1]<<" "<<TD_info::td_vel_op->cart_At[2]<<" "<<std::endl;
     Et = elecstate::H_TDDFT_pw::Et;
 }
diff --git a/source/source_lcao/module_rt/td_folding.cpp b/source/source_lcao/module_rt/td_folding.cpp
@@ -1,11 +1,14 @@
-#include "td_info.h"
+#include "td_folding.h"
 #include "source_base/libm/libm.h"
+namespace module_rt{
 template<typename TR>
-void TD_info::folding_HR_td(const hamilt::HContainer<TR>& hR,
+void folding_HR_td(const hamilt::HContainer<TR>& hR,
                 std::complex<double>* hk,
                 const ModuleBase::Vector3<double>& kvec_d_in,
                 const int ncol,
-                const int hk_type)
+                const int hk_type,
+                const UnitCell& ucell,
+                const ModuleBase::Vector3<double>& cart_At)
 {
 #ifdef _OPENMP
 #pragma omp parallel for
@@ -18,11 +21,11 @@ void TD_info::folding_HR_td(const hamilt::HContainer<TR>& hR,
             const ModuleBase::Vector3<int> r_index = tmp.get_R_index(ir);
 
             //new
-            //cal tddft phase for hybrid gauge
+            //cal tddft phase for hybrid gague
             const int iat1 = tmp.get_atom_i();
             const int iat2 = tmp.get_atom_j();
-            ModuleBase::Vector3<double> dtau = ucell->cal_dtau(iat1, iat2, r_index);
-            const double arg_td = cart_At * dtau * ucell->lat0;
+            ModuleBase::Vector3<double> dtau = ucell.cal_dtau(iat1, iat2, r_index);
+            const double arg_td = cart_At * dtau * ucell.lat0;
             //new
 
             // cal k_phase
@@ -39,14 +42,19 @@ void TD_info::folding_HR_td(const hamilt::HContainer<TR>& hR,
     }
 }
 template
-void TD_info::folding_HR_td<double>(const hamilt::HContainer<double>& hR,
+void folding_HR_td<double>(const hamilt::HContainer<double>& hR,
                 std::complex<double>* hk,
                 const ModuleBase::Vector3<double>& kvec_d_in,
                 const int ncol,
-                const int hk_type);
+                const int hk_type,
+                const UnitCell& ucell,
+                const ModuleBase::Vector3<double>& At);
 template
-void TD_info::folding_HR_td<std::complex<double>>(const hamilt::HContainer<std::complex<double>>& hR,
+void folding_HR_td<std::complex<double>>(const hamilt::HContainer<std::complex<double>>& hR,
                 std::complex<double>* hk,
                 const ModuleBase::Vector3<double>& kvec_d_in,
                 const int ncol,
-                const int hk_type);
+                const int hk_type,
+                const UnitCell& ucell,
+                const ModuleBase::Vector3<double>& At);
+}// namespace module_rt
diff --git a/source/source_lcao/module_rt/td_folding.h b/source/source_lcao/module_rt/td_folding.h
@@ -0,0 +1,14 @@
+#ifndef TD_FOLDING_H
+#define TD_FOLDING_H
+
+namespace module_rt{
+// folding HR to hk, for hybrid gague
+template<typename TR>
+void folding_HR_td(const hamilt::HContainer<TR>& hR,
+            std::complex<double>* hk,
+            const ModuleBase::Vector3<double>& kvec_d_in,
+            const int ncol,
+            const int hk_type,
+            const UnitCell& ucell,
+            const ModuleBase::Vector3<double>& At);
+}// namespace module_rt
diff --git a/source/source_lcao/module_rt/td_info.cpp b/source/source_lcao/module_rt/td_info.cpp
@@ -15,6 +15,7 @@ TD_info* TD_info::td_vel_op = nullptr;
 int TD_info::estep_shift = 0;
 int TD_info::istep = -1;
 int TD_info::max_istep = -1;
+ModuleBase::Vector3<double> TD_info::cart_At;
 std::vector<ModuleBase::Vector3<double>> TD_info::At_from_file;
 
 TD_info::TD_info(const UnitCell* ucell_in)
@@ -28,11 +29,11 @@ TD_info::TD_info(const UnitCell* ucell_in)
     if(PARAM.inp.mdp.md_restart)
     {
         std::stringstream ssc;
-        ssc << PARAM.globalv.global_readin_dir << "Restart_td.txt";
+        ssc << PARAM.globalv.global_readin_dir << "Restart_td.dat";
         std::ifstream file(ssc.str().c_str());
         if (!file)
         {
-            ModuleBase::WARNING_QUIT("TD_info::TD_info", "No Restart_td.txt!");
+            ModuleBase::WARNING_QUIT("TD_info::TD_info", "No Restart_td.dat!");
         }
         file >> estep_shift;
         //std::cout<<"estep_shift"<<estep_shift<<std::endl;
@@ -92,12 +93,12 @@ void TD_info::cal_cart_At(const ModuleBase::Vector3<double>& At)
     istep++;
     if (init_vecpot_file)
     {
-        this->cart_At = At_from_file[istep > max_istep ? max_istep : istep];
+        cart_At = At_from_file[istep > max_istep ? max_istep : istep];
     }
     else
     {
         // transfrom into atomic unit
-        this->cart_At = At / 2.0;
+        cart_At = At / 2.0;
     }
     // output the vector potential if needed
     if (out_vecpot == true)
@@ -164,10 +165,10 @@ void TD_info::out_restart_info(const int nstep,
     if (GlobalV::MY_RANK == 0)
     {
         // open file
-        std::string outdir = PARAM.globalv.global_out_dir + "Restart_td.txt";
+        std::string outdir = PARAM.globalv.global_out_dir + "Restart_td.dat";
         std::ofstream outFile(outdir);
         if (!outFile) {
-            ModuleBase::WARNING_QUIT("out_restart_info", "no Restart_td.txt!");
+            ModuleBase::WARNING_QUIT("out_restart_info", "no Restart_td.dat!");
         }
         // write data
         outFile << nstep << std::endl;
diff --git a/source/source_lcao/module_rt/td_info.h b/source/source_lcao/module_rt/td_info.h
@@ -39,7 +39,7 @@ class TD_info
     static int estep_shift;
 
     /// @brief Store the vector potential for tddft calculation
-    ModuleBase::Vector3<double> cart_At;
+    static ModuleBase::Vector3<double> cart_At;
 
     /// @brief calculate the At in cartesian coordinate
     void cal_cart_At(const ModuleBase::Vector3<double>& At);
@@ -57,15 +57,6 @@ class TD_info
         return this->current_term[i];
     }
 
-
-    // folding HR to hk, for hybrid gauge
-    template<typename TR>
-    void folding_HR_td(const hamilt::HContainer<TR>& hR,
-                std::complex<double>* hk,
-                const ModuleBase::Vector3<double>& kvec_d_in,
-                const int ncol,
-                const int hk_type);
-
     int get_istep()
     {
       return istep;

Original file line number	Diff line number	Diff line change
`@@ -144,9 +144,9 @@ void ESolver_KS_LCAO_TDDFT<TR, Device>::runner(UnitCell& ucell, const int istep)`
`144`	`144`	`{`
`145`	`145`	`elecstate::H_TDDFT_pw::update_At();`
`146`	`146`	`td_p->cal_cart_At(elecstate::H_TDDFT_pw::At);`
`147`		`- ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Ax(t)", td_p->cart_At[0]);`
`148`		`- ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Ay(t)", td_p->cart_At[1]);`
`149`		`- ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Az(t)", td_p->cart_At[2]);`
	`147`	`+ ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Ax(t)", TD_info::cart_At[0]);`
	`148`	`+ ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Ay(t)", TD_info::cart_At[1]);`
	`149`	`+ ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "Cartesian vector potential Az(t)", TD_info::cart_At[2]);`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`if(estep!=0)`
`@@ -588,7 +588,7 @@ void ESolver_KS_LCAO_TDDFT<TR, Device>::weight_dm_rho(const UnitCell& ucell)`
`588`	`588`	`elecstate::cal_dm_psi(_pes->DM->get_paraV_pointer(), _pes->wg, this->psi[0], *(_pes->DM));`
`589`	`589`	`if(PARAM.inp.td_stype == 2)`
`590`	`590`	`{`
`591`		`- _pes->DM->cal_DMR_td(ucell, td_p->cart_At);`
	`591`	`+ _pes->DM->cal_DMR_td(ucell, TD_info::cart_At);`
`592`	`592`	`}`
`593`	`593`	`else`
`594`	`594`	`{`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ void ModuleIO::write_current(const UnitCell& ucell,`
`58`	`58`	`{`
`59`	`59`	`if (TD_info::td_vel_op == nullptr)`
`60`	`60`	`{`
`61`		`- ModuleBase::WARNING_QUIT("ModuleIO::write_current", "velocity gauge infos is null!");`
	`61`	`+ ModuleBase::WARNING_QUIT("ModuleIO::write_current", "velocity gague infos is null!");`
`62`	`62`	`}`
`63`	`63`	`for (int dir = 0; dir < 3; dir++)`
`64`	`64`	`{`
`@@ -250,12 +250,12 @@ void ModuleIO::cal_tmp_DM_k(const UnitCell& ucell,`
`250`	`250`	`double arg_td = 0.0;`
`251`	`251`	`if(elecstate::H_TDDFT_pw::stype == 2)`
`252`	`252`	`{`
`253`		`- //cal tddft phase for hybrid gauge`
	`253`	`+ //cal tddft phase for hybrid gague`
`254`	`254`	`const int iat1 = tmp_ap_real.get_atom_i();`
`255`	`255`	`const int iat2 = tmp_ap_real.get_atom_j();`
`256`	`256`	`ModuleBase::Vector3<double> dtau = ucell.cal_dtau(iat1, iat2, r_index);`
`257`	`257`	`double& tmp_lat0 = ucell.lat0;`
`258`		`- arg_td = TD_info::td_vel_op->cart_At * dtau * tmp_lat0;`
	`258`	`+ arg_td = TD_info::cart_At * dtau * tmp_lat0;`
`259`	`259`	`}`
`260`	`260`	`// cal k_phase`
`261`	`261`	`// if TK==std::complex<double>, kphase is e^{ikR}`
`@@ -320,12 +320,12 @@ void ModuleIO::cal_tmp_DM_k(const UnitCell& ucell,`
`320`	`320`	`if(elecstate::H_TDDFT_pw::stype == 2)`
`321`	`321`	`{`
`322`	`322`	`//new`
`323`		`- //cal tddft phase for mixing gauge`
	`323`	`+ //cal tddft phase for mixing gague`
`324`	`324`	`const int iat1 = tmp_ap_real.get_atom_i();`
`325`	`325`	`const int iat2 = tmp_ap_real.get_atom_j();`
`326`	`326`	`ModuleBase::Vector3<double> dtau = ucell.cal_dtau(iat1, iat2, r_index);`
`327`	`327`	`double& tmp_lat0 = ucell.lat0;`
`328`		`- arg_td = TD_info::td_vel_op->cart_At * dtau * tmp_lat0;`
	`328`	`+ arg_td = TD_info::cart_At * dtau * tmp_lat0;`
`329`	`329`	`}`
`330`	`330`	`const double arg = (DM_real.get_kvec_d()[ik] * dR) * ModuleBase::TWO_PI + arg_td;`
`331`	`331`	`double sinp, cosp;`
`@@ -424,7 +424,7 @@ void ModuleIO::write_current_eachk(const UnitCell& ucell,`
`424`	`424`	`{`
`425`	`425`	`if (TD_info::td_vel_op == nullptr)`
`426`	`426`	`{`
`427`		`- ModuleBase::WARNING_QUIT("ModuleIO::write_current", "velocity gauge infos is null!");`
	`427`	`+ ModuleBase::WARNING_QUIT("ModuleIO::write_current", "velocity gague infos is null!");`
`428`	`428`	`}`
`429`	`429`	`for (int dir = 0; dir < 3; dir++)`
`430`	`430`	`{`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,9 @@ add_executable(`
`37`	`37`	`../../../source_lcao/module_operator_lcao/deepks_lcao.cpp`
`38`	`38`	`../../../source_lcao/module_operator_lcao/operator_lcao.cpp`
`39`	`39`	`../../../source_hamilt/operator.cpp`
	`40`	`+ ../../../source_lcao/module_rt/td_info.cpp`
	`41`	`+ ../../../source_lcao/module_rt/td_folding.cpp`
	`42`	`+ ../../../source_estate/module_pot/H_TDDFT_pw.cpp`
`40`	`43`	`)`
`41`	`44`
`42`	`45`	`target_link_libraries(`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@`
`13`	`13`	`#endif`
`14`	`14`
`15`	`15`	`#include "source_lcao/module_rt/td_info.h"`
	`16`	`+#include "source_lcao/module_rt/td_folding.h"`
`16`	`17`
`17`	`18`	`namespace hamilt {`
`18`	`19`
`@@ -268,7 +269,7 @@ void OperatorLCAO<TK, TR>::contributeHk(int ik) {`
`268`	`269`	`const int nrow = this->hsk->get_pv()->get_row_size();`
`269`	`270`	`if(PARAM.inp.td_stype == 2)`
`270`	`271`	`{`
`271`		`- TD_info::td_vel_op->folding_HR_td(*this->hR, this->hsk->get_hk(), this->kvec_d[ik], nrow, 1);`
	`272`	`+ module_rt::folding_HR_td(*this->hR, this->hsk->get_hk(), this->kvec_d[ik], nrow, 1, TD_info::td_vel_op->get_ucell(), TD_info::cart_At);`
`272`	`273`	`}`
`273`	`274`	`else`
`274`	`275`	`{`
`@@ -280,7 +281,7 @@ void OperatorLCAO<TK, TR>::contributeHk(int ik) {`
`280`	`281`	`const int ncol = this->hsk->get_pv()->get_col_size();`
`281`	`282`	`if(PARAM.inp.td_stype == 2)`
`282`	`283`	`{`
`283`		`- TD_info::td_vel_op->folding_HR_td(*this->hR, this->hsk->get_hk(), this->kvec_d[ik], ncol, 0);`
	`284`	`+ module_rt::folding_HR_td(*this->hR, this->hsk->get_hk(), this->kvec_d[ik], ncol, 0, TD_info::td_vel_op->get_ucell(), TD_info::cart_At);`
`284`	`285`	`}`
`285`	`286`	`else`
`286`	`287`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`#include "source_lcao/module_hcontainer/hcontainer_funcs.h"`
`9`	`9`	`#include <vector>`
`10`	`10`	`#include "source_lcao/module_rt/td_info.h"`
	`11`	`+#include "source_lcao/module_rt/td_folding.h"`
`11`	`12`
`12`	`13`	`template <typename TK, typename TR>`
`13`	`14`	`hamilt::OverlapNew<hamilt::OperatorLCAO<TK, TR>>::OverlapNew(HS_Matrix_K<TK>* hsk_in,`
`@@ -231,7 +232,7 @@ void hamilt::OverlapNew<hamilt::OperatorLCAO<TK, TR>>::contributeHk(int ik)`
`231`	`232`	`const int nrow = this->SR->get_atom_pair(0).get_paraV()->get_row_size();`
`232`	`233`	`if(PARAM.inp.td_stype == 2)`
`233`	`234`	`{`
`234`		`- TD_info::td_vel_op->folding_HR_td(*this->SR, this->hsk->get_sk(), this->kvec_d[ik], nrow, 1);`
	`235`	`+ module_rt::folding_HR_td(*this->SR, this->hsk->get_sk(), this->kvec_d[ik], nrow, 1, ucell, TD_info::cart_At);`
`235`	`236`	`}`
`236`	`237`	`else`
`237`	`238`	`{`
`@@ -243,7 +244,7 @@ void hamilt::OverlapNew<hamilt::OperatorLCAO<TK, TR>>::contributeHk(int ik)`
`243`	`244`	`const int ncol = this->SR->get_atom_pair(0).get_paraV()->get_col_size();`
`244`	`245`	`if(PARAM.inp.td_stype == 2)`
`245`	`246`	`{`
`246`		`- TD_info::td_vel_op->folding_HR_td(*this->SR, this->hsk->get_sk(), this->kvec_d[ik], ncol, 0);`
	`247`	`+ module_rt::folding_HR_td(*this->SR, this->hsk->get_sk(), this->kvec_d[ik], ncol, 0, ucell, TD_info::cart_At);`
`247`	`248`	`}`
`248`	`249`	`else`
`249`	`250`	`{`
Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ template <typename TK, typename TR>`
`227`	`227`	`void TDEkinetic<OperatorLCAO<TK, TR>>::update_td()`
`228`	`228`	`{`
`229`	`229`	`//std::cout<<"velocity"<<std::endl;`
`230`		`- this->cart_At = TD_info::td_vel_op->cart_At;`
	`230`	`+ this->cart_At = TD_info::cart_At;`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`template <typename TK, typename TR>`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ template <typename TK, typename TR>`
`45`	`45`	`void hamilt::TDNonlocal<hamilt::OperatorLCAO<TK, TR>>::update_td()`
`46`	`46`	`{`
`47`	`47`	`// calculate At in cartesian coorinates.`
`48`		`- this->cart_At = TD_info::td_vel_op->cart_At;`
	`48`	`+ this->cart_At = TD_info::cart_At;`
`49`	`49`	`}`
`50`	`50`	`// initialize_HR()`
`51`	`51`	`template <typename TK, typename TR>`
Original file line number	Diff line number	Diff line change
`@@ -238,8 +238,8 @@ void hamilt::TD_pot_hybrid<hamilt::OperatorLCAO<TK, TR>>::init_td()`
`238`	`238`	`template <typename TK, typename TR>`
`239`	`239`	`void hamilt::TD_pot_hybrid<hamilt::OperatorLCAO<TK, TR>>::update_td()`
`240`	`240`	`{`
`241`		`- //std::cout<<"hybrid gauge" <<std::endl;`
`242`		`- this->cart_At = TD_info::td_vel_op->cart_At;`
	`241`	`+ //std::cout<<"hybrid gague" <<std::endl;`
	`242`	`+ this->cart_At = TD_info::cart_At;`
`243`	`243`	`//std::cout<<"At: "<< TD_info::td_vel_op->cart_At[0] <<" "<<TD_info::td_vel_op->cart_At[1]<<" "<<TD_info::td_vel_op->cart_At[2]<<" "<<std::endl;`
`244`	`244`	`Et = elecstate::H_TDDFT_pw::Et;`
`245`	`245`	`}`