(git:e5b1968)
Loading...
Searching...
No Matches
mp2_eri.F
Go to the documentation of this file.
1!--------------------------------------------------------------------------------------------------!
2! CP2K: A general program to perform molecular dynamics simulations !
3! Copyright 2000-2025 CP2K developers group <https://cp2k.org> !
4! !
5! SPDX-License-Identifier: GPL-2.0-or-later !
6!--------------------------------------------------------------------------------------------------!
7
8! **************************************************************************************************
9!> \brief Interface to direct methods for electron repulsion integrals for MP2.
10! **************************************************************************************************
11
12MODULE mp2_eri
13 USE ai_contraction_sphi, ONLY: ab_contract, &
14 abc_contract
15 USE ai_coulomb, ONLY: coulomb2_new, &
16 coulomb3
17 USE atomic_kind_types, ONLY: atomic_kind_type, &
18 get_atomic_kind_set
19 USE basis_set_types, ONLY: gto_basis_set_p_type, &
20 gto_basis_set_type
21 USE cell_types, ONLY: cell_type, &
22 pbc
23 USE cp_eri_mme_interface, ONLY: cp_eri_mme_finalize, &
24 cp_eri_mme_init_read_input, &
25 cp_eri_mme_param, &
26 cp_eri_mme_set_params
27 USE message_passing, ONLY: mp_para_env_type
28 USE cp_dbcsr_api, ONLY: dbcsr_get_block_p, &
29 dbcsr_p_type
30 USE eri_mme_integrate, ONLY: eri_mme_2c_integrate, &
31 eri_mme_3c_integrate
32 USE eri_mme_test, ONLY: eri_mme_2c_perf_acc_test, &
33 eri_mme_3c_perf_acc_test
34 USE eri_mme_types, ONLY: eri_mme_param, &
35 eri_mme_set_potential, eri_mme_coulomb, eri_mme_longrange
36 USE input_constants, ONLY: do_eri_gpw, &
37 do_eri_mme, &
38 do_eri_os, &
39 do_potential_coulomb, &
40 do_potential_long
41 USE input_section_types, ONLY: section_vals_get_subs_vals, &
42 section_vals_type, &
43 section_vals_val_get
44 USE kinds, ONLY: dp
45 USE libint_2c_3c, ONLY: libint_potential_type
46 USE orbital_pointers, ONLY: coset, &
47 init_orbital_pointers, &
48 ncoset
49 USE particle_types, ONLY: particle_type
50 USE qs_environment_types, ONLY: get_qs_env, &
51 qs_environment_type
52 USE qs_integral_utils, ONLY: basis_set_list_setup
53 USE qs_kind_types, ONLY: get_qs_kind, &
54 qs_kind_type
55 USE qs_neighbor_list_types, ONLY: get_iterator_info, &
56 get_neighbor_list_set_p, &
57 neighbor_list_iterate, &
58 neighbor_list_iterator_create, &
59 neighbor_list_iterator_p_type, &
60 neighbor_list_iterator_release, &
61 neighbor_list_set_p_type
62 USE util, ONLY: get_limit
63 USE cp_eri_mme_interface, ONLY: cp_eri_mme_update_local_counts
64#include "./base/base_uses.f90"
65
66 IMPLICIT NONE
67
68 PRIVATE
69
70 LOGICAL, PRIVATE, PARAMETER :: debug_this_module = .false.
71
72 CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'mp2_eri'
73
74 PUBLIC :: &
75 mp2_eri_2c_integrate, &
76 mp2_eri_3c_integrate, &
77 mp2_eri_allocate_forces, &
78 mp2_eri_deallocate_forces, &
79 mp2_eri_force, &
80 integrate_set_2c, &
81 convert_potential_type
82
83 TYPE mp2_eri_force
84 REAL(kind=dp), DIMENSION(:, :), ALLOCATABLE :: forces
85 END TYPE mp2_eri_force
86
87CONTAINS
88
89! **************************************************************************************************
90!> \brief high-level integration routine for 2c integrals over CP2K basis sets.
91!> Contiguous column-wise distribution and parallelization over pairs of sets.
92!> \param param ...
93!> \param para_env mpi environment for local columns
94!> \param potential_parameter ...
95!> \param qs_env ...
96!> \param basis_type_a ...
97!> \param basis_type_b ...
98!> \param hab columns of ERI matrix
99!> \param first_b first column of hab
100!> \param last_b last column of hab
101!> \param eri_method ...
102!> \param pab ...
103!> \param force_a ...
104!> \param force_b ...
105!> \param hdab ...
106!> \param hadb ...
107!> \param reflection_z_a ...
108!> \param reflection_z_b ...
109!> \param do_reflection_a ...
110!> \param do_reflection_b ...
111! **************************************************************************************************
112 SUBROUTINE mp2_eri_2c_integrate(param, potential_parameter, para_env, qs_env, basis_type_a, basis_type_b, hab, first_b, &
113 last_b, eri_method, pab, force_a, force_b, hdab, hadb, &
114 reflection_z_a, reflection_z_b, do_reflection_a, do_reflection_b)
115 TYPE(cp_eri_mme_param), INTENT(INOUT) :: param
116 TYPE(libint_potential_type), INTENT(IN) :: potential_parameter
117 TYPE(mp_para_env_type), INTENT(IN) :: para_env
118 TYPE(qs_environment_type), INTENT(IN), POINTER :: qs_env
119 CHARACTER(len=*), INTENT(IN), OPTIONAL :: basis_type_a, basis_type_b
120 REAL(kind=dp), DIMENSION(:, :), INTENT(INOUT) :: hab
121 INTEGER, INTENT(IN) :: first_b, last_b
122 INTEGER, INTENT(IN), OPTIONAL :: eri_method
123 REAL(kind=dp), DIMENSION(:, :), INTENT(IN), &
124 OPTIONAL :: pab
125 TYPE(mp2_eri_force), ALLOCATABLE, &
126 DIMENSION(:), INTENT(OUT), OPTIONAL :: force_a, force_b
127 REAL(kind=dp), DIMENSION(:, :, :), INTENT(INOUT), &
128 OPTIONAL :: hdab, hadb
129 REAL(kind=dp), INTENT(IN), OPTIONAL :: reflection_z_a, reflection_z_b
130 LOGICAL, INTENT(IN), OPTIONAL :: do_reflection_a, do_reflection_b
131
132 CHARACTER(len=*), PARAMETER :: routinen = 'mp2_eri_2c_integrate'
133
134 INTEGER :: atom_a, atom_b, atom_end, atom_start, first_set, g_count, handle, iatom, ikind, &
135 iset, jatom, jkind, jset, jset_end, jset_start, last_set, my_eri_method, my_setpair, &
136 n_setpair, natom, nkind, nseta, nseta_total, nsetb, nsetb_total, offset_a_end, &
137 offset_a_start, offset_b_end, offset_b_start, r_count, set_end, set_offset_end, &
138 set_offset_start, set_start, sgfa, sgfb
139 INTEGER, ALLOCATABLE, DIMENSION(:) :: atom_of_kind, kind_of, natom_of_kind
140 INTEGER, ALLOCATABLE, DIMENSION(:, :) :: eri_offsets
141 INTEGER, DIMENSION(:), POINTER :: la_max, la_min, lb_max, lb_min, npgfa, &
142 npgfb, nsgfa, nsgfb
143 INTEGER, DIMENSION(:, :), POINTER :: first_sgfa, first_sgfb
144 LOGICAL :: map_it_here, my_do_reflection_a, &
145 my_do_reflection_b
146 REAL(kind=dp) :: dab
147 REAL(kind=dp), DIMENSION(3) :: ra, rab, rb
148 REAL(kind=dp), DIMENSION(:, :), POINTER :: sphi_a, sphi_b, zeta, zetb
149 TYPE(atomic_kind_type), DIMENSION(:), POINTER :: atomic_kind_set
150 TYPE(cell_type), POINTER :: cell
151 TYPE(gto_basis_set_type), POINTER :: basis_set_a, basis_set_b
152 TYPE(particle_type), DIMENSION(:), POINTER :: particle_set
153 TYPE(qs_kind_type), DIMENSION(:), POINTER :: qs_kind_set
154
155 CALL timeset(routinen, handle)
156
157 my_eri_method = do_eri_mme
158 IF (PRESENT(eri_method)) my_eri_method = eri_method
159
160 my_do_reflection_a = .false.
161 IF (PRESENT(do_reflection_a) .AND. PRESENT(reflection_z_a)) my_do_reflection_a = do_reflection_a
162
163 my_do_reflection_b = .false.
164 IF (PRESENT(do_reflection_b) .AND. PRESENT(reflection_z_b)) my_do_reflection_b = do_reflection_b
165
166 g_count = 0; r_count = 0;
167 ! get mapping between ERIs and atoms, sets, set offsets
168 CALL get_eri_offsets(qs_env, basis_type_b, eri_offsets)
169
170 atom_start = eri_offsets(first_b, 1)
171 set_start = eri_offsets(first_b, 2)
172 set_offset_start = eri_offsets(first_b, 3)
173
174 atom_end = eri_offsets(last_b, 1)
175 set_end = eri_offsets(last_b, 2)
176 set_offset_end = eri_offsets(last_b, 3)
177
178 ! get QS stuff
179 CALL get_qs_env(qs_env, atomic_kind_set=atomic_kind_set, qs_kind_set=qs_kind_set, &
180 cell=cell, particle_set=particle_set, natom=natom, nkind=nkind)
181
182 CALL get_atomic_kind_set(atomic_kind_set, kind_of=kind_of, natom_of_kind=natom_of_kind, atom_of_kind=atom_of_kind)
183
184 IF (PRESENT(force_a)) CALL mp2_eri_allocate_forces(force_a, natom_of_kind)
185 IF (PRESENT(force_b)) CALL mp2_eri_allocate_forces(force_b, natom_of_kind)
186
187 ! get total number of local set pairs to integrate
188 nseta_total = 0
189 DO iatom = 1, natom
190 ikind = kind_of(iatom)
191 CALL get_qs_kind(qs_kind=qs_kind_set(ikind), basis_set=basis_set_a, basis_type=basis_type_a)
192 nseta_total = nseta_total + basis_set_a%nset
193 END DO
194
195 nsetb_total = 0
196 DO jatom = atom_start, atom_end
197 jkind = kind_of(jatom)
198 CALL get_qs_kind(qs_kind=qs_kind_set(jkind), basis_set=basis_set_b, basis_type=basis_type_b)
199 nsetb_total = nsetb_total + basis_set_b%nset
200 END DO
201
202 n_setpair = nseta_total*nsetb_total
203
204 my_setpair = 0
205
206 offset_a_end = 0
207 DO iatom = 1, natom
208 ikind = kind_of(iatom)
209 atom_a = atom_of_kind(iatom)
210 CALL get_qs_kind(qs_kind=qs_kind_set(ikind), basis_set=basis_set_a, basis_type=basis_type_a)
211
212 first_sgfa => basis_set_a%first_sgf
213 la_max => basis_set_a%lmax
214 la_min => basis_set_a%lmin
215 nseta = basis_set_a%nset
216 nsgfa => basis_set_a%nsgf_set
217 sphi_a => basis_set_a%sphi
218 zeta => basis_set_a%zet
219 npgfa => basis_set_a%npgf
220
221 ra(:) = pbc(particle_set(iatom)%r, cell)
222
223 IF (my_do_reflection_a) THEN
224 ra(3) = 2.0_dp*reflection_z_a - ra(3)
225 END IF
226
227 DO iset = 1, nseta
228 offset_a_start = offset_a_end
229 offset_a_end = offset_a_end + nsgfa(iset)
230 sgfa = first_sgfa(1, iset)
231
232 offset_b_end = 0
233 DO jatom = atom_start, atom_end
234 jkind = kind_of(jatom)
235 atom_b = atom_of_kind(jatom)
236 CALL get_qs_kind(qs_kind=qs_kind_set(jkind), basis_set=basis_set_b, basis_type=basis_type_b)
237
238 first_sgfb => basis_set_b%first_sgf
239 lb_max => basis_set_b%lmax
240 lb_min => basis_set_b%lmin
241 nsetb = basis_set_b%nset
242 nsgfb => basis_set_b%nsgf_set
243 sphi_b => basis_set_b%sphi
244 zetb => basis_set_b%zet
245 npgfb => basis_set_b%npgf
246
247 rb(:) = pbc(particle_set(jatom)%r, cell)
248
249 IF (my_do_reflection_b) THEN
250 rb(3) = 2.0_dp*reflection_z_b - rb(3)
251 END IF
252
253 rab(:) = ra(:) - rb(:) ! pbc not needed?
254 dab = sqrt(rab(1)**2 + rab(2)**2 + rab(3)**2)
255
256 jset_start = 1; jset_end = nsetb
257 IF (jatom == atom_start) jset_start = set_start
258 IF (jatom == atom_end) jset_end = set_end
259
260 DO jset = jset_start, jset_end
261 first_set = 1; last_set = nsgfb(jset)
262 IF (jset == jset_start .AND. jatom == atom_start) first_set = set_offset_start
263 IF (jset == jset_end .AND. jatom == atom_end) last_set = set_offset_end
264
265 offset_b_start = offset_b_end
266 offset_b_end = offset_b_end + last_set + 1 - first_set
267 sgfb = first_sgfb(1, jset)
268 my_setpair = my_setpair + 1
269 map_it_here = modulo(my_setpair, para_env%num_pe) == para_env%mepos
270
271 IF (map_it_here) THEN
272 IF (.NOT.PRESENT(force_a) .AND. &
273 .NOT.PRESENT(force_b)) THEN
274
275 CALL integrate_set_2c( &
276 param%par, potential_parameter, &
277 la_min(iset), la_max(iset), &
278 lb_min(jset), lb_max(jset), &
279 npgfa(iset), npgfb(jset), &
280 zeta(:, iset), zetb(:, jset), &
281 ra, rb, &
282 hab, nsgfa(iset), last_set - first_set + 1, &
283 offset_a_start, offset_b_start, &
284 0, first_set - 1, &
285 sphi_a, sphi_b, &
286 sgfa, sgfb, nsgfa(iset), nsgfb(jset), &
287 my_eri_method, &
288 pab, &
289
290
291 hdab=hdab, hadb=hadb, &
292 g_count=g_count, r_count=r_count, &
293 do_reflection_a=do_reflection_a, do_reflection_b=do_reflection_b)
294 END IF
295 IF (.NOT.PRESENT(force_a) .AND. &
296 PRESENT(force_b)) THEN
297
298 CALL integrate_set_2c( &
299 param%par, potential_parameter, &
300 la_min(iset), la_max(iset), &
301 lb_min(jset), lb_max(jset), &
302 npgfa(iset), npgfb(jset), &
303 zeta(:, iset), zetb(:, jset), &
304 ra, rb, &
305 hab, nsgfa(iset), last_set - first_set + 1, &
306 offset_a_start, offset_b_start, &
307 0, first_set - 1, &
308 sphi_a, sphi_b, &
309 sgfa, sgfb, nsgfa(iset), nsgfb(jset), &
310 my_eri_method, &
311 pab, &
312
313force_b=force_b(jkind)%forces(:, atom_b), &
314 hdab=hdab, hadb=hadb, &
315 g_count=g_count, r_count=r_count, &
316 do_reflection_a=do_reflection_a, do_reflection_b=do_reflection_b)
317 END IF
318 IF (PRESENT(force_a) .AND. &
319 .NOT.PRESENT(force_b)) THEN
320
321 CALL integrate_set_2c( &
322 param%par, potential_parameter, &
323 la_min(iset), la_max(iset), &
324 lb_min(jset), lb_max(jset), &
325 npgfa(iset), npgfb(jset), &
326 zeta(:, iset), zetb(:, jset), &
327 ra, rb, &
328 hab, nsgfa(iset), last_set - first_set + 1, &
329 offset_a_start, offset_b_start, &
330 0, first_set - 1, &
331 sphi_a, sphi_b, &
332 sgfa, sgfb, nsgfa(iset), nsgfb(jset), &
333 my_eri_method, &
334 pab, &
335force_a=force_a(ikind)%forces(:, atom_a), &
336
337 hdab=hdab, hadb=hadb, &
338 g_count=g_count, r_count=r_count, &
339 do_reflection_a=do_reflection_a, do_reflection_b=do_reflection_b)
340 END IF
341 IF (PRESENT(force_a) .AND. &
342 PRESENT(force_b)) THEN
343
344 CALL integrate_set_2c( &
345 param%par, potential_parameter, &
346 la_min(iset), la_max(iset), &
347 lb_min(jset), lb_max(jset), &
348 npgfa(iset), npgfb(jset), &
349 zeta(:, iset), zetb(:, jset), &
350 ra, rb, &
351 hab, nsgfa(iset), last_set - first_set + 1, &
352 offset_a_start, offset_b_start, &
353 0, first_set - 1, &
354 sphi_a, sphi_b, &
355 sgfa, sgfb, nsgfa(iset), nsgfb(jset), &
356 my_eri_method, &
357 pab, &
358force_a=force_a(ikind)%forces(:, atom_a), &
359force_b=force_b(jkind)%forces(:, atom_b), &
360 hdab=hdab, hadb=hadb, &
361 g_count=g_count, r_count=r_count, &
362 do_reflection_a=do_reflection_a, do_reflection_b=do_reflection_b)
363 END IF
364 END IF
365 END DO
366 END DO
367 END DO
368 END DO
369
370 IF (my_eri_method == do_eri_mme) THEN
371
372 CALL cp_eri_mme_update_local_counts(param, para_env, g_count_2c=g_count, r_count_2c=r_count)
373
374 END IF
375
376 CALL para_env%sum(hab)
377 IF (PRESENT(hdab)) CALL para_env%sum(hdab)
378 IF (PRESENT(hadb)) CALL para_env%sum(hadb)
379
380 CALL timestop(handle)
381 END SUBROUTINE mp2_eri_2c_integrate
382
383! **************************************************************************************************
384!> \brief Integrate set pair and contract with sphi matrix.
385!> \param param ...
386!> \param potential_parameter ...
387!> \param la_min ...
388!> \param la_max ...
389!> \param lb_min ...
390!> \param lb_max ...
391!> \param npgfa ...
392!> \param npgfb ...
393!> \param zeta ...
394!> \param zetb ...
395!> \param ra ...
396!> \param rb ...
397!> \param hab ...
398!> \param n_hab_a ...
399!> \param n_hab_b ...
400!> \param offset_hab_a ...
401!> \param offset_hab_b ...
402!> \param offset_set_a ...
403!> \param offset_set_b ...
404!> \param sphi_a ...
405!> \param sphi_b ...
406!> \param sgfa ...
407!> \param sgfb ...
408!> \param nsgfa ...
409!> \param nsgfb ...
410!> \param eri_method ...
411!> \param pab ...
412!> \param force_a ...
413!> \param force_b ...
414!> \param hdab ...
415!> \param hadb ...
416!> \param G_count ...
417!> \param R_count ...
418!> \param do_reflection_a ...
419!> \param do_reflection_b ...
420! **************************************************************************************************
421 SUBROUTINE integrate_set_2c(param, potential_parameter, la_min, la_max, lb_min, lb_max, npgfa, npgfb, zeta, zetb, &
422 ra, rb, hab, n_hab_a, n_hab_b, offset_hab_a, offset_hab_b, &
423 offset_set_a, offset_set_b, sphi_a, sphi_b, sgfa, sgfb, nsgfa, nsgfb, &
424 eri_method, pab, force_a, force_b, hdab, hadb, G_count, R_count, &
425 do_reflection_a, do_reflection_b)
426 TYPE(eri_mme_param), INTENT(INOUT) :: param
427 TYPE(libint_potential_type), INTENT(IN) :: potential_parameter
428 INTEGER, INTENT(IN) :: la_min, la_max, lb_min, lb_max, npgfa
429 REAL(kind=dp), DIMENSION(npgfa), INTENT(IN) :: zeta
430 INTEGER, INTENT(IN) :: npgfb
431 REAL(kind=dp), DIMENSION(npgfb), INTENT(IN) :: zetb
432 REAL(kind=dp), DIMENSION(3), INTENT(IN) :: ra, rb
433 REAL(kind=dp), DIMENSION(:, :), INTENT(OUT) :: hab
434 INTEGER, INTENT(IN) :: n_hab_a, n_hab_b, offset_hab_a, &
435 offset_hab_b, offset_set_a, &
436 offset_set_b
437 REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: sphi_a
438 INTEGER, INTENT(IN) :: sgfa, nsgfa
439 REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: sphi_b
440 INTEGER, INTENT(IN) :: sgfb, nsgfb, eri_method
441 REAL(kind=dp), DIMENSION(:, :), INTENT(IN), &
442 OPTIONAL :: pab
443 REAL(kind=dp), DIMENSION(3), INTENT(INOUT), &
444 OPTIONAL :: force_a, force_b
445 REAL(kind=dp), DIMENSION(:, :, :), INTENT(OUT), &
446 OPTIONAL :: hdab, hadb
447 INTEGER, INTENT(INOUT), OPTIONAL :: g_count, r_count
448 LOGICAL, INTENT(IN), OPTIONAL :: do_reflection_a, do_reflection_b
449
450 CHARACTER(LEN=*), PARAMETER :: routinen = 'integrate_set_2c'
451
452 INTEGER :: ax, ay, az, bx, by, bz, hab_a_end, hab_a_start, hab_b_end, hab_b_start, handle, &
453 i_xyz, ico, icox, icoy, icoz, ipgf, jco, jcox, jcoy, jcoz, jpgf, la, la_max_d, lb, &
454 lb_max_d, na, nb, ncoa, ncob, set_a_end, set_a_start, set_b_end, set_b_start, &
455 sphi_a_start, sphi_b_start
456 INTEGER, DIMENSION(3) :: la_xyz, lb_xyz
457 LOGICAL :: calculate_forces, my_do_reflection_a, &
458 my_do_reflection_b, do_force_a, do_force_b
459 REAL(kind=dp) :: rab2
460 REAL(kind=dp), ALLOCATABLE, DIMENSION(:) :: f_work
461 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: hab_contr, hab_uncontr, &
462 hab_uncontr_d, pab_hh, pab_hs, &
463 pab_ss
464 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: hadb_contr, hadb_uncontr, hdab_contr, &
465 hdab_uncontr, v_work
466
467 ! note: tested only for one exponent per pair (npgfa = npgfb = 1)
468 CALL timeset(routinen, handle)
469
470 my_do_reflection_a = .false.
471 IF (PRESENT(do_reflection_a)) my_do_reflection_a = do_reflection_a
472
473 my_do_reflection_b = .false.
474 IF (PRESENT(do_reflection_b)) my_do_reflection_b = do_reflection_b
475
476 do_force_a = PRESENT(force_a) .OR. PRESENT(hdab)
477 do_force_b = PRESENT(force_b) .OR. PRESENT(hadb)
478 calculate_forces = do_force_a .OR. do_force_b
479
480 IF (PRESENT(force_a) .OR. PRESENT(force_b)) THEN
481 cpassert(PRESENT(pab))
482 cpassert(all(shape(pab) .EQ. shape(hab)))
483 END IF
484
485 la_max_d = la_max
486 lb_max_d = lb_max
487
488 IF (calculate_forces) THEN
489 IF (do_force_a) la_max_d = la_max + 1
490 IF (do_force_b) lb_max_d = lb_max + 1
491 END IF
492
493 ncoa = npgfa*ncoset(la_max)
494 ncob = npgfb*ncoset(lb_max)
495
496 rab2 = (ra(1) - rb(1))**2 + (ra(2) - rb(2))**2 + (ra(3) - rb(3))**2
497
498 ALLOCATE (hab_uncontr_d(ncoset(la_max_d), ncoset(lb_max_d))); hab_uncontr_d(:, :) = 0.0_dp
499 ALLOCATE (hab_uncontr(ncoa, ncob)); hab_uncontr(:, :) = 0.0_dp
500 IF (PRESENT(hdab)) THEN
501 ALLOCATE (hdab_uncontr(3, ncoa, ncob)); hdab_uncontr(:, :, :) = 0.0_dp
502 END IF
503 IF (PRESENT(hadb)) THEN
504 ALLOCATE (hadb_uncontr(3, ncoa, ncob)); hadb_uncontr(:, :, :) = 0.0_dp
505 END IF
506
507 hab_a_start = offset_hab_a + 1; hab_a_end = offset_hab_a + n_hab_a
508 hab_b_start = offset_hab_b + 1; hab_b_end = offset_hab_b + n_hab_b
509 set_a_start = offset_set_a + 1; set_a_end = offset_set_a + n_hab_a
510 set_b_start = offset_set_b + 1; set_b_end = offset_set_b + n_hab_b
511
512 IF (eri_method == do_eri_mme) THEN
513 CALL eri_mme_set_potential(param, convert_potential_type(potential_parameter%potential_type), potential_parameter%omega)
514
515 IF (calculate_forces .AND. PRESENT(pab)) THEN
516 ! uncontracted hermite-gaussian representation of density matrix
517 sphi_a_start = sgfa - 1 + set_a_start
518 sphi_b_start = sgfb - 1 + set_b_start
519
520 ALLOCATE (pab_ss(n_hab_a, n_hab_b))
521 pab_ss(:, :) = pab(hab_a_start:hab_a_end, hab_b_start:hab_b_end)
522 ALLOCATE (pab_hs(ncoa, n_hab_b)); ALLOCATE (pab_hh(ncoa, ncob))
523 CALL dgemm("N", "N", ncoa, n_hab_b, n_hab_a, 1.0_dp, &
524 sphi_a(:, sphi_a_start), SIZE(sphi_a, 1), pab_ss, n_hab_a, 0.0_dp, pab_hs, ncoa)
525 CALL dgemm("N", "T", ncoa, ncob, n_hab_b, 1.0_dp, &
526 pab_hs, ncoa, sphi_b(:, sphi_b_start), SIZE(sphi_b, 1), 0.0_dp, pab_hh, ncoa)
527 END IF
528
529 DO ipgf = 1, npgfa
530 na = (ipgf - 1)*ncoset(la_max)
531 DO jpgf = 1, npgfb
532 nb = (jpgf - 1)*ncoset(lb_max)
533 hab_uncontr_d(:, :) = 0.0_dp
534 CALL eri_mme_2c_integrate(param, &
535 la_min, la_max_d, lb_min, lb_max_d, &
536 zeta(ipgf), zetb(jpgf), ra - rb, hab_uncontr_d, 0, 0, g_count, r_count)
537
538 hab_uncontr(na + 1:na + ncoset(la_max), nb + 1:nb + ncoset(lb_max)) = &
539 hab_uncontr_d(:ncoset(la_max), :ncoset(lb_max))
540
541 IF (calculate_forces) THEN
542 DO lb = lb_min, lb_max
543 DO bx = 0, lb
544 DO by = 0, lb - bx
545 bz = lb - bx - by
546 jco = coset(bx, by, bz)
547 jcox = coset(bx + 1, by, bz)
548 jcoy = coset(bx, by + 1, bz)
549 jcoz = coset(bx, by, bz + 1)
550 DO la = la_min, la_max
551 DO ax = 0, la
552 DO ay = 0, la - ax
553 az = la - ax - ay
554 la_xyz = [ax, ay, az]
555 lb_xyz = [bx, by, bz]
556 ico = coset(ax, ay, az)
557 icox = coset(ax + 1, ay, az)
558 icoy = coset(ax, ay + 1, az)
559 icoz = coset(ax, ay, az + 1)
560 IF (PRESENT(force_a)) THEN
561 force_a(:) = force_a(:) + 2.0_dp*zeta(ipgf)* &
562 [pab_hh(na + ico, nb + jco)*hab_uncontr_d(icox, jco), &
563 pab_hh(na + ico, nb + jco)*hab_uncontr_d(icoy, jco), &
564 pab_hh(na + ico, nb + jco)*hab_uncontr_d(icoz, jco)]
565 END IF
566 IF (PRESENT(force_b)) THEN
567 force_b(:) = force_b(:) + 2.0_dp*zetb(jpgf)* &
568 [pab_hh(na + ico, nb + jco)*hab_uncontr_d(ico, jcox), &
569 pab_hh(na + ico, nb + jco)*hab_uncontr_d(ico, jcoy), &
570 pab_hh(na + ico, nb + jco)*hab_uncontr_d(ico, jcoz)]
571 END IF
572 IF (PRESENT(hdab)) THEN
573 hdab_uncontr(1:3, na + ico, nb + jco) = 2.0_dp*zeta(ipgf)* &
574 [hab_uncontr_d(icox, jco), &
575 hab_uncontr_d(icoy, jco), &
576 hab_uncontr_d(icoz, jco)]
577 END IF
578 IF (PRESENT(hadb)) THEN
579 hadb_uncontr(1:3, na + ico, nb + jco) = 2.0_dp*zetb(jpgf)* &
580 [hab_uncontr_d(ico, jcox), &
581 hab_uncontr_d(ico, jcoy), &
582 hab_uncontr_d(ico, jcoz)]
583 END IF
584 END DO
585 END DO
586 END DO
587 END DO
588 END DO
589 END DO
590 END IF
591
592 END DO
593 END DO
594
595 ELSE IF (eri_method == do_eri_os) THEN
596
597 IF (calculate_forces) cpabort("NYI")
598
599 ALLOCATE (f_work(0:la_max + lb_max + 2))
600 ALLOCATE (v_work(ncoa, ncob, la_max + lb_max + 1))
601 v_work(:, :, :) = 0.0_dp
602 f_work = 0.0_dp
603
604 CALL coulomb2_new(la_max, npgfa, zeta, la_min, lb_max, npgfb, zetb, lb_min, &
605 rb - ra, rab2, hab_uncontr, v_work, f_work)
606
607 DEALLOCATE (v_work, f_work)
608
609 ELSE IF (eri_method == do_eri_gpw) THEN
610
611 cpabort("GPW not enabled in the ERI interface.")
612
613 END IF
614
615 ALLOCATE (hab_contr(nsgfa, nsgfb))
616 IF (PRESENT(hdab)) THEN
617 ALLOCATE (hdab_contr(3, nsgfa, nsgfb))
618 END IF
619 IF (PRESENT(hadb)) THEN
620 ALLOCATE (hadb_contr(3, nsgfa, nsgfb))
621 END IF
622
623 CALL ab_contract(hab_contr, hab_uncontr, sphi_a(:, sgfa:), sphi_b(:, sgfb:), ncoa, ncob, nsgfa, nsgfb)
624
625 IF (calculate_forces) THEN
626 DO i_xyz = 1, 3
627 IF (PRESENT(hdab)) THEN
628 CALL ab_contract(hdab_contr(i_xyz, :, :), hdab_uncontr(i_xyz, :, :), &
629 sphi_a(:, sgfa:), sphi_b(:, sgfb:), ncoa, ncob, nsgfa, nsgfb)
630 END IF
631 IF (PRESENT(hadb)) THEN
632 CALL ab_contract(hadb_contr(i_xyz, :, :), hadb_uncontr(i_xyz, :, :), &
633 sphi_a(:, sgfa:), sphi_b(:, sgfb:), ncoa, ncob, nsgfa, nsgfb)
634 END IF
635 END DO
636 END IF
637
638 hab(hab_a_start:hab_a_end, hab_b_start:hab_b_end) = hab_contr(set_a_start:set_a_end, set_b_start:set_b_end)
639
640 IF (calculate_forces) THEN
641 IF (PRESENT(hdab)) hdab(:, hab_a_start:hab_a_end, hab_b_start:hab_b_end) = &
642 hdab_contr(:, set_a_start:set_a_end, set_b_start:set_b_end)
643 IF (PRESENT(hadb)) hadb(:, hab_a_start:hab_a_end, hab_b_start:hab_b_end) = &
644 hadb_contr(:, set_a_start:set_a_end, set_b_start:set_b_end)
645 END IF
646
647 CALL timestop(handle)
648
649 END SUBROUTINE integrate_set_2c
650
651! **************************************************************************************************
652!> \brief high-level integration routine for 3c integrals (ab|c) over CP2K basis sets.
653!> For each local function of c, (ab|c) is written to a DBCSR matrix mat_ab.
654!> \param param ...
655!> \param potential_parameter ...
656!> \param para_env ...
657!> \param qs_env ...
658!> \param first_c start index of local range of c
659!> \param last_c end index of local range of c
660!> \param mat_ab DBCSR matrices for each c
661!> \param basis_type_a ...
662!> \param basis_type_b ...
663!> \param basis_type_c ...
664!> \param sab_nl neighbor list for a, b
665!> \param eri_method ...
666!> \param pabc ...
667!> \param force_a ...
668!> \param force_b ...
669!> \param force_c ...
670!> \param mat_dabc ...
671!> \param mat_adbc ...
672!> \param mat_abdc ...
673! **************************************************************************************************
674 SUBROUTINE mp2_eri_3c_integrate(param, potential_parameter, para_env, qs_env, &
675 first_c, last_c, mat_ab, &
676 basis_type_a, basis_type_b, basis_type_c, &
677 sab_nl, eri_method, &
678 pabc, force_a, force_b, force_c, &
679 mat_dabc, mat_adbc, mat_abdc)
680 TYPE(cp_eri_mme_param), INTENT(INOUT) :: param
681 TYPE(libint_potential_type), INTENT(IN) :: potential_parameter
682 TYPE(mp_para_env_type), INTENT(IN) :: para_env
683 TYPE(qs_environment_type), INTENT(IN), POINTER :: qs_env
684 INTEGER, INTENT(IN) :: first_c, last_c
685 TYPE(dbcsr_p_type), DIMENSION(last_c - first_c + 1), &
686 INTENT(INOUT) :: mat_ab
687 CHARACTER(LEN=*), INTENT(IN) :: basis_type_a, basis_type_b, basis_type_c
688 TYPE(neighbor_list_set_p_type), DIMENSION(:), &
689 POINTER :: sab_nl
690 INTEGER, INTENT(IN), OPTIONAL :: eri_method
691 TYPE(dbcsr_p_type), DIMENSION(last_c - first_c + 1), &
692 INTENT(INOUT), OPTIONAL :: pabc
693 TYPE(mp2_eri_force), ALLOCATABLE, &
694 DIMENSION(:), INTENT(OUT), OPTIONAL :: force_a, force_b, force_c
695 TYPE(dbcsr_p_type), &
696 DIMENSION(3, last_c - first_c + 1), INTENT(INOUT), &
697 OPTIONAL :: mat_dabc, mat_adbc, mat_abdc
698
699 CHARACTER(LEN=*), PARAMETER :: routinen = 'mp2_eri_3c_integrate'
700
701 INTEGER :: atom_a, atom_b, atom_c, atom_end, atom_start, first_set, gg_count, gr_count, &
702 handle, i_xyz, iatom, ic, icol, ikind, inode, irow, iset, jatom, jkind, jset, katom, &
703 kkind, kset, kset_end, kset_start, last_jatom, last_set, mepos, my_eri_method, na, natom, &
704 nb, nc, nkind, nseta, nsetb, nsetc, nthread, offset_a_end, offset_a_start, offset_b_end, &
705 offset_b_start, offset_c_end, offset_c_start, rr_count, set_end, set_offset_end, &
706 set_offset_start, set_start, sgfa, sgfb, sgfc
707 INTEGER, ALLOCATABLE, DIMENSION(:) :: atom_of_kind, kind_of, natom_of_kind
708 INTEGER, ALLOCATABLE, DIMENSION(:, :) :: eri_offsets
709 INTEGER, DIMENSION(:), POINTER :: la_max, la_min, lb_max, lb_min, lc_max, &
710 lc_min, npgfa, npgfb, npgfc, nsgfa, &
711 nsgfb, nsgfc
712 INTEGER, DIMENSION(:, :), POINTER :: first_sgfa, first_sgfb, first_sgfc
713 LOGICAL :: calculate_forces, do_symmetric, found, &
714 to_be_asserted
715 REAL(kind=dp) :: dab
716 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: habc, pabc_block
717 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :, :) :: habdc, hadbc, hdabc
718 REAL(kind=dp), DIMENSION(3) :: ra, rab, rb, rc
719 REAL(kind=dp), DIMENSION(:), POINTER :: set_radius_a, set_radius_b
720 REAL(kind=dp), DIMENSION(:, :), POINTER :: munu_block, pab_block, rpgfb, sphi_a, &
721 sphi_b, sphi_c, zeta, zetb, zetc
722 TYPE(atomic_kind_type), DIMENSION(:), POINTER :: atomic_kind_set
723 TYPE(cell_type), POINTER :: cell
724 TYPE(gto_basis_set_p_type), DIMENSION(:), POINTER :: basis_set_list_a, basis_set_list_b
725 TYPE(gto_basis_set_type), POINTER :: basis_set_a, basis_set_b, basis_set_c
726 TYPE(neighbor_list_iterator_p_type), &
727 DIMENSION(:), POINTER :: nl_iterator
728 TYPE(particle_type), DIMENSION(:), POINTER :: particle_set
729 TYPE(qs_kind_type), DIMENSION(:), POINTER :: qs_kind_set
730
731 CALL timeset(routinen, handle)
732
733 calculate_forces = PRESENT(force_a) .OR. PRESENT(force_b) .OR. PRESENT(force_c) .OR. &
734 PRESENT(mat_dabc) .OR. PRESENT(mat_adbc) .OR. PRESENT(mat_abdc)
735
736 my_eri_method = do_eri_mme
737 IF (PRESENT(eri_method)) my_eri_method = eri_method
738
739 IF (PRESENT(force_a) .OR. PRESENT(force_b) .OR. PRESENT(force_c)) THEN
740 cpassert(PRESENT(pabc))
741 END IF
742
743 gg_count = 0; gr_count = 0; rr_count = 0
744
745 nthread = 1
746
747 ! get mapping between ERIs and atoms, sets, set offsets
748 CALL get_eri_offsets(qs_env, basis_type_c, eri_offsets)
749
750 atom_start = eri_offsets(first_c, 1)
751 set_start = eri_offsets(first_c, 2)
752 set_offset_start = eri_offsets(first_c, 3)
753
754 atom_end = eri_offsets(last_c, 1)
755 set_end = eri_offsets(last_c, 2)
756 set_offset_end = eri_offsets(last_c, 3)
757
758 ! get QS stuff
759 CALL get_qs_env(qs_env, &
760 atomic_kind_set=atomic_kind_set, &
761 natom=natom, &
762 qs_kind_set=qs_kind_set, &
763 particle_set=particle_set, &
764 cell=cell, &
765 nkind=nkind)
766
767 CALL get_atomic_kind_set(atomic_kind_set, atom_of_kind=atom_of_kind, kind_of=kind_of, natom_of_kind=natom_of_kind)
768
769 IF (PRESENT(force_a)) CALL mp2_eri_allocate_forces(force_a, natom_of_kind)
770 IF (PRESENT(force_b)) CALL mp2_eri_allocate_forces(force_b, natom_of_kind)
771 IF (PRESENT(force_c)) CALL mp2_eri_allocate_forces(force_c, natom_of_kind)
772
773 nc = last_c - first_c + 1
774
775 ! check for symmetry
776 cpassert(SIZE(sab_nl) > 0)
777 CALL get_neighbor_list_set_p(neighbor_list_sets=sab_nl, symmetric=do_symmetric)
778
779 IF (do_symmetric) THEN
780 cpassert(basis_type_a == basis_type_b)
781 END IF
782
783 ALLOCATE (basis_set_list_a(nkind), basis_set_list_b(nkind))
784 CALL basis_set_list_setup(basis_set_list_a, basis_type_a, qs_kind_set)
785 CALL basis_set_list_setup(basis_set_list_b, basis_type_b, qs_kind_set)
786
787 CALL neighbor_list_iterator_create(nl_iterator, sab_nl, nthread=nthread)
788
789 mepos = 0
790
791 DO WHILE (neighbor_list_iterate(nl_iterator, mepos=mepos) == 0)
792 CALL get_iterator_info(nl_iterator, mepos=mepos, ikind=ikind, jkind=jkind, inode=inode, &
793 iatom=iatom, jatom=jatom, r=rab)
794
795 ! exclude periodic images because method is periodic intrinsically
796 IF (inode == 1) last_jatom = 0
797
798 IF (jatom /= last_jatom) THEN
799 last_jatom = jatom
800 ELSE
801 cycle
802 END IF
803
804 basis_set_a => basis_set_list_a(ikind)%gto_basis_set
805 ! When RI_AUX NONE is invoked, the pointers to basis_set_a and basis_set_b are created,
806 ! but not filled. Therefore, we check for the association and the number of entries.
807 IF (.NOT. ASSOCIATED(basis_set_a) .OR. sum(basis_set_a%nsgf_set) <= 0) cycle
808 basis_set_b => basis_set_list_b(jkind)%gto_basis_set
809 IF (.NOT. ASSOCIATED(basis_set_b) .OR. sum(basis_set_b%nsgf_set) <= 0) cycle
810 atom_a = atom_of_kind(iatom)
811 atom_b = atom_of_kind(jatom)
812
813 first_sgfa => basis_set_a%first_sgf
814 la_max => basis_set_a%lmax
815 la_min => basis_set_a%lmin
816 npgfa => basis_set_a%npgf
817 nseta = basis_set_a%nset
818 nsgfa => basis_set_a%nsgf_set
819 set_radius_a => basis_set_a%set_radius
820 sphi_a => basis_set_a%sphi
821 zeta => basis_set_a%zet
822 na = sum(nsgfa)
823
824 ra(:) = pbc(particle_set(iatom)%r, cell)
825
826 ! basis jkind
827 first_sgfb => basis_set_b%first_sgf
828 lb_max => basis_set_b%lmax
829 lb_min => basis_set_b%lmin
830 npgfb => basis_set_b%npgf
831 nsetb = basis_set_b%nset
832 nsgfb => basis_set_b%nsgf_set
833 rpgfb => basis_set_b%pgf_radius
834 set_radius_b => basis_set_b%set_radius
835 sphi_b => basis_set_b%sphi
836 zetb => basis_set_b%zet
837 nb = sum(nsgfb)
838
839 rb(:) = pbc(particle_set(jatom)%r, cell)
840
841 IF (do_symmetric) THEN
842 IF (iatom <= jatom) THEN
843 irow = iatom
844 icol = jatom
845 ELSE
846 irow = jatom
847 icol = iatom
848 END IF
849 ELSE
850 irow = iatom
851 icol = jatom
852 END IF
853
854 ALLOCATE (habc(na, nb, nc))
855 habc(:, :, :) = 0.0_dp ! needs to be initialized due to screening
856 IF (PRESENT(mat_dabc)) THEN
857 ALLOCATE (hdabc(3, na, nb, nc))
858 hdabc(:, :, :, :) = 0.0_dp
859 END IF
860 IF (PRESENT(mat_adbc)) THEN
861 ALLOCATE (hadbc(3, na, nb, nc))
862 hadbc(:, :, :, :) = 0.0_dp
863 END IF
864 IF (PRESENT(mat_abdc)) THEN
865 ALLOCATE (habdc(3, na, nb, nc))
866 habdc(:, :, :, :) = 0.0_dp
867 END IF
868
869 IF (calculate_forces .AND. PRESENT(pabc)) THEN
870 ALLOCATE (pabc_block(na, nb, nc))
871 DO ic = 1, nc
872 NULLIFY (pab_block)
873 CALL dbcsr_get_block_p(matrix=pabc(ic)%matrix, &
874 row=irow, col=icol, block=pab_block, found=found)
875 cpassert(found)
876 IF (irow .EQ. iatom) THEN
877 to_be_asserted = SIZE(pab_block, 1) .EQ. SIZE(pabc_block, 1) .AND. SIZE(pab_block, 2) .EQ. SIZE(pabc_block, 2)
878 cpassert(to_be_asserted)
879 pabc_block(:, :, ic) = pab_block(:, :)
880 ELSE
881 to_be_asserted = SIZE(pab_block, 2) .EQ. SIZE(pabc_block, 1) .AND. SIZE(pab_block, 1) .EQ. SIZE(pabc_block, 2)
882 cpassert(to_be_asserted)
883 pabc_block(:, :, ic) = transpose(pab_block(:, :))
884 END IF
885 END DO
886 END IF
887
888 rab(:) = pbc(rab, cell)
889 dab = sqrt(rab(1)**2 + rab(2)**2 + rab(3)**2)
890
891 offset_a_end = 0
892 DO iset = 1, nseta
893 offset_a_start = offset_a_end
894 offset_a_end = offset_a_end + nsgfa(iset)
895 sgfa = first_sgfa(1, iset)
896
897 offset_b_end = 0
898 DO jset = 1, nsetb
899 offset_b_start = offset_b_end
900 offset_b_end = offset_b_end + nsgfb(jset)
901
902 sgfb = first_sgfb(1, jset)
903
904 ! Screening
905 IF (set_radius_a(iset) + set_radius_b(jset) < dab) cycle
906
907 offset_c_end = 0
908 DO katom = atom_start, atom_end
909
910 atom_c = atom_of_kind(katom)
911
912 kkind = kind_of(katom)
913 CALL get_qs_kind(qs_kind=qs_kind_set(kkind), basis_set=basis_set_c, basis_type=basis_type_c)
914 first_sgfc => basis_set_c%first_sgf
915 lc_max => basis_set_c%lmax
916 lc_min => basis_set_c%lmin
917 nsetc = basis_set_c%nset
918 nsgfc => basis_set_c%nsgf_set
919 sphi_c => basis_set_c%sphi
920 zetc => basis_set_c%zet
921 npgfc => basis_set_c%npgf
922
923 rc(:) = pbc(particle_set(katom)%r, cell)
924
925 kset_start = 1; kset_end = nsetc
926 IF (katom == atom_start) kset_start = set_start
927 IF (katom == atom_end) kset_end = set_end
928
929 DO kset = kset_start, kset_end
930 first_set = 1; last_set = nsgfc(kset)
931 IF (kset == kset_start .AND. katom == atom_start) first_set = set_offset_start
932 IF (kset == kset_end .AND. katom == atom_end) last_set = set_offset_end
933
934 offset_c_start = offset_c_end
935 offset_c_end = offset_c_end + last_set + 1 - first_set
936 sgfc = first_sgfc(1, kset)
937
938 IF (.NOT.PRESENT(force_a) .AND. &
939 .NOT.PRESENT(force_b) .AND. &
940 .NOT.PRESENT(force_c) .AND. &
941 .NOT.PRESENT(pabc) .AND. &
942 .NOT.PRESENT(mat_dabc) .AND. &
943 .NOT.PRESENT(mat_adbc) .AND. &
944 .NOT.PRESENT(mat_abdc)) THEN
945 CALL integrate_set_3c( &
946 param%par, potential_parameter, &
947 la_min(iset), la_max(iset), &
948 lb_min(jset), lb_max(jset), &
949 lc_min(kset), lc_max(kset), &
950 npgfa(iset), npgfb(jset), npgfc(kset), &
951 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
952 ra, rb, rc, &
953 habc, &
954 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
955 offset_a_start, offset_b_start, offset_c_start, &
956 0, 0, first_set - 1, &
957 sphi_a, sphi_b, sphi_c, &
958 sgfa, sgfb, sgfc, &
959 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
960 my_eri_method, &
961
962
963
964
965 do_symmetric=do_symmetric, &
966 on_diagonal=iatom .EQ. jatom, &
967
968
969
970 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
971 END IF
972 IF (.NOT.PRESENT(force_a) .AND. &
973 .NOT.PRESENT(force_b) .AND. &
974 .NOT.PRESENT(force_c) .AND. &
975 .NOT.PRESENT(pabc) .AND. &
976 .NOT.PRESENT(mat_dabc) .AND. &
977 .NOT.PRESENT(mat_adbc) .AND. &
978 PRESENT(mat_abdc)) THEN
979 CALL integrate_set_3c( &
980 param%par, potential_parameter, &
981 la_min(iset), la_max(iset), &
982 lb_min(jset), lb_max(jset), &
983 lc_min(kset), lc_max(kset), &
984 npgfa(iset), npgfb(jset), npgfc(kset), &
985 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
986 ra, rb, rc, &
987 habc, &
988 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
989 offset_a_start, offset_b_start, offset_c_start, &
990 0, 0, first_set - 1, &
991 sphi_a, sphi_b, sphi_c, &
992 sgfa, sgfb, sgfc, &
993 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
994 my_eri_method, &
995
996
997
998
999 do_symmetric=do_symmetric, &
1000 on_diagonal=iatom .EQ. jatom, &
1001
1002
1003habdc=habdc, &
1004 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1005 END IF
1006 IF (.NOT.PRESENT(force_a) .AND. &
1007 .NOT.PRESENT(force_b) .AND. &
1008 .NOT.PRESENT(force_c) .AND. &
1009 .NOT.PRESENT(pabc) .AND. &
1010 .NOT.PRESENT(mat_dabc) .AND. &
1011 PRESENT(mat_adbc) .AND. &
1012 .NOT.PRESENT(mat_abdc)) THEN
1013 CALL integrate_set_3c( &
1014 param%par, potential_parameter, &
1015 la_min(iset), la_max(iset), &
1016 lb_min(jset), lb_max(jset), &
1017 lc_min(kset), lc_max(kset), &
1018 npgfa(iset), npgfb(jset), npgfc(kset), &
1019 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1020 ra, rb, rc, &
1021 habc, &
1022 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1023 offset_a_start, offset_b_start, offset_c_start, &
1024 0, 0, first_set - 1, &
1025 sphi_a, sphi_b, sphi_c, &
1026 sgfa, sgfb, sgfc, &
1027 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1028 my_eri_method, &
1029
1030
1031
1032
1033 do_symmetric=do_symmetric, &
1034 on_diagonal=iatom .EQ. jatom, &
1035
1036hadbc=hadbc, &
1037
1038 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1039 END IF
1040 IF (.NOT.PRESENT(force_a) .AND. &
1041 .NOT.PRESENT(force_b) .AND. &
1042 .NOT.PRESENT(force_c) .AND. &
1043 .NOT.PRESENT(pabc) .AND. &
1044 .NOT.PRESENT(mat_dabc) .AND. &
1045 PRESENT(mat_adbc) .AND. &
1046 PRESENT(mat_abdc)) THEN
1047 CALL integrate_set_3c( &
1048 param%par, potential_parameter, &
1049 la_min(iset), la_max(iset), &
1050 lb_min(jset), lb_max(jset), &
1051 lc_min(kset), lc_max(kset), &
1052 npgfa(iset), npgfb(jset), npgfc(kset), &
1053 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1054 ra, rb, rc, &
1055 habc, &
1056 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1057 offset_a_start, offset_b_start, offset_c_start, &
1058 0, 0, first_set - 1, &
1059 sphi_a, sphi_b, sphi_c, &
1060 sgfa, sgfb, sgfc, &
1061 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1062 my_eri_method, &
1063
1064
1065
1066
1067 do_symmetric=do_symmetric, &
1068 on_diagonal=iatom .EQ. jatom, &
1069
1070hadbc=hadbc, &
1071habdc=habdc, &
1072 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1073 END IF
1074 IF (.NOT.PRESENT(force_a) .AND. &
1075 .NOT.PRESENT(force_b) .AND. &
1076 .NOT.PRESENT(force_c) .AND. &
1077 .NOT.PRESENT(pabc) .AND. &
1078 PRESENT(mat_dabc) .AND. &
1079 .NOT.PRESENT(mat_adbc) .AND. &
1080 .NOT.PRESENT(mat_abdc)) THEN
1081 CALL integrate_set_3c( &
1082 param%par, potential_parameter, &
1083 la_min(iset), la_max(iset), &
1084 lb_min(jset), lb_max(jset), &
1085 lc_min(kset), lc_max(kset), &
1086 npgfa(iset), npgfb(jset), npgfc(kset), &
1087 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1088 ra, rb, rc, &
1089 habc, &
1090 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1091 offset_a_start, offset_b_start, offset_c_start, &
1092 0, 0, first_set - 1, &
1093 sphi_a, sphi_b, sphi_c, &
1094 sgfa, sgfb, sgfc, &
1095 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1096 my_eri_method, &
1097
1098
1099
1100
1101 do_symmetric=do_symmetric, &
1102 on_diagonal=iatom .EQ. jatom, &
1103hdabc=hdabc, &
1104
1105
1106 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1107 END IF
1108 IF (.NOT.PRESENT(force_a) .AND. &
1109 .NOT.PRESENT(force_b) .AND. &
1110 .NOT.PRESENT(force_c) .AND. &
1111 .NOT.PRESENT(pabc) .AND. &
1112 PRESENT(mat_dabc) .AND. &
1113 .NOT.PRESENT(mat_adbc) .AND. &
1114 PRESENT(mat_abdc)) THEN
1115 CALL integrate_set_3c( &
1116 param%par, potential_parameter, &
1117 la_min(iset), la_max(iset), &
1118 lb_min(jset), lb_max(jset), &
1119 lc_min(kset), lc_max(kset), &
1120 npgfa(iset), npgfb(jset), npgfc(kset), &
1121 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1122 ra, rb, rc, &
1123 habc, &
1124 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1125 offset_a_start, offset_b_start, offset_c_start, &
1126 0, 0, first_set - 1, &
1127 sphi_a, sphi_b, sphi_c, &
1128 sgfa, sgfb, sgfc, &
1129 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1130 my_eri_method, &
1131
1132
1133
1134
1135 do_symmetric=do_symmetric, &
1136 on_diagonal=iatom .EQ. jatom, &
1137hdabc=hdabc, &
1138
1139habdc=habdc, &
1140 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1141 END IF
1142 IF (.NOT.PRESENT(force_a) .AND. &
1143 .NOT.PRESENT(force_b) .AND. &
1144 .NOT.PRESENT(force_c) .AND. &
1145 .NOT.PRESENT(pabc) .AND. &
1146 PRESENT(mat_dabc) .AND. &
1147 PRESENT(mat_adbc) .AND. &
1148 .NOT.PRESENT(mat_abdc)) THEN
1149 CALL integrate_set_3c( &
1150 param%par, potential_parameter, &
1151 la_min(iset), la_max(iset), &
1152 lb_min(jset), lb_max(jset), &
1153 lc_min(kset), lc_max(kset), &
1154 npgfa(iset), npgfb(jset), npgfc(kset), &
1155 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1156 ra, rb, rc, &
1157 habc, &
1158 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1159 offset_a_start, offset_b_start, offset_c_start, &
1160 0, 0, first_set - 1, &
1161 sphi_a, sphi_b, sphi_c, &
1162 sgfa, sgfb, sgfc, &
1163 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1164 my_eri_method, &
1165
1166
1167
1168
1169 do_symmetric=do_symmetric, &
1170 on_diagonal=iatom .EQ. jatom, &
1171hdabc=hdabc, &
1172hadbc=hadbc, &
1173
1174 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1175 END IF
1176 IF (.NOT.PRESENT(force_a) .AND. &
1177 .NOT.PRESENT(force_b) .AND. &
1178 .NOT.PRESENT(force_c) .AND. &
1179 .NOT.PRESENT(pabc) .AND. &
1180 PRESENT(mat_dabc) .AND. &
1181 PRESENT(mat_adbc) .AND. &
1182 PRESENT(mat_abdc)) THEN
1183 CALL integrate_set_3c( &
1184 param%par, potential_parameter, &
1185 la_min(iset), la_max(iset), &
1186 lb_min(jset), lb_max(jset), &
1187 lc_min(kset), lc_max(kset), &
1188 npgfa(iset), npgfb(jset), npgfc(kset), &
1189 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1190 ra, rb, rc, &
1191 habc, &
1192 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1193 offset_a_start, offset_b_start, offset_c_start, &
1194 0, 0, first_set - 1, &
1195 sphi_a, sphi_b, sphi_c, &
1196 sgfa, sgfb, sgfc, &
1197 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1198 my_eri_method, &
1199
1200
1201
1202
1203 do_symmetric=do_symmetric, &
1204 on_diagonal=iatom .EQ. jatom, &
1205hdabc=hdabc, &
1206hadbc=hadbc, &
1207habdc=habdc, &
1208 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1209 END IF
1210 IF (.NOT.PRESENT(force_a) .AND. &
1211 .NOT.PRESENT(force_b) .AND. &
1212 PRESENT(force_c) .AND. &
1213 .NOT.PRESENT(pabc) .AND. &
1214 .NOT.PRESENT(mat_dabc) .AND. &
1215 .NOT.PRESENT(mat_adbc) .AND. &
1216 .NOT.PRESENT(mat_abdc)) THEN
1217 CALL integrate_set_3c( &
1218 param%par, potential_parameter, &
1219 la_min(iset), la_max(iset), &
1220 lb_min(jset), lb_max(jset), &
1221 lc_min(kset), lc_max(kset), &
1222 npgfa(iset), npgfb(jset), npgfc(kset), &
1223 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1224 ra, rb, rc, &
1225 habc, &
1226 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1227 offset_a_start, offset_b_start, offset_c_start, &
1228 0, 0, first_set - 1, &
1229 sphi_a, sphi_b, sphi_c, &
1230 sgfa, sgfb, sgfc, &
1231 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1232 my_eri_method, &
1233
1234
1235
1236force_c=force_c(kkind)%forces(:, atom_c), &
1237 do_symmetric=do_symmetric, &
1238 on_diagonal=iatom .EQ. jatom, &
1239
1240
1241
1242 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1243 END IF
1244 IF (.NOT.PRESENT(force_a) .AND. &
1245 .NOT.PRESENT(force_b) .AND. &
1246 PRESENT(force_c) .AND. &
1247 .NOT.PRESENT(pabc) .AND. &
1248 .NOT.PRESENT(mat_dabc) .AND. &
1249 .NOT.PRESENT(mat_adbc) .AND. &
1250 PRESENT(mat_abdc)) THEN
1251 CALL integrate_set_3c( &
1252 param%par, potential_parameter, &
1253 la_min(iset), la_max(iset), &
1254 lb_min(jset), lb_max(jset), &
1255 lc_min(kset), lc_max(kset), &
1256 npgfa(iset), npgfb(jset), npgfc(kset), &
1257 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1258 ra, rb, rc, &
1259 habc, &
1260 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1261 offset_a_start, offset_b_start, offset_c_start, &
1262 0, 0, first_set - 1, &
1263 sphi_a, sphi_b, sphi_c, &
1264 sgfa, sgfb, sgfc, &
1265 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1266 my_eri_method, &
1267
1268
1269
1270force_c=force_c(kkind)%forces(:, atom_c), &
1271 do_symmetric=do_symmetric, &
1272 on_diagonal=iatom .EQ. jatom, &
1273
1274
1275habdc=habdc, &
1276 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1277 END IF
1278 IF (.NOT.PRESENT(force_a) .AND. &
1279 .NOT.PRESENT(force_b) .AND. &
1280 PRESENT(force_c) .AND. &
1281 .NOT.PRESENT(pabc) .AND. &
1282 .NOT.PRESENT(mat_dabc) .AND. &
1283 PRESENT(mat_adbc) .AND. &
1284 .NOT.PRESENT(mat_abdc)) THEN
1285 CALL integrate_set_3c( &
1286 param%par, potential_parameter, &
1287 la_min(iset), la_max(iset), &
1288 lb_min(jset), lb_max(jset), &
1289 lc_min(kset), lc_max(kset), &
1290 npgfa(iset), npgfb(jset), npgfc(kset), &
1291 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1292 ra, rb, rc, &
1293 habc, &
1294 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1295 offset_a_start, offset_b_start, offset_c_start, &
1296 0, 0, first_set - 1, &
1297 sphi_a, sphi_b, sphi_c, &
1298 sgfa, sgfb, sgfc, &
1299 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1300 my_eri_method, &
1301
1302
1303
1304force_c=force_c(kkind)%forces(:, atom_c), &
1305 do_symmetric=do_symmetric, &
1306 on_diagonal=iatom .EQ. jatom, &
1307
1308hadbc=hadbc, &
1309
1310 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1311 END IF
1312 IF (.NOT.PRESENT(force_a) .AND. &
1313 .NOT.PRESENT(force_b) .AND. &
1314 PRESENT(force_c) .AND. &
1315 .NOT.PRESENT(pabc) .AND. &
1316 .NOT.PRESENT(mat_dabc) .AND. &
1317 PRESENT(mat_adbc) .AND. &
1318 PRESENT(mat_abdc)) THEN
1319 CALL integrate_set_3c( &
1320 param%par, potential_parameter, &
1321 la_min(iset), la_max(iset), &
1322 lb_min(jset), lb_max(jset), &
1323 lc_min(kset), lc_max(kset), &
1324 npgfa(iset), npgfb(jset), npgfc(kset), &
1325 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1326 ra, rb, rc, &
1327 habc, &
1328 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1329 offset_a_start, offset_b_start, offset_c_start, &
1330 0, 0, first_set - 1, &
1331 sphi_a, sphi_b, sphi_c, &
1332 sgfa, sgfb, sgfc, &
1333 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1334 my_eri_method, &
1335
1336
1337
1338force_c=force_c(kkind)%forces(:, atom_c), &
1339 do_symmetric=do_symmetric, &
1340 on_diagonal=iatom .EQ. jatom, &
1341
1342hadbc=hadbc, &
1343habdc=habdc, &
1344 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1345 END IF
1346 IF (.NOT.PRESENT(force_a) .AND. &
1347 .NOT.PRESENT(force_b) .AND. &
1348 PRESENT(force_c) .AND. &
1349 .NOT.PRESENT(pabc) .AND. &
1350 PRESENT(mat_dabc) .AND. &
1351 .NOT.PRESENT(mat_adbc) .AND. &
1352 .NOT.PRESENT(mat_abdc)) THEN
1353 CALL integrate_set_3c( &
1354 param%par, potential_parameter, &
1355 la_min(iset), la_max(iset), &
1356 lb_min(jset), lb_max(jset), &
1357 lc_min(kset), lc_max(kset), &
1358 npgfa(iset), npgfb(jset), npgfc(kset), &
1359 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1360 ra, rb, rc, &
1361 habc, &
1362 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1363 offset_a_start, offset_b_start, offset_c_start, &
1364 0, 0, first_set - 1, &
1365 sphi_a, sphi_b, sphi_c, &
1366 sgfa, sgfb, sgfc, &
1367 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1368 my_eri_method, &
1369
1370
1371
1372force_c=force_c(kkind)%forces(:, atom_c), &
1373 do_symmetric=do_symmetric, &
1374 on_diagonal=iatom .EQ. jatom, &
1375hdabc=hdabc, &
1376
1377
1378 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1379 END IF
1380 IF (.NOT.PRESENT(force_a) .AND. &
1381 .NOT.PRESENT(force_b) .AND. &
1382 PRESENT(force_c) .AND. &
1383 .NOT.PRESENT(pabc) .AND. &
1384 PRESENT(mat_dabc) .AND. &
1385 .NOT.PRESENT(mat_adbc) .AND. &
1386 PRESENT(mat_abdc)) THEN
1387 CALL integrate_set_3c( &
1388 param%par, potential_parameter, &
1389 la_min(iset), la_max(iset), &
1390 lb_min(jset), lb_max(jset), &
1391 lc_min(kset), lc_max(kset), &
1392 npgfa(iset), npgfb(jset), npgfc(kset), &
1393 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1394 ra, rb, rc, &
1395 habc, &
1396 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1397 offset_a_start, offset_b_start, offset_c_start, &
1398 0, 0, first_set - 1, &
1399 sphi_a, sphi_b, sphi_c, &
1400 sgfa, sgfb, sgfc, &
1401 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1402 my_eri_method, &
1403
1404
1405
1406force_c=force_c(kkind)%forces(:, atom_c), &
1407 do_symmetric=do_symmetric, &
1408 on_diagonal=iatom .EQ. jatom, &
1409hdabc=hdabc, &
1410
1411habdc=habdc, &
1412 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1413 END IF
1414 IF (.NOT.PRESENT(force_a) .AND. &
1415 .NOT.PRESENT(force_b) .AND. &
1416 PRESENT(force_c) .AND. &
1417 .NOT.PRESENT(pabc) .AND. &
1418 PRESENT(mat_dabc) .AND. &
1419 PRESENT(mat_adbc) .AND. &
1420 .NOT.PRESENT(mat_abdc)) THEN
1421 CALL integrate_set_3c( &
1422 param%par, potential_parameter, &
1423 la_min(iset), la_max(iset), &
1424 lb_min(jset), lb_max(jset), &
1425 lc_min(kset), lc_max(kset), &
1426 npgfa(iset), npgfb(jset), npgfc(kset), &
1427 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1428 ra, rb, rc, &
1429 habc, &
1430 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1431 offset_a_start, offset_b_start, offset_c_start, &
1432 0, 0, first_set - 1, &
1433 sphi_a, sphi_b, sphi_c, &
1434 sgfa, sgfb, sgfc, &
1435 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1436 my_eri_method, &
1437
1438
1439
1440force_c=force_c(kkind)%forces(:, atom_c), &
1441 do_symmetric=do_symmetric, &
1442 on_diagonal=iatom .EQ. jatom, &
1443hdabc=hdabc, &
1444hadbc=hadbc, &
1445
1446 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1447 END IF
1448 IF (.NOT.PRESENT(force_a) .AND. &
1449 .NOT.PRESENT(force_b) .AND. &
1450 PRESENT(force_c) .AND. &
1451 .NOT.PRESENT(pabc) .AND. &
1452 PRESENT(mat_dabc) .AND. &
1453 PRESENT(mat_adbc) .AND. &
1454 PRESENT(mat_abdc)) THEN
1455 CALL integrate_set_3c( &
1456 param%par, potential_parameter, &
1457 la_min(iset), la_max(iset), &
1458 lb_min(jset), lb_max(jset), &
1459 lc_min(kset), lc_max(kset), &
1460 npgfa(iset), npgfb(jset), npgfc(kset), &
1461 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1462 ra, rb, rc, &
1463 habc, &
1464 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1465 offset_a_start, offset_b_start, offset_c_start, &
1466 0, 0, first_set - 1, &
1467 sphi_a, sphi_b, sphi_c, &
1468 sgfa, sgfb, sgfc, &
1469 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1470 my_eri_method, &
1471
1472
1473
1474force_c=force_c(kkind)%forces(:, atom_c), &
1475 do_symmetric=do_symmetric, &
1476 on_diagonal=iatom .EQ. jatom, &
1477hdabc=hdabc, &
1478hadbc=hadbc, &
1479habdc=habdc, &
1480 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1481 END IF
1482 IF (.NOT.PRESENT(force_a) .AND. &
1483 PRESENT(force_b) .AND. &
1484 .NOT.PRESENT(force_c) .AND. &
1485 .NOT.PRESENT(pabc) .AND. &
1486 .NOT.PRESENT(mat_dabc) .AND. &
1487 .NOT.PRESENT(mat_adbc) .AND. &
1488 .NOT.PRESENT(mat_abdc)) THEN
1489 CALL integrate_set_3c( &
1490 param%par, potential_parameter, &
1491 la_min(iset), la_max(iset), &
1492 lb_min(jset), lb_max(jset), &
1493 lc_min(kset), lc_max(kset), &
1494 npgfa(iset), npgfb(jset), npgfc(kset), &
1495 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1496 ra, rb, rc, &
1497 habc, &
1498 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1499 offset_a_start, offset_b_start, offset_c_start, &
1500 0, 0, first_set - 1, &
1501 sphi_a, sphi_b, sphi_c, &
1502 sgfa, sgfb, sgfc, &
1503 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1504 my_eri_method, &
1505
1506
1507force_b=force_b(jkind)%forces(:, atom_b), &
1508
1509 do_symmetric=do_symmetric, &
1510 on_diagonal=iatom .EQ. jatom, &
1511
1512
1513
1514 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1515 END IF
1516 IF (.NOT.PRESENT(force_a) .AND. &
1517 PRESENT(force_b) .AND. &
1518 .NOT.PRESENT(force_c) .AND. &
1519 .NOT.PRESENT(pabc) .AND. &
1520 .NOT.PRESENT(mat_dabc) .AND. &
1521 .NOT.PRESENT(mat_adbc) .AND. &
1522 PRESENT(mat_abdc)) THEN
1523 CALL integrate_set_3c( &
1524 param%par, potential_parameter, &
1525 la_min(iset), la_max(iset), &
1526 lb_min(jset), lb_max(jset), &
1527 lc_min(kset), lc_max(kset), &
1528 npgfa(iset), npgfb(jset), npgfc(kset), &
1529 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1530 ra, rb, rc, &
1531 habc, &
1532 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1533 offset_a_start, offset_b_start, offset_c_start, &
1534 0, 0, first_set - 1, &
1535 sphi_a, sphi_b, sphi_c, &
1536 sgfa, sgfb, sgfc, &
1537 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1538 my_eri_method, &
1539
1540
1541force_b=force_b(jkind)%forces(:, atom_b), &
1542
1543 do_symmetric=do_symmetric, &
1544 on_diagonal=iatom .EQ. jatom, &
1545
1546
1547habdc=habdc, &
1548 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1549 END IF
1550 IF (.NOT.PRESENT(force_a) .AND. &
1551 PRESENT(force_b) .AND. &
1552 .NOT.PRESENT(force_c) .AND. &
1553 .NOT.PRESENT(pabc) .AND. &
1554 .NOT.PRESENT(mat_dabc) .AND. &
1555 PRESENT(mat_adbc) .AND. &
1556 .NOT.PRESENT(mat_abdc)) THEN
1557 CALL integrate_set_3c( &
1558 param%par, potential_parameter, &
1559 la_min(iset), la_max(iset), &
1560 lb_min(jset), lb_max(jset), &
1561 lc_min(kset), lc_max(kset), &
1562 npgfa(iset), npgfb(jset), npgfc(kset), &
1563 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1564 ra, rb, rc, &
1565 habc, &
1566 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1567 offset_a_start, offset_b_start, offset_c_start, &
1568 0, 0, first_set - 1, &
1569 sphi_a, sphi_b, sphi_c, &
1570 sgfa, sgfb, sgfc, &
1571 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1572 my_eri_method, &
1573
1574
1575force_b=force_b(jkind)%forces(:, atom_b), &
1576
1577 do_symmetric=do_symmetric, &
1578 on_diagonal=iatom .EQ. jatom, &
1579
1580hadbc=hadbc, &
1581
1582 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1583 END IF
1584 IF (.NOT.PRESENT(force_a) .AND. &
1585 PRESENT(force_b) .AND. &
1586 .NOT.PRESENT(force_c) .AND. &
1587 .NOT.PRESENT(pabc) .AND. &
1588 .NOT.PRESENT(mat_dabc) .AND. &
1589 PRESENT(mat_adbc) .AND. &
1590 PRESENT(mat_abdc)) THEN
1591 CALL integrate_set_3c( &
1592 param%par, potential_parameter, &
1593 la_min(iset), la_max(iset), &
1594 lb_min(jset), lb_max(jset), &
1595 lc_min(kset), lc_max(kset), &
1596 npgfa(iset), npgfb(jset), npgfc(kset), &
1597 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1598 ra, rb, rc, &
1599 habc, &
1600 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1601 offset_a_start, offset_b_start, offset_c_start, &
1602 0, 0, first_set - 1, &
1603 sphi_a, sphi_b, sphi_c, &
1604 sgfa, sgfb, sgfc, &
1605 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1606 my_eri_method, &
1607
1608
1609force_b=force_b(jkind)%forces(:, atom_b), &
1610
1611 do_symmetric=do_symmetric, &
1612 on_diagonal=iatom .EQ. jatom, &
1613
1614hadbc=hadbc, &
1615habdc=habdc, &
1616 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1617 END IF
1618 IF (.NOT.PRESENT(force_a) .AND. &
1619 PRESENT(force_b) .AND. &
1620 .NOT.PRESENT(force_c) .AND. &
1621 .NOT.PRESENT(pabc) .AND. &
1622 PRESENT(mat_dabc) .AND. &
1623 .NOT.PRESENT(mat_adbc) .AND. &
1624 .NOT.PRESENT(mat_abdc)) THEN
1625 CALL integrate_set_3c( &
1626 param%par, potential_parameter, &
1627 la_min(iset), la_max(iset), &
1628 lb_min(jset), lb_max(jset), &
1629 lc_min(kset), lc_max(kset), &
1630 npgfa(iset), npgfb(jset), npgfc(kset), &
1631 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1632 ra, rb, rc, &
1633 habc, &
1634 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1635 offset_a_start, offset_b_start, offset_c_start, &
1636 0, 0, first_set - 1, &
1637 sphi_a, sphi_b, sphi_c, &
1638 sgfa, sgfb, sgfc, &
1639 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1640 my_eri_method, &
1641
1642
1643force_b=force_b(jkind)%forces(:, atom_b), &
1644
1645 do_symmetric=do_symmetric, &
1646 on_diagonal=iatom .EQ. jatom, &
1647hdabc=hdabc, &
1648
1649
1650 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1651 END IF
1652 IF (.NOT.PRESENT(force_a) .AND. &
1653 PRESENT(force_b) .AND. &
1654 .NOT.PRESENT(force_c) .AND. &
1655 .NOT.PRESENT(pabc) .AND. &
1656 PRESENT(mat_dabc) .AND. &
1657 .NOT.PRESENT(mat_adbc) .AND. &
1658 PRESENT(mat_abdc)) THEN
1659 CALL integrate_set_3c( &
1660 param%par, potential_parameter, &
1661 la_min(iset), la_max(iset), &
1662 lb_min(jset), lb_max(jset), &
1663 lc_min(kset), lc_max(kset), &
1664 npgfa(iset), npgfb(jset), npgfc(kset), &
1665 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1666 ra, rb, rc, &
1667 habc, &
1668 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1669 offset_a_start, offset_b_start, offset_c_start, &
1670 0, 0, first_set - 1, &
1671 sphi_a, sphi_b, sphi_c, &
1672 sgfa, sgfb, sgfc, &
1673 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1674 my_eri_method, &
1675
1676
1677force_b=force_b(jkind)%forces(:, atom_b), &
1678
1679 do_symmetric=do_symmetric, &
1680 on_diagonal=iatom .EQ. jatom, &
1681hdabc=hdabc, &
1682
1683habdc=habdc, &
1684 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1685 END IF
1686 IF (.NOT.PRESENT(force_a) .AND. &
1687 PRESENT(force_b) .AND. &
1688 .NOT.PRESENT(force_c) .AND. &
1689 .NOT.PRESENT(pabc) .AND. &
1690 PRESENT(mat_dabc) .AND. &
1691 PRESENT(mat_adbc) .AND. &
1692 .NOT.PRESENT(mat_abdc)) THEN
1693 CALL integrate_set_3c( &
1694 param%par, potential_parameter, &
1695 la_min(iset), la_max(iset), &
1696 lb_min(jset), lb_max(jset), &
1697 lc_min(kset), lc_max(kset), &
1698 npgfa(iset), npgfb(jset), npgfc(kset), &
1699 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1700 ra, rb, rc, &
1701 habc, &
1702 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1703 offset_a_start, offset_b_start, offset_c_start, &
1704 0, 0, first_set - 1, &
1705 sphi_a, sphi_b, sphi_c, &
1706 sgfa, sgfb, sgfc, &
1707 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1708 my_eri_method, &
1709
1710
1711force_b=force_b(jkind)%forces(:, atom_b), &
1712
1713 do_symmetric=do_symmetric, &
1714 on_diagonal=iatom .EQ. jatom, &
1715hdabc=hdabc, &
1716hadbc=hadbc, &
1717
1718 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1719 END IF
1720 IF (.NOT.PRESENT(force_a) .AND. &
1721 PRESENT(force_b) .AND. &
1722 .NOT.PRESENT(force_c) .AND. &
1723 .NOT.PRESENT(pabc) .AND. &
1724 PRESENT(mat_dabc) .AND. &
1725 PRESENT(mat_adbc) .AND. &
1726 PRESENT(mat_abdc)) THEN
1727 CALL integrate_set_3c( &
1728 param%par, potential_parameter, &
1729 la_min(iset), la_max(iset), &
1730 lb_min(jset), lb_max(jset), &
1731 lc_min(kset), lc_max(kset), &
1732 npgfa(iset), npgfb(jset), npgfc(kset), &
1733 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1734 ra, rb, rc, &
1735 habc, &
1736 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1737 offset_a_start, offset_b_start, offset_c_start, &
1738 0, 0, first_set - 1, &
1739 sphi_a, sphi_b, sphi_c, &
1740 sgfa, sgfb, sgfc, &
1741 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1742 my_eri_method, &
1743
1744
1745force_b=force_b(jkind)%forces(:, atom_b), &
1746
1747 do_symmetric=do_symmetric, &
1748 on_diagonal=iatom .EQ. jatom, &
1749hdabc=hdabc, &
1750hadbc=hadbc, &
1751habdc=habdc, &
1752 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1753 END IF
1754 IF (.NOT.PRESENT(force_a) .AND. &
1755 PRESENT(force_b) .AND. &
1756 PRESENT(force_c) .AND. &
1757 .NOT.PRESENT(pabc) .AND. &
1758 .NOT.PRESENT(mat_dabc) .AND. &
1759 .NOT.PRESENT(mat_adbc) .AND. &
1760 .NOT.PRESENT(mat_abdc)) THEN
1761 CALL integrate_set_3c( &
1762 param%par, potential_parameter, &
1763 la_min(iset), la_max(iset), &
1764 lb_min(jset), lb_max(jset), &
1765 lc_min(kset), lc_max(kset), &
1766 npgfa(iset), npgfb(jset), npgfc(kset), &
1767 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1768 ra, rb, rc, &
1769 habc, &
1770 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1771 offset_a_start, offset_b_start, offset_c_start, &
1772 0, 0, first_set - 1, &
1773 sphi_a, sphi_b, sphi_c, &
1774 sgfa, sgfb, sgfc, &
1775 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1776 my_eri_method, &
1777
1778
1779force_b=force_b(jkind)%forces(:, atom_b), &
1780force_c=force_c(kkind)%forces(:, atom_c), &
1781 do_symmetric=do_symmetric, &
1782 on_diagonal=iatom .EQ. jatom, &
1783
1784
1785
1786 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1787 END IF
1788 IF (.NOT.PRESENT(force_a) .AND. &
1789 PRESENT(force_b) .AND. &
1790 PRESENT(force_c) .AND. &
1791 .NOT.PRESENT(pabc) .AND. &
1792 .NOT.PRESENT(mat_dabc) .AND. &
1793 .NOT.PRESENT(mat_adbc) .AND. &
1794 PRESENT(mat_abdc)) THEN
1795 CALL integrate_set_3c( &
1796 param%par, potential_parameter, &
1797 la_min(iset), la_max(iset), &
1798 lb_min(jset), lb_max(jset), &
1799 lc_min(kset), lc_max(kset), &
1800 npgfa(iset), npgfb(jset), npgfc(kset), &
1801 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1802 ra, rb, rc, &
1803 habc, &
1804 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1805 offset_a_start, offset_b_start, offset_c_start, &
1806 0, 0, first_set - 1, &
1807 sphi_a, sphi_b, sphi_c, &
1808 sgfa, sgfb, sgfc, &
1809 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1810 my_eri_method, &
1811
1812
1813force_b=force_b(jkind)%forces(:, atom_b), &
1814force_c=force_c(kkind)%forces(:, atom_c), &
1815 do_symmetric=do_symmetric, &
1816 on_diagonal=iatom .EQ. jatom, &
1817
1818
1819habdc=habdc, &
1820 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1821 END IF
1822 IF (.NOT.PRESENT(force_a) .AND. &
1823 PRESENT(force_b) .AND. &
1824 PRESENT(force_c) .AND. &
1825 .NOT.PRESENT(pabc) .AND. &
1826 .NOT.PRESENT(mat_dabc) .AND. &
1827 PRESENT(mat_adbc) .AND. &
1828 .NOT.PRESENT(mat_abdc)) THEN
1829 CALL integrate_set_3c( &
1830 param%par, potential_parameter, &
1831 la_min(iset), la_max(iset), &
1832 lb_min(jset), lb_max(jset), &
1833 lc_min(kset), lc_max(kset), &
1834 npgfa(iset), npgfb(jset), npgfc(kset), &
1835 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1836 ra, rb, rc, &
1837 habc, &
1838 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1839 offset_a_start, offset_b_start, offset_c_start, &
1840 0, 0, first_set - 1, &
1841 sphi_a, sphi_b, sphi_c, &
1842 sgfa, sgfb, sgfc, &
1843 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1844 my_eri_method, &
1845
1846
1847force_b=force_b(jkind)%forces(:, atom_b), &
1848force_c=force_c(kkind)%forces(:, atom_c), &
1849 do_symmetric=do_symmetric, &
1850 on_diagonal=iatom .EQ. jatom, &
1851
1852hadbc=hadbc, &
1853
1854 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1855 END IF
1856 IF (.NOT.PRESENT(force_a) .AND. &
1857 PRESENT(force_b) .AND. &
1858 PRESENT(force_c) .AND. &
1859 .NOT.PRESENT(pabc) .AND. &
1860 .NOT.PRESENT(mat_dabc) .AND. &
1861 PRESENT(mat_adbc) .AND. &
1862 PRESENT(mat_abdc)) THEN
1863 CALL integrate_set_3c( &
1864 param%par, potential_parameter, &
1865 la_min(iset), la_max(iset), &
1866 lb_min(jset), lb_max(jset), &
1867 lc_min(kset), lc_max(kset), &
1868 npgfa(iset), npgfb(jset), npgfc(kset), &
1869 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1870 ra, rb, rc, &
1871 habc, &
1872 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1873 offset_a_start, offset_b_start, offset_c_start, &
1874 0, 0, first_set - 1, &
1875 sphi_a, sphi_b, sphi_c, &
1876 sgfa, sgfb, sgfc, &
1877 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1878 my_eri_method, &
1879
1880
1881force_b=force_b(jkind)%forces(:, atom_b), &
1882force_c=force_c(kkind)%forces(:, atom_c), &
1883 do_symmetric=do_symmetric, &
1884 on_diagonal=iatom .EQ. jatom, &
1885
1886hadbc=hadbc, &
1887habdc=habdc, &
1888 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1889 END IF
1890 IF (.NOT.PRESENT(force_a) .AND. &
1891 PRESENT(force_b) .AND. &
1892 PRESENT(force_c) .AND. &
1893 .NOT.PRESENT(pabc) .AND. &
1894 PRESENT(mat_dabc) .AND. &
1895 .NOT.PRESENT(mat_adbc) .AND. &
1896 .NOT.PRESENT(mat_abdc)) THEN
1897 CALL integrate_set_3c( &
1898 param%par, potential_parameter, &
1899 la_min(iset), la_max(iset), &
1900 lb_min(jset), lb_max(jset), &
1901 lc_min(kset), lc_max(kset), &
1902 npgfa(iset), npgfb(jset), npgfc(kset), &
1903 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1904 ra, rb, rc, &
1905 habc, &
1906 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1907 offset_a_start, offset_b_start, offset_c_start, &
1908 0, 0, first_set - 1, &
1909 sphi_a, sphi_b, sphi_c, &
1910 sgfa, sgfb, sgfc, &
1911 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1912 my_eri_method, &
1913
1914
1915force_b=force_b(jkind)%forces(:, atom_b), &
1916force_c=force_c(kkind)%forces(:, atom_c), &
1917 do_symmetric=do_symmetric, &
1918 on_diagonal=iatom .EQ. jatom, &
1919hdabc=hdabc, &
1920
1921
1922 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1923 END IF
1924 IF (.NOT.PRESENT(force_a) .AND. &
1925 PRESENT(force_b) .AND. &
1926 PRESENT(force_c) .AND. &
1927 .NOT.PRESENT(pabc) .AND. &
1928 PRESENT(mat_dabc) .AND. &
1929 .NOT.PRESENT(mat_adbc) .AND. &
1930 PRESENT(mat_abdc)) THEN
1931 CALL integrate_set_3c( &
1932 param%par, potential_parameter, &
1933 la_min(iset), la_max(iset), &
1934 lb_min(jset), lb_max(jset), &
1935 lc_min(kset), lc_max(kset), &
1936 npgfa(iset), npgfb(jset), npgfc(kset), &
1937 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1938 ra, rb, rc, &
1939 habc, &
1940 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1941 offset_a_start, offset_b_start, offset_c_start, &
1942 0, 0, first_set - 1, &
1943 sphi_a, sphi_b, sphi_c, &
1944 sgfa, sgfb, sgfc, &
1945 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1946 my_eri_method, &
1947
1948
1949force_b=force_b(jkind)%forces(:, atom_b), &
1950force_c=force_c(kkind)%forces(:, atom_c), &
1951 do_symmetric=do_symmetric, &
1952 on_diagonal=iatom .EQ. jatom, &
1953hdabc=hdabc, &
1954
1955habdc=habdc, &
1956 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1957 END IF
1958 IF (.NOT.PRESENT(force_a) .AND. &
1959 PRESENT(force_b) .AND. &
1960 PRESENT(force_c) .AND. &
1961 .NOT.PRESENT(pabc) .AND. &
1962 PRESENT(mat_dabc) .AND. &
1963 PRESENT(mat_adbc) .AND. &
1964 .NOT.PRESENT(mat_abdc)) THEN
1965 CALL integrate_set_3c( &
1966 param%par, potential_parameter, &
1967 la_min(iset), la_max(iset), &
1968 lb_min(jset), lb_max(jset), &
1969 lc_min(kset), lc_max(kset), &
1970 npgfa(iset), npgfb(jset), npgfc(kset), &
1971 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1972 ra, rb, rc, &
1973 habc, &
1974 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1975 offset_a_start, offset_b_start, offset_c_start, &
1976 0, 0, first_set - 1, &
1977 sphi_a, sphi_b, sphi_c, &
1978 sgfa, sgfb, sgfc, &
1979 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1980 my_eri_method, &
1981
1982
1983force_b=force_b(jkind)%forces(:, atom_b), &
1984force_c=force_c(kkind)%forces(:, atom_c), &
1985 do_symmetric=do_symmetric, &
1986 on_diagonal=iatom .EQ. jatom, &
1987hdabc=hdabc, &
1988hadbc=hadbc, &
1989
1990 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1991 END IF
1992 IF (.NOT.PRESENT(force_a) .AND. &
1993 PRESENT(force_b) .AND. &
1994 PRESENT(force_c) .AND. &
1995 .NOT.PRESENT(pabc) .AND. &
1996 PRESENT(mat_dabc) .AND. &
1997 PRESENT(mat_adbc) .AND. &
1998 PRESENT(mat_abdc)) THEN
1999 CALL integrate_set_3c( &
2000 param%par, potential_parameter, &
2001 la_min(iset), la_max(iset), &
2002 lb_min(jset), lb_max(jset), &
2003 lc_min(kset), lc_max(kset), &
2004 npgfa(iset), npgfb(jset), npgfc(kset), &
2005 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2006 ra, rb, rc, &
2007 habc, &
2008 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2009 offset_a_start, offset_b_start, offset_c_start, &
2010 0, 0, first_set - 1, &
2011 sphi_a, sphi_b, sphi_c, &
2012 sgfa, sgfb, sgfc, &
2013 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2014 my_eri_method, &
2015
2016
2017force_b=force_b(jkind)%forces(:, atom_b), &
2018force_c=force_c(kkind)%forces(:, atom_c), &
2019 do_symmetric=do_symmetric, &
2020 on_diagonal=iatom .EQ. jatom, &
2021hdabc=hdabc, &
2022hadbc=hadbc, &
2023habdc=habdc, &
2024 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2025 END IF
2026 IF (PRESENT(force_a) .AND. &
2027 .NOT.PRESENT(force_b) .AND. &
2028 .NOT.PRESENT(force_c) .AND. &
2029 .NOT.PRESENT(pabc) .AND. &
2030 .NOT.PRESENT(mat_dabc) .AND. &
2031 .NOT.PRESENT(mat_adbc) .AND. &
2032 .NOT.PRESENT(mat_abdc)) THEN
2033 CALL integrate_set_3c( &
2034 param%par, potential_parameter, &
2035 la_min(iset), la_max(iset), &
2036 lb_min(jset), lb_max(jset), &
2037 lc_min(kset), lc_max(kset), &
2038 npgfa(iset), npgfb(jset), npgfc(kset), &
2039 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2040 ra, rb, rc, &
2041 habc, &
2042 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2043 offset_a_start, offset_b_start, offset_c_start, &
2044 0, 0, first_set - 1, &
2045 sphi_a, sphi_b, sphi_c, &
2046 sgfa, sgfb, sgfc, &
2047 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2048 my_eri_method, &
2049
2050force_a=force_a(ikind)%forces(:, atom_a), &
2051
2052
2053 do_symmetric=do_symmetric, &
2054 on_diagonal=iatom .EQ. jatom, &
2055
2056
2057
2058 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2059 END IF
2060 IF (PRESENT(force_a) .AND. &
2061 .NOT.PRESENT(force_b) .AND. &
2062 .NOT.PRESENT(force_c) .AND. &
2063 .NOT.PRESENT(pabc) .AND. &
2064 .NOT.PRESENT(mat_dabc) .AND. &
2065 .NOT.PRESENT(mat_adbc) .AND. &
2066 PRESENT(mat_abdc)) THEN
2067 CALL integrate_set_3c( &
2068 param%par, potential_parameter, &
2069 la_min(iset), la_max(iset), &
2070 lb_min(jset), lb_max(jset), &
2071 lc_min(kset), lc_max(kset), &
2072 npgfa(iset), npgfb(jset), npgfc(kset), &
2073 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2074 ra, rb, rc, &
2075 habc, &
2076 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2077 offset_a_start, offset_b_start, offset_c_start, &
2078 0, 0, first_set - 1, &
2079 sphi_a, sphi_b, sphi_c, &
2080 sgfa, sgfb, sgfc, &
2081 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2082 my_eri_method, &
2083
2084force_a=force_a(ikind)%forces(:, atom_a), &
2085
2086
2087 do_symmetric=do_symmetric, &
2088 on_diagonal=iatom .EQ. jatom, &
2089
2090
2091habdc=habdc, &
2092 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2093 END IF
2094 IF (PRESENT(force_a) .AND. &
2095 .NOT.PRESENT(force_b) .AND. &
2096 .NOT.PRESENT(force_c) .AND. &
2097 .NOT.PRESENT(pabc) .AND. &
2098 .NOT.PRESENT(mat_dabc) .AND. &
2099 PRESENT(mat_adbc) .AND. &
2100 .NOT.PRESENT(mat_abdc)) THEN
2101 CALL integrate_set_3c( &
2102 param%par, potential_parameter, &
2103 la_min(iset), la_max(iset), &
2104 lb_min(jset), lb_max(jset), &
2105 lc_min(kset), lc_max(kset), &
2106 npgfa(iset), npgfb(jset), npgfc(kset), &
2107 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2108 ra, rb, rc, &
2109 habc, &
2110 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2111 offset_a_start, offset_b_start, offset_c_start, &
2112 0, 0, first_set - 1, &
2113 sphi_a, sphi_b, sphi_c, &
2114 sgfa, sgfb, sgfc, &
2115 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2116 my_eri_method, &
2117
2118force_a=force_a(ikind)%forces(:, atom_a), &
2119
2120
2121 do_symmetric=do_symmetric, &
2122 on_diagonal=iatom .EQ. jatom, &
2123
2124hadbc=hadbc, &
2125
2126 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2127 END IF
2128 IF (PRESENT(force_a) .AND. &
2129 .NOT.PRESENT(force_b) .AND. &
2130 .NOT.PRESENT(force_c) .AND. &
2131 .NOT.PRESENT(pabc) .AND. &
2132 .NOT.PRESENT(mat_dabc) .AND. &
2133 PRESENT(mat_adbc) .AND. &
2134 PRESENT(mat_abdc)) THEN
2135 CALL integrate_set_3c( &
2136 param%par, potential_parameter, &
2137 la_min(iset), la_max(iset), &
2138 lb_min(jset), lb_max(jset), &
2139 lc_min(kset), lc_max(kset), &
2140 npgfa(iset), npgfb(jset), npgfc(kset), &
2141 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2142 ra, rb, rc, &
2143 habc, &
2144 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2145 offset_a_start, offset_b_start, offset_c_start, &
2146 0, 0, first_set - 1, &
2147 sphi_a, sphi_b, sphi_c, &
2148 sgfa, sgfb, sgfc, &
2149 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2150 my_eri_method, &
2151
2152force_a=force_a(ikind)%forces(:, atom_a), &
2153
2154
2155 do_symmetric=do_symmetric, &
2156 on_diagonal=iatom .EQ. jatom, &
2157
2158hadbc=hadbc, &
2159habdc=habdc, &
2160 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2161 END IF
2162 IF (PRESENT(force_a) .AND. &
2163 .NOT.PRESENT(force_b) .AND. &
2164 .NOT.PRESENT(force_c) .AND. &
2165 .NOT.PRESENT(pabc) .AND. &
2166 PRESENT(mat_dabc) .AND. &
2167 .NOT.PRESENT(mat_adbc) .AND. &
2168 .NOT.PRESENT(mat_abdc)) THEN
2169 CALL integrate_set_3c( &
2170 param%par, potential_parameter, &
2171 la_min(iset), la_max(iset), &
2172 lb_min(jset), lb_max(jset), &
2173 lc_min(kset), lc_max(kset), &
2174 npgfa(iset), npgfb(jset), npgfc(kset), &
2175 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2176 ra, rb, rc, &
2177 habc, &
2178 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2179 offset_a_start, offset_b_start, offset_c_start, &
2180 0, 0, first_set - 1, &
2181 sphi_a, sphi_b, sphi_c, &
2182 sgfa, sgfb, sgfc, &
2183 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2184 my_eri_method, &
2185
2186force_a=force_a(ikind)%forces(:, atom_a), &
2187
2188
2189 do_symmetric=do_symmetric, &
2190 on_diagonal=iatom .EQ. jatom, &
2191hdabc=hdabc, &
2192
2193
2194 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2195 END IF
2196 IF (PRESENT(force_a) .AND. &
2197 .NOT.PRESENT(force_b) .AND. &
2198 .NOT.PRESENT(force_c) .AND. &
2199 .NOT.PRESENT(pabc) .AND. &
2200 PRESENT(mat_dabc) .AND. &
2201 .NOT.PRESENT(mat_adbc) .AND. &
2202 PRESENT(mat_abdc)) THEN
2203 CALL integrate_set_3c( &
2204 param%par, potential_parameter, &
2205 la_min(iset), la_max(iset), &
2206 lb_min(jset), lb_max(jset), &
2207 lc_min(kset), lc_max(kset), &
2208 npgfa(iset), npgfb(jset), npgfc(kset), &
2209 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2210 ra, rb, rc, &
2211 habc, &
2212 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2213 offset_a_start, offset_b_start, offset_c_start, &
2214 0, 0, first_set - 1, &
2215 sphi_a, sphi_b, sphi_c, &
2216 sgfa, sgfb, sgfc, &
2217 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2218 my_eri_method, &
2219
2220force_a=force_a(ikind)%forces(:, atom_a), &
2221
2222
2223 do_symmetric=do_symmetric, &
2224 on_diagonal=iatom .EQ. jatom, &
2225hdabc=hdabc, &
2226
2227habdc=habdc, &
2228 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2229 END IF
2230 IF (PRESENT(force_a) .AND. &
2231 .NOT.PRESENT(force_b) .AND. &
2232 .NOT.PRESENT(force_c) .AND. &
2233 .NOT.PRESENT(pabc) .AND. &
2234 PRESENT(mat_dabc) .AND. &
2235 PRESENT(mat_adbc) .AND. &
2236 .NOT.PRESENT(mat_abdc)) THEN
2237 CALL integrate_set_3c( &
2238 param%par, potential_parameter, &
2239 la_min(iset), la_max(iset), &
2240 lb_min(jset), lb_max(jset), &
2241 lc_min(kset), lc_max(kset), &
2242 npgfa(iset), npgfb(jset), npgfc(kset), &
2243 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2244 ra, rb, rc, &
2245 habc, &
2246 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2247 offset_a_start, offset_b_start, offset_c_start, &
2248 0, 0, first_set - 1, &
2249 sphi_a, sphi_b, sphi_c, &
2250 sgfa, sgfb, sgfc, &
2251 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2252 my_eri_method, &
2253
2254force_a=force_a(ikind)%forces(:, atom_a), &
2255
2256
2257 do_symmetric=do_symmetric, &
2258 on_diagonal=iatom .EQ. jatom, &
2259hdabc=hdabc, &
2260hadbc=hadbc, &
2261
2262 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2263 END IF
2264 IF (PRESENT(force_a) .AND. &
2265 .NOT.PRESENT(force_b) .AND. &
2266 .NOT.PRESENT(force_c) .AND. &
2267 .NOT.PRESENT(pabc) .AND. &
2268 PRESENT(mat_dabc) .AND. &
2269 PRESENT(mat_adbc) .AND. &
2270 PRESENT(mat_abdc)) THEN
2271 CALL integrate_set_3c( &
2272 param%par, potential_parameter, &
2273 la_min(iset), la_max(iset), &
2274 lb_min(jset), lb_max(jset), &
2275 lc_min(kset), lc_max(kset), &
2276 npgfa(iset), npgfb(jset), npgfc(kset), &
2277 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2278 ra, rb, rc, &
2279 habc, &
2280 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2281 offset_a_start, offset_b_start, offset_c_start, &
2282 0, 0, first_set - 1, &
2283 sphi_a, sphi_b, sphi_c, &
2284 sgfa, sgfb, sgfc, &
2285 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2286 my_eri_method, &
2287
2288force_a=force_a(ikind)%forces(:, atom_a), &
2289
2290
2291 do_symmetric=do_symmetric, &
2292 on_diagonal=iatom .EQ. jatom, &
2293hdabc=hdabc, &
2294hadbc=hadbc, &
2295habdc=habdc, &
2296 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2297 END IF
2298 IF (PRESENT(force_a) .AND. &
2299 .NOT.PRESENT(force_b) .AND. &
2300 PRESENT(force_c) .AND. &
2301 .NOT.PRESENT(pabc) .AND. &
2302 .NOT.PRESENT(mat_dabc) .AND. &
2303 .NOT.PRESENT(mat_adbc) .AND. &
2304 .NOT.PRESENT(mat_abdc)) THEN
2305 CALL integrate_set_3c( &
2306 param%par, potential_parameter, &
2307 la_min(iset), la_max(iset), &
2308 lb_min(jset), lb_max(jset), &
2309 lc_min(kset), lc_max(kset), &
2310 npgfa(iset), npgfb(jset), npgfc(kset), &
2311 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2312 ra, rb, rc, &
2313 habc, &
2314 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2315 offset_a_start, offset_b_start, offset_c_start, &
2316 0, 0, first_set - 1, &
2317 sphi_a, sphi_b, sphi_c, &
2318 sgfa, sgfb, sgfc, &
2319 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2320 my_eri_method, &
2321
2322force_a=force_a(ikind)%forces(:, atom_a), &
2323
2324force_c=force_c(kkind)%forces(:, atom_c), &
2325 do_symmetric=do_symmetric, &
2326 on_diagonal=iatom .EQ. jatom, &
2327
2328
2329
2330 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2331 END IF
2332 IF (PRESENT(force_a) .AND. &
2333 .NOT.PRESENT(force_b) .AND. &
2334 PRESENT(force_c) .AND. &
2335 .NOT.PRESENT(pabc) .AND. &
2336 .NOT.PRESENT(mat_dabc) .AND. &
2337 .NOT.PRESENT(mat_adbc) .AND. &
2338 PRESENT(mat_abdc)) THEN
2339 CALL integrate_set_3c( &
2340 param%par, potential_parameter, &
2341 la_min(iset), la_max(iset), &
2342 lb_min(jset), lb_max(jset), &
2343 lc_min(kset), lc_max(kset), &
2344 npgfa(iset), npgfb(jset), npgfc(kset), &
2345 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2346 ra, rb, rc, &
2347 habc, &
2348 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2349 offset_a_start, offset_b_start, offset_c_start, &
2350 0, 0, first_set - 1, &
2351 sphi_a, sphi_b, sphi_c, &
2352 sgfa, sgfb, sgfc, &
2353 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2354 my_eri_method, &
2355
2356force_a=force_a(ikind)%forces(:, atom_a), &
2357
2358force_c=force_c(kkind)%forces(:, atom_c), &
2359 do_symmetric=do_symmetric, &
2360 on_diagonal=iatom .EQ. jatom, &
2361
2362
2363habdc=habdc, &
2364 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2365 END IF
2366 IF (PRESENT(force_a) .AND. &
2367 .NOT.PRESENT(force_b) .AND. &
2368 PRESENT(force_c) .AND. &
2369 .NOT.PRESENT(pabc) .AND. &
2370 .NOT.PRESENT(mat_dabc) .AND. &
2371 PRESENT(mat_adbc) .AND. &
2372 .NOT.PRESENT(mat_abdc)) THEN
2373 CALL integrate_set_3c( &
2374 param%par, potential_parameter, &
2375 la_min(iset), la_max(iset), &
2376 lb_min(jset), lb_max(jset), &
2377 lc_min(kset), lc_max(kset), &
2378 npgfa(iset), npgfb(jset), npgfc(kset), &
2379 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2380 ra, rb, rc, &
2381 habc, &
2382 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2383 offset_a_start, offset_b_start, offset_c_start, &
2384 0, 0, first_set - 1, &
2385 sphi_a, sphi_b, sphi_c, &
2386 sgfa, sgfb, sgfc, &
2387 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2388 my_eri_method, &
2389
2390force_a=force_a(ikind)%forces(:, atom_a), &
2391
2392force_c=force_c(kkind)%forces(:, atom_c), &
2393 do_symmetric=do_symmetric, &
2394 on_diagonal=iatom .EQ. jatom, &
2395
2396hadbc=hadbc, &
2397
2398 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2399 END IF
2400 IF (PRESENT(force_a) .AND. &
2401 .NOT.PRESENT(force_b) .AND. &
2402 PRESENT(force_c) .AND. &
2403 .NOT.PRESENT(pabc) .AND. &
2404 .NOT.PRESENT(mat_dabc) .AND. &
2405 PRESENT(mat_adbc) .AND. &
2406 PRESENT(mat_abdc)) THEN
2407 CALL integrate_set_3c( &
2408 param%par, potential_parameter, &
2409 la_min(iset), la_max(iset), &
2410 lb_min(jset), lb_max(jset), &
2411 lc_min(kset), lc_max(kset), &
2412 npgfa(iset), npgfb(jset), npgfc(kset), &
2413 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2414 ra, rb, rc, &
2415 habc, &
2416 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2417 offset_a_start, offset_b_start, offset_c_start, &
2418 0, 0, first_set - 1, &
2419 sphi_a, sphi_b, sphi_c, &
2420 sgfa, sgfb, sgfc, &
2421 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2422 my_eri_method, &
2423
2424force_a=force_a(ikind)%forces(:, atom_a), &
2425
2426force_c=force_c(kkind)%forces(:, atom_c), &
2427 do_symmetric=do_symmetric, &
2428 on_diagonal=iatom .EQ. jatom, &
2429
2430hadbc=hadbc, &
2431habdc=habdc, &
2432 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2433 END IF
2434 IF (PRESENT(force_a) .AND. &
2435 .NOT.PRESENT(force_b) .AND. &
2436 PRESENT(force_c) .AND. &
2437 .NOT.PRESENT(pabc) .AND. &
2438 PRESENT(mat_dabc) .AND. &
2439 .NOT.PRESENT(mat_adbc) .AND. &
2440 .NOT.PRESENT(mat_abdc)) THEN
2441 CALL integrate_set_3c( &
2442 param%par, potential_parameter, &
2443 la_min(iset), la_max(iset), &
2444 lb_min(jset), lb_max(jset), &
2445 lc_min(kset), lc_max(kset), &
2446 npgfa(iset), npgfb(jset), npgfc(kset), &
2447 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2448 ra, rb, rc, &
2449 habc, &
2450 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2451 offset_a_start, offset_b_start, offset_c_start, &
2452 0, 0, first_set - 1, &
2453 sphi_a, sphi_b, sphi_c, &
2454 sgfa, sgfb, sgfc, &
2455 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2456 my_eri_method, &
2457
2458force_a=force_a(ikind)%forces(:, atom_a), &
2459
2460force_c=force_c(kkind)%forces(:, atom_c), &
2461 do_symmetric=do_symmetric, &
2462 on_diagonal=iatom .EQ. jatom, &
2463hdabc=hdabc, &
2464
2465
2466 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2467 END IF
2468 IF (PRESENT(force_a) .AND. &
2469 .NOT.PRESENT(force_b) .AND. &
2470 PRESENT(force_c) .AND. &
2471 .NOT.PRESENT(pabc) .AND. &
2472 PRESENT(mat_dabc) .AND. &
2473 .NOT.PRESENT(mat_adbc) .AND. &
2474 PRESENT(mat_abdc)) THEN
2475 CALL integrate_set_3c( &
2476 param%par, potential_parameter, &
2477 la_min(iset), la_max(iset), &
2478 lb_min(jset), lb_max(jset), &
2479 lc_min(kset), lc_max(kset), &
2480 npgfa(iset), npgfb(jset), npgfc(kset), &
2481 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2482 ra, rb, rc, &
2483 habc, &
2484 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2485 offset_a_start, offset_b_start, offset_c_start, &
2486 0, 0, first_set - 1, &
2487 sphi_a, sphi_b, sphi_c, &
2488 sgfa, sgfb, sgfc, &
2489 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2490 my_eri_method, &
2491
2492force_a=force_a(ikind)%forces(:, atom_a), &
2493
2494force_c=force_c(kkind)%forces(:, atom_c), &
2495 do_symmetric=do_symmetric, &
2496 on_diagonal=iatom .EQ. jatom, &
2497hdabc=hdabc, &
2498
2499habdc=habdc, &
2500 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2501 END IF
2502 IF (PRESENT(force_a) .AND. &
2503 .NOT.PRESENT(force_b) .AND. &
2504 PRESENT(force_c) .AND. &
2505 .NOT.PRESENT(pabc) .AND. &
2506 PRESENT(mat_dabc) .AND. &
2507 PRESENT(mat_adbc) .AND. &
2508 .NOT.PRESENT(mat_abdc)) THEN
2509 CALL integrate_set_3c( &
2510 param%par, potential_parameter, &
2511 la_min(iset), la_max(iset), &
2512 lb_min(jset), lb_max(jset), &
2513 lc_min(kset), lc_max(kset), &
2514 npgfa(iset), npgfb(jset), npgfc(kset), &
2515 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2516 ra, rb, rc, &
2517 habc, &
2518 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2519 offset_a_start, offset_b_start, offset_c_start, &
2520 0, 0, first_set - 1, &
2521 sphi_a, sphi_b, sphi_c, &
2522 sgfa, sgfb, sgfc, &
2523 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2524 my_eri_method, &
2525
2526force_a=force_a(ikind)%forces(:, atom_a), &
2527
2528force_c=force_c(kkind)%forces(:, atom_c), &
2529 do_symmetric=do_symmetric, &
2530 on_diagonal=iatom .EQ. jatom, &
2531hdabc=hdabc, &
2532hadbc=hadbc, &
2533
2534 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2535 END IF
2536 IF (PRESENT(force_a) .AND. &
2537 .NOT.PRESENT(force_b) .AND. &
2538 PRESENT(force_c) .AND. &
2539 .NOT.PRESENT(pabc) .AND. &
2540 PRESENT(mat_dabc) .AND. &
2541 PRESENT(mat_adbc) .AND. &
2542 PRESENT(mat_abdc)) THEN
2543 CALL integrate_set_3c( &
2544 param%par, potential_parameter, &
2545 la_min(iset), la_max(iset), &
2546 lb_min(jset), lb_max(jset), &
2547 lc_min(kset), lc_max(kset), &
2548 npgfa(iset), npgfb(jset), npgfc(kset), &
2549 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2550 ra, rb, rc, &
2551 habc, &
2552 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2553 offset_a_start, offset_b_start, offset_c_start, &
2554 0, 0, first_set - 1, &
2555 sphi_a, sphi_b, sphi_c, &
2556 sgfa, sgfb, sgfc, &
2557 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2558 my_eri_method, &
2559
2560force_a=force_a(ikind)%forces(:, atom_a), &
2561
2562force_c=force_c(kkind)%forces(:, atom_c), &
2563 do_symmetric=do_symmetric, &
2564 on_diagonal=iatom .EQ. jatom, &
2565hdabc=hdabc, &
2566hadbc=hadbc, &
2567habdc=habdc, &
2568 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2569 END IF
2570 IF (PRESENT(force_a) .AND. &
2571 PRESENT(force_b) .AND. &
2572 .NOT.PRESENT(force_c) .AND. &
2573 .NOT.PRESENT(pabc) .AND. &
2574 .NOT.PRESENT(mat_dabc) .AND. &
2575 .NOT.PRESENT(mat_adbc) .AND. &
2576 .NOT.PRESENT(mat_abdc)) THEN
2577 CALL integrate_set_3c( &
2578 param%par, potential_parameter, &
2579 la_min(iset), la_max(iset), &
2580 lb_min(jset), lb_max(jset), &
2581 lc_min(kset), lc_max(kset), &
2582 npgfa(iset), npgfb(jset), npgfc(kset), &
2583 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2584 ra, rb, rc, &
2585 habc, &
2586 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2587 offset_a_start, offset_b_start, offset_c_start, &
2588 0, 0, first_set - 1, &
2589 sphi_a, sphi_b, sphi_c, &
2590 sgfa, sgfb, sgfc, &
2591 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2592 my_eri_method, &
2593
2594force_a=force_a(ikind)%forces(:, atom_a), &
2595force_b=force_b(jkind)%forces(:, atom_b), &
2596
2597 do_symmetric=do_symmetric, &
2598 on_diagonal=iatom .EQ. jatom, &
2599
2600
2601
2602 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2603 END IF
2604 IF (PRESENT(force_a) .AND. &
2605 PRESENT(force_b) .AND. &
2606 .NOT.PRESENT(force_c) .AND. &
2607 .NOT.PRESENT(pabc) .AND. &
2608 .NOT.PRESENT(mat_dabc) .AND. &
2609 .NOT.PRESENT(mat_adbc) .AND. &
2610 PRESENT(mat_abdc)) THEN
2611 CALL integrate_set_3c( &
2612 param%par, potential_parameter, &
2613 la_min(iset), la_max(iset), &
2614 lb_min(jset), lb_max(jset), &
2615 lc_min(kset), lc_max(kset), &
2616 npgfa(iset), npgfb(jset), npgfc(kset), &
2617 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2618 ra, rb, rc, &
2619 habc, &
2620 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2621 offset_a_start, offset_b_start, offset_c_start, &
2622 0, 0, first_set - 1, &
2623 sphi_a, sphi_b, sphi_c, &
2624 sgfa, sgfb, sgfc, &
2625 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2626 my_eri_method, &
2627
2628force_a=force_a(ikind)%forces(:, atom_a), &
2629force_b=force_b(jkind)%forces(:, atom_b), &
2630
2631 do_symmetric=do_symmetric, &
2632 on_diagonal=iatom .EQ. jatom, &
2633
2634
2635habdc=habdc, &
2636 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2637 END IF
2638 IF (PRESENT(force_a) .AND. &
2639 PRESENT(force_b) .AND. &
2640 .NOT.PRESENT(force_c) .AND. &
2641 .NOT.PRESENT(pabc) .AND. &
2642 .NOT.PRESENT(mat_dabc) .AND. &
2643 PRESENT(mat_adbc) .AND. &
2644 .NOT.PRESENT(mat_abdc)) THEN
2645 CALL integrate_set_3c( &
2646 param%par, potential_parameter, &
2647 la_min(iset), la_max(iset), &
2648 lb_min(jset), lb_max(jset), &
2649 lc_min(kset), lc_max(kset), &
2650 npgfa(iset), npgfb(jset), npgfc(kset), &
2651 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2652 ra, rb, rc, &
2653 habc, &
2654 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2655 offset_a_start, offset_b_start, offset_c_start, &
2656 0, 0, first_set - 1, &
2657 sphi_a, sphi_b, sphi_c, &
2658 sgfa, sgfb, sgfc, &
2659 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2660 my_eri_method, &
2661
2662force_a=force_a(ikind)%forces(:, atom_a), &
2663force_b=force_b(jkind)%forces(:, atom_b), &
2664
2665 do_symmetric=do_symmetric, &
2666 on_diagonal=iatom .EQ. jatom, &
2667
2668hadbc=hadbc, &
2669
2670 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2671 END IF
2672 IF (PRESENT(force_a) .AND. &
2673 PRESENT(force_b) .AND. &
2674 .NOT.PRESENT(force_c) .AND. &
2675 .NOT.PRESENT(pabc) .AND. &
2676 .NOT.PRESENT(mat_dabc) .AND. &
2677 PRESENT(mat_adbc) .AND. &
2678 PRESENT(mat_abdc)) THEN
2679 CALL integrate_set_3c( &
2680 param%par, potential_parameter, &
2681 la_min(iset), la_max(iset), &
2682 lb_min(jset), lb_max(jset), &
2683 lc_min(kset), lc_max(kset), &
2684 npgfa(iset), npgfb(jset), npgfc(kset), &
2685 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2686 ra, rb, rc, &
2687 habc, &
2688 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2689 offset_a_start, offset_b_start, offset_c_start, &
2690 0, 0, first_set - 1, &
2691 sphi_a, sphi_b, sphi_c, &
2692 sgfa, sgfb, sgfc, &
2693 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2694 my_eri_method, &
2695
2696force_a=force_a(ikind)%forces(:, atom_a), &
2697force_b=force_b(jkind)%forces(:, atom_b), &
2698
2699 do_symmetric=do_symmetric, &
2700 on_diagonal=iatom .EQ. jatom, &
2701
2702hadbc=hadbc, &
2703habdc=habdc, &
2704 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2705 END IF
2706 IF (PRESENT(force_a) .AND. &
2707 PRESENT(force_b) .AND. &
2708 .NOT.PRESENT(force_c) .AND. &
2709 .NOT.PRESENT(pabc) .AND. &
2710 PRESENT(mat_dabc) .AND. &
2711 .NOT.PRESENT(mat_adbc) .AND. &
2712 .NOT.PRESENT(mat_abdc)) THEN
2713 CALL integrate_set_3c( &
2714 param%par, potential_parameter, &
2715 la_min(iset), la_max(iset), &
2716 lb_min(jset), lb_max(jset), &
2717 lc_min(kset), lc_max(kset), &
2718 npgfa(iset), npgfb(jset), npgfc(kset), &
2719 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2720 ra, rb, rc, &
2721 habc, &
2722 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2723 offset_a_start, offset_b_start, offset_c_start, &
2724 0, 0, first_set - 1, &
2725 sphi_a, sphi_b, sphi_c, &
2726 sgfa, sgfb, sgfc, &
2727 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2728 my_eri_method, &
2729
2730force_a=force_a(ikind)%forces(:, atom_a), &
2731force_b=force_b(jkind)%forces(:, atom_b), &
2732
2733 do_symmetric=do_symmetric, &
2734 on_diagonal=iatom .EQ. jatom, &
2735hdabc=hdabc, &
2736
2737
2738 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2739 END IF
2740 IF (PRESENT(force_a) .AND. &
2741 PRESENT(force_b) .AND. &
2742 .NOT.PRESENT(force_c) .AND. &
2743 .NOT.PRESENT(pabc) .AND. &
2744 PRESENT(mat_dabc) .AND. &
2745 .NOT.PRESENT(mat_adbc) .AND. &
2746 PRESENT(mat_abdc)) THEN
2747 CALL integrate_set_3c( &
2748 param%par, potential_parameter, &
2749 la_min(iset), la_max(iset), &
2750 lb_min(jset), lb_max(jset), &
2751 lc_min(kset), lc_max(kset), &
2752 npgfa(iset), npgfb(jset), npgfc(kset), &
2753 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2754 ra, rb, rc, &
2755 habc, &
2756 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2757 offset_a_start, offset_b_start, offset_c_start, &
2758 0, 0, first_set - 1, &
2759 sphi_a, sphi_b, sphi_c, &
2760 sgfa, sgfb, sgfc, &
2761 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2762 my_eri_method, &
2763
2764force_a=force_a(ikind)%forces(:, atom_a), &
2765force_b=force_b(jkind)%forces(:, atom_b), &
2766
2767 do_symmetric=do_symmetric, &
2768 on_diagonal=iatom .EQ. jatom, &
2769hdabc=hdabc, &
2770
2771habdc=habdc, &
2772 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2773 END IF
2774 IF (PRESENT(force_a) .AND. &
2775 PRESENT(force_b) .AND. &
2776 .NOT.PRESENT(force_c) .AND. &
2777 .NOT.PRESENT(pabc) .AND. &
2778 PRESENT(mat_dabc) .AND. &
2779 PRESENT(mat_adbc) .AND. &
2780 .NOT.PRESENT(mat_abdc)) THEN
2781 CALL integrate_set_3c( &
2782 param%par, potential_parameter, &
2783 la_min(iset), la_max(iset), &
2784 lb_min(jset), lb_max(jset), &
2785 lc_min(kset), lc_max(kset), &
2786 npgfa(iset), npgfb(jset), npgfc(kset), &
2787 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2788 ra, rb, rc, &
2789 habc, &
2790 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2791 offset_a_start, offset_b_start, offset_c_start, &
2792 0, 0, first_set - 1, &
2793 sphi_a, sphi_b, sphi_c, &
2794 sgfa, sgfb, sgfc, &
2795 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2796 my_eri_method, &
2797
2798force_a=force_a(ikind)%forces(:, atom_a), &
2799force_b=force_b(jkind)%forces(:, atom_b), &
2800
2801 do_symmetric=do_symmetric, &
2802 on_diagonal=iatom .EQ. jatom, &
2803hdabc=hdabc, &
2804hadbc=hadbc, &
2805
2806 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2807 END IF
2808 IF (PRESENT(force_a) .AND. &
2809 PRESENT(force_b) .AND. &
2810 .NOT.PRESENT(force_c) .AND. &
2811 .NOT.PRESENT(pabc) .AND. &
2812 PRESENT(mat_dabc) .AND. &
2813 PRESENT(mat_adbc) .AND. &
2814 PRESENT(mat_abdc)) THEN
2815 CALL integrate_set_3c( &
2816 param%par, potential_parameter, &
2817 la_min(iset), la_max(iset), &
2818 lb_min(jset), lb_max(jset), &
2819 lc_min(kset), lc_max(kset), &
2820 npgfa(iset), npgfb(jset), npgfc(kset), &
2821 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2822 ra, rb, rc, &
2823 habc, &
2824 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2825 offset_a_start, offset_b_start, offset_c_start, &
2826 0, 0, first_set - 1, &
2827 sphi_a, sphi_b, sphi_c, &
2828 sgfa, sgfb, sgfc, &
2829 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2830 my_eri_method, &
2831
2832force_a=force_a(ikind)%forces(:, atom_a), &
2833force_b=force_b(jkind)%forces(:, atom_b), &
2834
2835 do_symmetric=do_symmetric, &
2836 on_diagonal=iatom .EQ. jatom, &
2837hdabc=hdabc, &
2838hadbc=hadbc, &
2839habdc=habdc, &
2840 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2841 END IF
2842 IF (PRESENT(force_a) .AND. &
2843 PRESENT(force_b) .AND. &
2844 PRESENT(force_c) .AND. &
2845 .NOT.PRESENT(pabc) .AND. &
2846 .NOT.PRESENT(mat_dabc) .AND. &
2847 .NOT.PRESENT(mat_adbc) .AND. &
2848 .NOT.PRESENT(mat_abdc)) THEN
2849 CALL integrate_set_3c( &
2850 param%par, potential_parameter, &
2851 la_min(iset), la_max(iset), &
2852 lb_min(jset), lb_max(jset), &
2853 lc_min(kset), lc_max(kset), &
2854 npgfa(iset), npgfb(jset), npgfc(kset), &
2855 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2856 ra, rb, rc, &
2857 habc, &
2858 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2859 offset_a_start, offset_b_start, offset_c_start, &
2860 0, 0, first_set - 1, &
2861 sphi_a, sphi_b, sphi_c, &
2862 sgfa, sgfb, sgfc, &
2863 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2864 my_eri_method, &
2865
2866force_a=force_a(ikind)%forces(:, atom_a), &
2867force_b=force_b(jkind)%forces(:, atom_b), &
2868force_c=force_c(kkind)%forces(:, atom_c), &
2869 do_symmetric=do_symmetric, &
2870 on_diagonal=iatom .EQ. jatom, &
2871
2872
2873
2874 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2875 END IF
2876 IF (PRESENT(force_a) .AND. &
2877 PRESENT(force_b) .AND. &
2878 PRESENT(force_c) .AND. &
2879 .NOT.PRESENT(pabc) .AND. &
2880 .NOT.PRESENT(mat_dabc) .AND. &
2881 .NOT.PRESENT(mat_adbc) .AND. &
2882 PRESENT(mat_abdc)) THEN
2883 CALL integrate_set_3c( &
2884 param%par, potential_parameter, &
2885 la_min(iset), la_max(iset), &
2886 lb_min(jset), lb_max(jset), &
2887 lc_min(kset), lc_max(kset), &
2888 npgfa(iset), npgfb(jset), npgfc(kset), &
2889 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2890 ra, rb, rc, &
2891 habc, &
2892 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2893 offset_a_start, offset_b_start, offset_c_start, &
2894 0, 0, first_set - 1, &
2895 sphi_a, sphi_b, sphi_c, &
2896 sgfa, sgfb, sgfc, &
2897 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2898 my_eri_method, &
2899
2900force_a=force_a(ikind)%forces(:, atom_a), &
2901force_b=force_b(jkind)%forces(:, atom_b), &
2902force_c=force_c(kkind)%forces(:, atom_c), &
2903 do_symmetric=do_symmetric, &
2904 on_diagonal=iatom .EQ. jatom, &
2905
2906
2907habdc=habdc, &
2908 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2909 END IF
2910 IF (PRESENT(force_a) .AND. &
2911 PRESENT(force_b) .AND. &
2912 PRESENT(force_c) .AND. &
2913 .NOT.PRESENT(pabc) .AND. &
2914 .NOT.PRESENT(mat_dabc) .AND. &
2915 PRESENT(mat_adbc) .AND. &
2916 .NOT.PRESENT(mat_abdc)) THEN
2917 CALL integrate_set_3c( &
2918 param%par, potential_parameter, &
2919 la_min(iset), la_max(iset), &
2920 lb_min(jset), lb_max(jset), &
2921 lc_min(kset), lc_max(kset), &
2922 npgfa(iset), npgfb(jset), npgfc(kset), &
2923 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2924 ra, rb, rc, &
2925 habc, &
2926 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2927 offset_a_start, offset_b_start, offset_c_start, &
2928 0, 0, first_set - 1, &
2929 sphi_a, sphi_b, sphi_c, &
2930 sgfa, sgfb, sgfc, &
2931 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2932 my_eri_method, &
2933
2934force_a=force_a(ikind)%forces(:, atom_a), &
2935force_b=force_b(jkind)%forces(:, atom_b), &
2936force_c=force_c(kkind)%forces(:, atom_c), &
2937 do_symmetric=do_symmetric, &
2938 on_diagonal=iatom .EQ. jatom, &
2939
2940hadbc=hadbc, &
2941
2942 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2943 END IF
2944 IF (PRESENT(force_a) .AND. &
2945 PRESENT(force_b) .AND. &
2946 PRESENT(force_c) .AND. &
2947 .NOT.PRESENT(pabc) .AND. &
2948 .NOT.PRESENT(mat_dabc) .AND. &
2949 PRESENT(mat_adbc) .AND. &
2950 PRESENT(mat_abdc)) THEN
2951 CALL integrate_set_3c( &
2952 param%par, potential_parameter, &
2953 la_min(iset), la_max(iset), &
2954 lb_min(jset), lb_max(jset), &
2955 lc_min(kset), lc_max(kset), &
2956 npgfa(iset), npgfb(jset), npgfc(kset), &
2957 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2958 ra, rb, rc, &
2959 habc, &
2960 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2961 offset_a_start, offset_b_start, offset_c_start, &
2962 0, 0, first_set - 1, &
2963 sphi_a, sphi_b, sphi_c, &
2964 sgfa, sgfb, sgfc, &
2965 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2966 my_eri_method, &
2967
2968force_a=force_a(ikind)%forces(:, atom_a), &
2969force_b=force_b(jkind)%forces(:, atom_b), &
2970force_c=force_c(kkind)%forces(:, atom_c), &
2971 do_symmetric=do_symmetric, &
2972 on_diagonal=iatom .EQ. jatom, &
2973
2974hadbc=hadbc, &
2975habdc=habdc, &
2976 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2977 END IF
2978 IF (PRESENT(force_a) .AND. &
2979 PRESENT(force_b) .AND. &
2980 PRESENT(force_c) .AND. &
2981 .NOT.PRESENT(pabc) .AND. &
2982 PRESENT(mat_dabc) .AND. &
2983 .NOT.PRESENT(mat_adbc) .AND. &
2984 .NOT.PRESENT(mat_abdc)) THEN
2985 CALL integrate_set_3c( &
2986 param%par, potential_parameter, &
2987 la_min(iset), la_max(iset), &
2988 lb_min(jset), lb_max(jset), &
2989 lc_min(kset), lc_max(kset), &
2990 npgfa(iset), npgfb(jset), npgfc(kset), &
2991 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2992 ra, rb, rc, &
2993 habc, &
2994 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2995 offset_a_start, offset_b_start, offset_c_start, &
2996 0, 0, first_set - 1, &
2997 sphi_a, sphi_b, sphi_c, &
2998 sgfa, sgfb, sgfc, &
2999 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3000 my_eri_method, &
3001
3002force_a=force_a(ikind)%forces(:, atom_a), &
3003force_b=force_b(jkind)%forces(:, atom_b), &
3004force_c=force_c(kkind)%forces(:, atom_c), &
3005 do_symmetric=do_symmetric, &
3006 on_diagonal=iatom .EQ. jatom, &
3007hdabc=hdabc, &
3008
3009
3010 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3011 END IF
3012 IF (PRESENT(force_a) .AND. &
3013 PRESENT(force_b) .AND. &
3014 PRESENT(force_c) .AND. &
3015 .NOT.PRESENT(pabc) .AND. &
3016 PRESENT(mat_dabc) .AND. &
3017 .NOT.PRESENT(mat_adbc) .AND. &
3018 PRESENT(mat_abdc)) THEN
3019 CALL integrate_set_3c( &
3020 param%par, potential_parameter, &
3021 la_min(iset), la_max(iset), &
3022 lb_min(jset), lb_max(jset), &
3023 lc_min(kset), lc_max(kset), &
3024 npgfa(iset), npgfb(jset), npgfc(kset), &
3025 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3026 ra, rb, rc, &
3027 habc, &
3028 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3029 offset_a_start, offset_b_start, offset_c_start, &
3030 0, 0, first_set - 1, &
3031 sphi_a, sphi_b, sphi_c, &
3032 sgfa, sgfb, sgfc, &
3033 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3034 my_eri_method, &
3035
3036force_a=force_a(ikind)%forces(:, atom_a), &
3037force_b=force_b(jkind)%forces(:, atom_b), &
3038force_c=force_c(kkind)%forces(:, atom_c), &
3039 do_symmetric=do_symmetric, &
3040 on_diagonal=iatom .EQ. jatom, &
3041hdabc=hdabc, &
3042
3043habdc=habdc, &
3044 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3045 END IF
3046 IF (PRESENT(force_a) .AND. &
3047 PRESENT(force_b) .AND. &
3048 PRESENT(force_c) .AND. &
3049 .NOT.PRESENT(pabc) .AND. &
3050 PRESENT(mat_dabc) .AND. &
3051 PRESENT(mat_adbc) .AND. &
3052 .NOT.PRESENT(mat_abdc)) THEN
3053 CALL integrate_set_3c( &
3054 param%par, potential_parameter, &
3055 la_min(iset), la_max(iset), &
3056 lb_min(jset), lb_max(jset), &
3057 lc_min(kset), lc_max(kset), &
3058 npgfa(iset), npgfb(jset), npgfc(kset), &
3059 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3060 ra, rb, rc, &
3061 habc, &
3062 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3063 offset_a_start, offset_b_start, offset_c_start, &
3064 0, 0, first_set - 1, &
3065 sphi_a, sphi_b, sphi_c, &
3066 sgfa, sgfb, sgfc, &
3067 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3068 my_eri_method, &
3069
3070force_a=force_a(ikind)%forces(:, atom_a), &
3071force_b=force_b(jkind)%forces(:, atom_b), &
3072force_c=force_c(kkind)%forces(:, atom_c), &
3073 do_symmetric=do_symmetric, &
3074 on_diagonal=iatom .EQ. jatom, &
3075hdabc=hdabc, &
3076hadbc=hadbc, &
3077
3078 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3079 END IF
3080 IF (PRESENT(force_a) .AND. &
3081 PRESENT(force_b) .AND. &
3082 PRESENT(force_c) .AND. &
3083 .NOT.PRESENT(pabc) .AND. &
3084 PRESENT(mat_dabc) .AND. &
3085 PRESENT(mat_adbc) .AND. &
3086 PRESENT(mat_abdc)) THEN
3087 CALL integrate_set_3c( &
3088 param%par, potential_parameter, &
3089 la_min(iset), la_max(iset), &
3090 lb_min(jset), lb_max(jset), &
3091 lc_min(kset), lc_max(kset), &
3092 npgfa(iset), npgfb(jset), npgfc(kset), &
3093 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3094 ra, rb, rc, &
3095 habc, &
3096 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3097 offset_a_start, offset_b_start, offset_c_start, &
3098 0, 0, first_set - 1, &
3099 sphi_a, sphi_b, sphi_c, &
3100 sgfa, sgfb, sgfc, &
3101 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3102 my_eri_method, &
3103
3104force_a=force_a(ikind)%forces(:, atom_a), &
3105force_b=force_b(jkind)%forces(:, atom_b), &
3106force_c=force_c(kkind)%forces(:, atom_c), &
3107 do_symmetric=do_symmetric, &
3108 on_diagonal=iatom .EQ. jatom, &
3109hdabc=hdabc, &
3110hadbc=hadbc, &
3111habdc=habdc, &
3112 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3113 END IF
3114 IF (.NOT.PRESENT(force_a) .AND. &
3115 .NOT.PRESENT(force_b) .AND. &
3116 .NOT.PRESENT(force_c) .AND. &
3117 PRESENT(pabc) .AND. &
3118 .NOT.PRESENT(mat_dabc) .AND. &
3119 .NOT.PRESENT(mat_adbc) .AND. &
3120 .NOT.PRESENT(mat_abdc)) THEN
3121 CALL integrate_set_3c( &
3122 param%par, potential_parameter, &
3123 la_min(iset), la_max(iset), &
3124 lb_min(jset), lb_max(jset), &
3125 lc_min(kset), lc_max(kset), &
3126 npgfa(iset), npgfb(jset), npgfc(kset), &
3127 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3128 ra, rb, rc, &
3129 habc, &
3130 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3131 offset_a_start, offset_b_start, offset_c_start, &
3132 0, 0, first_set - 1, &
3133 sphi_a, sphi_b, sphi_c, &
3134 sgfa, sgfb, sgfc, &
3135 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3136 my_eri_method, &
3137pabc=pabc_block, &
3138
3139
3140
3141 do_symmetric=do_symmetric, &
3142 on_diagonal=iatom .EQ. jatom, &
3143
3144
3145
3146 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3147 END IF
3148 IF (.NOT.PRESENT(force_a) .AND. &
3149 .NOT.PRESENT(force_b) .AND. &
3150 .NOT.PRESENT(force_c) .AND. &
3151 PRESENT(pabc) .AND. &
3152 .NOT.PRESENT(mat_dabc) .AND. &
3153 .NOT.PRESENT(mat_adbc) .AND. &
3154 PRESENT(mat_abdc)) THEN
3155 CALL integrate_set_3c( &
3156 param%par, potential_parameter, &
3157 la_min(iset), la_max(iset), &
3158 lb_min(jset), lb_max(jset), &
3159 lc_min(kset), lc_max(kset), &
3160 npgfa(iset), npgfb(jset), npgfc(kset), &
3161 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3162 ra, rb, rc, &
3163 habc, &
3164 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3165 offset_a_start, offset_b_start, offset_c_start, &
3166 0, 0, first_set - 1, &
3167 sphi_a, sphi_b, sphi_c, &
3168 sgfa, sgfb, sgfc, &
3169 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3170 my_eri_method, &
3171pabc=pabc_block, &
3172
3173
3174
3175 do_symmetric=do_symmetric, &
3176 on_diagonal=iatom .EQ. jatom, &
3177
3178
3179habdc=habdc, &
3180 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3181 END IF
3182 IF (.NOT.PRESENT(force_a) .AND. &
3183 .NOT.PRESENT(force_b) .AND. &
3184 .NOT.PRESENT(force_c) .AND. &
3185 PRESENT(pabc) .AND. &
3186 .NOT.PRESENT(mat_dabc) .AND. &
3187 PRESENT(mat_adbc) .AND. &
3188 .NOT.PRESENT(mat_abdc)) THEN
3189 CALL integrate_set_3c( &
3190 param%par, potential_parameter, &
3191 la_min(iset), la_max(iset), &
3192 lb_min(jset), lb_max(jset), &
3193 lc_min(kset), lc_max(kset), &
3194 npgfa(iset), npgfb(jset), npgfc(kset), &
3195 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3196 ra, rb, rc, &
3197 habc, &
3198 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3199 offset_a_start, offset_b_start, offset_c_start, &
3200 0, 0, first_set - 1, &
3201 sphi_a, sphi_b, sphi_c, &
3202 sgfa, sgfb, sgfc, &
3203 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3204 my_eri_method, &
3205pabc=pabc_block, &
3206
3207
3208
3209 do_symmetric=do_symmetric, &
3210 on_diagonal=iatom .EQ. jatom, &
3211
3212hadbc=hadbc, &
3213
3214 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3215 END IF
3216 IF (.NOT.PRESENT(force_a) .AND. &
3217 .NOT.PRESENT(force_b) .AND. &
3218 .NOT.PRESENT(force_c) .AND. &
3219 PRESENT(pabc) .AND. &
3220 .NOT.PRESENT(mat_dabc) .AND. &
3221 PRESENT(mat_adbc) .AND. &
3222 PRESENT(mat_abdc)) THEN
3223 CALL integrate_set_3c( &
3224 param%par, potential_parameter, &
3225 la_min(iset), la_max(iset), &
3226 lb_min(jset), lb_max(jset), &
3227 lc_min(kset), lc_max(kset), &
3228 npgfa(iset), npgfb(jset), npgfc(kset), &
3229 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3230 ra, rb, rc, &
3231 habc, &
3232 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3233 offset_a_start, offset_b_start, offset_c_start, &
3234 0, 0, first_set - 1, &
3235 sphi_a, sphi_b, sphi_c, &
3236 sgfa, sgfb, sgfc, &
3237 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3238 my_eri_method, &
3239pabc=pabc_block, &
3240
3241
3242
3243 do_symmetric=do_symmetric, &
3244 on_diagonal=iatom .EQ. jatom, &
3245
3246hadbc=hadbc, &
3247habdc=habdc, &
3248 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3249 END IF
3250 IF (.NOT.PRESENT(force_a) .AND. &
3251 .NOT.PRESENT(force_b) .AND. &
3252 .NOT.PRESENT(force_c) .AND. &
3253 PRESENT(pabc) .AND. &
3254 PRESENT(mat_dabc) .AND. &
3255 .NOT.PRESENT(mat_adbc) .AND. &
3256 .NOT.PRESENT(mat_abdc)) THEN
3257 CALL integrate_set_3c( &
3258 param%par, potential_parameter, &
3259 la_min(iset), la_max(iset), &
3260 lb_min(jset), lb_max(jset), &
3261 lc_min(kset), lc_max(kset), &
3262 npgfa(iset), npgfb(jset), npgfc(kset), &
3263 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3264 ra, rb, rc, &
3265 habc, &
3266 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3267 offset_a_start, offset_b_start, offset_c_start, &
3268 0, 0, first_set - 1, &
3269 sphi_a, sphi_b, sphi_c, &
3270 sgfa, sgfb, sgfc, &
3271 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3272 my_eri_method, &
3273pabc=pabc_block, &
3274
3275
3276
3277 do_symmetric=do_symmetric, &
3278 on_diagonal=iatom .EQ. jatom, &
3279hdabc=hdabc, &
3280
3281
3282 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3283 END IF
3284 IF (.NOT.PRESENT(force_a) .AND. &
3285 .NOT.PRESENT(force_b) .AND. &
3286 .NOT.PRESENT(force_c) .AND. &
3287 PRESENT(pabc) .AND. &
3288 PRESENT(mat_dabc) .AND. &
3289 .NOT.PRESENT(mat_adbc) .AND. &
3290 PRESENT(mat_abdc)) THEN
3291 CALL integrate_set_3c( &
3292 param%par, potential_parameter, &
3293 la_min(iset), la_max(iset), &
3294 lb_min(jset), lb_max(jset), &
3295 lc_min(kset), lc_max(kset), &
3296 npgfa(iset), npgfb(jset), npgfc(kset), &
3297 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3298 ra, rb, rc, &
3299 habc, &
3300 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3301 offset_a_start, offset_b_start, offset_c_start, &
3302 0, 0, first_set - 1, &
3303 sphi_a, sphi_b, sphi_c, &
3304 sgfa, sgfb, sgfc, &
3305 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3306 my_eri_method, &
3307pabc=pabc_block, &
3308
3309
3310
3311 do_symmetric=do_symmetric, &
3312 on_diagonal=iatom .EQ. jatom, &
3313hdabc=hdabc, &
3314
3315habdc=habdc, &
3316 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3317 END IF
3318 IF (.NOT.PRESENT(force_a) .AND. &
3319 .NOT.PRESENT(force_b) .AND. &
3320 .NOT.PRESENT(force_c) .AND. &
3321 PRESENT(pabc) .AND. &
3322 PRESENT(mat_dabc) .AND. &
3323 PRESENT(mat_adbc) .AND. &
3324 .NOT.PRESENT(mat_abdc)) THEN
3325 CALL integrate_set_3c( &
3326 param%par, potential_parameter, &
3327 la_min(iset), la_max(iset), &
3328 lb_min(jset), lb_max(jset), &
3329 lc_min(kset), lc_max(kset), &
3330 npgfa(iset), npgfb(jset), npgfc(kset), &
3331 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3332 ra, rb, rc, &
3333 habc, &
3334 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3335 offset_a_start, offset_b_start, offset_c_start, &
3336 0, 0, first_set - 1, &
3337 sphi_a, sphi_b, sphi_c, &
3338 sgfa, sgfb, sgfc, &
3339 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3340 my_eri_method, &
3341pabc=pabc_block, &
3342
3343
3344
3345 do_symmetric=do_symmetric, &
3346 on_diagonal=iatom .EQ. jatom, &
3347hdabc=hdabc, &
3348hadbc=hadbc, &
3349
3350 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3351 END IF
3352 IF (.NOT.PRESENT(force_a) .AND. &
3353 .NOT.PRESENT(force_b) .AND. &
3354 .NOT.PRESENT(force_c) .AND. &
3355 PRESENT(pabc) .AND. &
3356 PRESENT(mat_dabc) .AND. &
3357 PRESENT(mat_adbc) .AND. &
3358 PRESENT(mat_abdc)) THEN
3359 CALL integrate_set_3c( &
3360 param%par, potential_parameter, &
3361 la_min(iset), la_max(iset), &
3362 lb_min(jset), lb_max(jset), &
3363 lc_min(kset), lc_max(kset), &
3364 npgfa(iset), npgfb(jset), npgfc(kset), &
3365 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3366 ra, rb, rc, &
3367 habc, &
3368 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3369 offset_a_start, offset_b_start, offset_c_start, &
3370 0, 0, first_set - 1, &
3371 sphi_a, sphi_b, sphi_c, &
3372 sgfa, sgfb, sgfc, &
3373 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3374 my_eri_method, &
3375pabc=pabc_block, &
3376
3377
3378
3379 do_symmetric=do_symmetric, &
3380 on_diagonal=iatom .EQ. jatom, &
3381hdabc=hdabc, &
3382hadbc=hadbc, &
3383habdc=habdc, &
3384 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3385 END IF
3386 IF (.NOT.PRESENT(force_a) .AND. &
3387 .NOT.PRESENT(force_b) .AND. &
3388 PRESENT(force_c) .AND. &
3389 PRESENT(pabc) .AND. &
3390 .NOT.PRESENT(mat_dabc) .AND. &
3391 .NOT.PRESENT(mat_adbc) .AND. &
3392 .NOT.PRESENT(mat_abdc)) THEN
3393 CALL integrate_set_3c( &
3394 param%par, potential_parameter, &
3395 la_min(iset), la_max(iset), &
3396 lb_min(jset), lb_max(jset), &
3397 lc_min(kset), lc_max(kset), &
3398 npgfa(iset), npgfb(jset), npgfc(kset), &
3399 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3400 ra, rb, rc, &
3401 habc, &
3402 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3403 offset_a_start, offset_b_start, offset_c_start, &
3404 0, 0, first_set - 1, &
3405 sphi_a, sphi_b, sphi_c, &
3406 sgfa, sgfb, sgfc, &
3407 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3408 my_eri_method, &
3409pabc=pabc_block, &
3410
3411
3412force_c=force_c(kkind)%forces(:, atom_c), &
3413 do_symmetric=do_symmetric, &
3414 on_diagonal=iatom .EQ. jatom, &
3415
3416
3417
3418 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3419 END IF
3420 IF (.NOT.PRESENT(force_a) .AND. &
3421 .NOT.PRESENT(force_b) .AND. &
3422 PRESENT(force_c) .AND. &
3423 PRESENT(pabc) .AND. &
3424 .NOT.PRESENT(mat_dabc) .AND. &
3425 .NOT.PRESENT(mat_adbc) .AND. &
3426 PRESENT(mat_abdc)) THEN
3427 CALL integrate_set_3c( &
3428 param%par, potential_parameter, &
3429 la_min(iset), la_max(iset), &
3430 lb_min(jset), lb_max(jset), &
3431 lc_min(kset), lc_max(kset), &
3432 npgfa(iset), npgfb(jset), npgfc(kset), &
3433 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3434 ra, rb, rc, &
3435 habc, &
3436 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3437 offset_a_start, offset_b_start, offset_c_start, &
3438 0, 0, first_set - 1, &
3439 sphi_a, sphi_b, sphi_c, &
3440 sgfa, sgfb, sgfc, &
3441 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3442 my_eri_method, &
3443pabc=pabc_block, &
3444
3445
3446force_c=force_c(kkind)%forces(:, atom_c), &
3447 do_symmetric=do_symmetric, &
3448 on_diagonal=iatom .EQ. jatom, &
3449
3450
3451habdc=habdc, &
3452 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3453 END IF
3454 IF (.NOT.PRESENT(force_a) .AND. &
3455 .NOT.PRESENT(force_b) .AND. &
3456 PRESENT(force_c) .AND. &
3457 PRESENT(pabc) .AND. &
3458 .NOT.PRESENT(mat_dabc) .AND. &
3459 PRESENT(mat_adbc) .AND. &
3460 .NOT.PRESENT(mat_abdc)) THEN
3461 CALL integrate_set_3c( &
3462 param%par, potential_parameter, &
3463 la_min(iset), la_max(iset), &
3464 lb_min(jset), lb_max(jset), &
3465 lc_min(kset), lc_max(kset), &
3466 npgfa(iset), npgfb(jset), npgfc(kset), &
3467 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3468 ra, rb, rc, &
3469 habc, &
3470 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3471 offset_a_start, offset_b_start, offset_c_start, &
3472 0, 0, first_set - 1, &
3473 sphi_a, sphi_b, sphi_c, &
3474 sgfa, sgfb, sgfc, &
3475 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3476 my_eri_method, &
3477pabc=pabc_block, &
3478
3479
3480force_c=force_c(kkind)%forces(:, atom_c), &
3481 do_symmetric=do_symmetric, &
3482 on_diagonal=iatom .EQ. jatom, &
3483
3484hadbc=hadbc, &
3485
3486 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3487 END IF
3488 IF (.NOT.PRESENT(force_a) .AND. &
3489 .NOT.PRESENT(force_b) .AND. &
3490 PRESENT(force_c) .AND. &
3491 PRESENT(pabc) .AND. &
3492 .NOT.PRESENT(mat_dabc) .AND. &
3493 PRESENT(mat_adbc) .AND. &
3494 PRESENT(mat_abdc)) THEN
3495 CALL integrate_set_3c( &
3496 param%par, potential_parameter, &
3497 la_min(iset), la_max(iset), &
3498 lb_min(jset), lb_max(jset), &
3499 lc_min(kset), lc_max(kset), &
3500 npgfa(iset), npgfb(jset), npgfc(kset), &
3501 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3502 ra, rb, rc, &
3503 habc, &
3504 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3505 offset_a_start, offset_b_start, offset_c_start, &
3506 0, 0, first_set - 1, &
3507 sphi_a, sphi_b, sphi_c, &
3508 sgfa, sgfb, sgfc, &
3509 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3510 my_eri_method, &
3511pabc=pabc_block, &
3512
3513
3514force_c=force_c(kkind)%forces(:, atom_c), &
3515 do_symmetric=do_symmetric, &
3516 on_diagonal=iatom .EQ. jatom, &
3517
3518hadbc=hadbc, &
3519habdc=habdc, &
3520 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3521 END IF
3522 IF (.NOT.PRESENT(force_a) .AND. &
3523 .NOT.PRESENT(force_b) .AND. &
3524 PRESENT(force_c) .AND. &
3525 PRESENT(pabc) .AND. &
3526 PRESENT(mat_dabc) .AND. &
3527 .NOT.PRESENT(mat_adbc) .AND. &
3528 .NOT.PRESENT(mat_abdc)) THEN
3529 CALL integrate_set_3c( &
3530 param%par, potential_parameter, &
3531 la_min(iset), la_max(iset), &
3532 lb_min(jset), lb_max(jset), &
3533 lc_min(kset), lc_max(kset), &
3534 npgfa(iset), npgfb(jset), npgfc(kset), &
3535 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3536 ra, rb, rc, &
3537 habc, &
3538 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3539 offset_a_start, offset_b_start, offset_c_start, &
3540 0, 0, first_set - 1, &
3541 sphi_a, sphi_b, sphi_c, &
3542 sgfa, sgfb, sgfc, &
3543 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3544 my_eri_method, &
3545pabc=pabc_block, &
3546
3547
3548force_c=force_c(kkind)%forces(:, atom_c), &
3549 do_symmetric=do_symmetric, &
3550 on_diagonal=iatom .EQ. jatom, &
3551hdabc=hdabc, &
3552
3553
3554 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3555 END IF
3556 IF (.NOT.PRESENT(force_a) .AND. &
3557 .NOT.PRESENT(force_b) .AND. &
3558 PRESENT(force_c) .AND. &
3559 PRESENT(pabc) .AND. &
3560 PRESENT(mat_dabc) .AND. &
3561 .NOT.PRESENT(mat_adbc) .AND. &
3562 PRESENT(mat_abdc)) THEN
3563 CALL integrate_set_3c( &
3564 param%par, potential_parameter, &
3565 la_min(iset), la_max(iset), &
3566 lb_min(jset), lb_max(jset), &
3567 lc_min(kset), lc_max(kset), &
3568 npgfa(iset), npgfb(jset), npgfc(kset), &
3569 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3570 ra, rb, rc, &
3571 habc, &
3572 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3573 offset_a_start, offset_b_start, offset_c_start, &
3574 0, 0, first_set - 1, &
3575 sphi_a, sphi_b, sphi_c, &
3576 sgfa, sgfb, sgfc, &
3577 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3578 my_eri_method, &
3579pabc=pabc_block, &
3580
3581
3582force_c=force_c(kkind)%forces(:, atom_c), &
3583 do_symmetric=do_symmetric, &
3584 on_diagonal=iatom .EQ. jatom, &
3585hdabc=hdabc, &
3586
3587habdc=habdc, &
3588 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3589 END IF
3590 IF (.NOT.PRESENT(force_a) .AND. &
3591 .NOT.PRESENT(force_b) .AND. &
3592 PRESENT(force_c) .AND. &
3593 PRESENT(pabc) .AND. &
3594 PRESENT(mat_dabc) .AND. &
3595 PRESENT(mat_adbc) .AND. &
3596 .NOT.PRESENT(mat_abdc)) THEN
3597 CALL integrate_set_3c( &
3598 param%par, potential_parameter, &
3599 la_min(iset), la_max(iset), &
3600 lb_min(jset), lb_max(jset), &
3601 lc_min(kset), lc_max(kset), &
3602 npgfa(iset), npgfb(jset), npgfc(kset), &
3603 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3604 ra, rb, rc, &
3605 habc, &
3606 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3607 offset_a_start, offset_b_start, offset_c_start, &
3608 0, 0, first_set - 1, &
3609 sphi_a, sphi_b, sphi_c, &
3610 sgfa, sgfb, sgfc, &
3611 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3612 my_eri_method, &
3613pabc=pabc_block, &
3614
3615
3616force_c=force_c(kkind)%forces(:, atom_c), &
3617 do_symmetric=do_symmetric, &
3618 on_diagonal=iatom .EQ. jatom, &
3619hdabc=hdabc, &
3620hadbc=hadbc, &
3621
3622 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3623 END IF
3624 IF (.NOT.PRESENT(force_a) .AND. &
3625 .NOT.PRESENT(force_b) .AND. &
3626 PRESENT(force_c) .AND. &
3627 PRESENT(pabc) .AND. &
3628 PRESENT(mat_dabc) .AND. &
3629 PRESENT(mat_adbc) .AND. &
3630 PRESENT(mat_abdc)) THEN
3631 CALL integrate_set_3c( &
3632 param%par, potential_parameter, &
3633 la_min(iset), la_max(iset), &
3634 lb_min(jset), lb_max(jset), &
3635 lc_min(kset), lc_max(kset), &
3636 npgfa(iset), npgfb(jset), npgfc(kset), &
3637 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3638 ra, rb, rc, &
3639 habc, &
3640 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3641 offset_a_start, offset_b_start, offset_c_start, &
3642 0, 0, first_set - 1, &
3643 sphi_a, sphi_b, sphi_c, &
3644 sgfa, sgfb, sgfc, &
3645 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3646 my_eri_method, &
3647pabc=pabc_block, &
3648
3649
3650force_c=force_c(kkind)%forces(:, atom_c), &
3651 do_symmetric=do_symmetric, &
3652 on_diagonal=iatom .EQ. jatom, &
3653hdabc=hdabc, &
3654hadbc=hadbc, &
3655habdc=habdc, &
3656 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3657 END IF
3658 IF (.NOT.PRESENT(force_a) .AND. &
3659 PRESENT(force_b) .AND. &
3660 .NOT.PRESENT(force_c) .AND. &
3661 PRESENT(pabc) .AND. &
3662 .NOT.PRESENT(mat_dabc) .AND. &
3663 .NOT.PRESENT(mat_adbc) .AND. &
3664 .NOT.PRESENT(mat_abdc)) THEN
3665 CALL integrate_set_3c( &
3666 param%par, potential_parameter, &
3667 la_min(iset), la_max(iset), &
3668 lb_min(jset), lb_max(jset), &
3669 lc_min(kset), lc_max(kset), &
3670 npgfa(iset), npgfb(jset), npgfc(kset), &
3671 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3672 ra, rb, rc, &
3673 habc, &
3674 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3675 offset_a_start, offset_b_start, offset_c_start, &
3676 0, 0, first_set - 1, &
3677 sphi_a, sphi_b, sphi_c, &
3678 sgfa, sgfb, sgfc, &
3679 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3680 my_eri_method, &
3681pabc=pabc_block, &
3682
3683force_b=force_b(jkind)%forces(:, atom_b), &
3684
3685 do_symmetric=do_symmetric, &
3686 on_diagonal=iatom .EQ. jatom, &
3687
3688
3689
3690 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3691 END IF
3692 IF (.NOT.PRESENT(force_a) .AND. &
3693 PRESENT(force_b) .AND. &
3694 .NOT.PRESENT(force_c) .AND. &
3695 PRESENT(pabc) .AND. &
3696 .NOT.PRESENT(mat_dabc) .AND. &
3697 .NOT.PRESENT(mat_adbc) .AND. &
3698 PRESENT(mat_abdc)) THEN
3699 CALL integrate_set_3c( &
3700 param%par, potential_parameter, &
3701 la_min(iset), la_max(iset), &
3702 lb_min(jset), lb_max(jset), &
3703 lc_min(kset), lc_max(kset), &
3704 npgfa(iset), npgfb(jset), npgfc(kset), &
3705 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3706 ra, rb, rc, &
3707 habc, &
3708 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3709 offset_a_start, offset_b_start, offset_c_start, &
3710 0, 0, first_set - 1, &
3711 sphi_a, sphi_b, sphi_c, &
3712 sgfa, sgfb, sgfc, &
3713 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3714 my_eri_method, &
3715pabc=pabc_block, &
3716
3717force_b=force_b(jkind)%forces(:, atom_b), &
3718
3719 do_symmetric=do_symmetric, &
3720 on_diagonal=iatom .EQ. jatom, &
3721
3722
3723habdc=habdc, &
3724 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3725 END IF
3726 IF (.NOT.PRESENT(force_a) .AND. &
3727 PRESENT(force_b) .AND. &
3728 .NOT.PRESENT(force_c) .AND. &
3729 PRESENT(pabc) .AND. &
3730 .NOT.PRESENT(mat_dabc) .AND. &
3731 PRESENT(mat_adbc) .AND. &
3732 .NOT.PRESENT(mat_abdc)) THEN
3733 CALL integrate_set_3c( &
3734 param%par, potential_parameter, &
3735 la_min(iset), la_max(iset), &
3736 lb_min(jset), lb_max(jset), &
3737 lc_min(kset), lc_max(kset), &
3738 npgfa(iset), npgfb(jset), npgfc(kset), &
3739 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3740 ra, rb, rc, &
3741 habc, &
3742 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3743 offset_a_start, offset_b_start, offset_c_start, &
3744 0, 0, first_set - 1, &
3745 sphi_a, sphi_b, sphi_c, &
3746 sgfa, sgfb, sgfc, &
3747 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3748 my_eri_method, &
3749pabc=pabc_block, &
3750
3751force_b=force_b(jkind)%forces(:, atom_b), &
3752
3753 do_symmetric=do_symmetric, &
3754 on_diagonal=iatom .EQ. jatom, &
3755
3756hadbc=hadbc, &
3757
3758 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3759 END IF
3760 IF (.NOT.PRESENT(force_a) .AND. &
3761 PRESENT(force_b) .AND. &
3762 .NOT.PRESENT(force_c) .AND. &
3763 PRESENT(pabc) .AND. &
3764 .NOT.PRESENT(mat_dabc) .AND. &
3765 PRESENT(mat_adbc) .AND. &
3766 PRESENT(mat_abdc)) THEN
3767 CALL integrate_set_3c( &
3768 param%par, potential_parameter, &
3769 la_min(iset), la_max(iset), &
3770 lb_min(jset), lb_max(jset), &
3771 lc_min(kset), lc_max(kset), &
3772 npgfa(iset), npgfb(jset), npgfc(kset), &
3773 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3774 ra, rb, rc, &
3775 habc, &
3776 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3777 offset_a_start, offset_b_start, offset_c_start, &
3778 0, 0, first_set - 1, &
3779 sphi_a, sphi_b, sphi_c, &
3780 sgfa, sgfb, sgfc, &
3781 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3782 my_eri_method, &
3783pabc=pabc_block, &
3784
3785force_b=force_b(jkind)%forces(:, atom_b), &
3786
3787 do_symmetric=do_symmetric, &
3788 on_diagonal=iatom .EQ. jatom, &
3789
3790hadbc=hadbc, &
3791habdc=habdc, &
3792 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3793 END IF
3794 IF (.NOT.PRESENT(force_a) .AND. &
3795 PRESENT(force_b) .AND. &
3796 .NOT.PRESENT(force_c) .AND. &
3797 PRESENT(pabc) .AND. &
3798 PRESENT(mat_dabc) .AND. &
3799 .NOT.PRESENT(mat_adbc) .AND. &
3800 .NOT.PRESENT(mat_abdc)) THEN
3801 CALL integrate_set_3c( &
3802 param%par, potential_parameter, &
3803 la_min(iset), la_max(iset), &
3804 lb_min(jset), lb_max(jset), &
3805 lc_min(kset), lc_max(kset), &
3806 npgfa(iset), npgfb(jset), npgfc(kset), &
3807 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3808 ra, rb, rc, &
3809 habc, &
3810 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3811 offset_a_start, offset_b_start, offset_c_start, &
3812 0, 0, first_set - 1, &
3813 sphi_a, sphi_b, sphi_c, &
3814 sgfa, sgfb, sgfc, &
3815 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3816 my_eri_method, &
3817pabc=pabc_block, &
3818
3819force_b=force_b(jkind)%forces(:, atom_b), &
3820
3821 do_symmetric=do_symmetric, &
3822 on_diagonal=iatom .EQ. jatom, &
3823hdabc=hdabc, &
3824
3825
3826 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3827 END IF
3828 IF (.NOT.PRESENT(force_a) .AND. &
3829 PRESENT(force_b) .AND. &
3830 .NOT.PRESENT(force_c) .AND. &
3831 PRESENT(pabc) .AND. &
3832 PRESENT(mat_dabc) .AND. &
3833 .NOT.PRESENT(mat_adbc) .AND. &
3834 PRESENT(mat_abdc)) THEN
3835 CALL integrate_set_3c( &
3836 param%par, potential_parameter, &
3837 la_min(iset), la_max(iset), &
3838 lb_min(jset), lb_max(jset), &
3839 lc_min(kset), lc_max(kset), &
3840 npgfa(iset), npgfb(jset), npgfc(kset), &
3841 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3842 ra, rb, rc, &
3843 habc, &
3844 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3845 offset_a_start, offset_b_start, offset_c_start, &
3846 0, 0, first_set - 1, &
3847 sphi_a, sphi_b, sphi_c, &
3848 sgfa, sgfb, sgfc, &
3849 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3850 my_eri_method, &
3851pabc=pabc_block, &
3852
3853force_b=force_b(jkind)%forces(:, atom_b), &
3854
3855 do_symmetric=do_symmetric, &
3856 on_diagonal=iatom .EQ. jatom, &
3857hdabc=hdabc, &
3858
3859habdc=habdc, &
3860 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3861 END IF
3862 IF (.NOT.PRESENT(force_a) .AND. &
3863 PRESENT(force_b) .AND. &
3864 .NOT.PRESENT(force_c) .AND. &
3865 PRESENT(pabc) .AND. &
3866 PRESENT(mat_dabc) .AND. &
3867 PRESENT(mat_adbc) .AND. &
3868 .NOT.PRESENT(mat_abdc)) THEN
3869 CALL integrate_set_3c( &
3870 param%par, potential_parameter, &
3871 la_min(iset), la_max(iset), &
3872 lb_min(jset), lb_max(jset), &
3873 lc_min(kset), lc_max(kset), &
3874 npgfa(iset), npgfb(jset), npgfc(kset), &
3875 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3876 ra, rb, rc, &
3877 habc, &
3878 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3879 offset_a_start, offset_b_start, offset_c_start, &
3880 0, 0, first_set - 1, &
3881 sphi_a, sphi_b, sphi_c, &
3882 sgfa, sgfb, sgfc, &
3883 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3884 my_eri_method, &
3885pabc=pabc_block, &
3886
3887force_b=force_b(jkind)%forces(:, atom_b), &
3888
3889 do_symmetric=do_symmetric, &
3890 on_diagonal=iatom .EQ. jatom, &
3891hdabc=hdabc, &
3892hadbc=hadbc, &
3893
3894 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3895 END IF
3896 IF (.NOT.PRESENT(force_a) .AND. &
3897 PRESENT(force_b) .AND. &
3898 .NOT.PRESENT(force_c) .AND. &
3899 PRESENT(pabc) .AND. &
3900 PRESENT(mat_dabc) .AND. &
3901 PRESENT(mat_adbc) .AND. &
3902 PRESENT(mat_abdc)) THEN
3903 CALL integrate_set_3c( &
3904 param%par, potential_parameter, &
3905 la_min(iset), la_max(iset), &
3906 lb_min(jset), lb_max(jset), &
3907 lc_min(kset), lc_max(kset), &
3908 npgfa(iset), npgfb(jset), npgfc(kset), &
3909 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3910 ra, rb, rc, &
3911 habc, &
3912 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3913 offset_a_start, offset_b_start, offset_c_start, &
3914 0, 0, first_set - 1, &
3915 sphi_a, sphi_b, sphi_c, &
3916 sgfa, sgfb, sgfc, &
3917 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3918 my_eri_method, &
3919pabc=pabc_block, &
3920
3921force_b=force_b(jkind)%forces(:, atom_b), &
3922
3923 do_symmetric=do_symmetric, &
3924 on_diagonal=iatom .EQ. jatom, &
3925hdabc=hdabc, &
3926hadbc=hadbc, &
3927habdc=habdc, &
3928 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3929 END IF
3930 IF (.NOT.PRESENT(force_a) .AND. &
3931 PRESENT(force_b) .AND. &
3932 PRESENT(force_c) .AND. &
3933 PRESENT(pabc) .AND. &
3934 .NOT.PRESENT(mat_dabc) .AND. &
3935 .NOT.PRESENT(mat_adbc) .AND. &
3936 .NOT.PRESENT(mat_abdc)) THEN
3937 CALL integrate_set_3c( &
3938 param%par, potential_parameter, &
3939 la_min(iset), la_max(iset), &
3940 lb_min(jset), lb_max(jset), &
3941 lc_min(kset), lc_max(kset), &
3942 npgfa(iset), npgfb(jset), npgfc(kset), &
3943 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3944 ra, rb, rc, &
3945 habc, &
3946 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3947 offset_a_start, offset_b_start, offset_c_start, &
3948 0, 0, first_set - 1, &
3949 sphi_a, sphi_b, sphi_c, &
3950 sgfa, sgfb, sgfc, &
3951 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3952 my_eri_method, &
3953pabc=pabc_block, &
3954
3955force_b=force_b(jkind)%forces(:, atom_b), &
3956force_c=force_c(kkind)%forces(:, atom_c), &
3957 do_symmetric=do_symmetric, &
3958 on_diagonal=iatom .EQ. jatom, &
3959
3960
3961
3962 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3963 END IF
3964 IF (.NOT.PRESENT(force_a) .AND. &
3965 PRESENT(force_b) .AND. &
3966 PRESENT(force_c) .AND. &
3967 PRESENT(pabc) .AND. &
3968 .NOT.PRESENT(mat_dabc) .AND. &
3969 .NOT.PRESENT(mat_adbc) .AND. &
3970 PRESENT(mat_abdc)) THEN
3971 CALL integrate_set_3c( &
3972 param%par, potential_parameter, &
3973 la_min(iset), la_max(iset), &
3974 lb_min(jset), lb_max(jset), &
3975 lc_min(kset), lc_max(kset), &
3976 npgfa(iset), npgfb(jset), npgfc(kset), &
3977 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3978 ra, rb, rc, &
3979 habc, &
3980 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3981 offset_a_start, offset_b_start, offset_c_start, &
3982 0, 0, first_set - 1, &
3983 sphi_a, sphi_b, sphi_c, &
3984 sgfa, sgfb, sgfc, &
3985 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3986 my_eri_method, &
3987pabc=pabc_block, &
3988
3989force_b=force_b(jkind)%forces(:, atom_b), &
3990force_c=force_c(kkind)%forces(:, atom_c), &
3991 do_symmetric=do_symmetric, &
3992 on_diagonal=iatom .EQ. jatom, &
3993
3994
3995habdc=habdc, &
3996 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3997 END IF
3998 IF (.NOT.PRESENT(force_a) .AND. &
3999 PRESENT(force_b) .AND. &
4000 PRESENT(force_c) .AND. &
4001 PRESENT(pabc) .AND. &
4002 .NOT.PRESENT(mat_dabc) .AND. &
4003 PRESENT(mat_adbc) .AND. &
4004 .NOT.PRESENT(mat_abdc)) THEN
4005 CALL integrate_set_3c( &
4006 param%par, potential_parameter, &
4007 la_min(iset), la_max(iset), &
4008 lb_min(jset), lb_max(jset), &
4009 lc_min(kset), lc_max(kset), &
4010 npgfa(iset), npgfb(jset), npgfc(kset), &
4011 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4012 ra, rb, rc, &
4013 habc, &
4014 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4015 offset_a_start, offset_b_start, offset_c_start, &
4016 0, 0, first_set - 1, &
4017 sphi_a, sphi_b, sphi_c, &
4018 sgfa, sgfb, sgfc, &
4019 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4020 my_eri_method, &
4021pabc=pabc_block, &
4022
4023force_b=force_b(jkind)%forces(:, atom_b), &
4024force_c=force_c(kkind)%forces(:, atom_c), &
4025 do_symmetric=do_symmetric, &
4026 on_diagonal=iatom .EQ. jatom, &
4027
4028hadbc=hadbc, &
4029
4030 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4031 END IF
4032 IF (.NOT.PRESENT(force_a) .AND. &
4033 PRESENT(force_b) .AND. &
4034 PRESENT(force_c) .AND. &
4035 PRESENT(pabc) .AND. &
4036 .NOT.PRESENT(mat_dabc) .AND. &
4037 PRESENT(mat_adbc) .AND. &
4038 PRESENT(mat_abdc)) THEN
4039 CALL integrate_set_3c( &
4040 param%par, potential_parameter, &
4041 la_min(iset), la_max(iset), &
4042 lb_min(jset), lb_max(jset), &
4043 lc_min(kset), lc_max(kset), &
4044 npgfa(iset), npgfb(jset), npgfc(kset), &
4045 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4046 ra, rb, rc, &
4047 habc, &
4048 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4049 offset_a_start, offset_b_start, offset_c_start, &
4050 0, 0, first_set - 1, &
4051 sphi_a, sphi_b, sphi_c, &
4052 sgfa, sgfb, sgfc, &
4053 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4054 my_eri_method, &
4055pabc=pabc_block, &
4056
4057force_b=force_b(jkind)%forces(:, atom_b), &
4058force_c=force_c(kkind)%forces(:, atom_c), &
4059 do_symmetric=do_symmetric, &
4060 on_diagonal=iatom .EQ. jatom, &
4061
4062hadbc=hadbc, &
4063habdc=habdc, &
4064 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4065 END IF
4066 IF (.NOT.PRESENT(force_a) .AND. &
4067 PRESENT(force_b) .AND. &
4068 PRESENT(force_c) .AND. &
4069 PRESENT(pabc) .AND. &
4070 PRESENT(mat_dabc) .AND. &
4071 .NOT.PRESENT(mat_adbc) .AND. &
4072 .NOT.PRESENT(mat_abdc)) THEN
4073 CALL integrate_set_3c( &
4074 param%par, potential_parameter, &
4075 la_min(iset), la_max(iset), &
4076 lb_min(jset), lb_max(jset), &
4077 lc_min(kset), lc_max(kset), &
4078 npgfa(iset), npgfb(jset), npgfc(kset), &
4079 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4080 ra, rb, rc, &
4081 habc, &
4082 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4083 offset_a_start, offset_b_start, offset_c_start, &
4084 0, 0, first_set - 1, &
4085 sphi_a, sphi_b, sphi_c, &
4086 sgfa, sgfb, sgfc, &
4087 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4088 my_eri_method, &
4089pabc=pabc_block, &
4090
4091force_b=force_b(jkind)%forces(:, atom_b), &
4092force_c=force_c(kkind)%forces(:, atom_c), &
4093 do_symmetric=do_symmetric, &
4094 on_diagonal=iatom .EQ. jatom, &
4095hdabc=hdabc, &
4096
4097
4098 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4099 END IF
4100 IF (.NOT.PRESENT(force_a) .AND. &
4101 PRESENT(force_b) .AND. &
4102 PRESENT(force_c) .AND. &
4103 PRESENT(pabc) .AND. &
4104 PRESENT(mat_dabc) .AND. &
4105 .NOT.PRESENT(mat_adbc) .AND. &
4106 PRESENT(mat_abdc)) THEN
4107 CALL integrate_set_3c( &
4108 param%par, potential_parameter, &
4109 la_min(iset), la_max(iset), &
4110 lb_min(jset), lb_max(jset), &
4111 lc_min(kset), lc_max(kset), &
4112 npgfa(iset), npgfb(jset), npgfc(kset), &
4113 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4114 ra, rb, rc, &
4115 habc, &
4116 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4117 offset_a_start, offset_b_start, offset_c_start, &
4118 0, 0, first_set - 1, &
4119 sphi_a, sphi_b, sphi_c, &
4120 sgfa, sgfb, sgfc, &
4121 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4122 my_eri_method, &
4123pabc=pabc_block, &
4124
4125force_b=force_b(jkind)%forces(:, atom_b), &
4126force_c=force_c(kkind)%forces(:, atom_c), &
4127 do_symmetric=do_symmetric, &
4128 on_diagonal=iatom .EQ. jatom, &
4129hdabc=hdabc, &
4130
4131habdc=habdc, &
4132 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4133 END IF
4134 IF (.NOT.PRESENT(force_a) .AND. &
4135 PRESENT(force_b) .AND. &
4136 PRESENT(force_c) .AND. &
4137 PRESENT(pabc) .AND. &
4138 PRESENT(mat_dabc) .AND. &
4139 PRESENT(mat_adbc) .AND. &
4140 .NOT.PRESENT(mat_abdc)) THEN
4141 CALL integrate_set_3c( &
4142 param%par, potential_parameter, &
4143 la_min(iset), la_max(iset), &
4144 lb_min(jset), lb_max(jset), &
4145 lc_min(kset), lc_max(kset), &
4146 npgfa(iset), npgfb(jset), npgfc(kset), &
4147 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4148 ra, rb, rc, &
4149 habc, &
4150 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4151 offset_a_start, offset_b_start, offset_c_start, &
4152 0, 0, first_set - 1, &
4153 sphi_a, sphi_b, sphi_c, &
4154 sgfa, sgfb, sgfc, &
4155 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4156 my_eri_method, &
4157pabc=pabc_block, &
4158
4159force_b=force_b(jkind)%forces(:, atom_b), &
4160force_c=force_c(kkind)%forces(:, atom_c), &
4161 do_symmetric=do_symmetric, &
4162 on_diagonal=iatom .EQ. jatom, &
4163hdabc=hdabc, &
4164hadbc=hadbc, &
4165
4166 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4167 END IF
4168 IF (.NOT.PRESENT(force_a) .AND. &
4169 PRESENT(force_b) .AND. &
4170 PRESENT(force_c) .AND. &
4171 PRESENT(pabc) .AND. &
4172 PRESENT(mat_dabc) .AND. &
4173 PRESENT(mat_adbc) .AND. &
4174 PRESENT(mat_abdc)) THEN
4175 CALL integrate_set_3c( &
4176 param%par, potential_parameter, &
4177 la_min(iset), la_max(iset), &
4178 lb_min(jset), lb_max(jset), &
4179 lc_min(kset), lc_max(kset), &
4180 npgfa(iset), npgfb(jset), npgfc(kset), &
4181 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4182 ra, rb, rc, &
4183 habc, &
4184 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4185 offset_a_start, offset_b_start, offset_c_start, &
4186 0, 0, first_set - 1, &
4187 sphi_a, sphi_b, sphi_c, &
4188 sgfa, sgfb, sgfc, &
4189 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4190 my_eri_method, &
4191pabc=pabc_block, &
4192
4193force_b=force_b(jkind)%forces(:, atom_b), &
4194force_c=force_c(kkind)%forces(:, atom_c), &
4195 do_symmetric=do_symmetric, &
4196 on_diagonal=iatom .EQ. jatom, &
4197hdabc=hdabc, &
4198hadbc=hadbc, &
4199habdc=habdc, &
4200 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4201 END IF
4202 IF (PRESENT(force_a) .AND. &
4203 .NOT.PRESENT(force_b) .AND. &
4204 .NOT.PRESENT(force_c) .AND. &
4205 PRESENT(pabc) .AND. &
4206 .NOT.PRESENT(mat_dabc) .AND. &
4207 .NOT.PRESENT(mat_adbc) .AND. &
4208 .NOT.PRESENT(mat_abdc)) THEN
4209 CALL integrate_set_3c( &
4210 param%par, potential_parameter, &
4211 la_min(iset), la_max(iset), &
4212 lb_min(jset), lb_max(jset), &
4213 lc_min(kset), lc_max(kset), &
4214 npgfa(iset), npgfb(jset), npgfc(kset), &
4215 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4216 ra, rb, rc, &
4217 habc, &
4218 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4219 offset_a_start, offset_b_start, offset_c_start, &
4220 0, 0, first_set - 1, &
4221 sphi_a, sphi_b, sphi_c, &
4222 sgfa, sgfb, sgfc, &
4223 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4224 my_eri_method, &
4225pabc=pabc_block, &
4226force_a=force_a(ikind)%forces(:, atom_a), &
4227
4228
4229 do_symmetric=do_symmetric, &
4230 on_diagonal=iatom .EQ. jatom, &
4231
4232
4233
4234 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4235 END IF
4236 IF (PRESENT(force_a) .AND. &
4237 .NOT.PRESENT(force_b) .AND. &
4238 .NOT.PRESENT(force_c) .AND. &
4239 PRESENT(pabc) .AND. &
4240 .NOT.PRESENT(mat_dabc) .AND. &
4241 .NOT.PRESENT(mat_adbc) .AND. &
4242 PRESENT(mat_abdc)) THEN
4243 CALL integrate_set_3c( &
4244 param%par, potential_parameter, &
4245 la_min(iset), la_max(iset), &
4246 lb_min(jset), lb_max(jset), &
4247 lc_min(kset), lc_max(kset), &
4248 npgfa(iset), npgfb(jset), npgfc(kset), &
4249 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4250 ra, rb, rc, &
4251 habc, &
4252 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4253 offset_a_start, offset_b_start, offset_c_start, &
4254 0, 0, first_set - 1, &
4255 sphi_a, sphi_b, sphi_c, &
4256 sgfa, sgfb, sgfc, &
4257 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4258 my_eri_method, &
4259pabc=pabc_block, &
4260force_a=force_a(ikind)%forces(:, atom_a), &
4261
4262
4263 do_symmetric=do_symmetric, &
4264 on_diagonal=iatom .EQ. jatom, &
4265
4266
4267habdc=habdc, &
4268 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4269 END IF
4270 IF (PRESENT(force_a) .AND. &
4271 .NOT.PRESENT(force_b) .AND. &
4272 .NOT.PRESENT(force_c) .AND. &
4273 PRESENT(pabc) .AND. &
4274 .NOT.PRESENT(mat_dabc) .AND. &
4275 PRESENT(mat_adbc) .AND. &
4276 .NOT.PRESENT(mat_abdc)) THEN
4277 CALL integrate_set_3c( &
4278 param%par, potential_parameter, &
4279 la_min(iset), la_max(iset), &
4280 lb_min(jset), lb_max(jset), &
4281 lc_min(kset), lc_max(kset), &
4282 npgfa(iset), npgfb(jset), npgfc(kset), &
4283 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4284 ra, rb, rc, &
4285 habc, &
4286 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4287 offset_a_start, offset_b_start, offset_c_start, &
4288 0, 0, first_set - 1, &
4289 sphi_a, sphi_b, sphi_c, &
4290 sgfa, sgfb, sgfc, &
4291 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4292 my_eri_method, &
4293pabc=pabc_block, &
4294force_a=force_a(ikind)%forces(:, atom_a), &
4295
4296
4297 do_symmetric=do_symmetric, &
4298 on_diagonal=iatom .EQ. jatom, &
4299
4300hadbc=hadbc, &
4301
4302 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4303 END IF
4304 IF (PRESENT(force_a) .AND. &
4305 .NOT.PRESENT(force_b) .AND. &
4306 .NOT.PRESENT(force_c) .AND. &
4307 PRESENT(pabc) .AND. &
4308 .NOT.PRESENT(mat_dabc) .AND. &
4309 PRESENT(mat_adbc) .AND. &
4310 PRESENT(mat_abdc)) THEN
4311 CALL integrate_set_3c( &
4312 param%par, potential_parameter, &
4313 la_min(iset), la_max(iset), &
4314 lb_min(jset), lb_max(jset), &
4315 lc_min(kset), lc_max(kset), &
4316 npgfa(iset), npgfb(jset), npgfc(kset), &
4317 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4318 ra, rb, rc, &
4319 habc, &
4320 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4321 offset_a_start, offset_b_start, offset_c_start, &
4322 0, 0, first_set - 1, &
4323 sphi_a, sphi_b, sphi_c, &
4324 sgfa, sgfb, sgfc, &
4325 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4326 my_eri_method, &
4327pabc=pabc_block, &
4328force_a=force_a(ikind)%forces(:, atom_a), &
4329
4330
4331 do_symmetric=do_symmetric, &
4332 on_diagonal=iatom .EQ. jatom, &
4333
4334hadbc=hadbc, &
4335habdc=habdc, &
4336 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4337 END IF
4338 IF (PRESENT(force_a) .AND. &
4339 .NOT.PRESENT(force_b) .AND. &
4340 .NOT.PRESENT(force_c) .AND. &
4341 PRESENT(pabc) .AND. &
4342 PRESENT(mat_dabc) .AND. &
4343 .NOT.PRESENT(mat_adbc) .AND. &
4344 .NOT.PRESENT(mat_abdc)) THEN
4345 CALL integrate_set_3c( &
4346 param%par, potential_parameter, &
4347 la_min(iset), la_max(iset), &
4348 lb_min(jset), lb_max(jset), &
4349 lc_min(kset), lc_max(kset), &
4350 npgfa(iset), npgfb(jset), npgfc(kset), &
4351 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4352 ra, rb, rc, &
4353 habc, &
4354 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4355 offset_a_start, offset_b_start, offset_c_start, &
4356 0, 0, first_set - 1, &
4357 sphi_a, sphi_b, sphi_c, &
4358 sgfa, sgfb, sgfc, &
4359 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4360 my_eri_method, &
4361pabc=pabc_block, &
4362force_a=force_a(ikind)%forces(:, atom_a), &
4363
4364
4365 do_symmetric=do_symmetric, &
4366 on_diagonal=iatom .EQ. jatom, &
4367hdabc=hdabc, &
4368
4369
4370 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4371 END IF
4372 IF (PRESENT(force_a) .AND. &
4373 .NOT.PRESENT(force_b) .AND. &
4374 .NOT.PRESENT(force_c) .AND. &
4375 PRESENT(pabc) .AND. &
4376 PRESENT(mat_dabc) .AND. &
4377 .NOT.PRESENT(mat_adbc) .AND. &
4378 PRESENT(mat_abdc)) THEN
4379 CALL integrate_set_3c( &
4380 param%par, potential_parameter, &
4381 la_min(iset), la_max(iset), &
4382 lb_min(jset), lb_max(jset), &
4383 lc_min(kset), lc_max(kset), &
4384 npgfa(iset), npgfb(jset), npgfc(kset), &
4385 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4386 ra, rb, rc, &
4387 habc, &
4388 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4389 offset_a_start, offset_b_start, offset_c_start, &
4390 0, 0, first_set - 1, &
4391 sphi_a, sphi_b, sphi_c, &
4392 sgfa, sgfb, sgfc, &
4393 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4394 my_eri_method, &
4395pabc=pabc_block, &
4396force_a=force_a(ikind)%forces(:, atom_a), &
4397
4398
4399 do_symmetric=do_symmetric, &
4400 on_diagonal=iatom .EQ. jatom, &
4401hdabc=hdabc, &
4402
4403habdc=habdc, &
4404 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4405 END IF
4406 IF (PRESENT(force_a) .AND. &
4407 .NOT.PRESENT(force_b) .AND. &
4408 .NOT.PRESENT(force_c) .AND. &
4409 PRESENT(pabc) .AND. &
4410 PRESENT(mat_dabc) .AND. &
4411 PRESENT(mat_adbc) .AND. &
4412 .NOT.PRESENT(mat_abdc)) THEN
4413 CALL integrate_set_3c( &
4414 param%par, potential_parameter, &
4415 la_min(iset), la_max(iset), &
4416 lb_min(jset), lb_max(jset), &
4417 lc_min(kset), lc_max(kset), &
4418 npgfa(iset), npgfb(jset), npgfc(kset), &
4419 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4420 ra, rb, rc, &
4421 habc, &
4422 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4423 offset_a_start, offset_b_start, offset_c_start, &
4424 0, 0, first_set - 1, &
4425 sphi_a, sphi_b, sphi_c, &
4426 sgfa, sgfb, sgfc, &
4427 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4428 my_eri_method, &
4429pabc=pabc_block, &
4430force_a=force_a(ikind)%forces(:, atom_a), &
4431
4432
4433 do_symmetric=do_symmetric, &
4434 on_diagonal=iatom .EQ. jatom, &
4435hdabc=hdabc, &
4436hadbc=hadbc, &
4437
4438 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4439 END IF
4440 IF (PRESENT(force_a) .AND. &
4441 .NOT.PRESENT(force_b) .AND. &
4442 .NOT.PRESENT(force_c) .AND. &
4443 PRESENT(pabc) .AND. &
4444 PRESENT(mat_dabc) .AND. &
4445 PRESENT(mat_adbc) .AND. &
4446 PRESENT(mat_abdc)) THEN
4447 CALL integrate_set_3c( &
4448 param%par, potential_parameter, &
4449 la_min(iset), la_max(iset), &
4450 lb_min(jset), lb_max(jset), &
4451 lc_min(kset), lc_max(kset), &
4452 npgfa(iset), npgfb(jset), npgfc(kset), &
4453 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4454 ra, rb, rc, &
4455 habc, &
4456 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4457 offset_a_start, offset_b_start, offset_c_start, &
4458 0, 0, first_set - 1, &
4459 sphi_a, sphi_b, sphi_c, &
4460 sgfa, sgfb, sgfc, &
4461 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4462 my_eri_method, &
4463pabc=pabc_block, &
4464force_a=force_a(ikind)%forces(:, atom_a), &
4465
4466
4467 do_symmetric=do_symmetric, &
4468 on_diagonal=iatom .EQ. jatom, &
4469hdabc=hdabc, &
4470hadbc=hadbc, &
4471habdc=habdc, &
4472 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4473 END IF
4474 IF (PRESENT(force_a) .AND. &
4475 .NOT.PRESENT(force_b) .AND. &
4476 PRESENT(force_c) .AND. &
4477 PRESENT(pabc) .AND. &
4478 .NOT.PRESENT(mat_dabc) .AND. &
4479 .NOT.PRESENT(mat_adbc) .AND. &
4480 .NOT.PRESENT(mat_abdc)) THEN
4481 CALL integrate_set_3c( &
4482 param%par, potential_parameter, &
4483 la_min(iset), la_max(iset), &
4484 lb_min(jset), lb_max(jset), &
4485 lc_min(kset), lc_max(kset), &
4486 npgfa(iset), npgfb(jset), npgfc(kset), &
4487 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4488 ra, rb, rc, &
4489 habc, &
4490 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4491 offset_a_start, offset_b_start, offset_c_start, &
4492 0, 0, first_set - 1, &
4493 sphi_a, sphi_b, sphi_c, &
4494 sgfa, sgfb, sgfc, &
4495 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4496 my_eri_method, &
4497pabc=pabc_block, &
4498force_a=force_a(ikind)%forces(:, atom_a), &
4499
4500force_c=force_c(kkind)%forces(:, atom_c), &
4501 do_symmetric=do_symmetric, &
4502 on_diagonal=iatom .EQ. jatom, &
4503
4504
4505
4506 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4507 END IF
4508 IF (PRESENT(force_a) .AND. &
4509 .NOT.PRESENT(force_b) .AND. &
4510 PRESENT(force_c) .AND. &
4511 PRESENT(pabc) .AND. &
4512 .NOT.PRESENT(mat_dabc) .AND. &
4513 .NOT.PRESENT(mat_adbc) .AND. &
4514 PRESENT(mat_abdc)) THEN
4515 CALL integrate_set_3c( &
4516 param%par, potential_parameter, &
4517 la_min(iset), la_max(iset), &
4518 lb_min(jset), lb_max(jset), &
4519 lc_min(kset), lc_max(kset), &
4520 npgfa(iset), npgfb(jset), npgfc(kset), &
4521 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4522 ra, rb, rc, &
4523 habc, &
4524 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4525 offset_a_start, offset_b_start, offset_c_start, &
4526 0, 0, first_set - 1, &
4527 sphi_a, sphi_b, sphi_c, &
4528 sgfa, sgfb, sgfc, &
4529 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4530 my_eri_method, &
4531pabc=pabc_block, &
4532force_a=force_a(ikind)%forces(:, atom_a), &
4533
4534force_c=force_c(kkind)%forces(:, atom_c), &
4535 do_symmetric=do_symmetric, &
4536 on_diagonal=iatom .EQ. jatom, &
4537
4538
4539habdc=habdc, &
4540 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4541 END IF
4542 IF (PRESENT(force_a) .AND. &
4543 .NOT.PRESENT(force_b) .AND. &
4544 PRESENT(force_c) .AND. &
4545 PRESENT(pabc) .AND. &
4546 .NOT.PRESENT(mat_dabc) .AND. &
4547 PRESENT(mat_adbc) .AND. &
4548 .NOT.PRESENT(mat_abdc)) THEN
4549 CALL integrate_set_3c( &
4550 param%par, potential_parameter, &
4551 la_min(iset), la_max(iset), &
4552 lb_min(jset), lb_max(jset), &
4553 lc_min(kset), lc_max(kset), &
4554 npgfa(iset), npgfb(jset), npgfc(kset), &
4555 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4556 ra, rb, rc, &
4557 habc, &
4558 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4559 offset_a_start, offset_b_start, offset_c_start, &
4560 0, 0, first_set - 1, &
4561 sphi_a, sphi_b, sphi_c, &
4562 sgfa, sgfb, sgfc, &
4563 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4564 my_eri_method, &
4565pabc=pabc_block, &
4566force_a=force_a(ikind)%forces(:, atom_a), &
4567
4568force_c=force_c(kkind)%forces(:, atom_c), &
4569 do_symmetric=do_symmetric, &
4570 on_diagonal=iatom .EQ. jatom, &
4571
4572hadbc=hadbc, &
4573
4574 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4575 END IF
4576 IF (PRESENT(force_a) .AND. &
4577 .NOT.PRESENT(force_b) .AND. &
4578 PRESENT(force_c) .AND. &
4579 PRESENT(pabc) .AND. &
4580 .NOT.PRESENT(mat_dabc) .AND. &
4581 PRESENT(mat_adbc) .AND. &
4582 PRESENT(mat_abdc)) THEN
4583 CALL integrate_set_3c( &
4584 param%par, potential_parameter, &
4585 la_min(iset), la_max(iset), &
4586 lb_min(jset), lb_max(jset), &
4587 lc_min(kset), lc_max(kset), &
4588 npgfa(iset), npgfb(jset), npgfc(kset), &
4589 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4590 ra, rb, rc, &
4591 habc, &
4592 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4593 offset_a_start, offset_b_start, offset_c_start, &
4594 0, 0, first_set - 1, &
4595 sphi_a, sphi_b, sphi_c, &
4596 sgfa, sgfb, sgfc, &
4597 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4598 my_eri_method, &
4599pabc=pabc_block, &
4600force_a=force_a(ikind)%forces(:, atom_a), &
4601
4602force_c=force_c(kkind)%forces(:, atom_c), &
4603 do_symmetric=do_symmetric, &
4604 on_diagonal=iatom .EQ. jatom, &
4605
4606hadbc=hadbc, &
4607habdc=habdc, &
4608 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4609 END IF
4610 IF (PRESENT(force_a) .AND. &
4611 .NOT.PRESENT(force_b) .AND. &
4612 PRESENT(force_c) .AND. &
4613 PRESENT(pabc) .AND. &
4614 PRESENT(mat_dabc) .AND. &
4615 .NOT.PRESENT(mat_adbc) .AND. &
4616 .NOT.PRESENT(mat_abdc)) THEN
4617 CALL integrate_set_3c( &
4618 param%par, potential_parameter, &
4619 la_min(iset), la_max(iset), &
4620 lb_min(jset), lb_max(jset), &
4621 lc_min(kset), lc_max(kset), &
4622 npgfa(iset), npgfb(jset), npgfc(kset), &
4623 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4624 ra, rb, rc, &
4625 habc, &
4626 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4627 offset_a_start, offset_b_start, offset_c_start, &
4628 0, 0, first_set - 1, &
4629 sphi_a, sphi_b, sphi_c, &
4630 sgfa, sgfb, sgfc, &
4631 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4632 my_eri_method, &
4633pabc=pabc_block, &
4634force_a=force_a(ikind)%forces(:, atom_a), &
4635
4636force_c=force_c(kkind)%forces(:, atom_c), &
4637 do_symmetric=do_symmetric, &
4638 on_diagonal=iatom .EQ. jatom, &
4639hdabc=hdabc, &
4640
4641
4642 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4643 END IF
4644 IF (PRESENT(force_a) .AND. &
4645 .NOT.PRESENT(force_b) .AND. &
4646 PRESENT(force_c) .AND. &
4647 PRESENT(pabc) .AND. &
4648 PRESENT(mat_dabc) .AND. &
4649 .NOT.PRESENT(mat_adbc) .AND. &
4650 PRESENT(mat_abdc)) THEN
4651 CALL integrate_set_3c( &
4652 param%par, potential_parameter, &
4653 la_min(iset), la_max(iset), &
4654 lb_min(jset), lb_max(jset), &
4655 lc_min(kset), lc_max(kset), &
4656 npgfa(iset), npgfb(jset), npgfc(kset), &
4657 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4658 ra, rb, rc, &
4659 habc, &
4660 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4661 offset_a_start, offset_b_start, offset_c_start, &
4662 0, 0, first_set - 1, &
4663 sphi_a, sphi_b, sphi_c, &
4664 sgfa, sgfb, sgfc, &
4665 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4666 my_eri_method, &
4667pabc=pabc_block, &
4668force_a=force_a(ikind)%forces(:, atom_a), &
4669
4670force_c=force_c(kkind)%forces(:, atom_c), &
4671 do_symmetric=do_symmetric, &
4672 on_diagonal=iatom .EQ. jatom, &
4673hdabc=hdabc, &
4674
4675habdc=habdc, &
4676 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4677 END IF
4678 IF (PRESENT(force_a) .AND. &
4679 .NOT.PRESENT(force_b) .AND. &
4680 PRESENT(force_c) .AND. &
4681 PRESENT(pabc) .AND. &
4682 PRESENT(mat_dabc) .AND. &
4683 PRESENT(mat_adbc) .AND. &
4684 .NOT.PRESENT(mat_abdc)) THEN
4685 CALL integrate_set_3c( &
4686 param%par, potential_parameter, &
4687 la_min(iset), la_max(iset), &
4688 lb_min(jset), lb_max(jset), &
4689 lc_min(kset), lc_max(kset), &
4690 npgfa(iset), npgfb(jset), npgfc(kset), &
4691 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4692 ra, rb, rc, &
4693 habc, &
4694 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4695 offset_a_start, offset_b_start, offset_c_start, &
4696 0, 0, first_set - 1, &
4697 sphi_a, sphi_b, sphi_c, &
4698 sgfa, sgfb, sgfc, &
4699 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4700 my_eri_method, &
4701pabc=pabc_block, &
4702force_a=force_a(ikind)%forces(:, atom_a), &
4703
4704force_c=force_c(kkind)%forces(:, atom_c), &
4705 do_symmetric=do_symmetric, &
4706 on_diagonal=iatom .EQ. jatom, &
4707hdabc=hdabc, &
4708hadbc=hadbc, &
4709
4710 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4711 END IF
4712 IF (PRESENT(force_a) .AND. &
4713 .NOT.PRESENT(force_b) .AND. &
4714 PRESENT(force_c) .AND. &
4715 PRESENT(pabc) .AND. &
4716 PRESENT(mat_dabc) .AND. &
4717 PRESENT(mat_adbc) .AND. &
4718 PRESENT(mat_abdc)) THEN
4719 CALL integrate_set_3c( &
4720 param%par, potential_parameter, &
4721 la_min(iset), la_max(iset), &
4722 lb_min(jset), lb_max(jset), &
4723 lc_min(kset), lc_max(kset), &
4724 npgfa(iset), npgfb(jset), npgfc(kset), &
4725 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4726 ra, rb, rc, &
4727 habc, &
4728 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4729 offset_a_start, offset_b_start, offset_c_start, &
4730 0, 0, first_set - 1, &
4731 sphi_a, sphi_b, sphi_c, &
4732 sgfa, sgfb, sgfc, &
4733 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4734 my_eri_method, &
4735pabc=pabc_block, &
4736force_a=force_a(ikind)%forces(:, atom_a), &
4737
4738force_c=force_c(kkind)%forces(:, atom_c), &
4739 do_symmetric=do_symmetric, &
4740 on_diagonal=iatom .EQ. jatom, &
4741hdabc=hdabc, &
4742hadbc=hadbc, &
4743habdc=habdc, &
4744 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4745 END IF
4746 IF (PRESENT(force_a) .AND. &
4747 PRESENT(force_b) .AND. &
4748 .NOT.PRESENT(force_c) .AND. &
4749 PRESENT(pabc) .AND. &
4750 .NOT.PRESENT(mat_dabc) .AND. &
4751 .NOT.PRESENT(mat_adbc) .AND. &
4752 .NOT.PRESENT(mat_abdc)) THEN
4753 CALL integrate_set_3c( &
4754 param%par, potential_parameter, &
4755 la_min(iset), la_max(iset), &
4756 lb_min(jset), lb_max(jset), &
4757 lc_min(kset), lc_max(kset), &
4758 npgfa(iset), npgfb(jset), npgfc(kset), &
4759 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4760 ra, rb, rc, &
4761 habc, &
4762 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4763 offset_a_start, offset_b_start, offset_c_start, &
4764 0, 0, first_set - 1, &
4765 sphi_a, sphi_b, sphi_c, &
4766 sgfa, sgfb, sgfc, &
4767 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4768 my_eri_method, &
4769pabc=pabc_block, &
4770force_a=force_a(ikind)%forces(:, atom_a), &
4771force_b=force_b(jkind)%forces(:, atom_b), &
4772
4773 do_symmetric=do_symmetric, &
4774 on_diagonal=iatom .EQ. jatom, &
4775
4776
4777
4778 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4779 END IF
4780 IF (PRESENT(force_a) .AND. &
4781 PRESENT(force_b) .AND. &
4782 .NOT.PRESENT(force_c) .AND. &
4783 PRESENT(pabc) .AND. &
4784 .NOT.PRESENT(mat_dabc) .AND. &
4785 .NOT.PRESENT(mat_adbc) .AND. &
4786 PRESENT(mat_abdc)) THEN
4787 CALL integrate_set_3c( &
4788 param%par, potential_parameter, &
4789 la_min(iset), la_max(iset), &
4790 lb_min(jset), lb_max(jset), &
4791 lc_min(kset), lc_max(kset), &
4792 npgfa(iset), npgfb(jset), npgfc(kset), &
4793 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4794 ra, rb, rc, &
4795 habc, &
4796 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4797 offset_a_start, offset_b_start, offset_c_start, &
4798 0, 0, first_set - 1, &
4799 sphi_a, sphi_b, sphi_c, &
4800 sgfa, sgfb, sgfc, &
4801 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4802 my_eri_method, &
4803pabc=pabc_block, &
4804force_a=force_a(ikind)%forces(:, atom_a), &
4805force_b=force_b(jkind)%forces(:, atom_b), &
4806
4807 do_symmetric=do_symmetric, &
4808 on_diagonal=iatom .EQ. jatom, &
4809
4810
4811habdc=habdc, &
4812 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4813 END IF
4814 IF (PRESENT(force_a) .AND. &
4815 PRESENT(force_b) .AND. &
4816 .NOT.PRESENT(force_c) .AND. &
4817 PRESENT(pabc) .AND. &
4818 .NOT.PRESENT(mat_dabc) .AND. &
4819 PRESENT(mat_adbc) .AND. &
4820 .NOT.PRESENT(mat_abdc)) THEN
4821 CALL integrate_set_3c( &
4822 param%par, potential_parameter, &
4823 la_min(iset), la_max(iset), &
4824 lb_min(jset), lb_max(jset), &
4825 lc_min(kset), lc_max(kset), &
4826 npgfa(iset), npgfb(jset), npgfc(kset), &
4827 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4828 ra, rb, rc, &
4829 habc, &
4830 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4831 offset_a_start, offset_b_start, offset_c_start, &
4832 0, 0, first_set - 1, &
4833 sphi_a, sphi_b, sphi_c, &
4834 sgfa, sgfb, sgfc, &
4835 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4836 my_eri_method, &
4837pabc=pabc_block, &
4838force_a=force_a(ikind)%forces(:, atom_a), &
4839force_b=force_b(jkind)%forces(:, atom_b), &
4840
4841 do_symmetric=do_symmetric, &
4842 on_diagonal=iatom .EQ. jatom, &
4843
4844hadbc=hadbc, &
4845
4846 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4847 END IF
4848 IF (PRESENT(force_a) .AND. &
4849 PRESENT(force_b) .AND. &
4850 .NOT.PRESENT(force_c) .AND. &
4851 PRESENT(pabc) .AND. &
4852 .NOT.PRESENT(mat_dabc) .AND. &
4853 PRESENT(mat_adbc) .AND. &
4854 PRESENT(mat_abdc)) THEN
4855 CALL integrate_set_3c( &
4856 param%par, potential_parameter, &
4857 la_min(iset), la_max(iset), &
4858 lb_min(jset), lb_max(jset), &
4859 lc_min(kset), lc_max(kset), &
4860 npgfa(iset), npgfb(jset), npgfc(kset), &
4861 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4862 ra, rb, rc, &
4863 habc, &
4864 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4865 offset_a_start, offset_b_start, offset_c_start, &
4866 0, 0, first_set - 1, &
4867 sphi_a, sphi_b, sphi_c, &
4868 sgfa, sgfb, sgfc, &
4869 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4870 my_eri_method, &
4871pabc=pabc_block, &
4872force_a=force_a(ikind)%forces(:, atom_a), &
4873force_b=force_b(jkind)%forces(:, atom_b), &
4874
4875 do_symmetric=do_symmetric, &
4876 on_diagonal=iatom .EQ. jatom, &
4877
4878hadbc=hadbc, &
4879habdc=habdc, &
4880 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4881 END IF
4882 IF (PRESENT(force_a) .AND. &
4883 PRESENT(force_b) .AND. &
4884 .NOT.PRESENT(force_c) .AND. &
4885 PRESENT(pabc) .AND. &
4886 PRESENT(mat_dabc) .AND. &
4887 .NOT.PRESENT(mat_adbc) .AND. &
4888 .NOT.PRESENT(mat_abdc)) THEN
4889 CALL integrate_set_3c( &
4890 param%par, potential_parameter, &
4891 la_min(iset), la_max(iset), &
4892 lb_min(jset), lb_max(jset), &
4893 lc_min(kset), lc_max(kset), &
4894 npgfa(iset), npgfb(jset), npgfc(kset), &
4895 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4896 ra, rb, rc, &
4897 habc, &
4898 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4899 offset_a_start, offset_b_start, offset_c_start, &
4900 0, 0, first_set - 1, &
4901 sphi_a, sphi_b, sphi_c, &
4902 sgfa, sgfb, sgfc, &
4903 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4904 my_eri_method, &
4905pabc=pabc_block, &
4906force_a=force_a(ikind)%forces(:, atom_a), &
4907force_b=force_b(jkind)%forces(:, atom_b), &
4908
4909 do_symmetric=do_symmetric, &
4910 on_diagonal=iatom .EQ. jatom, &
4911hdabc=hdabc, &
4912
4913
4914 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4915 END IF
4916 IF (PRESENT(force_a) .AND. &
4917 PRESENT(force_b) .AND. &
4918 .NOT.PRESENT(force_c) .AND. &
4919 PRESENT(pabc) .AND. &
4920 PRESENT(mat_dabc) .AND. &
4921 .NOT.PRESENT(mat_adbc) .AND. &
4922 PRESENT(mat_abdc)) THEN
4923 CALL integrate_set_3c( &
4924 param%par, potential_parameter, &
4925 la_min(iset), la_max(iset), &
4926 lb_min(jset), lb_max(jset), &
4927 lc_min(kset), lc_max(kset), &
4928 npgfa(iset), npgfb(jset), npgfc(kset), &
4929 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4930 ra, rb, rc, &
4931 habc, &
4932 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4933 offset_a_start, offset_b_start, offset_c_start, &
4934 0, 0, first_set - 1, &
4935 sphi_a, sphi_b, sphi_c, &
4936 sgfa, sgfb, sgfc, &
4937 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4938 my_eri_method, &
4939pabc=pabc_block, &
4940force_a=force_a(ikind)%forces(:, atom_a), &
4941force_b=force_b(jkind)%forces(:, atom_b), &
4942
4943 do_symmetric=do_symmetric, &
4944 on_diagonal=iatom .EQ. jatom, &
4945hdabc=hdabc, &
4946
4947habdc=habdc, &
4948 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4949 END IF
4950 IF (PRESENT(force_a) .AND. &
4951 PRESENT(force_b) .AND. &
4952 .NOT.PRESENT(force_c) .AND. &
4953 PRESENT(pabc) .AND. &
4954 PRESENT(mat_dabc) .AND. &
4955 PRESENT(mat_adbc) .AND. &
4956 .NOT.PRESENT(mat_abdc)) THEN
4957 CALL integrate_set_3c( &
4958 param%par, potential_parameter, &
4959 la_min(iset), la_max(iset), &
4960 lb_min(jset), lb_max(jset), &
4961 lc_min(kset), lc_max(kset), &
4962 npgfa(iset), npgfb(jset), npgfc(kset), &
4963 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4964 ra, rb, rc, &
4965 habc, &
4966 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4967 offset_a_start, offset_b_start, offset_c_start, &
4968 0, 0, first_set - 1, &
4969 sphi_a, sphi_b, sphi_c, &
4970 sgfa, sgfb, sgfc, &
4971 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4972 my_eri_method, &
4973pabc=pabc_block, &
4974force_a=force_a(ikind)%forces(:, atom_a), &
4975force_b=force_b(jkind)%forces(:, atom_b), &
4976
4977 do_symmetric=do_symmetric, &
4978 on_diagonal=iatom .EQ. jatom, &
4979hdabc=hdabc, &
4980hadbc=hadbc, &
4981
4982 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4983 END IF
4984 IF (PRESENT(force_a) .AND. &
4985 PRESENT(force_b) .AND. &
4986 .NOT.PRESENT(force_c) .AND. &
4987 PRESENT(pabc) .AND. &
4988 PRESENT(mat_dabc) .AND. &
4989 PRESENT(mat_adbc) .AND. &
4990 PRESENT(mat_abdc)) THEN
4991 CALL integrate_set_3c( &
4992 param%par, potential_parameter, &
4993 la_min(iset), la_max(iset), &
4994 lb_min(jset), lb_max(jset), &
4995 lc_min(kset), lc_max(kset), &
4996 npgfa(iset), npgfb(jset), npgfc(kset), &
4997 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4998 ra, rb, rc, &
4999 habc, &
5000 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5001 offset_a_start, offset_b_start, offset_c_start, &
5002 0, 0, first_set - 1, &
5003 sphi_a, sphi_b, sphi_c, &
5004 sgfa, sgfb, sgfc, &
5005 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5006 my_eri_method, &
5007pabc=pabc_block, &
5008force_a=force_a(ikind)%forces(:, atom_a), &
5009force_b=force_b(jkind)%forces(:, atom_b), &
5010
5011 do_symmetric=do_symmetric, &
5012 on_diagonal=iatom .EQ. jatom, &
5013hdabc=hdabc, &
5014hadbc=hadbc, &
5015habdc=habdc, &
5016 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5017 END IF
5018 IF (PRESENT(force_a) .AND. &
5019 PRESENT(force_b) .AND. &
5020 PRESENT(force_c) .AND. &
5021 PRESENT(pabc) .AND. &
5022 .NOT.PRESENT(mat_dabc) .AND. &
5023 .NOT.PRESENT(mat_adbc) .AND. &
5024 .NOT.PRESENT(mat_abdc)) THEN
5025 CALL integrate_set_3c( &
5026 param%par, potential_parameter, &
5027 la_min(iset), la_max(iset), &
5028 lb_min(jset), lb_max(jset), &
5029 lc_min(kset), lc_max(kset), &
5030 npgfa(iset), npgfb(jset), npgfc(kset), &
5031 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5032 ra, rb, rc, &
5033 habc, &
5034 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5035 offset_a_start, offset_b_start, offset_c_start, &
5036 0, 0, first_set - 1, &
5037 sphi_a, sphi_b, sphi_c, &
5038 sgfa, sgfb, sgfc, &
5039 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5040 my_eri_method, &
5041pabc=pabc_block, &
5042force_a=force_a(ikind)%forces(:, atom_a), &
5043force_b=force_b(jkind)%forces(:, atom_b), &
5044force_c=force_c(kkind)%forces(:, atom_c), &
5045 do_symmetric=do_symmetric, &
5046 on_diagonal=iatom .EQ. jatom, &
5047
5048
5049
5050 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5051 END IF
5052 IF (PRESENT(force_a) .AND. &
5053 PRESENT(force_b) .AND. &
5054 PRESENT(force_c) .AND. &
5055 PRESENT(pabc) .AND. &
5056 .NOT.PRESENT(mat_dabc) .AND. &
5057 .NOT.PRESENT(mat_adbc) .AND. &
5058 PRESENT(mat_abdc)) THEN
5059 CALL integrate_set_3c( &
5060 param%par, potential_parameter, &
5061 la_min(iset), la_max(iset), &
5062 lb_min(jset), lb_max(jset), &
5063 lc_min(kset), lc_max(kset), &
5064 npgfa(iset), npgfb(jset), npgfc(kset), &
5065 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5066 ra, rb, rc, &
5067 habc, &
5068 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5069 offset_a_start, offset_b_start, offset_c_start, &
5070 0, 0, first_set - 1, &
5071 sphi_a, sphi_b, sphi_c, &
5072 sgfa, sgfb, sgfc, &
5073 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5074 my_eri_method, &
5075pabc=pabc_block, &
5076force_a=force_a(ikind)%forces(:, atom_a), &
5077force_b=force_b(jkind)%forces(:, atom_b), &
5078force_c=force_c(kkind)%forces(:, atom_c), &
5079 do_symmetric=do_symmetric, &
5080 on_diagonal=iatom .EQ. jatom, &
5081
5082
5083habdc=habdc, &
5084 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5085 END IF
5086 IF (PRESENT(force_a) .AND. &
5087 PRESENT(force_b) .AND. &
5088 PRESENT(force_c) .AND. &
5089 PRESENT(pabc) .AND. &
5090 .NOT.PRESENT(mat_dabc) .AND. &
5091 PRESENT(mat_adbc) .AND. &
5092 .NOT.PRESENT(mat_abdc)) THEN
5093 CALL integrate_set_3c( &
5094 param%par, potential_parameter, &
5095 la_min(iset), la_max(iset), &
5096 lb_min(jset), lb_max(jset), &
5097 lc_min(kset), lc_max(kset), &
5098 npgfa(iset), npgfb(jset), npgfc(kset), &
5099 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5100 ra, rb, rc, &
5101 habc, &
5102 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5103 offset_a_start, offset_b_start, offset_c_start, &
5104 0, 0, first_set - 1, &
5105 sphi_a, sphi_b, sphi_c, &
5106 sgfa, sgfb, sgfc, &
5107 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5108 my_eri_method, &
5109pabc=pabc_block, &
5110force_a=force_a(ikind)%forces(:, atom_a), &
5111force_b=force_b(jkind)%forces(:, atom_b), &
5112force_c=force_c(kkind)%forces(:, atom_c), &
5113 do_symmetric=do_symmetric, &
5114 on_diagonal=iatom .EQ. jatom, &
5115
5116hadbc=hadbc, &
5117
5118 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5119 END IF
5120 IF (PRESENT(force_a) .AND. &
5121 PRESENT(force_b) .AND. &
5122 PRESENT(force_c) .AND. &
5123 PRESENT(pabc) .AND. &
5124 .NOT.PRESENT(mat_dabc) .AND. &
5125 PRESENT(mat_adbc) .AND. &
5126 PRESENT(mat_abdc)) THEN
5127 CALL integrate_set_3c( &
5128 param%par, potential_parameter, &
5129 la_min(iset), la_max(iset), &
5130 lb_min(jset), lb_max(jset), &
5131 lc_min(kset), lc_max(kset), &
5132 npgfa(iset), npgfb(jset), npgfc(kset), &
5133 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5134 ra, rb, rc, &
5135 habc, &
5136 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5137 offset_a_start, offset_b_start, offset_c_start, &
5138 0, 0, first_set - 1, &
5139 sphi_a, sphi_b, sphi_c, &
5140 sgfa, sgfb, sgfc, &
5141 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5142 my_eri_method, &
5143pabc=pabc_block, &
5144force_a=force_a(ikind)%forces(:, atom_a), &
5145force_b=force_b(jkind)%forces(:, atom_b), &
5146force_c=force_c(kkind)%forces(:, atom_c), &
5147 do_symmetric=do_symmetric, &
5148 on_diagonal=iatom .EQ. jatom, &
5149
5150hadbc=hadbc, &
5151habdc=habdc, &
5152 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5153 END IF
5154 IF (PRESENT(force_a) .AND. &
5155 PRESENT(force_b) .AND. &
5156 PRESENT(force_c) .AND. &
5157 PRESENT(pabc) .AND. &
5158 PRESENT(mat_dabc) .AND. &
5159 .NOT.PRESENT(mat_adbc) .AND. &
5160 .NOT.PRESENT(mat_abdc)) THEN
5161 CALL integrate_set_3c( &
5162 param%par, potential_parameter, &
5163 la_min(iset), la_max(iset), &
5164 lb_min(jset), lb_max(jset), &
5165 lc_min(kset), lc_max(kset), &
5166 npgfa(iset), npgfb(jset), npgfc(kset), &
5167 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5168 ra, rb, rc, &
5169 habc, &
5170 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5171 offset_a_start, offset_b_start, offset_c_start, &
5172 0, 0, first_set - 1, &
5173 sphi_a, sphi_b, sphi_c, &
5174 sgfa, sgfb, sgfc, &
5175 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5176 my_eri_method, &
5177pabc=pabc_block, &
5178force_a=force_a(ikind)%forces(:, atom_a), &
5179force_b=force_b(jkind)%forces(:, atom_b), &
5180force_c=force_c(kkind)%forces(:, atom_c), &
5181 do_symmetric=do_symmetric, &
5182 on_diagonal=iatom .EQ. jatom, &
5183hdabc=hdabc, &
5184
5185
5186 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5187 END IF
5188 IF (PRESENT(force_a) .AND. &
5189 PRESENT(force_b) .AND. &
5190 PRESENT(force_c) .AND. &
5191 PRESENT(pabc) .AND. &
5192 PRESENT(mat_dabc) .AND. &
5193 .NOT.PRESENT(mat_adbc) .AND. &
5194 PRESENT(mat_abdc)) THEN
5195 CALL integrate_set_3c( &
5196 param%par, potential_parameter, &
5197 la_min(iset), la_max(iset), &
5198 lb_min(jset), lb_max(jset), &
5199 lc_min(kset), lc_max(kset), &
5200 npgfa(iset), npgfb(jset), npgfc(kset), &
5201 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5202 ra, rb, rc, &
5203 habc, &
5204 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5205 offset_a_start, offset_b_start, offset_c_start, &
5206 0, 0, first_set - 1, &
5207 sphi_a, sphi_b, sphi_c, &
5208 sgfa, sgfb, sgfc, &
5209 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5210 my_eri_method, &
5211pabc=pabc_block, &
5212force_a=force_a(ikind)%forces(:, atom_a), &
5213force_b=force_b(jkind)%forces(:, atom_b), &
5214force_c=force_c(kkind)%forces(:, atom_c), &
5215 do_symmetric=do_symmetric, &
5216 on_diagonal=iatom .EQ. jatom, &
5217hdabc=hdabc, &
5218
5219habdc=habdc, &
5220 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5221 END IF
5222 IF (PRESENT(force_a) .AND. &
5223 PRESENT(force_b) .AND. &
5224 PRESENT(force_c) .AND. &
5225 PRESENT(pabc) .AND. &
5226 PRESENT(mat_dabc) .AND. &
5227 PRESENT(mat_adbc) .AND. &
5228 .NOT.PRESENT(mat_abdc)) THEN
5229 CALL integrate_set_3c( &
5230 param%par, potential_parameter, &
5231 la_min(iset), la_max(iset), &
5232 lb_min(jset), lb_max(jset), &
5233 lc_min(kset), lc_max(kset), &
5234 npgfa(iset), npgfb(jset), npgfc(kset), &
5235 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5236 ra, rb, rc, &
5237 habc, &
5238 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5239 offset_a_start, offset_b_start, offset_c_start, &
5240 0, 0, first_set - 1, &
5241 sphi_a, sphi_b, sphi_c, &
5242 sgfa, sgfb, sgfc, &
5243 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5244 my_eri_method, &
5245pabc=pabc_block, &
5246force_a=force_a(ikind)%forces(:, atom_a), &
5247force_b=force_b(jkind)%forces(:, atom_b), &
5248force_c=force_c(kkind)%forces(:, atom_c), &
5249 do_symmetric=do_symmetric, &
5250 on_diagonal=iatom .EQ. jatom, &
5251hdabc=hdabc, &
5252hadbc=hadbc, &
5253
5254 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5255 END IF
5256 IF (PRESENT(force_a) .AND. &
5257 PRESENT(force_b) .AND. &
5258 PRESENT(force_c) .AND. &
5259 PRESENT(pabc) .AND. &
5260 PRESENT(mat_dabc) .AND. &
5261 PRESENT(mat_adbc) .AND. &
5262 PRESENT(mat_abdc)) THEN
5263 CALL integrate_set_3c( &
5264 param%par, potential_parameter, &
5265 la_min(iset), la_max(iset), &
5266 lb_min(jset), lb_max(jset), &
5267 lc_min(kset), lc_max(kset), &
5268 npgfa(iset), npgfb(jset), npgfc(kset), &
5269 zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5270 ra, rb, rc, &
5271 habc, &
5272 nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5273 offset_a_start, offset_b_start, offset_c_start, &
5274 0, 0, first_set - 1, &
5275 sphi_a, sphi_b, sphi_c, &
5276 sgfa, sgfb, sgfc, &
5277 nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5278 my_eri_method, &
5279pabc=pabc_block, &
5280force_a=force_a(ikind)%forces(:, atom_a), &
5281force_b=force_b(jkind)%forces(:, atom_b), &
5282force_c=force_c(kkind)%forces(:, atom_c), &
5283 do_symmetric=do_symmetric, &
5284 on_diagonal=iatom .EQ. jatom, &
5285hdabc=hdabc, &
5286hadbc=hadbc, &
5287habdc=habdc, &
5288 gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5289 END IF
5290 END DO
5291 END DO
5292 END DO
5293 END DO
5294
5295 IF (calculate_forces .AND. PRESENT(pabc)) DEALLOCATE (pabc_block)
5296 DO ic = 1, nc
5297 NULLIFY (munu_block)
5298 CALL dbcsr_get_block_p(matrix=mat_ab(ic)%matrix, &
5299 row=irow, col=icol, block=munu_block, found=found)
5300 cpassert(found)
5301 munu_block(:, :) = 0.0_dp
5302 IF (irow .EQ. iatom) THEN
5303 to_be_asserted = SIZE(munu_block, 1) .EQ. SIZE(habc, 1) .AND. SIZE(munu_block, 2) .EQ. SIZE(habc, 2)
5304 cpassert(to_be_asserted)
5305 munu_block(:, :) = habc(:, :, ic)
5306 ELSE
5307 to_be_asserted = SIZE(munu_block, 2) .EQ. SIZE(habc, 1) .AND. SIZE(munu_block, 1) .EQ. SIZE(habc, 2)
5308 cpassert(to_be_asserted)
5309 munu_block(:, :) = transpose(habc(:, :, ic))
5310 END IF
5311 END DO
5312 DEALLOCATE (habc)
5313 IF (calculate_forces) THEN
5314 DO ic = 1, nc
5315 DO i_xyz = 1, 3
5316 IF (PRESENT(mat_dabc)) THEN
5317 NULLIFY (munu_block)
5318 CALL dbcsr_get_block_p(matrix=mat_dabc(i_xyz, ic)%matrix, &
5319 row=irow, col=icol, block=munu_block, found=found)
5320 cpassert(found)
5321 munu_block(:, :) = 0.0_dp
5322 IF (irow .EQ. iatom) THEN
5323 munu_block(:, :) = hdabc(i_xyz, :, :, ic)
5324 ELSE
5325 munu_block(:, :) = transpose(hdabc(i_xyz, :, :, ic))
5326 END IF
5327 END IF
5328 IF (PRESENT(mat_adbc)) THEN
5329 NULLIFY (munu_block)
5330 CALL dbcsr_get_block_p(matrix=mat_adbc(i_xyz, ic)%matrix, &
5331 row=irow, col=icol, block=munu_block, found=found)
5332 cpassert(found)
5333 munu_block(:, :) = 0.0_dp
5334 IF (irow .EQ. iatom) THEN
5335 munu_block(:, :) = hadbc(i_xyz, :, :, ic)
5336 ELSE
5337 munu_block(:, :) = transpose(hadbc(i_xyz, :, :, ic))
5338 END IF
5339 END IF
5340 IF (PRESENT(mat_abdc)) THEN
5341 NULLIFY (munu_block)
5342 CALL dbcsr_get_block_p(matrix=mat_abdc(i_xyz, ic)%matrix, &
5343 row=irow, col=icol, block=munu_block, found=found)
5344 cpassert(found)
5345 munu_block(:, :) = 0.0_dp
5346 IF (irow .EQ. iatom) THEN
5347 munu_block(:, :) = habdc(i_xyz, :, :, ic)
5348 ELSE
5349 munu_block(:, :) = transpose(habdc(i_xyz, :, :, ic))
5350 END IF
5351 END IF
5352 END DO
5353 END DO
5354 IF (PRESENT(mat_dabc)) DEALLOCATE (hdabc)
5355 IF (PRESENT(mat_adbc)) DEALLOCATE (hadbc)
5356 IF (PRESENT(mat_abdc)) DEALLOCATE (habdc)
5357 END IF
5358 END DO
5359
5360 DEALLOCATE (basis_set_list_a, basis_set_list_b)
5361 CALL neighbor_list_iterator_release(nl_iterator)
5362
5363 CALL cp_eri_mme_update_local_counts(param, para_env, gg_count_3c=gg_count, gr_count_3c=gr_count, rr_count_3c=rr_count)
5364
5365 CALL timestop(handle)
5366 END SUBROUTINE mp2_eri_3c_integrate
5367
5368! **************************************************************************************************
5369!> \brief Integrate set triple and contract with sphi matrix
5370!> \param param ...
5371!> \param potential_parameter ...
5372!> \param la_min ...
5373!> \param la_max ...
5374!> \param lb_min ...
5375!> \param lb_max ...
5376!> \param lc_min ...
5377!> \param lc_max ...
5378!> \param npgfa ...
5379!> \param npgfb ...
5380!> \param npgfc ...
5381!> \param zeta ...
5382!> \param zetb ...
5383!> \param zetc ...
5384!> \param ra ...
5385!> \param rb ...
5386!> \param rc ...
5387!> \param habc ...
5388!> \param n_habc_a ...
5389!> \param n_habc_b ...
5390!> \param n_habc_c ...
5391!> \param offset_habc_a ...
5392!> \param offset_habc_b ...
5393!> \param offset_habc_c ...
5394!> \param offset_set_a ...
5395!> \param offset_set_b ...
5396!> \param offset_set_c ...
5397!> \param sphi_a ...
5398!> \param sphi_b ...
5399!> \param sphi_c ...
5400!> \param sgfa ...
5401!> \param sgfb ...
5402!> \param sgfc ...
5403!> \param nsgfa ...
5404!> \param nsgfb ...
5405!> \param nsgfc ...
5406!> \param eri_method ...
5407!> \param pabc ...
5408!> \param force_a ...
5409!> \param force_b ...
5410!> \param force_c ...
5411!> \param do_symmetric ...
5412!> \param on_diagonal ...
5413!> \param hdabc ...
5414!> \param hadbc ...
5415!> \param habdc ...
5416!> \param GG_count ...
5417!> \param GR_count ...
5418!> \param RR_count ...
5419!> \note
5420! **************************************************************************************************
5421 SUBROUTINE integrate_set_3c(param, potential_parameter, &
5422 la_min, la_max, lb_min, lb_max, lc_min, lc_max, &
5423 npgfa, npgfb, npgfc, &
5424 zeta, zetb, zetc, &
5425 ra, rb, rc, &
5426 habc, &
5427 n_habc_a, n_habc_b, n_habc_c, &
5428 offset_habc_a, offset_habc_b, offset_habc_c, &
5429 offset_set_a, offset_set_b, offset_set_c, &
5430 sphi_a, sphi_b, sphi_c, &
5431 sgfa, sgfb, sgfc, &
5432 nsgfa, nsgfb, nsgfc, &
5433 eri_method, &
5434 pabc, &
5435 force_a, force_b, force_c, &
5436 do_symmetric, on_diagonal, &
5437 hdabc, hadbc, habdc, &
5438 GG_count, GR_count, RR_count)
5439
5440 TYPE(eri_mme_param), INTENT(INOUT) :: param
5441 TYPE(libint_potential_type), INTENT(IN) :: potential_parameter
5442 INTEGER, INTENT(IN) :: la_min, la_max, lb_min, lb_max, lc_min, &
5443 lc_max, npgfa, npgfb, npgfc
5444 REAL(kind=dp), DIMENSION(npgfa), INTENT(IN) :: zeta
5445 REAL(kind=dp), DIMENSION(npgfb), INTENT(IN) :: zetb
5446 REAL(kind=dp), DIMENSION(npgfc), INTENT(IN) :: zetc
5447 REAL(kind=dp), DIMENSION(3), INTENT(IN) :: ra, rb, rc
5448 REAL(kind=dp), DIMENSION(:, :, :), INTENT(INOUT) :: habc
5449 INTEGER, INTENT(IN) :: n_habc_a, n_habc_b, n_habc_c, offset_habc_a, offset_habc_b, &
5450 offset_habc_c, offset_set_a, offset_set_b, offset_set_c
5451 REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: sphi_a, sphi_b, sphi_c
5452 INTEGER, INTENT(IN) :: sgfa, sgfb, sgfc, nsgfa, nsgfb, nsgfc, &
5453 eri_method
5454 REAL(kind=dp), DIMENSION(:, :, :), INTENT(IN), &
5455 OPTIONAL :: pabc
5456 REAL(kind=dp), DIMENSION(3), INTENT(INOUT), &
5457 OPTIONAL :: force_a, force_b, force_c
5458 LOGICAL, INTENT(IN) :: do_symmetric
5459 LOGICAL, INTENT(IN), OPTIONAL :: on_diagonal
5460 REAL(kind=dp), DIMENSION(:, :, :, :), &
5461 INTENT(OUT), OPTIONAL :: hdabc, hadbc, habdc
5462 INTEGER, INTENT(INOUT), OPTIONAL :: gg_count, gr_count, rr_count
5463
5464 CHARACTER(len=*), PARAMETER :: routinen = 'integrate_set_3c'
5465
5466 INTEGER :: ax, ay, az, bx, by, bz, cx, cy, cz, habc_a_end, habc_a_start, habc_b_end, &
5467 habc_b_start, habc_c_end, habc_c_start, handle, i_xyz, ico, icoc, icox, icoy, icoz, ipgf, &
5468 jco, jcox, jcoy, jcoz, jpgf, kco, kcox, kcoy, kcoz, kpgf, la, la_max_d, lb, &
5469 lb_max_d, lc, lc_max_d, na, nb, nc, nc_end, nc_start, ncoa, ncoa_d, ncob, &
5470 ncob_d, ncoc, ncoc_d, set_a_end, set_a_start, set_b_end, set_b_start, &
5471 set_c_end, set_c_start, sphi_a_start, sphi_b_start, sphi_c_start
5472 INTEGER, DIMENSION(3) :: la_xyz, lb_xyz
5473 LOGICAL :: calculate_forces, do_force_a, do_force_b, &
5474 do_force_c
5475 REAL(kind=dp) :: rab2, rac2, rbc2, w
5476 REAL(kind=dp), ALLOCATABLE, DIMENSION(:) :: f_work, gccc, rpgfa, rpgfb, rpgfc
5477 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: pab_hh, pab_hs, vabc
5478 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: habc_contr, habc_uncontr, &
5479 habc_uncontr_d, pabc_hhh, &
5480 pabc_hsh, pabc_hss, pabc_sss
5481 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :, :) :: habdc_contr, habdc_uncontr, hadbc_contr, &
5482 hadbc_uncontr, hdabc_contr, &
5483 hdabc_uncontr, v_work
5484
5485 CALL timeset(routinen, handle)
5486
5487 do_force_a = PRESENT(force_a) .OR. PRESENT(hdabc)
5488 do_force_b = PRESENT(force_b) .OR. PRESENT(hadbc)
5489 do_force_c = PRESENT(force_c) .OR. PRESENT(habdc)
5490 calculate_forces = do_force_a .OR. do_force_b .OR. do_force_c
5491
5492 IF (do_symmetric) THEN
5493 cpassert(PRESENT(on_diagonal))
5494 END IF
5495
5496 la_max_d = la_max
5497 lb_max_d = lb_max
5498 lc_max_d = lc_max
5499
5500 IF (calculate_forces) THEN
5501 IF (do_force_a) la_max_d = la_max + 1
5502 IF (do_force_b) lb_max_d = lb_max + 1
5503 IF (do_force_c) lc_max_d = lc_max + 1
5504 END IF
5505
5506 ncoa = npgfa*ncoset(la_max)
5507 ncob = npgfb*ncoset(lb_max)
5508 ncoc = npgfc*ncoset(lc_max)
5509
5510 ncoa_d = npgfa*ncoset(la_max_d)
5511 ncob_d = npgfb*ncoset(lb_max_d)
5512 ncoc_d = npgfc*ncoset(lc_max_d)
5513
5514 ALLOCATE (habc_uncontr_d(ncoset(la_max_d), ncoset(lb_max_d), ncoset(lc_max_d)))
5515 habc_uncontr_d(:, :, :) = 0.0_dp
5516 ALLOCATE (habc_uncontr(ncoa, ncob, ncoc)); habc_uncontr(:, :, :) = 0.0_dp
5517 IF (PRESENT(hdabc)) THEN
5518 ALLOCATE (hdabc_uncontr(3, ncoa, ncob, ncoc)); hdabc_uncontr(:, :, :, :) = 0.0_dp
5519 END IF
5520 IF (PRESENT(hadbc)) THEN
5521 ALLOCATE (hadbc_uncontr(3, ncoa, ncob, ncoc)); hadbc_uncontr(:, :, :, :) = 0.0_dp
5522 END IF
5523 IF (PRESENT(habdc)) THEN
5524 ALLOCATE (habdc_uncontr(3, ncoa, ncob, ncoc)); habdc_uncontr(:, :, :, :) = 0.0_dp
5525 END IF
5526
5527 habc_a_start = offset_habc_a + 1; habc_a_end = offset_habc_a + n_habc_a
5528 habc_b_start = offset_habc_b + 1; habc_b_end = offset_habc_b + n_habc_b
5529 habc_c_start = offset_habc_c + 1; habc_c_end = offset_habc_c + n_habc_c
5530 set_a_start = offset_set_a + 1; set_a_end = offset_set_a + n_habc_a
5531 set_b_start = offset_set_b + 1; set_b_end = offset_set_b + n_habc_b
5532 set_c_start = offset_set_c + 1; set_c_end = offset_set_c + n_habc_c
5533
5534 IF (eri_method == do_eri_mme) THEN
5535 CALL eri_mme_set_potential(param, convert_potential_type(potential_parameter%potential_type), potential_parameter%omega)
5536
5537 IF (calculate_forces .AND. PRESENT(pabc)) THEN
5538 ! uncontracted hermite-gaussian representation of density matrix
5539 sphi_a_start = sgfa - 1 + set_a_start
5540 sphi_b_start = sgfb - 1 + set_b_start
5541 sphi_c_start = sgfc - 1 + set_c_start
5542
5543 ALLOCATE (pabc_sss(n_habc_a, n_habc_b, n_habc_c))
5544 pabc_sss(:, :, :) = pabc(habc_a_start:habc_a_end, habc_b_start:habc_b_end, habc_c_start:habc_c_end)
5545 ALLOCATE (pabc_hss(ncoa, n_habc_b, n_habc_c))
5546 ALLOCATE (pabc_hsh(ncoa, n_habc_b, ncoc))
5547 ALLOCATE (pabc_hhh(ncoa, ncob, ncoc))
5548 ALLOCATE (pab_hs(ncoa, n_habc_b))
5549 ALLOCATE (pab_hh(ncoa, ncob))
5550
5551 CALL dgemm("N", "N", ncoa, n_habc_b*n_habc_c, n_habc_a, 1.0_dp, &
5552 sphi_a(:, sphi_a_start), SIZE(sphi_a, 1), pabc_sss, n_habc_a, 0.0_dp, pabc_hss, ncoa)
5553 CALL dgemm("N", "T", ncoa*n_habc_b, ncoc, n_habc_c, 1.0_dp, &
5554 pabc_hss, ncoa*n_habc_b, sphi_c(:, sphi_c_start), SIZE(sphi_c, 1), 0.0_dp, pabc_hsh, ncoa*n_habc_b)
5555
5556 DO icoc = 1, ncoc
5557 pab_hs(:, :) = pabc_hsh(:, :, icoc)
5558 CALL dgemm("N", "T", ncoa, ncob, n_habc_b, 1.0_dp, &
5559 pab_hs, ncoa, sphi_b(:, sphi_b_start), SIZE(sphi_b, 1), 0.0_dp, pab_hh, ncoa)
5560 pabc_hhh(:, :, icoc) = pab_hh(:, :)
5561 END DO
5562 END IF
5563
5564 DO ipgf = 1, npgfa
5565 na = (ipgf - 1)*ncoset(la_max)
5566 DO jpgf = 1, npgfb
5567 nb = (jpgf - 1)*ncoset(lb_max)
5568 DO kpgf = 1, npgfc
5569 nc = (kpgf - 1)*ncoset(lc_max)
5570 habc_uncontr_d(:, :, :) = 0.0_dp
5571 CALL eri_mme_3c_integrate(param, &
5572 la_min, la_max_d, lb_min, lb_max_d, lc_min, lc_max_d, &
5573 zeta(ipgf), zetb(jpgf), zetc(kpgf), ra, rb, rc, habc_uncontr_d, 0, 0, 0, &
5574 gg_count, gr_count, rr_count)
5575
5576 habc_uncontr(na + 1:na + ncoset(la_max), nb + 1:nb + ncoset(lb_max), nc + 1:nc + ncoset(lc_max)) = &
5577 habc_uncontr_d(:ncoset(la_max), :ncoset(lb_max), :ncoset(lc_max))
5578
5579 IF (calculate_forces) THEN
5580 DO lc = lc_min, lc_max
5581 DO cx = 0, lc
5582 DO cy = 0, lc - cx
5583 cz = lc - cx - cy
5584 kco = coset(cx, cy, cz)
5585 kcox = coset(cx + 1, cy, cz)
5586 kcoy = coset(cx, cy + 1, cz)
5587 kcoz = coset(cx, cy, cz + 1)
5588 DO lb = lb_min, lb_max
5589 DO bx = 0, lb
5590 DO by = 0, lb - bx
5591 bz = lb - bx - by
5592 jco = coset(bx, by, bz)
5593 jcox = coset(bx + 1, by, bz)
5594 jcoy = coset(bx, by + 1, bz)
5595 jcoz = coset(bx, by, bz + 1)
5596 DO la = la_min, la_max
5597 DO ax = 0, la
5598 DO ay = 0, la - ax
5599 az = la - ax - ay
5600 la_xyz = [ax, ay, az]
5601 lb_xyz = [bx, by, bz]
5602 ico = coset(ax, ay, az)
5603 icox = coset(ax + 1, ay, az)
5604 icoy = coset(ax, ay + 1, az)
5605 icoz = coset(ax, ay, az + 1)
5606
5607 w = 1.0_dp
5608 IF (do_symmetric .AND. .NOT. on_diagonal) w = 2.0_dp
5609
5610 IF (PRESENT(force_a)) THEN
5611 force_a = force_a + 2.0_dp*w*zeta(ipgf)* &
5612 [pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(icox, jco, kco), &
5613 pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(icoy, jco, kco), &
5614 pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(icoz, jco, kco)]
5615
5616 END IF
5617 IF (PRESENT(force_b)) THEN
5618 force_b = force_b + 2.0_dp*w*zetb(jpgf)* &
5619 [pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jcox, kco), &
5620 pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jcoy, kco), &
5621 pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jcoz, kco)]
5622 END IF
5623 IF (PRESENT(force_c)) THEN
5624 force_c = force_c + 2.0_dp*w*zetc(kpgf)* &
5625 [pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jco, kcox), &
5626 pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jco, kcoy), &
5627 pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jco, kcoz)]
5628 END IF
5629
5630 IF (PRESENT(hdabc)) THEN
5631 hdabc_uncontr(1:3, na + ico, nb + jco, nc + kco) = 2.0_dp*zeta(ipgf)* &
5632 [habc_uncontr_d(icox, jco, kco), &
5633 habc_uncontr_d(icoy, jco, kco), &
5634 habc_uncontr_d(icoz, jco, kco)]
5635 END IF
5636 IF (PRESENT(hadbc)) THEN
5637 hadbc_uncontr(1:3, na + ico, nb + jco, nc + kco) = 2.0_dp*zetb(jpgf)* &
5638 [habc_uncontr_d(ico, jcox, kco), &
5639 habc_uncontr_d(ico, jcoy, kco), &
5640 habc_uncontr_d(ico, jcoz, kco)]
5641 END IF
5642 IF (PRESENT(habdc)) THEN
5643 habdc_uncontr(1:3, na + ico, nb + jco, nc + kco) = 2.0_dp*zetc(kpgf)* &
5644 [habc_uncontr_d(ico, jco, kcox), &
5645 habc_uncontr_d(ico, jco, kcoy), &
5646 habc_uncontr_d(ico, jco, kcoz)]
5647 END IF
5648 END DO
5649 END DO
5650 END DO
5651 END DO
5652 END DO
5653 END DO
5654 END DO
5655 END DO
5656 END DO
5657 END IF
5658
5659 END DO
5660 END DO
5661 END DO
5662
5663 ELSE IF (eri_method == do_eri_os) THEN
5664
5665 IF (calculate_forces) cpabort("NYI")
5666
5667 ALLOCATE (f_work(0:la_max + lb_max + lc_max + 2))
5668 f_work(:) = 0.0_dp
5669 ALLOCATE (v_work(ncoa, ncob, ncoc, la_max + lb_max + lc_max + 1))
5670 v_work(:, :, :, :) = 0.0_dp
5671 ! no screening
5672 ALLOCATE (rpgfa(npgfa))
5673 ALLOCATE (rpgfb(npgfb))
5674 ALLOCATE (rpgfc(npgfc))
5675 rpgfa(:) = 1.0e10_dp
5676 rpgfb(:) = 1.0e10_dp
5677 rpgfc(:) = 1.0e10_dp
5678 ALLOCATE (gccc(ncoc))
5679 gccc(:) = 0.0_dp
5680 ALLOCATE (vabc(ncoa, ncob))
5681 vabc(:, :) = 0.0_dp
5682 rab2 = (rb(1) - ra(1))**2 + (rb(2) - ra(2))**2 + (rb(3) - ra(3))**2
5683 rac2 = (rc(1) - ra(1))**2 + (rc(2) - ra(2))**2 + (rc(3) - ra(3))**2
5684 rbc2 = (rc(1) - rb(1))**2 + (rc(2) - rb(2))**2 + (rc(3) - rb(3))**2
5685
5686 ! in the RI basis, there is only a single primitive Gaussian
5687 kpgf = 1
5688
5689 ! ncoset is indexed by -1,..., ,5
5690 ! e.g. for pure s: lc_min = lc_max = 0, nc_start = 1
5691 nc_start = ncoset(lc_min - 1) + 1
5692 nc_end = ncoset(lc_max)
5693
5694 CALL coulomb3(la_max, npgfa, zeta(:), rpgfa(:), la_min, &
5695 lb_max, npgfb, zetb(:), rpgfb(:), lb_min, &
5696 lc_max, zetc(kpgf), rpgfc(kpgf), lc_min, &
5697 gccc, rb - ra, rab2, rc - ra, rac2, rbc2, &
5698 vabc, habc_uncontr(:, :, nc_start:nc_end), v_work, f_work)
5699
5700 DEALLOCATE (v_work, f_work, rpgfa, rpgfb, rpgfc, gccc, vabc)
5701
5702 ELSE IF (eri_method == do_eri_gpw) THEN
5703
5704 cpabort("GPW not enabled in the ERI interface.")
5705
5706 END IF
5707
5708 ALLOCATE (habc_contr(nsgfa, nsgfb, nsgfc))
5709 IF (PRESENT(hdabc)) THEN
5710 ALLOCATE (hdabc_contr(3, nsgfa, nsgfb, nsgfc))
5711 END IF
5712 IF (PRESENT(hadbc)) THEN
5713 ALLOCATE (hadbc_contr(3, nsgfa, nsgfb, nsgfc))
5714 END IF
5715 IF (PRESENT(habdc)) THEN
5716 ALLOCATE (habdc_contr(3, nsgfa, nsgfb, nsgfc))
5717 END IF
5718
5719 CALL abc_contract(habc_contr, habc_uncontr, &
5720 sphi_a(:, sgfa:), sphi_b(:, sgfb:), sphi_c(:, sgfc:), &
5721 ncoa, ncob, ncoc, nsgfa, nsgfb, nsgfc)
5722
5723 IF (calculate_forces) THEN
5724 DO i_xyz = 1, 3
5725 IF (PRESENT(hdabc)) THEN
5726 CALL abc_contract(hdabc_contr(i_xyz, :, :, :), hdabc_uncontr(i_xyz, :, :, :), &
5727 sphi_a(:, sgfa:), sphi_b(:, sgfb:), sphi_c(:, sgfc:), &
5728 ncoa, ncob, ncoc, nsgfa, nsgfb, nsgfc)
5729 END IF
5730 IF (PRESENT(hadbc)) THEN
5731 CALL abc_contract(hadbc_contr(i_xyz, :, :, :), hadbc_uncontr(i_xyz, :, :, :), &
5732 sphi_a(:, sgfa:), sphi_b(:, sgfb:), sphi_c(:, sgfc:), &
5733 ncoa, ncob, ncoc, nsgfa, nsgfb, nsgfc)
5734 END IF
5735 IF (PRESENT(habdc)) THEN
5736 CALL abc_contract(habdc_contr(i_xyz, :, :, :), habdc_uncontr(i_xyz, :, :, :), &
5737 sphi_a(:, sgfa:), sphi_b(:, sgfb:), sphi_c(:, sgfc:), &
5738 ncoa, ncob, ncoc, nsgfa, nsgfb, nsgfc)
5739 END IF
5740 END DO
5741 END IF
5742
5743 habc(habc_a_start:habc_a_end, habc_b_start:habc_b_end, habc_c_start:habc_c_end) = &
5744 habc_contr(set_a_start:set_a_end, set_b_start:set_b_end, set_c_start:set_c_end)
5745
5746 IF (calculate_forces) THEN
5747 IF (PRESENT(hdabc)) hdabc(:, habc_a_start:habc_a_end, habc_b_start:habc_b_end, habc_c_start:habc_c_end) = &
5748 hdabc_contr(:, set_a_start:set_a_end, set_b_start:set_b_end, set_c_start:set_c_end)
5749 IF (PRESENT(hadbc)) hadbc(:, habc_a_start:habc_a_end, habc_b_start:habc_b_end, habc_c_start:habc_c_end) = &
5750 hadbc_contr(:, set_a_start:set_a_end, set_b_start:set_b_end, set_c_start:set_c_end)
5751 IF (PRESENT(habdc)) habdc(:, habc_a_start:habc_a_end, habc_b_start:habc_b_end, habc_c_start:habc_c_end) = &
5752 habdc_contr(:, set_a_start:set_a_end, set_b_start:set_b_end, set_c_start:set_c_end)
5753 END IF
5754
5755 CALL timestop(handle)
5756
5757 END SUBROUTINE integrate_set_3c
5758
5759! **************************************************************************************************
5760!> \brief get pointer to atom, pointer to set and offset in a set for each spherical orbital of a
5761!> basis.
5762!> \param qs_env ...
5763!> \param basis_type ...
5764!> \param eri_offsets (:,1) atom numbers
5765!> (:,2) set numbers
5766!> (:,3) set offsets
5767! **************************************************************************************************
5768 SUBROUTINE get_eri_offsets(qs_env, basis_type, eri_offsets)
5769 TYPE(qs_environment_type), INTENT(IN), POINTER :: qs_env
5770 CHARACTER(len=*), INTENT(IN), OPTIONAL :: basis_type
5771 INTEGER, ALLOCATABLE, DIMENSION(:, :), INTENT(OUT) :: eri_offsets
5772
5773 INTEGER :: dimen_basis, iatom, ikind, iset, isgf, &
5774 natom, nkind, nset, nsgf, offset, &
5775 set_offset
5776 INTEGER, ALLOCATABLE, DIMENSION(:) :: kind_of
5777 INTEGER, DIMENSION(:), POINTER :: nsgf_set
5778 TYPE(atomic_kind_type), DIMENSION(:), POINTER :: atomic_kind_set
5779 TYPE(gto_basis_set_type), POINTER :: basis_set
5780 TYPE(particle_type), DIMENSION(:), POINTER :: particle_set
5781 TYPE(qs_kind_type), DIMENSION(:), POINTER :: qs_kind_set
5782
5783 CALL get_qs_env(qs_env, atomic_kind_set=atomic_kind_set, qs_kind_set=qs_kind_set, &
5784 particle_set=particle_set, natom=natom, nkind=nkind)
5785
5786 CALL get_atomic_kind_set(atomic_kind_set, kind_of=kind_of)
5787
5788 dimen_basis = 0
5789 DO iatom = 1, natom
5790 ikind = kind_of(iatom)
5791 CALL get_qs_kind(qs_kind=qs_kind_set(ikind), nsgf=nsgf, basis_type=basis_type)
5792 dimen_basis = dimen_basis + nsgf
5793 END DO
5794
5795 ALLOCATE (eri_offsets(dimen_basis, 3))
5796
5797 offset = 0
5798 DO iatom = 1, natom
5799 ikind = kind_of(iatom)
5800 CALL get_qs_kind(qs_kind=qs_kind_set(ikind), basis_set=basis_set, basis_type=basis_type)
5801 nset = basis_set%nset
5802 nsgf_set => basis_set%nsgf_set
5803 DO iset = 1, nset
5804 set_offset = 0
5805 DO isgf = 1, nsgf_set(iset)
5806 set_offset = set_offset + 1
5807 eri_offsets(offset + set_offset, :) = [iatom, iset, set_offset]
5808 END DO
5809 offset = offset + nsgf_set(iset)
5810 END DO
5811 END DO
5812 END SUBROUTINE get_eri_offsets
5813
5814! **************************************************************************************************
5815!> \brief ...
5816!> \param force ...
5817!> \param natom_of_kind ...
5818! **************************************************************************************************
5819 PURE SUBROUTINE mp2_eri_allocate_forces(force, natom_of_kind)
5820 TYPE(mp2_eri_force), ALLOCATABLE, &
5821 DIMENSION(:), INTENT(OUT) :: force
5822 INTEGER, DIMENSION(:), INTENT(IN) :: natom_of_kind
5823
5824 INTEGER :: ikind, n, nkind
5825
5826 nkind = SIZE(natom_of_kind)
5827
5828 ALLOCATE (force(nkind))
5829
5830 DO ikind = 1, nkind
5831 n = natom_of_kind(ikind)
5832 ALLOCATE (force(ikind)%forces(3, n))
5833 force(ikind)%forces(:, :) = 0.0_dp
5834 END DO
5835 END SUBROUTINE mp2_eri_allocate_forces
5836
5837! **************************************************************************************************
5838!> \brief ...
5839!> \param force ...
5840! **************************************************************************************************
5841 PURE SUBROUTINE mp2_eri_deallocate_forces(force)
5842 TYPE(mp2_eri_force), ALLOCATABLE, &
5843 DIMENSION(:), INTENT(INOUT) :: force
5844
5845 INTEGER :: ikind, nkind
5846
5847 IF (ALLOCATED(force)) THEN
5848 nkind = SIZE(force)
5849 DO ikind = 1, nkind
5850 IF (ALLOCATED(force(ikind)%forces)) DEALLOCATE (force(ikind)%forces)
5851 END DO
5852
5853 DEALLOCATE (force)
5854 END IF
5855 END SUBROUTINE mp2_eri_deallocate_forces
5856
5857 FUNCTION convert_potential_type(potential_type) RESULT(res)
5858 INTEGER, INTENT(IN) :: potential_type
5859 INTEGER :: res
5860
5861 IF (potential_type == do_potential_coulomb) THEN
5862 res = eri_mme_coulomb
5863 ELSE IF (potential_type == do_potential_long) THEN
5864 res = eri_mme_longrange
5865 ELSE
5866 cpabort("MME potential not implemented!")
5867 END IF
5868
5869 END FUNCTION convert_potential_type
5870
5871END MODULE mp2_eri
modulo
static GRID_HOST_DEVICE int modulo(int a, int m)
Equivalent of Fortran's MODULO, which always return a positive number. https://gcc....
Definition grid_common.h:120
dgemm
static void dgemm(const char transa, const char transb, const int m, const int n, const int k, const double alpha, const double *a, const int lda, const double *b, const int ldb, const double beta, double *c, const int ldc)
Convenient wrapper to hide Fortran nature of dgemm_, swapping a and b.
Definition grid_cpu_task_list.c:206
cell_types::pbc
Definition cell_types.F:92
cp_eri_mme_interface::cp_eri_mme_set_params
Definition cp_eri_mme_interface.F:74
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:105
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_coulomb
Calculation of Coulomb integrals over Cartesian Gaussian-type functions (electron repulsion integrals...
Definition ai_coulomb.F:41
ai_coulomb::coulomb3
subroutine, public coulomb3(la_max, npgfa, zeta, rpgfa, la_min, lb_max, npgfb, zetb, rpgfb, lb_min, lc_max, zetc, rpgfc, lc_min, gccc, rab, rab2, rac, rac2, rbc2, vabc, int_abc, v, f, maxder, vabc_plus)
Calculation of the primitive three-center Coulomb integrals over Cartesian Gaussian-type functions (e...
Definition ai_coulomb.F:798
ai_coulomb::coulomb2_new
subroutine, public coulomb2_new(la_max, npgfa, zeta, la_min, lc_max, npgfc, zetc, lc_min, rac, rac2, vac, v, f, maxder, vac_plus)
Calculation of the primitive two-center Coulomb integrals over Cartesian Gaussian-type functions....
Definition ai_coulomb.F:441
atomic_kind_types
Define the atomic kind types and their sub types.
Definition atomic_kind_types.F:23
atomic_kind_types::get_atomic_kind_set
subroutine, public get_atomic_kind_set(atomic_kind_set, atom_of_kind, kind_of, natom_of_kind, maxatom, natom, nshell, fist_potential_present, shell_present, shell_adiabatic, shell_check_distance, damping_present)
Get attributes of an atomic kind set.
Definition atomic_kind_types.F:223
basis_set_types
Definition basis_set_types.F:15
cell_types
Handles all functions related to the CELL.
Definition cell_types.F:15
cp_dbcsr_api
Definition cp_dbcsr_api.F:8
cp_dbcsr_api::dbcsr_get_block_p
subroutine, public dbcsr_get_block_p(matrix, row, col, block, found, row_size, col_size)
...
Definition cp_dbcsr_api.F:679
cp_eri_mme_interface
Interface to Minimax-Ewald method for periodic ERI's to be used in CP2K.
Definition cp_eri_mme_interface.F:12
cp_eri_mme_interface::cp_eri_mme_init_read_input
subroutine, public cp_eri_mme_init_read_input(mme_section, param)
Read input and initialize parameter type.
Definition cp_eri_mme_interface.F:249
cp_eri_mme_interface::cp_eri_mme_finalize
subroutine, public cp_eri_mme_finalize(param)
Release eri mme data. Prints some statistics on summation methods chosen.
Definition cp_eri_mme_interface.F:304
cp_eri_mme_interface::cp_eri_mme_update_local_counts
subroutine, public cp_eri_mme_update_local_counts(param, para_env, g_count_2c, r_count_2c, gg_count_3c, gr_count_3c, rr_count_3c)
Update local counters to gather statistics on different paths taken in MME algorithm (each Ewald sum ...
Definition cp_eri_mme_interface.F:714
eri_mme_integrate
Minimax-Ewald (MME) method for calculating 2-center and 3-center electron repulsion integrals (ERI) o...
Definition eri_mme_integrate.F:23
eri_mme_integrate::eri_mme_3c_integrate
subroutine, public eri_mme_3c_integrate(param, la_min, la_max, lb_min, lb_max, lc_min, lc_max, zeta, zetb, zetc, ra, rb, rc, habc, o1, o2, o3, gg_count, gr_count, rr_count)
Low-level integration routine for 3-center ERIs.
Definition eri_mme_integrate.F:274
eri_mme_integrate::eri_mme_2c_integrate
subroutine, public eri_mme_2c_integrate(param, la_min, la_max, lb_min, lb_max, zeta, zetb, rab, hab, o1, o2, g_count, r_count, normalize, potential, pot_par)
Low-level integration routine for 2-center ERIs.
Definition eri_mme_integrate.F:72
eri_mme_test
Methods for testing / debugging.
Definition eri_mme_test.F:14
eri_mme_test::eri_mme_3c_perf_acc_test
subroutine, public eri_mme_3c_perf_acc_test(param, l_max, zet, rabc, nrep, nsample, para_env, iw, potential, pot_par, gg_count, gr_count, rr_count)
...
Definition eri_mme_test.F:187
eri_mme_test::eri_mme_2c_perf_acc_test
subroutine, public eri_mme_2c_perf_acc_test(param, l_max, zet, rabc, nrep, test_accuracy, para_env, iw, potential, pot_par, g_count, r_count)
Unit test for performance and accuracy.
Definition eri_mme_test.F:60
eri_mme_types
Types and initialization / release routines for Minimax-Ewald method for electron repulsion integrals...
Definition eri_mme_types.F:16
eri_mme_types::eri_mme_set_potential
subroutine, public eri_mme_set_potential(param, potential, pot_par)
...
Definition eri_mme_types.F:262
input_constants
collects all constants needed in input so that they can be used without circular dependencies
Definition input_constants.F:17
input_constants::do_eri_os
integer, parameter, public do_eri_os
Definition input_constants.F:1255
input_constants::do_eri_mme
integer, parameter, public do_eri_mme
Definition input_constants.F:1255
input_constants::do_potential_coulomb
integer, parameter, public do_potential_coulomb
Definition input_constants.F:808
input_constants::do_potential_long
integer, parameter, public do_potential_long
Definition input_constants.F:808
input_constants::do_eri_gpw
integer, parameter, public do_eri_gpw
Definition input_constants.F:1255
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_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:731
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:1047
kinds
Defines the basic variable types.
Definition kinds.F:23
kinds::dp
integer, parameter, public dp
Definition kinds.F:34
libint_2c_3c
2- and 3-center electron repulsion integral routines based on libint2 Currently available operators: ...
Definition libint_2c_3c.F:14
message_passing
Interface to the message passing library MPI.
Definition message_passing.F:23
mp2_eri
Interface to direct methods for electron repulsion integrals for MP2.
Definition mp2_eri.F:12
mp2_eri::mp2_eri_2c_integrate
subroutine, public mp2_eri_2c_integrate(param, potential_parameter, para_env, qs_env, basis_type_a, basis_type_b, hab, first_b, last_b, eri_method, pab, force_a, force_b, hdab, hadb, reflection_z_a, reflection_z_b, do_reflection_a, do_reflection_b)
high-level integration routine for 2c integrals over CP2K basis sets. Contiguous column-wise distribu...
Definition mp2_eri.F:115
mp2_eri::mp2_eri_3c_integrate
subroutine, public mp2_eri_3c_integrate(param, potential_parameter, para_env, qs_env, first_c, last_c, mat_ab, basis_type_a, basis_type_b, basis_type_c, sab_nl, eri_method, pabc, force_a, force_b, force_c, mat_dabc, mat_adbc, mat_abdc)
high-level integration routine for 3c integrals (ab|c) over CP2K basis sets. For each local function ...
Definition mp2_eri.F:680
mp2_eri::integrate_set_2c
subroutine, public integrate_set_2c(param, potential_parameter, la_min, la_max, lb_min, lb_max, npgfa, npgfb, zeta, zetb, ra, rb, hab, n_hab_a, n_hab_b, offset_hab_a, offset_hab_b, offset_set_a, offset_set_b, sphi_a, sphi_b, sgfa, sgfb, nsgfa, nsgfb, eri_method, pab, force_a, force_b, hdab, hadb, g_count, r_count, do_reflection_a, do_reflection_b)
Integrate set pair and contract with sphi matrix.
Definition mp2_eri.F:426
mp2_eri::convert_potential_type
integer function, public convert_potential_type(potential_type)
Definition mp2_eri.F:5858
mp2_eri::mp2_eri_deallocate_forces
pure subroutine, public mp2_eri_deallocate_forces(force)
...
Definition mp2_eri.F:5842
mp2_eri::mp2_eri_allocate_forces
pure subroutine, public mp2_eri_allocate_forces(force, natom_of_kind)
...
Definition mp2_eri.F:5820
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_pointers::ncoset
integer, dimension(:), allocatable, public ncoset
Definition orbital_pointers.F:42
orbital_pointers::coset
integer, dimension(:, :, :), allocatable, public coset
Definition orbital_pointers.F:45
particle_types
Define the data structure for the particle information.
Definition particle_types.F:19
qs_environment_types
Definition qs_environment_types.F:14
qs_environment_types::get_qs_env
subroutine, public get_qs_env(qs_env, atomic_kind_set, qs_kind_set, cell, super_cell, cell_ref, use_ref_cell, kpoints, dft_control, mos, sab_orb, sab_all, qmmm, qmmm_periodic, sac_ae, sac_ppl, sac_lri, sap_ppnl, sab_vdw, sab_scp, sap_oce, sab_lrc, sab_se, sab_xtbe, sab_tbe, sab_core, sab_xb, sab_xtb_pp, sab_xtb_nonbond, sab_almo, sab_kp, sab_kp_nosym, particle_set, energy, force, matrix_h, matrix_h_im, matrix_ks, matrix_ks_im, matrix_vxc, run_rtp, rtp, matrix_h_kp, matrix_h_im_kp, matrix_ks_kp, matrix_ks_im_kp, matrix_vxc_kp, kinetic_kp, matrix_s_kp, matrix_w_kp, matrix_s_ri_aux_kp, matrix_s, matrix_s_ri_aux, matrix_w, matrix_p_mp2, matrix_p_mp2_admm, rho, rho_xc, pw_env, ewald_env, ewald_pw, active_space, mpools, input, para_env, blacs_env, scf_control, rel_control, kinetic, qs_charges, vppl, rho_core, rho_nlcc, rho_nlcc_g, ks_env, ks_qmmm_env, wf_history, scf_env, local_particles, local_molecules, distribution_2d, dbcsr_dist, molecule_kind_set, molecule_set, subsys, cp_subsys, oce, local_rho_set, rho_atom_set, task_list, task_list_soft, rho0_atom_set, rho0_mpole, rhoz_set, ecoul_1c, rho0_s_rs, rho0_s_gs, do_kpoints, has_unit_metric, requires_mo_derivs, mo_derivs, mo_loc_history, nkind, natom, nelectron_total, nelectron_spin, efield, neighbor_list_id, linres_control, xas_env, virial, cp_ddapc_env, cp_ddapc_ewald, outer_scf_history, outer_scf_ihistory, x_data, et_coupling, dftb_potential, results, se_taper, se_store_int_env, se_nddo_mpole, se_nonbond_env, admm_env, lri_env, lri_density, exstate_env, ec_env, harris_env, dispersion_env, gcp_env, vee, rho_external, external_vxc, mask, mp2_env, bs_env, kg_env, wanniercentres, atprop, ls_scf_env, do_transport, transport_env, v_hartree_rspace, s_mstruct_changed, rho_changed, potential_changed, forces_up_to_date, mscfg_env, almo_scf_env, gradient_history, variable_history, embed_pot, spin_embed_pot, polar_env, mos_last_converged, eeq, rhs, tb_tblite)
Get the QUICKSTEP environment.
Definition qs_environment_types.F:518
qs_integral_utils
Some utility functions for the calculation of integrals.
Definition qs_integral_utils.F:14
qs_integral_utils::basis_set_list_setup
subroutine, public basis_set_list_setup(basis_set_list, basis_type, qs_kind_set)
Set up an easy accessible list of the basis sets for all kinds.
Definition qs_integral_utils.F:149
qs_kind_types
Define the quickstep kind type and their sub types.
Definition qs_kind_types.F:23
qs_kind_types::get_qs_kind
subroutine, public get_qs_kind(qs_kind, basis_set, basis_type, ncgf, nsgf, all_potential, tnadd_potential, gth_potential, sgp_potential, upf_potential, se_parameter, dftb_parameter, xtb_parameter, dftb3_param, zatom, zeff, elec_conf, mao, lmax_dftb, alpha_core_charge, ccore_charge, core_charge, core_charge_radius, paw_proj_set, paw_atom, hard_radius, hard0_radius, max_rad_local, covalent_radius, vdw_radius, gpw_type_forced, harmonics, max_iso_not0, max_s_harm, grid_atom, ngrid_ang, ngrid_rad, lmax_rho0, dft_plus_u_atom, l_of_dft_plus_u, n_of_dft_plus_u, u_minus_j, u_of_dft_plus_u, j_of_dft_plus_u, alpha_of_dft_plus_u, beta_of_dft_plus_u, j0_of_dft_plus_u, occupation_of_dft_plus_u, dispersion, bs_occupation, magnetization, no_optimize, addel, laddel, naddel, orbitals, max_scf, eps_scf, smear, u_ramping, u_minus_j_target, eps_u_ramping, init_u_ramping_each_scf, reltmat, ghost, floating, name, element_symbol, pao_basis_size, pao_model_file, pao_potentials, pao_descriptors, nelec)
Get attributes of an atomic kind.
Definition qs_kind_types.F:454
qs_neighbor_list_types
Define the neighbor list data types and the corresponding functionality.
Definition qs_neighbor_list_types.F:17
qs_neighbor_list_types::neighbor_list_iterator_create
subroutine, public neighbor_list_iterator_create(iterator_set, nl, search, nthread)
Neighbor list iterator functions.
Definition qs_neighbor_list_types.F:165
qs_neighbor_list_types::neighbor_list_iterator_release
subroutine, public neighbor_list_iterator_release(iterator_set)
...
Definition qs_neighbor_list_types.F:251
qs_neighbor_list_types::get_neighbor_list_set_p
subroutine, public get_neighbor_list_set_p(neighbor_list_sets, nlist, symmetric)
Return the components of the first neighbor list set.
Definition qs_neighbor_list_types.F:993
qs_neighbor_list_types::neighbor_list_iterate
integer function, public neighbor_list_iterate(iterator_set, mepos)
...
Definition qs_neighbor_list_types.F:351
qs_neighbor_list_types::get_iterator_info
subroutine, public get_iterator_info(iterator_set, mepos, ikind, jkind, nkind, ilist, nlist, inode, nnode, iatom, jatom, r, cell)
...
Definition qs_neighbor_list_types.F:549
util
All kind of helpful little routines.
Definition util.F:14
util::get_limit
pure integer function, dimension(2), public get_limit(m, n, me)
divide m entries into n parts, return size of part me
Definition util.F:333
atomic_kind_types::atomic_kind_type
Provides all information about an atomic kind.
Definition atomic_kind_types.F:45
basis_set_types::gto_basis_set_p_type
Definition basis_set_types.F:94
basis_set_types::gto_basis_set_type
Definition basis_set_types.F:72
cell_types::cell_type
Type defining parameters related to the simulation cell.
Definition cell_types.F:55
cp_dbcsr_api::dbcsr_p_type
Definition cp_dbcsr_api.F:170
cp_eri_mme_interface::cp_eri_mme_param
Definition cp_eri_mme_interface.F:79
eri_mme_types::eri_mme_param
Definition eri_mme_types.F:63
input_section_types::section_vals_type
stores the values of a section
Definition input_section_types.F:127
libint_2c_3c::libint_potential_type
Definition libint_2c_3c.F:66
message_passing::mp_para_env_type
stores all the informations relevant to an mpi environment
Definition message_passing.F:763
mp2_eri::mp2_eri_force
Definition mp2_eri.F:83
particle_types::particle_type
Definition particle_types.F:35
qs_environment_types::qs_environment_type
Definition qs_environment_types.F:219
qs_kind_types::qs_kind_type
Provides all information about a quickstep kind.
Definition qs_kind_types.F:171
qs_neighbor_list_types::neighbor_list_iterator_p_type
Definition qs_neighbor_list_types.F:117
qs_neighbor_list_types::neighbor_list_set_p_type
Definition qs_neighbor_list_types.F:67