(git:b279b6b)
shg_integrals_test.F
Go to the documentation of this file.
1 !--------------------------------------------------------------------------------------------------!
2 ! CP2K: A general program to perform molecular dynamics simulations !
3 ! Copyright 2000-2024 CP2K developers group <https://cp2k.org> !
4 ! !
5 ! SPDX-License-Identifier: GPL-2.0-or-later !
6 !--------------------------------------------------------------------------------------------------!
7 
8 ! **************************************************************************************************
9 !> \brief Calculates 2-center integrals for different r12 operators comparing the Solid harmonic
10 !> Gaussian integral scheme to the Obara-Saika (OS) scheme
11 !> \author Dorothea Golze [05.2016]
12 ! **************************************************************************************************
13 MODULE shg_integrals_test
14 
15  USE basis_set_types, ONLY: allocate_gto_basis_set,&
16  deallocate_gto_basis_set,&
17  gto_basis_set_type,&
18  init_orb_basis_set,&
19  read_gto_basis_set
20  USE constants_operator, ONLY: operator_coulomb,&
21  operator_gauss,&
22  operator_verf,&
23  operator_verfc,&
24  operator_vgauss
25  USE cp_log_handling, ONLY: cp_to_string
26  USE generic_os_integrals, ONLY: int_operators_r12_ab_os,&
27  int_overlap_ab_os,&
28  int_overlap_aba_os,&
29  int_overlap_abb_os,&
30  int_ra2m_ab_os
31  USE generic_shg_integrals, ONLY: int_operators_r12_ab_shg,&
32  int_overlap_ab_shg,&
33  int_overlap_aba_shg,&
34  int_overlap_abb_shg,&
35  int_ra2m_ab_shg
36  USE generic_shg_integrals_init, ONLY: contraction_matrix_shg,&
37  contraction_matrix_shg_mix,&
38  contraction_matrix_shg_rx2m,&
39  get_clebsch_gordon_coefficients
40  USE input_cp2k_subsys, ONLY: create_basis_section
41  USE input_keyword_types, ONLY: keyword_create,&
42  keyword_release,&
43  keyword_type
44  USE input_section_types, ONLY: &
45  section_add_keyword, section_add_subsection, section_create, section_release, &
46  section_type, section_vals_get, section_vals_get_subs_vals, section_vals_type, &
47  section_vals_val_get
48  USE input_val_types, ONLY: real_t
49  USE kinds, ONLY: default_string_length,&
50  dp
51  USE orbital_pointers, ONLY: init_orbital_pointers
52  USE orbital_transformation_matrices, ONLY: init_spherical_harmonics
53 #include "./base/base_uses.f90"
54 
55  IMPLICIT NONE
56 
57  PRIVATE
58 
59 ! **************************************************************************************************
60 
61  CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'shg_integrals_test'
62 
63  PUBLIC :: create_shg_integrals_test_section, shg_integrals_perf_acc_test
64 
65 CONTAINS
66 
67 ! **************************************************************************************************
68 !> \brief Create input section for unit testing
69 !> \param section ...
70 ! **************************************************************************************************
71  SUBROUTINE create_shg_integrals_test_section(section)
72  TYPE(section_type), INTENT(INOUT), POINTER :: section
73 
74  TYPE(keyword_type), POINTER :: keyword
75  TYPE(section_type), POINTER :: subsection
76 
77  NULLIFY (keyword, subsection)
78 
79  cpassert(.NOT. ASSOCIATED(section))
80  CALL section_create(section, __location__, name="SHG_INTEGRALS_TEST", &
81  description="Parameters for testing the SHG 2-center integrals for "// &
82  "different r12 operators. Test w.r.t. performance and accurarcy.", &
83  n_keywords=4, n_subsections=1)
84 
85  CALL create_basis_section(subsection)
86  CALL section_add_subsection(section, subsection)
87  CALL section_release(subsection)
88 
89  CALL keyword_create(keyword, __location__, &
90  name="_SECTION_PARAMETERS_", &
91  description="Controls the activation the SHG integral test. ", &
92  default_l_val=.false., &
93  lone_keyword_l_val=.true.)
94  CALL section_add_keyword(section, keyword)
95  CALL keyword_release(keyword)
96 
97  CALL keyword_create(keyword, __location__, name="ABC", &
98  description="Specify the lengths of the cell vectors A, B, and C. ", &
99  usage="ABC 10.000 10.000 10.000", unit_str="angstrom", &
100  n_var=3, type_of_var=real_t)
101  CALL section_add_keyword(section, keyword)
102  CALL keyword_release(keyword)
103 
104  CALL keyword_create(keyword, __location__, name="NAB_MIN", &
105  description="Minimum number of atomic distances to consider. ", &
106  default_i_val=8)
107  CALL section_add_keyword(section, keyword)
108  CALL keyword_release(keyword)
109 
110  CALL keyword_create(keyword, __location__, name="NREP", &
111  description="Number of repeated calculation of each integral. ", &
112  default_i_val=1)
113  CALL section_add_keyword(section, keyword)
114  CALL keyword_release(keyword)
115 
116  CALL keyword_create(keyword, __location__, name="CHECK_ACCURACY", &
117  description="Causes abortion when SHG and OS integrals differ "// &
118  "more what's given by ACCURACY_LEVEL.", &
119  default_l_val=.true., lone_keyword_l_val=.true.)
120  CALL section_add_keyword(section, keyword)
121  CALL keyword_release(keyword)
122 
123  CALL keyword_create(keyword, __location__, name="ACCURACY_LEVEL", &
124  description="Level of accuracy for comparison of SHG and OS "// &
125  "integrals.", &
126  default_r_val=1.0e-8_dp)
127  CALL section_add_keyword(section, keyword)
128  CALL keyword_release(keyword)
129 
130  CALL keyword_create(keyword, __location__, name="CALCULATE_DERIVATIVES", &
131  description="Calculates also the derivatives of the integrals.", &
132  default_l_val=.false., lone_keyword_l_val=.true.)
133  CALL section_add_keyword(section, keyword)
134  CALL keyword_release(keyword)
135 
136  CALL keyword_create(keyword, __location__, name="TEST_OVERLAP", &
137  description="Calculates the integrals (a|b).", &
138  default_l_val=.false., lone_keyword_l_val=.true.)
139  CALL section_add_keyword(section, keyword)
140  CALL keyword_release(keyword)
141 
142  CALL keyword_release(keyword)
143  CALL keyword_create(keyword, __location__, name="TEST_COULOMB", &
144  description="Calculates the integrals (a|1/r12|b).", &
145  default_l_val=.false., lone_keyword_l_val=.true.)
146  CALL section_add_keyword(section, keyword)
147  CALL keyword_release(keyword)
148 
149  CALL keyword_create(keyword, __location__, name="TEST_VERF", &
150  description="Calculates the integrals (a|erf(omega*r12)/r12|b).", &
151  default_l_val=.false., lone_keyword_l_val=.true.)
152  CALL section_add_keyword(section, keyword)
153  CALL keyword_release(keyword)
154 
155  CALL keyword_create(keyword, __location__, name="TEST_VERFC", &
156  description="Calculates the integrals (a|erfc(omega*r12)/r12|b).", &
157  default_l_val=.false., lone_keyword_l_val=.true.)
158  CALL section_add_keyword(section, keyword)
159  CALL keyword_release(keyword)
160 
161  CALL keyword_create(keyword, __location__, name="TEST_VGAUSS", &
162  description="Calculates the integrals (a|exp(omega*r12^2)/r12|b).", &
163  default_l_val=.false., lone_keyword_l_val=.true.)
164  CALL section_add_keyword(section, keyword)
165  CALL keyword_release(keyword)
166 
167  CALL keyword_create(keyword, __location__, name="TEST_GAUSS", &
168  description="Calculates the integrals (a|exp(omega*r12^2)|b).", &
169  default_l_val=.false., lone_keyword_l_val=.true.)
170  CALL section_add_keyword(section, keyword)
171  CALL keyword_release(keyword)
172 
173  CALL keyword_create(keyword, __location__, name="TEST_RA2M", &
174  description="Calculates the integrals (a|(r-Ra)^(2m)|b).", &
175  default_l_val=.false., lone_keyword_l_val=.true.)
176  CALL section_add_keyword(section, keyword)
177  CALL keyword_release(keyword)
178 
179  CALL keyword_create(keyword, __location__, name="M", &
180  description="Exponent in integral (a|(r-Ra)^(2m)|b).", &
181  default_i_val=1)
182  CALL section_add_keyword(section, keyword)
183  CALL keyword_release(keyword)
184 
185  CALL keyword_create(keyword, __location__, name="TEST_OVERLAP_ABA", &
186  description="Calculates the integrals (a|b|b).", &
187  default_l_val=.false., lone_keyword_l_val=.true.)
188  CALL section_add_keyword(section, keyword)
189  CALL keyword_release(keyword)
190 
191  CALL keyword_create(keyword, __location__, name="TEST_OVERLAP_ABB", &
192  description="Calculates the integrals (a|b|b).", &
193  default_l_val=.false., lone_keyword_l_val=.true.)
194  CALL section_add_keyword(section, keyword)
195  CALL keyword_release(keyword)
196 
197  END SUBROUTINE create_shg_integrals_test_section
198 
199 ! **************************************************************************************************
200 !> \brief Unit test for performance and accuracy of the SHG integrals
201 !> \param iw output unit
202 !> \param shg_integrals_test_section ...
203 ! **************************************************************************************************
204  SUBROUTINE shg_integrals_perf_acc_test(iw, shg_integrals_test_section)
205  INTEGER, INTENT(IN) :: iw
206  TYPE(section_vals_type), INTENT(INOUT), POINTER :: shg_integrals_test_section
207 
208  CHARACTER(len=*), PARAMETER :: routinen = 'shg_integrals_perf_acc_test'
209 
210  CHARACTER(LEN=default_string_length) :: basis_type
211  INTEGER :: count_ab, handle, iab, jab, kab, lamax, &
212  lbmax, lcamax, lcbmax, lmax, nab, &
213  nab_min, nab_xyz, nrep, nrep_bas
214  LOGICAL :: acc_check, calc_derivatives, &
215  test_overlap_aba, test_overlap_abb
216  REAL(kind=dp) :: acc_param
217  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: rab
218  REAL(kind=dp), DIMENSION(:), POINTER :: cell_par
219  REAL(kind=dp), DIMENSION(:, :, :), POINTER :: scona_shg, sconb_shg
220  TYPE(gto_basis_set_type), POINTER :: fba, fbb, oba, obb
221  TYPE(section_vals_type), POINTER :: basis_section
222 
223  CALL timeset(routinen, handle)
224  NULLIFY (oba, obb, fba, fbb, basis_section, cell_par)
225  CALL section_vals_val_get(shg_integrals_test_section, "ABC", r_vals=cell_par)
226  CALL section_vals_val_get(shg_integrals_test_section, "NAB_MIN", i_val=nab_min)
227  CALL section_vals_val_get(shg_integrals_test_section, "NREP", i_val=nrep)
228  CALL section_vals_val_get(shg_integrals_test_section, "CHECK_ACCURACY", l_val=acc_check)
229  CALL section_vals_val_get(shg_integrals_test_section, "ACCURACY_LEVEL", r_val=acc_param)
230  CALL section_vals_val_get(shg_integrals_test_section, "CALCULATE_DERIVATIVES", l_val=calc_derivatives)
231  CALL section_vals_val_get(shg_integrals_test_section, "TEST_OVERLAP_ABA", l_val=test_overlap_aba)
232  CALL section_vals_val_get(shg_integrals_test_section, "TEST_OVERLAP_ABB", l_val=test_overlap_abb)
233 
234  !*** Read the basis set information
235  basis_section => section_vals_get_subs_vals(shg_integrals_test_section, "BASIS")
236  CALL section_vals_get(basis_section, n_repetition=nrep_bas)
237  IF (.NOT. (nrep_bas == 2 .OR. nrep_bas == 3)) THEN
238  CALL cp_abort(__location__, &
239  "Provide basis sets")
240  END IF
241  CALL allocate_gto_basis_set(oba)
242  CALL read_gto_basis_set(trim("A"), basis_type, oba, basis_section, irep=1)
243  lamax = maxval(oba%lmax)
244  CALL allocate_gto_basis_set(obb)
245  CALL read_gto_basis_set(trim("B"), basis_type, obb, basis_section, irep=2)
246  lbmax = maxval(obb%lmax)
247  lmax = max(lamax, lbmax)
248  IF (test_overlap_aba) THEN
249  CALL allocate_gto_basis_set(fba)
250  CALL read_gto_basis_set(trim("CA"), basis_type, fba, basis_section, irep=3)
251  lcamax = maxval(fba%lmax)
252  lmax = max(lamax + lcamax, lbmax)
253  END IF
254  IF (test_overlap_abb) THEN
255  CALL allocate_gto_basis_set(fbb)
256  CALL read_gto_basis_set(trim("CB"), basis_type, fbb, basis_section, irep=3)
257  lcbmax = maxval(fbb%lmax)
258  lmax = max(lamax, lbmax + lcbmax)
259  END IF
260  IF (test_overlap_aba .AND. test_overlap_abb) THEN
261  lmax = max(max(lamax + lcamax, lbmax), max(lamax, lbmax + lcbmax))
262  END IF
263  !*** Initialize basis set information
264  CALL init_orbital_pointers(lmax + 1)
265  CALL init_spherical_harmonics(lmax, output_unit=-100)
266  oba%norm_type = 2
267  CALL init_orb_basis_set(oba)
268  obb%norm_type = 2
269  CALL init_orb_basis_set(obb)
270  IF (test_overlap_aba) THEN
271  fba%norm_type = 2
272  CALL init_orb_basis_set(fba)
273  END IF
274  IF (test_overlap_abb) THEN
275  fbb%norm_type = 2
276  CALL init_orb_basis_set(fbb)
277  END IF
278  ! if shg integrals are later actually used in the code, contraction_matrix_shg should be
279  ! moved to init_orb_basis_set and scon_shg should become an element of gto_basis_set_type
280  CALL contraction_matrix_shg(oba, scona_shg)
281  CALL contraction_matrix_shg(obb, sconb_shg)
282 
283  !*** Create range of rab (atomic distances) to be tested
284  nab_xyz = ceiling(real(nab_min, kind=dp)**(1.0_dp/3.0_dp) - 1.0e-06)
285  nab = nab_xyz**3
286 
287  ALLOCATE (rab(3, nab))
288  count_ab = 0
289  DO iab = 1, nab_xyz
290  DO jab = 1, nab_xyz
291  DO kab = 1, nab_xyz
292  count_ab = count_ab + 1
293  rab(:, count_ab) = [iab*abs(cell_par(1)), jab*abs(cell_par(2)), kab*abs(cell_par(3))]/nab_xyz
294  END DO
295  END DO
296  END DO
297 
298  !*** Calculate the SHG integrals
299 
300  CALL test_shg_operator12_integrals(oba, obb, rab, nrep, scona_shg, sconb_shg, &
301  shg_integrals_test_section, acc_check, &
302  acc_param, calc_derivatives, iw)
303 
304  CALL test_shg_overlap_integrals(oba, obb, rab, nrep, scona_shg, sconb_shg, &
305  shg_integrals_test_section, acc_check, &
306  acc_param, calc_derivatives, iw)
307  CALL test_shg_ra2m_integrals(oba, obb, rab, nrep, scona_shg, sconb_shg, &
308  shg_integrals_test_section, acc_check, &
309  acc_param, calc_derivatives, iw)
310 
311  CALL test_shg_overlap_aba_integrals(oba, obb, fba, fbb, rab, nrep, scona_shg, sconb_shg, &
312  shg_integrals_test_section, acc_check, &
313  acc_param, calc_derivatives, iw)
314 
315  DEALLOCATE (scona_shg, sconb_shg, rab)
316  CALL deallocate_gto_basis_set(oba)
317  CALL deallocate_gto_basis_set(obb)
318  IF (test_overlap_aba) CALL deallocate_gto_basis_set(fba)
319  IF (test_overlap_abb) CALL deallocate_gto_basis_set(fbb)
320 
321  CALL timestop(handle)
322 
323  END SUBROUTINE shg_integrals_perf_acc_test
324 
325 ! **************************************************************************************************
326 !> \brief tests two-center integrals of the type [a|O(r12)|b]
327 !> \param oba basis set on a
328 !> \param obb basis set on b
329 !> \param rab distance between a and b
330 !> \param nrep ...
331 !> \param scona_shg SHG contraction matrix for a
332 !> \param sconb_shg SHG contraction matrix for b
333 !> \param shg_integrals_test_section ...
334 !> \param acc_check if accuracy is checked
335 !> \param acc_param accuracy level, if deviation larger abort
336 !> \param calc_derivatives ...
337 !> \param iw ...
338 ! **************************************************************************************************
339  SUBROUTINE test_shg_operator12_integrals(oba, obb, rab, nrep, scona_shg, sconb_shg, &
340  shg_integrals_test_section, acc_check, &
341  acc_param, calc_derivatives, iw)
342  TYPE(gto_basis_set_type), POINTER :: oba, obb
343  REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: rab
344  INTEGER, INTENT(IN) :: nrep
345  REAL(kind=dp), DIMENSION(:, :, :), POINTER :: scona_shg, sconb_shg
346  TYPE(section_vals_type), INTENT(IN), POINTER :: shg_integrals_test_section
347  LOGICAL, INTENT(IN) :: acc_check
348  REAL(kind=dp), INTENT(IN) :: acc_param
349  LOGICAL, INTENT(IN) :: calc_derivatives
350  INTEGER, INTENT(IN) :: iw
351 
352  INTEGER :: iab, irep, nab, nfa, nfb
353  LOGICAL :: test_any, test_coulomb, test_gauss, &
354  test_verf, test_verfc, test_vgauss
355  REAL(kind=dp) :: ddmax_coulomb, ddmax_gauss, ddmax_verf, ddmax_verfc, ddmax_vgauss, ddtemp, &
356  dmax_coulomb, dmax_gauss, dmax_verf, dmax_verfc, dmax_vgauss, dtemp, omega
357  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: vab_os, vab_shg
358  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: dvab_os, dvab_shg
359 
360  CALL section_vals_val_get(shg_integrals_test_section, "TEST_COULOMB", l_val=test_coulomb)
361  CALL section_vals_val_get(shg_integrals_test_section, "TEST_VERF", l_val=test_verf)
362  CALL section_vals_val_get(shg_integrals_test_section, "TEST_VERFC", l_val=test_verfc)
363  CALL section_vals_val_get(shg_integrals_test_section, "TEST_VGAUSS", l_val=test_vgauss)
364  CALL section_vals_val_get(shg_integrals_test_section, "TEST_GAUSS", l_val=test_gauss)
365 
366  test_any = (test_coulomb .OR. test_verf .OR. test_verfc .OR. test_vgauss .OR. test_gauss)
367 
368  IF (test_any) THEN
369  nfa = oba%nsgf
370  nfb = obb%nsgf
371  ALLOCATE (vab_shg(nfa, nfb), dvab_shg(nfa, nfb, 3))
372  ALLOCATE (vab_os(nfa, nfb), dvab_os(nfa, nfb, 3))
373  omega = 2.3_dp
374  dmax_coulomb = 0.0_dp
375  ddmax_coulomb = 0.0_dp
376  dmax_verf = 0.0_dp
377  ddmax_verf = 0.0_dp
378  dmax_verfc = 0.0_dp
379  ddmax_verfc = 0.0_dp
380  dmax_vgauss = 0.0_dp
381  ddmax_vgauss = 0.0_dp
382  dmax_gauss = 0.0_dp
383  ddmax_gauss = 0.0_dp
384 
385  nab = SIZE(rab, 2)
386  DO irep = 1, nrep
387  DO iab = 1, nab
388  !*** Coulomb: (a|1/r12|b)
389  IF (test_coulomb) THEN
390  CALL int_operators_r12_ab_shg(operator_coulomb, vab_shg, dvab_shg, rab(:, iab), &
391  oba, obb, scona_shg, sconb_shg, &
392  calculate_forces=calc_derivatives)
393  CALL int_operators_r12_ab_os(operator_coulomb, vab_os, dvab_os, rab(:, iab), &
394  oba, obb, calculate_forces=calc_derivatives)
395  CALL calculate_deviation_ab(vab_shg, vab_os, dvab_shg, dvab_os, dtemp, ddtemp)
396  dmax_coulomb = max(dmax_coulomb, dtemp)
397  ddmax_coulomb = max(ddmax_coulomb, ddtemp)
398  END IF
399  !*** verf: (a|erf(omega*r12)/r12|b)
400  IF (test_verf) THEN
401  CALL int_operators_r12_ab_shg(operator_verf, vab_shg, dvab_shg, rab(:, iab), &
402  oba, obb, scona_shg, sconb_shg, omega, &
403  calc_derivatives)
404  CALL int_operators_r12_ab_os(operator_verf, vab_os, dvab_os, rab(:, iab), &
405  oba, obb, omega=omega, calculate_forces=calc_derivatives)
406  CALL calculate_deviation_ab(vab_shg, vab_os, dvab_shg, dvab_os, dtemp, ddtemp)
407  dmax_verf = max(dmax_verf, dtemp)
408  ddmax_verf = max(ddmax_verf, ddtemp)
409  END IF
410  !*** verfc: (a|erfc(omega*r12)/r12|b)
411  IF (test_verfc) THEN
412  CALL int_operators_r12_ab_shg(operator_verfc, vab_shg, dvab_shg, rab(:, iab), &
413  oba, obb, scona_shg, sconb_shg, omega, &
414  calc_derivatives)
415  CALL int_operators_r12_ab_os(operator_verfc, vab_os, dvab_os, rab(:, iab), &
416  oba, obb, omega=omega, calculate_forces=calc_derivatives)
417  CALL calculate_deviation_ab(vab_shg, vab_os, dvab_shg, dvab_os, dtemp, ddtemp)
418  dmax_verfc = max(dmax_verfc, dtemp)
419  ddmax_verfc = max(ddmax_verfc, ddtemp)
420  END IF
421  !*** vgauss: (a|exp(omega*r12^2)/r12|b)
422  IF (test_vgauss) THEN
423  CALL int_operators_r12_ab_shg(operator_vgauss, vab_shg, dvab_shg, rab(:, iab), &
424  oba, obb, scona_shg, sconb_shg, omega, &
425  calc_derivatives)
426  CALL int_operators_r12_ab_os(operator_vgauss, vab_os, dvab_os, rab(:, iab), &
427  oba, obb, omega=omega, calculate_forces=calc_derivatives)
428  CALL calculate_deviation_ab(vab_shg, vab_os, dvab_shg, dvab_os, dtemp, ddtemp)
429  dmax_vgauss = max(dmax_vgauss, dtemp)
430  ddmax_vgauss = max(ddmax_vgauss, ddtemp)
431  END IF
432  !*** gauss: (a|exp(omega*r12^2)|b)
433  IF (test_gauss) THEN
434  CALL int_operators_r12_ab_shg(operator_gauss, vab_shg, dvab_shg, rab(:, iab), &
435  oba, obb, scona_shg, sconb_shg, omega, &
436  calc_derivatives)
437  CALL int_operators_r12_ab_os(operator_gauss, vab_os, dvab_os, rab(:, iab), &
438  oba, obb, omega=omega, calculate_forces=calc_derivatives)
439  CALL calculate_deviation_ab(vab_shg, vab_os, dvab_shg, dvab_os, dtemp, ddtemp)
440  dmax_gauss = max(dmax_gauss, dtemp)
441  ddmax_gauss = max(ddmax_gauss, ddtemp)
442  END IF
443  END DO
444  END DO
445 
446  IF (iw > 0) THEN
447  WRITE (iw, fmt="(/,T2,A)") "TEST INFO FOR 2-CENTER SHG and OS INTEGRALS:"
448  WRITE (iw, fmt="(T2,A)") "Maximal deviation between SHG and OS integrals and their derivatives"
449  IF (test_coulomb) THEN
450  WRITE (iw, fmt="(T2,A,T53,ES12.5,4X,ES12.5)") "SHG_INTEGRALS | [a|1/r12|b]", &
451  dmax_coulomb, ddmax_coulomb
452  END IF
453  IF (test_verf) THEN
454  WRITE (iw, fmt="(T2,A,T53,ES12.5,4X,ES12.5)") "SHG_INTEGRALS | [a|erf(omega*r12)/r12|b]", &
455  dmax_verf, ddmax_verf
456  END IF
457  IF (test_verfc) THEN
458  WRITE (iw, fmt="(T2,A,T53,ES12.5,4X,ES12.5)") "SHG_INTEGRALS | [a|erfc(omega*r12)/r12|b]", &
459  dmax_verfc, ddmax_verfc
460  END IF
461  IF (test_vgauss) THEN
462  WRITE (iw, fmt="(T2,A,T53,ES12.5,4X,ES12.5)") "SHG_INTEGRALS | [a|exp(-omega*r12^2)/r12|b]", &
463  dmax_vgauss, ddmax_vgauss
464  END IF
465  IF (test_gauss) THEN
466  WRITE (iw, fmt="(T2,A,T53,ES12.5,4X,ES12.5)") "SHG_INTEGRALS | [a|exp(-omega*r12^2)|b]", &
467  dmax_gauss, ddmax_gauss
468  END IF
469 
470  IF (acc_check) THEN
471  IF ((dmax_coulomb >= acc_param) .OR. (ddmax_coulomb >= acc_param)) THEN
472  cpabort("[a|1/r12|b]: Dev. larger than"//cp_to_string(acc_param))
473  END IF
474  IF ((dmax_verf >= acc_param) .OR. (ddmax_verf >= acc_param)) THEN
475  cpabort("[a|erf(omega*r12)/r12|b]: Dev. larger than"//cp_to_string(acc_param))
476  END IF
477  IF ((dmax_verfc >= acc_param) .OR. (ddmax_verfc >= acc_param)) THEN
478  cpabort("[a|erfc(omega*r12)/r12|b]: Dev. larger than"//cp_to_string(acc_param))
479  END IF
480  IF ((dmax_vgauss >= acc_param) .OR. (ddmax_vgauss >= acc_param)) THEN
481  cpabort("[a|exp(-omega*r12^2)/r12|b]: Dev. larger than"//cp_to_string(acc_param))
482  END IF
483  IF ((dmax_gauss >= acc_param) .OR. (ddmax_gauss >= acc_param)) THEN
484  cpabort("[a|exp(-omega*r12^2)|b]: Dev. larger than"//cp_to_string(acc_param))
485  END IF
486  END IF
487  END IF
488  DEALLOCATE (vab_shg, vab_os, dvab_shg, dvab_os)
489  END IF
490 
491  END SUBROUTINE test_shg_operator12_integrals
492 
493 ! **************************************************************************************************
494 !> \brief tests two center overlap integrals [a|b]
495 !> \param oba ...
496 !> \param obb ...
497 !> \param rab ...
498 !> \param nrep ...
499 !> \param scona_shg ...
500 !> \param sconb_shg ...
501 !> \param shg_integrals_test_section ...
502 !> \param acc_check ...
503 !> \param acc_param ...
504 !> \param calc_derivatives ...
505 !> \param iw ...
506 ! **************************************************************************************************
507  SUBROUTINE test_shg_overlap_integrals(oba, obb, rab, nrep, scona_shg, sconb_shg, &
508  shg_integrals_test_section, acc_check, &
509  acc_param, calc_derivatives, iw)
510  TYPE(gto_basis_set_type), POINTER :: oba, obb
511  REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: rab
512  INTEGER, INTENT(IN) :: nrep
513  REAL(kind=dp), DIMENSION(:, :, :), INTENT(IN) :: scona_shg, sconb_shg
514  TYPE(section_vals_type), INTENT(IN), POINTER :: shg_integrals_test_section
515  LOGICAL, INTENT(IN) :: acc_check
516  REAL(kind=dp), INTENT(IN) :: acc_param
517  LOGICAL, INTENT(IN) :: calc_derivatives
518  INTEGER, INTENT(IN) :: iw
519 
520  INTEGER :: iab, irep, nab, nfa, nfb
521  LOGICAL :: test_overlap
522  REAL(kind=dp) :: ddmax_overlap, ddtemp, dmax_overlap, &
523  dtemp, dummy
524  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: sab_os, sab_shg
525  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: dsab_os, dsab_shg
526 
527  CALL section_vals_val_get(shg_integrals_test_section, "TEST_OVERLAP", &
528  l_val=test_overlap)
529  IF (test_overlap) THEN
530  !effectively switch off screening; makes no sense for the tests
531  oba%set_radius(:) = 1.0e+09_dp
532  obb%set_radius(:) = 1.0e+09_dp
533  oba%pgf_radius(:, :) = 1.0e+09_dp
534  obb%pgf_radius(:, :) = 1.0e+09_dp
535  nfa = oba%nsgf
536  nfb = obb%nsgf
537  dummy = 0.0_dp
538  dmax_overlap = 0.0_dp
539  ddmax_overlap = 0.0_dp
540  ALLOCATE (sab_shg(nfa, nfb), dsab_shg(nfa, nfb, 3))
541  ALLOCATE (sab_os(nfa, nfb), dsab_os(nfa, nfb, 3))
542  nab = SIZE(rab, 2)
543  DO irep = 1, nrep
544  DO iab = 1, nab
545  CALL int_overlap_ab_shg(sab_shg, dsab_shg, rab(:, iab), oba, obb, &
546  scona_shg, sconb_shg, calc_derivatives)
547  CALL int_overlap_ab_os(sab_os, dsab_os, rab(:, iab), oba, obb, &
548  calc_derivatives, debug=.false., dmax=dummy)
549  CALL calculate_deviation_ab(sab_shg, sab_os, dsab_shg, dsab_os, dtemp, ddtemp)
550  dmax_overlap = max(dmax_overlap, dtemp)
551  ddmax_overlap = max(ddmax_overlap, ddtemp)
552  END DO
553  END DO
554 
555  IF (iw > 0) THEN
556  WRITE (iw, fmt="(/,T2,A)") "TEST INFO FOR 2-CENTER OVERLAP SHG and OS INTEGRALS:"
557  WRITE (iw, fmt="(T2,A)") "Maximal deviation between SHG and OS integrals and their derivatives"
558  WRITE (iw, fmt="(T2,A,T53,ES12.5,4X,ES12.5)") "SHG_INTEGRALS | [a|b]", &
559  dmax_overlap, ddmax_overlap
560  END IF
561  IF (acc_check) THEN
562  IF ((dmax_overlap >= acc_param) .OR. (ddmax_overlap >= acc_param)) THEN
563  cpabort("[a|b]: Deviation larger than"//cp_to_string(acc_param))
564  END IF
565  END IF
566  DEALLOCATE (sab_shg, sab_os, dsab_shg, dsab_os)
567  END IF
568 
569  END SUBROUTINE test_shg_overlap_integrals
570 
571 ! **************************************************************************************************
572 !> \brief tests two-center integrals of the type [a|(r-Ra)^(2m)|b]
573 !> \param oba ...
574 !> \param obb ...
575 !> \param rab ...
576 !> \param nrep ...
577 !> \param scona_shg ...
578 !> \param sconb_shg ...
579 !> \param shg_integrals_test_section ...
580 !> \param acc_check ...
581 !> \param acc_param ...
582 !> \param calc_derivatives ...
583 !> \param iw ...
584 ! **************************************************************************************************
585  SUBROUTINE test_shg_ra2m_integrals(oba, obb, rab, nrep, scona_shg, sconb_shg, &
586  shg_integrals_test_section, acc_check, &
587  acc_param, calc_derivatives, iw)
588  TYPE(gto_basis_set_type), POINTER :: oba, obb
589  REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: rab
590  INTEGER, INTENT(IN) :: nrep
591  REAL(kind=dp), DIMENSION(:, :, :), INTENT(IN) :: scona_shg, sconb_shg
592  TYPE(section_vals_type), INTENT(IN), POINTER :: shg_integrals_test_section
593  LOGICAL, INTENT(IN) :: acc_check
594  REAL(kind=dp), INTENT(IN) :: acc_param
595  LOGICAL, INTENT(IN) :: calc_derivatives
596  INTEGER, INTENT(IN) :: iw
597 
598  INTEGER :: iab, irep, m, nab, nfa, nfb
599  LOGICAL :: test_ra2m
600  REAL(kind=dp) :: ddmax, ddtemp, dmax, dtemp
601  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: vab_os, vab_shg
602  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: dvab_os, dvab_shg
603  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :, :) :: scon_ra2m
604 
605  CALL section_vals_val_get(shg_integrals_test_section, "TEST_RA2M", &
606  l_val=test_ra2m)
607  IF (test_ra2m) THEN
608  CALL section_vals_val_get(shg_integrals_test_section, "M", &
609  i_val=m)
610  nfa = oba%nsgf
611  nfb = obb%nsgf
612  dmax = 0.0_dp
613  ddmax = 0.0_dp
614  CALL contraction_matrix_shg_rx2m(oba, m, scona_shg, scon_ra2m)
615  ALLOCATE (vab_shg(nfa, nfb), dvab_shg(nfa, nfb, 3))
616  ALLOCATE (vab_os(nfa, nfb), dvab_os(nfa, nfb, 3))
617  nab = SIZE(rab, 2)
618  DO irep = 1, nrep
619  DO iab = 1, nab
620  CALL int_ra2m_ab_shg(vab_shg, dvab_shg, rab(:, iab), oba, obb, &
621  scon_ra2m, sconb_shg, m, calc_derivatives)
622  CALL int_ra2m_ab_os(vab_os, dvab_os, rab(:, iab), oba, obb, m, calc_derivatives)
623  CALL calculate_deviation_ab(vab_shg, vab_os, dvab_shg, dvab_os, dtemp, ddtemp)
624  dmax = max(dmax, dtemp)
625  ddmax = max(ddmax, ddtemp)
626  END DO
627  END DO
628  IF (iw > 0) THEN
629  WRITE (iw, fmt="(/,T2,A)") "TEST INFO FOR 2-CENTER RA2m SHG and OS INTEGRALS:"
630  WRITE (iw, fmt="(T2,A)") "Maximal deviation between SHG and OS integrals and their derivatives"
631  WRITE (iw, fmt="(T2,A,T53,ES12.5,4X,ES12.5)") "SHG_INTEGRALS | [a|(r-Ra)^(2m)|b]", &
632  dmax, ddmax
633  END IF
634  IF (acc_check) THEN
635  IF ((dmax >= acc_param) .OR. (ddmax >= acc_param)) THEN
636  cpabort("[a|ra^(2m)|b]: Deviation larger than"//cp_to_string(acc_param))
637  END IF
638  END IF
639  DEALLOCATE (scon_ra2m)
640  DEALLOCATE (vab_shg, vab_os, dvab_shg, dvab_os)
641  END IF
642  END SUBROUTINE test_shg_ra2m_integrals
643 
644 ! **************************************************************************************************
645 !> \brief test overlap integrals [a|b|a] and [a|b|b]
646 !> \param oba ...
647 !> \param obb ...
648 !> \param fba ...
649 !> \param fbb ...
650 !> \param rab ...
651 !> \param nrep ...
652 !> \param scon_oba ...
653 !> \param scon_obb ...
654 !> \param shg_integrals_test_section ...
655 !> \param acc_check ...
656 !> \param acc_param ...
657 !> \param calc_derivatives ...
658 !> \param iw ...
659 ! **************************************************************************************************
660  SUBROUTINE test_shg_overlap_aba_integrals(oba, obb, fba, fbb, rab, nrep, scon_oba, scon_obb, &
661  shg_integrals_test_section, acc_check, &
662  acc_param, calc_derivatives, iw)
663  TYPE(gto_basis_set_type), POINTER :: oba, obb, fba, fbb
664  REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: rab
665  INTEGER, INTENT(IN) :: nrep
666  REAL(kind=dp), DIMENSION(:, :, :), POINTER :: scon_oba, scon_obb
667  TYPE(section_vals_type), INTENT(IN), POINTER :: shg_integrals_test_section
668  LOGICAL, INTENT(IN) :: acc_check
669  REAL(kind=dp), INTENT(IN) :: acc_param
670  LOGICAL, INTENT(IN) :: calc_derivatives
671  INTEGER, INTENT(IN) :: iw
672 
673  INTEGER :: iab, irep, la_max, lb_max, lbb_max, &
674  maxl_orb, maxl_ri, nab, nba, nbb, nfa, &
675  nfb
676  INTEGER, DIMENSION(:, :), POINTER :: ncg_none0
677  INTEGER, DIMENSION(:, :, :), POINTER :: cg_none0_list, fba_index, fbb_index, &
678  oba_index, obb_index
679  LOGICAL :: test_overlap_aba, test_overlap_abb
680  REAL(kind=dp) :: ddmax_overlap_aba, ddmax_overlap_abb, &
681  ddtemp, dmax_overlap_aba, &
682  dmax_overlap_abb, dtemp, dummy
683  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: saba_os, saba_shg, sabb_os, sabb_shg
684  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :, :) :: dsaba_os, dsaba_shg, dsabb_os, dsabb_shg
685  REAL(kind=dp), DIMENSION(:, :, :), POINTER :: cg_coeff
686  REAL(kind=dp), DIMENSION(:, :, :, :), POINTER :: scona_mix, sconb_mix
687 
688  CALL section_vals_val_get(shg_integrals_test_section, "TEST_OVERLAP_ABA", &
689  l_val=test_overlap_aba)
690  CALL section_vals_val_get(shg_integrals_test_section, "TEST_OVERLAP_ABB", &
691  l_val=test_overlap_abb)
692  IF (test_overlap_aba .OR. test_overlap_abb) THEN
693  !effectively switch off screening; makes no sense for the tests
694  oba%set_radius(:) = 1.0e+09_dp
695  obb%set_radius(:) = 1.0e+09_dp
696  oba%pgf_radius(:, :) = 1.0e+09_dp
697  obb%pgf_radius(:, :) = 1.0e+09_dp
698  nba = oba%nsgf
699  nbb = obb%nsgf
700  maxl_orb = max(maxval(oba%lmax), maxval(obb%lmax))
701  la_max = maxval(oba%lmax)
702  lb_max = maxval(obb%lmax)
703  IF (test_overlap_aba) THEN
704  fba%set_radius(:) = 1.0e+09_dp
705  fba%pgf_radius(:, :) = 1.0e+09_dp
706  nfa = fba%nsgf
707  maxl_ri = maxval(fba%lmax) + 1 ! + 1 to avoid fail for l=0
708  ALLOCATE (saba_shg(nba, nbb, nfa), dsaba_shg(nba, nbb, nfa, 3))
709  ALLOCATE (saba_os(nba, nbb, nfa), dsaba_os(nba, nbb, nfa, 3))
710  CALL contraction_matrix_shg_mix(oba, fba, oba_index, fba_index, scona_mix)
711  END IF
712  IF (test_overlap_abb) THEN
713  fbb%set_radius(:) = 1.0e+09_dp
714  fbb%pgf_radius(:, :) = 1.0e+09_dp
715  nfb = fbb%nsgf
716  maxl_ri = maxval(fbb%lmax) + 1
717  lbb_max = maxval(obb%lmax) + maxval(fbb%lmax)
718  ALLOCATE (sabb_shg(nba, nbb, nfb), dsabb_shg(nba, nbb, nfb, 3))
719  ALLOCATE (sabb_os(nba, nbb, nfb), dsabb_os(nba, nbb, nfb, 3))
720  CALL contraction_matrix_shg_mix(obb, fbb, obb_index, fbb_index, sconb_mix)
721  END IF
722  dummy = 0.0_dp
723  dmax_overlap_aba = 0.0_dp
724  ddmax_overlap_aba = 0.0_dp
725  dmax_overlap_abb = 0.0_dp
726  ddmax_overlap_abb = 0.0_dp
727  CALL get_clebsch_gordon_coefficients(cg_coeff, cg_none0_list, ncg_none0, maxl_orb, maxl_ri)
728  nab = SIZE(rab, 2)
729  IF (test_overlap_aba) THEN
730  DO irep = 1, nrep
731  DO iab = 1, nab
732  CALL int_overlap_aba_shg(saba_shg, dsaba_shg, rab(:, iab), oba, obb, fba, &
733  scon_obb, scona_mix, oba_index, fba_index, &
734  cg_coeff, cg_none0_list, ncg_none0, &
735  calc_derivatives)
736  CALL int_overlap_aba_os(saba_os, dsaba_os, rab(:, iab), oba, obb, fba, &
737  calc_derivatives, debug=.false., dmax=dummy)
738  CALL calculate_deviation_abx(saba_shg, saba_os, dsaba_shg, dsaba_os, dtemp, ddtemp)
739  dmax_overlap_aba = max(dmax_overlap_aba, dtemp)
740  ddmax_overlap_aba = max(ddmax_overlap_aba, ddtemp)
741  END DO
742  END DO
743  DEALLOCATE (oba_index, fba_index, scona_mix)
744  DEALLOCATE (saba_shg, saba_os, dsaba_shg, dsaba_os)
745  END IF
746  IF (test_overlap_abb) THEN
747  DO irep = 1, nrep
748  DO iab = 1, nab
749  CALL int_overlap_abb_shg(sabb_shg, dsabb_shg, rab(:, iab), oba, obb, fbb, &
750  scon_oba, sconb_mix, obb_index, fbb_index, &
751  cg_coeff, cg_none0_list, ncg_none0, &
752  calc_derivatives)
753  CALL int_overlap_abb_os(sabb_os, dsabb_os, rab(:, iab), oba, obb, fbb, &
754  calc_derivatives, debug=.false., dmax=dummy)
755  CALL calculate_deviation_abx(sabb_shg, sabb_os, dsabb_shg, dsabb_os, dtemp, ddtemp)
756  dmax_overlap_abb = max(dmax_overlap_abb, dtemp)
757  ddmax_overlap_abb = max(ddmax_overlap_abb, ddtemp)
758  END DO
759  END DO
760  DEALLOCATE (obb_index, fbb_index, sconb_mix)
761  DEALLOCATE (sabb_shg, sabb_os, dsabb_shg, dsabb_os)
762  END IF
763  IF (iw > 0) THEN
764  WRITE (iw, fmt="(/,T2,A)") "TEST INFO [a|b|x] OVERLAP SHG and OS INTEGRALS:"
765  WRITE (iw, fmt="(T2,A)") "Maximal deviation between SHG and OS integrals and their derivatives"
766  IF (test_overlap_aba) THEN
767  WRITE (iw, fmt="(T2,A,T53,ES12.5,4X,ES12.5)") "SHG_INTEGRALS | [a|b|a]", &
768  dmax_overlap_aba, ddmax_overlap_aba
769  END IF
770  IF (test_overlap_abb) THEN
771  WRITE (iw, fmt="(T2,A,T53,ES12.5,4X,ES12.5)") "SHG_INTEGRALS | [a|b|b]", &
772  dmax_overlap_abb, ddmax_overlap_abb
773  END IF
774  END IF
775  IF (acc_check) THEN
776  IF ((dmax_overlap_aba >= acc_param) .OR. (ddmax_overlap_aba >= acc_param)) THEN
777  cpabort("[a|b|a]: Dev. larger than"//cp_to_string(acc_param))
778  END IF
779  IF ((dmax_overlap_abb >= acc_param) .OR. (ddmax_overlap_abb >= acc_param)) THEN
780  cpabort("[a|b|b]: Dev. larger than"//cp_to_string(acc_param))
781  END IF
782  END IF
783  DEALLOCATE (cg_coeff, cg_none0_list, ncg_none0)
784  END IF
785 
786  END SUBROUTINE test_shg_overlap_aba_integrals
787 
788 ! **************************************************************************************************
789 !> \brief Calculation of the deviation between SHG and OS integrals
790 !> \param vab_shg integral matrix obtained from the SHG scheme
791 !> \param vab_os integral matrix obtained from the OS scheme
792 !> \param dvab_shg derivative of the integrals, SHG
793 !> \param dvab_os derivative of the integrals, OS
794 !> \param dmax maximal deviation of vab matrices
795 !> \param ddmax maximal deviation of dvab matrices
796 ! **************************************************************************************************
797  SUBROUTINE calculate_deviation_ab(vab_shg, vab_os, dvab_shg, dvab_os, dmax, ddmax)
798 
799  REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: vab_shg, vab_os
800  REAL(kind=dp), DIMENSION(:, :, :), INTENT(IN) :: dvab_shg, dvab_os
801  REAL(kind=dp), INTENT(OUT) :: dmax, ddmax
802 
803  INTEGER :: i, j, k
804  REAL(kind=dp) :: diff
805 
806  dmax = 0.0_dp
807  ddmax = 0.0_dp
808 
809  ! integrals vab
810  DO j = 1, SIZE(vab_shg, 2)
811  DO i = 1, SIZE(vab_shg, 1)
812  diff = abs(vab_shg(i, j) - vab_os(i, j))
813  dmax = max(dmax, diff)
814  END DO
815  END DO
816 
817  ! derivatives dvab
818  DO k = 1, 3
819  DO j = 1, SIZE(dvab_shg, 2)
820  DO i = 1, SIZE(dvab_shg, 1)
821  diff = abs(dvab_shg(i, j, k) - dvab_os(i, j, k))
822  ddmax = max(ddmax, diff)
823  END DO
824  END DO
825  END DO
826 
827  END SUBROUTINE calculate_deviation_ab
828 
829 ! **************************************************************************************************
830 !> \brief Calculation of the deviation between SHG and OS integrals
831 !> \param vab_shg integral matrix obtained from the SHG scheme
832 !> \param vab_os integral matrix obtained from the OS scheme
833 !> \param dvab_shg derivative of the integrals, SHG
834 !> \param dvab_os derivative of the integrals, OS
835 !> \param dmax maximal deviation of vab matrices
836 !> \param ddmax maximal deviation of dvab matrices
837 ! **************************************************************************************************
838  SUBROUTINE calculate_deviation_abx(vab_shg, vab_os, dvab_shg, dvab_os, dmax, ddmax)
839 
840  REAL(kind=dp), DIMENSION(:, :, :), INTENT(IN) :: vab_shg, vab_os
841  REAL(kind=dp), DIMENSION(:, :, :, :), INTENT(IN) :: dvab_shg, dvab_os
842  REAL(kind=dp), INTENT(OUT) :: dmax, ddmax
843 
844  INTEGER :: i, j, k, l
845  REAL(kind=dp) :: diff
846 
847  dmax = 0.0_dp
848  ddmax = 0.0_dp
849 
850  ! integrals vab
851  DO k = 1, SIZE(vab_shg, 3)
852  DO j = 1, SIZE(vab_shg, 2)
853  DO i = 1, SIZE(vab_shg, 1)
854  diff = abs(vab_shg(i, j, k) - vab_os(i, j, k))
855  dmax = max(dmax, diff)
856  END DO
857  END DO
858  END DO
859 
860  ! derivatives dvab
861  DO l = 1, 3
862  DO k = 1, SIZE(dvab_shg, 3)
863  DO j = 1, SIZE(dvab_shg, 2)
864  DO i = 1, SIZE(dvab_shg, 1)
865  diff = abs(dvab_shg(i, j, k, l) - dvab_os(i, j, k, l))
866  ddmax = max(ddmax, diff)
867  END DO
868  END DO
869  END DO
870  END DO
871 
872  END SUBROUTINE calculate_deviation_abx
873 
874 END MODULE shg_integrals_test
basis_set_types
Definition: basis_set_types.F:15
basis_set_types::deallocate_gto_basis_set
subroutine, public deallocate_gto_basis_set(gto_basis_set)
...
Definition: basis_set_types.F:168
basis_set_types::allocate_gto_basis_set
subroutine, public allocate_gto_basis_set(gto_basis_set)
...
Definition: basis_set_types.F:150
basis_set_types::init_orb_basis_set
subroutine, public init_orb_basis_set(gto_basis_set)
Initialise a Gaussian-type orbital (GTO) basis set data set.
Definition: basis_set_types.F:1057
constants_operator
constants for the different operators of the 2c-integrals
Definition: constants_operator.F:14
constants_operator::operator_gauss
integer, parameter, public operator_gauss
Definition: constants_operator.F:22
constants_operator::operator_verf
integer, parameter, public operator_verf
Definition: constants_operator.F:22
constants_operator::operator_vgauss
integer, parameter, public operator_vgauss
Definition: constants_operator.F:22
constants_operator::operator_verfc
integer, parameter, public operator_verfc
Definition: constants_operator.F:22
constants_operator::operator_coulomb
integer, parameter, public operator_coulomb
Definition: constants_operator.F:22
cp_log_handling
various routines to log and control the output. The idea is that decisions about where to log should ...
Definition: cp_log_handling.F:41
generic_os_integrals
Calculation of contracted, spherical Gaussian integrals using the (OS) integral scheme....
Definition: generic_os_integrals.F:18
generic_os_integrals::int_overlap_aba_os
subroutine, public int_overlap_aba_os(abaint, dabdaint, rab, oba, obb, fba, calculate_forces, debug, dmax)
calculate integrals (a,b,fa)
Definition: generic_os_integrals.F:506
generic_os_integrals::int_overlap_ab_os
subroutine, public int_overlap_ab_os(sab, dsab, rab, fba, fbb, calculate_forces, debug, dmax)
calculate overlap integrals (a,b)
Definition: generic_os_integrals.F:270
generic_os_integrals::int_overlap_abb_os
subroutine, public int_overlap_abb_os(abbint, dabbint, rab, oba, obb, fbb, calculate_forces, debug, dmax)
calculate integrals (a,b,fb)
Definition: generic_os_integrals.F:667
generic_os_integrals::int_operators_r12_ab_os
subroutine, public int_operators_r12_ab_os(r12_operator, vab, dvab, rab, fba, fbb, omega, r_cutoff, calculate_forces)
Calcululates the two-center integrals of the type (a|O(r12)|b) using the OS scheme.
Definition: generic_os_integrals.F:78
generic_os_integrals::int_ra2m_ab_os
subroutine, public int_ra2m_ab_os(sab, dsab, rab, fba, fbb, m, calculate_forces)
calculate integrals (a|(r-Ra)^(2m)|b)
Definition: generic_os_integrals.F:398
generic_shg_integrals_init
Initialization for solid harmonic Gaussian (SHG) integral scheme. Scheme for calculation of contracte...
Definition: generic_shg_integrals_init.F:16
generic_shg_integrals_init::contraction_matrix_shg_rx2m
subroutine, public contraction_matrix_shg_rx2m(basis, m, scon_shg, scon_rx2m)
...
Definition: generic_shg_integrals_init.F:253
generic_shg_integrals_init::contraction_matrix_shg_mix
subroutine, public contraction_matrix_shg_mix(orb_basis, ri_basis, orb_index, ri_index, scon_mix)
mixed contraction matrix for SHG integrals [aba] and [abb] for orbital and ri basis at the same atom
Definition: generic_shg_integrals_init.F:135
generic_shg_integrals_init::contraction_matrix_shg
subroutine, public contraction_matrix_shg(basis, scon_shg)
contraction matrix for SHG integrals
Definition: generic_shg_integrals_init.F:49
generic_shg_integrals_init::get_clebsch_gordon_coefficients
subroutine, public get_clebsch_gordon_coefficients(my_cg, cg_none0_list, ncg_none0, maxl1, maxl2)
calculate the Clebsch-Gordon (CG) coefficients for expansion of the product of two spherical harmonic...
Definition: generic_shg_integrals_init.F:308
generic_shg_integrals
Calculation of contracted, spherical Gaussian integrals using the solid harmonic Gaussian (SHG) integ...
Definition: generic_shg_integrals.F:21
generic_shg_integrals::int_overlap_aba_shg
subroutine, public int_overlap_aba_shg(saba, dsaba, rab, oba, obb, fba, scon_obb, scona_mix, oba_index, fba_index, cg_coeff, cg_none0_list, ncg_none0, calculate_forces)
calculate integrals (a,b,fa)
Definition: generic_shg_integrals.F:251
generic_shg_integrals::int_overlap_ab_shg
subroutine, public int_overlap_ab_shg(vab, dvab, rab, fba, fbb, scona_shg, sconb_shg, calculate_forces)
calculate overlap integrals (a,b)
Definition: generic_shg_integrals.F:165
generic_shg_integrals::int_ra2m_ab_shg
subroutine, public int_ra2m_ab_shg(vab, dvab, rab, fba, fbb, scon_ra2m, sconb_shg, m, calculate_forces)
Calcululates the two-center integrals of the type (a|(r-Ra)^(2m)|b) using the SHG scheme.
Definition: generic_shg_integrals.F:205
generic_shg_integrals::int_overlap_abb_shg
subroutine, public int_overlap_abb_shg(sabb, dsabb, rab, oba, obb, fbb, scon_oba, sconb_mix, obb_index, fbb_index, cg_coeff, cg_none0_list, ncg_none0, calculate_forces)
calculate integrals (a,b,fb)
Definition: generic_shg_integrals.F:307
generic_shg_integrals::int_operators_r12_ab_shg
subroutine, public int_operators_r12_ab_shg(r12_operator, vab, dvab, rab, fba, fbb, scona_shg, sconb_shg, omega, calculate_forces)
Calcululates the two-center integrals of the type (a|O(r12)|b) using the SHG scheme.
Definition: generic_shg_integrals.F:100
input_cp2k_subsys
builds the subsystem section of the input
Definition: input_cp2k_subsys.F:14
input_cp2k_subsys::create_basis_section
subroutine, public create_basis_section(section)
Creates the &BASIS section.
Definition: input_cp2k_subsys.F:849
input_keyword_types
represents keywords in an input
Definition: input_keyword_types.F:14
input_keyword_types::keyword_release
subroutine, public keyword_release(keyword)
releases the given keyword (see doc/ReferenceCounting.html)
Definition: input_keyword_types.F:426
input_keyword_types::keyword_create
subroutine, public keyword_create(keyword, location, name, description, usage, type_of_var, n_var, repeats, variants, default_val, default_l_val, default_r_val, default_lc_val, default_c_val, default_i_val, default_l_vals, default_r_vals, default_c_vals, default_i_vals, lone_keyword_val, lone_keyword_l_val, lone_keyword_r_val, lone_keyword_c_val, lone_keyword_i_val, lone_keyword_l_vals, lone_keyword_r_vals, lone_keyword_c_vals, lone_keyword_i_vals, enum_c_vals, enum_i_vals, enum, enum_strict, enum_desc, unit_str, citations, deprecation_notice, removed)
creates a keyword object
Definition: input_keyword_types.F:155
input_section_types
objects that represent the structure of input sections and the data contained in an input section
Definition: input_section_types.F:15
input_section_types::section_create
subroutine, public section_create(section, location, name, description, n_keywords, n_subsections, repeats, citations)
creates a list of keywords
Definition: input_section_types.F:156
input_section_types::section_add_keyword
subroutine, public section_add_keyword(section, keyword)
adds a keyword to the given section
Definition: input_section_types.F:504
input_section_types::section_add_subsection
subroutine, public section_add_subsection(section, subsection)
adds a subsection to the given section
Definition: input_section_types.F:560
input_section_types::section_vals_get_subs_vals
recursive type(section_vals_type) function, pointer, public section_vals_get_subs_vals(section_vals, subsection_name, i_rep_section, can_return_null)
returns the values of the requested subsection
Definition: input_section_types.F:724
input_section_types::section_release
recursive subroutine, public section_release(section)
releases the given keyword list (see doc/ReferenceCounting.html)
Definition: input_section_types.F:231
input_section_types::section_vals_get
subroutine, public section_vals_get(section_vals, ref_count, n_repetition, n_subs_vals_rep, section, explicit)
returns various attributes about the section_vals
Definition: input_section_types.F:697
input_section_types::section_vals_val_get
subroutine, public section_vals_val_get(section_vals, keyword_name, i_rep_section, i_rep_val, n_rep_val, val, l_val, i_val, r_val, c_val, l_vals, i_vals, r_vals, c_vals, explicit)
returns the requested value
Definition: input_section_types.F:1040
input_val_types
a wrapper for basic fortran types.
Definition: input_val_types.F:14
input_val_types::real_t
integer, parameter, public real_t
Definition: input_val_types.F:41
kinds
Defines the basic variable types.
Definition: kinds.F:23
kinds::dp
integer, parameter, public dp
Definition: kinds.F:34
kinds::default_string_length
integer, parameter, public default_string_length
Definition: kinds.F:57
orbital_pointers
Provides Cartesian and spherical orbital pointers and indices.
Definition: orbital_pointers.F:15
orbital_pointers::init_orbital_pointers
subroutine, public init_orbital_pointers(maxl)
Initialize or update the orbital pointers.
Definition: orbital_pointers.F:253
orbital_transformation_matrices
Calculation of the spherical harmonics and the corresponding orbital transformation matrices.
Definition: orbital_transformation_matrices.F:17
orbital_transformation_matrices::init_spherical_harmonics
subroutine, public init_spherical_harmonics(maxl, output_unit)
Initialize or update the orbital transformation matrices.
Definition: orbital_transformation_matrices.F:256
shg_integrals_test
Calculates 2-center integrals for different r12 operators comparing the Solid harmonic Gaussian integ...
Definition: shg_integrals_test.F:13
shg_integrals_test::shg_integrals_perf_acc_test
subroutine, public shg_integrals_perf_acc_test(iw, shg_integrals_test_section)
Unit test for performance and accuracy of the SHG integrals.
Definition: shg_integrals_test.F:205
shg_integrals_test::create_shg_integrals_test_section
subroutine, public create_shg_integrals_test_section(section)
Create input section for unit testing.
Definition: shg_integrals_test.F:72