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