(git:e7e05ae)
mp2_eri.F
Go to the documentation of this file.
1 !--------------------------------------------------------------------------------------------------!
2 ! CP2K: A general program to perform molecular dynamics simulations !
3 ! Copyright 2000-2024 CP2K developers group <https://cp2k.org> !
4 ! !
5 ! SPDX-License-Identifier: GPL-2.0-or-later !
6 !--------------------------------------------------------------------------------------------------!
7 
8 ! **************************************************************************************************
9 !> \brief Interface to direct methods for electron repulsion integrals for MP2.
10 ! **************************************************************************************************
11 
12 MODULE 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 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 
87 CONTAINS
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 
313 force_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, &
335 force_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, &
358 force_a=force_a(ikind)%forces(:, atom_a), &
359 force_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  IF (.NOT. ASSOCIATED(basis_set_a)) cycle
806  basis_set_b => basis_set_list_b(jkind)%gto_basis_set
807  IF (.NOT. ASSOCIATED(basis_set_b)) cycle
808  atom_a = atom_of_kind(iatom)
809  atom_b = atom_of_kind(jatom)
810 
811  first_sgfa => basis_set_a%first_sgf
812  la_max => basis_set_a%lmax
813  la_min => basis_set_a%lmin
814  npgfa => basis_set_a%npgf
815  nseta = basis_set_a%nset
816  nsgfa => basis_set_a%nsgf_set
817  set_radius_a => basis_set_a%set_radius
818  sphi_a => basis_set_a%sphi
819  zeta => basis_set_a%zet
820  na = sum(nsgfa)
821 
822  ra(:) = pbc(particle_set(iatom)%r, cell)
823 
824  ! basis jkind
825  first_sgfb => basis_set_b%first_sgf
826  lb_max => basis_set_b%lmax
827  lb_min => basis_set_b%lmin
828  npgfb => basis_set_b%npgf
829  nsetb = basis_set_b%nset
830  nsgfb => basis_set_b%nsgf_set
831  rpgfb => basis_set_b%pgf_radius
832  set_radius_b => basis_set_b%set_radius
833  sphi_b => basis_set_b%sphi
834  zetb => basis_set_b%zet
835  nb = sum(nsgfb)
836 
837  rb(:) = pbc(particle_set(jatom)%r, cell)
838 
839  IF (do_symmetric) THEN
840  IF (iatom <= jatom) THEN
841  irow = iatom
842  icol = jatom
843  ELSE
844  irow = jatom
845  icol = iatom
846  END IF
847  ELSE
848  irow = iatom
849  icol = jatom
850  END IF
851 
852  ALLOCATE (habc(na, nb, nc))
853  habc(:, :, :) = 0.0_dp ! needs to be initialized due to screening
854  IF (PRESENT(mat_dabc)) THEN
855  ALLOCATE (hdabc(3, na, nb, nc))
856  hdabc(:, :, :, :) = 0.0_dp
857  END IF
858  IF (PRESENT(mat_adbc)) THEN
859  ALLOCATE (hadbc(3, na, nb, nc))
860  hadbc(:, :, :, :) = 0.0_dp
861  END IF
862  IF (PRESENT(mat_abdc)) THEN
863  ALLOCATE (habdc(3, na, nb, nc))
864  habdc(:, :, :, :) = 0.0_dp
865  END IF
866 
867  IF (calculate_forces .AND. PRESENT(pabc)) THEN
868  ALLOCATE (pabc_block(na, nb, nc))
869  DO ic = 1, nc
870  NULLIFY (pab_block)
871  CALL dbcsr_get_block_p(matrix=pabc(ic)%matrix, &
872  row=irow, col=icol, block=pab_block, found=found)
873  cpassert(found)
874  IF (irow .EQ. iatom) THEN
875  to_be_asserted = SIZE(pab_block, 1) .EQ. SIZE(pabc_block, 1) .AND. SIZE(pab_block, 2) .EQ. SIZE(pabc_block, 2)
876  cpassert(to_be_asserted)
877  pabc_block(:, :, ic) = pab_block(:, :)
878  ELSE
879  to_be_asserted = SIZE(pab_block, 2) .EQ. SIZE(pabc_block, 1) .AND. SIZE(pab_block, 1) .EQ. SIZE(pabc_block, 2)
880  cpassert(to_be_asserted)
881  pabc_block(:, :, ic) = transpose(pab_block(:, :))
882  END IF
883  END DO
884  END IF
885 
886  rab(:) = pbc(rab, cell)
887  dab = sqrt(rab(1)**2 + rab(2)**2 + rab(3)**2)
888 
889  offset_a_end = 0
890  DO iset = 1, nseta
891  offset_a_start = offset_a_end
892  offset_a_end = offset_a_end + nsgfa(iset)
893  sgfa = first_sgfa(1, iset)
894 
895  offset_b_end = 0
896  DO jset = 1, nsetb
897  offset_b_start = offset_b_end
898  offset_b_end = offset_b_end + nsgfb(jset)
899 
900  sgfb = first_sgfb(1, jset)
901 
902  ! Screening
903  IF (set_radius_a(iset) + set_radius_b(jset) < dab) cycle
904 
905  offset_c_end = 0
906  DO katom = atom_start, atom_end
907 
908  atom_c = atom_of_kind(katom)
909 
910  kkind = kind_of(katom)
911  CALL get_qs_kind(qs_kind=qs_kind_set(kkind), basis_set=basis_set_c, basis_type=basis_type_c)
912  first_sgfc => basis_set_c%first_sgf
913  lc_max => basis_set_c%lmax
914  lc_min => basis_set_c%lmin
915  nsetc = basis_set_c%nset
916  nsgfc => basis_set_c%nsgf_set
917  sphi_c => basis_set_c%sphi
918  zetc => basis_set_c%zet
919  npgfc => basis_set_c%npgf
920 
921  rc(:) = pbc(particle_set(katom)%r, cell)
922 
923  kset_start = 1; kset_end = nsetc
924  IF (katom == atom_start) kset_start = set_start
925  IF (katom == atom_end) kset_end = set_end
926 
927  DO kset = kset_start, kset_end
928  first_set = 1; last_set = nsgfc(kset)
929  IF (kset == kset_start .AND. katom == atom_start) first_set = set_offset_start
930  IF (kset == kset_end .AND. katom == atom_end) last_set = set_offset_end
931 
932  offset_c_start = offset_c_end
933  offset_c_end = offset_c_end + last_set + 1 - first_set
934  sgfc = first_sgfc(1, kset)
935 
936  IF (.NOT.PRESENT(force_a) .AND. &
937  .NOT.PRESENT(force_b) .AND. &
938  .NOT.PRESENT(force_c) .AND. &
939  .NOT.PRESENT(pabc) .AND. &
940  .NOT.PRESENT(mat_dabc) .AND. &
941  .NOT.PRESENT(mat_adbc) .AND. &
942  .NOT.PRESENT(mat_abdc)) THEN
943  CALL integrate_set_3c( &
944  param%par, potential_parameter, &
945  la_min(iset), la_max(iset), &
946  lb_min(jset), lb_max(jset), &
947  lc_min(kset), lc_max(kset), &
948  npgfa(iset), npgfb(jset), npgfc(kset), &
949  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
950  ra, rb, rc, &
951  habc, &
952  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
953  offset_a_start, offset_b_start, offset_c_start, &
954  0, 0, first_set - 1, &
955  sphi_a, sphi_b, sphi_c, &
956  sgfa, sgfb, sgfc, &
957  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
958  my_eri_method, &
959 
960 
961 
962 
963  do_symmetric=do_symmetric, &
964  on_diagonal=iatom .EQ. jatom, &
965 
966 
967 
968  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
969  END IF
970  IF (.NOT.PRESENT(force_a) .AND. &
971  .NOT.PRESENT(force_b) .AND. &
972  .NOT.PRESENT(force_c) .AND. &
973  .NOT.PRESENT(pabc) .AND. &
974  .NOT.PRESENT(mat_dabc) .AND. &
975  .NOT.PRESENT(mat_adbc) .AND. &
976  PRESENT(mat_abdc)) THEN
977  CALL integrate_set_3c( &
978  param%par, potential_parameter, &
979  la_min(iset), la_max(iset), &
980  lb_min(jset), lb_max(jset), &
981  lc_min(kset), lc_max(kset), &
982  npgfa(iset), npgfb(jset), npgfc(kset), &
983  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
984  ra, rb, rc, &
985  habc, &
986  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
987  offset_a_start, offset_b_start, offset_c_start, &
988  0, 0, first_set - 1, &
989  sphi_a, sphi_b, sphi_c, &
990  sgfa, sgfb, sgfc, &
991  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
992  my_eri_method, &
993 
994 
995 
996 
997  do_symmetric=do_symmetric, &
998  on_diagonal=iatom .EQ. jatom, &
999 
1000 
1001 habdc=habdc, &
1002  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1003  END IF
1004  IF (.NOT.PRESENT(force_a) .AND. &
1005  .NOT.PRESENT(force_b) .AND. &
1006  .NOT.PRESENT(force_c) .AND. &
1007  .NOT.PRESENT(pabc) .AND. &
1008  .NOT.PRESENT(mat_dabc) .AND. &
1009  PRESENT(mat_adbc) .AND. &
1010  .NOT.PRESENT(mat_abdc)) THEN
1011  CALL integrate_set_3c( &
1012  param%par, potential_parameter, &
1013  la_min(iset), la_max(iset), &
1014  lb_min(jset), lb_max(jset), &
1015  lc_min(kset), lc_max(kset), &
1016  npgfa(iset), npgfb(jset), npgfc(kset), &
1017  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1018  ra, rb, rc, &
1019  habc, &
1020  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1021  offset_a_start, offset_b_start, offset_c_start, &
1022  0, 0, first_set - 1, &
1023  sphi_a, sphi_b, sphi_c, &
1024  sgfa, sgfb, sgfc, &
1025  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1026  my_eri_method, &
1027 
1028 
1029 
1030 
1031  do_symmetric=do_symmetric, &
1032  on_diagonal=iatom .EQ. jatom, &
1033 
1034 hadbc=hadbc, &
1035 
1036  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1037  END IF
1038  IF (.NOT.PRESENT(force_a) .AND. &
1039  .NOT.PRESENT(force_b) .AND. &
1040  .NOT.PRESENT(force_c) .AND. &
1041  .NOT.PRESENT(pabc) .AND. &
1042  .NOT.PRESENT(mat_dabc) .AND. &
1043  PRESENT(mat_adbc) .AND. &
1044  PRESENT(mat_abdc)) THEN
1045  CALL integrate_set_3c( &
1046  param%par, potential_parameter, &
1047  la_min(iset), la_max(iset), &
1048  lb_min(jset), lb_max(jset), &
1049  lc_min(kset), lc_max(kset), &
1050  npgfa(iset), npgfb(jset), npgfc(kset), &
1051  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1052  ra, rb, rc, &
1053  habc, &
1054  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1055  offset_a_start, offset_b_start, offset_c_start, &
1056  0, 0, first_set - 1, &
1057  sphi_a, sphi_b, sphi_c, &
1058  sgfa, sgfb, sgfc, &
1059  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1060  my_eri_method, &
1061 
1062 
1063 
1064 
1065  do_symmetric=do_symmetric, &
1066  on_diagonal=iatom .EQ. jatom, &
1067 
1068 hadbc=hadbc, &
1069 habdc=habdc, &
1070  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1071  END IF
1072  IF (.NOT.PRESENT(force_a) .AND. &
1073  .NOT.PRESENT(force_b) .AND. &
1074  .NOT.PRESENT(force_c) .AND. &
1075  .NOT.PRESENT(pabc) .AND. &
1076  PRESENT(mat_dabc) .AND. &
1077  .NOT.PRESENT(mat_adbc) .AND. &
1078  .NOT.PRESENT(mat_abdc)) THEN
1079  CALL integrate_set_3c( &
1080  param%par, potential_parameter, &
1081  la_min(iset), la_max(iset), &
1082  lb_min(jset), lb_max(jset), &
1083  lc_min(kset), lc_max(kset), &
1084  npgfa(iset), npgfb(jset), npgfc(kset), &
1085  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1086  ra, rb, rc, &
1087  habc, &
1088  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1089  offset_a_start, offset_b_start, offset_c_start, &
1090  0, 0, first_set - 1, &
1091  sphi_a, sphi_b, sphi_c, &
1092  sgfa, sgfb, sgfc, &
1093  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1094  my_eri_method, &
1095 
1096 
1097 
1098 
1099  do_symmetric=do_symmetric, &
1100  on_diagonal=iatom .EQ. jatom, &
1101 hdabc=hdabc, &
1102 
1103 
1104  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1105  END IF
1106  IF (.NOT.PRESENT(force_a) .AND. &
1107  .NOT.PRESENT(force_b) .AND. &
1108  .NOT.PRESENT(force_c) .AND. &
1109  .NOT.PRESENT(pabc) .AND. &
1110  PRESENT(mat_dabc) .AND. &
1111  .NOT.PRESENT(mat_adbc) .AND. &
1112  PRESENT(mat_abdc)) THEN
1113  CALL integrate_set_3c( &
1114  param%par, potential_parameter, &
1115  la_min(iset), la_max(iset), &
1116  lb_min(jset), lb_max(jset), &
1117  lc_min(kset), lc_max(kset), &
1118  npgfa(iset), npgfb(jset), npgfc(kset), &
1119  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1120  ra, rb, rc, &
1121  habc, &
1122  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1123  offset_a_start, offset_b_start, offset_c_start, &
1124  0, 0, first_set - 1, &
1125  sphi_a, sphi_b, sphi_c, &
1126  sgfa, sgfb, sgfc, &
1127  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1128  my_eri_method, &
1129 
1130 
1131 
1132 
1133  do_symmetric=do_symmetric, &
1134  on_diagonal=iatom .EQ. jatom, &
1135 hdabc=hdabc, &
1136 
1137 habdc=habdc, &
1138  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1139  END IF
1140  IF (.NOT.PRESENT(force_a) .AND. &
1141  .NOT.PRESENT(force_b) .AND. &
1142  .NOT.PRESENT(force_c) .AND. &
1143  .NOT.PRESENT(pabc) .AND. &
1144  PRESENT(mat_dabc) .AND. &
1145  PRESENT(mat_adbc) .AND. &
1146  .NOT.PRESENT(mat_abdc)) THEN
1147  CALL integrate_set_3c( &
1148  param%par, potential_parameter, &
1149  la_min(iset), la_max(iset), &
1150  lb_min(jset), lb_max(jset), &
1151  lc_min(kset), lc_max(kset), &
1152  npgfa(iset), npgfb(jset), npgfc(kset), &
1153  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1154  ra, rb, rc, &
1155  habc, &
1156  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1157  offset_a_start, offset_b_start, offset_c_start, &
1158  0, 0, first_set - 1, &
1159  sphi_a, sphi_b, sphi_c, &
1160  sgfa, sgfb, sgfc, &
1161  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1162  my_eri_method, &
1163 
1164 
1165 
1166 
1167  do_symmetric=do_symmetric, &
1168  on_diagonal=iatom .EQ. jatom, &
1169 hdabc=hdabc, &
1170 hadbc=hadbc, &
1171 
1172  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1173  END IF
1174  IF (.NOT.PRESENT(force_a) .AND. &
1175  .NOT.PRESENT(force_b) .AND. &
1176  .NOT.PRESENT(force_c) .AND. &
1177  .NOT.PRESENT(pabc) .AND. &
1178  PRESENT(mat_dabc) .AND. &
1179  PRESENT(mat_adbc) .AND. &
1180  PRESENT(mat_abdc)) THEN
1181  CALL integrate_set_3c( &
1182  param%par, potential_parameter, &
1183  la_min(iset), la_max(iset), &
1184  lb_min(jset), lb_max(jset), &
1185  lc_min(kset), lc_max(kset), &
1186  npgfa(iset), npgfb(jset), npgfc(kset), &
1187  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1188  ra, rb, rc, &
1189  habc, &
1190  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1191  offset_a_start, offset_b_start, offset_c_start, &
1192  0, 0, first_set - 1, &
1193  sphi_a, sphi_b, sphi_c, &
1194  sgfa, sgfb, sgfc, &
1195  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1196  my_eri_method, &
1197 
1198 
1199 
1200 
1201  do_symmetric=do_symmetric, &
1202  on_diagonal=iatom .EQ. jatom, &
1203 hdabc=hdabc, &
1204 hadbc=hadbc, &
1205 habdc=habdc, &
1206  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1207  END IF
1208  IF (.NOT.PRESENT(force_a) .AND. &
1209  .NOT.PRESENT(force_b) .AND. &
1210  PRESENT(force_c) .AND. &
1211  .NOT.PRESENT(pabc) .AND. &
1212  .NOT.PRESENT(mat_dabc) .AND. &
1213  .NOT.PRESENT(mat_adbc) .AND. &
1214  .NOT.PRESENT(mat_abdc)) THEN
1215  CALL integrate_set_3c( &
1216  param%par, potential_parameter, &
1217  la_min(iset), la_max(iset), &
1218  lb_min(jset), lb_max(jset), &
1219  lc_min(kset), lc_max(kset), &
1220  npgfa(iset), npgfb(jset), npgfc(kset), &
1221  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1222  ra, rb, rc, &
1223  habc, &
1224  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1225  offset_a_start, offset_b_start, offset_c_start, &
1226  0, 0, first_set - 1, &
1227  sphi_a, sphi_b, sphi_c, &
1228  sgfa, sgfb, sgfc, &
1229  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1230  my_eri_method, &
1231 
1232 
1233 
1234 force_c=force_c(kkind)%forces(:, atom_c), &
1235  do_symmetric=do_symmetric, &
1236  on_diagonal=iatom .EQ. jatom, &
1237 
1238 
1239 
1240  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1241  END IF
1242  IF (.NOT.PRESENT(force_a) .AND. &
1243  .NOT.PRESENT(force_b) .AND. &
1244  PRESENT(force_c) .AND. &
1245  .NOT.PRESENT(pabc) .AND. &
1246  .NOT.PRESENT(mat_dabc) .AND. &
1247  .NOT.PRESENT(mat_adbc) .AND. &
1248  PRESENT(mat_abdc)) THEN
1249  CALL integrate_set_3c( &
1250  param%par, potential_parameter, &
1251  la_min(iset), la_max(iset), &
1252  lb_min(jset), lb_max(jset), &
1253  lc_min(kset), lc_max(kset), &
1254  npgfa(iset), npgfb(jset), npgfc(kset), &
1255  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1256  ra, rb, rc, &
1257  habc, &
1258  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1259  offset_a_start, offset_b_start, offset_c_start, &
1260  0, 0, first_set - 1, &
1261  sphi_a, sphi_b, sphi_c, &
1262  sgfa, sgfb, sgfc, &
1263  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1264  my_eri_method, &
1265 
1266 
1267 
1268 force_c=force_c(kkind)%forces(:, atom_c), &
1269  do_symmetric=do_symmetric, &
1270  on_diagonal=iatom .EQ. jatom, &
1271 
1272 
1273 habdc=habdc, &
1274  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1275  END IF
1276  IF (.NOT.PRESENT(force_a) .AND. &
1277  .NOT.PRESENT(force_b) .AND. &
1278  PRESENT(force_c) .AND. &
1279  .NOT.PRESENT(pabc) .AND. &
1280  .NOT.PRESENT(mat_dabc) .AND. &
1281  PRESENT(mat_adbc) .AND. &
1282  .NOT.PRESENT(mat_abdc)) THEN
1283  CALL integrate_set_3c( &
1284  param%par, potential_parameter, &
1285  la_min(iset), la_max(iset), &
1286  lb_min(jset), lb_max(jset), &
1287  lc_min(kset), lc_max(kset), &
1288  npgfa(iset), npgfb(jset), npgfc(kset), &
1289  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1290  ra, rb, rc, &
1291  habc, &
1292  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1293  offset_a_start, offset_b_start, offset_c_start, &
1294  0, 0, first_set - 1, &
1295  sphi_a, sphi_b, sphi_c, &
1296  sgfa, sgfb, sgfc, &
1297  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1298  my_eri_method, &
1299 
1300 
1301 
1302 force_c=force_c(kkind)%forces(:, atom_c), &
1303  do_symmetric=do_symmetric, &
1304  on_diagonal=iatom .EQ. jatom, &
1305 
1306 hadbc=hadbc, &
1307 
1308  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1309  END IF
1310  IF (.NOT.PRESENT(force_a) .AND. &
1311  .NOT.PRESENT(force_b) .AND. &
1312  PRESENT(force_c) .AND. &
1313  .NOT.PRESENT(pabc) .AND. &
1314  .NOT.PRESENT(mat_dabc) .AND. &
1315  PRESENT(mat_adbc) .AND. &
1316  PRESENT(mat_abdc)) THEN
1317  CALL integrate_set_3c( &
1318  param%par, potential_parameter, &
1319  la_min(iset), la_max(iset), &
1320  lb_min(jset), lb_max(jset), &
1321  lc_min(kset), lc_max(kset), &
1322  npgfa(iset), npgfb(jset), npgfc(kset), &
1323  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1324  ra, rb, rc, &
1325  habc, &
1326  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1327  offset_a_start, offset_b_start, offset_c_start, &
1328  0, 0, first_set - 1, &
1329  sphi_a, sphi_b, sphi_c, &
1330  sgfa, sgfb, sgfc, &
1331  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1332  my_eri_method, &
1333 
1334 
1335 
1336 force_c=force_c(kkind)%forces(:, atom_c), &
1337  do_symmetric=do_symmetric, &
1338  on_diagonal=iatom .EQ. jatom, &
1339 
1340 hadbc=hadbc, &
1341 habdc=habdc, &
1342  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1343  END IF
1344  IF (.NOT.PRESENT(force_a) .AND. &
1345  .NOT.PRESENT(force_b) .AND. &
1346  PRESENT(force_c) .AND. &
1347  .NOT.PRESENT(pabc) .AND. &
1348  PRESENT(mat_dabc) .AND. &
1349  .NOT.PRESENT(mat_adbc) .AND. &
1350  .NOT.PRESENT(mat_abdc)) THEN
1351  CALL integrate_set_3c( &
1352  param%par, potential_parameter, &
1353  la_min(iset), la_max(iset), &
1354  lb_min(jset), lb_max(jset), &
1355  lc_min(kset), lc_max(kset), &
1356  npgfa(iset), npgfb(jset), npgfc(kset), &
1357  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1358  ra, rb, rc, &
1359  habc, &
1360  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1361  offset_a_start, offset_b_start, offset_c_start, &
1362  0, 0, first_set - 1, &
1363  sphi_a, sphi_b, sphi_c, &
1364  sgfa, sgfb, sgfc, &
1365  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1366  my_eri_method, &
1367 
1368 
1369 
1370 force_c=force_c(kkind)%forces(:, atom_c), &
1371  do_symmetric=do_symmetric, &
1372  on_diagonal=iatom .EQ. jatom, &
1373 hdabc=hdabc, &
1374 
1375 
1376  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1377  END IF
1378  IF (.NOT.PRESENT(force_a) .AND. &
1379  .NOT.PRESENT(force_b) .AND. &
1380  PRESENT(force_c) .AND. &
1381  .NOT.PRESENT(pabc) .AND. &
1382  PRESENT(mat_dabc) .AND. &
1383  .NOT.PRESENT(mat_adbc) .AND. &
1384  PRESENT(mat_abdc)) THEN
1385  CALL integrate_set_3c( &
1386  param%par, potential_parameter, &
1387  la_min(iset), la_max(iset), &
1388  lb_min(jset), lb_max(jset), &
1389  lc_min(kset), lc_max(kset), &
1390  npgfa(iset), npgfb(jset), npgfc(kset), &
1391  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1392  ra, rb, rc, &
1393  habc, &
1394  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1395  offset_a_start, offset_b_start, offset_c_start, &
1396  0, 0, first_set - 1, &
1397  sphi_a, sphi_b, sphi_c, &
1398  sgfa, sgfb, sgfc, &
1399  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1400  my_eri_method, &
1401 
1402 
1403 
1404 force_c=force_c(kkind)%forces(:, atom_c), &
1405  do_symmetric=do_symmetric, &
1406  on_diagonal=iatom .EQ. jatom, &
1407 hdabc=hdabc, &
1408 
1409 habdc=habdc, &
1410  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1411  END IF
1412  IF (.NOT.PRESENT(force_a) .AND. &
1413  .NOT.PRESENT(force_b) .AND. &
1414  PRESENT(force_c) .AND. &
1415  .NOT.PRESENT(pabc) .AND. &
1416  PRESENT(mat_dabc) .AND. &
1417  PRESENT(mat_adbc) .AND. &
1418  .NOT.PRESENT(mat_abdc)) THEN
1419  CALL integrate_set_3c( &
1420  param%par, potential_parameter, &
1421  la_min(iset), la_max(iset), &
1422  lb_min(jset), lb_max(jset), &
1423  lc_min(kset), lc_max(kset), &
1424  npgfa(iset), npgfb(jset), npgfc(kset), &
1425  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1426  ra, rb, rc, &
1427  habc, &
1428  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1429  offset_a_start, offset_b_start, offset_c_start, &
1430  0, 0, first_set - 1, &
1431  sphi_a, sphi_b, sphi_c, &
1432  sgfa, sgfb, sgfc, &
1433  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1434  my_eri_method, &
1435 
1436 
1437 
1438 force_c=force_c(kkind)%forces(:, atom_c), &
1439  do_symmetric=do_symmetric, &
1440  on_diagonal=iatom .EQ. jatom, &
1441 hdabc=hdabc, &
1442 hadbc=hadbc, &
1443 
1444  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1445  END IF
1446  IF (.NOT.PRESENT(force_a) .AND. &
1447  .NOT.PRESENT(force_b) .AND. &
1448  PRESENT(force_c) .AND. &
1449  .NOT.PRESENT(pabc) .AND. &
1450  PRESENT(mat_dabc) .AND. &
1451  PRESENT(mat_adbc) .AND. &
1452  PRESENT(mat_abdc)) THEN
1453  CALL integrate_set_3c( &
1454  param%par, potential_parameter, &
1455  la_min(iset), la_max(iset), &
1456  lb_min(jset), lb_max(jset), &
1457  lc_min(kset), lc_max(kset), &
1458  npgfa(iset), npgfb(jset), npgfc(kset), &
1459  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1460  ra, rb, rc, &
1461  habc, &
1462  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1463  offset_a_start, offset_b_start, offset_c_start, &
1464  0, 0, first_set - 1, &
1465  sphi_a, sphi_b, sphi_c, &
1466  sgfa, sgfb, sgfc, &
1467  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1468  my_eri_method, &
1469 
1470 
1471 
1472 force_c=force_c(kkind)%forces(:, atom_c), &
1473  do_symmetric=do_symmetric, &
1474  on_diagonal=iatom .EQ. jatom, &
1475 hdabc=hdabc, &
1476 hadbc=hadbc, &
1477 habdc=habdc, &
1478  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1479  END IF
1480  IF (.NOT.PRESENT(force_a) .AND. &
1481  PRESENT(force_b) .AND. &
1482  .NOT.PRESENT(force_c) .AND. &
1483  .NOT.PRESENT(pabc) .AND. &
1484  .NOT.PRESENT(mat_dabc) .AND. &
1485  .NOT.PRESENT(mat_adbc) .AND. &
1486  .NOT.PRESENT(mat_abdc)) THEN
1487  CALL integrate_set_3c( &
1488  param%par, potential_parameter, &
1489  la_min(iset), la_max(iset), &
1490  lb_min(jset), lb_max(jset), &
1491  lc_min(kset), lc_max(kset), &
1492  npgfa(iset), npgfb(jset), npgfc(kset), &
1493  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1494  ra, rb, rc, &
1495  habc, &
1496  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1497  offset_a_start, offset_b_start, offset_c_start, &
1498  0, 0, first_set - 1, &
1499  sphi_a, sphi_b, sphi_c, &
1500  sgfa, sgfb, sgfc, &
1501  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1502  my_eri_method, &
1503 
1504 
1505 force_b=force_b(jkind)%forces(:, atom_b), &
1506 
1507  do_symmetric=do_symmetric, &
1508  on_diagonal=iatom .EQ. jatom, &
1509 
1510 
1511 
1512  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1513  END IF
1514  IF (.NOT.PRESENT(force_a) .AND. &
1515  PRESENT(force_b) .AND. &
1516  .NOT.PRESENT(force_c) .AND. &
1517  .NOT.PRESENT(pabc) .AND. &
1518  .NOT.PRESENT(mat_dabc) .AND. &
1519  .NOT.PRESENT(mat_adbc) .AND. &
1520  PRESENT(mat_abdc)) THEN
1521  CALL integrate_set_3c( &
1522  param%par, potential_parameter, &
1523  la_min(iset), la_max(iset), &
1524  lb_min(jset), lb_max(jset), &
1525  lc_min(kset), lc_max(kset), &
1526  npgfa(iset), npgfb(jset), npgfc(kset), &
1527  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1528  ra, rb, rc, &
1529  habc, &
1530  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1531  offset_a_start, offset_b_start, offset_c_start, &
1532  0, 0, first_set - 1, &
1533  sphi_a, sphi_b, sphi_c, &
1534  sgfa, sgfb, sgfc, &
1535  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1536  my_eri_method, &
1537 
1538 
1539 force_b=force_b(jkind)%forces(:, atom_b), &
1540 
1541  do_symmetric=do_symmetric, &
1542  on_diagonal=iatom .EQ. jatom, &
1543 
1544 
1545 habdc=habdc, &
1546  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1547  END IF
1548  IF (.NOT.PRESENT(force_a) .AND. &
1549  PRESENT(force_b) .AND. &
1550  .NOT.PRESENT(force_c) .AND. &
1551  .NOT.PRESENT(pabc) .AND. &
1552  .NOT.PRESENT(mat_dabc) .AND. &
1553  PRESENT(mat_adbc) .AND. &
1554  .NOT.PRESENT(mat_abdc)) THEN
1555  CALL integrate_set_3c( &
1556  param%par, potential_parameter, &
1557  la_min(iset), la_max(iset), &
1558  lb_min(jset), lb_max(jset), &
1559  lc_min(kset), lc_max(kset), &
1560  npgfa(iset), npgfb(jset), npgfc(kset), &
1561  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1562  ra, rb, rc, &
1563  habc, &
1564  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1565  offset_a_start, offset_b_start, offset_c_start, &
1566  0, 0, first_set - 1, &
1567  sphi_a, sphi_b, sphi_c, &
1568  sgfa, sgfb, sgfc, &
1569  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1570  my_eri_method, &
1571 
1572 
1573 force_b=force_b(jkind)%forces(:, atom_b), &
1574 
1575  do_symmetric=do_symmetric, &
1576  on_diagonal=iatom .EQ. jatom, &
1577 
1578 hadbc=hadbc, &
1579 
1580  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1581  END IF
1582  IF (.NOT.PRESENT(force_a) .AND. &
1583  PRESENT(force_b) .AND. &
1584  .NOT.PRESENT(force_c) .AND. &
1585  .NOT.PRESENT(pabc) .AND. &
1586  .NOT.PRESENT(mat_dabc) .AND. &
1587  PRESENT(mat_adbc) .AND. &
1588  PRESENT(mat_abdc)) THEN
1589  CALL integrate_set_3c( &
1590  param%par, potential_parameter, &
1591  la_min(iset), la_max(iset), &
1592  lb_min(jset), lb_max(jset), &
1593  lc_min(kset), lc_max(kset), &
1594  npgfa(iset), npgfb(jset), npgfc(kset), &
1595  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1596  ra, rb, rc, &
1597  habc, &
1598  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1599  offset_a_start, offset_b_start, offset_c_start, &
1600  0, 0, first_set - 1, &
1601  sphi_a, sphi_b, sphi_c, &
1602  sgfa, sgfb, sgfc, &
1603  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1604  my_eri_method, &
1605 
1606 
1607 force_b=force_b(jkind)%forces(:, atom_b), &
1608 
1609  do_symmetric=do_symmetric, &
1610  on_diagonal=iatom .EQ. jatom, &
1611 
1612 hadbc=hadbc, &
1613 habdc=habdc, &
1614  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1615  END IF
1616  IF (.NOT.PRESENT(force_a) .AND. &
1617  PRESENT(force_b) .AND. &
1618  .NOT.PRESENT(force_c) .AND. &
1619  .NOT.PRESENT(pabc) .AND. &
1620  PRESENT(mat_dabc) .AND. &
1621  .NOT.PRESENT(mat_adbc) .AND. &
1622  .NOT.PRESENT(mat_abdc)) THEN
1623  CALL integrate_set_3c( &
1624  param%par, potential_parameter, &
1625  la_min(iset), la_max(iset), &
1626  lb_min(jset), lb_max(jset), &
1627  lc_min(kset), lc_max(kset), &
1628  npgfa(iset), npgfb(jset), npgfc(kset), &
1629  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1630  ra, rb, rc, &
1631  habc, &
1632  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1633  offset_a_start, offset_b_start, offset_c_start, &
1634  0, 0, first_set - 1, &
1635  sphi_a, sphi_b, sphi_c, &
1636  sgfa, sgfb, sgfc, &
1637  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1638  my_eri_method, &
1639 
1640 
1641 force_b=force_b(jkind)%forces(:, atom_b), &
1642 
1643  do_symmetric=do_symmetric, &
1644  on_diagonal=iatom .EQ. jatom, &
1645 hdabc=hdabc, &
1646 
1647 
1648  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1649  END IF
1650  IF (.NOT.PRESENT(force_a) .AND. &
1651  PRESENT(force_b) .AND. &
1652  .NOT.PRESENT(force_c) .AND. &
1653  .NOT.PRESENT(pabc) .AND. &
1654  PRESENT(mat_dabc) .AND. &
1655  .NOT.PRESENT(mat_adbc) .AND. &
1656  PRESENT(mat_abdc)) THEN
1657  CALL integrate_set_3c( &
1658  param%par, potential_parameter, &
1659  la_min(iset), la_max(iset), &
1660  lb_min(jset), lb_max(jset), &
1661  lc_min(kset), lc_max(kset), &
1662  npgfa(iset), npgfb(jset), npgfc(kset), &
1663  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1664  ra, rb, rc, &
1665  habc, &
1666  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1667  offset_a_start, offset_b_start, offset_c_start, &
1668  0, 0, first_set - 1, &
1669  sphi_a, sphi_b, sphi_c, &
1670  sgfa, sgfb, sgfc, &
1671  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1672  my_eri_method, &
1673 
1674 
1675 force_b=force_b(jkind)%forces(:, atom_b), &
1676 
1677  do_symmetric=do_symmetric, &
1678  on_diagonal=iatom .EQ. jatom, &
1679 hdabc=hdabc, &
1680 
1681 habdc=habdc, &
1682  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1683  END IF
1684  IF (.NOT.PRESENT(force_a) .AND. &
1685  PRESENT(force_b) .AND. &
1686  .NOT.PRESENT(force_c) .AND. &
1687  .NOT.PRESENT(pabc) .AND. &
1688  PRESENT(mat_dabc) .AND. &
1689  PRESENT(mat_adbc) .AND. &
1690  .NOT.PRESENT(mat_abdc)) THEN
1691  CALL integrate_set_3c( &
1692  param%par, potential_parameter, &
1693  la_min(iset), la_max(iset), &
1694  lb_min(jset), lb_max(jset), &
1695  lc_min(kset), lc_max(kset), &
1696  npgfa(iset), npgfb(jset), npgfc(kset), &
1697  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1698  ra, rb, rc, &
1699  habc, &
1700  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1701  offset_a_start, offset_b_start, offset_c_start, &
1702  0, 0, first_set - 1, &
1703  sphi_a, sphi_b, sphi_c, &
1704  sgfa, sgfb, sgfc, &
1705  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1706  my_eri_method, &
1707 
1708 
1709 force_b=force_b(jkind)%forces(:, atom_b), &
1710 
1711  do_symmetric=do_symmetric, &
1712  on_diagonal=iatom .EQ. jatom, &
1713 hdabc=hdabc, &
1714 hadbc=hadbc, &
1715 
1716  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1717  END IF
1718  IF (.NOT.PRESENT(force_a) .AND. &
1719  PRESENT(force_b) .AND. &
1720  .NOT.PRESENT(force_c) .AND. &
1721  .NOT.PRESENT(pabc) .AND. &
1722  PRESENT(mat_dabc) .AND. &
1723  PRESENT(mat_adbc) .AND. &
1724  PRESENT(mat_abdc)) THEN
1725  CALL integrate_set_3c( &
1726  param%par, potential_parameter, &
1727  la_min(iset), la_max(iset), &
1728  lb_min(jset), lb_max(jset), &
1729  lc_min(kset), lc_max(kset), &
1730  npgfa(iset), npgfb(jset), npgfc(kset), &
1731  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1732  ra, rb, rc, &
1733  habc, &
1734  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1735  offset_a_start, offset_b_start, offset_c_start, &
1736  0, 0, first_set - 1, &
1737  sphi_a, sphi_b, sphi_c, &
1738  sgfa, sgfb, sgfc, &
1739  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1740  my_eri_method, &
1741 
1742 
1743 force_b=force_b(jkind)%forces(:, atom_b), &
1744 
1745  do_symmetric=do_symmetric, &
1746  on_diagonal=iatom .EQ. jatom, &
1747 hdabc=hdabc, &
1748 hadbc=hadbc, &
1749 habdc=habdc, &
1750  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1751  END IF
1752  IF (.NOT.PRESENT(force_a) .AND. &
1753  PRESENT(force_b) .AND. &
1754  PRESENT(force_c) .AND. &
1755  .NOT.PRESENT(pabc) .AND. &
1756  .NOT.PRESENT(mat_dabc) .AND. &
1757  .NOT.PRESENT(mat_adbc) .AND. &
1758  .NOT.PRESENT(mat_abdc)) THEN
1759  CALL integrate_set_3c( &
1760  param%par, potential_parameter, &
1761  la_min(iset), la_max(iset), &
1762  lb_min(jset), lb_max(jset), &
1763  lc_min(kset), lc_max(kset), &
1764  npgfa(iset), npgfb(jset), npgfc(kset), &
1765  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1766  ra, rb, rc, &
1767  habc, &
1768  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1769  offset_a_start, offset_b_start, offset_c_start, &
1770  0, 0, first_set - 1, &
1771  sphi_a, sphi_b, sphi_c, &
1772  sgfa, sgfb, sgfc, &
1773  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1774  my_eri_method, &
1775 
1776 
1777 force_b=force_b(jkind)%forces(:, atom_b), &
1778 force_c=force_c(kkind)%forces(:, atom_c), &
1779  do_symmetric=do_symmetric, &
1780  on_diagonal=iatom .EQ. jatom, &
1781 
1782 
1783 
1784  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1785  END IF
1786  IF (.NOT.PRESENT(force_a) .AND. &
1787  PRESENT(force_b) .AND. &
1788  PRESENT(force_c) .AND. &
1789  .NOT.PRESENT(pabc) .AND. &
1790  .NOT.PRESENT(mat_dabc) .AND. &
1791  .NOT.PRESENT(mat_adbc) .AND. &
1792  PRESENT(mat_abdc)) THEN
1793  CALL integrate_set_3c( &
1794  param%par, potential_parameter, &
1795  la_min(iset), la_max(iset), &
1796  lb_min(jset), lb_max(jset), &
1797  lc_min(kset), lc_max(kset), &
1798  npgfa(iset), npgfb(jset), npgfc(kset), &
1799  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1800  ra, rb, rc, &
1801  habc, &
1802  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1803  offset_a_start, offset_b_start, offset_c_start, &
1804  0, 0, first_set - 1, &
1805  sphi_a, sphi_b, sphi_c, &
1806  sgfa, sgfb, sgfc, &
1807  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1808  my_eri_method, &
1809 
1810 
1811 force_b=force_b(jkind)%forces(:, atom_b), &
1812 force_c=force_c(kkind)%forces(:, atom_c), &
1813  do_symmetric=do_symmetric, &
1814  on_diagonal=iatom .EQ. jatom, &
1815 
1816 
1817 habdc=habdc, &
1818  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1819  END IF
1820  IF (.NOT.PRESENT(force_a) .AND. &
1821  PRESENT(force_b) .AND. &
1822  PRESENT(force_c) .AND. &
1823  .NOT.PRESENT(pabc) .AND. &
1824  .NOT.PRESENT(mat_dabc) .AND. &
1825  PRESENT(mat_adbc) .AND. &
1826  .NOT.PRESENT(mat_abdc)) THEN
1827  CALL integrate_set_3c( &
1828  param%par, potential_parameter, &
1829  la_min(iset), la_max(iset), &
1830  lb_min(jset), lb_max(jset), &
1831  lc_min(kset), lc_max(kset), &
1832  npgfa(iset), npgfb(jset), npgfc(kset), &
1833  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1834  ra, rb, rc, &
1835  habc, &
1836  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1837  offset_a_start, offset_b_start, offset_c_start, &
1838  0, 0, first_set - 1, &
1839  sphi_a, sphi_b, sphi_c, &
1840  sgfa, sgfb, sgfc, &
1841  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1842  my_eri_method, &
1843 
1844 
1845 force_b=force_b(jkind)%forces(:, atom_b), &
1846 force_c=force_c(kkind)%forces(:, atom_c), &
1847  do_symmetric=do_symmetric, &
1848  on_diagonal=iatom .EQ. jatom, &
1849 
1850 hadbc=hadbc, &
1851 
1852  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1853  END IF
1854  IF (.NOT.PRESENT(force_a) .AND. &
1855  PRESENT(force_b) .AND. &
1856  PRESENT(force_c) .AND. &
1857  .NOT.PRESENT(pabc) .AND. &
1858  .NOT.PRESENT(mat_dabc) .AND. &
1859  PRESENT(mat_adbc) .AND. &
1860  PRESENT(mat_abdc)) THEN
1861  CALL integrate_set_3c( &
1862  param%par, potential_parameter, &
1863  la_min(iset), la_max(iset), &
1864  lb_min(jset), lb_max(jset), &
1865  lc_min(kset), lc_max(kset), &
1866  npgfa(iset), npgfb(jset), npgfc(kset), &
1867  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1868  ra, rb, rc, &
1869  habc, &
1870  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1871  offset_a_start, offset_b_start, offset_c_start, &
1872  0, 0, first_set - 1, &
1873  sphi_a, sphi_b, sphi_c, &
1874  sgfa, sgfb, sgfc, &
1875  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1876  my_eri_method, &
1877 
1878 
1879 force_b=force_b(jkind)%forces(:, atom_b), &
1880 force_c=force_c(kkind)%forces(:, atom_c), &
1881  do_symmetric=do_symmetric, &
1882  on_diagonal=iatom .EQ. jatom, &
1883 
1884 hadbc=hadbc, &
1885 habdc=habdc, &
1886  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1887  END IF
1888  IF (.NOT.PRESENT(force_a) .AND. &
1889  PRESENT(force_b) .AND. &
1890  PRESENT(force_c) .AND. &
1891  .NOT.PRESENT(pabc) .AND. &
1892  PRESENT(mat_dabc) .AND. &
1893  .NOT.PRESENT(mat_adbc) .AND. &
1894  .NOT.PRESENT(mat_abdc)) THEN
1895  CALL integrate_set_3c( &
1896  param%par, potential_parameter, &
1897  la_min(iset), la_max(iset), &
1898  lb_min(jset), lb_max(jset), &
1899  lc_min(kset), lc_max(kset), &
1900  npgfa(iset), npgfb(jset), npgfc(kset), &
1901  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1902  ra, rb, rc, &
1903  habc, &
1904  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1905  offset_a_start, offset_b_start, offset_c_start, &
1906  0, 0, first_set - 1, &
1907  sphi_a, sphi_b, sphi_c, &
1908  sgfa, sgfb, sgfc, &
1909  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1910  my_eri_method, &
1911 
1912 
1913 force_b=force_b(jkind)%forces(:, atom_b), &
1914 force_c=force_c(kkind)%forces(:, atom_c), &
1915  do_symmetric=do_symmetric, &
1916  on_diagonal=iatom .EQ. jatom, &
1917 hdabc=hdabc, &
1918 
1919 
1920  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1921  END IF
1922  IF (.NOT.PRESENT(force_a) .AND. &
1923  PRESENT(force_b) .AND. &
1924  PRESENT(force_c) .AND. &
1925  .NOT.PRESENT(pabc) .AND. &
1926  PRESENT(mat_dabc) .AND. &
1927  .NOT.PRESENT(mat_adbc) .AND. &
1928  PRESENT(mat_abdc)) THEN
1929  CALL integrate_set_3c( &
1930  param%par, potential_parameter, &
1931  la_min(iset), la_max(iset), &
1932  lb_min(jset), lb_max(jset), &
1933  lc_min(kset), lc_max(kset), &
1934  npgfa(iset), npgfb(jset), npgfc(kset), &
1935  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1936  ra, rb, rc, &
1937  habc, &
1938  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1939  offset_a_start, offset_b_start, offset_c_start, &
1940  0, 0, first_set - 1, &
1941  sphi_a, sphi_b, sphi_c, &
1942  sgfa, sgfb, sgfc, &
1943  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1944  my_eri_method, &
1945 
1946 
1947 force_b=force_b(jkind)%forces(:, atom_b), &
1948 force_c=force_c(kkind)%forces(:, atom_c), &
1949  do_symmetric=do_symmetric, &
1950  on_diagonal=iatom .EQ. jatom, &
1951 hdabc=hdabc, &
1952 
1953 habdc=habdc, &
1954  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1955  END IF
1956  IF (.NOT.PRESENT(force_a) .AND. &
1957  PRESENT(force_b) .AND. &
1958  PRESENT(force_c) .AND. &
1959  .NOT.PRESENT(pabc) .AND. &
1960  PRESENT(mat_dabc) .AND. &
1961  PRESENT(mat_adbc) .AND. &
1962  .NOT.PRESENT(mat_abdc)) THEN
1963  CALL integrate_set_3c( &
1964  param%par, potential_parameter, &
1965  la_min(iset), la_max(iset), &
1966  lb_min(jset), lb_max(jset), &
1967  lc_min(kset), lc_max(kset), &
1968  npgfa(iset), npgfb(jset), npgfc(kset), &
1969  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
1970  ra, rb, rc, &
1971  habc, &
1972  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
1973  offset_a_start, offset_b_start, offset_c_start, &
1974  0, 0, first_set - 1, &
1975  sphi_a, sphi_b, sphi_c, &
1976  sgfa, sgfb, sgfc, &
1977  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
1978  my_eri_method, &
1979 
1980 
1981 force_b=force_b(jkind)%forces(:, atom_b), &
1982 force_c=force_c(kkind)%forces(:, atom_c), &
1983  do_symmetric=do_symmetric, &
1984  on_diagonal=iatom .EQ. jatom, &
1985 hdabc=hdabc, &
1986 hadbc=hadbc, &
1987 
1988  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
1989  END IF
1990  IF (.NOT.PRESENT(force_a) .AND. &
1991  PRESENT(force_b) .AND. &
1992  PRESENT(force_c) .AND. &
1993  .NOT.PRESENT(pabc) .AND. &
1994  PRESENT(mat_dabc) .AND. &
1995  PRESENT(mat_adbc) .AND. &
1996  PRESENT(mat_abdc)) THEN
1997  CALL integrate_set_3c( &
1998  param%par, potential_parameter, &
1999  la_min(iset), la_max(iset), &
2000  lb_min(jset), lb_max(jset), &
2001  lc_min(kset), lc_max(kset), &
2002  npgfa(iset), npgfb(jset), npgfc(kset), &
2003  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2004  ra, rb, rc, &
2005  habc, &
2006  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2007  offset_a_start, offset_b_start, offset_c_start, &
2008  0, 0, first_set - 1, &
2009  sphi_a, sphi_b, sphi_c, &
2010  sgfa, sgfb, sgfc, &
2011  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2012  my_eri_method, &
2013 
2014 
2015 force_b=force_b(jkind)%forces(:, atom_b), &
2016 force_c=force_c(kkind)%forces(:, atom_c), &
2017  do_symmetric=do_symmetric, &
2018  on_diagonal=iatom .EQ. jatom, &
2019 hdabc=hdabc, &
2020 hadbc=hadbc, &
2021 habdc=habdc, &
2022  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2023  END IF
2024  IF (PRESENT(force_a) .AND. &
2025  .NOT.PRESENT(force_b) .AND. &
2026  .NOT.PRESENT(force_c) .AND. &
2027  .NOT.PRESENT(pabc) .AND. &
2028  .NOT.PRESENT(mat_dabc) .AND. &
2029  .NOT.PRESENT(mat_adbc) .AND. &
2030  .NOT.PRESENT(mat_abdc)) THEN
2031  CALL integrate_set_3c( &
2032  param%par, potential_parameter, &
2033  la_min(iset), la_max(iset), &
2034  lb_min(jset), lb_max(jset), &
2035  lc_min(kset), lc_max(kset), &
2036  npgfa(iset), npgfb(jset), npgfc(kset), &
2037  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2038  ra, rb, rc, &
2039  habc, &
2040  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2041  offset_a_start, offset_b_start, offset_c_start, &
2042  0, 0, first_set - 1, &
2043  sphi_a, sphi_b, sphi_c, &
2044  sgfa, sgfb, sgfc, &
2045  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2046  my_eri_method, &
2047 
2048 force_a=force_a(ikind)%forces(:, atom_a), &
2049 
2050 
2051  do_symmetric=do_symmetric, &
2052  on_diagonal=iatom .EQ. jatom, &
2053 
2054 
2055 
2056  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2057  END IF
2058  IF (PRESENT(force_a) .AND. &
2059  .NOT.PRESENT(force_b) .AND. &
2060  .NOT.PRESENT(force_c) .AND. &
2061  .NOT.PRESENT(pabc) .AND. &
2062  .NOT.PRESENT(mat_dabc) .AND. &
2063  .NOT.PRESENT(mat_adbc) .AND. &
2064  PRESENT(mat_abdc)) THEN
2065  CALL integrate_set_3c( &
2066  param%par, potential_parameter, &
2067  la_min(iset), la_max(iset), &
2068  lb_min(jset), lb_max(jset), &
2069  lc_min(kset), lc_max(kset), &
2070  npgfa(iset), npgfb(jset), npgfc(kset), &
2071  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2072  ra, rb, rc, &
2073  habc, &
2074  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2075  offset_a_start, offset_b_start, offset_c_start, &
2076  0, 0, first_set - 1, &
2077  sphi_a, sphi_b, sphi_c, &
2078  sgfa, sgfb, sgfc, &
2079  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2080  my_eri_method, &
2081 
2082 force_a=force_a(ikind)%forces(:, atom_a), &
2083 
2084 
2085  do_symmetric=do_symmetric, &
2086  on_diagonal=iatom .EQ. jatom, &
2087 
2088 
2089 habdc=habdc, &
2090  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2091  END IF
2092  IF (PRESENT(force_a) .AND. &
2093  .NOT.PRESENT(force_b) .AND. &
2094  .NOT.PRESENT(force_c) .AND. &
2095  .NOT.PRESENT(pabc) .AND. &
2096  .NOT.PRESENT(mat_dabc) .AND. &
2097  PRESENT(mat_adbc) .AND. &
2098  .NOT.PRESENT(mat_abdc)) THEN
2099  CALL integrate_set_3c( &
2100  param%par, potential_parameter, &
2101  la_min(iset), la_max(iset), &
2102  lb_min(jset), lb_max(jset), &
2103  lc_min(kset), lc_max(kset), &
2104  npgfa(iset), npgfb(jset), npgfc(kset), &
2105  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2106  ra, rb, rc, &
2107  habc, &
2108  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2109  offset_a_start, offset_b_start, offset_c_start, &
2110  0, 0, first_set - 1, &
2111  sphi_a, sphi_b, sphi_c, &
2112  sgfa, sgfb, sgfc, &
2113  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2114  my_eri_method, &
2115 
2116 force_a=force_a(ikind)%forces(:, atom_a), &
2117 
2118 
2119  do_symmetric=do_symmetric, &
2120  on_diagonal=iatom .EQ. jatom, &
2121 
2122 hadbc=hadbc, &
2123 
2124  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2125  END IF
2126  IF (PRESENT(force_a) .AND. &
2127  .NOT.PRESENT(force_b) .AND. &
2128  .NOT.PRESENT(force_c) .AND. &
2129  .NOT.PRESENT(pabc) .AND. &
2130  .NOT.PRESENT(mat_dabc) .AND. &
2131  PRESENT(mat_adbc) .AND. &
2132  PRESENT(mat_abdc)) THEN
2133  CALL integrate_set_3c( &
2134  param%par, potential_parameter, &
2135  la_min(iset), la_max(iset), &
2136  lb_min(jset), lb_max(jset), &
2137  lc_min(kset), lc_max(kset), &
2138  npgfa(iset), npgfb(jset), npgfc(kset), &
2139  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2140  ra, rb, rc, &
2141  habc, &
2142  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2143  offset_a_start, offset_b_start, offset_c_start, &
2144  0, 0, first_set - 1, &
2145  sphi_a, sphi_b, sphi_c, &
2146  sgfa, sgfb, sgfc, &
2147  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2148  my_eri_method, &
2149 
2150 force_a=force_a(ikind)%forces(:, atom_a), &
2151 
2152 
2153  do_symmetric=do_symmetric, &
2154  on_diagonal=iatom .EQ. jatom, &
2155 
2156 hadbc=hadbc, &
2157 habdc=habdc, &
2158  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2159  END IF
2160  IF (PRESENT(force_a) .AND. &
2161  .NOT.PRESENT(force_b) .AND. &
2162  .NOT.PRESENT(force_c) .AND. &
2163  .NOT.PRESENT(pabc) .AND. &
2164  PRESENT(mat_dabc) .AND. &
2165  .NOT.PRESENT(mat_adbc) .AND. &
2166  .NOT.PRESENT(mat_abdc)) THEN
2167  CALL integrate_set_3c( &
2168  param%par, potential_parameter, &
2169  la_min(iset), la_max(iset), &
2170  lb_min(jset), lb_max(jset), &
2171  lc_min(kset), lc_max(kset), &
2172  npgfa(iset), npgfb(jset), npgfc(kset), &
2173  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2174  ra, rb, rc, &
2175  habc, &
2176  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2177  offset_a_start, offset_b_start, offset_c_start, &
2178  0, 0, first_set - 1, &
2179  sphi_a, sphi_b, sphi_c, &
2180  sgfa, sgfb, sgfc, &
2181  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2182  my_eri_method, &
2183 
2184 force_a=force_a(ikind)%forces(:, atom_a), &
2185 
2186 
2187  do_symmetric=do_symmetric, &
2188  on_diagonal=iatom .EQ. jatom, &
2189 hdabc=hdabc, &
2190 
2191 
2192  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2193  END IF
2194  IF (PRESENT(force_a) .AND. &
2195  .NOT.PRESENT(force_b) .AND. &
2196  .NOT.PRESENT(force_c) .AND. &
2197  .NOT.PRESENT(pabc) .AND. &
2198  PRESENT(mat_dabc) .AND. &
2199  .NOT.PRESENT(mat_adbc) .AND. &
2200  PRESENT(mat_abdc)) THEN
2201  CALL integrate_set_3c( &
2202  param%par, potential_parameter, &
2203  la_min(iset), la_max(iset), &
2204  lb_min(jset), lb_max(jset), &
2205  lc_min(kset), lc_max(kset), &
2206  npgfa(iset), npgfb(jset), npgfc(kset), &
2207  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2208  ra, rb, rc, &
2209  habc, &
2210  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2211  offset_a_start, offset_b_start, offset_c_start, &
2212  0, 0, first_set - 1, &
2213  sphi_a, sphi_b, sphi_c, &
2214  sgfa, sgfb, sgfc, &
2215  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2216  my_eri_method, &
2217 
2218 force_a=force_a(ikind)%forces(:, atom_a), &
2219 
2220 
2221  do_symmetric=do_symmetric, &
2222  on_diagonal=iatom .EQ. jatom, &
2223 hdabc=hdabc, &
2224 
2225 habdc=habdc, &
2226  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2227  END IF
2228  IF (PRESENT(force_a) .AND. &
2229  .NOT.PRESENT(force_b) .AND. &
2230  .NOT.PRESENT(force_c) .AND. &
2231  .NOT.PRESENT(pabc) .AND. &
2232  PRESENT(mat_dabc) .AND. &
2233  PRESENT(mat_adbc) .AND. &
2234  .NOT.PRESENT(mat_abdc)) THEN
2235  CALL integrate_set_3c( &
2236  param%par, potential_parameter, &
2237  la_min(iset), la_max(iset), &
2238  lb_min(jset), lb_max(jset), &
2239  lc_min(kset), lc_max(kset), &
2240  npgfa(iset), npgfb(jset), npgfc(kset), &
2241  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2242  ra, rb, rc, &
2243  habc, &
2244  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2245  offset_a_start, offset_b_start, offset_c_start, &
2246  0, 0, first_set - 1, &
2247  sphi_a, sphi_b, sphi_c, &
2248  sgfa, sgfb, sgfc, &
2249  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2250  my_eri_method, &
2251 
2252 force_a=force_a(ikind)%forces(:, atom_a), &
2253 
2254 
2255  do_symmetric=do_symmetric, &
2256  on_diagonal=iatom .EQ. jatom, &
2257 hdabc=hdabc, &
2258 hadbc=hadbc, &
2259 
2260  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2261  END IF
2262  IF (PRESENT(force_a) .AND. &
2263  .NOT.PRESENT(force_b) .AND. &
2264  .NOT.PRESENT(force_c) .AND. &
2265  .NOT.PRESENT(pabc) .AND. &
2266  PRESENT(mat_dabc) .AND. &
2267  PRESENT(mat_adbc) .AND. &
2268  PRESENT(mat_abdc)) THEN
2269  CALL integrate_set_3c( &
2270  param%par, potential_parameter, &
2271  la_min(iset), la_max(iset), &
2272  lb_min(jset), lb_max(jset), &
2273  lc_min(kset), lc_max(kset), &
2274  npgfa(iset), npgfb(jset), npgfc(kset), &
2275  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2276  ra, rb, rc, &
2277  habc, &
2278  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2279  offset_a_start, offset_b_start, offset_c_start, &
2280  0, 0, first_set - 1, &
2281  sphi_a, sphi_b, sphi_c, &
2282  sgfa, sgfb, sgfc, &
2283  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2284  my_eri_method, &
2285 
2286 force_a=force_a(ikind)%forces(:, atom_a), &
2287 
2288 
2289  do_symmetric=do_symmetric, &
2290  on_diagonal=iatom .EQ. jatom, &
2291 hdabc=hdabc, &
2292 hadbc=hadbc, &
2293 habdc=habdc, &
2294  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2295  END IF
2296  IF (PRESENT(force_a) .AND. &
2297  .NOT.PRESENT(force_b) .AND. &
2298  PRESENT(force_c) .AND. &
2299  .NOT.PRESENT(pabc) .AND. &
2300  .NOT.PRESENT(mat_dabc) .AND. &
2301  .NOT.PRESENT(mat_adbc) .AND. &
2302  .NOT.PRESENT(mat_abdc)) THEN
2303  CALL integrate_set_3c( &
2304  param%par, potential_parameter, &
2305  la_min(iset), la_max(iset), &
2306  lb_min(jset), lb_max(jset), &
2307  lc_min(kset), lc_max(kset), &
2308  npgfa(iset), npgfb(jset), npgfc(kset), &
2309  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2310  ra, rb, rc, &
2311  habc, &
2312  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2313  offset_a_start, offset_b_start, offset_c_start, &
2314  0, 0, first_set - 1, &
2315  sphi_a, sphi_b, sphi_c, &
2316  sgfa, sgfb, sgfc, &
2317  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2318  my_eri_method, &
2319 
2320 force_a=force_a(ikind)%forces(:, atom_a), &
2321 
2322 force_c=force_c(kkind)%forces(:, atom_c), &
2323  do_symmetric=do_symmetric, &
2324  on_diagonal=iatom .EQ. jatom, &
2325 
2326 
2327 
2328  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2329  END IF
2330  IF (PRESENT(force_a) .AND. &
2331  .NOT.PRESENT(force_b) .AND. &
2332  PRESENT(force_c) .AND. &
2333  .NOT.PRESENT(pabc) .AND. &
2334  .NOT.PRESENT(mat_dabc) .AND. &
2335  .NOT.PRESENT(mat_adbc) .AND. &
2336  PRESENT(mat_abdc)) THEN
2337  CALL integrate_set_3c( &
2338  param%par, potential_parameter, &
2339  la_min(iset), la_max(iset), &
2340  lb_min(jset), lb_max(jset), &
2341  lc_min(kset), lc_max(kset), &
2342  npgfa(iset), npgfb(jset), npgfc(kset), &
2343  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2344  ra, rb, rc, &
2345  habc, &
2346  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2347  offset_a_start, offset_b_start, offset_c_start, &
2348  0, 0, first_set - 1, &
2349  sphi_a, sphi_b, sphi_c, &
2350  sgfa, sgfb, sgfc, &
2351  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2352  my_eri_method, &
2353 
2354 force_a=force_a(ikind)%forces(:, atom_a), &
2355 
2356 force_c=force_c(kkind)%forces(:, atom_c), &
2357  do_symmetric=do_symmetric, &
2358  on_diagonal=iatom .EQ. jatom, &
2359 
2360 
2361 habdc=habdc, &
2362  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2363  END IF
2364  IF (PRESENT(force_a) .AND. &
2365  .NOT.PRESENT(force_b) .AND. &
2366  PRESENT(force_c) .AND. &
2367  .NOT.PRESENT(pabc) .AND. &
2368  .NOT.PRESENT(mat_dabc) .AND. &
2369  PRESENT(mat_adbc) .AND. &
2370  .NOT.PRESENT(mat_abdc)) THEN
2371  CALL integrate_set_3c( &
2372  param%par, potential_parameter, &
2373  la_min(iset), la_max(iset), &
2374  lb_min(jset), lb_max(jset), &
2375  lc_min(kset), lc_max(kset), &
2376  npgfa(iset), npgfb(jset), npgfc(kset), &
2377  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2378  ra, rb, rc, &
2379  habc, &
2380  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2381  offset_a_start, offset_b_start, offset_c_start, &
2382  0, 0, first_set - 1, &
2383  sphi_a, sphi_b, sphi_c, &
2384  sgfa, sgfb, sgfc, &
2385  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2386  my_eri_method, &
2387 
2388 force_a=force_a(ikind)%forces(:, atom_a), &
2389 
2390 force_c=force_c(kkind)%forces(:, atom_c), &
2391  do_symmetric=do_symmetric, &
2392  on_diagonal=iatom .EQ. jatom, &
2393 
2394 hadbc=hadbc, &
2395 
2396  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2397  END IF
2398  IF (PRESENT(force_a) .AND. &
2399  .NOT.PRESENT(force_b) .AND. &
2400  PRESENT(force_c) .AND. &
2401  .NOT.PRESENT(pabc) .AND. &
2402  .NOT.PRESENT(mat_dabc) .AND. &
2403  PRESENT(mat_adbc) .AND. &
2404  PRESENT(mat_abdc)) THEN
2405  CALL integrate_set_3c( &
2406  param%par, potential_parameter, &
2407  la_min(iset), la_max(iset), &
2408  lb_min(jset), lb_max(jset), &
2409  lc_min(kset), lc_max(kset), &
2410  npgfa(iset), npgfb(jset), npgfc(kset), &
2411  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2412  ra, rb, rc, &
2413  habc, &
2414  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2415  offset_a_start, offset_b_start, offset_c_start, &
2416  0, 0, first_set - 1, &
2417  sphi_a, sphi_b, sphi_c, &
2418  sgfa, sgfb, sgfc, &
2419  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2420  my_eri_method, &
2421 
2422 force_a=force_a(ikind)%forces(:, atom_a), &
2423 
2424 force_c=force_c(kkind)%forces(:, atom_c), &
2425  do_symmetric=do_symmetric, &
2426  on_diagonal=iatom .EQ. jatom, &
2427 
2428 hadbc=hadbc, &
2429 habdc=habdc, &
2430  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2431  END IF
2432  IF (PRESENT(force_a) .AND. &
2433  .NOT.PRESENT(force_b) .AND. &
2434  PRESENT(force_c) .AND. &
2435  .NOT.PRESENT(pabc) .AND. &
2436  PRESENT(mat_dabc) .AND. &
2437  .NOT.PRESENT(mat_adbc) .AND. &
2438  .NOT.PRESENT(mat_abdc)) THEN
2439  CALL integrate_set_3c( &
2440  param%par, potential_parameter, &
2441  la_min(iset), la_max(iset), &
2442  lb_min(jset), lb_max(jset), &
2443  lc_min(kset), lc_max(kset), &
2444  npgfa(iset), npgfb(jset), npgfc(kset), &
2445  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2446  ra, rb, rc, &
2447  habc, &
2448  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2449  offset_a_start, offset_b_start, offset_c_start, &
2450  0, 0, first_set - 1, &
2451  sphi_a, sphi_b, sphi_c, &
2452  sgfa, sgfb, sgfc, &
2453  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2454  my_eri_method, &
2455 
2456 force_a=force_a(ikind)%forces(:, atom_a), &
2457 
2458 force_c=force_c(kkind)%forces(:, atom_c), &
2459  do_symmetric=do_symmetric, &
2460  on_diagonal=iatom .EQ. jatom, &
2461 hdabc=hdabc, &
2462 
2463 
2464  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2465  END IF
2466  IF (PRESENT(force_a) .AND. &
2467  .NOT.PRESENT(force_b) .AND. &
2468  PRESENT(force_c) .AND. &
2469  .NOT.PRESENT(pabc) .AND. &
2470  PRESENT(mat_dabc) .AND. &
2471  .NOT.PRESENT(mat_adbc) .AND. &
2472  PRESENT(mat_abdc)) THEN
2473  CALL integrate_set_3c( &
2474  param%par, potential_parameter, &
2475  la_min(iset), la_max(iset), &
2476  lb_min(jset), lb_max(jset), &
2477  lc_min(kset), lc_max(kset), &
2478  npgfa(iset), npgfb(jset), npgfc(kset), &
2479  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2480  ra, rb, rc, &
2481  habc, &
2482  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2483  offset_a_start, offset_b_start, offset_c_start, &
2484  0, 0, first_set - 1, &
2485  sphi_a, sphi_b, sphi_c, &
2486  sgfa, sgfb, sgfc, &
2487  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2488  my_eri_method, &
2489 
2490 force_a=force_a(ikind)%forces(:, atom_a), &
2491 
2492 force_c=force_c(kkind)%forces(:, atom_c), &
2493  do_symmetric=do_symmetric, &
2494  on_diagonal=iatom .EQ. jatom, &
2495 hdabc=hdabc, &
2496 
2497 habdc=habdc, &
2498  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2499  END IF
2500  IF (PRESENT(force_a) .AND. &
2501  .NOT.PRESENT(force_b) .AND. &
2502  PRESENT(force_c) .AND. &
2503  .NOT.PRESENT(pabc) .AND. &
2504  PRESENT(mat_dabc) .AND. &
2505  PRESENT(mat_adbc) .AND. &
2506  .NOT.PRESENT(mat_abdc)) THEN
2507  CALL integrate_set_3c( &
2508  param%par, potential_parameter, &
2509  la_min(iset), la_max(iset), &
2510  lb_min(jset), lb_max(jset), &
2511  lc_min(kset), lc_max(kset), &
2512  npgfa(iset), npgfb(jset), npgfc(kset), &
2513  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2514  ra, rb, rc, &
2515  habc, &
2516  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2517  offset_a_start, offset_b_start, offset_c_start, &
2518  0, 0, first_set - 1, &
2519  sphi_a, sphi_b, sphi_c, &
2520  sgfa, sgfb, sgfc, &
2521  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2522  my_eri_method, &
2523 
2524 force_a=force_a(ikind)%forces(:, atom_a), &
2525 
2526 force_c=force_c(kkind)%forces(:, atom_c), &
2527  do_symmetric=do_symmetric, &
2528  on_diagonal=iatom .EQ. jatom, &
2529 hdabc=hdabc, &
2530 hadbc=hadbc, &
2531 
2532  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2533  END IF
2534  IF (PRESENT(force_a) .AND. &
2535  .NOT.PRESENT(force_b) .AND. &
2536  PRESENT(force_c) .AND. &
2537  .NOT.PRESENT(pabc) .AND. &
2538  PRESENT(mat_dabc) .AND. &
2539  PRESENT(mat_adbc) .AND. &
2540  PRESENT(mat_abdc)) THEN
2541  CALL integrate_set_3c( &
2542  param%par, potential_parameter, &
2543  la_min(iset), la_max(iset), &
2544  lb_min(jset), lb_max(jset), &
2545  lc_min(kset), lc_max(kset), &
2546  npgfa(iset), npgfb(jset), npgfc(kset), &
2547  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2548  ra, rb, rc, &
2549  habc, &
2550  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2551  offset_a_start, offset_b_start, offset_c_start, &
2552  0, 0, first_set - 1, &
2553  sphi_a, sphi_b, sphi_c, &
2554  sgfa, sgfb, sgfc, &
2555  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2556  my_eri_method, &
2557 
2558 force_a=force_a(ikind)%forces(:, atom_a), &
2559 
2560 force_c=force_c(kkind)%forces(:, atom_c), &
2561  do_symmetric=do_symmetric, &
2562  on_diagonal=iatom .EQ. jatom, &
2563 hdabc=hdabc, &
2564 hadbc=hadbc, &
2565 habdc=habdc, &
2566  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2567  END IF
2568  IF (PRESENT(force_a) .AND. &
2569  PRESENT(force_b) .AND. &
2570  .NOT.PRESENT(force_c) .AND. &
2571  .NOT.PRESENT(pabc) .AND. &
2572  .NOT.PRESENT(mat_dabc) .AND. &
2573  .NOT.PRESENT(mat_adbc) .AND. &
2574  .NOT.PRESENT(mat_abdc)) THEN
2575  CALL integrate_set_3c( &
2576  param%par, potential_parameter, &
2577  la_min(iset), la_max(iset), &
2578  lb_min(jset), lb_max(jset), &
2579  lc_min(kset), lc_max(kset), &
2580  npgfa(iset), npgfb(jset), npgfc(kset), &
2581  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2582  ra, rb, rc, &
2583  habc, &
2584  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2585  offset_a_start, offset_b_start, offset_c_start, &
2586  0, 0, first_set - 1, &
2587  sphi_a, sphi_b, sphi_c, &
2588  sgfa, sgfb, sgfc, &
2589  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2590  my_eri_method, &
2591 
2592 force_a=force_a(ikind)%forces(:, atom_a), &
2593 force_b=force_b(jkind)%forces(:, atom_b), &
2594 
2595  do_symmetric=do_symmetric, &
2596  on_diagonal=iatom .EQ. jatom, &
2597 
2598 
2599 
2600  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2601  END IF
2602  IF (PRESENT(force_a) .AND. &
2603  PRESENT(force_b) .AND. &
2604  .NOT.PRESENT(force_c) .AND. &
2605  .NOT.PRESENT(pabc) .AND. &
2606  .NOT.PRESENT(mat_dabc) .AND. &
2607  .NOT.PRESENT(mat_adbc) .AND. &
2608  PRESENT(mat_abdc)) THEN
2609  CALL integrate_set_3c( &
2610  param%par, potential_parameter, &
2611  la_min(iset), la_max(iset), &
2612  lb_min(jset), lb_max(jset), &
2613  lc_min(kset), lc_max(kset), &
2614  npgfa(iset), npgfb(jset), npgfc(kset), &
2615  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2616  ra, rb, rc, &
2617  habc, &
2618  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2619  offset_a_start, offset_b_start, offset_c_start, &
2620  0, 0, first_set - 1, &
2621  sphi_a, sphi_b, sphi_c, &
2622  sgfa, sgfb, sgfc, &
2623  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2624  my_eri_method, &
2625 
2626 force_a=force_a(ikind)%forces(:, atom_a), &
2627 force_b=force_b(jkind)%forces(:, atom_b), &
2628 
2629  do_symmetric=do_symmetric, &
2630  on_diagonal=iatom .EQ. jatom, &
2631 
2632 
2633 habdc=habdc, &
2634  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2635  END IF
2636  IF (PRESENT(force_a) .AND. &
2637  PRESENT(force_b) .AND. &
2638  .NOT.PRESENT(force_c) .AND. &
2639  .NOT.PRESENT(pabc) .AND. &
2640  .NOT.PRESENT(mat_dabc) .AND. &
2641  PRESENT(mat_adbc) .AND. &
2642  .NOT.PRESENT(mat_abdc)) THEN
2643  CALL integrate_set_3c( &
2644  param%par, potential_parameter, &
2645  la_min(iset), la_max(iset), &
2646  lb_min(jset), lb_max(jset), &
2647  lc_min(kset), lc_max(kset), &
2648  npgfa(iset), npgfb(jset), npgfc(kset), &
2649  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2650  ra, rb, rc, &
2651  habc, &
2652  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2653  offset_a_start, offset_b_start, offset_c_start, &
2654  0, 0, first_set - 1, &
2655  sphi_a, sphi_b, sphi_c, &
2656  sgfa, sgfb, sgfc, &
2657  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2658  my_eri_method, &
2659 
2660 force_a=force_a(ikind)%forces(:, atom_a), &
2661 force_b=force_b(jkind)%forces(:, atom_b), &
2662 
2663  do_symmetric=do_symmetric, &
2664  on_diagonal=iatom .EQ. jatom, &
2665 
2666 hadbc=hadbc, &
2667 
2668  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2669  END IF
2670  IF (PRESENT(force_a) .AND. &
2671  PRESENT(force_b) .AND. &
2672  .NOT.PRESENT(force_c) .AND. &
2673  .NOT.PRESENT(pabc) .AND. &
2674  .NOT.PRESENT(mat_dabc) .AND. &
2675  PRESENT(mat_adbc) .AND. &
2676  PRESENT(mat_abdc)) THEN
2677  CALL integrate_set_3c( &
2678  param%par, potential_parameter, &
2679  la_min(iset), la_max(iset), &
2680  lb_min(jset), lb_max(jset), &
2681  lc_min(kset), lc_max(kset), &
2682  npgfa(iset), npgfb(jset), npgfc(kset), &
2683  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2684  ra, rb, rc, &
2685  habc, &
2686  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2687  offset_a_start, offset_b_start, offset_c_start, &
2688  0, 0, first_set - 1, &
2689  sphi_a, sphi_b, sphi_c, &
2690  sgfa, sgfb, sgfc, &
2691  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2692  my_eri_method, &
2693 
2694 force_a=force_a(ikind)%forces(:, atom_a), &
2695 force_b=force_b(jkind)%forces(:, atom_b), &
2696 
2697  do_symmetric=do_symmetric, &
2698  on_diagonal=iatom .EQ. jatom, &
2699 
2700 hadbc=hadbc, &
2701 habdc=habdc, &
2702  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2703  END IF
2704  IF (PRESENT(force_a) .AND. &
2705  PRESENT(force_b) .AND. &
2706  .NOT.PRESENT(force_c) .AND. &
2707  .NOT.PRESENT(pabc) .AND. &
2708  PRESENT(mat_dabc) .AND. &
2709  .NOT.PRESENT(mat_adbc) .AND. &
2710  .NOT.PRESENT(mat_abdc)) THEN
2711  CALL integrate_set_3c( &
2712  param%par, potential_parameter, &
2713  la_min(iset), la_max(iset), &
2714  lb_min(jset), lb_max(jset), &
2715  lc_min(kset), lc_max(kset), &
2716  npgfa(iset), npgfb(jset), npgfc(kset), &
2717  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2718  ra, rb, rc, &
2719  habc, &
2720  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2721  offset_a_start, offset_b_start, offset_c_start, &
2722  0, 0, first_set - 1, &
2723  sphi_a, sphi_b, sphi_c, &
2724  sgfa, sgfb, sgfc, &
2725  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2726  my_eri_method, &
2727 
2728 force_a=force_a(ikind)%forces(:, atom_a), &
2729 force_b=force_b(jkind)%forces(:, atom_b), &
2730 
2731  do_symmetric=do_symmetric, &
2732  on_diagonal=iatom .EQ. jatom, &
2733 hdabc=hdabc, &
2734 
2735 
2736  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2737  END IF
2738  IF (PRESENT(force_a) .AND. &
2739  PRESENT(force_b) .AND. &
2740  .NOT.PRESENT(force_c) .AND. &
2741  .NOT.PRESENT(pabc) .AND. &
2742  PRESENT(mat_dabc) .AND. &
2743  .NOT.PRESENT(mat_adbc) .AND. &
2744  PRESENT(mat_abdc)) THEN
2745  CALL integrate_set_3c( &
2746  param%par, potential_parameter, &
2747  la_min(iset), la_max(iset), &
2748  lb_min(jset), lb_max(jset), &
2749  lc_min(kset), lc_max(kset), &
2750  npgfa(iset), npgfb(jset), npgfc(kset), &
2751  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2752  ra, rb, rc, &
2753  habc, &
2754  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2755  offset_a_start, offset_b_start, offset_c_start, &
2756  0, 0, first_set - 1, &
2757  sphi_a, sphi_b, sphi_c, &
2758  sgfa, sgfb, sgfc, &
2759  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2760  my_eri_method, &
2761 
2762 force_a=force_a(ikind)%forces(:, atom_a), &
2763 force_b=force_b(jkind)%forces(:, atom_b), &
2764 
2765  do_symmetric=do_symmetric, &
2766  on_diagonal=iatom .EQ. jatom, &
2767 hdabc=hdabc, &
2768 
2769 habdc=habdc, &
2770  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2771  END IF
2772  IF (PRESENT(force_a) .AND. &
2773  PRESENT(force_b) .AND. &
2774  .NOT.PRESENT(force_c) .AND. &
2775  .NOT.PRESENT(pabc) .AND. &
2776  PRESENT(mat_dabc) .AND. &
2777  PRESENT(mat_adbc) .AND. &
2778  .NOT.PRESENT(mat_abdc)) THEN
2779  CALL integrate_set_3c( &
2780  param%par, potential_parameter, &
2781  la_min(iset), la_max(iset), &
2782  lb_min(jset), lb_max(jset), &
2783  lc_min(kset), lc_max(kset), &
2784  npgfa(iset), npgfb(jset), npgfc(kset), &
2785  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2786  ra, rb, rc, &
2787  habc, &
2788  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2789  offset_a_start, offset_b_start, offset_c_start, &
2790  0, 0, first_set - 1, &
2791  sphi_a, sphi_b, sphi_c, &
2792  sgfa, sgfb, sgfc, &
2793  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2794  my_eri_method, &
2795 
2796 force_a=force_a(ikind)%forces(:, atom_a), &
2797 force_b=force_b(jkind)%forces(:, atom_b), &
2798 
2799  do_symmetric=do_symmetric, &
2800  on_diagonal=iatom .EQ. jatom, &
2801 hdabc=hdabc, &
2802 hadbc=hadbc, &
2803 
2804  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2805  END IF
2806  IF (PRESENT(force_a) .AND. &
2807  PRESENT(force_b) .AND. &
2808  .NOT.PRESENT(force_c) .AND. &
2809  .NOT.PRESENT(pabc) .AND. &
2810  PRESENT(mat_dabc) .AND. &
2811  PRESENT(mat_adbc) .AND. &
2812  PRESENT(mat_abdc)) THEN
2813  CALL integrate_set_3c( &
2814  param%par, potential_parameter, &
2815  la_min(iset), la_max(iset), &
2816  lb_min(jset), lb_max(jset), &
2817  lc_min(kset), lc_max(kset), &
2818  npgfa(iset), npgfb(jset), npgfc(kset), &
2819  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2820  ra, rb, rc, &
2821  habc, &
2822  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2823  offset_a_start, offset_b_start, offset_c_start, &
2824  0, 0, first_set - 1, &
2825  sphi_a, sphi_b, sphi_c, &
2826  sgfa, sgfb, sgfc, &
2827  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2828  my_eri_method, &
2829 
2830 force_a=force_a(ikind)%forces(:, atom_a), &
2831 force_b=force_b(jkind)%forces(:, atom_b), &
2832 
2833  do_symmetric=do_symmetric, &
2834  on_diagonal=iatom .EQ. jatom, &
2835 hdabc=hdabc, &
2836 hadbc=hadbc, &
2837 habdc=habdc, &
2838  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2839  END IF
2840  IF (PRESENT(force_a) .AND. &
2841  PRESENT(force_b) .AND. &
2842  PRESENT(force_c) .AND. &
2843  .NOT.PRESENT(pabc) .AND. &
2844  .NOT.PRESENT(mat_dabc) .AND. &
2845  .NOT.PRESENT(mat_adbc) .AND. &
2846  .NOT.PRESENT(mat_abdc)) THEN
2847  CALL integrate_set_3c( &
2848  param%par, potential_parameter, &
2849  la_min(iset), la_max(iset), &
2850  lb_min(jset), lb_max(jset), &
2851  lc_min(kset), lc_max(kset), &
2852  npgfa(iset), npgfb(jset), npgfc(kset), &
2853  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2854  ra, rb, rc, &
2855  habc, &
2856  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2857  offset_a_start, offset_b_start, offset_c_start, &
2858  0, 0, first_set - 1, &
2859  sphi_a, sphi_b, sphi_c, &
2860  sgfa, sgfb, sgfc, &
2861  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2862  my_eri_method, &
2863 
2864 force_a=force_a(ikind)%forces(:, atom_a), &
2865 force_b=force_b(jkind)%forces(:, atom_b), &
2866 force_c=force_c(kkind)%forces(:, atom_c), &
2867  do_symmetric=do_symmetric, &
2868  on_diagonal=iatom .EQ. jatom, &
2869 
2870 
2871 
2872  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2873  END IF
2874  IF (PRESENT(force_a) .AND. &
2875  PRESENT(force_b) .AND. &
2876  PRESENT(force_c) .AND. &
2877  .NOT.PRESENT(pabc) .AND. &
2878  .NOT.PRESENT(mat_dabc) .AND. &
2879  .NOT.PRESENT(mat_adbc) .AND. &
2880  PRESENT(mat_abdc)) THEN
2881  CALL integrate_set_3c( &
2882  param%par, potential_parameter, &
2883  la_min(iset), la_max(iset), &
2884  lb_min(jset), lb_max(jset), &
2885  lc_min(kset), lc_max(kset), &
2886  npgfa(iset), npgfb(jset), npgfc(kset), &
2887  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2888  ra, rb, rc, &
2889  habc, &
2890  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2891  offset_a_start, offset_b_start, offset_c_start, &
2892  0, 0, first_set - 1, &
2893  sphi_a, sphi_b, sphi_c, &
2894  sgfa, sgfb, sgfc, &
2895  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2896  my_eri_method, &
2897 
2898 force_a=force_a(ikind)%forces(:, atom_a), &
2899 force_b=force_b(jkind)%forces(:, atom_b), &
2900 force_c=force_c(kkind)%forces(:, atom_c), &
2901  do_symmetric=do_symmetric, &
2902  on_diagonal=iatom .EQ. jatom, &
2903 
2904 
2905 habdc=habdc, &
2906  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2907  END IF
2908  IF (PRESENT(force_a) .AND. &
2909  PRESENT(force_b) .AND. &
2910  PRESENT(force_c) .AND. &
2911  .NOT.PRESENT(pabc) .AND. &
2912  .NOT.PRESENT(mat_dabc) .AND. &
2913  PRESENT(mat_adbc) .AND. &
2914  .NOT.PRESENT(mat_abdc)) THEN
2915  CALL integrate_set_3c( &
2916  param%par, potential_parameter, &
2917  la_min(iset), la_max(iset), &
2918  lb_min(jset), lb_max(jset), &
2919  lc_min(kset), lc_max(kset), &
2920  npgfa(iset), npgfb(jset), npgfc(kset), &
2921  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2922  ra, rb, rc, &
2923  habc, &
2924  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2925  offset_a_start, offset_b_start, offset_c_start, &
2926  0, 0, first_set - 1, &
2927  sphi_a, sphi_b, sphi_c, &
2928  sgfa, sgfb, sgfc, &
2929  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2930  my_eri_method, &
2931 
2932 force_a=force_a(ikind)%forces(:, atom_a), &
2933 force_b=force_b(jkind)%forces(:, atom_b), &
2934 force_c=force_c(kkind)%forces(:, atom_c), &
2935  do_symmetric=do_symmetric, &
2936  on_diagonal=iatom .EQ. jatom, &
2937 
2938 hadbc=hadbc, &
2939 
2940  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2941  END IF
2942  IF (PRESENT(force_a) .AND. &
2943  PRESENT(force_b) .AND. &
2944  PRESENT(force_c) .AND. &
2945  .NOT.PRESENT(pabc) .AND. &
2946  .NOT.PRESENT(mat_dabc) .AND. &
2947  PRESENT(mat_adbc) .AND. &
2948  PRESENT(mat_abdc)) THEN
2949  CALL integrate_set_3c( &
2950  param%par, potential_parameter, &
2951  la_min(iset), la_max(iset), &
2952  lb_min(jset), lb_max(jset), &
2953  lc_min(kset), lc_max(kset), &
2954  npgfa(iset), npgfb(jset), npgfc(kset), &
2955  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2956  ra, rb, rc, &
2957  habc, &
2958  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2959  offset_a_start, offset_b_start, offset_c_start, &
2960  0, 0, first_set - 1, &
2961  sphi_a, sphi_b, sphi_c, &
2962  sgfa, sgfb, sgfc, &
2963  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2964  my_eri_method, &
2965 
2966 force_a=force_a(ikind)%forces(:, atom_a), &
2967 force_b=force_b(jkind)%forces(:, atom_b), &
2968 force_c=force_c(kkind)%forces(:, atom_c), &
2969  do_symmetric=do_symmetric, &
2970  on_diagonal=iatom .EQ. jatom, &
2971 
2972 hadbc=hadbc, &
2973 habdc=habdc, &
2974  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
2975  END IF
2976  IF (PRESENT(force_a) .AND. &
2977  PRESENT(force_b) .AND. &
2978  PRESENT(force_c) .AND. &
2979  .NOT.PRESENT(pabc) .AND. &
2980  PRESENT(mat_dabc) .AND. &
2981  .NOT.PRESENT(mat_adbc) .AND. &
2982  .NOT.PRESENT(mat_abdc)) THEN
2983  CALL integrate_set_3c( &
2984  param%par, potential_parameter, &
2985  la_min(iset), la_max(iset), &
2986  lb_min(jset), lb_max(jset), &
2987  lc_min(kset), lc_max(kset), &
2988  npgfa(iset), npgfb(jset), npgfc(kset), &
2989  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
2990  ra, rb, rc, &
2991  habc, &
2992  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
2993  offset_a_start, offset_b_start, offset_c_start, &
2994  0, 0, first_set - 1, &
2995  sphi_a, sphi_b, sphi_c, &
2996  sgfa, sgfb, sgfc, &
2997  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
2998  my_eri_method, &
2999 
3000 force_a=force_a(ikind)%forces(:, atom_a), &
3001 force_b=force_b(jkind)%forces(:, atom_b), &
3002 force_c=force_c(kkind)%forces(:, atom_c), &
3003  do_symmetric=do_symmetric, &
3004  on_diagonal=iatom .EQ. jatom, &
3005 hdabc=hdabc, &
3006 
3007 
3008  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3009  END IF
3010  IF (PRESENT(force_a) .AND. &
3011  PRESENT(force_b) .AND. &
3012  PRESENT(force_c) .AND. &
3013  .NOT.PRESENT(pabc) .AND. &
3014  PRESENT(mat_dabc) .AND. &
3015  .NOT.PRESENT(mat_adbc) .AND. &
3016  PRESENT(mat_abdc)) THEN
3017  CALL integrate_set_3c( &
3018  param%par, potential_parameter, &
3019  la_min(iset), la_max(iset), &
3020  lb_min(jset), lb_max(jset), &
3021  lc_min(kset), lc_max(kset), &
3022  npgfa(iset), npgfb(jset), npgfc(kset), &
3023  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3024  ra, rb, rc, &
3025  habc, &
3026  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3027  offset_a_start, offset_b_start, offset_c_start, &
3028  0, 0, first_set - 1, &
3029  sphi_a, sphi_b, sphi_c, &
3030  sgfa, sgfb, sgfc, &
3031  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3032  my_eri_method, &
3033 
3034 force_a=force_a(ikind)%forces(:, atom_a), &
3035 force_b=force_b(jkind)%forces(:, atom_b), &
3036 force_c=force_c(kkind)%forces(:, atom_c), &
3037  do_symmetric=do_symmetric, &
3038  on_diagonal=iatom .EQ. jatom, &
3039 hdabc=hdabc, &
3040 
3041 habdc=habdc, &
3042  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3043  END IF
3044  IF (PRESENT(force_a) .AND. &
3045  PRESENT(force_b) .AND. &
3046  PRESENT(force_c) .AND. &
3047  .NOT.PRESENT(pabc) .AND. &
3048  PRESENT(mat_dabc) .AND. &
3049  PRESENT(mat_adbc) .AND. &
3050  .NOT.PRESENT(mat_abdc)) THEN
3051  CALL integrate_set_3c( &
3052  param%par, potential_parameter, &
3053  la_min(iset), la_max(iset), &
3054  lb_min(jset), lb_max(jset), &
3055  lc_min(kset), lc_max(kset), &
3056  npgfa(iset), npgfb(jset), npgfc(kset), &
3057  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3058  ra, rb, rc, &
3059  habc, &
3060  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3061  offset_a_start, offset_b_start, offset_c_start, &
3062  0, 0, first_set - 1, &
3063  sphi_a, sphi_b, sphi_c, &
3064  sgfa, sgfb, sgfc, &
3065  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3066  my_eri_method, &
3067 
3068 force_a=force_a(ikind)%forces(:, atom_a), &
3069 force_b=force_b(jkind)%forces(:, atom_b), &
3070 force_c=force_c(kkind)%forces(:, atom_c), &
3071  do_symmetric=do_symmetric, &
3072  on_diagonal=iatom .EQ. jatom, &
3073 hdabc=hdabc, &
3074 hadbc=hadbc, &
3075 
3076  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3077  END IF
3078  IF (PRESENT(force_a) .AND. &
3079  PRESENT(force_b) .AND. &
3080  PRESENT(force_c) .AND. &
3081  .NOT.PRESENT(pabc) .AND. &
3082  PRESENT(mat_dabc) .AND. &
3083  PRESENT(mat_adbc) .AND. &
3084  PRESENT(mat_abdc)) THEN
3085  CALL integrate_set_3c( &
3086  param%par, potential_parameter, &
3087  la_min(iset), la_max(iset), &
3088  lb_min(jset), lb_max(jset), &
3089  lc_min(kset), lc_max(kset), &
3090  npgfa(iset), npgfb(jset), npgfc(kset), &
3091  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3092  ra, rb, rc, &
3093  habc, &
3094  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3095  offset_a_start, offset_b_start, offset_c_start, &
3096  0, 0, first_set - 1, &
3097  sphi_a, sphi_b, sphi_c, &
3098  sgfa, sgfb, sgfc, &
3099  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3100  my_eri_method, &
3101 
3102 force_a=force_a(ikind)%forces(:, atom_a), &
3103 force_b=force_b(jkind)%forces(:, atom_b), &
3104 force_c=force_c(kkind)%forces(:, atom_c), &
3105  do_symmetric=do_symmetric, &
3106  on_diagonal=iatom .EQ. jatom, &
3107 hdabc=hdabc, &
3108 hadbc=hadbc, &
3109 habdc=habdc, &
3110  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3111  END IF
3112  IF (.NOT.PRESENT(force_a) .AND. &
3113  .NOT.PRESENT(force_b) .AND. &
3114  .NOT.PRESENT(force_c) .AND. &
3115  PRESENT(pabc) .AND. &
3116  .NOT.PRESENT(mat_dabc) .AND. &
3117  .NOT.PRESENT(mat_adbc) .AND. &
3118  .NOT.PRESENT(mat_abdc)) THEN
3119  CALL integrate_set_3c( &
3120  param%par, potential_parameter, &
3121  la_min(iset), la_max(iset), &
3122  lb_min(jset), lb_max(jset), &
3123  lc_min(kset), lc_max(kset), &
3124  npgfa(iset), npgfb(jset), npgfc(kset), &
3125  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3126  ra, rb, rc, &
3127  habc, &
3128  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3129  offset_a_start, offset_b_start, offset_c_start, &
3130  0, 0, first_set - 1, &
3131  sphi_a, sphi_b, sphi_c, &
3132  sgfa, sgfb, sgfc, &
3133  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3134  my_eri_method, &
3135 pabc=pabc_block, &
3136 
3137 
3138 
3139  do_symmetric=do_symmetric, &
3140  on_diagonal=iatom .EQ. jatom, &
3141 
3142 
3143 
3144  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3145  END IF
3146  IF (.NOT.PRESENT(force_a) .AND. &
3147  .NOT.PRESENT(force_b) .AND. &
3148  .NOT.PRESENT(force_c) .AND. &
3149  PRESENT(pabc) .AND. &
3150  .NOT.PRESENT(mat_dabc) .AND. &
3151  .NOT.PRESENT(mat_adbc) .AND. &
3152  PRESENT(mat_abdc)) THEN
3153  CALL integrate_set_3c( &
3154  param%par, potential_parameter, &
3155  la_min(iset), la_max(iset), &
3156  lb_min(jset), lb_max(jset), &
3157  lc_min(kset), lc_max(kset), &
3158  npgfa(iset), npgfb(jset), npgfc(kset), &
3159  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3160  ra, rb, rc, &
3161  habc, &
3162  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3163  offset_a_start, offset_b_start, offset_c_start, &
3164  0, 0, first_set - 1, &
3165  sphi_a, sphi_b, sphi_c, &
3166  sgfa, sgfb, sgfc, &
3167  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3168  my_eri_method, &
3169 pabc=pabc_block, &
3170 
3171 
3172 
3173  do_symmetric=do_symmetric, &
3174  on_diagonal=iatom .EQ. jatom, &
3175 
3176 
3177 habdc=habdc, &
3178  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3179  END IF
3180  IF (.NOT.PRESENT(force_a) .AND. &
3181  .NOT.PRESENT(force_b) .AND. &
3182  .NOT.PRESENT(force_c) .AND. &
3183  PRESENT(pabc) .AND. &
3184  .NOT.PRESENT(mat_dabc) .AND. &
3185  PRESENT(mat_adbc) .AND. &
3186  .NOT.PRESENT(mat_abdc)) THEN
3187  CALL integrate_set_3c( &
3188  param%par, potential_parameter, &
3189  la_min(iset), la_max(iset), &
3190  lb_min(jset), lb_max(jset), &
3191  lc_min(kset), lc_max(kset), &
3192  npgfa(iset), npgfb(jset), npgfc(kset), &
3193  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3194  ra, rb, rc, &
3195  habc, &
3196  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3197  offset_a_start, offset_b_start, offset_c_start, &
3198  0, 0, first_set - 1, &
3199  sphi_a, sphi_b, sphi_c, &
3200  sgfa, sgfb, sgfc, &
3201  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3202  my_eri_method, &
3203 pabc=pabc_block, &
3204 
3205 
3206 
3207  do_symmetric=do_symmetric, &
3208  on_diagonal=iatom .EQ. jatom, &
3209 
3210 hadbc=hadbc, &
3211 
3212  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3213  END IF
3214  IF (.NOT.PRESENT(force_a) .AND. &
3215  .NOT.PRESENT(force_b) .AND. &
3216  .NOT.PRESENT(force_c) .AND. &
3217  PRESENT(pabc) .AND. &
3218  .NOT.PRESENT(mat_dabc) .AND. &
3219  PRESENT(mat_adbc) .AND. &
3220  PRESENT(mat_abdc)) THEN
3221  CALL integrate_set_3c( &
3222  param%par, potential_parameter, &
3223  la_min(iset), la_max(iset), &
3224  lb_min(jset), lb_max(jset), &
3225  lc_min(kset), lc_max(kset), &
3226  npgfa(iset), npgfb(jset), npgfc(kset), &
3227  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3228  ra, rb, rc, &
3229  habc, &
3230  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3231  offset_a_start, offset_b_start, offset_c_start, &
3232  0, 0, first_set - 1, &
3233  sphi_a, sphi_b, sphi_c, &
3234  sgfa, sgfb, sgfc, &
3235  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3236  my_eri_method, &
3237 pabc=pabc_block, &
3238 
3239 
3240 
3241  do_symmetric=do_symmetric, &
3242  on_diagonal=iatom .EQ. jatom, &
3243 
3244 hadbc=hadbc, &
3245 habdc=habdc, &
3246  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3247  END IF
3248  IF (.NOT.PRESENT(force_a) .AND. &
3249  .NOT.PRESENT(force_b) .AND. &
3250  .NOT.PRESENT(force_c) .AND. &
3251  PRESENT(pabc) .AND. &
3252  PRESENT(mat_dabc) .AND. &
3253  .NOT.PRESENT(mat_adbc) .AND. &
3254  .NOT.PRESENT(mat_abdc)) THEN
3255  CALL integrate_set_3c( &
3256  param%par, potential_parameter, &
3257  la_min(iset), la_max(iset), &
3258  lb_min(jset), lb_max(jset), &
3259  lc_min(kset), lc_max(kset), &
3260  npgfa(iset), npgfb(jset), npgfc(kset), &
3261  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3262  ra, rb, rc, &
3263  habc, &
3264  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3265  offset_a_start, offset_b_start, offset_c_start, &
3266  0, 0, first_set - 1, &
3267  sphi_a, sphi_b, sphi_c, &
3268  sgfa, sgfb, sgfc, &
3269  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3270  my_eri_method, &
3271 pabc=pabc_block, &
3272 
3273 
3274 
3275  do_symmetric=do_symmetric, &
3276  on_diagonal=iatom .EQ. jatom, &
3277 hdabc=hdabc, &
3278 
3279 
3280  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3281  END IF
3282  IF (.NOT.PRESENT(force_a) .AND. &
3283  .NOT.PRESENT(force_b) .AND. &
3284  .NOT.PRESENT(force_c) .AND. &
3285  PRESENT(pabc) .AND. &
3286  PRESENT(mat_dabc) .AND. &
3287  .NOT.PRESENT(mat_adbc) .AND. &
3288  PRESENT(mat_abdc)) THEN
3289  CALL integrate_set_3c( &
3290  param%par, potential_parameter, &
3291  la_min(iset), la_max(iset), &
3292  lb_min(jset), lb_max(jset), &
3293  lc_min(kset), lc_max(kset), &
3294  npgfa(iset), npgfb(jset), npgfc(kset), &
3295  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3296  ra, rb, rc, &
3297  habc, &
3298  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3299  offset_a_start, offset_b_start, offset_c_start, &
3300  0, 0, first_set - 1, &
3301  sphi_a, sphi_b, sphi_c, &
3302  sgfa, sgfb, sgfc, &
3303  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3304  my_eri_method, &
3305 pabc=pabc_block, &
3306 
3307 
3308 
3309  do_symmetric=do_symmetric, &
3310  on_diagonal=iatom .EQ. jatom, &
3311 hdabc=hdabc, &
3312 
3313 habdc=habdc, &
3314  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3315  END IF
3316  IF (.NOT.PRESENT(force_a) .AND. &
3317  .NOT.PRESENT(force_b) .AND. &
3318  .NOT.PRESENT(force_c) .AND. &
3319  PRESENT(pabc) .AND. &
3320  PRESENT(mat_dabc) .AND. &
3321  PRESENT(mat_adbc) .AND. &
3322  .NOT.PRESENT(mat_abdc)) THEN
3323  CALL integrate_set_3c( &
3324  param%par, potential_parameter, &
3325  la_min(iset), la_max(iset), &
3326  lb_min(jset), lb_max(jset), &
3327  lc_min(kset), lc_max(kset), &
3328  npgfa(iset), npgfb(jset), npgfc(kset), &
3329  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3330  ra, rb, rc, &
3331  habc, &
3332  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3333  offset_a_start, offset_b_start, offset_c_start, &
3334  0, 0, first_set - 1, &
3335  sphi_a, sphi_b, sphi_c, &
3336  sgfa, sgfb, sgfc, &
3337  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3338  my_eri_method, &
3339 pabc=pabc_block, &
3340 
3341 
3342 
3343  do_symmetric=do_symmetric, &
3344  on_diagonal=iatom .EQ. jatom, &
3345 hdabc=hdabc, &
3346 hadbc=hadbc, &
3347 
3348  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3349  END IF
3350  IF (.NOT.PRESENT(force_a) .AND. &
3351  .NOT.PRESENT(force_b) .AND. &
3352  .NOT.PRESENT(force_c) .AND. &
3353  PRESENT(pabc) .AND. &
3354  PRESENT(mat_dabc) .AND. &
3355  PRESENT(mat_adbc) .AND. &
3356  PRESENT(mat_abdc)) THEN
3357  CALL integrate_set_3c( &
3358  param%par, potential_parameter, &
3359  la_min(iset), la_max(iset), &
3360  lb_min(jset), lb_max(jset), &
3361  lc_min(kset), lc_max(kset), &
3362  npgfa(iset), npgfb(jset), npgfc(kset), &
3363  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3364  ra, rb, rc, &
3365  habc, &
3366  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3367  offset_a_start, offset_b_start, offset_c_start, &
3368  0, 0, first_set - 1, &
3369  sphi_a, sphi_b, sphi_c, &
3370  sgfa, sgfb, sgfc, &
3371  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3372  my_eri_method, &
3373 pabc=pabc_block, &
3374 
3375 
3376 
3377  do_symmetric=do_symmetric, &
3378  on_diagonal=iatom .EQ. jatom, &
3379 hdabc=hdabc, &
3380 hadbc=hadbc, &
3381 habdc=habdc, &
3382  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3383  END IF
3384  IF (.NOT.PRESENT(force_a) .AND. &
3385  .NOT.PRESENT(force_b) .AND. &
3386  PRESENT(force_c) .AND. &
3387  PRESENT(pabc) .AND. &
3388  .NOT.PRESENT(mat_dabc) .AND. &
3389  .NOT.PRESENT(mat_adbc) .AND. &
3390  .NOT.PRESENT(mat_abdc)) THEN
3391  CALL integrate_set_3c( &
3392  param%par, potential_parameter, &
3393  la_min(iset), la_max(iset), &
3394  lb_min(jset), lb_max(jset), &
3395  lc_min(kset), lc_max(kset), &
3396  npgfa(iset), npgfb(jset), npgfc(kset), &
3397  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3398  ra, rb, rc, &
3399  habc, &
3400  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3401  offset_a_start, offset_b_start, offset_c_start, &
3402  0, 0, first_set - 1, &
3403  sphi_a, sphi_b, sphi_c, &
3404  sgfa, sgfb, sgfc, &
3405  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3406  my_eri_method, &
3407 pabc=pabc_block, &
3408 
3409 
3410 force_c=force_c(kkind)%forces(:, atom_c), &
3411  do_symmetric=do_symmetric, &
3412  on_diagonal=iatom .EQ. jatom, &
3413 
3414 
3415 
3416  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3417  END IF
3418  IF (.NOT.PRESENT(force_a) .AND. &
3419  .NOT.PRESENT(force_b) .AND. &
3420  PRESENT(force_c) .AND. &
3421  PRESENT(pabc) .AND. &
3422  .NOT.PRESENT(mat_dabc) .AND. &
3423  .NOT.PRESENT(mat_adbc) .AND. &
3424  PRESENT(mat_abdc)) THEN
3425  CALL integrate_set_3c( &
3426  param%par, potential_parameter, &
3427  la_min(iset), la_max(iset), &
3428  lb_min(jset), lb_max(jset), &
3429  lc_min(kset), lc_max(kset), &
3430  npgfa(iset), npgfb(jset), npgfc(kset), &
3431  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3432  ra, rb, rc, &
3433  habc, &
3434  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3435  offset_a_start, offset_b_start, offset_c_start, &
3436  0, 0, first_set - 1, &
3437  sphi_a, sphi_b, sphi_c, &
3438  sgfa, sgfb, sgfc, &
3439  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3440  my_eri_method, &
3441 pabc=pabc_block, &
3442 
3443 
3444 force_c=force_c(kkind)%forces(:, atom_c), &
3445  do_symmetric=do_symmetric, &
3446  on_diagonal=iatom .EQ. jatom, &
3447 
3448 
3449 habdc=habdc, &
3450  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3451  END IF
3452  IF (.NOT.PRESENT(force_a) .AND. &
3453  .NOT.PRESENT(force_b) .AND. &
3454  PRESENT(force_c) .AND. &
3455  PRESENT(pabc) .AND. &
3456  .NOT.PRESENT(mat_dabc) .AND. &
3457  PRESENT(mat_adbc) .AND. &
3458  .NOT.PRESENT(mat_abdc)) THEN
3459  CALL integrate_set_3c( &
3460  param%par, potential_parameter, &
3461  la_min(iset), la_max(iset), &
3462  lb_min(jset), lb_max(jset), &
3463  lc_min(kset), lc_max(kset), &
3464  npgfa(iset), npgfb(jset), npgfc(kset), &
3465  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3466  ra, rb, rc, &
3467  habc, &
3468  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3469  offset_a_start, offset_b_start, offset_c_start, &
3470  0, 0, first_set - 1, &
3471  sphi_a, sphi_b, sphi_c, &
3472  sgfa, sgfb, sgfc, &
3473  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3474  my_eri_method, &
3475 pabc=pabc_block, &
3476 
3477 
3478 force_c=force_c(kkind)%forces(:, atom_c), &
3479  do_symmetric=do_symmetric, &
3480  on_diagonal=iatom .EQ. jatom, &
3481 
3482 hadbc=hadbc, &
3483 
3484  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3485  END IF
3486  IF (.NOT.PRESENT(force_a) .AND. &
3487  .NOT.PRESENT(force_b) .AND. &
3488  PRESENT(force_c) .AND. &
3489  PRESENT(pabc) .AND. &
3490  .NOT.PRESENT(mat_dabc) .AND. &
3491  PRESENT(mat_adbc) .AND. &
3492  PRESENT(mat_abdc)) THEN
3493  CALL integrate_set_3c( &
3494  param%par, potential_parameter, &
3495  la_min(iset), la_max(iset), &
3496  lb_min(jset), lb_max(jset), &
3497  lc_min(kset), lc_max(kset), &
3498  npgfa(iset), npgfb(jset), npgfc(kset), &
3499  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3500  ra, rb, rc, &
3501  habc, &
3502  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3503  offset_a_start, offset_b_start, offset_c_start, &
3504  0, 0, first_set - 1, &
3505  sphi_a, sphi_b, sphi_c, &
3506  sgfa, sgfb, sgfc, &
3507  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3508  my_eri_method, &
3509 pabc=pabc_block, &
3510 
3511 
3512 force_c=force_c(kkind)%forces(:, atom_c), &
3513  do_symmetric=do_symmetric, &
3514  on_diagonal=iatom .EQ. jatom, &
3515 
3516 hadbc=hadbc, &
3517 habdc=habdc, &
3518  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3519  END IF
3520  IF (.NOT.PRESENT(force_a) .AND. &
3521  .NOT.PRESENT(force_b) .AND. &
3522  PRESENT(force_c) .AND. &
3523  PRESENT(pabc) .AND. &
3524  PRESENT(mat_dabc) .AND. &
3525  .NOT.PRESENT(mat_adbc) .AND. &
3526  .NOT.PRESENT(mat_abdc)) THEN
3527  CALL integrate_set_3c( &
3528  param%par, potential_parameter, &
3529  la_min(iset), la_max(iset), &
3530  lb_min(jset), lb_max(jset), &
3531  lc_min(kset), lc_max(kset), &
3532  npgfa(iset), npgfb(jset), npgfc(kset), &
3533  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3534  ra, rb, rc, &
3535  habc, &
3536  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3537  offset_a_start, offset_b_start, offset_c_start, &
3538  0, 0, first_set - 1, &
3539  sphi_a, sphi_b, sphi_c, &
3540  sgfa, sgfb, sgfc, &
3541  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3542  my_eri_method, &
3543 pabc=pabc_block, &
3544 
3545 
3546 force_c=force_c(kkind)%forces(:, atom_c), &
3547  do_symmetric=do_symmetric, &
3548  on_diagonal=iatom .EQ. jatom, &
3549 hdabc=hdabc, &
3550 
3551 
3552  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3553  END IF
3554  IF (.NOT.PRESENT(force_a) .AND. &
3555  .NOT.PRESENT(force_b) .AND. &
3556  PRESENT(force_c) .AND. &
3557  PRESENT(pabc) .AND. &
3558  PRESENT(mat_dabc) .AND. &
3559  .NOT.PRESENT(mat_adbc) .AND. &
3560  PRESENT(mat_abdc)) THEN
3561  CALL integrate_set_3c( &
3562  param%par, potential_parameter, &
3563  la_min(iset), la_max(iset), &
3564  lb_min(jset), lb_max(jset), &
3565  lc_min(kset), lc_max(kset), &
3566  npgfa(iset), npgfb(jset), npgfc(kset), &
3567  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3568  ra, rb, rc, &
3569  habc, &
3570  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3571  offset_a_start, offset_b_start, offset_c_start, &
3572  0, 0, first_set - 1, &
3573  sphi_a, sphi_b, sphi_c, &
3574  sgfa, sgfb, sgfc, &
3575  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3576  my_eri_method, &
3577 pabc=pabc_block, &
3578 
3579 
3580 force_c=force_c(kkind)%forces(:, atom_c), &
3581  do_symmetric=do_symmetric, &
3582  on_diagonal=iatom .EQ. jatom, &
3583 hdabc=hdabc, &
3584 
3585 habdc=habdc, &
3586  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3587  END IF
3588  IF (.NOT.PRESENT(force_a) .AND. &
3589  .NOT.PRESENT(force_b) .AND. &
3590  PRESENT(force_c) .AND. &
3591  PRESENT(pabc) .AND. &
3592  PRESENT(mat_dabc) .AND. &
3593  PRESENT(mat_adbc) .AND. &
3594  .NOT.PRESENT(mat_abdc)) THEN
3595  CALL integrate_set_3c( &
3596  param%par, potential_parameter, &
3597  la_min(iset), la_max(iset), &
3598  lb_min(jset), lb_max(jset), &
3599  lc_min(kset), lc_max(kset), &
3600  npgfa(iset), npgfb(jset), npgfc(kset), &
3601  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3602  ra, rb, rc, &
3603  habc, &
3604  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3605  offset_a_start, offset_b_start, offset_c_start, &
3606  0, 0, first_set - 1, &
3607  sphi_a, sphi_b, sphi_c, &
3608  sgfa, sgfb, sgfc, &
3609  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3610  my_eri_method, &
3611 pabc=pabc_block, &
3612 
3613 
3614 force_c=force_c(kkind)%forces(:, atom_c), &
3615  do_symmetric=do_symmetric, &
3616  on_diagonal=iatom .EQ. jatom, &
3617 hdabc=hdabc, &
3618 hadbc=hadbc, &
3619 
3620  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3621  END IF
3622  IF (.NOT.PRESENT(force_a) .AND. &
3623  .NOT.PRESENT(force_b) .AND. &
3624  PRESENT(force_c) .AND. &
3625  PRESENT(pabc) .AND. &
3626  PRESENT(mat_dabc) .AND. &
3627  PRESENT(mat_adbc) .AND. &
3628  PRESENT(mat_abdc)) THEN
3629  CALL integrate_set_3c( &
3630  param%par, potential_parameter, &
3631  la_min(iset), la_max(iset), &
3632  lb_min(jset), lb_max(jset), &
3633  lc_min(kset), lc_max(kset), &
3634  npgfa(iset), npgfb(jset), npgfc(kset), &
3635  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3636  ra, rb, rc, &
3637  habc, &
3638  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3639  offset_a_start, offset_b_start, offset_c_start, &
3640  0, 0, first_set - 1, &
3641  sphi_a, sphi_b, sphi_c, &
3642  sgfa, sgfb, sgfc, &
3643  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3644  my_eri_method, &
3645 pabc=pabc_block, &
3646 
3647 
3648 force_c=force_c(kkind)%forces(:, atom_c), &
3649  do_symmetric=do_symmetric, &
3650  on_diagonal=iatom .EQ. jatom, &
3651 hdabc=hdabc, &
3652 hadbc=hadbc, &
3653 habdc=habdc, &
3654  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3655  END IF
3656  IF (.NOT.PRESENT(force_a) .AND. &
3657  PRESENT(force_b) .AND. &
3658  .NOT.PRESENT(force_c) .AND. &
3659  PRESENT(pabc) .AND. &
3660  .NOT.PRESENT(mat_dabc) .AND. &
3661  .NOT.PRESENT(mat_adbc) .AND. &
3662  .NOT.PRESENT(mat_abdc)) THEN
3663  CALL integrate_set_3c( &
3664  param%par, potential_parameter, &
3665  la_min(iset), la_max(iset), &
3666  lb_min(jset), lb_max(jset), &
3667  lc_min(kset), lc_max(kset), &
3668  npgfa(iset), npgfb(jset), npgfc(kset), &
3669  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3670  ra, rb, rc, &
3671  habc, &
3672  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3673  offset_a_start, offset_b_start, offset_c_start, &
3674  0, 0, first_set - 1, &
3675  sphi_a, sphi_b, sphi_c, &
3676  sgfa, sgfb, sgfc, &
3677  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3678  my_eri_method, &
3679 pabc=pabc_block, &
3680 
3681 force_b=force_b(jkind)%forces(:, atom_b), &
3682 
3683  do_symmetric=do_symmetric, &
3684  on_diagonal=iatom .EQ. jatom, &
3685 
3686 
3687 
3688  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3689  END IF
3690  IF (.NOT.PRESENT(force_a) .AND. &
3691  PRESENT(force_b) .AND. &
3692  .NOT.PRESENT(force_c) .AND. &
3693  PRESENT(pabc) .AND. &
3694  .NOT.PRESENT(mat_dabc) .AND. &
3695  .NOT.PRESENT(mat_adbc) .AND. &
3696  PRESENT(mat_abdc)) THEN
3697  CALL integrate_set_3c( &
3698  param%par, potential_parameter, &
3699  la_min(iset), la_max(iset), &
3700  lb_min(jset), lb_max(jset), &
3701  lc_min(kset), lc_max(kset), &
3702  npgfa(iset), npgfb(jset), npgfc(kset), &
3703  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3704  ra, rb, rc, &
3705  habc, &
3706  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3707  offset_a_start, offset_b_start, offset_c_start, &
3708  0, 0, first_set - 1, &
3709  sphi_a, sphi_b, sphi_c, &
3710  sgfa, sgfb, sgfc, &
3711  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3712  my_eri_method, &
3713 pabc=pabc_block, &
3714 
3715 force_b=force_b(jkind)%forces(:, atom_b), &
3716 
3717  do_symmetric=do_symmetric, &
3718  on_diagonal=iatom .EQ. jatom, &
3719 
3720 
3721 habdc=habdc, &
3722  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3723  END IF
3724  IF (.NOT.PRESENT(force_a) .AND. &
3725  PRESENT(force_b) .AND. &
3726  .NOT.PRESENT(force_c) .AND. &
3727  PRESENT(pabc) .AND. &
3728  .NOT.PRESENT(mat_dabc) .AND. &
3729  PRESENT(mat_adbc) .AND. &
3730  .NOT.PRESENT(mat_abdc)) THEN
3731  CALL integrate_set_3c( &
3732  param%par, potential_parameter, &
3733  la_min(iset), la_max(iset), &
3734  lb_min(jset), lb_max(jset), &
3735  lc_min(kset), lc_max(kset), &
3736  npgfa(iset), npgfb(jset), npgfc(kset), &
3737  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3738  ra, rb, rc, &
3739  habc, &
3740  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3741  offset_a_start, offset_b_start, offset_c_start, &
3742  0, 0, first_set - 1, &
3743  sphi_a, sphi_b, sphi_c, &
3744  sgfa, sgfb, sgfc, &
3745  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3746  my_eri_method, &
3747 pabc=pabc_block, &
3748 
3749 force_b=force_b(jkind)%forces(:, atom_b), &
3750 
3751  do_symmetric=do_symmetric, &
3752  on_diagonal=iatom .EQ. jatom, &
3753 
3754 hadbc=hadbc, &
3755 
3756  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3757  END IF
3758  IF (.NOT.PRESENT(force_a) .AND. &
3759  PRESENT(force_b) .AND. &
3760  .NOT.PRESENT(force_c) .AND. &
3761  PRESENT(pabc) .AND. &
3762  .NOT.PRESENT(mat_dabc) .AND. &
3763  PRESENT(mat_adbc) .AND. &
3764  PRESENT(mat_abdc)) THEN
3765  CALL integrate_set_3c( &
3766  param%par, potential_parameter, &
3767  la_min(iset), la_max(iset), &
3768  lb_min(jset), lb_max(jset), &
3769  lc_min(kset), lc_max(kset), &
3770  npgfa(iset), npgfb(jset), npgfc(kset), &
3771  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3772  ra, rb, rc, &
3773  habc, &
3774  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3775  offset_a_start, offset_b_start, offset_c_start, &
3776  0, 0, first_set - 1, &
3777  sphi_a, sphi_b, sphi_c, &
3778  sgfa, sgfb, sgfc, &
3779  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3780  my_eri_method, &
3781 pabc=pabc_block, &
3782 
3783 force_b=force_b(jkind)%forces(:, atom_b), &
3784 
3785  do_symmetric=do_symmetric, &
3786  on_diagonal=iatom .EQ. jatom, &
3787 
3788 hadbc=hadbc, &
3789 habdc=habdc, &
3790  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3791  END IF
3792  IF (.NOT.PRESENT(force_a) .AND. &
3793  PRESENT(force_b) .AND. &
3794  .NOT.PRESENT(force_c) .AND. &
3795  PRESENT(pabc) .AND. &
3796  PRESENT(mat_dabc) .AND. &
3797  .NOT.PRESENT(mat_adbc) .AND. &
3798  .NOT.PRESENT(mat_abdc)) THEN
3799  CALL integrate_set_3c( &
3800  param%par, potential_parameter, &
3801  la_min(iset), la_max(iset), &
3802  lb_min(jset), lb_max(jset), &
3803  lc_min(kset), lc_max(kset), &
3804  npgfa(iset), npgfb(jset), npgfc(kset), &
3805  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3806  ra, rb, rc, &
3807  habc, &
3808  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3809  offset_a_start, offset_b_start, offset_c_start, &
3810  0, 0, first_set - 1, &
3811  sphi_a, sphi_b, sphi_c, &
3812  sgfa, sgfb, sgfc, &
3813  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3814  my_eri_method, &
3815 pabc=pabc_block, &
3816 
3817 force_b=force_b(jkind)%forces(:, atom_b), &
3818 
3819  do_symmetric=do_symmetric, &
3820  on_diagonal=iatom .EQ. jatom, &
3821 hdabc=hdabc, &
3822 
3823 
3824  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3825  END IF
3826  IF (.NOT.PRESENT(force_a) .AND. &
3827  PRESENT(force_b) .AND. &
3828  .NOT.PRESENT(force_c) .AND. &
3829  PRESENT(pabc) .AND. &
3830  PRESENT(mat_dabc) .AND. &
3831  .NOT.PRESENT(mat_adbc) .AND. &
3832  PRESENT(mat_abdc)) THEN
3833  CALL integrate_set_3c( &
3834  param%par, potential_parameter, &
3835  la_min(iset), la_max(iset), &
3836  lb_min(jset), lb_max(jset), &
3837  lc_min(kset), lc_max(kset), &
3838  npgfa(iset), npgfb(jset), npgfc(kset), &
3839  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3840  ra, rb, rc, &
3841  habc, &
3842  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3843  offset_a_start, offset_b_start, offset_c_start, &
3844  0, 0, first_set - 1, &
3845  sphi_a, sphi_b, sphi_c, &
3846  sgfa, sgfb, sgfc, &
3847  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3848  my_eri_method, &
3849 pabc=pabc_block, &
3850 
3851 force_b=force_b(jkind)%forces(:, atom_b), &
3852 
3853  do_symmetric=do_symmetric, &
3854  on_diagonal=iatom .EQ. jatom, &
3855 hdabc=hdabc, &
3856 
3857 habdc=habdc, &
3858  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3859  END IF
3860  IF (.NOT.PRESENT(force_a) .AND. &
3861  PRESENT(force_b) .AND. &
3862  .NOT.PRESENT(force_c) .AND. &
3863  PRESENT(pabc) .AND. &
3864  PRESENT(mat_dabc) .AND. &
3865  PRESENT(mat_adbc) .AND. &
3866  .NOT.PRESENT(mat_abdc)) THEN
3867  CALL integrate_set_3c( &
3868  param%par, potential_parameter, &
3869  la_min(iset), la_max(iset), &
3870  lb_min(jset), lb_max(jset), &
3871  lc_min(kset), lc_max(kset), &
3872  npgfa(iset), npgfb(jset), npgfc(kset), &
3873  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3874  ra, rb, rc, &
3875  habc, &
3876  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3877  offset_a_start, offset_b_start, offset_c_start, &
3878  0, 0, first_set - 1, &
3879  sphi_a, sphi_b, sphi_c, &
3880  sgfa, sgfb, sgfc, &
3881  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3882  my_eri_method, &
3883 pabc=pabc_block, &
3884 
3885 force_b=force_b(jkind)%forces(:, atom_b), &
3886 
3887  do_symmetric=do_symmetric, &
3888  on_diagonal=iatom .EQ. jatom, &
3889 hdabc=hdabc, &
3890 hadbc=hadbc, &
3891 
3892  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3893  END IF
3894  IF (.NOT.PRESENT(force_a) .AND. &
3895  PRESENT(force_b) .AND. &
3896  .NOT.PRESENT(force_c) .AND. &
3897  PRESENT(pabc) .AND. &
3898  PRESENT(mat_dabc) .AND. &
3899  PRESENT(mat_adbc) .AND. &
3900  PRESENT(mat_abdc)) THEN
3901  CALL integrate_set_3c( &
3902  param%par, potential_parameter, &
3903  la_min(iset), la_max(iset), &
3904  lb_min(jset), lb_max(jset), &
3905  lc_min(kset), lc_max(kset), &
3906  npgfa(iset), npgfb(jset), npgfc(kset), &
3907  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3908  ra, rb, rc, &
3909  habc, &
3910  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3911  offset_a_start, offset_b_start, offset_c_start, &
3912  0, 0, first_set - 1, &
3913  sphi_a, sphi_b, sphi_c, &
3914  sgfa, sgfb, sgfc, &
3915  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3916  my_eri_method, &
3917 pabc=pabc_block, &
3918 
3919 force_b=force_b(jkind)%forces(:, atom_b), &
3920 
3921  do_symmetric=do_symmetric, &
3922  on_diagonal=iatom .EQ. jatom, &
3923 hdabc=hdabc, &
3924 hadbc=hadbc, &
3925 habdc=habdc, &
3926  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3927  END IF
3928  IF (.NOT.PRESENT(force_a) .AND. &
3929  PRESENT(force_b) .AND. &
3930  PRESENT(force_c) .AND. &
3931  PRESENT(pabc) .AND. &
3932  .NOT.PRESENT(mat_dabc) .AND. &
3933  .NOT.PRESENT(mat_adbc) .AND. &
3934  .NOT.PRESENT(mat_abdc)) THEN
3935  CALL integrate_set_3c( &
3936  param%par, potential_parameter, &
3937  la_min(iset), la_max(iset), &
3938  lb_min(jset), lb_max(jset), &
3939  lc_min(kset), lc_max(kset), &
3940  npgfa(iset), npgfb(jset), npgfc(kset), &
3941  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3942  ra, rb, rc, &
3943  habc, &
3944  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3945  offset_a_start, offset_b_start, offset_c_start, &
3946  0, 0, first_set - 1, &
3947  sphi_a, sphi_b, sphi_c, &
3948  sgfa, sgfb, sgfc, &
3949  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3950  my_eri_method, &
3951 pabc=pabc_block, &
3952 
3953 force_b=force_b(jkind)%forces(:, atom_b), &
3954 force_c=force_c(kkind)%forces(:, atom_c), &
3955  do_symmetric=do_symmetric, &
3956  on_diagonal=iatom .EQ. jatom, &
3957 
3958 
3959 
3960  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3961  END IF
3962  IF (.NOT.PRESENT(force_a) .AND. &
3963  PRESENT(force_b) .AND. &
3964  PRESENT(force_c) .AND. &
3965  PRESENT(pabc) .AND. &
3966  .NOT.PRESENT(mat_dabc) .AND. &
3967  .NOT.PRESENT(mat_adbc) .AND. &
3968  PRESENT(mat_abdc)) THEN
3969  CALL integrate_set_3c( &
3970  param%par, potential_parameter, &
3971  la_min(iset), la_max(iset), &
3972  lb_min(jset), lb_max(jset), &
3973  lc_min(kset), lc_max(kset), &
3974  npgfa(iset), npgfb(jset), npgfc(kset), &
3975  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
3976  ra, rb, rc, &
3977  habc, &
3978  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
3979  offset_a_start, offset_b_start, offset_c_start, &
3980  0, 0, first_set - 1, &
3981  sphi_a, sphi_b, sphi_c, &
3982  sgfa, sgfb, sgfc, &
3983  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
3984  my_eri_method, &
3985 pabc=pabc_block, &
3986 
3987 force_b=force_b(jkind)%forces(:, atom_b), &
3988 force_c=force_c(kkind)%forces(:, atom_c), &
3989  do_symmetric=do_symmetric, &
3990  on_diagonal=iatom .EQ. jatom, &
3991 
3992 
3993 habdc=habdc, &
3994  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
3995  END IF
3996  IF (.NOT.PRESENT(force_a) .AND. &
3997  PRESENT(force_b) .AND. &
3998  PRESENT(force_c) .AND. &
3999  PRESENT(pabc) .AND. &
4000  .NOT.PRESENT(mat_dabc) .AND. &
4001  PRESENT(mat_adbc) .AND. &
4002  .NOT.PRESENT(mat_abdc)) THEN
4003  CALL integrate_set_3c( &
4004  param%par, potential_parameter, &
4005  la_min(iset), la_max(iset), &
4006  lb_min(jset), lb_max(jset), &
4007  lc_min(kset), lc_max(kset), &
4008  npgfa(iset), npgfb(jset), npgfc(kset), &
4009  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4010  ra, rb, rc, &
4011  habc, &
4012  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4013  offset_a_start, offset_b_start, offset_c_start, &
4014  0, 0, first_set - 1, &
4015  sphi_a, sphi_b, sphi_c, &
4016  sgfa, sgfb, sgfc, &
4017  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4018  my_eri_method, &
4019 pabc=pabc_block, &
4020 
4021 force_b=force_b(jkind)%forces(:, atom_b), &
4022 force_c=force_c(kkind)%forces(:, atom_c), &
4023  do_symmetric=do_symmetric, &
4024  on_diagonal=iatom .EQ. jatom, &
4025 
4026 hadbc=hadbc, &
4027 
4028  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4029  END IF
4030  IF (.NOT.PRESENT(force_a) .AND. &
4031  PRESENT(force_b) .AND. &
4032  PRESENT(force_c) .AND. &
4033  PRESENT(pabc) .AND. &
4034  .NOT.PRESENT(mat_dabc) .AND. &
4035  PRESENT(mat_adbc) .AND. &
4036  PRESENT(mat_abdc)) THEN
4037  CALL integrate_set_3c( &
4038  param%par, potential_parameter, &
4039  la_min(iset), la_max(iset), &
4040  lb_min(jset), lb_max(jset), &
4041  lc_min(kset), lc_max(kset), &
4042  npgfa(iset), npgfb(jset), npgfc(kset), &
4043  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4044  ra, rb, rc, &
4045  habc, &
4046  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4047  offset_a_start, offset_b_start, offset_c_start, &
4048  0, 0, first_set - 1, &
4049  sphi_a, sphi_b, sphi_c, &
4050  sgfa, sgfb, sgfc, &
4051  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4052  my_eri_method, &
4053 pabc=pabc_block, &
4054 
4055 force_b=force_b(jkind)%forces(:, atom_b), &
4056 force_c=force_c(kkind)%forces(:, atom_c), &
4057  do_symmetric=do_symmetric, &
4058  on_diagonal=iatom .EQ. jatom, &
4059 
4060 hadbc=hadbc, &
4061 habdc=habdc, &
4062  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4063  END IF
4064  IF (.NOT.PRESENT(force_a) .AND. &
4065  PRESENT(force_b) .AND. &
4066  PRESENT(force_c) .AND. &
4067  PRESENT(pabc) .AND. &
4068  PRESENT(mat_dabc) .AND. &
4069  .NOT.PRESENT(mat_adbc) .AND. &
4070  .NOT.PRESENT(mat_abdc)) THEN
4071  CALL integrate_set_3c( &
4072  param%par, potential_parameter, &
4073  la_min(iset), la_max(iset), &
4074  lb_min(jset), lb_max(jset), &
4075  lc_min(kset), lc_max(kset), &
4076  npgfa(iset), npgfb(jset), npgfc(kset), &
4077  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4078  ra, rb, rc, &
4079  habc, &
4080  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4081  offset_a_start, offset_b_start, offset_c_start, &
4082  0, 0, first_set - 1, &
4083  sphi_a, sphi_b, sphi_c, &
4084  sgfa, sgfb, sgfc, &
4085  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4086  my_eri_method, &
4087 pabc=pabc_block, &
4088 
4089 force_b=force_b(jkind)%forces(:, atom_b), &
4090 force_c=force_c(kkind)%forces(:, atom_c), &
4091  do_symmetric=do_symmetric, &
4092  on_diagonal=iatom .EQ. jatom, &
4093 hdabc=hdabc, &
4094 
4095 
4096  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4097  END IF
4098  IF (.NOT.PRESENT(force_a) .AND. &
4099  PRESENT(force_b) .AND. &
4100  PRESENT(force_c) .AND. &
4101  PRESENT(pabc) .AND. &
4102  PRESENT(mat_dabc) .AND. &
4103  .NOT.PRESENT(mat_adbc) .AND. &
4104  PRESENT(mat_abdc)) THEN
4105  CALL integrate_set_3c( &
4106  param%par, potential_parameter, &
4107  la_min(iset), la_max(iset), &
4108  lb_min(jset), lb_max(jset), &
4109  lc_min(kset), lc_max(kset), &
4110  npgfa(iset), npgfb(jset), npgfc(kset), &
4111  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4112  ra, rb, rc, &
4113  habc, &
4114  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4115  offset_a_start, offset_b_start, offset_c_start, &
4116  0, 0, first_set - 1, &
4117  sphi_a, sphi_b, sphi_c, &
4118  sgfa, sgfb, sgfc, &
4119  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4120  my_eri_method, &
4121 pabc=pabc_block, &
4122 
4123 force_b=force_b(jkind)%forces(:, atom_b), &
4124 force_c=force_c(kkind)%forces(:, atom_c), &
4125  do_symmetric=do_symmetric, &
4126  on_diagonal=iatom .EQ. jatom, &
4127 hdabc=hdabc, &
4128 
4129 habdc=habdc, &
4130  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4131  END IF
4132  IF (.NOT.PRESENT(force_a) .AND. &
4133  PRESENT(force_b) .AND. &
4134  PRESENT(force_c) .AND. &
4135  PRESENT(pabc) .AND. &
4136  PRESENT(mat_dabc) .AND. &
4137  PRESENT(mat_adbc) .AND. &
4138  .NOT.PRESENT(mat_abdc)) THEN
4139  CALL integrate_set_3c( &
4140  param%par, potential_parameter, &
4141  la_min(iset), la_max(iset), &
4142  lb_min(jset), lb_max(jset), &
4143  lc_min(kset), lc_max(kset), &
4144  npgfa(iset), npgfb(jset), npgfc(kset), &
4145  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4146  ra, rb, rc, &
4147  habc, &
4148  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4149  offset_a_start, offset_b_start, offset_c_start, &
4150  0, 0, first_set - 1, &
4151  sphi_a, sphi_b, sphi_c, &
4152  sgfa, sgfb, sgfc, &
4153  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4154  my_eri_method, &
4155 pabc=pabc_block, &
4156 
4157 force_b=force_b(jkind)%forces(:, atom_b), &
4158 force_c=force_c(kkind)%forces(:, atom_c), &
4159  do_symmetric=do_symmetric, &
4160  on_diagonal=iatom .EQ. jatom, &
4161 hdabc=hdabc, &
4162 hadbc=hadbc, &
4163 
4164  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4165  END IF
4166  IF (.NOT.PRESENT(force_a) .AND. &
4167  PRESENT(force_b) .AND. &
4168  PRESENT(force_c) .AND. &
4169  PRESENT(pabc) .AND. &
4170  PRESENT(mat_dabc) .AND. &
4171  PRESENT(mat_adbc) .AND. &
4172  PRESENT(mat_abdc)) THEN
4173  CALL integrate_set_3c( &
4174  param%par, potential_parameter, &
4175  la_min(iset), la_max(iset), &
4176  lb_min(jset), lb_max(jset), &
4177  lc_min(kset), lc_max(kset), &
4178  npgfa(iset), npgfb(jset), npgfc(kset), &
4179  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4180  ra, rb, rc, &
4181  habc, &
4182  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4183  offset_a_start, offset_b_start, offset_c_start, &
4184  0, 0, first_set - 1, &
4185  sphi_a, sphi_b, sphi_c, &
4186  sgfa, sgfb, sgfc, &
4187  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4188  my_eri_method, &
4189 pabc=pabc_block, &
4190 
4191 force_b=force_b(jkind)%forces(:, atom_b), &
4192 force_c=force_c(kkind)%forces(:, atom_c), &
4193  do_symmetric=do_symmetric, &
4194  on_diagonal=iatom .EQ. jatom, &
4195 hdabc=hdabc, &
4196 hadbc=hadbc, &
4197 habdc=habdc, &
4198  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4199  END IF
4200  IF (PRESENT(force_a) .AND. &
4201  .NOT.PRESENT(force_b) .AND. &
4202  .NOT.PRESENT(force_c) .AND. &
4203  PRESENT(pabc) .AND. &
4204  .NOT.PRESENT(mat_dabc) .AND. &
4205  .NOT.PRESENT(mat_adbc) .AND. &
4206  .NOT.PRESENT(mat_abdc)) THEN
4207  CALL integrate_set_3c( &
4208  param%par, potential_parameter, &
4209  la_min(iset), la_max(iset), &
4210  lb_min(jset), lb_max(jset), &
4211  lc_min(kset), lc_max(kset), &
4212  npgfa(iset), npgfb(jset), npgfc(kset), &
4213  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4214  ra, rb, rc, &
4215  habc, &
4216  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4217  offset_a_start, offset_b_start, offset_c_start, &
4218  0, 0, first_set - 1, &
4219  sphi_a, sphi_b, sphi_c, &
4220  sgfa, sgfb, sgfc, &
4221  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4222  my_eri_method, &
4223 pabc=pabc_block, &
4224 force_a=force_a(ikind)%forces(:, atom_a), &
4225 
4226 
4227  do_symmetric=do_symmetric, &
4228  on_diagonal=iatom .EQ. jatom, &
4229 
4230 
4231 
4232  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4233  END IF
4234  IF (PRESENT(force_a) .AND. &
4235  .NOT.PRESENT(force_b) .AND. &
4236  .NOT.PRESENT(force_c) .AND. &
4237  PRESENT(pabc) .AND. &
4238  .NOT.PRESENT(mat_dabc) .AND. &
4239  .NOT.PRESENT(mat_adbc) .AND. &
4240  PRESENT(mat_abdc)) THEN
4241  CALL integrate_set_3c( &
4242  param%par, potential_parameter, &
4243  la_min(iset), la_max(iset), &
4244  lb_min(jset), lb_max(jset), &
4245  lc_min(kset), lc_max(kset), &
4246  npgfa(iset), npgfb(jset), npgfc(kset), &
4247  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4248  ra, rb, rc, &
4249  habc, &
4250  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4251  offset_a_start, offset_b_start, offset_c_start, &
4252  0, 0, first_set - 1, &
4253  sphi_a, sphi_b, sphi_c, &
4254  sgfa, sgfb, sgfc, &
4255  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4256  my_eri_method, &
4257 pabc=pabc_block, &
4258 force_a=force_a(ikind)%forces(:, atom_a), &
4259 
4260 
4261  do_symmetric=do_symmetric, &
4262  on_diagonal=iatom .EQ. jatom, &
4263 
4264 
4265 habdc=habdc, &
4266  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4267  END IF
4268  IF (PRESENT(force_a) .AND. &
4269  .NOT.PRESENT(force_b) .AND. &
4270  .NOT.PRESENT(force_c) .AND. &
4271  PRESENT(pabc) .AND. &
4272  .NOT.PRESENT(mat_dabc) .AND. &
4273  PRESENT(mat_adbc) .AND. &
4274  .NOT.PRESENT(mat_abdc)) THEN
4275  CALL integrate_set_3c( &
4276  param%par, potential_parameter, &
4277  la_min(iset), la_max(iset), &
4278  lb_min(jset), lb_max(jset), &
4279  lc_min(kset), lc_max(kset), &
4280  npgfa(iset), npgfb(jset), npgfc(kset), &
4281  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4282  ra, rb, rc, &
4283  habc, &
4284  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4285  offset_a_start, offset_b_start, offset_c_start, &
4286  0, 0, first_set - 1, &
4287  sphi_a, sphi_b, sphi_c, &
4288  sgfa, sgfb, sgfc, &
4289  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4290  my_eri_method, &
4291 pabc=pabc_block, &
4292 force_a=force_a(ikind)%forces(:, atom_a), &
4293 
4294 
4295  do_symmetric=do_symmetric, &
4296  on_diagonal=iatom .EQ. jatom, &
4297 
4298 hadbc=hadbc, &
4299 
4300  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4301  END IF
4302  IF (PRESENT(force_a) .AND. &
4303  .NOT.PRESENT(force_b) .AND. &
4304  .NOT.PRESENT(force_c) .AND. &
4305  PRESENT(pabc) .AND. &
4306  .NOT.PRESENT(mat_dabc) .AND. &
4307  PRESENT(mat_adbc) .AND. &
4308  PRESENT(mat_abdc)) THEN
4309  CALL integrate_set_3c( &
4310  param%par, potential_parameter, &
4311  la_min(iset), la_max(iset), &
4312  lb_min(jset), lb_max(jset), &
4313  lc_min(kset), lc_max(kset), &
4314  npgfa(iset), npgfb(jset), npgfc(kset), &
4315  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4316  ra, rb, rc, &
4317  habc, &
4318  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4319  offset_a_start, offset_b_start, offset_c_start, &
4320  0, 0, first_set - 1, &
4321  sphi_a, sphi_b, sphi_c, &
4322  sgfa, sgfb, sgfc, &
4323  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4324  my_eri_method, &
4325 pabc=pabc_block, &
4326 force_a=force_a(ikind)%forces(:, atom_a), &
4327 
4328 
4329  do_symmetric=do_symmetric, &
4330  on_diagonal=iatom .EQ. jatom, &
4331 
4332 hadbc=hadbc, &
4333 habdc=habdc, &
4334  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4335  END IF
4336  IF (PRESENT(force_a) .AND. &
4337  .NOT.PRESENT(force_b) .AND. &
4338  .NOT.PRESENT(force_c) .AND. &
4339  PRESENT(pabc) .AND. &
4340  PRESENT(mat_dabc) .AND. &
4341  .NOT.PRESENT(mat_adbc) .AND. &
4342  .NOT.PRESENT(mat_abdc)) THEN
4343  CALL integrate_set_3c( &
4344  param%par, potential_parameter, &
4345  la_min(iset), la_max(iset), &
4346  lb_min(jset), lb_max(jset), &
4347  lc_min(kset), lc_max(kset), &
4348  npgfa(iset), npgfb(jset), npgfc(kset), &
4349  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4350  ra, rb, rc, &
4351  habc, &
4352  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4353  offset_a_start, offset_b_start, offset_c_start, &
4354  0, 0, first_set - 1, &
4355  sphi_a, sphi_b, sphi_c, &
4356  sgfa, sgfb, sgfc, &
4357  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4358  my_eri_method, &
4359 pabc=pabc_block, &
4360 force_a=force_a(ikind)%forces(:, atom_a), &
4361 
4362 
4363  do_symmetric=do_symmetric, &
4364  on_diagonal=iatom .EQ. jatom, &
4365 hdabc=hdabc, &
4366 
4367 
4368  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4369  END IF
4370  IF (PRESENT(force_a) .AND. &
4371  .NOT.PRESENT(force_b) .AND. &
4372  .NOT.PRESENT(force_c) .AND. &
4373  PRESENT(pabc) .AND. &
4374  PRESENT(mat_dabc) .AND. &
4375  .NOT.PRESENT(mat_adbc) .AND. &
4376  PRESENT(mat_abdc)) THEN
4377  CALL integrate_set_3c( &
4378  param%par, potential_parameter, &
4379  la_min(iset), la_max(iset), &
4380  lb_min(jset), lb_max(jset), &
4381  lc_min(kset), lc_max(kset), &
4382  npgfa(iset), npgfb(jset), npgfc(kset), &
4383  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4384  ra, rb, rc, &
4385  habc, &
4386  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4387  offset_a_start, offset_b_start, offset_c_start, &
4388  0, 0, first_set - 1, &
4389  sphi_a, sphi_b, sphi_c, &
4390  sgfa, sgfb, sgfc, &
4391  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4392  my_eri_method, &
4393 pabc=pabc_block, &
4394 force_a=force_a(ikind)%forces(:, atom_a), &
4395 
4396 
4397  do_symmetric=do_symmetric, &
4398  on_diagonal=iatom .EQ. jatom, &
4399 hdabc=hdabc, &
4400 
4401 habdc=habdc, &
4402  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4403  END IF
4404  IF (PRESENT(force_a) .AND. &
4405  .NOT.PRESENT(force_b) .AND. &
4406  .NOT.PRESENT(force_c) .AND. &
4407  PRESENT(pabc) .AND. &
4408  PRESENT(mat_dabc) .AND. &
4409  PRESENT(mat_adbc) .AND. &
4410  .NOT.PRESENT(mat_abdc)) THEN
4411  CALL integrate_set_3c( &
4412  param%par, potential_parameter, &
4413  la_min(iset), la_max(iset), &
4414  lb_min(jset), lb_max(jset), &
4415  lc_min(kset), lc_max(kset), &
4416  npgfa(iset), npgfb(jset), npgfc(kset), &
4417  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4418  ra, rb, rc, &
4419  habc, &
4420  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4421  offset_a_start, offset_b_start, offset_c_start, &
4422  0, 0, first_set - 1, &
4423  sphi_a, sphi_b, sphi_c, &
4424  sgfa, sgfb, sgfc, &
4425  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4426  my_eri_method, &
4427 pabc=pabc_block, &
4428 force_a=force_a(ikind)%forces(:, atom_a), &
4429 
4430 
4431  do_symmetric=do_symmetric, &
4432  on_diagonal=iatom .EQ. jatom, &
4433 hdabc=hdabc, &
4434 hadbc=hadbc, &
4435 
4436  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4437  END IF
4438  IF (PRESENT(force_a) .AND. &
4439  .NOT.PRESENT(force_b) .AND. &
4440  .NOT.PRESENT(force_c) .AND. &
4441  PRESENT(pabc) .AND. &
4442  PRESENT(mat_dabc) .AND. &
4443  PRESENT(mat_adbc) .AND. &
4444  PRESENT(mat_abdc)) THEN
4445  CALL integrate_set_3c( &
4446  param%par, potential_parameter, &
4447  la_min(iset), la_max(iset), &
4448  lb_min(jset), lb_max(jset), &
4449  lc_min(kset), lc_max(kset), &
4450  npgfa(iset), npgfb(jset), npgfc(kset), &
4451  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4452  ra, rb, rc, &
4453  habc, &
4454  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4455  offset_a_start, offset_b_start, offset_c_start, &
4456  0, 0, first_set - 1, &
4457  sphi_a, sphi_b, sphi_c, &
4458  sgfa, sgfb, sgfc, &
4459  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4460  my_eri_method, &
4461 pabc=pabc_block, &
4462 force_a=force_a(ikind)%forces(:, atom_a), &
4463 
4464 
4465  do_symmetric=do_symmetric, &
4466  on_diagonal=iatom .EQ. jatom, &
4467 hdabc=hdabc, &
4468 hadbc=hadbc, &
4469 habdc=habdc, &
4470  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4471  END IF
4472  IF (PRESENT(force_a) .AND. &
4473  .NOT.PRESENT(force_b) .AND. &
4474  PRESENT(force_c) .AND. &
4475  PRESENT(pabc) .AND. &
4476  .NOT.PRESENT(mat_dabc) .AND. &
4477  .NOT.PRESENT(mat_adbc) .AND. &
4478  .NOT.PRESENT(mat_abdc)) THEN
4479  CALL integrate_set_3c( &
4480  param%par, potential_parameter, &
4481  la_min(iset), la_max(iset), &
4482  lb_min(jset), lb_max(jset), &
4483  lc_min(kset), lc_max(kset), &
4484  npgfa(iset), npgfb(jset), npgfc(kset), &
4485  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4486  ra, rb, rc, &
4487  habc, &
4488  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4489  offset_a_start, offset_b_start, offset_c_start, &
4490  0, 0, first_set - 1, &
4491  sphi_a, sphi_b, sphi_c, &
4492  sgfa, sgfb, sgfc, &
4493  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4494  my_eri_method, &
4495 pabc=pabc_block, &
4496 force_a=force_a(ikind)%forces(:, atom_a), &
4497 
4498 force_c=force_c(kkind)%forces(:, atom_c), &
4499  do_symmetric=do_symmetric, &
4500  on_diagonal=iatom .EQ. jatom, &
4501 
4502 
4503 
4504  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4505  END IF
4506  IF (PRESENT(force_a) .AND. &
4507  .NOT.PRESENT(force_b) .AND. &
4508  PRESENT(force_c) .AND. &
4509  PRESENT(pabc) .AND. &
4510  .NOT.PRESENT(mat_dabc) .AND. &
4511  .NOT.PRESENT(mat_adbc) .AND. &
4512  PRESENT(mat_abdc)) THEN
4513  CALL integrate_set_3c( &
4514  param%par, potential_parameter, &
4515  la_min(iset), la_max(iset), &
4516  lb_min(jset), lb_max(jset), &
4517  lc_min(kset), lc_max(kset), &
4518  npgfa(iset), npgfb(jset), npgfc(kset), &
4519  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4520  ra, rb, rc, &
4521  habc, &
4522  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4523  offset_a_start, offset_b_start, offset_c_start, &
4524  0, 0, first_set - 1, &
4525  sphi_a, sphi_b, sphi_c, &
4526  sgfa, sgfb, sgfc, &
4527  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4528  my_eri_method, &
4529 pabc=pabc_block, &
4530 force_a=force_a(ikind)%forces(:, atom_a), &
4531 
4532 force_c=force_c(kkind)%forces(:, atom_c), &
4533  do_symmetric=do_symmetric, &
4534  on_diagonal=iatom .EQ. jatom, &
4535 
4536 
4537 habdc=habdc, &
4538  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4539  END IF
4540  IF (PRESENT(force_a) .AND. &
4541  .NOT.PRESENT(force_b) .AND. &
4542  PRESENT(force_c) .AND. &
4543  PRESENT(pabc) .AND. &
4544  .NOT.PRESENT(mat_dabc) .AND. &
4545  PRESENT(mat_adbc) .AND. &
4546  .NOT.PRESENT(mat_abdc)) THEN
4547  CALL integrate_set_3c( &
4548  param%par, potential_parameter, &
4549  la_min(iset), la_max(iset), &
4550  lb_min(jset), lb_max(jset), &
4551  lc_min(kset), lc_max(kset), &
4552  npgfa(iset), npgfb(jset), npgfc(kset), &
4553  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4554  ra, rb, rc, &
4555  habc, &
4556  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4557  offset_a_start, offset_b_start, offset_c_start, &
4558  0, 0, first_set - 1, &
4559  sphi_a, sphi_b, sphi_c, &
4560  sgfa, sgfb, sgfc, &
4561  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4562  my_eri_method, &
4563 pabc=pabc_block, &
4564 force_a=force_a(ikind)%forces(:, atom_a), &
4565 
4566 force_c=force_c(kkind)%forces(:, atom_c), &
4567  do_symmetric=do_symmetric, &
4568  on_diagonal=iatom .EQ. jatom, &
4569 
4570 hadbc=hadbc, &
4571 
4572  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4573  END IF
4574  IF (PRESENT(force_a) .AND. &
4575  .NOT.PRESENT(force_b) .AND. &
4576  PRESENT(force_c) .AND. &
4577  PRESENT(pabc) .AND. &
4578  .NOT.PRESENT(mat_dabc) .AND. &
4579  PRESENT(mat_adbc) .AND. &
4580  PRESENT(mat_abdc)) THEN
4581  CALL integrate_set_3c( &
4582  param%par, potential_parameter, &
4583  la_min(iset), la_max(iset), &
4584  lb_min(jset), lb_max(jset), &
4585  lc_min(kset), lc_max(kset), &
4586  npgfa(iset), npgfb(jset), npgfc(kset), &
4587  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4588  ra, rb, rc, &
4589  habc, &
4590  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4591  offset_a_start, offset_b_start, offset_c_start, &
4592  0, 0, first_set - 1, &
4593  sphi_a, sphi_b, sphi_c, &
4594  sgfa, sgfb, sgfc, &
4595  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4596  my_eri_method, &
4597 pabc=pabc_block, &
4598 force_a=force_a(ikind)%forces(:, atom_a), &
4599 
4600 force_c=force_c(kkind)%forces(:, atom_c), &
4601  do_symmetric=do_symmetric, &
4602  on_diagonal=iatom .EQ. jatom, &
4603 
4604 hadbc=hadbc, &
4605 habdc=habdc, &
4606  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4607  END IF
4608  IF (PRESENT(force_a) .AND. &
4609  .NOT.PRESENT(force_b) .AND. &
4610  PRESENT(force_c) .AND. &
4611  PRESENT(pabc) .AND. &
4612  PRESENT(mat_dabc) .AND. &
4613  .NOT.PRESENT(mat_adbc) .AND. &
4614  .NOT.PRESENT(mat_abdc)) THEN
4615  CALL integrate_set_3c( &
4616  param%par, potential_parameter, &
4617  la_min(iset), la_max(iset), &
4618  lb_min(jset), lb_max(jset), &
4619  lc_min(kset), lc_max(kset), &
4620  npgfa(iset), npgfb(jset), npgfc(kset), &
4621  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4622  ra, rb, rc, &
4623  habc, &
4624  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4625  offset_a_start, offset_b_start, offset_c_start, &
4626  0, 0, first_set - 1, &
4627  sphi_a, sphi_b, sphi_c, &
4628  sgfa, sgfb, sgfc, &
4629  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4630  my_eri_method, &
4631 pabc=pabc_block, &
4632 force_a=force_a(ikind)%forces(:, atom_a), &
4633 
4634 force_c=force_c(kkind)%forces(:, atom_c), &
4635  do_symmetric=do_symmetric, &
4636  on_diagonal=iatom .EQ. jatom, &
4637 hdabc=hdabc, &
4638 
4639 
4640  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4641  END IF
4642  IF (PRESENT(force_a) .AND. &
4643  .NOT.PRESENT(force_b) .AND. &
4644  PRESENT(force_c) .AND. &
4645  PRESENT(pabc) .AND. &
4646  PRESENT(mat_dabc) .AND. &
4647  .NOT.PRESENT(mat_adbc) .AND. &
4648  PRESENT(mat_abdc)) THEN
4649  CALL integrate_set_3c( &
4650  param%par, potential_parameter, &
4651  la_min(iset), la_max(iset), &
4652  lb_min(jset), lb_max(jset), &
4653  lc_min(kset), lc_max(kset), &
4654  npgfa(iset), npgfb(jset), npgfc(kset), &
4655  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4656  ra, rb, rc, &
4657  habc, &
4658  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4659  offset_a_start, offset_b_start, offset_c_start, &
4660  0, 0, first_set - 1, &
4661  sphi_a, sphi_b, sphi_c, &
4662  sgfa, sgfb, sgfc, &
4663  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4664  my_eri_method, &
4665 pabc=pabc_block, &
4666 force_a=force_a(ikind)%forces(:, atom_a), &
4667 
4668 force_c=force_c(kkind)%forces(:, atom_c), &
4669  do_symmetric=do_symmetric, &
4670  on_diagonal=iatom .EQ. jatom, &
4671 hdabc=hdabc, &
4672 
4673 habdc=habdc, &
4674  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4675  END IF
4676  IF (PRESENT(force_a) .AND. &
4677  .NOT.PRESENT(force_b) .AND. &
4678  PRESENT(force_c) .AND. &
4679  PRESENT(pabc) .AND. &
4680  PRESENT(mat_dabc) .AND. &
4681  PRESENT(mat_adbc) .AND. &
4682  .NOT.PRESENT(mat_abdc)) THEN
4683  CALL integrate_set_3c( &
4684  param%par, potential_parameter, &
4685  la_min(iset), la_max(iset), &
4686  lb_min(jset), lb_max(jset), &
4687  lc_min(kset), lc_max(kset), &
4688  npgfa(iset), npgfb(jset), npgfc(kset), &
4689  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4690  ra, rb, rc, &
4691  habc, &
4692  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4693  offset_a_start, offset_b_start, offset_c_start, &
4694  0, 0, first_set - 1, &
4695  sphi_a, sphi_b, sphi_c, &
4696  sgfa, sgfb, sgfc, &
4697  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4698  my_eri_method, &
4699 pabc=pabc_block, &
4700 force_a=force_a(ikind)%forces(:, atom_a), &
4701 
4702 force_c=force_c(kkind)%forces(:, atom_c), &
4703  do_symmetric=do_symmetric, &
4704  on_diagonal=iatom .EQ. jatom, &
4705 hdabc=hdabc, &
4706 hadbc=hadbc, &
4707 
4708  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4709  END IF
4710  IF (PRESENT(force_a) .AND. &
4711  .NOT.PRESENT(force_b) .AND. &
4712  PRESENT(force_c) .AND. &
4713  PRESENT(pabc) .AND. &
4714  PRESENT(mat_dabc) .AND. &
4715  PRESENT(mat_adbc) .AND. &
4716  PRESENT(mat_abdc)) THEN
4717  CALL integrate_set_3c( &
4718  param%par, potential_parameter, &
4719  la_min(iset), la_max(iset), &
4720  lb_min(jset), lb_max(jset), &
4721  lc_min(kset), lc_max(kset), &
4722  npgfa(iset), npgfb(jset), npgfc(kset), &
4723  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4724  ra, rb, rc, &
4725  habc, &
4726  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4727  offset_a_start, offset_b_start, offset_c_start, &
4728  0, 0, first_set - 1, &
4729  sphi_a, sphi_b, sphi_c, &
4730  sgfa, sgfb, sgfc, &
4731  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4732  my_eri_method, &
4733 pabc=pabc_block, &
4734 force_a=force_a(ikind)%forces(:, atom_a), &
4735 
4736 force_c=force_c(kkind)%forces(:, atom_c), &
4737  do_symmetric=do_symmetric, &
4738  on_diagonal=iatom .EQ. jatom, &
4739 hdabc=hdabc, &
4740 hadbc=hadbc, &
4741 habdc=habdc, &
4742  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4743  END IF
4744  IF (PRESENT(force_a) .AND. &
4745  PRESENT(force_b) .AND. &
4746  .NOT.PRESENT(force_c) .AND. &
4747  PRESENT(pabc) .AND. &
4748  .NOT.PRESENT(mat_dabc) .AND. &
4749  .NOT.PRESENT(mat_adbc) .AND. &
4750  .NOT.PRESENT(mat_abdc)) THEN
4751  CALL integrate_set_3c( &
4752  param%par, potential_parameter, &
4753  la_min(iset), la_max(iset), &
4754  lb_min(jset), lb_max(jset), &
4755  lc_min(kset), lc_max(kset), &
4756  npgfa(iset), npgfb(jset), npgfc(kset), &
4757  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4758  ra, rb, rc, &
4759  habc, &
4760  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4761  offset_a_start, offset_b_start, offset_c_start, &
4762  0, 0, first_set - 1, &
4763  sphi_a, sphi_b, sphi_c, &
4764  sgfa, sgfb, sgfc, &
4765  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4766  my_eri_method, &
4767 pabc=pabc_block, &
4768 force_a=force_a(ikind)%forces(:, atom_a), &
4769 force_b=force_b(jkind)%forces(:, atom_b), &
4770 
4771  do_symmetric=do_symmetric, &
4772  on_diagonal=iatom .EQ. jatom, &
4773 
4774 
4775 
4776  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4777  END IF
4778  IF (PRESENT(force_a) .AND. &
4779  PRESENT(force_b) .AND. &
4780  .NOT.PRESENT(force_c) .AND. &
4781  PRESENT(pabc) .AND. &
4782  .NOT.PRESENT(mat_dabc) .AND. &
4783  .NOT.PRESENT(mat_adbc) .AND. &
4784  PRESENT(mat_abdc)) THEN
4785  CALL integrate_set_3c( &
4786  param%par, potential_parameter, &
4787  la_min(iset), la_max(iset), &
4788  lb_min(jset), lb_max(jset), &
4789  lc_min(kset), lc_max(kset), &
4790  npgfa(iset), npgfb(jset), npgfc(kset), &
4791  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4792  ra, rb, rc, &
4793  habc, &
4794  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4795  offset_a_start, offset_b_start, offset_c_start, &
4796  0, 0, first_set - 1, &
4797  sphi_a, sphi_b, sphi_c, &
4798  sgfa, sgfb, sgfc, &
4799  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4800  my_eri_method, &
4801 pabc=pabc_block, &
4802 force_a=force_a(ikind)%forces(:, atom_a), &
4803 force_b=force_b(jkind)%forces(:, atom_b), &
4804 
4805  do_symmetric=do_symmetric, &
4806  on_diagonal=iatom .EQ. jatom, &
4807 
4808 
4809 habdc=habdc, &
4810  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4811  END IF
4812  IF (PRESENT(force_a) .AND. &
4813  PRESENT(force_b) .AND. &
4814  .NOT.PRESENT(force_c) .AND. &
4815  PRESENT(pabc) .AND. &
4816  .NOT.PRESENT(mat_dabc) .AND. &
4817  PRESENT(mat_adbc) .AND. &
4818  .NOT.PRESENT(mat_abdc)) THEN
4819  CALL integrate_set_3c( &
4820  param%par, potential_parameter, &
4821  la_min(iset), la_max(iset), &
4822  lb_min(jset), lb_max(jset), &
4823  lc_min(kset), lc_max(kset), &
4824  npgfa(iset), npgfb(jset), npgfc(kset), &
4825  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4826  ra, rb, rc, &
4827  habc, &
4828  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4829  offset_a_start, offset_b_start, offset_c_start, &
4830  0, 0, first_set - 1, &
4831  sphi_a, sphi_b, sphi_c, &
4832  sgfa, sgfb, sgfc, &
4833  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4834  my_eri_method, &
4835 pabc=pabc_block, &
4836 force_a=force_a(ikind)%forces(:, atom_a), &
4837 force_b=force_b(jkind)%forces(:, atom_b), &
4838 
4839  do_symmetric=do_symmetric, &
4840  on_diagonal=iatom .EQ. jatom, &
4841 
4842 hadbc=hadbc, &
4843 
4844  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4845  END IF
4846  IF (PRESENT(force_a) .AND. &
4847  PRESENT(force_b) .AND. &
4848  .NOT.PRESENT(force_c) .AND. &
4849  PRESENT(pabc) .AND. &
4850  .NOT.PRESENT(mat_dabc) .AND. &
4851  PRESENT(mat_adbc) .AND. &
4852  PRESENT(mat_abdc)) THEN
4853  CALL integrate_set_3c( &
4854  param%par, potential_parameter, &
4855  la_min(iset), la_max(iset), &
4856  lb_min(jset), lb_max(jset), &
4857  lc_min(kset), lc_max(kset), &
4858  npgfa(iset), npgfb(jset), npgfc(kset), &
4859  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4860  ra, rb, rc, &
4861  habc, &
4862  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4863  offset_a_start, offset_b_start, offset_c_start, &
4864  0, 0, first_set - 1, &
4865  sphi_a, sphi_b, sphi_c, &
4866  sgfa, sgfb, sgfc, &
4867  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4868  my_eri_method, &
4869 pabc=pabc_block, &
4870 force_a=force_a(ikind)%forces(:, atom_a), &
4871 force_b=force_b(jkind)%forces(:, atom_b), &
4872 
4873  do_symmetric=do_symmetric, &
4874  on_diagonal=iatom .EQ. jatom, &
4875 
4876 hadbc=hadbc, &
4877 habdc=habdc, &
4878  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4879  END IF
4880  IF (PRESENT(force_a) .AND. &
4881  PRESENT(force_b) .AND. &
4882  .NOT.PRESENT(force_c) .AND. &
4883  PRESENT(pabc) .AND. &
4884  PRESENT(mat_dabc) .AND. &
4885  .NOT.PRESENT(mat_adbc) .AND. &
4886  .NOT.PRESENT(mat_abdc)) THEN
4887  CALL integrate_set_3c( &
4888  param%par, potential_parameter, &
4889  la_min(iset), la_max(iset), &
4890  lb_min(jset), lb_max(jset), &
4891  lc_min(kset), lc_max(kset), &
4892  npgfa(iset), npgfb(jset), npgfc(kset), &
4893  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4894  ra, rb, rc, &
4895  habc, &
4896  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4897  offset_a_start, offset_b_start, offset_c_start, &
4898  0, 0, first_set - 1, &
4899  sphi_a, sphi_b, sphi_c, &
4900  sgfa, sgfb, sgfc, &
4901  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4902  my_eri_method, &
4903 pabc=pabc_block, &
4904 force_a=force_a(ikind)%forces(:, atom_a), &
4905 force_b=force_b(jkind)%forces(:, atom_b), &
4906 
4907  do_symmetric=do_symmetric, &
4908  on_diagonal=iatom .EQ. jatom, &
4909 hdabc=hdabc, &
4910 
4911 
4912  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4913  END IF
4914  IF (PRESENT(force_a) .AND. &
4915  PRESENT(force_b) .AND. &
4916  .NOT.PRESENT(force_c) .AND. &
4917  PRESENT(pabc) .AND. &
4918  PRESENT(mat_dabc) .AND. &
4919  .NOT.PRESENT(mat_adbc) .AND. &
4920  PRESENT(mat_abdc)) THEN
4921  CALL integrate_set_3c( &
4922  param%par, potential_parameter, &
4923  la_min(iset), la_max(iset), &
4924  lb_min(jset), lb_max(jset), &
4925  lc_min(kset), lc_max(kset), &
4926  npgfa(iset), npgfb(jset), npgfc(kset), &
4927  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4928  ra, rb, rc, &
4929  habc, &
4930  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4931  offset_a_start, offset_b_start, offset_c_start, &
4932  0, 0, first_set - 1, &
4933  sphi_a, sphi_b, sphi_c, &
4934  sgfa, sgfb, sgfc, &
4935  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4936  my_eri_method, &
4937 pabc=pabc_block, &
4938 force_a=force_a(ikind)%forces(:, atom_a), &
4939 force_b=force_b(jkind)%forces(:, atom_b), &
4940 
4941  do_symmetric=do_symmetric, &
4942  on_diagonal=iatom .EQ. jatom, &
4943 hdabc=hdabc, &
4944 
4945 habdc=habdc, &
4946  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4947  END IF
4948  IF (PRESENT(force_a) .AND. &
4949  PRESENT(force_b) .AND. &
4950  .NOT.PRESENT(force_c) .AND. &
4951  PRESENT(pabc) .AND. &
4952  PRESENT(mat_dabc) .AND. &
4953  PRESENT(mat_adbc) .AND. &
4954  .NOT.PRESENT(mat_abdc)) THEN
4955  CALL integrate_set_3c( &
4956  param%par, potential_parameter, &
4957  la_min(iset), la_max(iset), &
4958  lb_min(jset), lb_max(jset), &
4959  lc_min(kset), lc_max(kset), &
4960  npgfa(iset), npgfb(jset), npgfc(kset), &
4961  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4962  ra, rb, rc, &
4963  habc, &
4964  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4965  offset_a_start, offset_b_start, offset_c_start, &
4966  0, 0, first_set - 1, &
4967  sphi_a, sphi_b, sphi_c, &
4968  sgfa, sgfb, sgfc, &
4969  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
4970  my_eri_method, &
4971 pabc=pabc_block, &
4972 force_a=force_a(ikind)%forces(:, atom_a), &
4973 force_b=force_b(jkind)%forces(:, atom_b), &
4974 
4975  do_symmetric=do_symmetric, &
4976  on_diagonal=iatom .EQ. jatom, &
4977 hdabc=hdabc, &
4978 hadbc=hadbc, &
4979 
4980  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
4981  END IF
4982  IF (PRESENT(force_a) .AND. &
4983  PRESENT(force_b) .AND. &
4984  .NOT.PRESENT(force_c) .AND. &
4985  PRESENT(pabc) .AND. &
4986  PRESENT(mat_dabc) .AND. &
4987  PRESENT(mat_adbc) .AND. &
4988  PRESENT(mat_abdc)) THEN
4989  CALL integrate_set_3c( &
4990  param%par, potential_parameter, &
4991  la_min(iset), la_max(iset), &
4992  lb_min(jset), lb_max(jset), &
4993  lc_min(kset), lc_max(kset), &
4994  npgfa(iset), npgfb(jset), npgfc(kset), &
4995  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
4996  ra, rb, rc, &
4997  habc, &
4998  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
4999  offset_a_start, offset_b_start, offset_c_start, &
5000  0, 0, first_set - 1, &
5001  sphi_a, sphi_b, sphi_c, &
5002  sgfa, sgfb, sgfc, &
5003  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5004  my_eri_method, &
5005 pabc=pabc_block, &
5006 force_a=force_a(ikind)%forces(:, atom_a), &
5007 force_b=force_b(jkind)%forces(:, atom_b), &
5008 
5009  do_symmetric=do_symmetric, &
5010  on_diagonal=iatom .EQ. jatom, &
5011 hdabc=hdabc, &
5012 hadbc=hadbc, &
5013 habdc=habdc, &
5014  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5015  END IF
5016  IF (PRESENT(force_a) .AND. &
5017  PRESENT(force_b) .AND. &
5018  PRESENT(force_c) .AND. &
5019  PRESENT(pabc) .AND. &
5020  .NOT.PRESENT(mat_dabc) .AND. &
5021  .NOT.PRESENT(mat_adbc) .AND. &
5022  .NOT.PRESENT(mat_abdc)) THEN
5023  CALL integrate_set_3c( &
5024  param%par, potential_parameter, &
5025  la_min(iset), la_max(iset), &
5026  lb_min(jset), lb_max(jset), &
5027  lc_min(kset), lc_max(kset), &
5028  npgfa(iset), npgfb(jset), npgfc(kset), &
5029  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5030  ra, rb, rc, &
5031  habc, &
5032  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5033  offset_a_start, offset_b_start, offset_c_start, &
5034  0, 0, first_set - 1, &
5035  sphi_a, sphi_b, sphi_c, &
5036  sgfa, sgfb, sgfc, &
5037  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5038  my_eri_method, &
5039 pabc=pabc_block, &
5040 force_a=force_a(ikind)%forces(:, atom_a), &
5041 force_b=force_b(jkind)%forces(:, atom_b), &
5042 force_c=force_c(kkind)%forces(:, atom_c), &
5043  do_symmetric=do_symmetric, &
5044  on_diagonal=iatom .EQ. jatom, &
5045 
5046 
5047 
5048  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5049  END IF
5050  IF (PRESENT(force_a) .AND. &
5051  PRESENT(force_b) .AND. &
5052  PRESENT(force_c) .AND. &
5053  PRESENT(pabc) .AND. &
5054  .NOT.PRESENT(mat_dabc) .AND. &
5055  .NOT.PRESENT(mat_adbc) .AND. &
5056  PRESENT(mat_abdc)) THEN
5057  CALL integrate_set_3c( &
5058  param%par, potential_parameter, &
5059  la_min(iset), la_max(iset), &
5060  lb_min(jset), lb_max(jset), &
5061  lc_min(kset), lc_max(kset), &
5062  npgfa(iset), npgfb(jset), npgfc(kset), &
5063  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5064  ra, rb, rc, &
5065  habc, &
5066  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5067  offset_a_start, offset_b_start, offset_c_start, &
5068  0, 0, first_set - 1, &
5069  sphi_a, sphi_b, sphi_c, &
5070  sgfa, sgfb, sgfc, &
5071  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5072  my_eri_method, &
5073 pabc=pabc_block, &
5074 force_a=force_a(ikind)%forces(:, atom_a), &
5075 force_b=force_b(jkind)%forces(:, atom_b), &
5076 force_c=force_c(kkind)%forces(:, atom_c), &
5077  do_symmetric=do_symmetric, &
5078  on_diagonal=iatom .EQ. jatom, &
5079 
5080 
5081 habdc=habdc, &
5082  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5083  END IF
5084  IF (PRESENT(force_a) .AND. &
5085  PRESENT(force_b) .AND. &
5086  PRESENT(force_c) .AND. &
5087  PRESENT(pabc) .AND. &
5088  .NOT.PRESENT(mat_dabc) .AND. &
5089  PRESENT(mat_adbc) .AND. &
5090  .NOT.PRESENT(mat_abdc)) THEN
5091  CALL integrate_set_3c( &
5092  param%par, potential_parameter, &
5093  la_min(iset), la_max(iset), &
5094  lb_min(jset), lb_max(jset), &
5095  lc_min(kset), lc_max(kset), &
5096  npgfa(iset), npgfb(jset), npgfc(kset), &
5097  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5098  ra, rb, rc, &
5099  habc, &
5100  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5101  offset_a_start, offset_b_start, offset_c_start, &
5102  0, 0, first_set - 1, &
5103  sphi_a, sphi_b, sphi_c, &
5104  sgfa, sgfb, sgfc, &
5105  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5106  my_eri_method, &
5107 pabc=pabc_block, &
5108 force_a=force_a(ikind)%forces(:, atom_a), &
5109 force_b=force_b(jkind)%forces(:, atom_b), &
5110 force_c=force_c(kkind)%forces(:, atom_c), &
5111  do_symmetric=do_symmetric, &
5112  on_diagonal=iatom .EQ. jatom, &
5113 
5114 hadbc=hadbc, &
5115 
5116  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5117  END IF
5118  IF (PRESENT(force_a) .AND. &
5119  PRESENT(force_b) .AND. &
5120  PRESENT(force_c) .AND. &
5121  PRESENT(pabc) .AND. &
5122  .NOT.PRESENT(mat_dabc) .AND. &
5123  PRESENT(mat_adbc) .AND. &
5124  PRESENT(mat_abdc)) THEN
5125  CALL integrate_set_3c( &
5126  param%par, potential_parameter, &
5127  la_min(iset), la_max(iset), &
5128  lb_min(jset), lb_max(jset), &
5129  lc_min(kset), lc_max(kset), &
5130  npgfa(iset), npgfb(jset), npgfc(kset), &
5131  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5132  ra, rb, rc, &
5133  habc, &
5134  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5135  offset_a_start, offset_b_start, offset_c_start, &
5136  0, 0, first_set - 1, &
5137  sphi_a, sphi_b, sphi_c, &
5138  sgfa, sgfb, sgfc, &
5139  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5140  my_eri_method, &
5141 pabc=pabc_block, &
5142 force_a=force_a(ikind)%forces(:, atom_a), &
5143 force_b=force_b(jkind)%forces(:, atom_b), &
5144 force_c=force_c(kkind)%forces(:, atom_c), &
5145  do_symmetric=do_symmetric, &
5146  on_diagonal=iatom .EQ. jatom, &
5147 
5148 hadbc=hadbc, &
5149 habdc=habdc, &
5150  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5151  END IF
5152  IF (PRESENT(force_a) .AND. &
5153  PRESENT(force_b) .AND. &
5154  PRESENT(force_c) .AND. &
5155  PRESENT(pabc) .AND. &
5156  PRESENT(mat_dabc) .AND. &
5157  .NOT.PRESENT(mat_adbc) .AND. &
5158  .NOT.PRESENT(mat_abdc)) THEN
5159  CALL integrate_set_3c( &
5160  param%par, potential_parameter, &
5161  la_min(iset), la_max(iset), &
5162  lb_min(jset), lb_max(jset), &
5163  lc_min(kset), lc_max(kset), &
5164  npgfa(iset), npgfb(jset), npgfc(kset), &
5165  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5166  ra, rb, rc, &
5167  habc, &
5168  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5169  offset_a_start, offset_b_start, offset_c_start, &
5170  0, 0, first_set - 1, &
5171  sphi_a, sphi_b, sphi_c, &
5172  sgfa, sgfb, sgfc, &
5173  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5174  my_eri_method, &
5175 pabc=pabc_block, &
5176 force_a=force_a(ikind)%forces(:, atom_a), &
5177 force_b=force_b(jkind)%forces(:, atom_b), &
5178 force_c=force_c(kkind)%forces(:, atom_c), &
5179  do_symmetric=do_symmetric, &
5180  on_diagonal=iatom .EQ. jatom, &
5181 hdabc=hdabc, &
5182 
5183 
5184  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5185  END IF
5186  IF (PRESENT(force_a) .AND. &
5187  PRESENT(force_b) .AND. &
5188  PRESENT(force_c) .AND. &
5189  PRESENT(pabc) .AND. &
5190  PRESENT(mat_dabc) .AND. &
5191  .NOT.PRESENT(mat_adbc) .AND. &
5192  PRESENT(mat_abdc)) THEN
5193  CALL integrate_set_3c( &
5194  param%par, potential_parameter, &
5195  la_min(iset), la_max(iset), &
5196  lb_min(jset), lb_max(jset), &
5197  lc_min(kset), lc_max(kset), &
5198  npgfa(iset), npgfb(jset), npgfc(kset), &
5199  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5200  ra, rb, rc, &
5201  habc, &
5202  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5203  offset_a_start, offset_b_start, offset_c_start, &
5204  0, 0, first_set - 1, &
5205  sphi_a, sphi_b, sphi_c, &
5206  sgfa, sgfb, sgfc, &
5207  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5208  my_eri_method, &
5209 pabc=pabc_block, &
5210 force_a=force_a(ikind)%forces(:, atom_a), &
5211 force_b=force_b(jkind)%forces(:, atom_b), &
5212 force_c=force_c(kkind)%forces(:, atom_c), &
5213  do_symmetric=do_symmetric, &
5214  on_diagonal=iatom .EQ. jatom, &
5215 hdabc=hdabc, &
5216 
5217 habdc=habdc, &
5218  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5219  END IF
5220  IF (PRESENT(force_a) .AND. &
5221  PRESENT(force_b) .AND. &
5222  PRESENT(force_c) .AND. &
5223  PRESENT(pabc) .AND. &
5224  PRESENT(mat_dabc) .AND. &
5225  PRESENT(mat_adbc) .AND. &
5226  .NOT.PRESENT(mat_abdc)) THEN
5227  CALL integrate_set_3c( &
5228  param%par, potential_parameter, &
5229  la_min(iset), la_max(iset), &
5230  lb_min(jset), lb_max(jset), &
5231  lc_min(kset), lc_max(kset), &
5232  npgfa(iset), npgfb(jset), npgfc(kset), &
5233  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5234  ra, rb, rc, &
5235  habc, &
5236  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5237  offset_a_start, offset_b_start, offset_c_start, &
5238  0, 0, first_set - 1, &
5239  sphi_a, sphi_b, sphi_c, &
5240  sgfa, sgfb, sgfc, &
5241  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5242  my_eri_method, &
5243 pabc=pabc_block, &
5244 force_a=force_a(ikind)%forces(:, atom_a), &
5245 force_b=force_b(jkind)%forces(:, atom_b), &
5246 force_c=force_c(kkind)%forces(:, atom_c), &
5247  do_symmetric=do_symmetric, &
5248  on_diagonal=iatom .EQ. jatom, &
5249 hdabc=hdabc, &
5250 hadbc=hadbc, &
5251 
5252  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5253  END IF
5254  IF (PRESENT(force_a) .AND. &
5255  PRESENT(force_b) .AND. &
5256  PRESENT(force_c) .AND. &
5257  PRESENT(pabc) .AND. &
5258  PRESENT(mat_dabc) .AND. &
5259  PRESENT(mat_adbc) .AND. &
5260  PRESENT(mat_abdc)) THEN
5261  CALL integrate_set_3c( &
5262  param%par, potential_parameter, &
5263  la_min(iset), la_max(iset), &
5264  lb_min(jset), lb_max(jset), &
5265  lc_min(kset), lc_max(kset), &
5266  npgfa(iset), npgfb(jset), npgfc(kset), &
5267  zeta(:, iset), zetb(:, jset), zetc(:, kset), &
5268  ra, rb, rc, &
5269  habc, &
5270  nsgfa(iset), nsgfb(jset), last_set - first_set + 1, &
5271  offset_a_start, offset_b_start, offset_c_start, &
5272  0, 0, first_set - 1, &
5273  sphi_a, sphi_b, sphi_c, &
5274  sgfa, sgfb, sgfc, &
5275  nsgfa(iset), nsgfb(jset), nsgfc(kset), &
5276  my_eri_method, &
5277 pabc=pabc_block, &
5278 force_a=force_a(ikind)%forces(:, atom_a), &
5279 force_b=force_b(jkind)%forces(:, atom_b), &
5280 force_c=force_c(kkind)%forces(:, atom_c), &
5281  do_symmetric=do_symmetric, &
5282  on_diagonal=iatom .EQ. jatom, &
5283 hdabc=hdabc, &
5284 hadbc=hadbc, &
5285 habdc=habdc, &
5286  gg_count=gg_count, gr_count=gr_count, rr_count=rr_count)
5287  END IF
5288  END DO
5289  END DO
5290  END DO
5291  END DO
5292 
5293  IF (calculate_forces .AND. PRESENT(pabc)) DEALLOCATE (pabc_block)
5294  DO ic = 1, nc
5295  NULLIFY (munu_block)
5296  CALL dbcsr_get_block_p(matrix=mat_ab(ic)%matrix, &
5297  row=irow, col=icol, block=munu_block, found=found)
5298  cpassert(found)
5299  munu_block(:, :) = 0.0_dp
5300  IF (irow .EQ. iatom) THEN
5301  to_be_asserted = SIZE(munu_block, 1) .EQ. SIZE(habc, 1) .AND. SIZE(munu_block, 2) .EQ. SIZE(habc, 2)
5302  cpassert(to_be_asserted)
5303  munu_block(:, :) = habc(:, :, ic)
5304  ELSE
5305  to_be_asserted = SIZE(munu_block, 2) .EQ. SIZE(habc, 1) .AND. SIZE(munu_block, 1) .EQ. SIZE(habc, 2)
5306  cpassert(to_be_asserted)
5307  munu_block(:, :) = transpose(habc(:, :, ic))
5308  END IF
5309  END DO
5310  DEALLOCATE (habc)
5311  IF (calculate_forces) THEN
5312  DO ic = 1, nc
5313  DO i_xyz = 1, 3
5314  IF (PRESENT(mat_dabc)) THEN
5315  NULLIFY (munu_block)
5316  CALL dbcsr_get_block_p(matrix=mat_dabc(i_xyz, ic)%matrix, &
5317  row=irow, col=icol, block=munu_block, found=found)
5318  cpassert(found)
5319  munu_block(:, :) = 0.0_dp
5320  IF (irow .EQ. iatom) THEN
5321  munu_block(:, :) = hdabc(i_xyz, :, :, ic)
5322  ELSE
5323  munu_block(:, :) = transpose(hdabc(i_xyz, :, :, ic))
5324  END IF
5325  END IF
5326  IF (PRESENT(mat_adbc)) THEN
5327  NULLIFY (munu_block)
5328  CALL dbcsr_get_block_p(matrix=mat_adbc(i_xyz, ic)%matrix, &
5329  row=irow, col=icol, block=munu_block, found=found)
5330  cpassert(found)
5331  munu_block(:, :) = 0.0_dp
5332  IF (irow .EQ. iatom) THEN
5333  munu_block(:, :) = hadbc(i_xyz, :, :, ic)
5334  ELSE
5335  munu_block(:, :) = transpose(hadbc(i_xyz, :, :, ic))
5336  END IF
5337  END IF
5338  IF (PRESENT(mat_abdc)) THEN
5339  NULLIFY (munu_block)
5340  CALL dbcsr_get_block_p(matrix=mat_abdc(i_xyz, ic)%matrix, &
5341  row=irow, col=icol, block=munu_block, found=found)
5342  cpassert(found)
5343  munu_block(:, :) = 0.0_dp
5344  IF (irow .EQ. iatom) THEN
5345  munu_block(:, :) = habdc(i_xyz, :, :, ic)
5346  ELSE
5347  munu_block(:, :) = transpose(habdc(i_xyz, :, :, ic))
5348  END IF
5349  END IF
5350  END DO
5351  END DO
5352  IF (PRESENT(mat_dabc)) DEALLOCATE (hdabc)
5353  IF (PRESENT(mat_adbc)) DEALLOCATE (hadbc)
5354  IF (PRESENT(mat_abdc)) DEALLOCATE (habdc)
5355  END IF
5356  END DO
5357 
5358  DEALLOCATE (basis_set_list_a, basis_set_list_b)
5359  CALL neighbor_list_iterator_release(nl_iterator)
5360 
5361  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)
5362 
5363  CALL timestop(handle)
5364  END SUBROUTINE mp2_eri_3c_integrate
5365 
5366 ! **************************************************************************************************
5367 !> \brief Integrate set triple and contract with sphi matrix
5368 !> \param param ...
5369 !> \param potential_parameter ...
5370 !> \param la_min ...
5371 !> \param la_max ...
5372 !> \param lb_min ...
5373 !> \param lb_max ...
5374 !> \param lc_min ...
5375 !> \param lc_max ...
5376 !> \param npgfa ...
5377 !> \param npgfb ...
5378 !> \param npgfc ...
5379 !> \param zeta ...
5380 !> \param zetb ...
5381 !> \param zetc ...
5382 !> \param ra ...
5383 !> \param rb ...
5384 !> \param rc ...
5385 !> \param habc ...
5386 !> \param n_habc_a ...
5387 !> \param n_habc_b ...
5388 !> \param n_habc_c ...
5389 !> \param offset_habc_a ...
5390 !> \param offset_habc_b ...
5391 !> \param offset_habc_c ...
5392 !> \param offset_set_a ...
5393 !> \param offset_set_b ...
5394 !> \param offset_set_c ...
5395 !> \param sphi_a ...
5396 !> \param sphi_b ...
5397 !> \param sphi_c ...
5398 !> \param sgfa ...
5399 !> \param sgfb ...
5400 !> \param sgfc ...
5401 !> \param nsgfa ...
5402 !> \param nsgfb ...
5403 !> \param nsgfc ...
5404 !> \param eri_method ...
5405 !> \param pabc ...
5406 !> \param force_a ...
5407 !> \param force_b ...
5408 !> \param force_c ...
5409 !> \param do_symmetric ...
5410 !> \param on_diagonal ...
5411 !> \param hdabc ...
5412 !> \param hadbc ...
5413 !> \param habdc ...
5414 !> \param GG_count ...
5415 !> \param GR_count ...
5416 !> \param RR_count ...
5417 !> \note
5418 ! **************************************************************************************************
5419  SUBROUTINE integrate_set_3c(param, potential_parameter, &
5420  la_min, la_max, lb_min, lb_max, lc_min, lc_max, &
5421  npgfa, npgfb, npgfc, &
5422  zeta, zetb, zetc, &
5423  ra, rb, rc, &
5424  habc, &
5425  n_habc_a, n_habc_b, n_habc_c, &
5426  offset_habc_a, offset_habc_b, offset_habc_c, &
5427  offset_set_a, offset_set_b, offset_set_c, &
5428  sphi_a, sphi_b, sphi_c, &
5429  sgfa, sgfb, sgfc, &
5430  nsgfa, nsgfb, nsgfc, &
5431  eri_method, &
5432  pabc, &
5433  force_a, force_b, force_c, &
5434  do_symmetric, on_diagonal, &
5435  hdabc, hadbc, habdc, &
5436  GG_count, GR_count, RR_count)
5437 
5438  TYPE(eri_mme_param), INTENT(INOUT) :: param
5439  TYPE(libint_potential_type), INTENT(IN) :: potential_parameter
5440  INTEGER, INTENT(IN) :: la_min, la_max, lb_min, lb_max, lc_min, &
5441  lc_max, npgfa, npgfb, npgfc
5442  REAL(kind=dp), DIMENSION(npgfa), INTENT(IN) :: zeta
5443  REAL(kind=dp), DIMENSION(npgfb), INTENT(IN) :: zetb
5444  REAL(kind=dp), DIMENSION(npgfc), INTENT(IN) :: zetc
5445  REAL(kind=dp), DIMENSION(3), INTENT(IN) :: ra, rb, rc
5446  REAL(kind=dp), DIMENSION(:, :, :), INTENT(INOUT) :: habc
5447  INTEGER, INTENT(IN) :: n_habc_a, n_habc_b, n_habc_c, offset_habc_a, offset_habc_b, &
5448  offset_habc_c, offset_set_a, offset_set_b, offset_set_c
5449  REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: sphi_a, sphi_b, sphi_c
5450  INTEGER, INTENT(IN) :: sgfa, sgfb, sgfc, nsgfa, nsgfb, nsgfc, &
5451  eri_method
5452  REAL(kind=dp), DIMENSION(:, :, :), INTENT(IN), &
5453  OPTIONAL :: pabc
5454  REAL(kind=dp), DIMENSION(3), INTENT(INOUT), &
5455  OPTIONAL :: force_a, force_b, force_c
5456  LOGICAL, INTENT(IN) :: do_symmetric
5457  LOGICAL, INTENT(IN), OPTIONAL :: on_diagonal
5458  REAL(kind=dp), DIMENSION(:, :, :, :), &
5459  INTENT(OUT), OPTIONAL :: hdabc, hadbc, habdc
5460  INTEGER, INTENT(INOUT), OPTIONAL :: gg_count, gr_count, rr_count
5461 
5462  CHARACTER(len=*), PARAMETER :: routinen = 'integrate_set_3c'
5463 
5464  INTEGER :: ax, ay, az, bx, by, bz, cx, cy, cz, habc_a_end, habc_a_start, habc_b_end, &
5465  habc_b_start, habc_c_end, habc_c_start, handle, i_xyz, ico, icoc, icox, icoy, icoz, ipgf, &
5466  jco, jcox, jcoy, jcoz, jpgf, kco, kcox, kcoy, kcoz, kpgf, la, la_max_d, lb, &
5467  lb_max_d, lc, lc_max_d, na, nb, nc, nc_end, nc_start, ncoa, ncoa_d, ncob, &
5468  ncob_d, ncoc, ncoc_d, set_a_end, set_a_start, set_b_end, set_b_start, &
5469  set_c_end, set_c_start, sphi_a_start, sphi_b_start, sphi_c_start
5470  INTEGER, DIMENSION(3) :: la_xyz, lb_xyz
5471  LOGICAL :: calculate_forces, do_force_a, do_force_b, &
5472  do_force_c
5473  REAL(kind=dp) :: rab2, rac2, rbc2, w
5474  REAL(kind=dp), ALLOCATABLE, DIMENSION(:) :: f_work, gccc, rpgfa, rpgfb, rpgfc
5475  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: pab_hh, pab_hs, vabc
5476  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: habc_contr, habc_uncontr, &
5477  habc_uncontr_d, pabc_hhh, &
5478  pabc_hsh, pabc_hss, pabc_sss
5479  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :, :) :: habdc_contr, habdc_uncontr, hadbc_contr, &
5480  hadbc_uncontr, hdabc_contr, &
5481  hdabc_uncontr, v_work
5482 
5483  CALL timeset(routinen, handle)
5484 
5485  do_force_a = PRESENT(force_a) .OR. PRESENT(hdabc)
5486  do_force_b = PRESENT(force_b) .OR. PRESENT(hadbc)
5487  do_force_c = PRESENT(force_c) .OR. PRESENT(habdc)
5488  calculate_forces = do_force_a .OR. do_force_b .OR. do_force_c
5489 
5490  IF (do_symmetric) THEN
5491  cpassert(PRESENT(on_diagonal))
5492  END IF
5493 
5494  la_max_d = la_max
5495  lb_max_d = lb_max
5496  lc_max_d = lc_max
5497 
5498  IF (calculate_forces) THEN
5499  IF (do_force_a) la_max_d = la_max + 1
5500  IF (do_force_b) lb_max_d = lb_max + 1
5501  IF (do_force_c) lc_max_d = lc_max + 1
5502  END IF
5503 
5504  ncoa = npgfa*ncoset(la_max)
5505  ncob = npgfb*ncoset(lb_max)
5506  ncoc = npgfc*ncoset(lc_max)
5507 
5508  ncoa_d = npgfa*ncoset(la_max_d)
5509  ncob_d = npgfb*ncoset(lb_max_d)
5510  ncoc_d = npgfc*ncoset(lc_max_d)
5511 
5512  ALLOCATE (habc_uncontr_d(ncoset(la_max_d), ncoset(lb_max_d), ncoset(lc_max_d)))
5513  habc_uncontr_d(:, :, :) = 0.0_dp
5514  ALLOCATE (habc_uncontr(ncoa, ncob, ncoc)); habc_uncontr(:, :, :) = 0.0_dp
5515  IF (PRESENT(hdabc)) THEN
5516  ALLOCATE (hdabc_uncontr(3, ncoa, ncob, ncoc)); hdabc_uncontr(:, :, :, :) = 0.0_dp
5517  END IF
5518  IF (PRESENT(hadbc)) THEN
5519  ALLOCATE (hadbc_uncontr(3, ncoa, ncob, ncoc)); hadbc_uncontr(:, :, :, :) = 0.0_dp
5520  END IF
5521  IF (PRESENT(habdc)) THEN
5522  ALLOCATE (habdc_uncontr(3, ncoa, ncob, ncoc)); habdc_uncontr(:, :, :, :) = 0.0_dp
5523  END IF
5524 
5525  habc_a_start = offset_habc_a + 1; habc_a_end = offset_habc_a + n_habc_a
5526  habc_b_start = offset_habc_b + 1; habc_b_end = offset_habc_b + n_habc_b
5527  habc_c_start = offset_habc_c + 1; habc_c_end = offset_habc_c + n_habc_c
5528  set_a_start = offset_set_a + 1; set_a_end = offset_set_a + n_habc_a
5529  set_b_start = offset_set_b + 1; set_b_end = offset_set_b + n_habc_b
5530  set_c_start = offset_set_c + 1; set_c_end = offset_set_c + n_habc_c
5531 
5532  IF (eri_method == do_eri_mme) THEN
5533  CALL eri_mme_set_potential(param, convert_potential_type(potential_parameter%potential_type), potential_parameter%omega)
5534 
5535  IF (calculate_forces .AND. PRESENT(pabc)) THEN
5536  ! uncontracted hermite-gaussian representation of density matrix
5537  sphi_a_start = sgfa - 1 + set_a_start
5538  sphi_b_start = sgfb - 1 + set_b_start
5539  sphi_c_start = sgfc - 1 + set_c_start
5540 
5541  ALLOCATE (pabc_sss(n_habc_a, n_habc_b, n_habc_c))
5542  pabc_sss(:, :, :) = pabc(habc_a_start:habc_a_end, habc_b_start:habc_b_end, habc_c_start:habc_c_end)
5543  ALLOCATE (pabc_hss(ncoa, n_habc_b, n_habc_c))
5544  ALLOCATE (pabc_hsh(ncoa, n_habc_b, ncoc))
5545  ALLOCATE (pabc_hhh(ncoa, ncob, ncoc))
5546  ALLOCATE (pab_hs(ncoa, n_habc_b))
5547  ALLOCATE (pab_hh(ncoa, ncob))
5548 
5549  CALL dgemm("N", "N", ncoa, n_habc_b*n_habc_c, n_habc_a, 1.0_dp, &
5550  sphi_a(:, sphi_a_start), SIZE(sphi_a, 1), pabc_sss, n_habc_a, 0.0_dp, pabc_hss, ncoa)
5551  CALL dgemm("N", "T", ncoa*n_habc_b, ncoc, n_habc_c, 1.0_dp, &
5552  pabc_hss, ncoa*n_habc_b, sphi_c(:, sphi_c_start), SIZE(sphi_c, 1), 0.0_dp, pabc_hsh, ncoa*n_habc_b)
5553 
5554  DO icoc = 1, ncoc
5555  pab_hs(:, :) = pabc_hsh(:, :, icoc)
5556  CALL dgemm("N", "T", ncoa, ncob, n_habc_b, 1.0_dp, &
5557  pab_hs, ncoa, sphi_b(:, sphi_b_start), SIZE(sphi_b, 1), 0.0_dp, pab_hh, ncoa)
5558  pabc_hhh(:, :, icoc) = pab_hh(:, :)
5559  END DO
5560  END IF
5561 
5562  DO ipgf = 1, npgfa
5563  na = (ipgf - 1)*ncoset(la_max)
5564  DO jpgf = 1, npgfb
5565  nb = (jpgf - 1)*ncoset(lb_max)
5566  DO kpgf = 1, npgfc
5567  nc = (kpgf - 1)*ncoset(lc_max)
5568  habc_uncontr_d(:, :, :) = 0.0_dp
5569  CALL eri_mme_3c_integrate(param, &
5570  la_min, la_max_d, lb_min, lb_max_d, lc_min, lc_max_d, &
5571  zeta(ipgf), zetb(jpgf), zetc(kpgf), ra, rb, rc, habc_uncontr_d, 0, 0, 0, &
5572  gg_count, gr_count, rr_count)
5573 
5574  habc_uncontr(na + 1:na + ncoset(la_max), nb + 1:nb + ncoset(lb_max), nc + 1:nc + ncoset(lc_max)) = &
5575  habc_uncontr_d(:ncoset(la_max), :ncoset(lb_max), :ncoset(lc_max))
5576 
5577  IF (calculate_forces) THEN
5578  DO lc = lc_min, lc_max
5579  DO cx = 0, lc
5580  DO cy = 0, lc - cx
5581  cz = lc - cx - cy
5582  kco = coset(cx, cy, cz)
5583  kcox = coset(cx + 1, cy, cz)
5584  kcoy = coset(cx, cy + 1, cz)
5585  kcoz = coset(cx, cy, cz + 1)
5586  DO lb = lb_min, lb_max
5587  DO bx = 0, lb
5588  DO by = 0, lb - bx
5589  bz = lb - bx - by
5590  jco = coset(bx, by, bz)
5591  jcox = coset(bx + 1, by, bz)
5592  jcoy = coset(bx, by + 1, bz)
5593  jcoz = coset(bx, by, bz + 1)
5594  DO la = la_min, la_max
5595  DO ax = 0, la
5596  DO ay = 0, la - ax
5597  az = la - ax - ay
5598  la_xyz = [ax, ay, az]
5599  lb_xyz = [bx, by, bz]
5600  ico = coset(ax, ay, az)
5601  icox = coset(ax + 1, ay, az)
5602  icoy = coset(ax, ay + 1, az)
5603  icoz = coset(ax, ay, az + 1)
5604 
5605  w = 1.0_dp
5606  IF (do_symmetric .AND. .NOT. on_diagonal) w = 2.0_dp
5607 
5608  IF (PRESENT(force_a)) THEN
5609  force_a = force_a + 2.0_dp*w*zeta(ipgf)* &
5610  [pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(icox, jco, kco), &
5611  pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(icoy, jco, kco), &
5612  pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(icoz, jco, kco)]
5613 
5614  END IF
5615  IF (PRESENT(force_b)) THEN
5616  force_b = force_b + 2.0_dp*w*zetb(jpgf)* &
5617  [pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jcox, kco), &
5618  pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jcoy, kco), &
5619  pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jcoz, kco)]
5620  END IF
5621  IF (PRESENT(force_c)) THEN
5622  force_c = force_c + 2.0_dp*w*zetc(kpgf)* &
5623  [pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jco, kcox), &
5624  pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jco, kcoy), &
5625  pabc_hhh(na + ico, nb + jco, nc + kco)*habc_uncontr_d(ico, jco, kcoz)]
5626  END IF
5627 
5628  IF (PRESENT(hdabc)) THEN
5629  hdabc_uncontr(1:3, na + ico, nb + jco, nc + kco) = 2.0_dp*zeta(ipgf)* &
5630  [habc_uncontr_d(icox, jco, kco), &
5631  habc_uncontr_d(icoy, jco, kco), &
5632  habc_uncontr_d(icoz, jco, kco)]
5633  END IF
5634  IF (PRESENT(hadbc)) THEN
5635  hadbc_uncontr(1:3, na + ico, nb + jco, nc + kco) = 2.0_dp*zetb(jpgf)* &
5636  [habc_uncontr_d(ico, jcox, kco), &
5637  habc_uncontr_d(ico, jcoy, kco), &
5638  habc_uncontr_d(ico, jcoz, kco)]
5639  END IF
5640  IF (PRESENT(habdc)) THEN
5641  habdc_uncontr(1:3, na + ico, nb + jco, nc + kco) = 2.0_dp*zetc(kpgf)* &
5642  [habc_uncontr_d(ico, jco, kcox), &
5643  habc_uncontr_d(ico, jco, kcoy), &
5644  habc_uncontr_d(ico, jco, kcoz)]
5645  END IF
5646  END DO
5647  END DO
5648  END DO
5649  END DO
5650  END DO
5651  END DO
5652  END DO
5653  END DO
5654  END DO
5655  END IF
5656 
5657  END DO
5658  END DO
5659  END DO
5660 
5661  ELSE IF (eri_method == do_eri_os) THEN
5662 
5663  IF (calculate_forces) cpabort("NYI")
5664 
5665  ALLOCATE (f_work(0:la_max + lb_max + lc_max + 2))
5666  f_work(:) = 0.0_dp
5667  ALLOCATE (v_work(ncoa, ncob, ncoc, la_max + lb_max + lc_max + 1))
5668  v_work(:, :, :, :) = 0.0_dp
5669  ! no screening
5670  ALLOCATE (rpgfa(npgfa))
5671  ALLOCATE (rpgfb(npgfb))
5672  ALLOCATE (rpgfc(npgfc))
5673  rpgfa(:) = 1.0e10_dp
5674  rpgfb(:) = 1.0e10_dp
5675  rpgfc(:) = 1.0e10_dp
5676  ALLOCATE (gccc(ncoc))
5677  gccc(:) = 0.0_dp
5678  ALLOCATE (vabc(ncoa, ncob))
5679  vabc(:, :) = 0.0_dp
5680  rab2 = (rb(1) - ra(1))**2 + (rb(2) - ra(2))**2 + (rb(3) - ra(3))**2
5681  rac2 = (rc(1) - ra(1))**2 + (rc(2) - ra(2))**2 + (rc(3) - ra(3))**2
5682  rbc2 = (rc(1) - rb(1))**2 + (rc(2) - rb(2))**2 + (rc(3) - rb(3))**2
5683 
5684  ! in the RI basis, there is only a single primitive Gaussian
5685  kpgf = 1
5686 
5687  IF (lc_max == 0) THEN
5688  nc_start = 1
5689  ELSE
5690  nc_start = ncoset(lc_max - 1) + 1
5691  END IF
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 
5871 END MODULE mp2_eri
pbc
subroutine pbc(r, r_pbc, s, s_pbc, a, b, c, alpha, beta, gamma, debug, info, pbc0, h, hinv)
...
Definition: dumpdcd.F:1203
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:117
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:195
ai_contraction_sphi
Contraction of integrals over primitive Cartesian Gaussians based on the contraction matrix sphi whic...
Definition: ai_contraction_sphi.F:15
ai_contraction_sphi::abc_contract
subroutine, public abc_contract(abcint, sabc, sphi_a, sphi_b, sphi_c, ncoa, ncob, ncoc, nsgfa, nsgfb, nsgfc)
contract three-center overlap integrals (a,b,c) and transfer to spherical Gaussians
Definition: ai_contraction_sphi.F:101
ai_contraction_sphi::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_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_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
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
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_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_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_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:1226
input_constants::do_eri_mme
integer, parameter, public do_eri_mme
Definition: input_constants.F:1226
input_constants::do_potential_coulomb
integer, parameter, public do_potential_coulomb
Definition: input_constants.F:801
input_constants::do_potential_long
integer, parameter, public do_potential_long
Definition: input_constants.F:801
input_constants::do_eri_gpw
integer, parameter, public do_eri_gpw
Definition: input_constants.F:1226
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:724
input_section_types::section_vals_val_get
subroutine, public section_vals_val_get(section_vals, keyword_name, i_rep_section, i_rep_val, n_rep_val, val, l_val, i_val, r_val, c_val, l_vals, i_vals, r_vals, c_vals, explicit)
returns the requested value
Definition: input_section_types.F:1040
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::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::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::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_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, 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, rhs)
Get the QUICKSTEP environment.
Definition: qs_environment_types.F:502
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, 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_r3d_rs_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_potentials, pao_descriptors, nelec)
Get attributes of an atomic kind.
Definition: qs_kind_types.F:451
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