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