(git:ccc2433)
qs_kinetic.F
Go to the documentation of this file.
1 !--------------------------------------------------------------------------------------------------!
2 ! CP2K: A general program to perform molecular dynamics simulations !
3 ! Copyright 2000-2024 CP2K developers group <https://cp2k.org> !
4 ! !
5 ! SPDX-License-Identifier: GPL-2.0-or-later !
6 !--------------------------------------------------------------------------------------------------!
7 
8 ! **************************************************************************************************
9 !> \brief Calculation of kinetic energy matrix and forces
10 !> \par History
11 !> JGH: from core_hamiltonian
12 !> simplify further [7.2014]
13 !> \author Juerg Hutter
14 ! **************************************************************************************************
15 MODULE qs_kinetic
16  USE ai_contraction, ONLY: block_add,&
17  contraction,&
18  decontraction,&
19  force_trace
20  USE ai_kinetic, ONLY: kinetic
21  USE atomic_kind_types, ONLY: atomic_kind_type,&
22  get_atomic_kind_set
23  USE basis_set_types, ONLY: gto_basis_set_p_type,&
24  gto_basis_set_type
25  USE block_p_types, ONLY: block_p_type
26  USE cp_control_types, ONLY: dft_control_type
27  USE cp_dbcsr_operations, ONLY: dbcsr_allocate_matrix_set
28  USE dbcsr_api, ONLY: dbcsr_filter,&
29  dbcsr_finalize,&
30  dbcsr_get_block_p,&
31  dbcsr_p_type,&
32  dbcsr_type
33  USE kinds, ONLY: dp,&
34  int_8
35  USE kpoint_types, ONLY: get_kpoint_info,&
36  kpoint_type
37  USE orbital_pointers, ONLY: ncoset
38  USE qs_force_types, ONLY: qs_force_type
39  USE qs_integral_utils, ONLY: basis_set_list_setup,&
40  get_memory_usage
41  USE qs_kind_types, ONLY: qs_kind_type
42  USE qs_ks_types, ONLY: get_ks_env,&
43  qs_ks_env_type
44  USE qs_neighbor_list_types, ONLY: get_neighbor_list_set_p,&
45  neighbor_list_set_p_type
46  USE qs_overlap, ONLY: create_sab_matrix
47  USE virial_methods, ONLY: virial_pair_force
48  USE virial_types, ONLY: virial_type
49 
50 !$ USE OMP_LIB, ONLY: omp_lock_kind, &
51 !$ omp_init_lock, omp_set_lock, &
52 !$ omp_unset_lock, omp_destroy_lock
53 
54 #include "./base/base_uses.f90"
55 
56  IMPLICIT NONE
57 
58  PRIVATE
59 
60 ! *** Global parameters ***
61 
62  CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'qs_kinetic'
63 
64 ! *** Public subroutines ***
65 
66  PUBLIC :: build_kinetic_matrix
67 
68  INTEGER, DIMENSION(1:56), SAVE :: ndod = (/0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, &
69  1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, &
70  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, &
71  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1/)
72 
73 CONTAINS
74 
75 ! **************************************************************************************************
76 !> \brief Calculation of the kinetic energy matrix over Cartesian Gaussian functions.
77 !> \param ks_env the QS environment
78 !> \param matrix_t The kinetic energy matrix to be calculated (optional)
79 !> \param matrixkp_t The kinetic energy matrices to be calculated (kpoints,optional)
80 !> \param matrix_name The name of the matrix (i.e. for output)
81 !> \param basis_type basis set to be used
82 !> \param sab_nl pair list (must be consistent with basis sets!)
83 !> \param calculate_forces (optional) ...
84 !> \param matrix_p density matrix for force calculation (optional)
85 !> \param matrixkp_p density matrix for force calculation with kpoints (optional)
86 !> \param eps_filter Filter final matrix (optional)
87 !> \param nderivative The number of calculated derivatives
88 !> \date 11.10.2010
89 !> \par History
90 !> Ported from qs_overlap, replaces code in build_core_hamiltonian
91 !> Refactoring [07.2014] JGH
92 !> Simplify options and use new kinetic energy integral routine
93 !> kpoints [08.2014] JGH
94 !> Include the derivatives [2021] SL, ED
95 !> \author JGH
96 !> \version 1.0
97 ! **************************************************************************************************
98  SUBROUTINE build_kinetic_matrix(ks_env, matrix_t, matrixkp_t, matrix_name, &
99  basis_type, sab_nl, calculate_forces, matrix_p, matrixkp_p, &
100  eps_filter, nderivative)
101 
102  TYPE(qs_ks_env_type), POINTER :: ks_env
103  TYPE(dbcsr_p_type), DIMENSION(:), OPTIONAL, &
104  POINTER :: matrix_t
105  TYPE(dbcsr_p_type), DIMENSION(:, :), OPTIONAL, &
106  POINTER :: matrixkp_t
107  CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: matrix_name
108  CHARACTER(LEN=*), INTENT(IN) :: basis_type
109  TYPE(neighbor_list_set_p_type), DIMENSION(:), &
110  POINTER :: sab_nl
111  LOGICAL, INTENT(IN), OPTIONAL :: calculate_forces
112  TYPE(dbcsr_type), OPTIONAL, POINTER :: matrix_p
113  TYPE(dbcsr_p_type), DIMENSION(:, :), OPTIONAL, &
114  POINTER :: matrixkp_p
115  REAL(kind=dp), INTENT(IN), OPTIONAL :: eps_filter
116  INTEGER, INTENT(IN), OPTIONAL :: nderivative
117 
118  INTEGER :: natom
119 
120  CALL get_ks_env(ks_env, natom=natom)
121 
122  CALL build_kinetic_matrix_low(ks_env, matrix_t, matrixkp_t, matrix_name, basis_type, &
123  sab_nl, calculate_forces, matrix_p, matrixkp_p, eps_filter, natom, &
124  nderivative)
125 
126  END SUBROUTINE build_kinetic_matrix
127 
128 ! **************************************************************************************************
129 !> \brief Implementation of build_kinetic_matrix with the additional natom argument passed in to
130 !> allow for explicitly shaped force_thread array which is needed for OMP REDUCTION.
131 !> \param ks_env ...
132 !> \param matrix_t ...
133 !> \param matrixkp_t ...
134 !> \param matrix_name ...
135 !> \param basis_type ...
136 !> \param sab_nl ...
137 !> \param calculate_forces ...
138 !> \param matrix_p ...
139 !> \param matrixkp_p ...
140 !> \param eps_filter ...
141 !> \param natom ...
142 !> \param nderivative ...
143 ! **************************************************************************************************
144  SUBROUTINE build_kinetic_matrix_low(ks_env, matrix_t, matrixkp_t, matrix_name, basis_type, &
145  sab_nl, calculate_forces, matrix_p, matrixkp_p, eps_filter, natom, &
146  nderivative)
147 
148  TYPE(qs_ks_env_type), POINTER :: ks_env
149  TYPE(dbcsr_p_type), DIMENSION(:), OPTIONAL, &
150  POINTER :: matrix_t
151  TYPE(dbcsr_p_type), DIMENSION(:, :), OPTIONAL, &
152  POINTER :: matrixkp_t
153  CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: matrix_name
154  CHARACTER(LEN=*), INTENT(IN) :: basis_type
155  TYPE(neighbor_list_set_p_type), DIMENSION(:), &
156  POINTER :: sab_nl
157  LOGICAL, INTENT(IN), OPTIONAL :: calculate_forces
158  TYPE(dbcsr_type), OPTIONAL, POINTER :: matrix_p
159  TYPE(dbcsr_p_type), DIMENSION(:, :), OPTIONAL, &
160  POINTER :: matrixkp_p
161  REAL(kind=dp), INTENT(IN), OPTIONAL :: eps_filter
162  INTEGER, INTENT(IN) :: natom
163  INTEGER, INTENT(IN), OPTIONAL :: nderivative
164 
165  CHARACTER(len=*), PARAMETER :: routinen = 'build_kinetic_matrix_low'
166 
167  INTEGER :: atom_a, handle, i, iatom, ic, icol, ikind, irow, iset, jatom, jkind, jset, ldsab, &
168  maxder, ncoa, ncob, nder, nimg, nkind, nseta, nsetb, sgfa, sgfb, slot
169  INTEGER, ALLOCATABLE, DIMENSION(:) :: atom_of_kind, kind_of
170  INTEGER, DIMENSION(3) :: cell
171  INTEGER, DIMENSION(:), POINTER :: la_max, la_min, lb_max, lb_min, npgfa, &
172  npgfb, nsgfa, nsgfb
173  INTEGER, DIMENSION(:, :), POINTER :: first_sgfa, first_sgfb
174  INTEGER, DIMENSION(:, :, :), POINTER :: cell_to_index
175  LOGICAL :: do_forces, do_symmetric, dokp, found, &
176  trans, use_cell_mapping, use_virial
177  REAL(kind=dp) :: f, f0, ff, rab2, tab
178  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: pab, qab
179  REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :) :: kab
180  REAL(kind=dp), DIMENSION(3) :: force_a, rab
181  REAL(kind=dp), DIMENSION(3, 3) :: pv_thread
182  REAL(kind=dp), DIMENSION(3, natom) :: force_thread
183  REAL(kind=dp), DIMENSION(:), POINTER :: set_radius_a, set_radius_b
184  REAL(kind=dp), DIMENSION(:, :), POINTER :: p_block, rpgfa, rpgfb, scon_a, scon_b, &
185  zeta, zetb
186  REAL(kind=dp), DIMENSION(:, :, :), POINTER :: dab
187  TYPE(atomic_kind_type), DIMENSION(:), POINTER :: atomic_kind_set
188  TYPE(block_p_type), ALLOCATABLE, DIMENSION(:) :: k_block
189  TYPE(dft_control_type), POINTER :: dft_control
190  TYPE(gto_basis_set_p_type), DIMENSION(:), POINTER :: basis_set_list
191  TYPE(gto_basis_set_type), POINTER :: basis_set_a, basis_set_b
192  TYPE(kpoint_type), POINTER :: kpoints
193  TYPE(qs_force_type), DIMENSION(:), POINTER :: force
194  TYPE(qs_kind_type), DIMENSION(:), POINTER :: qs_kind_set
195  TYPE(virial_type), POINTER :: virial
196 
197 !$ INTEGER(kind=omp_lock_kind), &
198 !$ ALLOCATABLE, DIMENSION(:) :: locks
199 !$ INTEGER :: lock_num, hash, hash1, hash2
200 !$ INTEGER(KIND=int_8) :: iatom8
201 !$ INTEGER, PARAMETER :: nlock = 501
202 
203  mark_used(int_8)
204 
205  CALL timeset(routinen, handle)
206 
207  ! test for matrices (kpoints or standard gamma point)
208  IF (PRESENT(matrix_t)) THEN
209  dokp = .false.
210  use_cell_mapping = .false.
211  ELSEIF (PRESENT(matrixkp_t)) THEN
212  dokp = .true.
213  CALL get_ks_env(ks_env=ks_env, kpoints=kpoints)
214  CALL get_kpoint_info(kpoint=kpoints, cell_to_index=cell_to_index)
215  use_cell_mapping = (SIZE(cell_to_index) > 1)
216  ELSE
217  cpabort("")
218  END IF
219 
220  NULLIFY (atomic_kind_set, qs_kind_set, p_block, dft_control)
221  CALL get_ks_env(ks_env, &
222  dft_control=dft_control, &
223  atomic_kind_set=atomic_kind_set, &
224  qs_kind_set=qs_kind_set)
225 
226  nimg = dft_control%nimages
227  nkind = SIZE(atomic_kind_set)
228 
229  do_forces = .false.
230  IF (PRESENT(calculate_forces)) do_forces = calculate_forces
231 
232  nder = 0
233  IF (PRESENT(nderivative)) nder = nderivative
234  maxder = ncoset(nder)
235 
236  ! check for symmetry
237  cpassert(SIZE(sab_nl) > 0)
238  CALL get_neighbor_list_set_p(neighbor_list_sets=sab_nl, symmetric=do_symmetric)
239 
240  ! prepare basis set
241  ALLOCATE (basis_set_list(nkind))
242  CALL basis_set_list_setup(basis_set_list, basis_type, qs_kind_set)
243 
244  IF (dokp) THEN
245  CALL dbcsr_allocate_matrix_set(matrixkp_t, 1, nimg)
246  CALL create_sab_matrix(ks_env, matrixkp_t, matrix_name, basis_set_list, basis_set_list, &
247  sab_nl, do_symmetric)
248  ELSE
249  CALL dbcsr_allocate_matrix_set(matrix_t, maxder)
250  CALL create_sab_matrix(ks_env, matrix_t, matrix_name, basis_set_list, basis_set_list, &
251  sab_nl, do_symmetric)
252  END IF
253 
254  use_virial = .false.
255  IF (do_forces) THEN
256  ! if forces -> maybe virial too
257  CALL get_ks_env(ks_env=ks_env, force=force, virial=virial)
258  use_virial = virial%pv_availability .AND. (.NOT. virial%pv_numer)
259  ! we need density matrix for forces
260  IF (dokp) THEN
261  cpassert(PRESENT(matrixkp_p))
262  ELSE
263  cpassert(PRESENT(matrix_p))
264  END IF
265  END IF
266 
267  force_thread = 0.0_dp
268  pv_thread = 0.0_dp
269 
270  ! *** Allocate work storage ***
271  ldsab = get_memory_usage(qs_kind_set, basis_type)
272 
273 !$OMP PARALLEL DEFAULT(NONE) &
274 !$OMP SHARED (do_forces, ldsab, use_cell_mapping, do_symmetric, dokp,&
275 !$OMP sab_nl, ncoset, maxder, nder, ndod, use_virial, matrix_t, matrixkp_t,&
276 !$OMP matrix_p, basis_set_list, atom_of_kind, cell_to_index, matrixkp_p, locks, natom) &
277 !$OMP PRIVATE (k_block, kab, qab, pab, ikind, jkind, iatom, jatom, rab, cell, basis_set_a, basis_set_b, f, &
278 !$OMP first_sgfa, la_max, la_min, npgfa, nsgfa, nseta, rpgfa, set_radius_a, ncoa, ncob, force_a, &
279 !$OMP zeta, first_sgfb, lb_max, lb_min, npgfb, nsetb, rpgfb, set_radius_b, nsgfb, p_block, dab, tab, &
280 !$OMP slot, zetb, scon_a, scon_b, i, ic, irow, icol, f0, ff, found, trans, rab2, sgfa, sgfb, iset, jset, &
281 !$OMP hash, hash1, hash2, iatom8) &
282 !$OMP REDUCTION (+ : pv_thread, force_thread )
283 
284 !$OMP SINGLE
285 !$ ALLOCATE (locks(nlock))
286 !$OMP END SINGLE
287 
288 !$OMP DO
289 !$ DO lock_num = 1, nlock
290 !$ call omp_init_lock(locks(lock_num))
291 !$ END DO
292 !$OMP END DO
293 
294  ALLOCATE (kab(ldsab, ldsab, maxder), qab(ldsab, ldsab))
295  IF (do_forces) THEN
296  ALLOCATE (dab(ldsab, ldsab, 3), pab(ldsab, ldsab))
297  END IF
298 
299  ALLOCATE (k_block(maxder))
300  DO i = 1, maxder
301  NULLIFY (k_block(i)%block)
302  END DO
303 
304 !$OMP DO SCHEDULE(GUIDED)
305  DO slot = 1, sab_nl(1)%nl_size
306 
307  ikind = sab_nl(1)%nlist_task(slot)%ikind
308  jkind = sab_nl(1)%nlist_task(slot)%jkind
309  iatom = sab_nl(1)%nlist_task(slot)%iatom
310  jatom = sab_nl(1)%nlist_task(slot)%jatom
311  cell(:) = sab_nl(1)%nlist_task(slot)%cell(:)
312  rab(1:3) = sab_nl(1)%nlist_task(slot)%r(1:3)
313 
314  basis_set_a => basis_set_list(ikind)%gto_basis_set
315  IF (.NOT. ASSOCIATED(basis_set_a)) cycle
316  basis_set_b => basis_set_list(jkind)%gto_basis_set
317  IF (.NOT. ASSOCIATED(basis_set_b)) cycle
318 
319 !$ iatom8 = INT(iatom - 1, int_8)*INT(natom, int_8) + INT(jatom, int_8)
320 !$ hash1 = INT(MOD(iatom8, INT(nlock, int_8)) + 1)
321 
322  ! basis ikind
323  first_sgfa => basis_set_a%first_sgf
324  la_max => basis_set_a%lmax
325  la_min => basis_set_a%lmin
326  npgfa => basis_set_a%npgf
327  nseta = basis_set_a%nset
328  nsgfa => basis_set_a%nsgf_set
329  rpgfa => basis_set_a%pgf_radius
330  set_radius_a => basis_set_a%set_radius
331  scon_a => basis_set_a%scon
332  zeta => basis_set_a%zet
333  ! basis jkind
334  first_sgfb => basis_set_b%first_sgf
335  lb_max => basis_set_b%lmax
336  lb_min => basis_set_b%lmin
337  npgfb => basis_set_b%npgf
338  nsetb = basis_set_b%nset
339  nsgfb => basis_set_b%nsgf_set
340  rpgfb => basis_set_b%pgf_radius
341  set_radius_b => basis_set_b%set_radius
342  scon_b => basis_set_b%scon
343  zetb => basis_set_b%zet
344 
345  IF (use_cell_mapping) THEN
346  ic = cell_to_index(cell(1), cell(2), cell(3))
347  cpassert(ic > 0)
348  ELSE
349  ic = 1
350  END IF
351 
352  IF (do_symmetric) THEN
353  IF (iatom <= jatom) THEN
354  irow = iatom
355  icol = jatom
356  ELSE
357  irow = jatom
358  icol = iatom
359  END IF
360  f0 = 2.0_dp
361  IF (iatom == jatom) f0 = 1.0_dp
362  ff = 2.0_dp
363  ELSE
364  irow = iatom
365  icol = jatom
366  f0 = 1.0_dp
367  ff = 1.0_dp
368  END IF
369  IF (dokp) THEN
370  CALL dbcsr_get_block_p(matrix=matrixkp_t(1, ic)%matrix, &
371  row=irow, col=icol, block=k_block(1)%block, found=found)
372  cpassert(found)
373  ELSE
374  DO i = 1, maxder
375  NULLIFY (k_block(i)%block)
376  CALL dbcsr_get_block_p(matrix=matrix_t(i)%matrix, &
377  row=irow, col=icol, block=k_block(i)%block, found=found)
378  cpassert(found)
379  END DO
380  END IF
381 
382  IF (do_forces) THEN
383  NULLIFY (p_block)
384  IF (dokp) THEN
385  CALL dbcsr_get_block_p(matrix=matrixkp_p(1, ic)%matrix, &
386  row=irow, col=icol, block=p_block, found=found)
387  cpassert(found)
388  ELSE
389  CALL dbcsr_get_block_p(matrix=matrix_p, row=irow, col=icol, &
390  block=p_block, found=found)
391  cpassert(found)
392  END IF
393  END IF
394 
395  rab2 = rab(1)*rab(1) + rab(2)*rab(2) + rab(3)*rab(3)
396  tab = sqrt(rab2)
397  trans = do_symmetric .AND. (iatom > jatom)
398 
399  DO iset = 1, nseta
400 
401  ncoa = npgfa(iset)*(ncoset(la_max(iset)) - ncoset(la_min(iset) - 1))
402  sgfa = first_sgfa(1, iset)
403 
404  DO jset = 1, nsetb
405 
406  IF (set_radius_a(iset) + set_radius_b(jset) < tab) cycle
407 
408 !$ hash2 = MOD((iset - 1)*nsetb + jset, nlock) + 1
409 !$ hash = MOD(hash1 + hash2, nlock) + 1
410 
411  ncob = npgfb(jset)*(ncoset(lb_max(jset)) - ncoset(lb_min(jset) - 1))
412  sgfb = first_sgfb(1, jset)
413 
414  IF (do_forces .AND. ASSOCIATED(p_block) .AND. ((iatom /= jatom) .OR. use_virial)) THEN
415  ! Decontract P matrix block
416  kab = 0.0_dp
417  CALL block_add("OUT", kab(:, :, 1), nsgfa(iset), nsgfb(jset), p_block, sgfa, sgfb, trans=trans)
418  CALL decontraction(kab(:, :, 1), pab, scon_a(:, sgfa:), ncoa, nsgfa(iset), scon_b(:, sgfb:), ncob, nsgfb(jset), &
419  trans=trans)
420  ! calculate integrals and derivatives
421  CALL kinetic(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
422  lb_max(jset), lb_min(jset), npgfb(jset), rpgfb(:, jset), zetb(:, jset), &
423  rab, kab(:, :, 1), dab)
424  CALL force_trace(force_a, dab, pab, ncoa, ncob, 3)
425  force_thread(:, iatom) = force_thread(:, iatom) + ff*force_a(:)
426  force_thread(:, jatom) = force_thread(:, jatom) - ff*force_a(:)
427  IF (use_virial) THEN
428  CALL virial_pair_force(pv_thread, f0, force_a, rab)
429  END IF
430  ELSE
431  ! calclulate integrals
432  IF (nder == 0) THEN
433  CALL kinetic(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
434  lb_max(jset), lb_min(jset), npgfb(jset), rpgfb(:, jset), zetb(:, jset), &
435  rab, kab=kab(:, :, 1))
436  ELSE IF (nder == 1) THEN
437  CALL kinetic(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
438  lb_max(jset), lb_min(jset), npgfb(jset), rpgfb(:, jset), zetb(:, jset), &
439  rab, kab=kab(:, :, 1), dab=kab(:, :, 2:4))
440  END IF
441  END IF
442  DO i = 1, maxder
443  f = 1.0_dp
444  IF (ndod(i) == 1 .AND. trans) f = -1.0_dp
445  ! Contraction step
446  CALL contraction(kab(:, :, i), qab, ca=scon_a(:, sgfa:), na=ncoa, ma=nsgfa(iset), &
447  cb=scon_b(:, sgfb:), nb=ncob, mb=nsgfb(jset), fscale=f, &
448  trans=trans)
449 !$ CALL omp_set_lock(locks(hash))
450  CALL block_add("IN", qab, nsgfa(iset), nsgfb(jset), k_block(i)%block, sgfa, sgfb, trans=trans)
451 !$ CALL omp_unset_lock(locks(hash))
452  END DO
453  END DO
454  END DO
455 
456  END DO
457  DEALLOCATE (kab, qab)
458  IF (do_forces) DEALLOCATE (pab, dab)
459 !$OMP DO
460 !$ DO lock_num = 1, nlock
461 !$ call omp_destroy_lock(locks(lock_num))
462 !$ END DO
463 !$OMP END DO
464 
465 !$OMP SINGLE
466 !$ DEALLOCATE (locks)
467 !$OMP END SINGLE NOWAIT
468 
469 !$OMP END PARALLEL
470 
471  IF (do_forces) THEN
472  CALL get_atomic_kind_set(atomic_kind_set=atomic_kind_set, atom_of_kind=atom_of_kind, &
473  kind_of=kind_of)
474 
475 !$OMP DO
476  DO iatom = 1, natom
477  atom_a = atom_of_kind(iatom)
478  ikind = kind_of(iatom)
479  force(ikind)%kinetic(:, atom_a) = force(ikind)%kinetic(:, atom_a) + force_thread(:, iatom)
480  END DO
481 !$OMP END DO
482  END IF
483  IF (do_forces .AND. use_virial) THEN
484  virial%pv_ekinetic = virial%pv_ekinetic + pv_thread
485  virial%pv_virial = virial%pv_virial + pv_thread
486  END IF
487 
488  IF (dokp) THEN
489  DO ic = 1, nimg
490  CALL dbcsr_finalize(matrixkp_t(1, ic)%matrix)
491  IF (PRESENT(eps_filter)) THEN
492  CALL dbcsr_filter(matrixkp_t(1, ic)%matrix, eps_filter)
493  END IF
494  END DO
495  ELSE
496  CALL dbcsr_finalize(matrix_t(1)%matrix)
497  IF (PRESENT(eps_filter)) THEN
498  CALL dbcsr_filter(matrix_t(1)%matrix, eps_filter)
499  END IF
500  END IF
501 
502  DEALLOCATE (basis_set_list)
503 
504  CALL timestop(handle)
505 
506  END SUBROUTINE build_kinetic_matrix_low
507 
508 END MODULE qs_kinetic
509 
cp_dbcsr_operations::dbcsr_allocate_matrix_set
Definition: cp_dbcsr_operations.F:81
ai_contraction
Set of routines to: Contract integrals over primitive Gaussians Decontract (density) matrices Trace m...
Definition: ai_contraction.F:18
ai_kinetic
Calculation of the kinetic energy integrals over Cartesian Gaussian-type functions.
Definition: ai_kinetic.F:20
ai_kinetic::kinetic
subroutine, public kinetic(la_max, la_min, npgfa, rpgfa, zeta, lb_max, lb_min, npgfb, rpgfb, zetb, rab, kab, dab)
Calculation of the two-center kinetic energy integrals [a|T|b] over Cartesian Gaussian-type functions...
Definition: ai_kinetic.F:62
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
block_p_types
collect pointers to a block of reals
Definition: block_p_types.F:14
cp_control_types
Defines control structures, which contain the parameters and the settings for the DFT-based calculati...
Definition: cp_control_types.F:12
cp_dbcsr_operations
DBCSR operations in CP2K.
Definition: cp_dbcsr_operations.F:18
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
kpoint_types
Types and basic routines needed for a kpoint calculation.
Definition: kpoint_types.F:15
kpoint_types::get_kpoint_info
subroutine, public get_kpoint_info(kpoint, kp_scheme, nkp_grid, kp_shift, symmetry, verbose, full_grid, use_real_wfn, eps_geo, parallel_group_size, kp_range, nkp, xkp, wkp, para_env, blacs_env_all, para_env_kp, para_env_inter_kp, blacs_env, kp_env, kp_aux_env, mpools, iogrp, nkp_groups, kp_dist, cell_to_index, index_to_cell, sab_nl, sab_nl_nosym)
Retrieve information from a kpoint environment.
Definition: kpoint_types.F:333
orbital_pointers
Provides Cartesian and spherical orbital pointers and indices.
Definition: orbital_pointers.F:15
orbital_pointers::ncoset
integer, dimension(:), allocatable, public ncoset
Definition: orbital_pointers.F:42
qs_force_types
Definition: qs_force_types.F:13
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_kinetic
Calculation of kinetic energy matrix and forces.
Definition: qs_kinetic.F:15
qs_kinetic::build_kinetic_matrix
subroutine, public build_kinetic_matrix(ks_env, matrix_t, matrixkp_t, matrix_name, basis_type, sab_nl, calculate_forces, matrix_p, matrixkp_p, eps_filter, nderivative)
Calculation of the kinetic energy matrix over Cartesian Gaussian functions.
Definition: qs_kinetic.F:101
qs_ks_types
Definition: qs_ks_types.F:15
qs_ks_types::get_ks_env
subroutine, public get_ks_env(ks_env, v_hartree_rspace, s_mstruct_changed, rho_changed, potential_changed, forces_up_to_date, complex_ks, matrix_h, matrix_h_im, matrix_ks, matrix_ks_im, matrix_vxc, kinetic, matrix_s, matrix_s_RI_aux, matrix_w, matrix_p_mp2, matrix_p_mp2_admm, matrix_h_kp, matrix_h_im_kp, matrix_ks_kp, matrix_vxc_kp, kinetic_kp, matrix_s_kp, matrix_w_kp, matrix_s_RI_aux_kp, matrix_ks_im_kp, rho, rho_xc, vppl, rho_core, rho_nlcc, rho_nlcc_g, vee, neighbor_list_id, sab_orb, sab_all, sac_ae, sac_ppl, sac_lri, sap_ppnl, sap_oce, sab_lrc, sab_se, sab_xtbe, sab_tbe, sab_core, sab_xb, sab_xtb_nonbond, sab_vdw, sab_scp, sab_almo, sab_kp, sab_kp_nosym, task_list, task_list_soft, kpoints, do_kpoints, atomic_kind_set, qs_kind_set, cell, cell_ref, use_ref_cell, particle_set, energy, force, local_particles, local_molecules, molecule_kind_set, molecule_set, subsys, cp_subsys, virial, results, atprop, nkind, natom, dft_control, dbcsr_dist, distribution_2d, pw_env, para_env, blacs_env, nelectron_total, nelectron_spin)
...
Definition: qs_ks_types.F:330
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::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_overlap
Calculation of overlap matrix, its derivatives and forces.
Definition: qs_overlap.F:19
virial_methods
Definition: virial_methods.F:12
virial_methods::virial_pair_force
pure subroutine, public virial_pair_force(pv_virial, f0, force, rab)
Computes the contribution to the stress tensor from two-body pair-wise forces.
Definition: virial_methods.F:139
virial_types
Definition: virial_types.F:13