(git:ed6f26b)
Loading...
Searching...
No Matches
semi_empirical_integrals.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 Set of wrappers for semi-empirical analytical/numerical Integrals
10!> routines
11!> \author Teodoro Laino [tlaino] - University of Zurich
12!> \date 04.2008
13!> \par History
14!> 05.2008 Teodoro Laino [tlaino] - University of Zurich - In core integrals
15! **************************************************************************************************
16MODULE semi_empirical_integrals
17
18 USE hfx_compression_methods, ONLY: hfx_add_mult_cache_elements,&
19 hfx_get_mult_cache_elements
20 USE input_constants, ONLY: do_se_is_slater
21 USE kinds, ONLY: dp,&
22 int_8
23 USE memory_utilities, ONLY: reallocate
24 USE semi_empirical_int_ana, ONLY: corecore_ana,&
25 corecore_el_ana,&
26 rotint_ana,&
27 rotnuc_ana
28 USE semi_empirical_int_gks, ONLY: corecore_gks,&
29 drotint_gks,&
30 drotnuc_gks,&
31 rotint_gks,&
32 rotnuc_gks
33 USE semi_empirical_int_num, ONLY: corecore_el_num,&
34 corecore_num,&
35 dcorecore_el_num,&
36 dcorecore_num,&
37 drotint_num,&
38 drotnuc_num,&
39 rotint_num,&
40 rotnuc_num
41 USE semi_empirical_store_int_types, ONLY: semi_empirical_si_type
42 USE semi_empirical_types, ONLY: se_int_control_type,&
43 se_taper_type,&
44 semi_empirical_type
45#include "./base/base_uses.f90"
46
47 IMPLICIT NONE
48
49 PRIVATE
50
51 CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'semi_empirical_integrals'
52 PUBLIC :: rotint, rotnuc, corecore, corecore_el, drotint, drotnuc, dcorecore, &
53 dcorecore_el
54
55CONTAINS
56
57! **************************************************************************************************
58!> \brief wrapper for numerical/analytical 2 center 2 electrons integrals
59!> routines with possibility of incore storage/compression
60!> \param sepi ...
61!> \param sepj ...
62!> \param rij ...
63!> \param w ...
64!> \param anag ...
65!> \param se_int_control ...
66!> \param se_taper ...
67!> \param store_int_env ...
68!> \date 05.2008
69!> \author Teodoro Laino [tlaino] - University of Zurich
70! **************************************************************************************************
71 SUBROUTINE rotint(sepi, sepj, rij, w, anag, se_int_control, se_taper, store_int_env)
72 TYPE(semi_empirical_type), POINTER :: sepi, sepj
73 REAL(dp), DIMENSION(3), INTENT(IN) :: rij
74 REAL(dp), DIMENSION(2025), INTENT(OUT) :: w
75 LOGICAL :: anag
76 TYPE(se_int_control_type), INTENT(IN) :: se_int_control
77 TYPE(se_taper_type), POINTER :: se_taper
78 TYPE(semi_empirical_si_type), POINTER :: store_int_env
79
80 INTEGER :: buffer_left, buffer_size, buffer_start, &
81 cache_size, memory_usage, nbits, &
82 new_size, nints
83 INTEGER(KIND=int_8) :: mem_compression_counter
84 LOGICAL :: buffer_overflow
85 REAL(kind=dp) :: eps_storage
86
87 w(:) = 0.0_dp
88 IF (.NOT. store_int_env%memory_parameter%do_all_on_the_fly) THEN
89 nints = (sepi%natorb*(sepi%natorb + 1)/2)*(sepj%natorb*(sepj%natorb + 1)/2)
90 cache_size = store_int_env%memory_parameter%cache_size
91 eps_storage = store_int_env%memory_parameter%eps_storage_scaling
92 IF (store_int_env%filling_containers) THEN
93 mem_compression_counter = store_int_env%memory_parameter%actual_memory_usage*cache_size
94 IF (mem_compression_counter > store_int_env%memory_parameter%max_compression_counter) THEN
95 buffer_overflow = .true.
96 store_int_env%memory_parameter%ram_counter = store_int_env%nbuffer
97 ELSE
98 store_int_env%nbuffer = store_int_env%nbuffer + 1
99 buffer_overflow = .false.
100 END IF
101 ! Compute Integrals
102 IF (se_int_control%integral_screening == do_se_is_slater) THEN
103 CALL rotint_gks(sepi, sepj, rij, w, se_int_control=se_int_control)
104 ELSE
105 IF (anag) THEN
106 CALL rotint_ana(sepi, sepj, rij, w, se_int_control=se_int_control, se_taper=se_taper)
107 ELSE
108 CALL rotint_num(sepi, sepj, rij, w, se_int_control=se_int_control, se_taper=se_taper)
109 END IF
110 END IF
111 ! Store integrals if we did not go overflow
112 IF (.NOT. buffer_overflow) THEN
113 IF (store_int_env%compress) THEN
114 ! Store integrals in the containers
115 IF (store_int_env%nbuffer > SIZE(store_int_env%max_val_buffer)) THEN
116 new_size = store_int_env%nbuffer + 1000
117 CALL reallocate(store_int_env%max_val_buffer, 1, new_size)
118 END IF
119 store_int_env%max_val_buffer(store_int_env%nbuffer) = maxval(abs(w(1:nints)))
120
121 nbits = exponent(store_int_env%max_val_buffer(store_int_env%nbuffer)/eps_storage) + 1
122 buffer_left = nints
123 buffer_start = 1
124 DO WHILE (buffer_left > 0)
125 buffer_size = min(buffer_left, cache_size)
126 CALL hfx_add_mult_cache_elements(w(buffer_start:), &
127 buffer_size, nbits, &
128 store_int_env%integral_caches(nbits), &
129 store_int_env%integral_containers(nbits), &
130 eps_storage, 1.0_dp, &
131 store_int_env%memory_parameter%actual_memory_usage, &
132 .false.)
133 buffer_left = buffer_left - buffer_size
134 buffer_start = buffer_start + buffer_size
135 END DO
136 ELSE
137 ! Skip compression
138 memory_usage = store_int_env%memory_parameter%actual_memory_usage
139 cpassert((nints/1.2_dp) <= huge(0) - memory_usage)
140 IF (memory_usage + nints > SIZE(store_int_env%uncompressed_container)) THEN
141 new_size = int((memory_usage + nints)*1.2_dp)
142 CALL reallocate(store_int_env%uncompressed_container, 1, new_size)
143 END IF
144 store_int_env%uncompressed_container(memory_usage:memory_usage + nints - 1) = w(1:nints)
145 store_int_env%memory_parameter%actual_memory_usage = memory_usage + nints
146 END IF
147 END IF
148 ELSE
149 ! Get integrals from the containers
150 IF (store_int_env%memory_parameter%ram_counter == store_int_env%nbuffer) THEN
151 buffer_overflow = .true.
152 ELSE
153 store_int_env%nbuffer = store_int_env%nbuffer + 1
154 buffer_overflow = .false.
155 END IF
156 ! Get integrals from cache unless we overflowed
157 IF (.NOT. buffer_overflow) THEN
158 IF (store_int_env%compress) THEN
159 ! Get Integrals from containers
160 nbits = exponent(store_int_env%max_val_buffer(store_int_env%nbuffer)/eps_storage) + 1
161 buffer_left = nints
162 buffer_start = 1
163 DO WHILE (buffer_left > 0)
164 buffer_size = min(buffer_left, cache_size)
165 CALL hfx_get_mult_cache_elements(w(buffer_start:), &
166 buffer_size, nbits, &
167 store_int_env%integral_caches(nbits), &
168 store_int_env%integral_containers(nbits), &
169 eps_storage, 1.0_dp, &
170 store_int_env%memory_parameter%actual_memory_usage, &
171 .false.)
172 buffer_left = buffer_left - buffer_size
173 buffer_start = buffer_start + buffer_size
174 END DO
175 ELSE
176 ! Skip compression
177 memory_usage = store_int_env%memory_parameter%actual_memory_usage
178 w(1:nints) = store_int_env%uncompressed_container(memory_usage:memory_usage + nints - 1)
179 store_int_env%memory_parameter%actual_memory_usage = memory_usage + nints
180 END IF
181 ELSE
182 IF (se_int_control%integral_screening == do_se_is_slater) THEN
183 CALL rotint_gks(sepi, sepj, rij, w, se_int_control=se_int_control)
184 ELSE
185 IF (anag) THEN
186 CALL rotint_ana(sepi, sepj, rij, w, se_int_control=se_int_control, se_taper=se_taper)
187 ELSE
188 CALL rotint_num(sepi, sepj, rij, w, se_int_control=se_int_control, se_taper=se_taper)
189 END IF
190 END IF
191 END IF
192 END IF
193 ELSE
194 IF (se_int_control%integral_screening == do_se_is_slater) THEN
195 CALL rotint_gks(sepi, sepj, rij, w, se_int_control=se_int_control)
196 ELSE
197 IF (anag) THEN
198 CALL rotint_ana(sepi, sepj, rij, w, se_int_control=se_int_control, se_taper=se_taper)
199 ELSE
200 CALL rotint_num(sepi, sepj, rij, w, se_int_control=se_int_control, se_taper=se_taper)
201 END IF
202 END IF
203 END IF
204 END SUBROUTINE rotint
205
206! **************************************************************************************************
207!> \brief wrapper for numerical/analytical 1 center 1 electron integrals
208!> \param sepi ...
209!> \param sepj ...
210!> \param rij ...
211!> \param e1b ...
212!> \param e2a ...
213!> \param itype ...
214!> \param anag ...
215!> \param se_int_control ...
216!> \param se_taper ...
217!> \param store_int_env ...
218!> \date 05.2008
219!> \author Teodoro Laino [tlaino] - University of Zurich
220! **************************************************************************************************
221 SUBROUTINE rotnuc(sepi, sepj, rij, e1b, e2a, itype, anag, se_int_control, se_taper, store_int_env)
222 TYPE(semi_empirical_type), POINTER :: sepi, sepj
223 REAL(dp), DIMENSION(3), INTENT(IN) :: rij
224 REAL(dp), DIMENSION(45), INTENT(OUT), OPTIONAL :: e1b, e2a
225 INTEGER, INTENT(IN) :: itype
226 LOGICAL, INTENT(IN) :: anag
227 TYPE(se_int_control_type), INTENT(IN) :: se_int_control
228 TYPE(se_taper_type), POINTER :: se_taper
229 TYPE(semi_empirical_si_type), OPTIONAL, POINTER :: store_int_env
230
231 INTEGER :: buffer_left, buffer_size, buffer_start, &
232 cache_size, memory_usage, nbits, &
233 new_size, nints, nints_1, nints_2
234 INTEGER(KIND=int_8) :: mem_compression_counter
235 LOGICAL :: buffer_overflow, do_all_on_the_fly
236 REAL(kind=dp) :: eps_storage, w(90)
237
238 do_all_on_the_fly = .true.
239 IF (PRESENT(e1b)) e1b(:) = 0.0_dp
240 IF (PRESENT(e2a)) e2a(:) = 0.0_dp
241 IF (PRESENT(store_int_env)) do_all_on_the_fly = store_int_env%memory_parameter%do_all_on_the_fly
242 IF (.NOT. do_all_on_the_fly) THEN
243 nints_1 = 0
244 nints_2 = 0
245 IF (PRESENT(e1b)) nints_1 = (sepi%natorb*(sepi%natorb + 1)/2)
246 IF (PRESENT(e2a)) nints_2 = (sepj%natorb*(sepj%natorb + 1)/2)
247 nints = nints_1 + nints_2
248 ! This is the upper limit for an spd basis set
249 cpassert(nints <= 90)
250 cache_size = store_int_env%memory_parameter%cache_size
251 eps_storage = store_int_env%memory_parameter%eps_storage_scaling
252 IF (store_int_env%filling_containers) THEN
253 mem_compression_counter = store_int_env%memory_parameter%actual_memory_usage*cache_size
254 IF (mem_compression_counter > store_int_env%memory_parameter%max_compression_counter) THEN
255 buffer_overflow = .true.
256 store_int_env%memory_parameter%ram_counter = store_int_env%nbuffer
257 ELSE
258 store_int_env%nbuffer = store_int_env%nbuffer + 1
259 buffer_overflow = .false.
260 END IF
261 ! Compute Integrals
262 IF (se_int_control%integral_screening == do_se_is_slater) THEN
263 CALL rotnuc_gks(sepi, sepj, rij, e1b=e1b, e2a=e2a, &
264 se_int_control=se_int_control)
265 ELSE
266 IF (anag) THEN
267 CALL rotnuc_ana(sepi, sepj, rij, e1b=e1b, e2a=e2a, itype=itype, &
268 se_int_control=se_int_control, se_taper=se_taper)
269 ELSE
270 CALL rotnuc_num(sepi, sepj, rij, e1b=e1b, e2a=e2a, itype=itype, &
271 se_int_control=se_int_control, se_taper=se_taper)
272 END IF
273 END IF
274 ! Store integrals if we did not go overflow
275 IF (.NOT. buffer_overflow) THEN
276 IF (PRESENT(e1b)) w(1:nints_1) = e1b(1:nints_1)
277 IF (PRESENT(e2a)) w(nints_1 + 1:nints) = e2a(1:nints_2)
278
279 IF (store_int_env%compress) THEN
280 ! Store integrals in the containers
281 IF (store_int_env%nbuffer > SIZE(store_int_env%max_val_buffer)) THEN
282 new_size = store_int_env%nbuffer + 1000
283 CALL reallocate(store_int_env%max_val_buffer, 1, new_size)
284 END IF
285 store_int_env%max_val_buffer(store_int_env%nbuffer) = maxval(abs(w(1:nints)))
286
287 nbits = exponent(store_int_env%max_val_buffer(store_int_env%nbuffer)/eps_storage) + 1
288 buffer_left = nints
289 buffer_start = 1
290 DO WHILE (buffer_left > 0)
291 buffer_size = min(buffer_left, cache_size)
292 CALL hfx_add_mult_cache_elements(w(buffer_start:), &
293 buffer_size, nbits, &
294 store_int_env%integral_caches(nbits), &
295 store_int_env%integral_containers(nbits), &
296 eps_storage, 1.0_dp, &
297 store_int_env%memory_parameter%actual_memory_usage, &
298 .false.)
299 buffer_left = buffer_left - buffer_size
300 buffer_start = buffer_start + buffer_size
301 END DO
302 ELSE
303 ! Skip compression
304 memory_usage = store_int_env%memory_parameter%actual_memory_usage
305 cpassert((nints/1.2_dp) <= huge(0) - memory_usage)
306 IF (memory_usage + nints > SIZE(store_int_env%uncompressed_container)) THEN
307 new_size = int((memory_usage + nints)*1.2_dp)
308 CALL reallocate(store_int_env%uncompressed_container, 1, new_size)
309 END IF
310 store_int_env%uncompressed_container(memory_usage:memory_usage + nints - 1) = w(1:nints)
311 store_int_env%memory_parameter%actual_memory_usage = memory_usage + nints
312 END IF
313 END IF
314 ELSE
315 ! Get integrals from the containers
316 IF (store_int_env%memory_parameter%ram_counter == store_int_env%nbuffer) THEN
317 buffer_overflow = .true.
318 ELSE
319 store_int_env%nbuffer = store_int_env%nbuffer + 1
320 buffer_overflow = .false.
321 END IF
322 ! Get integrals from cache unless we overflowed
323 IF (.NOT. buffer_overflow) THEN
324 IF (store_int_env%compress) THEN
325 ! Get Integrals from containers
326 nbits = exponent(store_int_env%max_val_buffer(store_int_env%nbuffer)/eps_storage) + 1
327 buffer_left = nints
328 buffer_start = 1
329 DO WHILE (buffer_left > 0)
330 buffer_size = min(buffer_left, cache_size)
331 CALL hfx_get_mult_cache_elements(w(buffer_start:), &
332 buffer_size, nbits, &
333 store_int_env%integral_caches(nbits), &
334 store_int_env%integral_containers(nbits), &
335 eps_storage, 1.0_dp, &
336 store_int_env%memory_parameter%actual_memory_usage, &
337 .false.)
338 buffer_left = buffer_left - buffer_size
339 buffer_start = buffer_start + buffer_size
340 END DO
341 ELSE
342 ! Skip compression
343 memory_usage = store_int_env%memory_parameter%actual_memory_usage
344 w(1:nints) = store_int_env%uncompressed_container(memory_usage:memory_usage + nints - 1)
345 store_int_env%memory_parameter%actual_memory_usage = memory_usage + nints
346 END IF
347 IF (PRESENT(e1b)) e1b(1:nints_1) = w(1:nints_1)
348 IF (PRESENT(e2a)) e2a(1:nints_2) = w(nints_1 + 1:nints)
349 ELSE
350 IF (se_int_control%integral_screening == do_se_is_slater) THEN
351 CALL rotnuc_gks(sepi, sepj, rij, e1b=e1b, e2a=e2a, &
352 se_int_control=se_int_control)
353 ELSE
354 IF (anag) THEN
355 CALL rotnuc_ana(sepi, sepj, rij, e1b=e1b, e2a=e2a, itype=itype, &
356 se_int_control=se_int_control, se_taper=se_taper)
357 ELSE
358 CALL rotnuc_num(sepi, sepj, rij, e1b=e1b, e2a=e2a, itype=itype, &
359 se_int_control=se_int_control, se_taper=se_taper)
360 END IF
361 END IF
362 END IF
363 END IF
364 ELSE
365 IF (se_int_control%integral_screening == do_se_is_slater) THEN
366 CALL rotnuc_gks(sepi, sepj, rij, e1b=e1b, e2a=e2a, &
367 se_int_control=se_int_control)
368 ELSE
369 IF (anag) THEN
370 CALL rotnuc_ana(sepi, sepj, rij, e1b=e1b, e2a=e2a, itype=itype, &
371 se_int_control=se_int_control, se_taper=se_taper)
372 ELSE
373 CALL rotnuc_num(sepi, sepj, rij, e1b=e1b, e2a=e2a, itype=itype, &
374 se_int_control=se_int_control, se_taper=se_taper)
375 END IF
376 END IF
377 END IF
378
379 END SUBROUTINE rotnuc
380
381! **************************************************************************************************
382!> \brief wrapper for numerical/analytical routines
383!> core-core integrals, since are evaluated only once do not need to be
384!> stored.
385!>
386!> \param sepi ...
387!> \param sepj ...
388!> \param rij ...
389!> \param enuc ...
390!> \param itype ...
391!> \param anag ...
392!> \param se_int_control ...
393!> \param se_taper ...
394!> \date 04.2008
395!> \author Teodoro Laino [tlaino] - University of Zurich
396! **************************************************************************************************
397 SUBROUTINE corecore(sepi, sepj, rij, enuc, itype, anag, se_int_control, se_taper)
398 TYPE(semi_empirical_type), POINTER :: sepi, sepj
399 REAL(dp), DIMENSION(3), INTENT(IN) :: rij
400 REAL(dp), INTENT(OUT) :: enuc
401 INTEGER, INTENT(IN) :: itype
402 LOGICAL, INTENT(IN) :: anag
403 TYPE(se_int_control_type), INTENT(IN) :: se_int_control
404 TYPE(se_taper_type), POINTER :: se_taper
405
406 enuc = 0.0_dp
407 IF (se_int_control%integral_screening == do_se_is_slater) THEN
408 CALL corecore_gks(sepi, sepj, rij, enuc=enuc, se_int_control=se_int_control)
409 ELSE
410 IF (anag) THEN
411 CALL corecore_ana(sepi, sepj, rij, enuc=enuc, itype=itype, se_int_control=se_int_control, &
412 se_taper=se_taper)
413 ELSE
414 CALL corecore_num(sepi, sepj, rij, enuc=enuc, itype=itype, se_int_control=se_int_control, &
415 se_taper=se_taper)
416 END IF
417 END IF
418
419 END SUBROUTINE corecore
420
421! **************************************************************************************************
422!> \brief wrapper for numerical/analytical routines
423!> core-core electrostatic (only) integrals
424!>
425!> \param sepi ...
426!> \param sepj ...
427!> \param rij ...
428!> \param enuc ...
429!> \param itype ...
430!> \param anag ...
431!> \param se_int_control ...
432!> \param se_taper ...
433!> \date 05.2009
434!> \author Teodoro Laino [tlaino] - University of Zurich
435! **************************************************************************************************
436 SUBROUTINE corecore_el(sepi, sepj, rij, enuc, itype, anag, se_int_control, se_taper)
437 TYPE(semi_empirical_type), POINTER :: sepi, sepj
438 REAL(dp), DIMENSION(3), INTENT(IN) :: rij
439 REAL(dp), INTENT(OUT) :: enuc
440 INTEGER, INTENT(IN) :: itype
441 LOGICAL, INTENT(IN) :: anag
442 TYPE(se_int_control_type), INTENT(IN) :: se_int_control
443 TYPE(se_taper_type), POINTER :: se_taper
444
445 enuc = 0.0_dp
446 IF (anag) THEN
447 CALL corecore_el_ana(sepi, sepj, rij, enuc=enuc, itype=itype, se_int_control=se_int_control, &
448 se_taper=se_taper)
449 ELSE
450 CALL corecore_el_num(sepi, sepj, rij, enuc=enuc, itype=itype, se_int_control=se_int_control, &
451 se_taper=se_taper)
452 END IF
453
454 END SUBROUTINE corecore_el
455
456! **************************************************************************************************
457!> \brief wrapper for numerical/analytical routines
458!> \param sepi ...
459!> \param sepj ...
460!> \param rij ...
461!> \param dw ...
462!> \param delta ...
463!> \param anag ...
464!> \param se_int_control ...
465!> \param se_taper ...
466!> \date 04.2008
467!> \author Teodoro Laino [tlaino] - University of Zurich
468! **************************************************************************************************
469 SUBROUTINE drotint(sepi, sepj, rij, dw, delta, anag, se_int_control, se_taper)
470 TYPE(semi_empirical_type), POINTER :: sepi, sepj
471 REAL(dp), DIMENSION(3), INTENT(IN) :: rij
472 REAL(dp), DIMENSION(3, 2025), INTENT(OUT) :: dw
473 REAL(dp), INTENT(IN) :: delta
474 LOGICAL, INTENT(IN) :: anag
475 TYPE(se_int_control_type), INTENT(IN) :: se_int_control
476 TYPE(se_taper_type), POINTER :: se_taper
477
478 dw(:, :) = 0.0_dp
479 IF (se_int_control%integral_screening == do_se_is_slater) THEN
480 CALL drotint_gks(sepi, sepj, rij, dw=dw, se_int_control=se_int_control)
481 ELSE
482 IF (anag) THEN
483 CALL rotint_ana(sepi, sepj, rij, dw=dw, se_int_control=se_int_control, se_taper=se_taper)
484 ELSE
485 CALL drotint_num(sepi, sepj, rij, dw, delta, se_int_control=se_int_control, se_taper=se_taper)
486 END IF
487 END IF
488
489 END SUBROUTINE drotint
490
491! **************************************************************************************************
492!> \brief wrapper for numerical/analytical routines
493!> \param sepi ...
494!> \param sepj ...
495!> \param rij ...
496!> \param de1b ...
497!> \param de2a ...
498!> \param itype ...
499!> \param delta ...
500!> \param anag ...
501!> \param se_int_control ...
502!> \param se_taper ...
503!> \date 04.2008
504!> \author Teodoro Laino [tlaino] - University of Zurich
505! **************************************************************************************************
506 SUBROUTINE drotnuc(sepi, sepj, rij, de1b, de2a, itype, delta, anag, se_int_control, se_taper)
507 TYPE(semi_empirical_type), POINTER :: sepi, sepj
508 REAL(dp), DIMENSION(3), INTENT(IN) :: rij
509 REAL(dp), DIMENSION(3, 45), INTENT(OUT), OPTIONAL :: de1b, de2a
510 INTEGER, INTENT(IN) :: itype
511 REAL(dp), INTENT(IN) :: delta
512 LOGICAL, INTENT(IN) :: anag
513 TYPE(se_int_control_type), INTENT(IN) :: se_int_control
514 TYPE(se_taper_type), POINTER :: se_taper
515
516 IF (PRESENT(de1b)) de1b(:, :) = 0.0_dp
517 IF (PRESENT(de2a)) de2a(:, :) = 0.0_dp
518 IF (se_int_control%integral_screening == do_se_is_slater) THEN
519 CALL drotnuc_gks(sepi, sepj, rij, de1b=de1b, de2a=de2a, &
520 se_int_control=se_int_control)
521 ELSE
522 IF (anag) THEN
523 CALL rotnuc_ana(sepi, sepj, rij, de1b=de1b, de2a=de2a, itype=itype, &
524 se_int_control=se_int_control, se_taper=se_taper)
525 ELSE
526 CALL drotnuc_num(sepi, sepj, rij, de1b=de1b, de2a=de2a, itype=itype, &
527 delta=delta, se_int_control=se_int_control, se_taper=se_taper)
528 END IF
529 END IF
530
531 END SUBROUTINE drotnuc
532
533! **************************************************************************************************
534!> \brief wrapper for numerical/analytical routines
535!> \param sepi ...
536!> \param sepj ...
537!> \param rij ...
538!> \param denuc ...
539!> \param itype ...
540!> \param delta ...
541!> \param anag ...
542!> \param se_int_control ...
543!> \param se_taper ...
544!> \date 04.2008
545!> \author Teodoro Laino [tlaino] - University of Zurich
546! **************************************************************************************************
547 SUBROUTINE dcorecore(sepi, sepj, rij, denuc, itype, delta, anag, se_int_control, se_taper)
548 TYPE(semi_empirical_type), POINTER :: sepi, sepj
549 REAL(dp), DIMENSION(3), INTENT(IN) :: rij
550 REAL(dp), DIMENSION(3), INTENT(OUT) :: denuc
551 INTEGER, INTENT(IN) :: itype
552 REAL(dp), INTENT(IN) :: delta
553 LOGICAL, INTENT(IN) :: anag
554 TYPE(se_int_control_type), INTENT(IN) :: se_int_control
555 TYPE(se_taper_type), POINTER :: se_taper
556
557 denuc = 0.0_dp
558 IF (se_int_control%integral_screening == do_se_is_slater) THEN
559 CALL corecore_gks(sepi, sepj, rij, denuc=denuc, se_int_control=se_int_control)
560 ELSE
561 IF (anag) THEN
562 CALL corecore_ana(sepi, sepj, rij, denuc=denuc, itype=itype, se_int_control=se_int_control, &
563 se_taper=se_taper)
564 ELSE
565 CALL dcorecore_num(sepi, sepj, rij, denuc=denuc, delta=delta, itype=itype, &
566 se_int_control=se_int_control, se_taper=se_taper)
567 END IF
568 END IF
569
570 END SUBROUTINE dcorecore
571
572! **************************************************************************************************
573!> \brief wrapper for numerical/analytical routines
574!> core-core electrostatic (only) integrals derivatives
575!>
576!> \param sepi ...
577!> \param sepj ...
578!> \param rij ...
579!> \param denuc ...
580!> \param itype ...
581!> \param delta ...
582!> \param anag ...
583!> \param se_int_control ...
584!> \param se_taper ...
585!> \date 05.2009
586!> \author Teodoro Laino [tlaino] - University of Zurich
587! **************************************************************************************************
588 SUBROUTINE dcorecore_el(sepi, sepj, rij, denuc, itype, delta, anag, se_int_control, se_taper)
589 TYPE(semi_empirical_type), POINTER :: sepi, sepj
590 REAL(dp), DIMENSION(3), INTENT(IN) :: rij
591 REAL(dp), DIMENSION(3), INTENT(OUT) :: denuc
592 INTEGER, INTENT(IN) :: itype
593 REAL(dp), INTENT(IN) :: delta
594 LOGICAL, INTENT(IN) :: anag
595 TYPE(se_int_control_type), INTENT(IN) :: se_int_control
596 TYPE(se_taper_type), POINTER :: se_taper
597
598 denuc = 0.0_dp
599 IF (anag) THEN
600 CALL corecore_el_ana(sepi, sepj, rij, denuc=denuc, itype=itype, se_int_control=se_int_control, &
601 se_taper=se_taper)
602 ELSE
603 CALL dcorecore_el_num(sepi, sepj, rij, denuc=denuc, delta=delta, itype=itype, &
604 se_int_control=se_int_control, se_taper=se_taper)
605 END IF
606
607 END SUBROUTINE dcorecore_el
608
609END MODULE semi_empirical_integrals
memory_utilities::reallocate
Definition memory_utilities.F:27
hfx_compression_methods
routines and types for Hartree-Fock-Exchange
Definition hfx_compression_methods.F:14
hfx_compression_methods::hfx_get_mult_cache_elements
subroutine, public hfx_get_mult_cache_elements(values, nints, nbits, cache, container, eps_schwarz, pmax_entry, memory_usage, use_disk_storage)
This routine returns a bunch real values from a cache. If the cache is empty a decompression routine ...
Definition hfx_compression_methods.F:421
hfx_compression_methods::hfx_add_mult_cache_elements
subroutine, public hfx_add_mult_cache_elements(values, nints, nbits, cache, container, eps_schwarz, pmax_entry, memory_usage, use_disk_storage)
This routine adds an a few real values to a cache. If the cache is full a compression routine is invo...
Definition hfx_compression_methods.F:341
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_se_is_slater
integer, parameter, public do_se_is_slater
Definition input_constants.F:278
kinds
Defines the basic variable types.
Definition kinds.F:23
kinds::int_8
integer, parameter, public int_8
Definition kinds.F:54
kinds::dp
integer, parameter, public dp
Definition kinds.F:34
memory_utilities
Utility routines for the memory handling.
Definition memory_utilities.F:14
semi_empirical_int_ana
Analytical derivatives of Integrals for semi-empirical methods.
Definition semi_empirical_int_ana.F:18
semi_empirical_int_ana::rotint_ana
recursive subroutine, public rotint_ana(sepi, sepj, rijv, w, dw, se_int_control, se_taper)
calculates the derivative of the two-particle interactions
Definition semi_empirical_int_ana.F:1423
semi_empirical_int_ana::corecore_el_ana
recursive subroutine, public corecore_el_ana(sepi, sepj, rijv, itype, enuc, denuc, se_int_control, se_taper)
Computes analytical gradients for semiempirical core-core electrostatic interaction only.
Definition semi_empirical_int_ana.F:851
semi_empirical_int_ana::corecore_ana
recursive subroutine, public corecore_ana(sepi, sepj, rijv, itype, enuc, denuc, se_int_control, se_taper)
Computes analytical gradients for semiempirical core-core interaction.
Definition semi_empirical_int_ana.F:542
semi_empirical_int_ana::rotnuc_ana
recursive subroutine, public rotnuc_ana(sepi, sepj, rijv, itype, e1b, e2a, de1b, de2a, se_int_control, se_taper)
Computes analytical gradients for semiempirical integrals.
Definition semi_empirical_int_ana.F:285
semi_empirical_int_gks
Integral GKS scheme: The order of the integrals in makeCoul reflects the standard order by MOPAC.
Definition semi_empirical_int_gks.F:20
semi_empirical_int_gks::drotnuc_gks
subroutine, public drotnuc_gks(sepi, sepj, rij, de1b, de2a, se_int_control)
Computes the derivatives of the electron-nuclei integrals.
Definition semi_empirical_int_gks.F:156
semi_empirical_int_gks::corecore_gks
subroutine, public corecore_gks(sepi, sepj, rijv, enuc, denuc, se_int_control)
Computes nuclei-nuclei interactions.
Definition semi_empirical_int_gks.F:478
semi_empirical_int_gks::drotint_gks
subroutine, public drotint_gks(sepi, sepj, rij, dw, se_int_control)
Computes the derivatives of the electron-electron integrals.
Definition semi_empirical_int_gks.F:204
semi_empirical_int_gks::rotnuc_gks
subroutine, public rotnuc_gks(sepi, sepj, rij, e1b, e2a, se_int_control)
Computes the electron-nuclei integrals.
Definition semi_empirical_int_gks.F:59
semi_empirical_int_gks::rotint_gks
subroutine, public rotint_gks(sepi, sepj, rij, w, se_int_control)
Computes the electron-electron integrals.
Definition semi_empirical_int_gks.F:107
semi_empirical_int_num
Integrals for semi-empiric methods.
Definition semi_empirical_int_num.F:17
semi_empirical_int_num::rotnuc_num
subroutine, public rotnuc_num(sepi, sepj, rijv, e1b, e2a, itype, se_int_control, se_taper)
Computes the two-particle interactions.
Definition semi_empirical_int_num.F:394
semi_empirical_int_num::corecore_el_num
subroutine, public corecore_el_num(sepi, sepj, rijv, enuc, itype, se_int_control, se_taper)
Computes the electrostatic core-core interactions only.
Definition semi_empirical_int_num.F:674
semi_empirical_int_num::rotint_num
subroutine, public rotint_num(sepi, sepj, rijv, w, se_int_control, se_taper)
Computes the two particle interactions in the lab frame.
Definition semi_empirical_int_num.F:77
semi_empirical_int_num::drotint_num
subroutine, public drotint_num(sepi, sepj, r, dw, delta, se_int_control, se_taper)
Numerical Derivatives for rotint.
Definition semi_empirical_int_num.F:988
semi_empirical_int_num::drotnuc_num
subroutine, public drotnuc_num(sepi, sepj, r, de1b, de2a, itype, delta, se_int_control, se_taper)
Numerical Derivatives for rotnuc.
Definition semi_empirical_int_num.F:1028
semi_empirical_int_num::dcorecore_num
subroutine, public dcorecore_num(sepi, sepj, r, denuc, itype, delta, se_int_control, se_taper)
Numerical Derivatives for corecore.
Definition semi_empirical_int_num.F:1077
semi_empirical_int_num::dcorecore_el_num
subroutine, public dcorecore_el_num(sepi, sepj, r, denuc, itype, delta, se_int_control, se_taper)
Numerical Derivatives for corecore.
Definition semi_empirical_int_num.F:1112
semi_empirical_int_num::corecore_num
subroutine, public corecore_num(sepi, sepj, rijv, enuc, itype, se_int_control, se_taper)
Computes the core-core interactions.
Definition semi_empirical_int_num.F:500
semi_empirical_integrals
Set of wrappers for semi-empirical analytical/numerical Integrals routines.
Definition semi_empirical_integrals.F:16
semi_empirical_integrals::dcorecore_el
subroutine, public dcorecore_el(sepi, sepj, rij, denuc, itype, delta, anag, se_int_control, se_taper)
wrapper for numerical/analytical routines core-core electrostatic (only) integrals derivatives
Definition semi_empirical_integrals.F:589
semi_empirical_integrals::rotnuc
subroutine, public rotnuc(sepi, sepj, rij, e1b, e2a, itype, anag, se_int_control, se_taper, store_int_env)
wrapper for numerical/analytical 1 center 1 electron integrals
Definition semi_empirical_integrals.F:222
semi_empirical_integrals::corecore_el
subroutine, public corecore_el(sepi, sepj, rij, enuc, itype, anag, se_int_control, se_taper)
wrapper for numerical/analytical routines core-core electrostatic (only) integrals
Definition semi_empirical_integrals.F:437
semi_empirical_integrals::dcorecore
subroutine, public dcorecore(sepi, sepj, rij, denuc, itype, delta, anag, se_int_control, se_taper)
wrapper for numerical/analytical routines
Definition semi_empirical_integrals.F:548
semi_empirical_integrals::corecore
subroutine, public corecore(sepi, sepj, rij, enuc, itype, anag, se_int_control, se_taper)
wrapper for numerical/analytical routines core-core integrals, since are evaluated only once do not n...
Definition semi_empirical_integrals.F:398
semi_empirical_integrals::drotint
subroutine, public drotint(sepi, sepj, rij, dw, delta, anag, se_int_control, se_taper)
wrapper for numerical/analytical routines
Definition semi_empirical_integrals.F:470
semi_empirical_integrals::rotint
subroutine, public rotint(sepi, sepj, rij, w, anag, se_int_control, se_taper, store_int_env)
wrapper for numerical/analytical 2 center 2 electrons integrals routines with possibility of incore s...
Definition semi_empirical_integrals.F:72
semi_empirical_integrals::drotnuc
subroutine, public drotnuc(sepi, sepj, rij, de1b, de2a, itype, delta, anag, se_int_control, se_taper)
wrapper for numerical/analytical routines
Definition semi_empirical_integrals.F:507
semi_empirical_store_int_types
Type to store integrals for semi-empirical calculations.
Definition semi_empirical_store_int_types.F:13
semi_empirical_types
Definition of the semi empirical parameter types.
Definition semi_empirical_types.F:12
semi_empirical_store_int_types::semi_empirical_si_type
Semi-empirical store integrals type.
Definition semi_empirical_store_int_types.F:43
semi_empirical_types::se_int_control_type
Definition semi_empirical_types.F:137
semi_empirical_types::se_taper_type
Taper type use in semi-empirical calculations.
Definition semi_empirical_types.F:158
semi_empirical_types::semi_empirical_type
Semi-empirical type.
Definition semi_empirical_types.F:57