(git:e7e05ae)
generic_os_integrals.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 Calculation of contracted, spherical Gaussian integrals using the (OS) integral
10 !> scheme. Routines for the following two-center integrals:
11 !> i) (a|O(r12)|b) where O(r12) is the overlap, coulomb operator etc.
12 !> ii) (aba) and (abb) s-overlaps
13 !> \par History
14 !> created [06.2015]
15 !> 05.2019: Added truncated coulomb operator (A. Bussy)
16 !> \author Dorothea Golze
17 ! **************************************************************************************************
18 MODULE generic_os_integrals
19  USE ai_contraction_sphi, ONLY: ab_contract,&
20  abc_contract,&
21  abcd_contract
22  USE ai_derivatives, ONLY: dabdr_noscreen
23  USE ai_operator_ra2m, ONLY: operator_ra2m
24  USE ai_operators_r12, ONLY: ab_sint_os,&
25  cps_coulomb2,&
26  cps_gauss2,&
27  cps_truncated2,&
28  cps_verf2,&
29  cps_verfc2,&
30  cps_vgauss2,&
31  operator2
32  USE ai_overlap, ONLY: overlap_aab,&
33  overlap_ab,&
34  overlap_abb
35  USE ai_overlap_aabb, ONLY: overlap_aabb
36  USE basis_set_types, ONLY: get_gto_basis_set,&
37  gto_basis_set_type
38  USE constants_operator, ONLY: operator_coulomb,&
39  operator_gauss,&
40  operator_truncated,&
41  operator_verf,&
42  operator_verfc,&
43  operator_vgauss
44  USE debug_os_integrals, ONLY: overlap_aabb_test,&
45  overlap_ab_test,&
46  overlap_abc_test
47  USE kinds, ONLY: dp
48  USE orbital_pointers, ONLY: ncoset
49 #include "./base/base_uses.f90"
50 
51  IMPLICIT NONE
52 
53  PRIVATE
54 
55 ! **************************************************************************************************
56 
57  CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'generic_os_integrals'
58 
59  PUBLIC :: int_operators_r12_ab_os, int_overlap_ab_os, int_ra2m_ab_os, int_overlap_aba_os, &
60  int_overlap_abb_os, int_overlap_aabb_os
61 
62 CONTAINS
63 
64 ! **************************************************************************************************
65 !> \brief Calcululates the two-center integrals of the type (a|O(r12)|b) using the OS scheme
66 !> \param r12_operator the integral operator, which depends on r12=|r1-r2|
67 !> \param vab integral matrix of spherical contracted Gaussian functions
68 !> \param dvab derivative of the integrals
69 !> \param rab distance vector between center A and B
70 !> \param fba basis at center A
71 !> \param fbb basis at center B
72 !> \param omega parameter in the operator
73 !> \param r_cutoff the cutoff in case of truncated coulomb operator
74 !> \param calculate_forces ...
75 ! **************************************************************************************************
76  SUBROUTINE int_operators_r12_ab_os(r12_operator, vab, dvab, rab, fba, fbb, omega, r_cutoff, &
77  calculate_forces)
78 
79  INTEGER, INTENT(IN) :: r12_operator
80  REAL(kind=dp), DIMENSION(:, :), INTENT(INOUT) :: vab
81  REAL(kind=dp), DIMENSION(:, :, :), INTENT(INOUT), &
82  OPTIONAL :: dvab
83  REAL(kind=dp), DIMENSION(3), INTENT(IN) :: rab
84  TYPE(gto_basis_set_type), POINTER :: fba, fbb
85  REAL(kind=dp), INTENT(IN), OPTIONAL :: omega, r_cutoff
86  LOGICAL, INTENT(IN) :: calculate_forces
87 
88  CHARACTER(LEN=*), PARAMETER :: routinen = 'int_operators_r12_ab_os'
89 
90  INTEGER :: handle
91  REAL(kind=dp) :: my_omega, my_r_cutoff
92 
93  PROCEDURE(ab_sint_os), POINTER :: cps_operator2
94 
95  NULLIFY (cps_operator2)
96  CALL timeset(routinen, handle)
97 
98  my_omega = 1.0_dp
99  my_r_cutoff = 1.0_dp
100 
101  SELECT CASE (r12_operator)
102  CASE (operator_coulomb)
103  cps_operator2 => cps_coulomb2
104  CASE (operator_verf)
105  cps_operator2 => cps_verf2
106  IF (PRESENT(omega)) my_omega = omega
107  CASE (operator_verfc)
108  cps_operator2 => cps_verfc2
109  IF (PRESENT(omega)) my_omega = omega
110  CASE (operator_vgauss)
111  cps_operator2 => cps_vgauss2
112  IF (PRESENT(omega)) my_omega = omega
113  CASE (operator_gauss)
114  cps_operator2 => cps_gauss2
115  IF (PRESENT(omega)) my_omega = omega
116  CASE (operator_truncated)
117  cps_operator2 => cps_truncated2
118  IF (PRESENT(r_cutoff)) my_r_cutoff = r_cutoff
119  CASE DEFAULT
120  cpabort("Operator not available")
121  END SELECT
122 
123  CALL int_operator_ab_os_low(cps_operator2, vab, dvab, rab, fba, fbb, my_omega, my_r_cutoff, &
124  calculate_forces)
125 
126  CALL timestop(handle)
127 
128  END SUBROUTINE int_operators_r12_ab_os
129 
130 ! **************************************************************************************************
131 !> \brief calculate integrals (a|O(r12)|b)
132 !> \param cps_operator2 procedure pointer for the respective operator.
133 !> \param vab integral matrix of spherical contracted Gaussian functions
134 !> \param dvab derivative of the integrals
135 !> \param rab distance vector between center A and B
136 !> \param fba basis at center A
137 !> \param fbb basis at center B
138 !> \param omega parameter in the operator
139 !> \param r_cutoff ...
140 !> \param calculate_forces ...
141 ! **************************************************************************************************
142  SUBROUTINE int_operator_ab_os_low(cps_operator2, vab, dvab, rab, fba, fbb, omega, r_cutoff, &
143  calculate_forces)
144 
145  PROCEDURE(ab_sint_os), POINTER :: cps_operator2
146  REAL(kind=dp), DIMENSION(:, :), INTENT(INOUT) :: vab
147  REAL(kind=dp), DIMENSION(:, :, :), OPTIONAL, &
148  INTENT(INOUT) :: dvab
149  REAL(kind=dp), DIMENSION(3), INTENT(IN) :: rab
150  TYPE(gto_basis_set_type), POINTER :: fba, fbb
151  REAL(kind=dp), INTENT(IN) :: omega, r_cutoff
152  LOGICAL, INTENT(IN) :: calculate_forces
153 
154  CHARACTER(LEN=*), PARAMETER :: routinen = 'int_operator_ab_os_low'
155 
156  INTEGER :: handle, i, iset, jset, lds, m1, m2, &
157  maxco, maxcoa, maxcob, maxl, maxla, &
158  maxlb, ncoa, ncoap, ncob, ncobp, &
159  nseta, nsetb, sgfa, sgfb
160  INTEGER, DIMENSION(:), POINTER :: la_max, la_min, lb_max, lb_min, npgfa, &
161  npgfb, nsgfa, nsgfb
162  INTEGER, DIMENSION(:, :), POINTER :: first_sgfa, first_sgfb
163  REAL(kind=dp) :: dab, rab2
164  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: vac, vac_plus
165  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: devab, vwork
166  REAL(kind=dp), DIMENSION(:, :), POINTER :: sphi_a, sphi_b, zeta, zetb
167 
168  CALL timeset(routinen, handle)
169  NULLIFY (la_max, la_min, lb_max, lb_min, npgfa, npgfb, nsgfa, nsgfb, &
170  first_sgfa, first_sgfb, sphi_a, sphi_b, zeta, zetb)
171 
172  ! basis ikind
173  first_sgfa => fba%first_sgf
174  la_max => fba%lmax
175  la_min => fba%lmin
176  npgfa => fba%npgf
177  nseta = fba%nset
178  nsgfa => fba%nsgf_set
179  sphi_a => fba%sphi
180  zeta => fba%zet
181  ! basis jkind
182  first_sgfb => fbb%first_sgf
183  lb_max => fbb%lmax
184  lb_min => fbb%lmin
185  npgfb => fbb%npgf
186  nsetb = fbb%nset
187  nsgfb => fbb%nsgf_set
188  sphi_b => fbb%sphi
189  zetb => fbb%zet
190 
191  CALL get_gto_basis_set(fba, maxco=maxcoa, maxl=maxla)
192  CALL get_gto_basis_set(fbb, maxco=maxcob, maxl=maxlb)
193  maxco = max(maxcoa, maxcob)
194  IF (calculate_forces) THEN
195  maxl = max(maxla + 1, maxlb)
196  ELSE
197  maxl = max(maxla, maxlb)
198  END IF
199  lds = ncoset(maxl)
200 
201  rab2 = sum(rab*rab)
202  dab = sqrt(rab2)
203 
204  vab = 0.0_dp
205  IF (calculate_forces) dvab = 0.0_dp
206 
207  DO iset = 1, nseta
208 
209  ncoa = npgfa(iset)*ncoset(la_max(iset))
210  ncoap = npgfa(iset)*ncoset(la_max(iset) + 1)
211  sgfa = first_sgfa(1, iset)
212 
213  DO jset = 1, nsetb
214 
215  ncob = npgfb(jset)*ncoset(lb_max(jset))
216  ncobp = npgfb(jset)*ncoset(lb_max(jset) + 1)
217  sgfb = first_sgfb(1, jset)
218  m1 = sgfa + nsgfa(iset) - 1
219  m2 = sgfb + nsgfb(jset) - 1
220 
221  ! calculate integrals
222  IF (calculate_forces) THEN
223  ALLOCATE (vwork(ncoap, ncobp, la_max(iset) + lb_max(jset) + 3), &
224  vac(ncoa, ncob), vac_plus(ncoap, ncobp), devab(ncoa, ncob, 3))
225  devab = 0._dp
226  vwork = 0.0_dp
227  vac = 0.0_dp
228  CALL operator2(cps_operator2, la_max(iset) + 1, npgfa(iset), zeta(:, iset), la_min(iset), &
229  lb_max(jset) + 1, npgfb(jset), zetb(:, jset), lb_min(jset), &
230  omega, r_cutoff, rab, rab2, vac, vwork, maxder=1, vac_plus=vac_plus)
231  CALL dabdr_noscreen(la_max(iset), npgfa(iset), zeta(:, iset), lb_max(jset), npgfb(jset), &
232  vac_plus, devab(:, :, 1), devab(:, :, 2), devab(:, :, 3))
233  DO i = 1, 3
234  CALL ab_contract(dvab(sgfa:m1, sgfb:m2, i), devab(:, :, i), sphi_a(:, sgfa:), &
235  sphi_b(:, sgfb:), ncoa, ncob, nsgfa(iset), nsgfb(jset))
236  END DO
237 
238  ELSE
239  ALLOCATE (vwork(ncoa, ncob, la_max(iset) + lb_max(jset) + 1), &
240  vac(ncoa, ncob), vac_plus(ncoap, ncobp), devab(ncoa, ncob, 3))
241  vwork = 0.0_dp
242  vac = 0.0_dp
243  CALL operator2(cps_operator2, la_max(iset), npgfa(iset), zeta(:, iset), la_min(iset), &
244  lb_max(jset), npgfb(jset), zetb(:, jset), lb_min(jset), &
245  omega, r_cutoff, rab, rab2, vac, vwork)
246  END IF
247 
248  CALL ab_contract(vab(sgfa:m1, sgfb:m2), vac(1:ncoa, 1:ncob), sphi_a(:, sgfa:), sphi_b(:, sgfb:), &
249  ncoa, ncob, nsgfa(iset), nsgfb(jset))
250  DEALLOCATE (vwork, vac, vac_plus, devab)
251  END DO
252  END DO
253 
254  CALL timestop(handle)
255 
256  END SUBROUTINE int_operator_ab_os_low
257 
258 ! **************************************************************************************************
259 !> \brief calculate overlap integrals (a,b)
260 !> \param sab integral (a,b)
261 !> \param dsab derivative of sab with respect to A
262 !> \param rab distance vector between center A and B
263 !> \param fba basis at center A
264 !> \param fbb basis at center B
265 !> \param calculate_forces ...
266 !> \param debug integrals are debugged by recursive routines if requested
267 !> \param dmax maximal deviation between integrals when debugging
268 ! **************************************************************************************************
269  SUBROUTINE int_overlap_ab_os(sab, dsab, rab, fba, fbb, calculate_forces, debug, dmax)
270 
271  REAL(kind=dp), DIMENSION(:, :), INTENT(INOUT) :: sab
272  REAL(kind=dp), DIMENSION(:, :, :), INTENT(INOUT), &
273  OPTIONAL :: dsab
274  REAL(kind=dp), DIMENSION(3), INTENT(IN) :: rab
275  TYPE(gto_basis_set_type), POINTER :: fba, fbb
276  LOGICAL, INTENT(IN) :: calculate_forces, debug
277  REAL(kind=dp), INTENT(INOUT) :: dmax
278 
279  CHARACTER(LEN=*), PARAMETER :: routinen = 'int_overlap_ab_os'
280 
281  INTEGER :: handle, i, iset, jset, m1, m2, maxco, &
282  maxcoa, maxcob, maxl, maxla, maxlb, &
283  ncoa, ncob, nseta, nsetb, sgfa, sgfb
284  INTEGER, DIMENSION(:), POINTER :: la_max, la_min, lb_max, lb_min, npgfa, &
285  npgfb, nsgfa, nsgfb
286  INTEGER, DIMENSION(:, :), POINTER :: first_sgfa, first_sgfb
287  LOGICAL :: failure
288  REAL(kind=dp) :: dab, ra(3), rb(3)
289  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: sint
290  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: dsint
291  REAL(kind=dp), DIMENSION(:), POINTER :: set_radius_a, set_radius_b
292  REAL(kind=dp), DIMENSION(:, :), POINTER :: rpgfa, rpgfb, scon_a, scon_b, zeta, zetb
293 
294  failure = .false.
295  CALL timeset(routinen, handle)
296  NULLIFY (la_max, la_min, lb_max, lb_min, npgfa, npgfb, nsgfa, nsgfb, &
297  first_sgfa, first_sgfb, scon_a, scon_b, zeta, zetb)
298 
299  ! basis ikind
300  first_sgfa => fba%first_sgf
301  la_max => fba%lmax
302  la_min => fba%lmin
303  npgfa => fba%npgf
304  nseta = fba%nset
305  nsgfa => fba%nsgf_set
306  rpgfa => fba%pgf_radius
307  set_radius_a => fba%set_radius
308  scon_a => fba%scon
309  zeta => fba%zet
310  ! basis jkind
311  first_sgfb => fbb%first_sgf
312  lb_max => fbb%lmax
313  lb_min => fbb%lmin
314  npgfb => fbb%npgf
315  nsetb = fbb%nset
316  nsgfb => fbb%nsgf_set
317  rpgfb => fbb%pgf_radius
318  set_radius_b => fbb%set_radius
319  scon_b => fbb%scon
320  zetb => fbb%zet
321 
322  CALL get_gto_basis_set(fba, maxco=maxcoa, maxl=maxla)
323  CALL get_gto_basis_set(fbb, maxco=maxcob, maxl=maxlb)
324  maxco = max(maxcoa, maxcob)
325  maxl = max(maxla, maxlb)
326  ALLOCATE (sint(maxco, maxco))
327  ALLOCATE (dsint(maxco, maxco, 3))
328 
329  dab = sqrt(sum(rab**2))
330 
331  sab = 0.0_dp
332  IF (calculate_forces) THEN
333  IF (PRESENT(dsab)) dsab = 0.0_dp
334  END IF
335 
336  DO iset = 1, nseta
337 
338  ncoa = npgfa(iset)*(ncoset(la_max(iset)) - ncoset(la_min(iset) - 1))
339  sgfa = first_sgfa(1, iset)
340 
341  DO jset = 1, nsetb
342 
343  IF (set_radius_a(iset) + set_radius_b(jset) < dab) cycle
344 
345  ncob = npgfb(jset)*(ncoset(lb_max(jset)) - ncoset(lb_min(jset) - 1))
346  sgfb = first_sgfb(1, jset)
347  m1 = sgfa + nsgfa(iset) - 1
348  m2 = sgfb + nsgfb(jset) - 1
349 
350  IF (calculate_forces) THEN
351  CALL overlap_ab(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
352  lb_max(jset), lb_min(jset), npgfb(jset), rpgfb(:, jset), zetb(:, jset), &
353  rab, sint, dsint)
354  ELSE
355  CALL overlap_ab(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
356  lb_max(jset), lb_min(jset), npgfb(jset), rpgfb(:, jset), zetb(:, jset), &
357  rab, sint)
358 
359  END IF
360 
361  ! debug if requested
362  IF (debug) THEN
363  ra = 0.0_dp
364  rb = rab
365  CALL overlap_ab_test(la_max(iset), la_min(iset), npgfa(iset), zeta(:, iset), &
366  lb_max(jset), lb_min(jset), npgfb(jset), zetb(:, jset), &
367  ra, rb, sint, dmax)
368  END IF
369 
370  CALL ab_contract(sab(sgfa:m1, sgfb:m2), sint(1:ncoa, 1:ncob), scon_a(:, sgfa:), scon_b(:, sgfb:), &
371  ncoa, ncob, nsgfa(iset), nsgfb(jset))
372  IF (calculate_forces) THEN
373  DO i = 1, 3
374  CALL ab_contract(dsab(sgfa:m1, sgfb:m2, i), dsint(1:ncoa, 1:ncob, i), scon_a(:, sgfa:), &
375  scon_b(:, sgfb:), ncoa, ncob, nsgfa(iset), nsgfb(jset))
376  END DO
377  END IF
378  END DO
379  END DO
380 
381  DEALLOCATE (sint, dsint)
382 
383  CALL timestop(handle)
384 
385  END SUBROUTINE int_overlap_ab_os
386 
387 ! **************************************************************************************************
388 !> \brief calculate integrals (a|(r-Ra)^(2m)|b)
389 !> \param sab integral (a|(r-Ra)^(2m)|b)
390 !> \param dsab derivative of sab with respect to A
391 !> \param rab distance vector between center A and B
392 !> \param fba fba basis at center A
393 !> \param fbb fbb basis at center B
394 !> \param m exponent m in operator (r-Ra)^(2m)
395 !> \param calculate_forces ...
396 ! **************************************************************************************************
397  SUBROUTINE int_ra2m_ab_os(sab, dsab, rab, fba, fbb, m, calculate_forces)
398 
399  REAL(kind=dp), DIMENSION(:, :), INTENT(INOUT) :: sab
400  REAL(kind=dp), DIMENSION(:, :, :), INTENT(INOUT), &
401  OPTIONAL :: dsab
402  REAL(kind=dp), DIMENSION(3), INTENT(IN) :: rab
403  TYPE(gto_basis_set_type), POINTER :: fba, fbb
404  INTEGER, INTENT(IN) :: m
405  LOGICAL, INTENT(IN) :: calculate_forces
406 
407  CHARACTER(LEN=*), PARAMETER :: routinen = 'int_ra2m_ab_os'
408 
409  INTEGER :: handle, i, iset, jset, m1, m2, maxco, &
410  maxcoa, maxcob, maxl, maxla, maxlb, &
411  ncoa, ncob, nseta, nsetb, sgfa, sgfb
412  INTEGER, DIMENSION(:), POINTER :: la_max, la_min, lb_max, lb_min, npgfa, &
413  npgfb, nsgfa, nsgfb
414  INTEGER, DIMENSION(:, :), POINTER :: first_sgfa, first_sgfb
415  LOGICAL :: failure
416  REAL(kind=dp) :: dab
417  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: sint
418  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: dsint
419  REAL(kind=dp), DIMENSION(:, :), POINTER :: scon_a, scon_b, zeta, zetb
420 
421  failure = .false.
422  CALL timeset(routinen, handle)
423  NULLIFY (la_max, la_min, lb_max, lb_min, npgfa, npgfb, nsgfa, nsgfb, &
424  first_sgfa, first_sgfb, scon_a, scon_b, zeta, zetb)
425 
426  ! basis ikind
427  first_sgfa => fba%first_sgf
428  la_max => fba%lmax
429  la_min => fba%lmin
430  npgfa => fba%npgf
431  nseta = fba%nset
432  nsgfa => fba%nsgf_set
433  scon_a => fba%scon
434  zeta => fba%zet
435  ! basis jkind
436  first_sgfb => fbb%first_sgf
437  lb_max => fbb%lmax
438  lb_min => fbb%lmin
439  npgfb => fbb%npgf
440  nsetb = fbb%nset
441  nsgfb => fbb%nsgf_set
442  scon_b => fbb%scon
443  zetb => fbb%zet
444 
445  CALL get_gto_basis_set(fba, maxco=maxcoa, maxl=maxla)
446  CALL get_gto_basis_set(fbb, maxco=maxcob, maxl=maxlb)
447  maxco = max(maxcoa, maxcob)
448  maxl = max(maxla, maxlb)
449  ALLOCATE (sint(maxco, maxco))
450  ALLOCATE (dsint(maxco, maxco, 3))
451 
452  dab = sqrt(sum(rab**2))
453 
454  sab = 0.0_dp
455  IF (calculate_forces) THEN
456  IF (PRESENT(dsab)) dsab = 0.0_dp
457  END IF
458 
459  DO iset = 1, nseta
460 
461  ncoa = npgfa(iset)*(ncoset(la_max(iset)) - ncoset(la_min(iset) - 1))
462  sgfa = first_sgfa(1, iset)
463 
464  DO jset = 1, nsetb
465 
466  ncob = npgfb(jset)*(ncoset(lb_max(jset)) - ncoset(lb_min(jset) - 1))
467  sgfb = first_sgfb(1, jset)
468  m1 = sgfa + nsgfa(iset) - 1
469  m2 = sgfb + nsgfb(jset) - 1
470 
471  CALL operator_ra2m(la_max(iset), la_min(iset), npgfa(iset), zeta(:, iset), &
472  lb_max(jset), lb_min(jset), npgfb(jset), zetb(:, jset), &
473  m, rab, sint, dsint, calculate_forces)
474 
475  CALL ab_contract(sab(sgfa:m1, sgfb:m2), sint, scon_a(:, sgfa:), scon_b(:, sgfb:), &
476  ncoa, ncob, nsgfa(iset), nsgfb(jset))
477  IF (calculate_forces) THEN
478  DO i = 1, 3
479  CALL ab_contract(dsab(sgfa:m1, sgfb:m2, i), dsint(:, :, i), scon_a(:, sgfa:), &
480  scon_b(:, sgfb:), ncoa, ncob, nsgfa(iset), nsgfb(jset))
481  END DO
482  END IF
483  END DO
484  END DO
485 
486  DEALLOCATE (sint, dsint)
487 
488  CALL timestop(handle)
489 
490  END SUBROUTINE int_ra2m_ab_os
491 
492 ! **************************************************************************************************
493 !> \brief calculate integrals (a,b,fa)
494 !> \param abaint integral (a,b,fa)
495 !> \param dabdaint derivative of abaint with respect to A
496 !> \param rab distance vector between center A and B
497 !> \param oba orbital basis at center A
498 !> \param obb orbital basis at center B
499 !> \param fba auxiliary basis set at center A
500 !> \param calculate_forces ...
501 !> \param debug integrals are debugged by recursive routines if requested
502 !> \param dmax maximal deviation between integrals when debugging
503 ! **************************************************************************************************
504  SUBROUTINE int_overlap_aba_os(abaint, dabdaint, rab, oba, obb, fba, &
505  calculate_forces, debug, dmax)
506 
507  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: abaint
508  REAL(kind=dp), ALLOCATABLE, &
509  DIMENSION(:, :, :, :), OPTIONAL :: dabdaint
510  REAL(kind=dp), DIMENSION(3), INTENT(IN) :: rab
511  TYPE(gto_basis_set_type), POINTER :: oba, obb, fba
512  LOGICAL, INTENT(IN) :: calculate_forces, debug
513  REAL(kind=dp), INTENT(INOUT) :: dmax
514 
515  CHARACTER(LEN=*), PARAMETER :: routinen = 'int_overlap_aba_os'
516 
517  INTEGER :: handle, i, iset, jset, kaset, m1, m2, &
518  m3, ncoa, ncob, ncoc, nseta, nsetb, &
519  nsetca, sgfa, sgfb, sgfc
520  INTEGER, DIMENSION(:), POINTER :: la_max, la_min, lb_max, lb_min, lca_max, &
521  lca_min, npgfa, npgfb, npgfca, nsgfa, &
522  nsgfb, nsgfca
523  INTEGER, DIMENSION(:, :), POINTER :: first_sgfa, first_sgfb, first_sgfca
524  REAL(kind=dp) :: dab, dac, dbc
525  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: saba
526  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :, :) :: sdaba
527  REAL(kind=dp), DIMENSION(3) :: ra, rac, rb, rbc
528  REAL(kind=dp), DIMENSION(:), POINTER :: set_radius_a, set_radius_b, set_radius_ca
529  REAL(kind=dp), DIMENSION(:, :), POINTER :: rpgfa, rpgfb, rpgfca, scon_a, scon_b, &
530  scon_ca, zeta, zetb, zetca
531 
532  CALL timeset(routinen, handle)
533  NULLIFY (la_max, la_min, lb_max, lb_min, lca_max, lca_min, npgfa, npgfb, &
534  npgfca, nsgfa, nsgfb, nsgfca)
535  NULLIFY (first_sgfa, first_sgfb, first_sgfca, set_radius_a, set_radius_b, &
536  set_radius_ca, rpgfa, rpgfb, rpgfca, scon_a, scon_b, scon_ca, &
537  zeta, zetb, zetca)
538 
539  ! basis ikind
540  first_sgfa => oba%first_sgf
541  la_max => oba%lmax
542  la_min => oba%lmin
543  npgfa => oba%npgf
544  nseta = oba%nset
545  nsgfa => oba%nsgf_set
546  rpgfa => oba%pgf_radius
547  set_radius_a => oba%set_radius
548  scon_a => oba%scon
549  zeta => oba%zet
550  ! basis jkind
551  first_sgfb => obb%first_sgf
552  lb_max => obb%lmax
553  lb_min => obb%lmin
554  npgfb => obb%npgf
555  nsetb = obb%nset
556  nsgfb => obb%nsgf_set
557  rpgfb => obb%pgf_radius
558  set_radius_b => obb%set_radius
559  scon_b => obb%scon
560  zetb => obb%zet
561 
562  ! basis RI A
563  first_sgfca => fba%first_sgf
564  lca_max => fba%lmax
565  lca_min => fba%lmin
566  npgfca => fba%npgf
567  nsetca = fba%nset
568  nsgfca => fba%nsgf_set
569  rpgfca => fba%pgf_radius
570  set_radius_ca => fba%set_radius
571  scon_ca => fba%scon
572  zetca => fba%zet
573 
574  dab = sqrt(sum(rab**2))
575 
576  abaint = 0.0_dp
577  IF (calculate_forces) THEN
578  IF (PRESENT(dabdaint)) dabdaint = 0.0_dp
579  END IF
580 
581  DO iset = 1, nseta
582 
583  ncoa = npgfa(iset)*(ncoset(la_max(iset)) - ncoset(la_min(iset) - 1))
584  sgfa = first_sgfa(1, iset)
585 
586  DO jset = 1, nsetb
587 
588  IF (set_radius_a(iset) + set_radius_b(jset) < dab) cycle
589 
590  ncob = npgfb(jset)*(ncoset(lb_max(jset)) - ncoset(lb_min(jset) - 1))
591  sgfb = first_sgfb(1, jset)
592  m1 = sgfa + nsgfa(iset) - 1
593  m2 = sgfb + nsgfb(jset) - 1
594 
595  ! calculate integrals abaint and derivative [d(a,b,a)/dA] dabdaint if requested
596  rac = 0._dp
597  dac = 0._dp
598  rbc = -rab
599  dbc = dab
600 
601  DO kaset = 1, nsetca
602 
603  IF (set_radius_b(jset) + set_radius_ca(kaset) < dab) cycle
604 
605  ncoc = npgfca(kaset)*(ncoset(lca_max(kaset)) - ncoset(lca_min(kaset) - 1))
606  sgfc = first_sgfca(1, kaset)
607  m3 = sgfc + nsgfca(kaset) - 1
608  IF (ncoa*ncob*ncoc > 0) THEN
609  ALLOCATE (saba(ncoa, ncob, ncoc))
610  ! integrals
611  IF (calculate_forces) THEN
612  ALLOCATE (sdaba(ncoa, ncob, ncoc, 3))
613  CALL overlap_aab(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
614  lca_max(kaset), lca_min(kaset), npgfca(kaset), rpgfca(:, kaset), zetca(:, kaset), &
615  lb_max(jset), lb_min(jset), npgfb(jset), rpgfb(:, jset), zetb(:, jset), &
616  rab, saba=saba, daba=sdaba)
617 
618  DO i = 1, 3
619  CALL abc_contract(dabdaint(sgfa:m1, sgfb:m2, sgfc:m3, i), sdaba(1:ncoa, 1:ncob, 1:ncoc, i), &
620  scon_a(:, sgfa:), scon_b(:, sgfb:), scon_ca(:, sgfc:), &
621  ncoa, ncob, ncoc, nsgfa(iset), nsgfb(jset), nsgfca(kaset))
622  END DO
623 
624  DEALLOCATE (sdaba)
625  ELSE
626  CALL overlap_aab(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
627  lca_max(kaset), lca_min(kaset), npgfca(kaset), rpgfca(:, kaset), zetca(:, kaset), &
628  lb_max(jset), lb_min(jset), npgfb(jset), rpgfb(:, jset), zetb(:, jset), &
629  rab, saba=saba)
630 
631  END IF
632  ! debug if requested
633  IF (debug) THEN
634  ra = 0.0_dp
635  rb = rab
636  CALL overlap_abc_test(la_max(iset), npgfa(iset), zeta(:, iset), la_min(iset), &
637  lb_max(jset), npgfb(jset), zetb(:, jset), lb_min(jset), &
638  lca_max(kaset), npgfca(kaset), zetca(:, kaset), lca_min(kaset), &
639  ra, rb, ra, saba, dmax)
640  END IF
641  CALL abc_contract(abaint(sgfa:m1, sgfb:m2, sgfc:m3), saba(1:ncoa, 1:ncob, 1:ncoc), &
642  scon_a(:, sgfa:), scon_b(:, sgfb:), scon_ca(:, sgfc:), &
643  ncoa, ncob, ncoc, nsgfa(iset), nsgfb(jset), nsgfca(kaset))
644  DEALLOCATE (saba)
645  END IF
646  END DO
647  END DO
648  END DO
649 
650  CALL timestop(handle)
651 
652  END SUBROUTINE int_overlap_aba_os
653 
654 ! **************************************************************************************************
655 !> \brief calculate integrals (a,b,fb)
656 !> \param abbint integral (a,b,fb)
657 !> \param dabbint derivative of abbint with respect to A
658 !> \param rab distance vector between center A and B
659 !> \param oba orbital basis at center A
660 !> \param obb orbital basis at center B
661 !> \param fbb auxiliary basis set at center B
662 !> \param calculate_forces ...
663 !> \param debug integrals are debugged by recursive routines if requested
664 !> \param dmax maximal deviation between integrals when debugging
665 ! **************************************************************************************************
666  SUBROUTINE int_overlap_abb_os(abbint, dabbint, rab, oba, obb, fbb, calculate_forces, debug, dmax)
667 
668  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: abbint
669  REAL(kind=dp), ALLOCATABLE, &
670  DIMENSION(:, :, :, :), OPTIONAL :: dabbint
671  REAL(kind=dp), DIMENSION(3), INTENT(IN) :: rab
672  TYPE(gto_basis_set_type), POINTER :: oba, obb, fbb
673  LOGICAL, INTENT(IN) :: calculate_forces, debug
674  REAL(kind=dp), INTENT(INOUT) :: dmax
675 
676  CHARACTER(LEN=*), PARAMETER :: routinen = 'int_overlap_abb_os'
677 
678  INTEGER :: handle, i, iset, jset, kbset, m1, m2, &
679  m3, ncoa, ncob, ncoc, nseta, nsetb, &
680  nsetcb, sgfa, sgfb, sgfc
681  INTEGER, DIMENSION(:), POINTER :: la_max, la_min, lb_max, lb_min, lcb_max, &
682  lcb_min, npgfa, npgfb, npgfcb, nsgfa, &
683  nsgfb, nsgfcb
684  INTEGER, DIMENSION(:, :), POINTER :: first_sgfa, first_sgfb, first_sgfcb
685  REAL(kind=dp) :: dab, dac, dbc
686  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: sabb
687  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :, :) :: sdabb
688  REAL(kind=dp), DIMENSION(3) :: ra, rac, rb, rbc
689  REAL(kind=dp), DIMENSION(:), POINTER :: set_radius_a, set_radius_b, set_radius_cb
690  REAL(kind=dp), DIMENSION(:, :), POINTER :: rpgfa, rpgfb, rpgfcb, scon_a, scon_b, &
691  scon_cb, zeta, zetb, zetcb
692 
693  CALL timeset(routinen, handle)
694  NULLIFY (la_max, la_min, lb_max, lb_min, lcb_max, lcb_min, npgfa, npgfb, &
695  npgfcb, nsgfa, nsgfb, nsgfcb)
696  NULLIFY (first_sgfa, first_sgfb, first_sgfcb, set_radius_a, set_radius_b, &
697  set_radius_cb, rpgfa, rpgfb, rpgfcb, scon_a, scon_b, scon_cb, &
698  zeta, zetb, zetcb)
699 
700  ! basis ikind
701  first_sgfa => oba%first_sgf
702  la_max => oba%lmax
703  la_min => oba%lmin
704  npgfa => oba%npgf
705  nseta = oba%nset
706  nsgfa => oba%nsgf_set
707  rpgfa => oba%pgf_radius
708  set_radius_a => oba%set_radius
709  scon_a => oba%scon
710  zeta => oba%zet
711  ! basis jkind
712  first_sgfb => obb%first_sgf
713  lb_max => obb%lmax
714  lb_min => obb%lmin
715  npgfb => obb%npgf
716  nsetb = obb%nset
717  nsgfb => obb%nsgf_set
718  rpgfb => obb%pgf_radius
719  set_radius_b => obb%set_radius
720  scon_b => obb%scon
721  zetb => obb%zet
722 
723  ! basis RI B
724  first_sgfcb => fbb%first_sgf
725  lcb_max => fbb%lmax
726  lcb_min => fbb%lmin
727  npgfcb => fbb%npgf
728  nsetcb = fbb%nset
729  nsgfcb => fbb%nsgf_set
730  rpgfcb => fbb%pgf_radius
731  set_radius_cb => fbb%set_radius
732  scon_cb => fbb%scon
733  zetcb => fbb%zet
734 
735  dab = sqrt(sum(rab**2))
736 
737  abbint = 0.0_dp
738  IF (calculate_forces) THEN
739  IF (PRESENT(dabbint)) dabbint = 0.0_dp
740  END IF
741 
742  DO iset = 1, nseta
743 
744  ncoa = npgfa(iset)*(ncoset(la_max(iset)) - ncoset(la_min(iset) - 1))
745  sgfa = first_sgfa(1, iset)
746 
747  DO jset = 1, nsetb
748 
749  IF (set_radius_a(iset) + set_radius_b(jset) < dab) cycle
750 
751  ncob = npgfb(jset)*(ncoset(lb_max(jset)) - ncoset(lb_min(jset) - 1))
752  sgfb = first_sgfb(1, jset)
753  m1 = sgfa + nsgfa(iset) - 1
754  m2 = sgfb + nsgfb(jset) - 1
755 
756  ! calculate integrals abbint and derivative [d(a,b,b)/dA] dabbint if requested
757  rac = rab
758  dac = dab
759  rbc = 0._dp
760  dbc = 0._dp
761 
762  DO kbset = 1, nsetcb
763 
764  IF (set_radius_a(iset) + set_radius_cb(kbset) < dab) cycle
765 
766  ncoc = npgfcb(kbset)*(ncoset(lcb_max(kbset)) - ncoset(lcb_min(kbset) - 1))
767  sgfc = first_sgfcb(1, kbset)
768  m3 = sgfc + nsgfcb(kbset) - 1
769  IF (ncoa*ncob*ncoc > 0) THEN
770  ALLOCATE (sabb(ncoa, ncob, ncoc))
771  IF (calculate_forces) THEN
772  ALLOCATE (sdabb(ncoa, ncob, ncoc, 3))
773  CALL overlap_abb(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
774  lb_max(jset), lb_min(jset), npgfb(jset), rpgfb(:, jset), zetb(:, jset), &
775  lcb_max(kbset), lcb_min(kbset), npgfcb(kbset), rpgfcb(:, kbset), zetcb(:, kbset), &
776  rab, sabb, sdabb)
777 
778  DO i = 1, 3
779  CALL abc_contract(dabbint(sgfa:m1, sgfb:m2, sgfc:m3, i), sdabb(1:ncoa, 1:ncob, 1:ncoc, i), &
780  scon_a(:, sgfa:), scon_b(:, sgfb:), scon_cb(:, sgfc:), &
781  ncoa, ncob, ncoc, nsgfa(iset), nsgfb(jset), nsgfcb(kbset))
782  END DO
783  DEALLOCATE (sdabb)
784  ELSE
785  CALL overlap_abb(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
786  lb_max(jset), lb_min(jset), npgfb(jset), rpgfb(:, jset), zetb(:, jset), &
787  lcb_max(kbset), lcb_min(kbset), npgfcb(kbset), rpgfcb(:, kbset), zetcb(:, kbset), &
788  rab, sabb)
789  END IF
790  ! debug if requested
791  IF (debug) THEN
792  ra = 0.0_dp
793  rb = rab
794  CALL overlap_abc_test(la_max(iset), npgfa(iset), zeta(:, iset), la_min(iset), &
795  lb_max(jset), npgfb(jset), zetb(:, jset), lb_min(jset), &
796  lcb_max(kbset), npgfcb(kbset), zetcb(:, kbset), lcb_min(kbset), &
797  ra, rb, rb, sabb, dmax)
798  END IF
799 
800  CALL abc_contract(abbint(sgfa:m1, sgfb:m2, sgfc:m3), sabb(1:ncoa, 1:ncob, 1:ncoc), &
801  scon_a(:, sgfa:), scon_b(:, sgfb:), scon_cb(:, sgfc:), &
802  ncoa, ncob, ncoc, nsgfa(iset), nsgfb(jset), nsgfcb(kbset))
803  DEALLOCATE (sabb)
804  END IF
805  END DO
806 
807  END DO
808  END DO
809 
810  CALL timestop(handle)
811 
812  END SUBROUTINE int_overlap_abb_os
813 
814 ! **************************************************************************************************
815 !> \brief calculate overlap integrals (aa,bb)
816 !> \param saabb integral (aa,bb)
817 !> \param oba orbital basis at center A
818 !> \param obb orbital basis at center B
819 !> \param rab ...
820 !> \param debug integrals are debugged by recursive routines if requested
821 !> \param dmax maximal deviation between integrals when debugging
822 ! **************************************************************************************************
823  SUBROUTINE int_overlap_aabb_os(saabb, oba, obb, rab, debug, dmax)
824 
825  REAL(kind=dp), DIMENSION(:, :, :, :), POINTER :: saabb
826  TYPE(gto_basis_set_type), POINTER :: oba, obb
827  REAL(kind=dp), DIMENSION(3), INTENT(IN) :: rab
828  LOGICAL, INTENT(IN) :: debug
829  REAL(kind=dp), INTENT(INOUT) :: dmax
830 
831  CHARACTER(LEN=*), PARAMETER :: routinen = 'int_overlap_aabb_os'
832 
833  INTEGER :: handle, iset, isgfa1, jset, jsgfa2, kset, ksgfb1, lds, lset, lsgfb2, m1, m2, m3, &
834  m4, maxco, maxcoa, maxcob, maxl, maxla, maxlb, ncoa1, ncoa2, ncob1, ncob2, nseta, nsetb, &
835  sgfa1, sgfa2, sgfb1, sgfb2
836  INTEGER, DIMENSION(:), POINTER :: la_max, la_min, lb_max, lb_min, npgfa, &
837  npgfb, nsgfa, nsgfb
838  INTEGER, DIMENSION(:, :), POINTER :: first_sgfa, first_sgfb
839  LOGICAL :: asets_equal, bsets_equal
840  REAL(kind=dp) :: dab, ra(3), rb(3)
841  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: swork
842  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :, :) :: sint
843  REAL(kind=dp), DIMENSION(:), POINTER :: set_radius_a, set_radius_b
844  REAL(kind=dp), DIMENSION(:, :), POINTER :: rpgfa, rpgfb, sphi_a, sphi_b, zeta, zetb
845 
846  CALL timeset(routinen, handle)
847  NULLIFY (la_max, la_min, lb_max, lb_min, npgfa, npgfb, nsgfa, nsgfb, &
848  first_sgfa, first_sgfb, set_radius_a, set_radius_b, rpgfa, rpgfb, &
849  sphi_a, sphi_b, zeta, zetb)
850 
851  ! basis ikind
852  first_sgfa => oba%first_sgf
853  la_max => oba%lmax
854  la_min => oba%lmin
855  npgfa => oba%npgf
856  nseta = oba%nset
857  nsgfa => oba%nsgf_set
858  rpgfa => oba%pgf_radius
859  set_radius_a => oba%set_radius
860  sphi_a => oba%sphi
861  zeta => oba%zet
862  ! basis jkind
863  first_sgfb => obb%first_sgf
864  lb_max => obb%lmax
865  lb_min => obb%lmin
866  npgfb => obb%npgf
867  nsetb = obb%nset
868  nsgfb => obb%nsgf_set
869  rpgfb => obb%pgf_radius
870  set_radius_b => obb%set_radius
871  sphi_b => obb%sphi
872  zetb => obb%zet
873 
874  CALL get_gto_basis_set(oba, maxco=maxcoa, maxl=maxla)
875  CALL get_gto_basis_set(obb, maxco=maxcob, maxl=maxlb)
876  maxco = max(maxcoa, maxcob)
877  maxla = 2*maxla
878  maxlb = 2*maxlb
879  maxl = max(maxla, maxlb)
880  lds = ncoset(maxl)
881  ALLOCATE (sint(maxco, maxco, maxco, maxco))
882  ALLOCATE (swork(lds, lds))
883  sint = 0._dp
884  swork = 0._dp
885 
886  dab = sqrt(sum(rab**2))
887 
888  DO iset = 1, nseta
889 
890  ncoa1 = npgfa(iset)*ncoset(la_max(iset))
891  sgfa1 = first_sgfa(1, iset)
892  m1 = sgfa1 + nsgfa(iset) - 1
893 
894  DO jset = iset, nseta
895 
896  ncoa2 = npgfa(jset)*ncoset(la_max(jset))
897  sgfa2 = first_sgfa(1, jset)
898  m2 = sgfa2 + nsgfa(jset) - 1
899 
900  DO kset = 1, nsetb
901 
902  ncob1 = npgfb(kset)*ncoset(lb_max(kset))
903  sgfb1 = first_sgfb(1, kset)
904  m3 = sgfb1 + nsgfb(kset) - 1
905 
906  DO lset = kset, nsetb
907 
908  ncob2 = npgfb(lset)*ncoset(lb_max(lset))
909  sgfb2 = first_sgfb(1, lset)
910  m4 = sgfb2 + nsgfb(lset) - 1
911 
912  ! check if sets are identical to spare some integral evaluation
913  asets_equal = .false.
914  IF (iset == jset) asets_equal = .true.
915  bsets_equal = .false.
916  IF (kset == lset) bsets_equal = .true.
917  ! calculate integrals
918  CALL overlap_aabb(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
919  la_max(jset), la_min(jset), npgfa(jset), rpgfa(:, jset), zeta(:, jset), &
920  lb_max(kset), lb_min(kset), npgfb(kset), rpgfb(:, kset), zetb(:, kset), &
921  lb_max(lset), lb_min(lset), npgfb(lset), rpgfb(:, lset), zetb(:, lset), &
922  asets_equal, bsets_equal, rab, dab, sint, swork, lds)
923  ! debug if requested
924  IF (debug) THEN
925  ra = 0.0_dp
926  rb = rab
927  CALL overlap_aabb_test(la_max(iset), la_min(iset), npgfa(iset), zeta(:, iset), &
928  la_max(jset), la_min(jset), npgfa(jset), zeta(:, jset), &
929  lb_max(kset), lb_min(kset), npgfb(kset), zetb(:, kset), &
930  lb_max(lset), lb_min(lset), npgfb(lset), zetb(:, lset), &
931  ra, rb, sint, dmax)
932  END IF
933 
934  CALL abcd_contract(saabb(sgfa1:m1, sgfa2:m2, sgfb1:m3, sgfb2:m4), sint, sphi_a(:, sgfa1:), &
935  sphi_a(:, sgfa2:), sphi_b(:, sgfb1:), sphi_b(:, sgfb2:), ncoa1, ncoa2, &
936  ncob1, ncob2, nsgfa(iset), nsgfa(jset), nsgfb(kset), nsgfb(lset))
937 
938  ! account for the fact that some integrals are alike
939  DO isgfa1 = sgfa1, m1
940  DO jsgfa2 = sgfa2, m2
941  DO ksgfb1 = sgfb1, m3
942  DO lsgfb2 = sgfb2, m4
943  saabb(jsgfa2, isgfa1, ksgfb1, lsgfb2) = saabb(isgfa1, jsgfa2, ksgfb1, lsgfb2)
944  saabb(isgfa1, jsgfa2, lsgfb2, ksgfb1) = saabb(isgfa1, jsgfa2, ksgfb1, lsgfb2)
945  saabb(jsgfa2, isgfa1, lsgfb2, ksgfb1) = saabb(isgfa1, jsgfa2, ksgfb1, lsgfb2)
946  END DO
947  END DO
948  END DO
949  END DO
950 
951  END DO
952  END DO
953  END DO
954  END DO
955 
956  DEALLOCATE (sint, swork)
957 
958  CALL timestop(handle)
959 
960  END SUBROUTINE int_overlap_aabb_os
961 
962 END MODULE generic_os_integrals
ai_contraction_sphi
Contraction of integrals over primitive Cartesian Gaussians based on the contraction matrix sphi whic...
Definition: ai_contraction_sphi.F:15
ai_contraction_sphi::abc_contract
subroutine, public abc_contract(abcint, sabc, sphi_a, sphi_b, sphi_c, ncoa, ncob, ncoc, nsgfa, nsgfb, nsgfc)
contract three-center overlap integrals (a,b,c) and transfer to spherical Gaussians
Definition: ai_contraction_sphi.F:101
ai_contraction_sphi::abcd_contract
subroutine, public abcd_contract(abcdint, sabcd, sphi_a, sphi_b, sphi_c, sphi_d, ncoa, ncob, ncoc, ncod, nsgfa, nsgfb, nsgfc, nsgfd)
contract four-center overlap integrals (a,b,c,d) and transfer to spherical Gaussians
Definition: ai_contraction_sphi.F:161
ai_contraction_sphi::ab_contract
subroutine, public ab_contract(abint, sab, sphi_a, sphi_b, ncoa, ncob, nsgfa, nsgfb)
contract overlap integrals (a,b) and transfer to spherical Gaussians
Definition: ai_contraction_sphi.F:52
ai_derivatives
Calculate the first derivative of an integral block.
Definition: ai_derivatives.F:34
ai_derivatives::dabdr_noscreen
subroutine, public dabdr_noscreen(la_max, npgfa, zeta, lb_max, npgfb, ab, dabdx, dabdy, dabdz)
Calculate the first derivative of an integral block. This takes the derivative with respect to the at...
Definition: ai_derivatives.F:366
ai_operator_ra2m
Calculation of integrals over Cartesian Gaussian-type functions for [a|(r-Ra)^(2m)|b] Ra is the posit...
Definition: ai_operator_ra2m.F:32
ai_operator_ra2m::operator_ra2m
subroutine, public operator_ra2m(la_max, la_min, npgfa, zeta, lb_max, lb_min, npgfb, zetb, m, rab, sab, dsab, calculate_forces)
Calculation of the primitive two-center [a|(r-Ra)^(2m)|b] integrals over Cartesian Gaussian-type func...
Definition: ai_operator_ra2m.F:75
ai_operators_r12
Calculation of integrals over Cartesian Gaussian-type functions for different r12 operators: 1/r12,...
Definition: ai_operators_r12.F:36
ai_operators_r12::cps_verfc2
subroutine, public cps_verfc2(v, nmax, zetp, zetq, zetw, rho, rac2, omega, r_cutoff)
Calculation of verfc integrals for s-function, i.e, [s|erfc(omega*r12)/r12|s], and the auxiliary inte...
Definition: ai_operators_r12.F:531
ai_operators_r12::cps_vgauss2
subroutine, public cps_vgauss2(v, nmax, zetp, zetq, zetw, rho, rac2, omega, r_cutoff)
Calculation of vgauss integrals for s-function, i.e, [s|exp(-omega*r12^2)/r12|s], and the auxiliary i...
Definition: ai_operators_r12.F:578
ai_operators_r12::cps_gauss2
subroutine, public cps_gauss2(v, nmax, zetp, zetq, zetw, rho, rac2, omega, r_cutoff)
Calculation of gauss integrals for s-function, i.e, [s|exp(-omega*r12^2)|s], and the auxiliary integr...
Definition: ai_operators_r12.F:634
ai_operators_r12::cps_coulomb2
subroutine, public cps_coulomb2(v, nmax, zetp, zetq, zetw, rho, rac2, omega, r_cutoff)
Calculation of Coulomb integrals for s-function, i.e, [s|1/r12|s], and the auxiliary integrals [s|1/r...
Definition: ai_operators_r12.F:443
ai_operators_r12::cps_truncated2
subroutine, public cps_truncated2(v, nmax, zetp, zetq, zetw, rho, rac2, omega, r_cutoff)
Calculation of truncated Coulomb integrals for s-function, i.e, [s|TC|s] where TC = 1/r12 if r12 <= r...
Definition: ai_operators_r12.F:679
ai_operators_r12::cps_verf2
subroutine, public cps_verf2(v, nmax, zetp, zetq, zetw, rho, rac2, omega, r_cutoff)
Calculation of verf integrals for s-function, i.e, [s|erf(omega*r12)/r12|s], and the auxiliary integr...
Definition: ai_operators_r12.F:486
ai_operators_r12::operator2
subroutine, public operator2(cps_operator2, la_max, npgfa, zeta, la_min, lc_max, npgfc, zetc, lc_min, omega, r_cutoff, rac, rac2, vac, v, maxder, vac_plus)
Calculation of the primitive two-center integrals over Cartesian Gaussian-type functions for differen...
Definition: ai_operators_r12.F:110
ai_overlap_aabb
Calculation of the overlap integrals over Cartesian Gaussian-type functions.
Definition: ai_overlap_aabb.F:27
ai_overlap_aabb::overlap_aabb
subroutine, public overlap_aabb(la_max_set1, la_min_set1, npgfa1, rpgfa1, zeta1, la_max_set2, la_min_set2, npgfa2, rpgfa2, zeta2, lb_max_set1, lb_min_set1, npgfb1, rpgfb1, zetb1, lb_max_set2, lb_min_set2, npgfb2, rpgfb2, zetb2, asets_equal, bsets_equal, rab, dab, saabb, s, lds)
Purpose: Calculation of the two-center overlap integrals [aa|bb] over Cartesian Gaussian-type functio...
Definition: ai_overlap_aabb.F:85
ai_overlap
Calculation of the overlap integrals over Cartesian Gaussian-type functions.
Definition: ai_overlap.F:18
ai_overlap::overlap_ab
subroutine, public overlap_ab(la_max, la_min, npgfa, rpgfa, zeta, lb_max, lb_min, npgfb, rpgfb, zetb, rab, sab, dab, ddab)
Calculation of the two-center overlap integrals [a|b] over Cartesian Gaussian-type functions....
Definition: ai_overlap.F:680
ai_overlap::overlap_aab
subroutine, public overlap_aab(la1_max, la1_min, npgfa1, rpgfa1, zeta1, la2_max, la2_min, npgfa2, rpgfa2, zeta2, lb_max, lb_min, npgfb, rpgfb, zetb, rab, saab, daab, saba, daba)
Calculation of the two-center overlap integrals [aa|b] over Cartesian Gaussian-type functions.
Definition: ai_overlap.F:967
ai_overlap::overlap_abb
subroutine, public overlap_abb(la_max, la_min, npgfa, rpgfa, zeta, lb1_max, lb1_min, npgfb1, rpgfb1, zetb1, lb2_max, lb2_min, npgfb2, rpgfb2, zetb2, rab, sabb, dabb)
Calculation of the two-center overlap integrals [a|bb] over Cartesian Gaussian-type functions.
Definition: ai_overlap.F:1184
basis_set_types
Definition: basis_set_types.F:15
basis_set_types::get_gto_basis_set
subroutine, public get_gto_basis_set(gto_basis_set, name, aliases, norm_type, kind_radius, ncgf, nset, nsgf, cgf_symbol, sgf_symbol, norm_cgf, set_radius, lmax, lmin, lx, ly, lz, m, ncgf_set, npgf, nsgf_set, nshell, cphi, pgf_radius, sphi, scon, zet, first_cgf, first_sgf, l, last_cgf, last_sgf, n, gcc, maxco, maxl, maxpgf, maxsgf_set, maxshell, maxso, nco_sum, npgf_sum, nshell_sum, maxder, short_kind_radius)
...
Definition: basis_set_types.F:615
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_truncated
integer, parameter, public operator_truncated
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
debug_os_integrals
Debugs Obara-Saika integral matrices.
Definition: debug_os_integrals.F:14
debug_os_integrals::overlap_ab_test
subroutine, public overlap_ab_test(la_max, la_min, npgfa, zeta, lb_max, lb_min, npgfb, zetb, ra, rb, sab, dmax)
recursive test routines for integral (a,b)
Definition: debug_os_integrals.F:135
debug_os_integrals::overlap_abc_test
subroutine, public overlap_abc_test(la_max, npgfa, zeta, la_min, lb_max, npgfb, zetb, lb_min, lc_max, npgfc, zetc, lc_min, ra, rb, rc, sabc, dmax)
recursive test routines for integral (a,b,c)
Definition: debug_os_integrals.F:306
debug_os_integrals::overlap_aabb_test
subroutine, public overlap_aabb_test(la_max1, la_min1, npgfa1, zeta1, la_max2, la_min2, npgfa2, zeta2, lb_max1, lb_min1, npgfb1, zetb1, lb_max2, lb_min2, npgfb2, zetb2, ra, rb, saabb, dmax)
recursive test routines for integral (aa,bb)
Definition: debug_os_integrals.F:514
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_overlap_aabb_os
subroutine, public int_overlap_aabb_os(saabb, oba, obb, rab, debug, dmax)
calculate overlap integrals (aa,bb)
Definition: generic_os_integrals.F:824
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
kinds
Defines the basic variable types.
Definition: kinds.F:23
kinds::dp
integer, parameter, public dp
Definition: kinds.F:34
orbital_pointers
Provides Cartesian and spherical orbital pointers and indices.
Definition: orbital_pointers.F:15
orbital_pointers::ncoset
integer, dimension(:), allocatable, public ncoset
Definition: orbital_pointers.F:42