(git:374b731)
Loading...
Searching...
No Matches
qs_fb_filter_matrix_methods.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
8MODULE qs_fb_filter_matrix_methods
9
10 USE atomic_kind_types, ONLY: atomic_kind_type,&
11 get_atomic_kind
12 USE dbcsr_api, ONLY: dbcsr_create,&
13 dbcsr_distribution_type,&
14 dbcsr_finalize,&
15 dbcsr_get_info,&
16 dbcsr_get_stored_coordinates,&
17 dbcsr_put_block,&
18 dbcsr_type,&
19 dbcsr_type_no_symmetry
20 USE fermi_utils, ONLY: fermi,&
21 fermifixed
22 USE kinds, ONLY: default_string_length,&
23 dp,&
24 int_8
25 USE message_passing, ONLY: mp_para_env_type
26 USE particle_types, ONLY: particle_type
27 USE qs_fb_atomic_halo_types, ONLY: fb_atomic_halo_create,&
28 fb_atomic_halo_get,&
29 fb_atomic_halo_list_get,&
30 fb_atomic_halo_list_obj,&
31 fb_atomic_halo_nullify,&
32 fb_atomic_halo_obj,&
33 fb_atomic_halo_release,&
34 fb_atomic_halo_set
35 USE qs_fb_atomic_matrix_methods, ONLY: fb_atmatrix_calc_size,&
36 fb_atmatrix_construct,&
37 fb_atmatrix_construct_2,&
38 fb_atmatrix_generate_com_pairs_2
39 USE qs_fb_com_tasks_types, ONLY: &
40 task_cost, task_dest, task_n_records, task_pair, task_src, &
41 fb_com_atom_pairs_calc_buffer_sizes, fb_com_atom_pairs_create, fb_com_atom_pairs_decode, &
42 fb_com_atom_pairs_distribute_blks, fb_com_atom_pairs_gather_blks, fb_com_atom_pairs_get, &
43 fb_com_atom_pairs_has_data, fb_com_atom_pairs_init, fb_com_atom_pairs_nullify, &
44 fb_com_atom_pairs_obj, fb_com_atom_pairs_release, fb_com_tasks_build_atom_pairs, &
45 fb_com_tasks_create, fb_com_tasks_encode_pair, fb_com_tasks_nullify, fb_com_tasks_obj, &
46 fb_com_tasks_release, fb_com_tasks_set, fb_com_tasks_transpose_dest_src
47 USE qs_fb_matrix_data_types, ONLY: fb_matrix_data_add,&
48 fb_matrix_data_create,&
49 fb_matrix_data_has_data,&
50 fb_matrix_data_nullify,&
51 fb_matrix_data_obj,&
52 fb_matrix_data_release
53 USE qs_fb_trial_fns_types, ONLY: fb_trial_fns_get,&
54 fb_trial_fns_obj
55 USE string_utilities, ONLY: compress,&
56 uppercase
57#include "./base/base_uses.f90"
58
59 IMPLICIT NONE
60
61 PRIVATE
62
63 CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'qs_fb_filter_matrix_methods'
64
65 PUBLIC :: fb_fltrmat_build, &
66 fb_fltrmat_build_2
67
68CONTAINS
69
70! **************************************************************************************************
71!> \brief Build the filter matrix, with MPI communications happening at each
72!> step. Less efficient on communication, but more efficient on
73!> memory usage (compared to fb_fltrmat_build_2)
74!> \param H_mat : DBCSR system KS matrix
75!> \param S_mat : DBCSR system overlap matrix
76!> \param atomic_halos : list of all local atomic halos, each halo gives
77!> one atomic matrix and contributes to one blk
78!> col to the filter matrix
79!> \param trial_fns : the trial functions to be used to shrink the
80!> size of the new "filtered" basis
81!> \param para_env : cp2k parallel environment
82!> \param particle_set : set of all particles in the system
83!> \param fermi_level : the fermi level used for defining the filter
84!> function, which is a Fermi-Dirac distribution
85!> function
86!> \param filter_temp : the filter temperature used for defining the
87!> filter function
88!> \param name : name given to the filter matrix
89!> \param filter_mat : DBCSR format filter matrix
90!> \param tolerance : anything less than tolerance is treated as zero
91!> \author Lianheng Tong (LT) lianheng.tong@kcl.ac.uk
92! **************************************************************************************************
93 SUBROUTINE fb_fltrmat_build(H_mat, &
94 S_mat, &
95 atomic_halos, &
96 trial_fns, &
97 para_env, &
98 particle_set, &
99 fermi_level, &
100 filter_temp, &
101 name, &
102 filter_mat, &
103 tolerance)
104 TYPE(dbcsr_type), POINTER :: h_mat, s_mat
105 TYPE(fb_atomic_halo_list_obj), INTENT(IN) :: atomic_halos
106 TYPE(fb_trial_fns_obj), INTENT(IN) :: trial_fns
107 TYPE(mp_para_env_type), POINTER :: para_env
108 TYPE(particle_type), DIMENSION(:), POINTER :: particle_set
109 REAL(kind=dp), INTENT(IN) :: fermi_level, filter_temp
110 CHARACTER(LEN=*), INTENT(IN) :: name
111 TYPE(dbcsr_type), POINTER :: filter_mat
112 REAL(kind=dp), INTENT(IN) :: tolerance
113
114 CHARACTER(LEN=*), PARAMETER :: routinen = 'fb_fltrmat_build'
115
116 CHARACTER(LEN=32) :: symmetry_string
117 CHARACTER(LEN=default_string_length) :: name_string
118 INTEGER :: handle, iblkcol, ihalo, ikind, &
119 max_nhalos, nblkcols_total, nhalos
120 INTEGER, DIMENSION(:), POINTER :: col_blk_size, dummy_halo_atoms, ntfns, &
121 row_blk_size
122 LOGICAL :: send_data_only
123 TYPE(atomic_kind_type), POINTER :: atomic_kind
124 TYPE(dbcsr_distribution_type) :: dbcsr_dist
125 TYPE(fb_atomic_halo_obj) :: dummy_atomic_halo
126 TYPE(fb_atomic_halo_obj), DIMENSION(:), POINTER :: halos
127
128 CALL timeset(routinen, handle)
129
130 NULLIFY (halos, atomic_kind, ntfns, dummy_halo_atoms, row_blk_size, col_blk_size)
131 CALL fb_atomic_halo_nullify(dummy_atomic_halo)
132
133 ! filter_mat must be of a dissassociated status (i.e. brand new)
134 cpassert(.NOT. ASSOCIATED(filter_mat))
135
136 ! get trial function information
137 CALL fb_trial_fns_get(trial_fns=trial_fns, &
138 nfunctions=ntfns)
139
140 ! calculate the row_blk_size and col_blk_size arrays for
141 ! constructing the filter matrix in DBCSR format
142 ! row_blk_size for the filter matrix is the same as H or S
143 CALL dbcsr_get_info(h_mat, &
144 nblkcols_total=nblkcols_total, &
145 row_blk_size=row_blk_size, &
146 distribution=dbcsr_dist)
147 ALLOCATE (col_blk_size(nblkcols_total))
148 col_blk_size = 0
149 DO iblkcol = 1, nblkcols_total
150 atomic_kind => particle_set(iblkcol)%atomic_kind
151 CALL get_atomic_kind(atomic_kind=atomic_kind, &
152 kind_number=ikind)
153 col_blk_size(iblkcol) = ntfns(ikind)
154 END DO
155 ! DO NOT deallocate cbs if gift=.TRUE. as col_blk_sizes will only point to cbs
156 name_string = name
157 CALL compress(name_string)
158 CALL uppercase(name_string)
159 ! the filter matrix is non-square and is always non-symmetric
160 symmetry_string = dbcsr_type_no_symmetry
161 ! create empty filter matrix
162 ALLOCATE (filter_mat)
163 CALL dbcsr_create(matrix=filter_mat, &
164 name=name_string, &
165 dist=dbcsr_dist, &
166 matrix_type=symmetry_string, &
167 row_blk_size=row_blk_size, &
168 col_blk_size=col_blk_size, &
169 nze=0)
170 DEALLOCATE (col_blk_size)
171
172 CALL fb_atomic_halo_list_get(atomic_halos=atomic_halos, &
173 nhalos=nhalos, &
174 max_nhalos=max_nhalos, &
175 halos=halos)
176
177 ! create dummy empty atomic halo
178 CALL fb_atomic_halo_create(dummy_atomic_halo)
179 ALLOCATE (dummy_halo_atoms(0))
180 CALL fb_atomic_halo_set(atomic_halo=dummy_atomic_halo, &
181 owner_atom=0, &
182 owner_id_in_halo=0, &
183 natoms=0, &
184 halo_atoms=dummy_halo_atoms, &
185 nelectrons=0, &
186 sorted=.true.)
187
188 send_data_only = .false.
189
190 DO ihalo = 1, max_nhalos
191 IF (ihalo > nhalos) THEN
192 send_data_only = .true.
193 END IF
194 ! construct the filter matrix block by block
195 IF (send_data_only) THEN
196 CALL fb_fltrmat_add_blkcol(h_mat, &
197 s_mat, &
198 dummy_atomic_halo, &
199 trial_fns, &
200 para_env, &
201 particle_set, &
202 fermi_level, &
203 filter_temp, &
204 filter_mat, &
205 tolerance)
206 ELSE
207 CALL fb_fltrmat_add_blkcol(h_mat, &
208 s_mat, &
209 halos(ihalo), &
210 trial_fns, &
211 para_env, &
212 particle_set, &
213 fermi_level, &
214 filter_temp, &
215 filter_mat, &
216 tolerance)
217 END IF ! send_data_only
218 END DO
219
220 ! finalise the filter matrix
221 CALL dbcsr_finalize(filter_mat)
222
223 ! cleanup
224 CALL fb_atomic_halo_release(dummy_atomic_halo)
225
226 CALL timestop(handle)
227
228 END SUBROUTINE fb_fltrmat_build
229
230! **************************************************************************************************
231!> \brief Build the filter matrix, with MPI communications grouped together.
232!> More effcient on communication, less efficient on memory (compared
233!> to fb_fltrmat_build)
234!> \param H_mat : DBCSR system KS matrix
235!> \param S_mat : DBCSR system overlap matrix
236!> \param atomic_halos : list of all local atomic halos, each halo gives
237!> one atomic matrix and contributes to one blk
238!> col to the filter matrix
239!> \param trial_fns : the trial functions to be used to shrink the
240!> size of the new "filtered" basis
241!> \param para_env : cp2k parallel environment
242!> \param particle_set : set of all particles in the system
243!> \param fermi_level : the fermi level used for defining the filter
244!> function, which is a Fermi-Dirac distribution
245!> function
246!> \param filter_temp : the filter temperature used for defining the
247!> filter function
248!> \param name : name given to the filter matrix
249!> \param filter_mat : DBCSR format filter matrix
250!> \param tolerance : anything less than tolerance is treated as zero
251!> \author Lianheng Tong (LT) lianheng.tong@kcl.ac.uk
252! **************************************************************************************************
253 SUBROUTINE fb_fltrmat_build_2(H_mat, &
254 S_mat, &
255 atomic_halos, &
256 trial_fns, &
257 para_env, &
258 particle_set, &
259 fermi_level, &
260 filter_temp, &
261 name, &
262 filter_mat, &
263 tolerance)
264 TYPE(dbcsr_type), POINTER :: h_mat, s_mat
265 TYPE(fb_atomic_halo_list_obj), INTENT(IN) :: atomic_halos
266 TYPE(fb_trial_fns_obj), INTENT(IN) :: trial_fns
267 TYPE(mp_para_env_type), POINTER :: para_env
268 TYPE(particle_type), DIMENSION(:), POINTER :: particle_set
269 REAL(kind=dp), INTENT(IN) :: fermi_level, filter_temp
270 CHARACTER(LEN=*), INTENT(IN) :: name
271 TYPE(dbcsr_type), POINTER :: filter_mat
272 REAL(kind=dp), INTENT(IN) :: tolerance
273
274 CHARACTER(LEN=*), PARAMETER :: routinen = 'fb_fltrmat_build_2'
275
276 CHARACTER(LEN=default_string_length) :: name_string
277 INTEGER :: handle, iblkcol, ihalo, ikind, &
278 natoms_global, natoms_in_halo, &
279 nblkcols_total, nblks_recv, nhalos, &
280 nmax
281 INTEGER, DIMENSION(:), POINTER :: col_blk_size, ntfns, row_blk_size
282 LOGICAL :: check_ok
283 TYPE(atomic_kind_type), POINTER :: atomic_kind
284 TYPE(dbcsr_distribution_type) :: dbcsr_dist
285 TYPE(fb_atomic_halo_obj), DIMENSION(:), POINTER :: halos
286 TYPE(fb_com_atom_pairs_obj) :: atmatrix_blks_recv, atmatrix_blks_send, &
287 filter_mat_blks_recv, &
288 filter_mat_blks_send
289 TYPE(fb_matrix_data_obj) :: filter_mat_data, h_mat_data, s_mat_data
290
291 CALL timeset(routinen, handle)
292
293 NULLIFY (halos, atomic_kind, row_blk_size, col_blk_size, ntfns)
294
295 ! filter_mat must be of a dissassociated status (i.e. brand new)
296 check_ok = .NOT. ASSOCIATED(filter_mat)
297 cpassert(check_ok)
298
299 ! get total number of atoms
300 natoms_global = SIZE(particle_set)
301
302 ! get trial function information
303 CALL fb_trial_fns_get(trial_fns=trial_fns, &
304 nfunctions=ntfns)
305
306 ! calculate the row_blk_size and col_blk_size arrays for
307 ! constructing the filter matrix in DBCSR format
308 ! row_blk_size for the filter matrix is the same as H or S
309 CALL dbcsr_get_info(h_mat, &
310 nblkcols_total=nblkcols_total, &
311 row_blk_size=row_blk_size, &
312 distribution=dbcsr_dist)
313 ALLOCATE (col_blk_size(nblkcols_total))
314 col_blk_size = 0
315 DO iblkcol = 1, nblkcols_total
316 atomic_kind => particle_set(iblkcol)%atomic_kind
317 CALL get_atomic_kind(atomic_kind=atomic_kind, &
318 kind_number=ikind)
319 col_blk_size(iblkcol) = ntfns(ikind)
320 END DO
321 ! DO NOT deallocate cbs if gift=.TRUE. as col_blk_sizes will only point to cbs
322 name_string = name
323 CALL compress(name_string)
324 CALL uppercase(name_string)
325 ! create empty filter matrix (it is always non-symmetric as it is non-square)
326 ALLOCATE (filter_mat)
327 CALL dbcsr_create(matrix=filter_mat, &
328 name=name_string, &
329 dist=dbcsr_dist, &
330 matrix_type=dbcsr_type_no_symmetry, &
331 row_blk_size=row_blk_size, &
332 col_blk_size=col_blk_size, &
333 nze=0)
334 DEALLOCATE (col_blk_size)
335
336 ! get all the blocks required for constructing atomic matrics, and
337 ! store it in a fb_matrix_data object
338 CALL fb_matrix_data_nullify(h_mat_data)
339 CALL fb_matrix_data_nullify(s_mat_data)
340 CALL fb_com_atom_pairs_nullify(atmatrix_blks_send)
341 CALL fb_com_atom_pairs_nullify(atmatrix_blks_recv)
342 CALL fb_com_atom_pairs_create(atmatrix_blks_send)
343 CALL fb_com_atom_pairs_create(atmatrix_blks_recv)
344 ! H matrix
345 CALL fb_atmatrix_generate_com_pairs_2(h_mat, &
346 atomic_halos, &
347 para_env, &
348 atmatrix_blks_send, &
349 atmatrix_blks_recv)
350 CALL fb_com_atom_pairs_get(atom_pairs=atmatrix_blks_recv, &
351 npairs=nblks_recv)
352 CALL fb_matrix_data_create(h_mat_data, &
353 nblks_recv, &
354 natoms_global)
355 CALL fb_com_atom_pairs_gather_blks(h_mat, &
356 atmatrix_blks_send, &
357 atmatrix_blks_recv, &
358 para_env, &
359 h_mat_data)
360 ! S matrix
361 CALL fb_atmatrix_generate_com_pairs_2(s_mat, &
362 atomic_halos, &
363 para_env, &
364 atmatrix_blks_send, &
365 atmatrix_blks_recv)
366 CALL fb_com_atom_pairs_get(atom_pairs=atmatrix_blks_recv, &
367 npairs=nblks_recv)
368 CALL fb_matrix_data_create(s_mat_data, &
369 nblks_recv, &
370 natoms_global)
371 CALL fb_com_atom_pairs_gather_blks(s_mat, &
372 atmatrix_blks_send, &
373 atmatrix_blks_recv, &
374 para_env, &
375 s_mat_data)
376 ! cleanup
377 CALL fb_com_atom_pairs_release(atmatrix_blks_send)
378 CALL fb_com_atom_pairs_release(atmatrix_blks_recv)
379
380 ! make filter matrix blocks one by one and store in an
381 ! matrix_data_obj
382 CALL fb_matrix_data_nullify(filter_mat_data)
383 CALL fb_atomic_halo_list_get(atomic_halos=atomic_halos, &
384 nhalos=nhalos, &
385 halos=halos)
386 nmax = 0
387 DO ihalo = 1, nhalos
388 CALL fb_atomic_halo_get(atomic_halo=halos(ihalo), &
389 natoms=natoms_in_halo)
390 nmax = nmax + natoms_in_halo
391 END DO
392 CALL fb_matrix_data_create(filter_mat_data, &
393 nmax, &
394 natoms_global)
395 DO ihalo = 1, nhalos
396 CALL fb_fltrmat_add_blkcol_2(h_mat, &
397 s_mat, &
398 h_mat_data, &
399 s_mat_data, &
400 halos(ihalo), &
401 trial_fns, &
402 particle_set, &
403 fermi_level, &
404 filter_temp, &
405 filter_mat_data, &
406 tolerance)
407 END DO
408 ! clean up
409 CALL fb_matrix_data_release(h_mat_data)
410 CALL fb_matrix_data_release(s_mat_data)
411
412 ! distribute the relevant blocks from the matrix_data_obj to DBCSR
413 ! filter matrix
414 CALL fb_com_atom_pairs_nullify(filter_mat_blks_send)
415 CALL fb_com_atom_pairs_nullify(filter_mat_blks_recv)
416 CALL fb_com_atom_pairs_create(filter_mat_blks_send)
417 CALL fb_com_atom_pairs_create(filter_mat_blks_recv)
418 CALL fb_fltrmat_generate_com_pairs_2(filter_mat, &
419 atomic_halos, &
420 para_env, &
421 filter_mat_blks_send, &
422 filter_mat_blks_recv)
423 CALL fb_com_atom_pairs_distribute_blks(filter_mat_data, &
424 filter_mat_blks_send, &
425 filter_mat_blks_recv, &
426 para_env, &
427 filter_mat)
428 ! cleanup
429 CALL fb_com_atom_pairs_release(filter_mat_blks_send)
430 CALL fb_com_atom_pairs_release(filter_mat_blks_recv)
431 CALL fb_matrix_data_release(filter_mat_data)
432
433 ! finalise matrix
434 CALL dbcsr_finalize(filter_mat)
435
436 CALL timestop(handle)
437
438 END SUBROUTINE fb_fltrmat_build_2
439
440! **************************************************************************************************
441!> \brief Add a computed blocks in one column to the filter matrix. This
442!> version is used by fb_fltrmat_build, for the case where MPI
443!> communications are done at each step
444!> It does not finalise the filter matrix
445!> \param H_mat : DBCSR system KS matrix
446!> \param S_mat : DBCSR system overlap matrix
447!> \param atomic_halo : the halo that contributes to the blk
448!> col of the filter matrix
449!> \param trial_fns ...
450!> \param para_env : cp2k parallel environment
451!> \param particle_set : set of all particles in the system
452!> \param fermi_level : the fermi level used for defining the filter
453!> function, which is a Fermi-Dirac distribution
454!> function
455!> \param filter_temp : the filter temperature used for defining the
456!> filter function
457!> \param filter_mat : DBCSR format filter matrix
458!> \param tolerance : anything smaller than tolerance is treated as zero
459!> \author Lianheng Tong (LT) lianheng.tong@kcl.ac.uk
460! **************************************************************************************************
461 SUBROUTINE fb_fltrmat_add_blkcol(H_mat, &
462 S_mat, &
463 atomic_halo, &
464 trial_fns, &
465 para_env, &
466 particle_set, &
467 fermi_level, &
468 filter_temp, &
469 filter_mat, &
470 tolerance)
471 TYPE(dbcsr_type), POINTER :: h_mat, s_mat
472 TYPE(fb_atomic_halo_obj), INTENT(IN) :: atomic_halo
473 TYPE(fb_trial_fns_obj), INTENT(IN) :: trial_fns
474 TYPE(mp_para_env_type), POINTER :: para_env
475 TYPE(particle_type), DIMENSION(:), POINTER :: particle_set
476 REAL(kind=dp), INTENT(IN) :: fermi_level, filter_temp
477 TYPE(dbcsr_type), POINTER :: filter_mat
478 REAL(kind=dp), INTENT(IN) :: tolerance
479
480 CHARACTER(LEN=*), PARAMETER :: routinen = 'fb_fltrmat_add_blkcol'
481
482 INTEGER :: handle, handle_mpi, iatom_global, iatom_in_halo, ind, ipair, ipe, itrial, &
483 jatom_global, jatom_in_halo, jkind, natoms_global, natoms_in_halo, ncols_atmatrix, &
484 ncols_blk, nrows_atmatrix, nrows_blk, numprocs, pe, recv_encode, send_encode, stat
485 INTEGER(KIND=int_8), DIMENSION(:), POINTER :: pairs_recv, pairs_send
486 INTEGER, ALLOCATABLE, DIMENSION(:) :: atomic_h_blk_col_start, atomic_h_blk_row_start, &
487 atomic_s_blk_col_start, atomic_s_blk_row_start, col_block_size_data, ind_in_halo, &
488 recv_disps, recv_pair_count, recv_pair_disps, recv_sizes, send_disps, send_pair_count, &
489 send_pair_disps, send_sizes
490 INTEGER, DIMENSION(:), POINTER :: halo_atoms, ntfns, row_block_size_data
491 INTEGER, DIMENSION(:, :), POINTER :: tfns
492 REAL(kind=dp), ALLOCATABLE, DIMENSION(:) :: recv_buf, send_buf
493 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: atomic_filter_mat, atomic_h, atomic_s
494 TYPE(atomic_kind_type), POINTER :: atomic_kind
495 TYPE(fb_com_atom_pairs_obj) :: com_pairs_recv, com_pairs_send
496
497 CALL timeset(routinen, handle)
498
499 NULLIFY (atomic_kind, halo_atoms, ntfns, pairs_send, pairs_recv, &
500 row_block_size_data, tfns)
501 CALL fb_com_atom_pairs_nullify(com_pairs_send)
502 CALL fb_com_atom_pairs_nullify(com_pairs_recv)
503
504 ! ----------------------------------------------------------------------
505 ! Get communication buffers ready
506 ! ----------------------------------------------------------------------
507
508 ! generate send and recv atom pairs
509 CALL fb_com_atom_pairs_create(com_pairs_send)
510 CALL fb_com_atom_pairs_create(com_pairs_recv)
511 CALL fb_fltrmat_generate_com_pairs(filter_mat, &
512 atomic_halo, &
513 para_env, &
514 com_pairs_send, &
515 com_pairs_recv)
516 CALL fb_com_atom_pairs_get(atom_pairs=com_pairs_send, &
517 natoms_encode=send_encode, &
518 pairs=pairs_send)
519 CALL fb_com_atom_pairs_get(atom_pairs=com_pairs_recv, &
520 natoms_encode=recv_encode, &
521 pairs=pairs_recv)
522
523 ! get para_env info
524 numprocs = para_env%num_pe
525 ! me = para_env%mepos + 1 ! my process id, starting counting from 1
526
527 ! obtain trail function information
528 CALL fb_trial_fns_get(trial_fns=trial_fns, &
529 nfunctions=ntfns, &
530 functions=tfns)
531
532 ! obtain row and col block size data for filter matrix
533 CALL dbcsr_get_info(h_mat, row_blk_size=row_block_size_data)
534 natoms_global = SIZE(particle_set)
535 ALLOCATE (col_block_size_data(natoms_global))
536 DO jatom_global = 1, natoms_global
537 atomic_kind => particle_set(jatom_global)%atomic_kind
538 CALL get_atomic_kind(atomic_kind=atomic_kind, kind_number=jkind)
539 col_block_size_data(jatom_global) = ntfns(jkind)
540 END DO
541
542 ! allocate temporary arrays for send
543 ALLOCATE (send_sizes(numprocs))
544 ALLOCATE (send_disps(numprocs))
545 ALLOCATE (send_pair_count(numprocs))
546 ALLOCATE (send_pair_disps(numprocs))
547 ! setup send buffer sizes
548 CALL fb_com_atom_pairs_calc_buffer_sizes(com_pairs_send, &
549 numprocs, &
550 row_block_size_data, &
551 col_block_size_data, &
552 send_sizes, &
553 send_disps, &
554 send_pair_count, &
555 send_pair_disps)
556 ! allocate send buffer
557 ALLOCATE (send_buf(sum(send_sizes)))
558
559 ! allocate temporary array for recv
560 ALLOCATE (recv_sizes(numprocs))
561 ALLOCATE (recv_disps(numprocs))
562 ALLOCATE (recv_pair_count(numprocs))
563 ALLOCATE (recv_pair_disps(numprocs))
564 ! setup recv buffer sizes
565 CALL fb_com_atom_pairs_calc_buffer_sizes(com_pairs_recv, &
566 numprocs, &
567 row_block_size_data, &
568 col_block_size_data, &
569 recv_sizes, &
570 recv_disps, &
571 recv_pair_count, &
572 recv_pair_disps)
573 ! allocate recv buffer
574 ALLOCATE (recv_buf(sum(recv_sizes)))
575
576 ! ----------------------------------------------------------------------
577 ! Construct atomic filter matrix for this atomic_halo
578 ! ----------------------------------------------------------------------
579
580 CALL fb_atomic_halo_get(atomic_halo=atomic_halo, &
581 natoms=natoms_in_halo, &
582 halo_atoms=halo_atoms)
583
584 ! construct atomic matrix for H for atomic_halo
585 ALLOCATE (atomic_h_blk_row_start(natoms_in_halo + 1), &
586 atomic_h_blk_col_start(natoms_in_halo + 1), &
587 stat=stat)
588 cpassert(stat == 0)
589 CALL fb_atmatrix_calc_size(h_mat, &
590 atomic_halo, &
591 nrows_atmatrix, &
592 ncols_atmatrix, &
593 atomic_h_blk_row_start, &
594 atomic_h_blk_col_start)
595
596 ALLOCATE (atomic_h(nrows_atmatrix, ncols_atmatrix))
597 CALL fb_atmatrix_construct(h_mat, &
598 atomic_halo, &
599 para_env, &
600 atomic_h, &
601 atomic_h_blk_row_start, &
602 atomic_h_blk_col_start)
603
604 ! construct atomic matrix for S for atomic_halo
605 ALLOCATE (atomic_s_blk_row_start(natoms_in_halo + 1), &
606 atomic_s_blk_col_start(natoms_in_halo + 1), &
607 stat=stat)
608 cpassert(stat == 0)
609 CALL fb_atmatrix_calc_size(s_mat, &
610 atomic_halo, &
611 nrows_atmatrix, &
612 ncols_atmatrix, &
613 atomic_s_blk_row_start, &
614 atomic_s_blk_col_start)
615 ALLOCATE (atomic_s(nrows_atmatrix, ncols_atmatrix))
616 CALL fb_atmatrix_construct(s_mat, &
617 atomic_halo, &
618 para_env, &
619 atomic_s, &
620 atomic_s_blk_row_start, &
621 atomic_s_blk_col_start)
622
623 ! construct the atomic filter matrix
624 ALLOCATE (atomic_filter_mat(nrows_atmatrix, ncols_atmatrix))
625 ! calculate atomic filter matrix only if it is non-zero sized
626 IF (nrows_atmatrix > 0 .AND. ncols_atmatrix > 0) THEN
627 CALL fb_fltrmat_build_atomic_fltrmat(atomic_h, &
628 atomic_s, &
629 fermi_level, &
630 filter_temp, &
631 atomic_filter_mat, &
632 tolerance)
633 END IF
634
635 ! ----------------------------------------------------------------------
636 ! Construct filter matrix blocks and add to the correct locations
637 ! in send_buffer
638 ! ----------------------------------------------------------------------
639
640 ! preconstruct iatom_global to iatom_in_halo map
641 ALLOCATE (ind_in_halo(natoms_global))
642 ind_in_halo = 0
643 DO iatom_in_halo = 1, natoms_in_halo
644 iatom_global = halo_atoms(iatom_in_halo)
645 ind_in_halo(iatom_global) = iatom_in_halo
646 END DO
647
648 ! initialise send buffer
649 IF (SIZE(send_buf) > 0) send_buf = 0.0_dp
650 ! assign values
651 DO ipe = 1, numprocs
652 send_sizes(ipe) = 0
653 DO ipair = 1, send_pair_count(ipe)
654 CALL fb_com_atom_pairs_decode(pairs_send(send_pair_disps(ipe) + ipair), &
655 pe, iatom_global, jatom_global, &
656 send_encode)
657 iatom_in_halo = ind_in_halo(iatom_global)
658 cpassert(iatom_in_halo > 0)
659 jatom_in_halo = ind_in_halo(jatom_global)
660 cpassert(jatom_in_halo > 0)
661 atomic_kind => particle_set(jatom_global)%atomic_kind
662 CALL get_atomic_kind(atomic_kind=atomic_kind, &
663 kind_number=jkind)
664 nrows_blk = row_block_size_data(iatom_global)
665 ncols_blk = ntfns(jkind)
666
667 ! do it column-wise one trial function at a time
668 DO itrial = 1, ntfns(jkind)
669 ind = send_disps(ipe) + send_sizes(ipe) + (itrial - 1)*nrows_blk
670 CALL dgemv("N", &
671 nrows_blk, &
672 ncols_atmatrix, &
673 1.0_dp, &
674 atomic_filter_mat( &
675 atomic_h_blk_row_start(iatom_in_halo): &
676 atomic_h_blk_row_start(iatom_in_halo + 1) - 1, &
677 1:ncols_atmatrix &
678 ), &
679 nrows_blk, &
680 atomic_s( &
681 1:nrows_atmatrix, &
682 atomic_s_blk_col_start(jatom_in_halo) + &
683 tfns(itrial, jkind) - 1 &
684 ), &
685 1, &
686 0.0_dp, &
687 send_buf(ind + 1:ind + nrows_blk), &
688 1)
689 END DO ! itrial
690 send_sizes(ipe) = send_sizes(ipe) + nrows_blk*ncols_blk
691 END DO ! ipair
692 END DO ! ipe
693
694 DEALLOCATE (atomic_h)
695 DEALLOCATE (atomic_h_blk_row_start)
696 DEALLOCATE (atomic_s)
697 DEALLOCATE (atomic_s_blk_row_start)
698 DEALLOCATE (atomic_filter_mat)
699 DEALLOCATE (ind_in_halo)
700
701 ! ----------------------------------------------------------------------
702 ! Do communication
703 ! ----------------------------------------------------------------------
704
705 CALL timeset("fb_fltrmat_add_blkcol_mpi", handle_mpi)
706
707 CALL para_env%alltoall(send_buf, send_sizes, send_disps, &
708 recv_buf, recv_sizes, recv_disps)
709
710 CALL timestop(handle_mpi)
711
712 DEALLOCATE (send_buf)
713 DEALLOCATE (send_sizes)
714 DEALLOCATE (send_disps)
715 DEALLOCATE (send_pair_count)
716 DEALLOCATE (send_pair_disps)
717
718 ! ----------------------------------------------------------------------
719 ! Unpack the recv buffer and add the blocks to correct parts of
720 ! the DBCSR filter matrix
721 ! ----------------------------------------------------------------------
722
723 DO ipe = 1, numprocs
724 recv_sizes(ipe) = 0
725 DO ipair = 1, recv_pair_count(ipe)
726 CALL fb_com_atom_pairs_decode(pairs_recv(recv_pair_disps(ipe) + ipair), &
727 pe, iatom_global, jatom_global, &
728 recv_encode)
729 nrows_blk = row_block_size_data(iatom_global)
730 ncols_blk = col_block_size_data(jatom_global)
731 ind = recv_disps(ipe) + recv_sizes(ipe)
732 CALL dbcsr_put_block(filter_mat, &
733 iatom_global, jatom_global, &
734 recv_buf((ind + 1):(ind + nrows_blk*ncols_blk)))
735 recv_sizes(ipe) = recv_sizes(ipe) + nrows_blk*ncols_blk
736 END DO ! ipair
737 END DO ! ipe
738
739 ! cleanup rest of the temporary arrays
740 DEALLOCATE (recv_buf)
741 DEALLOCATE (recv_sizes)
742 DEALLOCATE (recv_pair_count)
743 DEALLOCATE (recv_pair_disps)
744
745 CALL fb_com_atom_pairs_release(com_pairs_send)
746 CALL fb_com_atom_pairs_release(com_pairs_recv)
747
748 ! cannot finalise the matrix until all blocks has been added
749
750 CALL timestop(handle)
751
752 END SUBROUTINE fb_fltrmat_add_blkcol
753
754! **************************************************************************************************
755!> \brief Computed blocks in one filter matrix column. This version is used by
756!> fb_fltrmat_build_2, where MPI communication is done collectively
757!> \param H_mat : DBCSR system KS matrix
758!> \param S_mat : DBCSR system overlap matrix
759!> \param H_mat_data : local storage of the relevant H_mat matrix blocks
760!> \param S_mat_data : local storage of the relevant S_mat matrix blocks
761!> \param atomic_halo : the halo that contributes to the blk
762!> col of the filter matrix
763!> \param trial_fns : trial functions data
764!> \param particle_set : set of all particles in the system
765!> \param fermi_level : the fermi level used for defining the filter
766!> function, which is a Fermi-Dirac distribution
767!> function
768!> \param filter_temp : the filter temperature used for defining the
769!> filter function
770!> \param filter_mat_data : local storage for the the computed filter matrix
771!> blocks
772!> \param tolerance : anything less than this is regarded as zero
773!> \author Lianheng Tong (LT) lianheng.tong@kcl.ac.uk
774! **************************************************************************************************
775 SUBROUTINE fb_fltrmat_add_blkcol_2(H_mat, &
776 S_mat, &
777 H_mat_data, &
778 S_mat_data, &
779 atomic_halo, &
780 trial_fns, &
781 particle_set, &
782 fermi_level, &
783 filter_temp, &
784 filter_mat_data, &
785 tolerance)
786 TYPE(dbcsr_type), POINTER :: h_mat, s_mat
787 TYPE(fb_matrix_data_obj), INTENT(IN) :: h_mat_data, s_mat_data
788 TYPE(fb_atomic_halo_obj), INTENT(IN) :: atomic_halo
789 TYPE(fb_trial_fns_obj), INTENT(IN) :: trial_fns
790 TYPE(particle_type), DIMENSION(:), POINTER :: particle_set
791 REAL(kind=dp), INTENT(IN) :: fermi_level, filter_temp
792 TYPE(fb_matrix_data_obj), INTENT(INOUT) :: filter_mat_data
793 REAL(kind=dp), INTENT(IN) :: tolerance
794
795 CHARACTER(LEN=*), PARAMETER :: routinen = 'fb_fltrmat_add_blkcol_2'
796
797 INTEGER :: handle, iatom_global, iatom_in_halo, itrial, jatom_global, jatom_in_halo, jkind, &
798 natoms_global, natoms_in_halo, ncols_atmatrix, ncols_blk, ncols_blk_max, nrows_atmatrix, &
799 nrows_blk, nrows_blk_max, stat
800 INTEGER, ALLOCATABLE, DIMENSION(:) :: atomic_h_blk_col_start, atomic_h_blk_row_start, &
801 atomic_s_blk_col_start, atomic_s_blk_row_start, col_block_size_data
802 INTEGER, DIMENSION(:), POINTER :: halo_atoms, ntfns, row_block_size_data
803 INTEGER, DIMENSION(:, :), POINTER :: tfns
804 LOGICAL :: check_ok
805 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: atomic_filter_mat, atomic_h, atomic_s, &
806 mat_blk
807 TYPE(atomic_kind_type), POINTER :: atomic_kind
808
809 CALL timeset(routinen, handle)
810
811 NULLIFY (atomic_kind, halo_atoms, ntfns, row_block_size_data, tfns)
812
813 check_ok = fb_matrix_data_has_data(h_mat_data)
814 cpassert(check_ok)
815 check_ok = fb_matrix_data_has_data(s_mat_data)
816 cpassert(check_ok)
817
818 ! obtain trial function information
819 CALL fb_trial_fns_get(trial_fns=trial_fns, &
820 nfunctions=ntfns, &
821 functions=tfns)
822
823 ! obtain row and col block size data for filter matrix
824 CALL dbcsr_get_info(h_mat, row_blk_size=row_block_size_data)
825 natoms_global = SIZE(particle_set)
826 ALLOCATE (col_block_size_data(natoms_global))
827 DO jatom_global = 1, natoms_global
828 atomic_kind => particle_set(jatom_global)%atomic_kind
829 CALL get_atomic_kind(atomic_kind=atomic_kind, kind_number=jkind)
830 col_block_size_data(jatom_global) = ntfns(jkind)
831 END DO
832
833 ! ----------------------------------------------------------------------
834 ! Construct atomic filter matrix for this atomic_halo
835 ! ----------------------------------------------------------------------
836
837 CALL fb_atomic_halo_get(atomic_halo=atomic_halo, &
838 natoms=natoms_in_halo, &
839 halo_atoms=halo_atoms)
840
841 ! construct atomic matrix for H for atomic_halo
842 ALLOCATE (atomic_h_blk_row_start(natoms_in_halo + 1), &
843 atomic_h_blk_col_start(natoms_in_halo + 1), &
844 stat=stat)
845 cpassert(stat == 0)
846 CALL fb_atmatrix_calc_size(h_mat, &
847 atomic_halo, &
848 nrows_atmatrix, &
849 ncols_atmatrix, &
850 atomic_h_blk_row_start, &
851 atomic_h_blk_col_start)
852 ALLOCATE (atomic_h(nrows_atmatrix, ncols_atmatrix))
853 CALL fb_atmatrix_construct_2(h_mat_data, &
854 atomic_halo, &
855 atomic_h, &
856 atomic_h_blk_row_start, &
857 atomic_h_blk_col_start)
858
859 ! construct atomic matrix for S for atomic_halo
860 ALLOCATE (atomic_s_blk_row_start(natoms_in_halo + 1), &
861 atomic_s_blk_col_start(natoms_in_halo + 1), &
862 stat=stat)
863 cpassert(stat == 0)
864 CALL fb_atmatrix_calc_size(s_mat, &
865 atomic_halo, &
866 nrows_atmatrix, &
867 ncols_atmatrix, &
868 atomic_s_blk_row_start, &
869 atomic_s_blk_col_start)
870 ALLOCATE (atomic_s(nrows_atmatrix, ncols_atmatrix))
871 CALL fb_atmatrix_construct_2(s_mat_data, &
872 atomic_halo, &
873 atomic_s, &
874 atomic_s_blk_row_start, &
875 atomic_s_blk_col_start)
876
877 ! construct the atomic filter matrix
878 ALLOCATE (atomic_filter_mat(nrows_atmatrix, ncols_atmatrix))
879 ! calculate atomic filter matrix only if it is non-zero sized
880 IF (nrows_atmatrix > 0 .AND. ncols_atmatrix > 0) THEN
881 CALL fb_fltrmat_build_atomic_fltrmat(atomic_h, &
882 atomic_s, &
883 fermi_level, &
884 filter_temp, &
885 atomic_filter_mat, &
886 tolerance)
887 END IF
888
889 ! ----------------------------------------------------------------------
890 ! Construct filter matrix block and add to filter_mat_data
891 ! ----------------------------------------------------------------------
892
893 CALL fb_atomic_halo_get(atomic_halo=atomic_halo, &
894 owner_atom=jatom_global, &
895 owner_id_in_halo=jatom_in_halo)
896 nrows_blk_max = maxval(row_block_size_data)
897 ncols_blk_max = maxval(ntfns)
898 ALLOCATE (mat_blk(nrows_blk_max, ncols_blk_max))
899 mat_blk(:, :) = 0.0_dp
900 DO iatom_in_halo = 1, natoms_in_halo
901 iatom_global = halo_atoms(iatom_in_halo)
902 atomic_kind => particle_set(jatom_global)%atomic_kind
903 CALL get_atomic_kind(atomic_kind=atomic_kind, &
904 kind_number=jkind)
905 nrows_blk = row_block_size_data(iatom_global)
906 ncols_blk = ntfns(jkind)
907
908 ! ALLOCATE(mat_blk(nrows_blk,ncols_blk) STAT=stat)
909 ! CPPostcondition(stat==0, cp_failure_level, routineP,failure)
910
911 ! do it column-wise one trial function at a time
912 DO itrial = 1, ntfns(jkind)
913 CALL dgemv("N", &
914 nrows_blk, &
915 ncols_atmatrix, &
916 1.0_dp, &
917 atomic_filter_mat( &
918 atomic_h_blk_row_start(iatom_in_halo): &
919 atomic_h_blk_row_start(iatom_in_halo + 1) - 1, &
920 1:ncols_atmatrix &
921 ), &
922 nrows_blk, &
923 atomic_s( &
924 1:nrows_atmatrix, &
925 atomic_s_blk_col_start(jatom_in_halo) + &
926 tfns(itrial, jkind) - 1 &
927 ), &
928 1, &
929 0.0_dp, &
930 mat_blk( &
931 1:nrows_blk, &
932 itrial), &
933 1)
934 END DO ! itrial
935 CALL fb_matrix_data_add(filter_mat_data, &
936 iatom_global, &
937 jatom_global, &
938 mat_blk(1:nrows_blk, 1:ncols_blk))
939 ! DEALLOCATE(mat_blk, STAT=stat)
940 ! CPPostcondition(stat==0, cp_failure_level, routineP,failure)
941 END DO ! iatom_in_halo
942 DEALLOCATE (mat_blk)
943
944 ! clean up
945 DEALLOCATE (atomic_h)
946 DEALLOCATE (atomic_h_blk_row_start)
947 DEALLOCATE (atomic_s)
948 DEALLOCATE (atomic_s_blk_row_start)
949 DEALLOCATE (atomic_filter_mat)
950
951 CALL timestop(handle)
952
953 END SUBROUTINE fb_fltrmat_add_blkcol_2
954
955! **************************************************************************************************
956!> \brief generate the list of blocks (atom pairs) to be sent and received
957!> in order to construct the filter matrix for each atomic halo.
958!> This version is for use with fb_fltrmat_build, where MPI
959!> communications are done at each step
960!> \param filter_mat : DBCSR formatted filter matrix
961!> \param atomic_halo : the halo that contributes to a blk
962!> col of the filter matrix
963!> \param para_env : cp2k parallel environment
964!> \param atom_pairs_send : list of blocks to be sent
965!> \param atom_pairs_recv : list of blocks to be received
966!> \author Lianheng Tong (LT) lianheng.tong@kcl.ac.uk
967! **************************************************************************************************
968 SUBROUTINE fb_fltrmat_generate_com_pairs(filter_mat, &
969 atomic_halo, &
970 para_env, &
971 atom_pairs_send, &
972 atom_pairs_recv)
973 TYPE(dbcsr_type), POINTER :: filter_mat
974 TYPE(fb_atomic_halo_obj), INTENT(IN) :: atomic_halo
975 TYPE(mp_para_env_type), POINTER :: para_env
976 TYPE(fb_com_atom_pairs_obj), INTENT(INOUT) :: atom_pairs_send, atom_pairs_recv
977
978 CHARACTER(LEN=*), PARAMETER :: routinen = 'fb_fltrmat_generate_com_pairs'
979
980 INTEGER :: dest, handle, iatom_global, &
981 iatom_in_halo, itask, jatom_global, &
982 natoms_in_halo, nblkrows_total, &
983 ntasks_send
984 INTEGER(KIND=int_8), DIMENSION(:, :), POINTER :: tasks_send
985 INTEGER, DIMENSION(:), POINTER :: halo_atoms
986 TYPE(fb_com_tasks_obj) :: com_tasks_recv, com_tasks_send
987
988 CALL timeset(routinen, handle)
989
990 NULLIFY (tasks_send)
991 CALL fb_com_tasks_nullify(com_tasks_send)
992 CALL fb_com_tasks_nullify(com_tasks_recv)
993
994 ! initialise atom_pairs_send and atom_pairs_recv
995 IF (fb_com_atom_pairs_has_data(atom_pairs_send)) THEN
996 CALL fb_com_atom_pairs_init(atom_pairs_send)
997 ELSE
998 CALL fb_com_atom_pairs_create(atom_pairs_send)
999 END IF
1000 IF (fb_com_atom_pairs_has_data(atom_pairs_recv)) THEN
1001 CALL fb_com_atom_pairs_init(atom_pairs_recv)
1002 ELSE
1003 CALL fb_com_atom_pairs_create(atom_pairs_recv)
1004 END IF
1005
1006 ! The total number of filter matrix blocks each processor is going
1007 ! to construct equals to the total number of halo atoms in all of
1008 ! the atomic halos local to the processor. The number of send
1009 ! tasks will not exceed this. We do one halo (col) at a time, and
1010 ! each call of this subroutine will only work on one filter matrix
1011 ! col corresponding to atomic_halo.
1012
1013 ! The col atom block index for each filter matrix block are the
1014 ! owner atom of each halo. The row atom block index for each
1015 ! filter matrix block corresponding to each col are the halo atoms
1016 ! of the corresponding halos. Filter matrix is non-symmetric: it
1017 ! is non-square, because the blocks themselves are non-square
1018
1019 CALL fb_atomic_halo_get(atomic_halo=atomic_halo, &
1020 owner_atom=jatom_global, &
1021 natoms=natoms_in_halo, &
1022 halo_atoms=halo_atoms)
1023 ntasks_send = natoms_in_halo
1024
1025 ! allocate send tasks
1026 ALLOCATE (tasks_send(task_n_records, ntasks_send))
1027
1028 ! Get the total number of atoms, this can be obtained from the
1029 ! total number of block rows in the DBCSR filter matrix. We
1030 ! assumes that before calling this subroutine, the filter_mat has
1031 ! already been created and initialised: i.e. using
1032 ! dbcsr_create_new. Even if the matrix is at the moment empty,
1033 ! the attribute nblkrows_total is already assigned from the dbcsr
1034 ! distribution data
1035 CALL dbcsr_get_info(filter_mat, &
1036 nblkrows_total=nblkrows_total)
1037
1038 ! source is always the local processor
1039 associate(src => para_env%mepos)
1040 ! construct send tasks
1041 itask = 1
1042 DO iatom_in_halo = 1, natoms_in_halo
1043 iatom_global = halo_atoms(iatom_in_halo)
1044 ! find where the constructed block of filter matrix belongs to
1045 CALL dbcsr_get_stored_coordinates(filter_mat, &
1046 iatom_global, &
1047 jatom_global, &
1048 processor=dest)
1049 ! create the send tasks
1050 tasks_send(task_dest, itask) = dest
1051 tasks_send(task_src, itask) = src
1052 CALL fb_com_tasks_encode_pair(tasks_send(task_pair, itask), &
1053 iatom_global, jatom_global, &
1054 nblkrows_total)
1055 ! calculation of cost not implemented at the moment
1056 tasks_send(task_cost, itask) = 0
1057 itask = itask + 1
1058 END DO ! iatom_in_halo
1059 END associate
1060
1061 CALL fb_com_tasks_create(com_tasks_recv)
1062 CALL fb_com_tasks_create(com_tasks_send)
1063
1064 CALL fb_com_tasks_set(com_tasks=com_tasks_send, &
1065 task_dim=task_n_records, &
1066 ntasks=ntasks_send, &
1067 nencode=nblkrows_total, &
1068 tasks=tasks_send)
1069
1070 ! generate the recv task list (tasks_recv) from the send task list
1071 CALL fb_com_tasks_transpose_dest_src(com_tasks_recv, "<", com_tasks_send, &
1072 para_env)
1073
1074 ! task lists are now complete, now construct the atom_pairs_send
1075 ! and atom_pairs_recv from the tasks lists
1076 CALL fb_com_tasks_build_atom_pairs(com_tasks=com_tasks_send, &
1077 atom_pairs=atom_pairs_send, &
1078 natoms_encode=nblkrows_total, &
1079 send_or_recv="send")
1080 CALL fb_com_tasks_build_atom_pairs(com_tasks=com_tasks_recv, &
1081 atom_pairs=atom_pairs_recv, &
1082 natoms_encode=nblkrows_total, &
1083 send_or_recv="recv")
1084
1085 ! cleanup
1086 CALL fb_com_tasks_release(com_tasks_recv)
1087 CALL fb_com_tasks_release(com_tasks_send)
1088
1089 CALL timestop(handle)
1090
1091 END SUBROUTINE fb_fltrmat_generate_com_pairs
1092
1093! **************************************************************************************************
1094!> \brief generate the list of blocks (atom pairs) to be sent and received
1095!> in order to construct the filter matrix for each atomic halo.
1096!> This version is for use with fb_fltrmat_build_2, where MPI
1097!> communications are done collectively.
1098!> \param filter_mat : DBCSR formatted filter matrix
1099!> \param atomic_halos : set of all local atomic halos contributing to the
1100!> filter matrix
1101!> \param para_env : cp2k parallel environment
1102!> \param atom_pairs_send : list of blocks to be sent
1103!> \param atom_pairs_recv : list of blocks to be received
1104!> \author Lianheng Tong (LT) lianheng.tong@kcl.ac.uk
1105! **************************************************************************************************
1106 SUBROUTINE fb_fltrmat_generate_com_pairs_2(filter_mat, &
1107 atomic_halos, &
1108 para_env, &
1109 atom_pairs_send, &
1110 atom_pairs_recv)
1111 TYPE(dbcsr_type), POINTER :: filter_mat
1112 TYPE(fb_atomic_halo_list_obj), INTENT(IN) :: atomic_halos
1113 TYPE(mp_para_env_type), POINTER :: para_env
1114 TYPE(fb_com_atom_pairs_obj), INTENT(INOUT) :: atom_pairs_send, atom_pairs_recv
1115
1116 CHARACTER(LEN=*), PARAMETER :: routinen = 'fb_fltrmat_generate_com_pairs_2'
1117
1118 INTEGER :: dest, handle, iatom_global, iatom_in_halo, iatom_stored, ihalo, itask, &
1119 jatom_global, jatom_stored, natoms_in_halo, nblkrows_total, nhalos, ntasks_send
1120 INTEGER(KIND=int_8), DIMENSION(:, :), POINTER :: tasks_send
1121 INTEGER, DIMENSION(:), POINTER :: halo_atoms
1122 LOGICAL :: transpose
1123 TYPE(fb_atomic_halo_obj), DIMENSION(:), POINTER :: halos
1124 TYPE(fb_com_tasks_obj) :: com_tasks_recv, com_tasks_send
1125
1126 CALL timeset(routinen, handle)
1127
1128 NULLIFY (tasks_send)
1129 CALL fb_com_tasks_nullify(com_tasks_send)
1130 CALL fb_com_tasks_nullify(com_tasks_recv)
1131
1132 ! initialise atom_pairs_send and atom_pairs_recv
1133 IF (fb_com_atom_pairs_has_data(atom_pairs_send)) THEN
1134 CALL fb_com_atom_pairs_init(atom_pairs_send)
1135 ELSE
1136 CALL fb_com_atom_pairs_create(atom_pairs_send)
1137 END IF
1138 IF (fb_com_atom_pairs_has_data(atom_pairs_recv)) THEN
1139 CALL fb_com_atom_pairs_init(atom_pairs_recv)
1140 ELSE
1141 CALL fb_com_atom_pairs_create(atom_pairs_recv)
1142 END IF
1143
1144 ! The col atom block index for each filter matrix block are the
1145 ! owner atom of each halo. The row atom block index for each
1146 ! filter matrix block corresponding to each col are the halo atoms
1147 ! of the corresponding halos. Filter matrix is non-symmetric: it
1148 ! is non-square, because the blocks themselves are non-square
1149
1150 CALL fb_atomic_halo_list_get(atomic_halos=atomic_halos, &
1151 nhalos=nhalos, &
1152 halos=halos)
1153
1154 ! estimate the maximum number of blocks (i.e. atom paris) to send
1155 ntasks_send = 0
1156 DO ihalo = 1, nhalos
1157 CALL fb_atomic_halo_get(atomic_halo=halos(ihalo), &
1158 natoms=natoms_in_halo)
1159 ntasks_send = ntasks_send + natoms_in_halo
1160 END DO ! ihalo
1161
1162 ! allocate send tasks
1163 ALLOCATE (tasks_send(task_n_records, ntasks_send))
1164
1165 ! Get the total number of atoms. This can be obtained from the
1166 ! total number of block rows in the DBCSR filter matrix. We
1167 ! assumes that before calling this subroutine, the filter_mat has
1168 ! already been created and initialised: i.e. using
1169 ! dbcsr_create_new. Even if the matrix is at the moment empty,
1170 ! the attribute nblkrows_total is already assigned from the dbcsr
1171 ! distribution data
1172 CALL dbcsr_get_info(filter_mat, &
1173 nblkrows_total=nblkrows_total)
1174
1175 ! source is always the local processor
1176 associate(src => para_env%mepos)
1177 ! construct send tasks
1178 itask = 1
1179 DO ihalo = 1, nhalos
1180 CALL fb_atomic_halo_get(atomic_halo=halos(ihalo), &
1181 owner_atom=jatom_global, &
1182 natoms=natoms_in_halo, &
1183 halo_atoms=halo_atoms)
1184 DO iatom_in_halo = 1, natoms_in_halo
1185 iatom_global = halo_atoms(iatom_in_halo)
1186 iatom_stored = iatom_global
1187 jatom_stored = jatom_global
1188 transpose = .false.
1189 ! find where the constructed block of filter matrix belongs to
1190 CALL dbcsr_get_stored_coordinates(filter_mat, &
1191 iatom_stored, &
1192 jatom_stored, &
1193 processor=dest)
1194 ! create the send tasks
1195 tasks_send(task_dest, itask) = dest
1196 tasks_send(task_src, itask) = src
1197 CALL fb_com_tasks_encode_pair(tasks_send(task_pair, itask), &
1198 iatom_global, jatom_global, &
1199 nblkrows_total)
1200 ! calculation of cost not implemented at the moment
1201 tasks_send(task_cost, itask) = 0
1202 itask = itask + 1
1203 END DO ! iatom_in_halo
1204 END DO ! ihalo
1205 END associate
1206
1207 ! get the actual number of tasks
1208 ntasks_send = itask - 1
1209
1210 CALL fb_com_tasks_create(com_tasks_send)
1211 CALL fb_com_tasks_set(com_tasks=com_tasks_send, &
1212 task_dim=task_n_records, &
1213 ntasks=ntasks_send, &
1214 nencode=nblkrows_total, &
1215 tasks=tasks_send)
1216
1217 ! generate the recv task list (tasks_recv) from the send task list
1218 CALL fb_com_tasks_create(com_tasks_recv)
1219 CALL fb_com_tasks_transpose_dest_src(com_tasks_recv, "<", com_tasks_send, &
1220 para_env)
1221
1222 ! task lists are now complete, now construct the atom_pairs_send
1223 ! and atom_pairs_recv from the tasks lists
1224 CALL fb_com_tasks_build_atom_pairs(com_tasks=com_tasks_send, &
1225 atom_pairs=atom_pairs_send, &
1226 natoms_encode=nblkrows_total, &
1227 send_or_recv="send")
1228 CALL fb_com_tasks_build_atom_pairs(com_tasks=com_tasks_recv, &
1229 atom_pairs=atom_pairs_recv, &
1230 natoms_encode=nblkrows_total, &
1231 send_or_recv="recv")
1232
1233 ! cleanup
1234 CALL fb_com_tasks_release(com_tasks_recv)
1235 CALL fb_com_tasks_release(com_tasks_send)
1236
1237 CALL timestop(handle)
1238
1239 END SUBROUTINE fb_fltrmat_generate_com_pairs_2
1240
1241! **************************************************************************************************
1242!> \brief Build the atomic filter matrix for each atomic halo
1243!> \param atomic_H : atomic KS matrix
1244!> \param atomic_S : atomic overlap matrix
1245!> \param fermi_level : fermi level used to construct the Fermi-Dirac
1246!> filter function
1247!> \param filter_temp : temperature used to construct the Fermi-Dirac
1248!> filter function
1249!> \param atomic_filter_mat : the atomic filter matrix
1250!> \param tolerance : anything smaller than tolerance is treated as zero
1251!> \author Lianheng Tong (LT) lianheng.tong@kcl.ac.uk
1252! **************************************************************************************************
1253 SUBROUTINE fb_fltrmat_build_atomic_fltrmat(atomic_H, &
1254 atomic_S, &
1255 fermi_level, &
1256 filter_temp, &
1257 atomic_filter_mat, &
1258 tolerance)
1259 REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: atomic_h, atomic_s
1260 REAL(kind=dp), INTENT(IN) :: fermi_level, filter_temp
1261 REAL(kind=dp), DIMENSION(:, :), INTENT(OUT) :: atomic_filter_mat
1262 REAL(kind=dp), INTENT(IN) :: tolerance
1263
1264 CHARACTER(LEN=*), PARAMETER :: routinen = 'fb_fltrmat_build_atomic_fltrmat'
1265
1266 INTEGER :: handle, handle_dgemm, handle_dsygv, ii, &
1267 info, jj, mat_dim, work_array_size
1268 LOGICAL :: check_ok
1269 REAL(kind=dp), ALLOCATABLE, DIMENSION(:) :: eigenvalues, filter_function, work
1270 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: atomic_s_copy, eigenvectors, &
1271 filtered_eigenvectors
1272
1273 CALL timeset(routinen, handle)
1274
1275 ! This subroutine assumes atomic_filter_mat is not zero size, in
1276 ! other words, it really has to be constructed, instead of just
1277 ! being a dummy
1278
1279 check_ok = SIZE(atomic_filter_mat, 1) > 0 .AND. &
1280 SIZE(atomic_filter_mat, 2) > 0
1281 cpassert(check_ok)
1282
1283 ! initialise
1284 atomic_filter_mat = 0.0_dp
1285 mat_dim = SIZE(atomic_h, 1)
1286
1287 ! diagonalise using LAPACK
1288 ALLOCATE (eigenvalues(mat_dim))
1289 ! get optimal work array size
1290 ALLOCATE (work(1))
1291 ! dsygv will overwrite part of atomic_H and atomic_S, thus need to copy them
1292 ALLOCATE (atomic_s_copy(SIZE(atomic_s, 1), SIZE(atomic_s, 2)))
1293 atomic_s_copy(:, :) = atomic_s(:, :)
1294 ALLOCATE (eigenvectors(SIZE(atomic_h, 1), SIZE(atomic_h, 2)))
1295 eigenvectors(:, :) = atomic_h(:, :)
1296
1297 CALL timeset("fb_atomic_filter_dsygv", handle_dsygv)
1298
1299 info = 0
1300 CALL dsygv(1, &
1301 'V', &
1302 'U', &
1303 mat_dim, &
1304 eigenvectors, &
1305 mat_dim, &
1306 atomic_s_copy, &
1307 mat_dim, &
1308 eigenvalues, &
1309 work, &
1310 -1, &
1311 info)
1312 work_array_size = nint(work(1))
1313 ! now allocate work array
1314 DEALLOCATE (work)
1315 ALLOCATE (work(work_array_size))
1316 work = 0.0_dp
1317 ! do calculation
1318 atomic_s_copy(:, :) = atomic_s(:, :)
1319 eigenvectors(:, :) = atomic_h(:, :)
1320 info = 0
1321 CALL dsygv(1, &
1322 'V', &
1323 'U', &
1324 mat_dim, &
1325 eigenvectors, &
1326 mat_dim, &
1327 atomic_s_copy, &
1328 mat_dim, &
1329 eigenvalues, &
1330 work, &
1331 work_array_size, &
1332 info)
1333 ! check if diagonalisation is successful
1334 IF (info .NE. 0) THEN
1335 WRITE (*, *) "DSYGV ERROR MESSAGE: ", info
1336 cpabort("DSYGV failed")
1337 END IF
1338
1339 CALL timestop(handle_dsygv)
1340
1341 DEALLOCATE (work)
1342 DEALLOCATE (atomic_s_copy)
1343
1344 ! first get the filter function
1345 ALLOCATE (filter_function(mat_dim))
1346 filter_function = 0.0_dp
1347 CALL fb_fltrmat_fermi_dirac_mu(filter_function, &
1348 eigenvalues, &
1349 filter_temp, &
1350 fermi_level)
1351 DEALLOCATE (eigenvalues)
1352
1353 ! atomic_H has the eigenvectors, construct the version of it
1354 ! filtered through the filter function
1355 ALLOCATE (filtered_eigenvectors(mat_dim, mat_dim))
1356 DO jj = 1, mat_dim
1357 DO ii = 1, mat_dim
1358 filtered_eigenvectors(ii, jj) = &
1359 filter_function(jj)*eigenvectors(ii, jj)
1360 END DO ! ii
1361 END DO ! jj
1362
1363 DEALLOCATE (filter_function)
1364
1365 CALL timeset("fb_atomic_filter_dgemm", handle_dgemm)
1366
1367 ! construct atomic filter matrix
1368 CALL dgemm("N", &
1369 "T", &
1370 mat_dim, &
1371 mat_dim, &
1372 mat_dim, &
1373 1.0_dp, &
1374 filtered_eigenvectors, &
1375 mat_dim, &
1376 eigenvectors, &
1377 mat_dim, &
1378 0.0_dp, &
1379 atomic_filter_mat, &
1380 mat_dim)
1381
1382 CALL timestop(handle_dgemm)
1383
1384 ! remove small negative terms due to numerical error, the filter
1385 ! matrix must not be negative definite
1386 DO jj = 1, SIZE(atomic_filter_mat, 2)
1387 DO ii = 1, SIZE(atomic_filter_mat, 1)
1388 IF (abs(atomic_filter_mat(ii, jj)) < tolerance) THEN
1389 atomic_filter_mat(ii, jj) = 0.0_dp
1390 END IF
1391 END DO
1392 END DO
1393
1394 DEALLOCATE (filtered_eigenvectors)
1395 DEALLOCATE (eigenvectors)
1396
1397 CALL timestop(handle)
1398
1399 END SUBROUTINE fb_fltrmat_build_atomic_fltrmat
1400
1401! **************************************************************************************************
1402!> \brief get values of Fermi-Dirac distribution based on a given fermi
1403!> level at a given set of energy eigenvalues
1404!> \param f : the Fermi-Dirac distribution function values
1405!> \param eigenvals : set of energy eigenvalues
1406!> \param T : temperature
1407!> \param mu : the fermi level
1408!> \author Lianheng Tong (LT) lianheng.tong@kcl.ac.uk
1409! **************************************************************************************************
1410 SUBROUTINE fb_fltrmat_fermi_dirac_mu(f, eigenvals, T, mu)
1411 REAL(kind=dp), DIMENSION(:), INTENT(OUT) :: f
1412 REAL(kind=dp), DIMENSION(:), INTENT(IN) :: eigenvals
1413 REAL(kind=dp), INTENT(IN) :: t, mu
1414
1415 REAL(kind=dp) :: kts, ne
1416
1417! we want fermi function max at 1, so maxocc = 1 here
1418
1419 CALL fermi(f, ne, kts, eigenvals, mu, t, 1.0_dp)
1420 END SUBROUTINE fb_fltrmat_fermi_dirac_mu
1421
1422! **************************************************************************************************
1423!> \brief get values of Fermi-Dirac distribution based on a given electron
1424!> number at a given set of energy eigenvales
1425!> \param f : the Fermi-Dirac distribution function values
1426!> \param eigenvals : set of energy eigenvalues
1427!> \param T : temperature
1428!> \param ne : number of electrons
1429!> \param maxocc : maximum occupancy per orbital
1430!> \author Lianheng Tong (LT) lianheng.tong@kcl.ac.uk
1431! **************************************************************************************************
1432 SUBROUTINE fb_fltrmat_fermi_dirac_ne(f, eigenvals, T, ne, maxocc)
1433 REAL(kind=dp), DIMENSION(:), INTENT(OUT) :: f
1434 REAL(kind=dp), DIMENSION(:), INTENT(IN) :: eigenvals
1435 REAL(kind=dp), INTENT(IN) :: t, ne, maxocc
1436
1437 REAL(kind=dp) :: kts, mu
1438
1439! mu is the calculated fermi level
1440! kTS is the calculated entropic contribution to the energy i.e. -TS
1441! kTS = kT*[f ln f + (1-f) ln (1-f)]
1442
1443 CALL fermifixed(f, mu, kts, eigenvals, ne, t, maxocc)
1444 END SUBROUTINE fb_fltrmat_fermi_dirac_ne
1445
1446END MODULE qs_fb_filter_matrix_methods
dgemm
static void dgemm(const char transa, const char transb, const int m, const int n, const int k, const double alpha, const double *a, const int lda, const double *b, const int ldb, const double beta, double *c, const int ldc)
Convenient wrapper to hide Fortran nature of dgemm_, swapping a and b.
Definition grid_cpu_task_list.c:195
atomic_kind_types
Define the atomic kind types and their sub types.
Definition atomic_kind_types.F:23
atomic_kind_types::get_atomic_kind
subroutine, public get_atomic_kind(atomic_kind, fist_potential, element_symbol, name, mass, kind_number, natom, atom_list, rcov, rvdw, z, qeff, apol, cpol, mm_radius, shell, shell_active, damping)
Get attributes of an atomic kind.
Definition atomic_kind_types.F:138
fermi_utils
deal with the Fermi distribution, compute it, fix mu, get derivs
Definition fermi_utils.F:13
fermi_utils::fermifixed
subroutine, public fermifixed(f, mu, kts, e, n, t, maxocc, estate, festate)
returns occupations according to Fermi-Dirac statistics for a given set of energies and number of ele...
Definition fermi_utils.F:202
fermi_utils::fermi
subroutine, public fermi(f, n, kts, e, mu, t, maxocc, estate, festate)
returns occupations according to Fermi-Dirac statistics for a given set of energies and fermi level....
Definition fermi_utils.F:48
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
kinds::default_string_length
integer, parameter, public default_string_length
Definition kinds.F:57
message_passing
Interface to the message passing library MPI.
Definition message_passing.F:23
particle_types
Define the data structure for the particle information.
Definition particle_types.F:19
qs_fb_atomic_halo_types
Definition qs_fb_atomic_halo_types.F:8
qs_fb_atomic_halo_types::fb_atomic_halo_list_get
subroutine, public fb_atomic_halo_list_get(atomic_halos, nhalos, max_nhalos, halos)
Gets attributes from an fb_atomic_halo_list object, one should only access the data content in a fb_a...
Definition qs_fb_atomic_halo_types.F:632
qs_fb_atomic_halo_types::fb_atomic_halo_get
subroutine, public fb_atomic_halo_get(atomic_halo, owner_atom, owner_id_in_halo, natoms, nelectrons, halo_atoms, sorted, cost)
Gets attributes from a fb_atomic_halo object, one should only access the data content in a fb_atomic_...
Definition qs_fb_atomic_halo_types.F:253
qs_fb_atomic_halo_types::fb_atomic_halo_set
subroutine, public fb_atomic_halo_set(atomic_halo, owner_atom, owner_id_in_halo, natoms, nelectrons, halo_atoms, sorted, cost)
Sets attributes in a fb_atomic_halo object, one should only set the data content in a fb_atomic_halo ...
Definition qs_fb_atomic_halo_types.F:296
qs_fb_atomic_halo_types::fb_atomic_halo_create
subroutine, public fb_atomic_halo_create(atomic_halo)
Creates and initialises an empty fb_atomic_halo object.
Definition qs_fb_atomic_halo_types.F:194
qs_fb_atomic_halo_types::fb_atomic_halo_nullify
subroutine, public fb_atomic_halo_nullify(atomic_halo)
Nullifies a fb_atomic_halo object, note that it does not release the original object....
Definition qs_fb_atomic_halo_types.F:155
qs_fb_atomic_halo_types::fb_atomic_halo_release
subroutine, public fb_atomic_halo_release(atomic_halo)
Releases an fb_atomic_halo object.
Definition qs_fb_atomic_halo_types.F:130
qs_fb_atomic_matrix_methods
Definition qs_fb_atomic_matrix_methods.F:8
qs_fb_atomic_matrix_methods::fb_atmatrix_calc_size
subroutine, public fb_atmatrix_calc_size(dbcsr_mat, atomic_halo, nrows, ncols, blk_row_start, blk_col_start)
Calculates the atomic matrix size from a given DBCSR matrix and atomic halo. It also calculates the f...
Definition qs_fb_atomic_matrix_methods.F:71
qs_fb_atomic_matrix_methods::fb_atmatrix_generate_com_pairs_2
subroutine, public fb_atmatrix_generate_com_pairs_2(dbcsr_mat, atomic_halos, para_env, atom_pairs_send, atom_pairs_recv)
generate list of blocks (atom pairs) of a DBCSR matrix to be sent and received in order to construct ...
Definition qs_fb_atomic_matrix_methods.F:626
qs_fb_atomic_matrix_methods::fb_atmatrix_construct_2
subroutine, public fb_atmatrix_construct_2(matrix_storage, atomic_halo, atomic_matrix, blk_row_start, blk_col_start)
Constructs atomic matrix for filter basis method from a given DBCSR matrix and a set of atomic send a...
Definition qs_fb_atomic_matrix_methods.F:341
qs_fb_atomic_matrix_methods::fb_atmatrix_construct
subroutine, public fb_atmatrix_construct(dbcsr_mat, atomic_halo, para_env, atomic_matrix, blk_row_start, blk_col_start)
Constructs atomic matrix for filter basis method from a given DBCSR matrix and a set of atomic send a...
Definition qs_fb_atomic_matrix_methods.F:131
qs_fb_com_tasks_types
Definition qs_fb_com_tasks_types.F:8
qs_fb_com_tasks_types::fb_com_atom_pairs_init
subroutine, public fb_com_atom_pairs_init(atom_pairs)
Initialises an fb_com_atom_pairs object, and makes it empty.
Definition qs_fb_com_tasks_types.F:324
qs_fb_com_tasks_types::task_pair
integer, parameter, public task_pair
Definition qs_fb_com_tasks_types.F:77
qs_fb_com_tasks_types::fb_com_atom_pairs_decode
subroutine, public fb_com_atom_pairs_decode(ind, pe, iatom, jatom, natoms)
Decodes a single integer into the (rank, iatom, jatom) index of a communication task to send/receive ...
Definition qs_fb_com_tasks_types.F:805
qs_fb_com_tasks_types::task_src
integer, parameter, public task_src
Definition qs_fb_com_tasks_types.F:77
qs_fb_com_tasks_types::fb_com_tasks_nullify
subroutine, public fb_com_tasks_nullify(com_tasks)
Nullifies a fb_com_tasks object, note that it does not release the original object....
Definition qs_fb_com_tasks_types.F:193
qs_fb_com_tasks_types::fb_com_tasks_encode_pair
subroutine, public fb_com_tasks_encode_pair(ind, iatom, jatom, natoms)
Encodes (iatom, jatom) pair index of a block into a single integer.
Definition qs_fb_com_tasks_types.F:733
qs_fb_com_tasks_types::fb_com_atom_pairs_distribute_blks
subroutine, public fb_com_atom_pairs_distribute_blks(matrix_storage, atom_pairs_send, atom_pairs_recv, para_env, dbcsr_mat)
Given send and recv fb_com_atom_pair object, distribute the matrix blocks stored in a fb_matrix_data ...
Definition qs_fb_com_tasks_types.F:1111
qs_fb_com_tasks_types::fb_com_tasks_build_atom_pairs
subroutine, public fb_com_tasks_build_atom_pairs(com_tasks, atom_pairs, natoms_encode, send_or_recv)
Generate send or receive atom_pair lists from a com_tasks object. atom_pair list is used as a condens...
Definition qs_fb_com_tasks_types.F:641
qs_fb_com_tasks_types::fb_com_atom_pairs_create
subroutine, public fb_com_atom_pairs_create(atom_pairs)
Creates and initialises an empty fb_com_atom_pairs object.
Definition qs_fb_com_tasks_types.F:290
qs_fb_com_tasks_types::fb_com_tasks_transpose_dest_src
subroutine, public fb_com_tasks_transpose_dest_src(tasks_dest_is_me, direction, tasks_src_is_me, para_env)
Start from a local set of tasks that has desc/src process equal to the local MPI rank,...
Definition qs_fb_com_tasks_types.F:474
qs_fb_com_tasks_types::fb_com_atom_pairs_has_data
logical function, public fb_com_atom_pairs_has_data(atom_pairs)
Checks if a fb_com_atom_pairs object is associated with an actual data content or not.
Definition qs_fb_com_tasks_types.F:260
qs_fb_com_tasks_types::fb_com_atom_pairs_get
subroutine, public fb_com_atom_pairs_get(atom_pairs, npairs, natoms_encode, pairs)
Gets attributes from a fb_com_atom_pairs object, one should only access the data content in a fb_com_...
Definition qs_fb_com_tasks_types.F:378
qs_fb_com_tasks_types::fb_com_atom_pairs_nullify
subroutine, public fb_com_atom_pairs_nullify(atom_pairs)
Nullifies a fb_com_atom_pairs object, note that it does not release the original object....
Definition qs_fb_com_tasks_types.F:207
qs_fb_com_tasks_types::fb_com_atom_pairs_release
subroutine, public fb_com_atom_pairs_release(atom_pairs)
Releases an fb_com_atom_pairs object.
Definition qs_fb_com_tasks_types.F:172
qs_fb_com_tasks_types::fb_com_tasks_create
subroutine, public fb_com_tasks_create(com_tasks)
Creates and initialises an empty fb_com_tasks object.
Definition qs_fb_com_tasks_types.F:273
qs_fb_com_tasks_types::task_cost
integer, parameter, public task_cost
Definition qs_fb_com_tasks_types.F:77
qs_fb_com_tasks_types::fb_com_tasks_release
subroutine, public fb_com_tasks_release(com_tasks)
Releases an fb_com_tasks object.
Definition qs_fb_com_tasks_types.F:152
qs_fb_com_tasks_types::fb_com_atom_pairs_gather_blks
subroutine, public fb_com_atom_pairs_gather_blks(dbcsr_mat, atom_pairs_send, atom_pairs_recv, para_env, matrix_storage)
Given send and recv fb_com_atom_pair object, gather all the relevant DBCSR matrix blocks together,...
Definition qs_fb_com_tasks_types.F:926
qs_fb_com_tasks_types::fb_com_tasks_set
subroutine, public fb_com_tasks_set(com_tasks, task_dim, ntasks, nencode, tasks)
Sets attributes in a fb_com_tasks object, one should only access the data content in a fb_com_tasks o...
Definition qs_fb_com_tasks_types.F:406
qs_fb_com_tasks_types::task_dest
integer, parameter, public task_dest
Definition qs_fb_com_tasks_types.F:77
qs_fb_com_tasks_types::task_n_records
integer, parameter, public task_n_records
Definition qs_fb_com_tasks_types.F:75
qs_fb_com_tasks_types::fb_com_atom_pairs_calc_buffer_sizes
subroutine, public fb_com_atom_pairs_calc_buffer_sizes(atom_pairs, nprocs, row_blk_sizes, col_blk_sizes, sendrecv_sizes, sendrecv_disps, sendrecv_pair_counts, sendrecv_pair_disps)
Calculate the MPI send or recv buffer sizes according to the communication pairs (atom_pairs) and DBC...
Definition qs_fb_com_tasks_types.F:855
qs_fb_filter_matrix_methods
Definition qs_fb_filter_matrix_methods.F:8
qs_fb_filter_matrix_methods::fb_fltrmat_build_2
subroutine, public fb_fltrmat_build_2(h_mat, s_mat, atomic_halos, trial_fns, para_env, particle_set, fermi_level, filter_temp, name, filter_mat, tolerance)
Build the filter matrix, with MPI communications grouped together. More effcient on communication,...
Definition qs_fb_filter_matrix_methods.F:264
qs_fb_filter_matrix_methods::fb_fltrmat_build
subroutine, public fb_fltrmat_build(h_mat, s_mat, atomic_halos, trial_fns, para_env, particle_set, fermi_level, filter_temp, name, filter_mat, tolerance)
Build the filter matrix, with MPI communications happening at each step. Less efficient on communicat...
Definition qs_fb_filter_matrix_methods.F:104
qs_fb_matrix_data_types
Definition qs_fb_matrix_data_types.F:8
qs_fb_matrix_data_types::fb_matrix_data_has_data
pure logical function, public fb_matrix_data_has_data(matrix_data)
check if the object has data associated to it
Definition qs_fb_matrix_data_types.F:211
qs_fb_matrix_data_types::fb_matrix_data_add
subroutine, public fb_matrix_data_add(matrix_data, row, col, blk)
Add a matrix block to a fb_matrix_data object.
Definition qs_fb_matrix_data_types.F:92
qs_fb_matrix_data_types::fb_matrix_data_create
subroutine, public fb_matrix_data_create(matrix_data, nmax, nencode)
Creates and initialises an empty fb_matrix_data object of a given size.
Definition qs_fb_matrix_data_types.F:153
qs_fb_matrix_data_types::fb_matrix_data_nullify
pure subroutine, public fb_matrix_data_nullify(matrix_data)
Nullifies a fb_matrix_data object.
Definition qs_fb_matrix_data_types.F:261
qs_fb_matrix_data_types::fb_matrix_data_release
subroutine, public fb_matrix_data_release(matrix_data)
releases given object
Definition qs_fb_matrix_data_types.F:272
qs_fb_trial_fns_types
Definition qs_fb_trial_fns_types.F:8
qs_fb_trial_fns_types::fb_trial_fns_get
subroutine, public fb_trial_fns_get(trial_fns, nfunctions, functions)
get values of the attributes of a fb_trial_fns object
Definition qs_fb_trial_fns_types.F:185
string_utilities
Utilities for string manipulations.
Definition string_utilities.F:16
string_utilities::compress
subroutine, public compress(string, full)
Eliminate multiple space characters in a string. If full is .TRUE., then all spaces are eliminated.
Definition string_utilities.F:3190
string_utilities::uppercase
elemental subroutine, public uppercase(string)
Convert all lower case characters in a string to upper case.
Definition string_utilities.F:3361
atomic_kind_types::atomic_kind_type
Provides all information about an atomic kind.
Definition atomic_kind_types.F:45
message_passing::mp_para_env_type
stores all the informations relevant to an mpi environment
Definition message_passing.F:763
particle_types::particle_type
Definition particle_types.F:35
qs_fb_atomic_halo_types::fb_atomic_halo_list_obj
defines a fb_atomic_halo_list object
Definition qs_fb_atomic_halo_types.F:116
qs_fb_atomic_halo_types::fb_atomic_halo_obj
defines a fb_atomic_halo object
Definition qs_fb_atomic_halo_types.F:94
qs_fb_com_tasks_types::fb_com_atom_pairs_obj
defines a fb_com_atom_pairs object
Definition qs_fb_com_tasks_types.F:138
qs_fb_com_tasks_types::fb_com_tasks_obj
defines a fb_com_tasks object
Definition qs_fb_com_tasks_types.F:109
qs_fb_matrix_data_types::fb_matrix_data_obj
the object container which allows for the creation of an array of pointers to fb_matrix_data objects
Definition qs_fb_matrix_data_types.F:77
qs_fb_trial_fns_types::fb_trial_fns_obj
the object container which allows for the creation of an array of pointers to fb_trial_fns objects
Definition qs_fb_trial_fns_types.F:54