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