ABACUS develop
Atomic-orbital Based Ab-initio Computation at UStc
Loading...
Searching...
No Matches
ewald_Vq.hpp
Go to the documentation of this file.
1//=======================
2// AUTHOR : jiyy
3// DATE : 2024-03-08
4//=======================
5
6#ifndef EWALD_VQ_HPP
7#define EWALD_VQ_HPP
8
9#include <RI/comm/mix/Communicate_Tensors_Map_Judge.h>
10#include <RI/distribute/Distribute_Equally.h>
11#include <RI/global/Global_Func-1.h>
12
13// #include <chrono>
14#include "RI_2D_Comm.h"
15#include "RI_Util.h"
16#include "conv_coulomb_pot_k.h"
17#include "exx_abfs-construct_orbs.h"
18#include "gaussian_abfs.h"
19#include "source_basis/module_ao/element_basis_index-ORB.h"
20#include "source_base/element_basis_index.h"
21#include "source_base/timer.h"
22#include "source_base/tool_title.h"
23#include "singular_value.h"
24
25#include <cmath>
26
27template<typename Tdata>
28Ewald_Vq<Tdata>::Ewald_Vq(){}
29
30template<typename Tdata>
31Ewald_Vq<Tdata>::~Ewald_Vq(){}
32
33template <typename Tdata>
34void Ewald_Vq<Tdata>::init(const UnitCell& ucell,
35 const LCAO_Orbitals& orb,
36 const MPI_Comm& mpi_comm_in,
37 const K_Vectors* kv_in,
38 std::vector<std::vector<std::vector<Numerical_Orbital_Lm>>>& lcaos_in,
39 std::vector<std::vector<std::vector<Numerical_Orbital_Lm>>>& abfs_in,
40 const std::map<Conv_Coulomb_Pot_K::Coulomb_Type, std::vector<std::map<std::string,std::string>>> &coulomb_param_in,
41 std::shared_ptr<ORB_gaunt_table> MGT_in,
42 const double &ccp_rmesh_times_in,
43 const double &kmesh_times_in)
44{
45 ModuleBase::TITLE("Ewald_Vq", "init");
46 ModuleBase::timer::start("Ewald_Vq", "init");
47
48 this->mpi_comm = mpi_comm_in;
49 this->p_kv = kv_in;
50 this->nks0 = this->p_kv->get_nkstot_full();
51 this->kvec_c.resize(this->nks0);
52 this->ccp_rmesh_times = ccp_rmesh_times_in;
53 this->coulomb_param = coulomb_param_in;
54
55 this->g_lcaos = this->init_gauss(lcaos_in);
56 this->g_abfs = this->init_gauss(abfs_in);
57 this->g_abfs_ccp = Conv_Coulomb_Pot_K::cal_orbs_ccp(this->g_abfs,
58 this->coulomb_param,
59 this->ccp_rmesh_times);
60 this->multipole = Exx_Abfs::Construct_Orbs::get_multipole(abfs_in);
61 this->lcaos_rcut = Exx_Abfs::Construct_Orbs::get_Rcut(lcaos_in);
62 this->g_lcaos_rcut = Exx_Abfs::Construct_Orbs::get_Rcut(this->g_lcaos);
63 this->g_abfs_ccp_rcut = Exx_Abfs::Construct_Orbs::get_Rcut(this->g_abfs_ccp);
64
65 const ModuleBase::Element_Basis_Index::Range range_abfs = ModuleBase::Element_Basis_Index::construct_range(abfs_in);
66 this->index_abfs = ModuleBase::Element_Basis_Index::construct_index(range_abfs);
67
68 this->cv
69 .set_orbitals(ucell, orb, this->g_lcaos, this->g_abfs, this->g_abfs_ccp, kmesh_times_in, MGT_in, false);
70 this->gaunt.create(MGT_in->Gaunt_Coefficients.getBound1(),
71 MGT_in->Gaunt_Coefficients.getBound2(),
72 MGT_in->Gaunt_Coefficients.getBound3());
73 this->gaunt = MGT_in->Gaunt_Coefficients;
74
75 this->atoms_vec.resize(ucell.nat);
76 std::iota(this->atoms_vec.begin(), this->atoms_vec.end(), 0);
77 this->nmp = {this->p_kv->nmp[0], this->p_kv->nmp[1], this->p_kv->nmp[2]};
78
79 ModuleBase::timer::end("Ewald_Vq", "init");
80}
81
82template <typename Tdata>
83void Ewald_Vq<Tdata>::init_ions(const UnitCell& ucell, const std::array<Tcell, Ndim>& period_Vs_NAO)
84{
85 ModuleBase::TITLE("Ewald_Vq", "init_ions");
86 ModuleBase::timer::start("Ewald_Vq", "init_ions");
87
88 const std::array<Tcell, Ndim> period_Vs
89 = LRI_CV_Tools::cal_latvec_range<Tcell>(1 + this->ccp_rmesh_times, ucell, this->g_lcaos_rcut);
90
91 const std::pair<std::vector<TA>, std::vector<std::vector<std::pair<TA, std::array<Tcell, Ndim>>>>> list_As_Vs
92 = RI::Distribute_Equally::distribute_atoms_periods(this->mpi_comm, this->atoms_vec, period_Vs, 2, false);
93
94 this->list_A0 = list_As_Vs.first;
95 this->list_A1 = list_As_Vs.second[0];
96
97 const std::array<int, 1> Nks = {this->nks0};
98 const std::pair<std::vector<TA>, std::vector<std::vector<std::pair<TA, TK>>>> list_As_Vq
99 = RI::Distribute_Equally::distribute_atoms_periods(this->mpi_comm, this->atoms_vec, Nks, 2, false);
100 this->list_A0_k = list_As_Vq.first;
101 this->list_A1_k = list_As_Vq.second[0];
102
103 const std::pair<std::vector<TA>, std::vector<std::vector<std::pair<TA, TC>>>> list_As_Vs_atoms
104 = RI::Distribute_Equally::distribute_atoms(this->mpi_comm, this->atoms_vec, period_Vs_NAO, 2, false);
105 this->list_A0_pair_R = list_As_Vs_atoms.first;
106 this->list_A1_pair_R = list_As_Vs_atoms.second[0];
107
108 const std::pair<std::vector<TA>, std::vector<std::vector<std::pair<TA, TC>>>> list_As_Vs_atoms_period
109 = RI::Distribute_Equally::distribute_atoms(this->mpi_comm, this->atoms_vec, this->nmp, 2, false);
110 this->list_A0_pair_R_period = list_As_Vs_atoms_period.first;
111 this->list_A1_pair_R_period = list_As_Vs_atoms_period.second[0];
112
113 const std::pair<std::vector<TA>, std::vector<std::vector<std::pair<TA, TK>>>> list_As_Vq_atoms
114 = RI::Distribute_Equally::distribute_atoms(this->mpi_comm, this->atoms_vec, Nks, 2, false);
115 this->list_A0_pair_k = list_As_Vq_atoms.first;
116 this->list_A1_pair_k = list_As_Vq_atoms.second[0];
117
118 for (size_t ik = 0; ik != this->nks0; ++ik)
119 this->kvec_c[ik] = this->p_kv->kvec_c_full[ik];
120
121 std::vector<ModuleBase::Vector3<double>> neg_kvec(this->nks0);
122 std::transform(this->kvec_c.begin(),
123 this->kvec_c.end(),
124 neg_kvec.begin(),
125 [](ModuleBase::Vector3<double>& vec) -> ModuleBase::Vector3<double> { return -vec; });
126 this->gaussian_abfs.init(ucell, 2 * GlobalC::exx_info.info_ri.abfs_Lmax + 1, neg_kvec, ucell.G, this->ewald_lambda);
127
128 ModuleBase::timer::end("Ewald_Vq", "init_ions");
129}
130
131template <typename Tdata>
132double Ewald_Vq<Tdata>::get_singular_chi(const UnitCell& ucell, const std::vector<std::map<std::string,std::string>>& param_list, const double& qdiv)
133{
134 ModuleBase::TITLE("Ewald_Vq", "get_singular_chi");
135 ModuleBase::timer::start("Ewald_Vq", "get_singular_chi");
136
137 double chi = 0.0;
138 for(const auto &param : param_list)
139 {
140 if(param.at("singularity_correction") == "carrier")
141 {
142 chi = Singular_Value::cal_carrier(ucell, this->kvec_c, qdiv, 100, 30, 1e-6, 3);
143 }
144 else if(param.at("singularity_correction") == "massidda")
145 {
146 chi = Singular_Value::cal_massidda(ucell, this->nmp, qdiv, 1, 5, 1e-4);
147 }
148 else
149 {
150 throw std::domain_error(std::string(__FILE__) + " line " + std::to_string(__LINE__)
151 + ": singularity_correction must be carrier or massidda");
152 }
153 }
154
155 ModuleBase::timer::end("Ewald_Vq", "get_singular_chi");
156 return chi;
157}
158
159template <typename Tdata>
160auto Ewald_Vq<Tdata>::cal_Vs_gauss(const UnitCell& ucell, const std::vector<TA>& list_A0, const std::vector<TAC>& list_A1)
161 -> std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>
162{
163 ModuleBase::TITLE("Ewald_Vq", "cal_Vs_gauss");
164 ModuleBase::timer::start("Ewald_Vq", "cal_Vs_gauss");
165
166 std::map<std::string, bool> flags = {{"writable_Vws", true}};
167 std::map<TA, std::map<TAC, RI::Tensor<Tdata>>> Vs_gauss = this->cv.cal_Vs(ucell, list_A0, list_A1, flags);
168 this->cv.Vws = LRI_CV_Tools::get_CVws(ucell, Vs_gauss);
169
170 ModuleBase::timer::end("Ewald_Vq", "cal_Vs_gauss");
171 return Vs_gauss;
172}
173
174template <typename Tdata>
175auto Ewald_Vq<Tdata>::cal_dVs_gauss(const UnitCell& ucell, const std::vector<TA>& list_A0, const std::vector<TAC>& list_A1)
176 -> std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>>
177{
178 ModuleBase::TITLE("Ewald_Vq", "cal_dVs_gauss");
179 ModuleBase::timer::start("Ewald_Vq", "cal_dVs_gauss");
180
181 std::map<std::string, bool> flags = {{"writable_dVws", true}};
182
183 std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>> dVs_gauss
184 = this->cv.cal_dVs(ucell, list_A0, list_A1, flags);
185 this->cv.dVws = LRI_CV_Tools::get_dCVws(ucell, dVs_gauss);
186
187 ModuleBase::timer::end("Ewald_Vq", "cal_dVs_gauss");
188 return dVs_gauss;
189}
190
191template <typename Tdata>
192auto Ewald_Vq<Tdata>::cal_Vs_minus_gauss(const UnitCell& ucell,
193 const std::vector<TA>& list_A0,
194 const std::vector<TAC>& list_A1,
195 std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>& Vs_in)
196 -> std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>
197{
198 ModuleBase::TITLE("Ewald_Vq", "cal_Vs_minus_gauss");
199 ModuleBase::timer::start("Ewald_Vq", "cal_Vs_minus_gauss");
200
201 std::map<TA, std::map<TAC, RI::Tensor<Tdata>>> Vs_gauss = this->cal_Vs_gauss(ucell, list_A0, list_A1);
202 std::map<TA, std::map<TAC, RI::Tensor<Tdata>>> Vs_minus_gauss
203 = this->set_Vs_dVs_minus_gauss(ucell, list_A0, list_A1, Vs_in, Vs_gauss);
204
205 ModuleBase::timer::end("Ewald_Vq", "cal_Vs_minus_gauss");
206 return Vs_minus_gauss;
207}
208
209template <typename Tdata>
210auto Ewald_Vq<Tdata>::cal_dVs_minus_gauss(const UnitCell& ucell,
211 const std::vector<TA>& list_A0,
212 const std::vector<TAC>& list_A1,
213 std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>>& dVs_in)
214 -> std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>>
215{
216 ModuleBase::TITLE("Ewald_Vq", "cal_dVs_minus_gauss");
217 ModuleBase::timer::start("Ewald_Vq", "cal_dVs_minus_gauss");
218
219 std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>> dVs_gauss = this->cal_dVs_gauss(list_A0, list_A1);
220 std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>> dVs_minus_gauss
221 = this->set_Vs_dVs_minus_gauss(ucell, list_A0, list_A1, dVs_in, dVs_gauss);
222
223 ModuleBase::timer::end("Ewald_Vq", "cal_dVs_minus_gauss");
224 return dVs_minus_gauss;
225}
226
227template <typename Tdata>
228double Ewald_Vq<Tdata>::cal_V_Rcut(const int it0, const int it1)
229{
230 return this->g_abfs_ccp_rcut.at(it0) + this->g_lcaos_rcut.at(it1);
231}
232
233template <typename Tdata>
234double Ewald_Vq<Tdata>::get_Rcut_max(const int it0, const int it1)
235{
236 double lcaos_rmax = this->lcaos_rcut.at(it0) * this->ccp_rmesh_times + this->lcaos_rcut.at(it1);
237 double g_lcaos_rmax = this->g_lcaos_rcut.at(it0) * this->ccp_rmesh_times + this->g_lcaos_rcut.at(it1);
238 return std::min(lcaos_rmax, g_lcaos_rmax);
239}
240
241template <typename Tdata>
242template <typename Tresult>
243auto Ewald_Vq<Tdata>::set_Vs_dVs_minus_gauss(const UnitCell& ucell,
244 const std::vector<TA>& list_A0,
245 const std::vector<TAC>& list_A1,
246 std::map<TA, std::map<TAC, Tresult>>& Vs_dVs_in,
247 std::map<TA, std::map<TAC, Tresult>>& Vs_dVs_gauss_in)
248 -> std::map<TA, std::map<TAC, Tresult>>
249{
250 ModuleBase::TITLE("Ewald_Vq", "set_Vs_dVs_minus_gauss");
251 ModuleBase::timer::start("Ewald_Vq", "set_Vs_dVs_minus_gauss");
252
253 using Tin_convert = typename LRI_CV_Tools::TinType<Tresult>::type;
254 std::map<TA, std::map<TAC, Tresult>> pVs_dVs_gauss;
255#pragma omp parallel
256 for (size_t i0 = 0; i0 < list_A0.size(); ++i0)
257 {
258#pragma omp for schedule(dynamic) nowait
259 for (size_t i1 = 0; i1 < list_A1.size(); ++i1)
260 {
261 const TA iat0 = list_A0[i0];
262 const int it0 = ucell.iat2it[iat0];
263 const int ia0 = ucell.iat2ia[iat0];
264 const TA iat1 = list_A1[i1].first;
265 const int it1 = ucell.iat2it[iat1];
266 const int ia1 = ucell.iat2ia[iat1];
267 const TC& cell1 = list_A1[i1].second;
268
269 const ModuleBase::Vector3<double> tau0 = ucell.atoms[it0].tau[ia0];
270 const ModuleBase::Vector3<double> tau1 = ucell.atoms[it1].tau[ia1];
271
272 const double Rcut = std::min(this->cal_V_Rcut(it0, it1), this->cal_V_Rcut(it1, it0));
273 const Abfs::Vector3_Order<double> R_delta
274 = -tau0 + tau1 + (RI_Util::array3_to_Vector3(cell1) * ucell.latvec);
275 if (R_delta.norm() * ucell.lat0 < Rcut)
276 {
277 const size_t size0 = this->index_abfs[it0].count_size;
278 const size_t size1 = this->index_abfs[it1].count_size;
279 Tresult data;
280 LRI_CV_Tools::init_elem(data, size0, size1);
281
282 // pA * pB * V(R)_gauss
283 for (int l0 = 0; l0 != this->g_abfs_ccp.at(it0).size(); ++l0)
284 {
285 for (int l1 = 0; l1 != this->g_abfs.at(it1).size(); ++l1)
286 {
287 for (size_t n0 = 0; n0 != this->g_abfs_ccp.at(it0).at(l0).size(); ++n0)
288 {
289 const double pA = this->multipole.at(it0).at(l0).at(n0);
290 for (size_t n1 = 0; n1 != this->g_abfs.at(it1).at(l1).size(); ++n1)
291 {
292 const double pB = this->multipole.at(it1).at(l1).at(n1);
293 Tin_convert pp = RI::Global_Func::convert<Tin_convert>(pA * pB);
294 for (size_t m0 = 0; m0 != 2 * l0 + 1; ++m0)
295 {
296 for (size_t m1 = 0; m1 != 2 * l1 + 1; ++m1)
297 {
298 const size_t index0 = this->index_abfs.at(it0).at(l0).at(n0).at(m0);
299 const size_t index1 = this->index_abfs.at(it1).at(l1).at(n1).at(m1);
300
301 LRI_CV_Tools::add_elem(data,
302 index0,
303 index1,
304 Vs_dVs_gauss_in.at(list_A0[i0]).at(list_A1[i1]),
305 index0,
306 index1,
307 pp);
308 }
309 }
310 }
311 }
312 }
313 }
314#pragma omp critical(Ewald_Vq_set_Vs_dVs_minus_gauss)
315 pVs_dVs_gauss[list_A0[i0]][list_A1[i1]] = data;
316 }
317 }
318 }
319
320 std::map<TA, std::map<TAC, Tresult>> Vs_dVs_minus_gauss = LRI_CV_Tools::minus(Vs_dVs_in, pVs_dVs_gauss);
321 ModuleBase::timer::end("Ewald_Vq", "set_Vs_dVs_minus_gauss");
322 return Vs_dVs_minus_gauss;
323}
324
325template <typename Tdata>
326auto Ewald_Vq<Tdata>::cal_Vq_gauss(const UnitCell& ucell,
327 const std::vector<TA>& list_A0_k,
328 const std::vector<TAK>& list_A1_k,
329 const double& chi,
330 const int& shift_for_mpi)
331 -> std::map<TA, std::map<TAK, RI::Tensor<std::complex<double>>>>
332{
333 ModuleBase::TITLE("Ewald_Vq", "cal_Vq_gauss");
334 ModuleBase::timer::start("Ewald_Vq", "cal_Vq_gauss");
335
336 const T_func_DPget_Vq_dVq<RI::Tensor<std::complex<double>>> func_DPget_Vq = std::bind(&Gaussian_Abfs::get_Vq,
337 &this->gaussian_abfs,
338 std::placeholders::_1,
339 std::placeholders::_2,
340 std::placeholders::_3,
341 chi,
342 std::placeholders::_4,
343 this->gaunt);
344 auto Vq_gauss = this->set_Vq_dVq_gauss(ucell, list_A0_k, list_A1_k, shift_for_mpi, func_DPget_Vq);
345
346 ModuleBase::timer::end("Ewald_Vq", "cal_Vq_gauss");
347 return Vq_gauss;
348}
349
350template <typename Tdata>
351auto Ewald_Vq<Tdata>::cal_dVq_gauss(const UnitCell& ucell,
352 const std::vector<TA>& list_A0_k,
353 const std::vector<TAK>& list_A1_k,
354 const double& chi,
355 const int& shift_for_mpi)
356 -> std::map<TA, std::map<TAK, std::array<RI::Tensor<std::complex<double>>, Ndim>>>
357{
358 ModuleBase::TITLE("Ewald_Vq", "cal_dVq_gauss");
359 ModuleBase::timer::start("Ewald_Vq", "cal_dVq_gauss");
360
361 const T_func_DPget_Vq_dVq<std::array<RI::Tensor<std::complex<double>>, Ndim>> func_DPget_dVq
362 = std::bind(&Gaussian_Abfs::get_dVq,
363 &this->gaussian_abfs,
364 std::placeholders::_1,
365 std::placeholders::_2,
366 std::placeholders::_3,
367 chi,
368 std::placeholders::_4,
369 this->gaunt);
370
371 using namespace RI::Array_Operator;
372 std::map<TA, std::map<TAK, std::array<RI::Tensor<std::complex<double>>, Ndim>>> dVq_gauss;
373 auto res = this->set_Vq_dVq_gauss(ucell, list_A0_k, list_A1_k, shift_for_mpi, func_DPget_dVq);
374
375 for (size_t i0 = 0; i0 < list_A0_k.size(); ++i0)
376 {
377 const TA iat0 = list_A0_k[i0];
378 const int it0 = ucell.iat2it[iat0];
379 for (size_t i1 = 0; i1 < list_A1_k.size(); ++i1)
380 {
381 const TA iat1 = list_A1_k[i1].first;
382 const int it1 = ucell.iat2it[iat1];
383 if (iat0 != iat1)
384 {
385 const int ik = list_A1_k[i1].second[0];
386 const TAK index0 = std::make_pair(iat1, TK{ik});
387 dVq_gauss[iat0][index0] = -res.at(list_A0_k[i0]).at(list_A1_k[i1]);
388 const TAK index1 = std::make_pair(iat0, TK{ik});
389 dVq_gauss[iat1][index1] = res.at(list_A0_k[i0]).at(list_A1_k[i1]);
390 }
391 else
392 dVq_gauss[list_A0_k[i0]][list_A1_k[i1]] = res.at(list_A0_k[i0]).at(list_A1_k[i1]);
393 }
394 }
395
396 ModuleBase::timer::end("Ewald_Vq", "cal_dVq_gauss");
397 return dVq_gauss;
398}
399
400template <typename Tdata>
401template <typename Tresult>
402auto Ewald_Vq<Tdata>::set_Vq_dVq_gauss(const UnitCell& ucell,
403 const std::vector<TA>& list_A0_k,
404 const std::vector<TAK>& list_A1_k,
405 const int& shift_for_mpi,
406 const T_func_DPget_Vq_dVq<Tresult>& func_DPget_Vq_dVq)
407 -> std::map<TA, std::map<TAK, Tresult>>
408{
409 ModuleBase::TITLE("Ewald_Vq", "set_Vq_dVq_gauss");
410 ModuleBase::timer::start("Ewald_Vq", "set_Vq_dVq_gauss");
411
412 std::map<TA, std::map<TAK, Tresult>> Vq_dVq_gauss_out;
413 for(const auto &param_list : this->coulomb_param)
414 {
415 std::complex<double> alpha;
416 for(const auto &param : param_list.second)
417 {
418 alpha = std::complex<double>(std::stod(param.at("alpha")), 0);
419 }
420#pragma omp parallel
421 for (size_t i0 = 0; i0 < list_A0_k.size(); ++i0)
422 {
423#pragma omp for schedule(dynamic) nowait
424 for (size_t i1 = 0; i1 < list_A1_k.size(); ++i1)
425 {
426 const TA iat0 = list_A0_k[i0];
427 const int it0 = ucell.iat2it[iat0];
428 const int ia0 = ucell.iat2ia[iat0];
429 const ModuleBase::Vector3<double> tau0 = ucell.atoms[it0].tau[ia0];
430
431 const TA iat1 = list_A1_k[i1].first;
432 const int it1 = ucell.iat2it[iat1];
433 const int ia1 = ucell.iat2ia[iat1];
434 const ModuleBase::Vector3<double> tau1 = ucell.atoms[it1].tau[ia1];
435 const size_t ik = list_A1_k[i1].second[0] + shift_for_mpi;
436
437 const ModuleBase::Vector3<double> tau = tau0 - tau1;
438 auto data
439 = func_DPget_Vq_dVq(this->g_abfs_ccp.at(it0).size() - 1, this->g_abfs.at(it1).size() - 1, ik, tau);
440
441#pragma omp critical(Ewald_Vq_set_Vq_dVq_gauss)
442 Vq_dVq_gauss_out[list_A0_k[i0]][list_A1_k[i1]] = LRI_CV_Tools::mul2(alpha, data);
443 }
444 }
445 }
446
447 ModuleBase::timer::end("Ewald_Vq", "set_Vq_dVq_gauss");
448 return Vq_dVq_gauss_out;
449}
450
451template <typename Tdata>
452auto Ewald_Vq<Tdata>::cal_Vq_minus_gauss(const UnitCell& ucell,
453 const std::vector<TA>& list_A0,
454 const std::vector<TAC>& list_A1,
455 std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>& Vs_minus_gauss)
456 -> std::map<TA, std::map<TAK, RI::Tensor<std::complex<double>>>>
457{
458 ModuleBase::TITLE("Ewald_Vq", "cal_Vq_minus_gauss");
459 ModuleBase::timer::start("Ewald_Vq", "cal_Vq_minus_gauss");
460
461 auto Vq_minus_gauss
462 = this->set_Vq_dVq_minus_gauss<RI::Tensor<std::complex<double>>>(ucell, list_A0, list_A1, Vs_minus_gauss);
463
464 ModuleBase::timer::end("Ewald_Vq", "cal_Vq_minus_gauss");
465 return Vq_minus_gauss;
466}
467
468template <typename Tdata>
469auto Ewald_Vq<Tdata>::cal_dVq_minus_gauss(
470 const UnitCell& ucell,
471 const std::vector<TA>& list_A0,
472 const std::vector<TAC>& list_A1,
473 std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>>& dVs_minus_gauss)
474 -> std::map<TA, std::map<TAK, std::array<RI::Tensor<std::complex<double>>, Ndim>>>
475{
476 ModuleBase::TITLE("Ewald_Vq", "cal_dVq_minus_gauss");
477 ModuleBase::timer::start("Ewald_Vq", "cal_dVq_minus_gauss");
478
479 auto dVq_minus_gauss
480 = this->set_Vq_dVq_minus_gauss<std::array<RI::Tensor<std::complex<double>>, Ndim>>(ucell,
481 list_A0,
482 list_A1,
483 dVs_minus_gauss);
484
485 ModuleBase::timer::end("Ewald_Vq", "cal_dVq_minus_gauss");
486 return dVq_minus_gauss;
487}
488
489template <typename Tdata>
490template <typename Tout, typename Tin>
491auto Ewald_Vq<Tdata>::set_Vq_dVq_minus_gauss(const UnitCell& ucell,
492 const std::vector<TA>& list_A0,
493 const std::vector<TAC>& list_A1,
494 std::map<TA, std::map<TAC, Tin>>& Vs_dVs_minus_gauss)
495 -> std::map<TA, std::map<TAK, Tout>>
496{
497 ModuleBase::TITLE("Ewald_Vq", "set_Vq_dVq_minus_gauss");
498 ModuleBase::timer::start("Ewald_Vq", "set_Vq_dVq_minus_gauss");
499
500 using namespace RI::Array_Operator;
501 using Tin_convert = typename LRI_CV_Tools::TinType<Tout>::type;
502 std::map<TA, std::map<TAK, Tout>> datas;
503
504 // auto start = std::chrono::system_clock::now();
505
506#pragma omp parallel
507 {
508 std::map<TA, std::map<TAK, Tout>> local_datas;
509
510#pragma omp for schedule(dynamic) nowait
511 for (size_t ik = 0; ik != this->nks0; ++ik)
512 {
513 for (size_t i0 = 0; i0 < list_A0.size(); ++i0)
514 {
515 for (size_t i1 = 0; i1 < list_A1.size(); ++i1)
516 {
517 const TA iat0 = list_A0[i0];
518 const int it0 = ucell.iat2it[iat0];
519 const int ia0 = ucell.iat2ia[iat0];
520 const TA iat1 = list_A1[i1].first;
521 const int it1 = ucell.iat2it[iat1];
522 const int ia1 = ucell.iat2ia[iat1];
523 const TC& cell1 = list_A1[i1].second;
524
525 const ModuleBase::Vector3<double> tau0 = ucell.atoms[it0].tau[ia0];
526 const ModuleBase::Vector3<double> tau1 = ucell.atoms[it1].tau[ia1];
527 const double Rcut = std::min(this->get_Rcut_max(it0, it1), this->get_Rcut_max(it1, it0));
528 const ModuleBase::Vector3<double> R_delta
529 = -tau0 + tau1 + (RI_Util::array3_to_Vector3(cell1) * ucell.latvec);
530
531 if (R_delta.norm() * ucell.lat0 < Rcut)
532 {
533 const std::complex<double> phase
534 = std::exp(ModuleBase::TWO_PI * ModuleBase::IMAG_UNIT
535 * (this->kvec_c[ik] * (RI_Util::array3_to_Vector3(cell1) * ucell.latvec)));
536
537 Tout Vs_dVs_tmp = LRI_CV_Tools::mul2(
538 phase,
539 LRI_CV_Tools::convert<Tin_convert>(std::move(Vs_dVs_minus_gauss.at(iat0).at(list_A1[i1]))));
540
541 const TAK index = std::make_pair(iat1, TK{static_cast<int>(ik)});
542 if (!LRI_CV_Tools::exist(local_datas[iat0][index]))
543 local_datas[iat0][index] = Vs_dVs_tmp;
544 else
545 local_datas[iat0][index] = local_datas.at(iat0).at(index) + Vs_dVs_tmp;
546 }
547 }
548 }
549 }
550
551#pragma omp critical(Ewald_Vq_set_Vq_dVq_minus_gauss)
552 {
553 for (auto it0 = local_datas.begin(); it0 != local_datas.end(); ++it0)
554 {
555 const TA& key0 = it0->first;
556 std::map<TAK, Tout>& map1 = it0->second;
557 for (auto it1 = map1.begin(); it1 != map1.end(); ++it1)
558 {
559 const TAK& key1 = it1->first;
560 Tout& value = it1->second;
561
562 if (!LRI_CV_Tools::exist(datas[key0][key1]))
563 datas[key0][key1] = value;
564 else
565 datas[key0][key1] = datas.at(key0).at(key1) + value;
566 }
567 }
568 }
569 }
570
571 // auto end = std::chrono::system_clock::now();
572 // auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end
573 // - start); std::cout << "set_Vq_dVq_minus_gauss Time: "
574 // << double(duration.count()) *
575 // std::chrono::microseconds::period::num
576 // / std::chrono::microseconds::period::den
577 // << " s" << std::endl;
578 ModuleBase::timer::end("Ewald_Vq", "set_Vq_dVq_minus_gauss");
579 return datas;
580}
581
582template <typename Tdata>
583auto Ewald_Vq<Tdata>::cal_Vq(const UnitCell& ucell,
584 const double& chi,
585 std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>& Vs_in)
586 -> std::map<TA, std::map<TAK, RI::Tensor<std::complex<double>>>>
587{
588 ModuleBase::TITLE("Ewald_Vq", "cal_Vq");
589 ModuleBase::timer::start("Ewald_Vq", "cal_Vq");
590
591 std::map<TA, std::map<TAC, RI::Tensor<Tdata>>> Vs_minus_gauss = this->cal_Vs_minus_gauss(ucell,
592 this->list_A0,
593 this->list_A1,
594 Vs_in); //{ia0, {ia1, R}}
595 const T_func_DPcal_Vq_dVq_minus_gauss<RI::Tensor<std::complex<double>>, RI::Tensor<Tdata>> func_cal_Vq_minus_gauss
596 = std::bind(&Ewald_Vq<Tdata>::cal_Vq_minus_gauss,
597 this,
598 std::ref(ucell),
599 this->list_A0_pair_R,
600 this->list_A1_pair_R,
601 std::placeholders::_1);
602 const T_func_DPcal_Vq_dVq_gauss<RI::Tensor<std::complex<double>>> func_cal_Vq_gauss
603 = std::bind(&Ewald_Vq<Tdata>::cal_Vq_gauss,
604 this,
605 std::ref(ucell),
606 this->list_A0_k,
607 this->list_A1_k,
608 chi,
609 std::placeholders::_1);
610
611 auto Vq = this->set_Vq_dVq(ucell,
612 this->list_A0_pair_k,
613 this->list_A1_pair_k,
614 Vs_minus_gauss,
615 func_cal_Vq_minus_gauss,
616 func_cal_Vq_gauss); //{ia0, ia1}
617
618 ModuleBase::timer::end("Ewald_Vq", "cal_Vq");
619 return Vq;
620}
621
622template <typename Tdata>
623auto Ewald_Vq<Tdata>::cal_dVq(const UnitCell& ucell,
624 const double& chi,
625 std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>>& dVs_in)
626 -> std::map<TA, std::map<TAK, std::array<RI::Tensor<std::complex<double>>, Ndim>>>
627{
628 ModuleBase::TITLE("Ewald_Vq", "cal_dVq");
629 ModuleBase::timer::start("Ewald_Vq", "cal_dVq");
630
631 std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>> dVs_minus_gauss
632 = this->cal_dVs_minus_gauss(ucell,
633 this->list_A0,
634 this->list_A1,
635 dVs_in); //{ia0, {ia1, R}}
636 const T_func_DPcal_Vq_dVq_minus_gauss<std::array<RI::Tensor<std::complex<double>>, Ndim>,
637 std::array<RI::Tensor<Tdata>, Ndim>>
638 func_cal_dVq_minus_gauss = std::bind(&Ewald_Vq<Tdata>::cal_dVq_minus_gauss,
639 this,
640 std::ref(ucell),
641 this->list_A0_pair_R,
642 this->list_A1_pair_R,
643 std::placeholders::_1);
644 const T_func_DPcal_Vq_dVq_gauss<std::array<RI::Tensor<std::complex<double>>, Ndim>> func_cal_dVq_gauss
645 = std::bind(&Ewald_Vq<Tdata>::cal_dVq_gauss,
646 this,
647 std::ref(ucell),
648 this->list_A0_k,
649 this->list_A1_k,
650 chi,
651 std::placeholders::_1);
652
653 auto dVq = this->set_Vq_dVq(ucell,
654 this->list_A0_pair_k,
655 this->list_A1_pair_k,
656 dVs_minus_gauss,
657 func_cal_dVq_minus_gauss,
658 func_cal_dVq_gauss); //{ia0, ia1}
659
660 ModuleBase::timer::end("Ewald_Vq", "cal_dVq");
661 return dVq;
662}
663
664template <typename Tdata>
665template <typename Tout, typename Tin>
666auto Ewald_Vq<Tdata>::set_Vq_dVq(const UnitCell& ucell,
667 const std::vector<TA>& list_A0_pair_k,
668 const std::vector<TAK>& list_A1_pair_k,
669 std::map<TA, std::map<TAC, Tin>>& Vs_dVs_minus_gauss_in,
670 const T_func_DPcal_Vq_dVq_minus_gauss<Tout, Tin>& func_cal_Vq_dVq_minus_gauss,
671 const T_func_DPcal_Vq_dVq_gauss<Tout>& func_cal_Vq_dVq_gauss)
672 -> std::map<TA, std::map<TAK, Tout>>
673{
674 ModuleBase::TITLE("Ewald_Vq", "set_Vq_dVq");
675 ModuleBase::timer::start("Ewald_Vq", "set_Vq_dVq");
676
677 using namespace RI::Array_Operator;
678 using Tin_convert = typename LRI_CV_Tools::TinType<Tout>::type;
679 std::map<TA, std::map<TAK, Tout>> Vq_dVq;
680 const int shift_for_mpi = std::floor(this->nks0 / 2.0);
681
682 // MPI: {ia0, {ia1, R}} to {ia0, ia1}
683 std::set<TA> atoms00;
684 std::set<TA> atoms01;
685 for (const auto& I: this->list_A0_pair_R)
686 {
687 atoms00.insert(I);
688 }
689 for (const auto& JR: this->list_A1_pair_R)
690 {
691 atoms01.insert(JR.first);
692 }
693
694 std::map<TA, std::map<TAC, Tin>> Vs_dVs_minus_gauss
695 = RI_2D_Comm::comm_map2_first(this->mpi_comm, Vs_dVs_minus_gauss_in, atoms00, atoms01);
696 std::map<TA, std::map<TAK, Tout>> Vq_dVq_minus_gauss = func_cal_Vq_dVq_minus_gauss(Vs_dVs_minus_gauss); //{ia0, ia1}
697
698 // MPI: {ia0, {ia1, k}} to {ia0, ia1}
699 std::map<TA, std::map<TAK, Tout>> Vq_dVq_gauss_out = func_cal_Vq_dVq_gauss(shift_for_mpi); //{ia0, {ia1, k}}
700 // MPI: {ia0, {ia1, k}} to {ia0, ia1}
701 std::set<TA> atoms10;
702 std::set<TA> atoms11;
703 for (const auto& I: this->list_A0_pair_k)
704 {
705 atoms10.insert(I);
706 }
707 for (const auto& JR: this->list_A1_pair_k)
708 {
709 atoms11.insert(JR.first);
710 }
711
712 std::map<TA, std::map<TAK, Tout>> Vq_dVq_gauss
713 = RI_2D_Comm::comm_map2_first(this->mpi_comm, Vq_dVq_gauss_out, atoms10, atoms11); //{ia0, ia1}
714
715#pragma omp parallel
716 for (size_t i0 = 0; i0 < list_A0_pair_k.size(); ++i0)
717 {
718#pragma omp for schedule(dynamic) nowait
719 for (size_t i1 = 0; i1 < list_A1_pair_k.size(); ++i1)
720 {
721 const TA iat0 = list_A0_pair_k[i0];
722 const int it0 = ucell.iat2it[iat0];
723 const TA iat1 = list_A1_pair_k[i1].first;
724 const int it1 = ucell.iat2it[iat1];
725 const int ik = list_A1_pair_k[i1].second[0] + shift_for_mpi;
726 const TAK re_index = std::make_pair(iat1, std::array<int, 1>{ik});
727
728 // check the Fourier transformed V(q)
729 // whether ccp_rmesh_times * Rcut >= rIJ
730 // skip some IJ pairs
731 auto it_outer = Vq_dVq_minus_gauss.find(list_A0_pair_k[i0]);
732 if (it_outer == Vq_dVq_minus_gauss.end())
733 continue;
734
735 auto it_inner = it_outer->second.find(re_index);
736 if (it_inner == it_outer->second.end())
737 continue;
738
739 const size_t size0 = this->index_abfs[it0].count_size;
740 const size_t size1 = this->index_abfs[it1].count_size;
741 Tout data;
742 LRI_CV_Tools::init_elem(data, size0, size1);
743 for (int l0 = 0; l0 != this->g_abfs_ccp.at(it0).size(); ++l0)
744 {
745 for (int l1 = 0; l1 != this->g_abfs.at(it1).size(); ++l1)
746 {
747 for (size_t n0 = 0; n0 != this->g_abfs_ccp.at(it0).at(l0).size(); ++n0)
748 {
749 const double pA = this->multipole.at(it0).at(l0).at(n0);
750 for (size_t n1 = 0; n1 != this->g_abfs.at(it1).at(l1).size(); ++n1)
751 {
752 const double pB = this->multipole.at(it1).at(l1).at(n1);
753 Tin_convert frac = RI::Global_Func::convert<Tin_convert>(pA * pB);
754 for (size_t m0 = 0; m0 != 2 * l0 + 1; ++m0)
755 {
756 const size_t index0 = this->index_abfs.at(it0).at(l0).at(n0).at(m0);
757 const size_t lm0 = l0 * l0 + m0;
758 for (size_t m1 = 0; m1 != 2 * l1 + 1; ++m1)
759 {
760 const size_t index1 = this->index_abfs.at(it1).at(l1).at(n1).at(m1);
761 const size_t lm1 = l1 * l1 + m1;
762
763 LRI_CV_Tools::add_elem(data,
764 index0,
765 index1,
766 Vq_dVq_gauss.at(list_A0_pair_k[i0]).at(list_A1_pair_k[i1]),
767 lm0,
768 lm1,
769 frac);
770 }
771 }
772 }
773 }
774 }
775 }
776
777#pragma omp critical(Ewald_Vq_set_Vq_dVq)
778 if (LRI_CV_Tools::exist(Vq_dVq_minus_gauss.at(list_A0_pair_k[i0]).at(re_index)))
779 Vq_dVq[list_A0_pair_k[i0]][re_index] = Vq_dVq_minus_gauss.at(list_A0_pair_k[i0]).at(re_index) + data;
780 }
781 }
782
783 ModuleBase::timer::end("Ewald_Vq", "set_Vq_dVq");
784 return Vq_dVq;
785}
786
787template <typename Tdata>
788auto Ewald_Vq<Tdata>::cal_Vs(const UnitCell& ucell,
789 const double& chi,
790 std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>& Vs_in) //{ia0, {ia1, R}}
791 -> std::map<TA, std::map<TAC, RI::Tensor<Tdata>>>
792{
793 ModuleBase::TITLE("Ewald_Vq", "cal_Vs");
794 ModuleBase::timer::start("Ewald_Vq", "cal_Vs");
795
796 std::map<TA, std::map<TAK, RI::Tensor<std::complex<double>>>> Vq = this->cal_Vq(ucell, chi, Vs_in);
797 auto Vs = this->set_Vs_dVs<RI::Tensor<Tdata>>(ucell,
798 this->list_A0_pair_R_period,
799 this->list_A1_pair_R_period,
800 Vq); //{ia0, ia1}
801
802 ModuleBase::timer::end("Ewald_Vq", "cal_Vs");
803 return Vs;
804}
805
806template <typename Tdata>
807auto Ewald_Vq<Tdata>::cal_dVs(
808 const UnitCell& ucell,
809 const double& chi,
810 std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>>& dVs_in) //{ia0, {ia1, R}}
811 -> std::map<TA, std::map<TAC, std::array<RI::Tensor<Tdata>, Ndim>>>
812{
813 ModuleBase::TITLE("Ewald_Vq", "cal_dVs");
814 ModuleBase::timer::start("Ewald_Vq", "cal_dVs");
815
816 std::map<TA, std::map<TAK, std::array<RI::Tensor<std::complex<double>>, Ndim>>> dVq
817 = this->cal_dVq(ucell, chi, dVs_in);
818 auto dVs = this->set_Vs_dVs<std::array<RI::Tensor<Tdata>, Ndim>>(ucell,
819 this->list_A0_pair_R_period,
820 this->list_A1_pair_R_period,
821 dVq); //{ia0, ia1}
822
823 ModuleBase::timer::end("Ewald_Vq", "cal_dVs");
824 return dVs;
825}
826
827template <typename Tdata>
828template <typename Tout, typename Tin>
829auto Ewald_Vq<Tdata>::set_Vs_dVs(const UnitCell& ucell,
830 const std::vector<TA>& list_A0_pair_R,
831 const std::vector<TAC>& list_A1_pair_R,
832 std::map<TA, std::map<TAK, Tin>>& Vq) -> std::map<TA, std::map<TAC, Tout>>
833{
834 ModuleBase::TITLE("Ewald_Vq", "set_Vs_dVs");
835 ModuleBase::timer::start("Ewald_Vq", "set_Vs_dVs");
836
837 using namespace RI::Array_Operator;
838 using Tin_convert = typename LRI_CV_Tools::TinType<Tout>::type;
839
840 const double cfrac = 1.0 / this->nks0;
841 std::map<TA, std::map<TAC, Tout>> datas;
842
843 // auto start = std::chrono::system_clock::now();
844#pragma omp parallel
845 {
846 std::map<TA, std::map<TAC, Tout>> local_datas;
847
848#pragma omp for schedule(dynamic) nowait
849 for (size_t ik = 0; ik != this->nks0; ++ik)
850 {
851 for (size_t i0 = 0; i0 < list_A0_pair_R.size(); ++i0)
852 {
853 for (size_t i1 = 0; i1 < list_A1_pair_R.size(); ++i1)
854 {
855 const TA iat0 = list_A0_pair_R[i0];
856 const TA iat1 = list_A1_pair_R[i1].first;
857 const TC& cell1 = list_A1_pair_R[i1].second;
858 const std::complex<double> frac
859 = std::exp(-ModuleBase::TWO_PI * ModuleBase::IMAG_UNIT
860 * (this->kvec_c[ik] * (RI_Util::array3_to_Vector3(cell1) * ucell.latvec)))
861 * cfrac;
862
863 const TAK index = std::make_pair(iat1, std::array<int, 1>{static_cast<int>(ik)});
864
865 // check the Fourier transformed V(q)
866 // whether ccp_rmesh_times * Rcut >= rIJ
867 // skip some IJ pairs
868 auto it_outer = Vq.find(iat0);
869 if (it_outer == Vq.end())
870 continue;
871
872 auto it_inner = it_outer->second.find(index);
873 if (it_inner == it_outer->second.end())
874 continue;
875
876 if (LRI_CV_Tools::exist(Vq.at(iat0).at(index)))
877 {
878 Tout Vq_tmp = LRI_CV_Tools::convert<Tin_convert>(LRI_CV_Tools::mul2(frac, Vq.at(iat0).at(index)));
879
880 if (!LRI_CV_Tools::exist(local_datas[iat0][list_A1_pair_R[i1]]))
881 local_datas[iat0][list_A1_pair_R[i1]] = Vq_tmp;
882 else
883 local_datas[iat0][list_A1_pair_R[i1]]
884 = local_datas.at(iat0).at(list_A1_pair_R[i1]) + Vq_tmp;
885 }
886 }
887 }
888 }
889#pragma omp critical(Ewald_Vq_set_Vs_dVs)
890 {
891 for (auto& outer_pair: local_datas)
892 {
893 TA key0 = outer_pair.first;
894 for (auto& inner_pair: outer_pair.second)
895 {
896 TAC key1 = inner_pair.first;
897 Tout& value = inner_pair.second;
898 if (!LRI_CV_Tools::exist(datas[key0][key1]))
899 datas[key0][key1] = value;
900 else
901 datas[key0][key1] = datas.at(key0).at(key1) + value;
902 }
903 }
904 }
905 }
906 // auto end = std::chrono::system_clock::now();
907 // auto duration
908 // = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
909 // std::cout << "set_Vs_dVs Time: "
910 // << double(duration.count())
911 // * std::chrono::microseconds::period::num
912 // / std::chrono::microseconds::period::den
913 // << " s" << std::endl;
914
915 ModuleBase::timer::end("Ewald_Vq", "set_Vs_dVs");
916 return datas;
917}
918
919template <typename Tdata>
920std::vector<std::vector<std::vector<Numerical_Orbital_Lm>>> Ewald_Vq<Tdata>::init_gauss(
921 std::vector<std::vector<std::vector<Numerical_Orbital_Lm>>>& orb_in)
922{
923 std::vector<std::vector<std::vector<Numerical_Orbital_Lm>>> gauss;
924 gauss.resize(orb_in.size());
925 for (size_t T = 0; T != orb_in.size(); ++T)
926 {
927 gauss[T].resize(orb_in[T].size());
928 for (size_t L = 0; L != orb_in[T].size(); ++L)
929 {
930 gauss[T][L].resize(orb_in[T][L].size());
931 for (size_t N = 0; N != orb_in[T][L].size(); ++N)
932 {
933 gauss[T][L][N] = this->gaussian_abfs.Gauss(orb_in[T][L][N], this->ewald_lambda);
934 }
935 }
936 }
937
938 return gauss;
939}
940
941#endif
RI_2D_Comm.h
RI_Util.h
Abfs::Vector3_Order
Definition abfs-vector3_order.h:16
Ewald_Vq
Definition ewald_Vq.h:23
Ewald_Vq::cal_V_Rcut
double cal_V_Rcut(const int it0, const int it1)
Definition ewald_Vq.hpp:228
Ewald_Vq::TK
std::array< int, 1 > TK
Definition ewald_Vq.h:46
Ewald_Vq::cal_Vq
std::map< TA, std::map< TAK, RI::Tensor< std::complex< double > > > > cal_Vq(const UnitCell &ucell, const double &chi, std::map< TA, std::map< TAC, RI::Tensor< Tdata > > > &Vs_in)
Definition ewald_Vq.hpp:583
Ewald_Vq::set_Vs_dVs
std::map< TA, std::map< TAC, Tout > > set_Vs_dVs(const UnitCell &ucell, const std::vector< TA > &list_A0_pair_R, const std::vector< TAC > &list_A1_pair_R, std::map< TA, std::map< TAK, Tin > > &Vq)
Ewald_Vq::set_Vq_dVq_minus_gauss
std::map< TA, std::map< TAK, Tout > > set_Vq_dVq_minus_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0, const std::vector< TAC > &list_A1, std::map< TA, std::map< TAC, Tin > > &Vs_dVs_minus_gauss)
Ewald_Vq::init
void init(const UnitCell &ucell, const LCAO_Orbitals &orb, const MPI_Comm &mpi_comm_in, const K_Vectors *kv_in, std::vector< std::vector< std::vector< Numerical_Orbital_Lm > > > &lcaos_in, std::vector< std::vector< std::vector< Numerical_Orbital_Lm > > > &abfs_in, const std::map< Conv_Coulomb_Pot_K::Coulomb_Type, std::vector< std::map< std::string, std::string > > > &coulomb_param_in, std::shared_ptr< ORB_gaunt_table > MGT_in, const double &ccp_rmesh_times_in, const double &kmesh_times_in)
Definition ewald_Vq.hpp:34
Ewald_Vq::get_singular_chi
double get_singular_chi(const UnitCell &ucell, const std::vector< std::map< std::string, std::string > > &param_list, const double &qdiv)
Definition ewald_Vq.hpp:132
Ewald_Vq::set_Vs_dVs_minus_gauss
std::map< TA, std::map< TAC, Tresult > > set_Vs_dVs_minus_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0, const std::vector< TAC > &list_A1, std::map< TA, std::map< TAC, Tresult > > &Vs_dVs_in, std::map< TA, std::map< TAC, Tresult > > &Vs_dVs_gauss_in)
Ewald_Vq::get_Rcut_max
double get_Rcut_max(const int it0, const int it1)
Definition ewald_Vq.hpp:234
Ewald_Vq::cal_dVq
std::map< TA, std::map< TAK, std::array< RI::Tensor< std::complex< double > >, Ndim > > > cal_dVq(const UnitCell &ucell, const double &chi, std::map< TA, std::map< TAC, std::array< RI::Tensor< Tdata >, Ndim > > > &dVs_in)
Definition ewald_Vq.hpp:623
Ewald_Vq::init_ions
void init_ions(const UnitCell &ucell, const std::array< Tcell, Ndim > &period_Vs_NAO)
Definition ewald_Vq.hpp:83
Ewald_Vq::cal_dVs_gauss
std::map< TA, std::map< TAC, std::array< RI::Tensor< Tdata >, Ndim > > > cal_dVs_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0, const std::vector< TAC > &list_A1)
Definition ewald_Vq.hpp:175
Ewald_Vq::set_Vq_dVq
std::map< TA, std::map< TAK, Tout > > set_Vq_dVq(const UnitCell &ucell, const std::vector< TA > &list_A0_pair_k, const std::vector< TAK > &list_A1_pair_k, std::map< TA, std::map< TAC, Tin > > &Vs_dVs_minus_gauss_in, const T_func_DPcal_Vq_dVq_minus_gauss< Tout, Tin > &func_cal_Vq_dVq_minus_gauss, const T_func_DPcal_Vq_dVq_gauss< Tout > &func_cal_Vq_dVq_gauss)
Ewald_Vq::TAC
std::pair< TA, TC > TAC
Definition ewald_Vq.h:44
Ewald_Vq::T_func_DPget_Vq_dVq
std::function< Tresult(const int &lp_max, const int &lq_max, const size_t &ik, const ModuleBase::Vector3< double > &tau)> T_func_DPget_Vq_dVq
Definition ewald_Vq.h:166
Ewald_Vq::T_func_DPcal_Vq_dVq_minus_gauss
std::function< std::map< TA, std::map< TAK, Tout > >(std::map< TA, std::map< TAC, Tin > > &Vs_dVs_minus_gauss)> T_func_DPcal_Vq_dVq_minus_gauss
Definition ewald_Vq.h:204
Ewald_Vq::cal_Vs_minus_gauss
std::map< TA, std::map< TAC, RI::Tensor< Tdata > > > cal_Vs_minus_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0, const std::vector< TAC > &list_A1, std::map< TA, std::map< TAC, RI::Tensor< Tdata > > > &Vs_in)
Definition ewald_Vq.hpp:192
Ewald_Vq::T_func_DPcal_Vq_dVq_gauss
std::function< std::map< TA, std::map< TAK, Tout > >(const int &shift_for_mpi)> T_func_DPcal_Vq_dVq_gauss
Definition ewald_Vq.h:206
Ewald_Vq::TC
std::array< Tcell, Ndim > TC
Definition ewald_Vq.h:43
Ewald_Vq::cal_dVs
std::map< TA, std::map< TAC, std::array< RI::Tensor< Tdata >, Ndim > > > cal_dVs(const UnitCell &ucell, const double &chi, std::map< TA, std::map< TAC, std::array< RI::Tensor< Tdata >, Ndim > > > &dVs_in)
Definition ewald_Vq.hpp:807
Ewald_Vq::cal_dVq_minus_gauss
std::map< TA, std::map< TAK, std::array< RI::Tensor< std::complex< double > >, Ndim > > > cal_dVq_minus_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0, const std::vector< TAC > &list_A1, std::map< TA, std::map< TAC, std::array< RI::Tensor< Tdata >, Ndim > > > &dVs_minus_gauss)
Definition ewald_Vq.hpp:469
Ewald_Vq::cal_Vs
std::map< TA, std::map< TAC, RI::Tensor< Tdata > > > cal_Vs(const UnitCell &ucell, const double &chi, std::map< TA, std::map< TAC, RI::Tensor< Tdata > > > &Vs_in)
Definition ewald_Vq.hpp:788
Ewald_Vq::set_Vq_dVq_gauss
std::map< TA, std::map< TAK, Tresult > > set_Vq_dVq_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0_k, const std::vector< TAK > &list_A1_k, const int &shift_for_mpi, const T_func_DPget_Vq_dVq< Tresult > &func_DPget_Vq_dVq)
Ewald_Vq::cal_Vq_minus_gauss
std::map< TA, std::map< TAK, RI::Tensor< std::complex< double > > > > cal_Vq_minus_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0, const std::vector< TAC > &list_A1, std::map< TA, std::map< TAC, RI::Tensor< Tdata > > > &Vs_minus_gauss)
Definition ewald_Vq.hpp:452
Ewald_Vq::TA
int TA
The Ewald summation decomposes the bare Coulomb interaction into two components: the short-range cont...
Definition ewald_Vq.h:40
Ewald_Vq::Ewald_Vq
Ewald_Vq()
Definition ewald_Vq.hpp:28
Ewald_Vq::TAK
std::pair< TA, TK > TAK
Definition ewald_Vq.h:47
Ewald_Vq::~Ewald_Vq
~Ewald_Vq()
Definition ewald_Vq.hpp:31
Ewald_Vq::cal_Vq_gauss
std::map< TA, std::map< TAK, RI::Tensor< std::complex< double > > > > cal_Vq_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0_k, const std::vector< TAK > &list_A1_k, const double &chi, const int &shift_for_mpi)
Definition ewald_Vq.hpp:326
Ewald_Vq::init_gauss
std::vector< std::vector< std::vector< Numerical_Orbital_Lm > > > init_gauss(std::vector< std::vector< std::vector< Numerical_Orbital_Lm > > > &orb_in)
Definition ewald_Vq.hpp:920
Ewald_Vq::cal_dVs_minus_gauss
std::map< TA, std::map< TAC, std::array< RI::Tensor< Tdata >, Ndim > > > cal_dVs_minus_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0, const std::vector< TAC > &list_A1, std::map< TA, std::map< TAC, std::array< RI::Tensor< Tdata >, Ndim > > > &dVs_in)
Definition ewald_Vq.hpp:210
Ewald_Vq::cal_dVq_gauss
std::map< TA, std::map< TAK, std::array< RI::Tensor< std::complex< double > >, Ndim > > > cal_dVq_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0_k, const std::vector< TAK > &list_A1_k, const double &chi, const int &shift_for_mpi)
Definition ewald_Vq.hpp:351
Ewald_Vq::cal_Vs_gauss
std::map< TA, std::map< TAC, RI::Tensor< Tdata > > > cal_Vs_gauss(const UnitCell &ucell, const std::vector< TA > &list_A0, const std::vector< TAC > &list_A1)
Definition ewald_Vq.hpp:160
Exx_Abfs::Construct_Orbs::get_multipole
static std::vector< std::vector< std::vector< double > > > get_multipole(const std::vector< std::vector< std::vector< Numerical_Orbital_Lm > > > &orb_in)
Definition exx_abfs-construct_orbs.cpp:497
Exx_Abfs::Construct_Orbs::get_Rcut
static std::vector< double > get_Rcut(const std::vector< std::vector< std::vector< Numerical_Orbital_Lm > > > &orb_in)
Definition exx_abfs-construct_orbs.cpp:524
Gaussian_Abfs::get_Vq
RI::Tensor< std::complex< double > > get_Vq(const int &lp_max, const int &lq_max, const size_t &ik, const double &chi, const ModuleBase::Vector3< double > &tau, const ModuleBase::realArray &gaunt)
Definition gaussian_abfs.cpp:101
Gaussian_Abfs::get_dVq
std::array< RI::Tensor< std::complex< double > >, 3 > get_dVq(const int &lp_max, const int &lq_max, const size_t &ik, const double &chi, const ModuleBase::Vector3< double > &tau, const ModuleBase::realArray &gaunt)
Definition gaussian_abfs.cpp:134
K_Vectors
Definition klist.h:12
K_Vectors::get_nkstot_full
int get_nkstot_full() const
Definition klist.h:78
LCAO_Orbitals
Definition ORB_read.h:18
ModuleBase::Vector3
3 elements vector
Definition vector3.h:24
ModuleBase::Vector3::norm
T norm(void) const
Get the norm of a Vector3.
Definition vector3.h:216
ModuleBase::timer::start
static void start(void)
Start total time calculation.
Definition timer.cpp:44
ModuleBase::timer::end
static void end(const std::string &class_name_in, const std::string &name_in)
Definition timer.cpp:109
UnitCell
Definition unitcell.h:15
UnitCell::nat
int & nat
Definition unitcell.h:74
UnitCell::G
ModuleBase::Matrix3 & G
Definition unitcell.h:67
conv_coulomb_pot_k.h
element_basis_index-ORB.h
element_basis_index.h
N
#define N
Definition exp.cpp:24
T
#define T
Definition exp.cpp:237
exx_abfs-construct_orbs.h
gaussian_abfs.h
param
Parameter param
Definition io_system_variable_test.cpp:38
Conv_Coulomb_Pot_K::Coulomb_Type
Coulomb_Type
Definition conv_coulomb_pot_k.h:10
Conv_Coulomb_Pot_K::cal_orbs_ccp
T cal_orbs_ccp(const T &orbs, const std::map< Conv_Coulomb_Pot_K::Coulomb_Type, std::vector< std::map< std::string, std::string > > > &coulomb_param, const double rmesh_times)
GlobalC::exx_info
Exx_Info exx_info
Definition exx_info.cpp:8
LRI_CV_Tools::get_CVws
std::map< int, std::map< int, std::map< Abfs::Vector3_Order< double >, RI::Tensor< Tdata > > > > get_CVws(const UnitCell &ucell, const std::map< TA, std::map< std::pair< TA, std::array< Tcell, 3 > >, RI::Tensor< Tdata > > > &CVs)
Definition LRI_CV_Tools.hpp:385
LRI_CV_Tools::get_dCVws
std::map< int, std::map< int, std::map< Abfs::Vector3_Order< double >, std::array< RI::Tensor< Tdata >, 3 > > > > get_dCVws(const UnitCell &ucell, const std::map< TA, std::map< std::pair< TA, std::array< Tcell, 3 > >, std::array< RI::Tensor< Tdata >, 3 > > > &dCVs)
Definition LRI_CV_Tools.hpp:412
LRI_CV_Tools::mul2
std::vector< RI::Tensor< Tdata > > mul2(const std::vector< std::vector< RI::Tensor< Tdata > > > &mat, const std::vector< RI::Tensor< Tdata > > &vec)
Definition LRI_CV_Tools.hpp:89
LRI_CV_Tools::minus
std::vector< std::array< T, N > > minus(const std::vector< std::array< T, N > > &v1, const std::vector< std::array< T, N > > &v2)
Definition LRI_CV_Tools.hpp:165
LRI_CV_Tools::init_elem
void init_elem(Tdata &data, const size_t ndim0, const size_t ndim1)
Definition LRI_CV_Tools.h:185
LRI_CV_Tools::add_elem
void add_elem(Tdata &data, const Tdata &val, const Tdata &frac)
Definition LRI_CV_Tools.h:193
LRI_CV_Tools::exist
bool exist(const RI::Tensor< Tdata > &V)
Definition LRI_CV_Tools.hpp:53
ModuleBase::Element_Basis_Index::construct_range
Range construct_range(const LCAO_Orbitals &orb)
Definition element_basis_index-ORB.cpp:10
ModuleBase::Element_Basis_Index::construct_index
IndexLNM construct_index(const Range &range)
Definition element_basis_index.cpp:12
ModuleBase::Element_Basis_Index::Range
std::vector< std::vector< NM > > Range
Definition element_basis_index.h:41
ModuleBase::TWO_PI
const double TWO_PI
Definition constants.h:21
ModuleBase::IMAG_UNIT
const std::complex< double > IMAG_UNIT(0.0, 1.0)
ModuleBase::TITLE
void TITLE(const std::string &class_name, const std::string &function_name, const bool disable)
Definition tool_title.cpp:18
RI_2D_Comm::comm_map2_first
std::map< TA, std::map< TAC, T > > comm_map2_first(const MPI_Comm &mpi_comm, const std::map< TA, std::map< TAC, T > > &Ds_in, const std::set< TA > &s0, const std::set< TA > &s1)
Definition RI_2D_Comm.hpp:495
RI_Util::array3_to_Vector3
ModuleBase::Vector3< Tcell > array3_to_Vector3(const std::array< Tcell, 3 > &v)
Definition RI_Util.h:38
Singular_Value::cal_massidda
double cal_massidda(const UnitCell &ucell, const std::array< int, 3 > &nmp, const int &qdiv, const double &start_lambda, const int &niter, const double &eps)
Definition singular_value.cpp:167
Singular_Value::cal_carrier
double cal_carrier(const UnitCell &ucell, const std::vector< ModuleBase::Vector3< double > > &kvec_c, const int &qdiv, const double &qdense, const int &niter, const double &eps, const int &a_rate)
Definition singular_value.cpp:106
singular_value.h
LRI_CV_Tools::TinType
Definition LRI_CV_Tools.h:170
tool_title.h
Generated by doxygen 1.9.8