(git:ec04593)
Loading...
Searching...
No Matches
cp_dbcsr_api.F
Go to the documentation of this file.
1!--------------------------------------------------------------------------------------------------!
2! CP2K: A general program to perform molecular dynamics simulations !
3! Copyright 2000-2026 CP2K developers group <https://cp2k.org> !
4! !
5! SPDX-License-Identifier: GPL-2.0-or-later !
6!--------------------------------------------------------------------------------------------------!
7
9 USE dbcsr_api, ONLY: &
10 convert_csr_to_dbcsr_prv => dbcsr_convert_csr_to_dbcsr, &
11 convert_dbcsr_to_csr_prv => dbcsr_convert_dbcsr_to_csr, dbcsr_add_prv => dbcsr_add, &
12 dbcsr_binary_read_prv => dbcsr_binary_read, dbcsr_binary_write_prv => dbcsr_binary_write, &
13 dbcsr_clear_mempools, dbcsr_clear_prv => dbcsr_clear, &
14 dbcsr_complete_redistribute_prv => dbcsr_complete_redistribute, &
15 dbcsr_convert_offsets_to_sizes, dbcsr_convert_sizes_to_offsets, &
16 dbcsr_copy_prv => dbcsr_copy, dbcsr_create_prv => dbcsr_create, dbcsr_csr_create, &
17 dbcsr_csr_create_from_dbcsr_prv => dbcsr_csr_create_from_dbcsr, &
18 dbcsr_csr_dbcsr_blkrow_dist, dbcsr_csr_destroy, dbcsr_csr_eqrow_floor_dist, &
19 dbcsr_csr_p_type, dbcsr_csr_print_sparsity, dbcsr_csr_type, &
20 dbcsr_csr_type_real_8 => dbcsr_type_real_8, dbcsr_csr_write, &
21 dbcsr_desymmetrize_prv => dbcsr_desymmetrize, dbcsr_distribute_prv => dbcsr_distribute, &
22 dbcsr_distribution_get_num_images, dbcsr_distribution_get_prv => dbcsr_distribution_get, &
23 dbcsr_distribution_hold_prv => dbcsr_distribution_hold, &
24 dbcsr_distribution_new_prv => dbcsr_distribution_new, &
25 dbcsr_distribution_release_prv => dbcsr_distribution_release, &
26 dbcsr_distribution_type_prv => dbcsr_distribution_type, dbcsr_dot_prv => dbcsr_dot, &
27 dbcsr_filter_prv => dbcsr_filter, dbcsr_finalize_lib, &
28 dbcsr_finalize_prv => dbcsr_finalize, dbcsr_get_block_p_prv => dbcsr_get_block_p, &
29 dbcsr_get_data_p_prv => dbcsr_get_data_p, dbcsr_get_data_size_prv => dbcsr_get_data_size, &
30 dbcsr_get_default_config, dbcsr_get_info_prv => dbcsr_get_info, &
31 dbcsr_get_matrix_type_prv => dbcsr_get_matrix_type, &
32 dbcsr_get_num_blocks_prv => dbcsr_get_num_blocks, &
33 dbcsr_get_occupation_prv => dbcsr_get_occupation, &
34 dbcsr_get_stored_coordinates_prv => dbcsr_get_stored_coordinates, &
35 dbcsr_has_symmetry_prv => dbcsr_has_symmetry, dbcsr_init_lib, &
36 dbcsr_iterator_blocks_left_prv => dbcsr_iterator_blocks_left, &
37 dbcsr_iterator_next_block_prv => dbcsr_iterator_next_block, &
38 dbcsr_iterator_start_prv => dbcsr_iterator_start, &
39 dbcsr_iterator_stop_prv => dbcsr_iterator_stop, &
40 dbcsr_iterator_type_prv => dbcsr_iterator_type, &
41 dbcsr_mp_grid_setup_prv => dbcsr_mp_grid_setup, dbcsr_multiply_prv => dbcsr_multiply, &
42 dbcsr_no_transpose, dbcsr_print_config, dbcsr_print_statistics, &
43 dbcsr_put_block_prv => dbcsr_put_block, dbcsr_release_prv => dbcsr_release, &
44 dbcsr_replicate_all_prv => dbcsr_replicate_all, &
45 dbcsr_reserve_blocks_prv => dbcsr_reserve_blocks, dbcsr_reset_randmat_seed, &
46 dbcsr_run_tests, dbcsr_scale_prv => dbcsr_scale, dbcsr_set_config, &
47 dbcsr_set_prv => dbcsr_set, dbcsr_sum_replicated_prv => dbcsr_sum_replicated, &
48 dbcsr_test_mm, dbcsr_transpose, dbcsr_transposed_prv => dbcsr_transposed, &
49 dbcsr_type_antisymmetric, dbcsr_type_complex_8, dbcsr_type_no_symmetry, &
50 dbcsr_type_prv => dbcsr_type, dbcsr_type_real_8, dbcsr_type_symmetric, &
51 dbcsr_valid_index_prv => dbcsr_valid_index, &
52 dbcsr_verify_matrix_prv => dbcsr_verify_matrix, dbcsr_work_create_prv => dbcsr_work_create
53 USE dbm_api, ONLY: &
56 USE kinds, ONLY: dp,&
57 int_8
58 USE mathconstants, ONLY: gaussi,&
59 z_one
61#include "../base/base_uses.f90"
62
63 IMPLICIT NONE
64 PRIVATE
65
66 ! constants
67 PUBLIC :: dbcsr_type_no_symmetry
68 PUBLIC :: dbcsr_type_symmetric
69 PUBLIC :: dbcsr_type_antisymmetric
70 PUBLIC :: dbcsr_transpose
71 PUBLIC :: dbcsr_no_transpose
72
73 ! types
74 PUBLIC :: dbcsr_type
75 PUBLIC :: dbcsr_p_type
77 PUBLIC :: dbcsr_iterator_type
78
79 ! lib init/finalize
80 PUBLIC :: dbcsr_clear_mempools
81 PUBLIC :: dbcsr_init_lib
82 PUBLIC :: dbcsr_finalize_lib
83 PUBLIC :: dbcsr_set_config
84 PUBLIC :: dbcsr_get_default_config
85 PUBLIC :: dbcsr_print_config
86 PUBLIC :: dbcsr_reset_randmat_seed
87 PUBLIC :: dbcsr_mp_grid_setup
88 PUBLIC :: dbcsr_print_statistics
89
90 ! create / release
94 PUBLIC :: dbcsr_create
95 PUBLIC :: dbcsr_init_p
96 PUBLIC :: dbcsr_release
97 PUBLIC :: dbcsr_release_p
99
100 ! primitive matrix operations
101 PUBLIC :: dbcsr_set
102 PUBLIC :: dbcsr_add
103 PUBLIC :: dbcsr_scale
104 PUBLIC :: dbcsr_transposed
105 PUBLIC :: dbcsr_multiply
106 PUBLIC :: dbcsr_copy
107 PUBLIC :: dbcsr_desymmetrize
108 PUBLIC :: dbcsr_filter
110 PUBLIC :: dbcsr_reserve_blocks
111 PUBLIC :: dbcsr_put_block
112 PUBLIC :: dbcsr_get_block_p
114 PUBLIC :: dbcsr_clear
115
116 ! iterator
117 PUBLIC :: dbcsr_iterator_start
119 PUBLIC :: dbcsr_iterator_stop
122
123 ! getters
124 PUBLIC :: dbcsr_get_info
125 PUBLIC :: dbcsr_distribution_get
126 PUBLIC :: dbcsr_get_matrix_type
127 PUBLIC :: dbcsr_get_occupation
128 PUBLIC :: dbcsr_get_num_blocks
129 PUBLIC :: dbcsr_get_data_size
130 PUBLIC :: dbcsr_has_symmetry
132 PUBLIC :: dbcsr_valid_index
133
134 ! work operations
135 PUBLIC :: dbcsr_work_create
136 PUBLIC :: dbcsr_verify_matrix
137 PUBLIC :: dbcsr_get_data_p
138 PUBLIC :: dbcsr_finalize
139
140 ! replication
141 PUBLIC :: dbcsr_replicate_all
142 PUBLIC :: dbcsr_sum_replicated
143 PUBLIC :: dbcsr_distribute
144
145 ! misc
146 PUBLIC :: dbcsr_distribution_get_num_images
147 PUBLIC :: dbcsr_convert_offsets_to_sizes
148 PUBLIC :: dbcsr_convert_sizes_to_offsets
149 PUBLIC :: dbcsr_run_tests
150 PUBLIC :: dbcsr_test_mm
151 PUBLIC :: dbcsr_dot_threadsafe
152
153 ! csr conversion
154 PUBLIC :: dbcsr_csr_type
155 PUBLIC :: dbcsr_csr_p_type
159 PUBLIC :: dbcsr_csr_destroy
160 PUBLIC :: dbcsr_csr_create
161 PUBLIC :: dbcsr_csr_eqrow_floor_dist
162 PUBLIC :: dbcsr_csr_dbcsr_blkrow_dist
163 PUBLIC :: dbcsr_csr_print_sparsity
164 PUBLIC :: dbcsr_csr_write
166 PUBLIC :: dbcsr_csr_type_real_8
167
168 ! binary io
169 PUBLIC :: dbcsr_binary_write
170 PUBLIC :: dbcsr_binary_read
171
173 TYPE(dbcsr_type), POINTER :: matrix => null()
174 END TYPE dbcsr_p_type
175
177 PRIVATE
178 TYPE(dbcsr_type_prv) :: dbcsr = dbcsr_type_prv()
179 TYPE(dbm_type) :: dbm = dbm_type()
180 END TYPE dbcsr_type
181
183 PRIVATE
184 TYPE(dbcsr_distribution_type_prv) :: dbcsr = dbcsr_distribution_type_prv()
187
189 PRIVATE
190 TYPE(dbcsr_iterator_type_prv) :: dbcsr = dbcsr_iterator_type_prv()
191 TYPE(dbm_iterator) :: dbm = dbm_iterator()
192 END TYPE dbcsr_iterator_type
193
194 INTERFACE dbcsr_create
195 MODULE PROCEDURE dbcsr_create_new, dbcsr_create_template
196 END INTERFACE
197
198 LOGICAL, PARAMETER, PRIVATE :: USE_DBCSR_BACKEND = .true.
199
200CONTAINS
201
202! **************************************************************************************************
203!> \brief ...
204!> \param matrix ...
205! **************************************************************************************************
206 SUBROUTINE dbcsr_init_p(matrix)
207 TYPE(dbcsr_type), POINTER :: matrix
208
209 IF (ASSOCIATED(matrix)) THEN
210 CALL dbcsr_release(matrix)
211 DEALLOCATE (matrix)
212 END IF
213
214 ALLOCATE (matrix)
215 END SUBROUTINE dbcsr_init_p
216
217! **************************************************************************************************
218!> \brief ...
219!> \param matrix ...
220! **************************************************************************************************
221 SUBROUTINE dbcsr_release_p(matrix)
222 TYPE(dbcsr_type), POINTER :: matrix
223
224 IF (ASSOCIATED(matrix)) THEN
225 CALL dbcsr_release(matrix)
226 DEALLOCATE (matrix)
227 END IF
228 END SUBROUTINE dbcsr_release_p
229
230! **************************************************************************************************
231!> \brief ...
232!> \param matrix ...
233! **************************************************************************************************
234 SUBROUTINE dbcsr_deallocate_matrix(matrix)
235 TYPE(dbcsr_type), POINTER :: matrix
236
237 CALL dbcsr_release(matrix)
238 IF (dbcsr_valid_index(matrix)) THEN
239 CALL cp_abort(__location__, &
240 'You should not "deallocate" a referenced matrix. '// &
241 'Avoid pointers to DBCSR matrices.')
242 END IF
243 DEALLOCATE (matrix)
244 END SUBROUTINE dbcsr_deallocate_matrix
245
246! **************************************************************************************************
247!> \brief ...
248!> \param matrix_a ...
249!> \param matrix_b ...
250!> \param alpha_scalar ...
251!> \param beta_scalar ...
252! **************************************************************************************************
253 SUBROUTINE dbcsr_add(matrix_a, matrix_b, alpha_scalar, beta_scalar)
254 TYPE(dbcsr_type), INTENT(INOUT) :: matrix_a
255 TYPE(dbcsr_type), INTENT(IN) :: matrix_b
256 REAL(kind=dp), INTENT(IN) :: alpha_scalar, beta_scalar
257
258 IF (use_dbcsr_backend) THEN
259 CALL dbcsr_add_prv(matrix_a%dbcsr, matrix_b%dbcsr, alpha_scalar, beta_scalar)
260 ELSE
261 IF (alpha_scalar /= 1.0_dp .OR. beta_scalar /= 1.0_dp) cpabort("Not yet implemented for DBM.")
262 CALL dbm_add(matrix_a%dbm, matrix_b%dbm)
263 END IF
264 END SUBROUTINE dbcsr_add
265
266! **************************************************************************************************
267!> \brief ...
268!> \param filepath ...
269!> \param distribution ...
270!> \param matrix_new ...
271! **************************************************************************************************
272 SUBROUTINE dbcsr_binary_read(filepath, distribution, matrix_new)
273 CHARACTER(len=*), INTENT(IN) :: filepath
274 TYPE(dbcsr_distribution_type), INTENT(IN) :: distribution
275 TYPE(dbcsr_type), INTENT(INOUT) :: matrix_new
276
277 IF (use_dbcsr_backend) THEN
278 CALL dbcsr_binary_read_prv(filepath, distribution%dbcsr, matrix_new%dbcsr)
279 ELSE
280 cpabort("Not yet implemented for DBM.")
281 END IF
282 END SUBROUTINE dbcsr_binary_read
283
284! **************************************************************************************************
285!> \brief ...
286!> \param matrix ...
287!> \param filepath ...
288! **************************************************************************************************
289 SUBROUTINE dbcsr_binary_write(matrix, filepath)
290 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
291 CHARACTER(LEN=*), INTENT(IN) :: filepath
292
293 IF (use_dbcsr_backend) THEN
294 CALL dbcsr_binary_write_prv(matrix%dbcsr, filepath)
295 ELSE
296 cpabort("Not yet implemented for DBM.")
297 END IF
298 END SUBROUTINE dbcsr_binary_write
299
300! **************************************************************************************************
301!> \brief ...
302!> \param matrix ...
303! **************************************************************************************************
304 SUBROUTINE dbcsr_clear(matrix)
305 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
306
307 IF (use_dbcsr_backend) THEN
308 CALL dbcsr_clear_prv(matrix%dbcsr)
309 ELSE
310 CALL dbm_clear(matrix%dbm)
311 END IF
312 END SUBROUTINE dbcsr_clear
313
314! **************************************************************************************************
315!> \brief ...
316!> \param matrix ...
317!> \param redist ...
318! **************************************************************************************************
319 SUBROUTINE dbcsr_complete_redistribute(matrix, redist)
320 TYPE(dbcsr_type), INTENT(IN) :: matrix
321 TYPE(dbcsr_type), INTENT(INOUT) :: redist
322
323 IF (use_dbcsr_backend) THEN
324 CALL dbcsr_complete_redistribute_prv(matrix%dbcsr, redist%dbcsr)
325 ELSE
326 CALL dbm_redistribute(matrix%dbm, redist%dbm)
327 END IF
328 END SUBROUTINE dbcsr_complete_redistribute
329
330! **************************************************************************************************
331!> \brief ...
332!> \param dbcsr_mat ...
333!> \param csr_mat ...
334! **************************************************************************************************
335 SUBROUTINE dbcsr_convert_csr_to_dbcsr(dbcsr_mat, csr_mat)
336 TYPE(dbcsr_type), INTENT(INOUT) :: dbcsr_mat
337 TYPE(dbcsr_csr_type), INTENT(INOUT) :: csr_mat
338
339 IF (use_dbcsr_backend) THEN
340 CALL convert_csr_to_dbcsr_prv(dbcsr_mat%dbcsr, csr_mat)
341 ELSE
342 cpabort("Not yet implemented for DBM.")
343 END IF
344 END SUBROUTINE dbcsr_convert_csr_to_dbcsr
345
346! **************************************************************************************************
347!> \brief ...
348!> \param dbcsr_mat ...
349!> \param csr_mat ...
350! **************************************************************************************************
351 SUBROUTINE dbcsr_convert_dbcsr_to_csr(dbcsr_mat, csr_mat)
352 TYPE(dbcsr_type), INTENT(IN) :: dbcsr_mat
353 TYPE(dbcsr_csr_type), INTENT(INOUT) :: csr_mat
354
355 IF (use_dbcsr_backend) THEN
356 CALL convert_dbcsr_to_csr_prv(dbcsr_mat%dbcsr, csr_mat)
357 ELSE
358 cpabort("Not yet implemented for DBM.")
359 END IF
360 END SUBROUTINE dbcsr_convert_dbcsr_to_csr
361
362! **************************************************************************************************
363!> \brief ...
364!> \param matrix_b ...
365!> \param matrix_a ...
366!> \param name ...
367!> \param keep_sparsity ...
368!> \param keep_imaginary ...
369! **************************************************************************************************
370 SUBROUTINE dbcsr_copy(matrix_b, matrix_a, name, keep_sparsity, keep_imaginary)
371 TYPE(dbcsr_type), INTENT(INOUT) :: matrix_b
372 TYPE(dbcsr_type), INTENT(IN) :: matrix_a
373 CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: name
374 LOGICAL, INTENT(IN), OPTIONAL :: keep_sparsity, keep_imaginary
375
376 IF (use_dbcsr_backend) THEN
377 CALL dbcsr_copy_prv(matrix_b%dbcsr, matrix_a%dbcsr, name=name, &
378 keep_sparsity=keep_sparsity, keep_imaginary=keep_imaginary)
379 ELSE
380 IF (PRESENT(name) .OR. PRESENT(keep_sparsity) .OR. PRESENT(keep_imaginary)) THEN
381 cpabort("Not yet implemented for DBM.")
382 END IF
383 CALL dbm_copy(matrix_b%dbm, matrix_a%dbm)
384 END IF
385 END SUBROUTINE dbcsr_copy
386
387! **************************************************************************************************
388!> \brief ...
389!> \param matrix ...
390!> \param name ...
391!> \param dist ...
392!> \param matrix_type ...
393!> \param row_blk_size ...
394!> \param col_blk_size ...
395!> \param reuse_arrays ...
396!> \param mutable_work ...
397! **************************************************************************************************
398 SUBROUTINE dbcsr_create_new(matrix, name, dist, matrix_type, row_blk_size, col_blk_size, &
399 reuse_arrays, mutable_work)
400 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
401 CHARACTER(len=*), INTENT(IN) :: name
402 TYPE(dbcsr_distribution_type), INTENT(IN) :: dist
403 CHARACTER, INTENT(IN) :: matrix_type
404 INTEGER, CONTIGUOUS, DIMENSION(:), INTENT(INOUT), &
405 POINTER :: row_blk_size, col_blk_size
406 LOGICAL, INTENT(IN), OPTIONAL :: reuse_arrays, mutable_work
407
408 IF (use_dbcsr_backend) THEN
409 CALL dbcsr_create_prv(matrix=matrix%dbcsr, name=name, dist=dist%dbcsr, &
410 matrix_type=matrix_type, row_blk_size=row_blk_size, &
411 col_blk_size=col_blk_size, nze=0, data_type=dbcsr_type_real_8, &
412 reuse_arrays=reuse_arrays, mutable_work=mutable_work)
413 ELSE
414 IF (matrix_type /= dbcsr_type_no_symmetry .OR. PRESENT(reuse_arrays) .OR. PRESENT(mutable_work)) THEN
415 cpabort("Not yet implemented for DBM.")
416 END IF
417 CALL dbm_create(matrix=matrix%dbm, name=name, dist=dist%dbm, &
418 row_block_sizes=row_blk_size, col_block_sizes=col_blk_size)
419 END IF
420 END SUBROUTINE dbcsr_create_new
421
422! **************************************************************************************************
423!> \brief ...
424!> \param matrix ...
425!> \param name ...
426!> \param template ...
427!> \param dist ...
428!> \param matrix_type ...
429!> \param row_blk_size ...
430!> \param col_blk_size ...
431!> \param reuse_arrays ...
432!> \param mutable_work ...
433! **************************************************************************************************
434 SUBROUTINE dbcsr_create_template(matrix, name, template, dist, matrix_type, &
435 row_blk_size, col_blk_size, reuse_arrays, mutable_work)
436 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
437 CHARACTER(len=*), INTENT(IN), OPTIONAL :: name
438 TYPE(dbcsr_type), INTENT(IN) :: template
439 TYPE(dbcsr_distribution_type), INTENT(IN), &
440 OPTIONAL :: dist
441 CHARACTER, INTENT(IN), OPTIONAL :: matrix_type
442 INTEGER, CONTIGUOUS, DIMENSION(:), INTENT(INOUT), &
443 OPTIONAL, POINTER :: row_blk_size, col_blk_size
444 LOGICAL, INTENT(IN), OPTIONAL :: reuse_arrays, mutable_work
445
446 IF (use_dbcsr_backend) THEN
447 IF (PRESENT(dist)) THEN
448 CALL dbcsr_create_prv(matrix=matrix%dbcsr, name=name, template=template%dbcsr, &
449 dist=dist%dbcsr, matrix_type=matrix_type, &
450 row_blk_size=row_blk_size, col_blk_size=col_blk_size, &
451 nze=0, data_type=dbcsr_type_real_8, reuse_arrays=reuse_arrays, &
452 mutable_work=mutable_work)
453 ELSE
454 CALL dbcsr_create_prv(matrix=matrix%dbcsr, name=name, template=template%dbcsr, &
455 matrix_type=matrix_type, &
456 row_blk_size=row_blk_size, col_blk_size=col_blk_size, &
457 nze=0, data_type=dbcsr_type_real_8, reuse_arrays=reuse_arrays, &
458 mutable_work=mutable_work)
459 END IF
460 ELSE
461 cpabort("Not yet implemented for DBM.")
462 END IF
463 END SUBROUTINE dbcsr_create_template
464
465! **************************************************************************************************
466!> \brief ...
467!> \param dbcsr_mat ...
468!> \param csr_mat ...
469!> \param dist_format ...
470!> \param csr_sparsity ...
471!> \param numnodes ...
472! **************************************************************************************************
473 SUBROUTINE dbcsr_csr_create_from_dbcsr(dbcsr_mat, csr_mat, dist_format, csr_sparsity, numnodes)
474
475 TYPE(dbcsr_type), INTENT(IN) :: dbcsr_mat
476 TYPE(dbcsr_csr_type), INTENT(OUT) :: csr_mat
477 INTEGER :: dist_format
478 TYPE(dbcsr_type), INTENT(IN), OPTIONAL :: csr_sparsity
479 INTEGER, INTENT(IN), OPTIONAL :: numnodes
480
481 IF (use_dbcsr_backend) THEN
482 IF (PRESENT(csr_sparsity)) THEN
483 CALL dbcsr_csr_create_from_dbcsr_prv(dbcsr_mat%dbcsr, csr_mat, dist_format, &
484 csr_sparsity%dbcsr, numnodes)
485 ELSE
486 CALL dbcsr_csr_create_from_dbcsr_prv(dbcsr_mat%dbcsr, csr_mat, &
487 dist_format, numnodes=numnodes)
488 END IF
489 ELSE
490 cpabort("Not yet implemented for DBM.")
491 END IF
492 END SUBROUTINE dbcsr_csr_create_from_dbcsr
493
494! **************************************************************************************************
495!> \brief Combines csr_create_from_dbcsr and convert_dbcsr_to_csr to produce a complex CSR matrix.
496!> \param rmatrix Real part of the matrix.
497!> \param imatrix Imaginary part of the matrix.
498!> \param csr_mat The resulting CSR matrix.
499!> \param dist_format ...
500! **************************************************************************************************
501 SUBROUTINE dbcsr_csr_create_and_convert_complex(rmatrix, imatrix, csr_mat, dist_format)
502 TYPE(dbcsr_type), INTENT(IN) :: rmatrix, imatrix
503 TYPE(dbcsr_csr_type), INTENT(INOUT) :: csr_mat
504 INTEGER :: dist_format
505
506 TYPE(dbcsr_type) :: cmatrix, tmp_matrix
507
508 IF (use_dbcsr_backend) THEN
509 CALL dbcsr_create_prv(tmp_matrix%dbcsr, template=rmatrix%dbcsr, data_type=dbcsr_type_complex_8)
510 CALL dbcsr_create_prv(cmatrix%dbcsr, template=rmatrix%dbcsr, data_type=dbcsr_type_complex_8)
511 CALL dbcsr_copy_prv(cmatrix%dbcsr, rmatrix%dbcsr)
512 CALL dbcsr_copy_prv(tmp_matrix%dbcsr, imatrix%dbcsr)
513 CALL dbcsr_add_prv(cmatrix%dbcsr, tmp_matrix%dbcsr, z_one, gaussi)
514 CALL dbcsr_release_prv(tmp_matrix%dbcsr)
515 ! Convert to csr
516 CALL dbcsr_csr_create_from_dbcsr_prv(cmatrix%dbcsr, csr_mat, dist_format)
517 CALL convert_dbcsr_to_csr_prv(cmatrix%dbcsr, csr_mat)
518 CALL dbcsr_release_prv(cmatrix%dbcsr)
519 ELSE
520 cpabort("Not yet implemented for DBM.")
521 END IF
523
524! **************************************************************************************************
525!> \brief ...
526!> \param matrix_a ...
527!> \param matrix_b ...
528! **************************************************************************************************
529 SUBROUTINE dbcsr_desymmetrize(matrix_a, matrix_b)
530 TYPE(dbcsr_type), INTENT(IN) :: matrix_a
531 TYPE(dbcsr_type), INTENT(INOUT) :: matrix_b
532
533 IF (use_dbcsr_backend) THEN
534 CALL dbcsr_desymmetrize_prv(matrix_a%dbcsr, matrix_b%dbcsr)
535 ELSE
536 cpabort("Not yet implemented for DBM.")
537 END IF
538 END SUBROUTINE dbcsr_desymmetrize
539
540! **************************************************************************************************
541!> \brief ...
542!> \param matrix ...
543! **************************************************************************************************
544 SUBROUTINE dbcsr_distribute(matrix)
545 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
546
547 IF (use_dbcsr_backend) THEN
548 CALL dbcsr_distribute_prv(matrix%dbcsr)
549 ELSE
550 cpabort("Not yet implemented for DBM.")
551 END IF
552 END SUBROUTINE dbcsr_distribute
553
554! **************************************************************************************************
555!> \brief ...
556!> \param dist ...
557!> \param row_dist ...
558!> \param col_dist ...
559!> \param nrows ...
560!> \param ncols ...
561!> \param has_threads ...
562!> \param group ...
563!> \param mynode ...
564!> \param numnodes ...
565!> \param nprows ...
566!> \param npcols ...
567!> \param myprow ...
568!> \param mypcol ...
569!> \param pgrid ...
570!> \param subgroups_defined ...
571!> \param prow_group ...
572!> \param pcol_group ...
573! **************************************************************************************************
574 SUBROUTINE dbcsr_distribution_get(dist, row_dist, col_dist, nrows, ncols, has_threads, &
575 group, mynode, numnodes, nprows, npcols, myprow, mypcol, &
576 pgrid, subgroups_defined, prow_group, pcol_group)
577 TYPE(dbcsr_distribution_type), INTENT(IN) :: dist
578 INTEGER, DIMENSION(:), OPTIONAL, POINTER :: row_dist, col_dist
579 INTEGER, INTENT(OUT), OPTIONAL :: nrows, ncols
580 LOGICAL, INTENT(OUT), OPTIONAL :: has_threads
581 INTEGER, INTENT(OUT), OPTIONAL :: group, mynode, numnodes, nprows, npcols, &
582 myprow, mypcol
583 INTEGER, DIMENSION(:, :), OPTIONAL, POINTER :: pgrid
584 LOGICAL, INTENT(OUT), OPTIONAL :: subgroups_defined
585 INTEGER, INTENT(OUT), OPTIONAL :: prow_group, pcol_group
586
587 IF (use_dbcsr_backend) THEN
588 CALL dbcsr_distribution_get_prv(dist%dbcsr, row_dist, col_dist, nrows, ncols, has_threads, &
589 group, mynode, numnodes, nprows, npcols, myprow, mypcol, &
590 pgrid, subgroups_defined, prow_group, pcol_group)
591 ELSE
592 cpabort("Not yet implemented for DBM.")
593 END IF
594 END SUBROUTINE dbcsr_distribution_get
595
596! **************************************************************************************************
597!> \brief ...
598!> \param dist ...
599! **************************************************************************************************
600 SUBROUTINE dbcsr_distribution_hold(dist)
601 TYPE(dbcsr_distribution_type) :: dist
602
603 IF (use_dbcsr_backend) THEN
604 CALL dbcsr_distribution_hold_prv(dist%dbcsr)
605 ELSE
606 cpabort("Not yet implemented for DBM.")
607 END IF
608 END SUBROUTINE dbcsr_distribution_hold
609
610! **************************************************************************************************
611!> \brief ...
612!> \param dist ...
613!> \param template ...
614!> \param group ...
615!> \param pgrid ...
616!> \param row_dist ...
617!> \param col_dist ...
618!> \param reuse_arrays ...
619! **************************************************************************************************
620 SUBROUTINE dbcsr_distribution_new(dist, template, group, pgrid, row_dist, col_dist, reuse_arrays)
621 TYPE(dbcsr_distribution_type), INTENT(OUT) :: dist
622 TYPE(dbcsr_distribution_type), INTENT(IN), &
623 OPTIONAL :: template
624 INTEGER, INTENT(IN), OPTIONAL :: group
625 INTEGER, DIMENSION(:, :), OPTIONAL, POINTER :: pgrid
626 INTEGER, CONTIGUOUS, DIMENSION(:), INTENT(INOUT), &
627 POINTER :: row_dist, col_dist
628 LOGICAL, INTENT(IN), OPTIONAL :: reuse_arrays
629
630 TYPE(mp_comm_type) :: mp_comm
631
632 IF (use_dbcsr_backend) THEN
633 IF (PRESENT(template)) THEN
634 CALL dbcsr_distribution_new_prv(dist%dbcsr, template%dbcsr, group, pgrid, &
635 row_dist, col_dist, reuse_arrays)
636 ELSE
637 CALL dbcsr_distribution_new_prv(dist%dbcsr, group=group, pgrid=pgrid, &
638 row_dist=row_dist, col_dist=col_dist, &
639 reuse_arrays=reuse_arrays)
640 END IF
641 ELSE
642 IF (.NOT. PRESENT(group)) THEN
643 cpabort("Not yet implemented for DBM.")
644 END IF
645 CALL mp_comm%set_handle(group)
646 CALL dbm_distribution_new(dist%dbm, mp_comm, row_dist_block=row_dist, col_dist_block=col_dist)
647 END IF
648 END SUBROUTINE dbcsr_distribution_new
649
650! **************************************************************************************************
651!> \brief ...
652!> \param dist ...
653! **************************************************************************************************
655 TYPE(dbcsr_distribution_type) :: dist
656
657 IF (use_dbcsr_backend) THEN
658 CALL dbcsr_distribution_release_prv(dist%dbcsr)
659 ELSE
660 cpabort("Not yet implemented for DBM.")
661 END IF
662 END SUBROUTINE dbcsr_distribution_release
663
664! **************************************************************************************************
665!> \brief ...
666!> \param matrix ...
667!> \param eps ...
668! **************************************************************************************************
669 SUBROUTINE dbcsr_filter(matrix, eps)
670 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
671 REAL(dp), INTENT(IN) :: eps
672
673 IF (use_dbcsr_backend) THEN
674 CALL dbcsr_filter_prv(matrix%dbcsr, eps)
675 ELSE
676 cpabort("Not yet implemented for DBM.")
677 END IF
678 END SUBROUTINE dbcsr_filter
679
680! **************************************************************************************************
681!> \brief ...
682!> \param matrix ...
683! **************************************************************************************************
684 SUBROUTINE dbcsr_finalize(matrix)
685 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
686
687 IF (use_dbcsr_backend) THEN
688 CALL dbcsr_finalize_prv(matrix%dbcsr)
689 ELSE
690 cpabort("Not yet implemented for DBM.")
691 END IF
692 END SUBROUTINE dbcsr_finalize
693
694! **************************************************************************************************
695!> \brief ...
696!> \param matrix ...
697!> \param row ...
698!> \param col ...
699!> \param block ...
700!> \param found ...
701!> \param row_size ...
702!> \param col_size ...
703! **************************************************************************************************
704 SUBROUTINE dbcsr_get_block_p(matrix, row, col, block, found, row_size, col_size)
705 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
706 INTEGER, INTENT(IN) :: row, col
707 REAL(kind=dp), DIMENSION(:, :), POINTER :: block
708 LOGICAL, INTENT(OUT) :: found
709 INTEGER, INTENT(OUT), OPTIONAL :: row_size, col_size
710
711 IF (use_dbcsr_backend) THEN
712 CALL dbcsr_get_block_p_prv(matrix%dbcsr, row, col, block, found, row_size, col_size)
713 ELSE
714 cpabort("Not yet implemented for DBM.")
715 END IF
716 END SUBROUTINE dbcsr_get_block_p
717
718! **************************************************************************************************
719!> \brief Like dbcsr_get_block_p() but with matrix being INTENT(IN).
720!> When invoking this routine, the caller promises not to modify the returned block.
721!> \param matrix ...
722!> \param row ...
723!> \param col ...
724!> \param block ...
725!> \param found ...
726!> \param row_size ...
727!> \param col_size ...
728! **************************************************************************************************
729 SUBROUTINE dbcsr_get_readonly_block_p(matrix, row, col, block, found, row_size, col_size)
730 TYPE(dbcsr_type), INTENT(IN), TARGET :: matrix
731 INTEGER, INTENT(IN) :: row, col
732 REAL(kind=dp), DIMENSION(:, :), POINTER :: block
733 LOGICAL, INTENT(OUT) :: found
734 INTEGER, INTENT(OUT), OPTIONAL :: row_size, col_size
735
736 TYPE(dbcsr_type), POINTER :: matrix_p
737
738 mark_used(matrix)
739 mark_used(row)
740 mark_used(col)
741 mark_used(block)
742 mark_used(found)
743 mark_used(row_size)
744 mark_used(col_size)
745 IF (use_dbcsr_backend) THEN
746 matrix_p => matrix ! Hacky workaround to shake the INTENT(IN).
747 CALL dbcsr_get_block_p_prv(matrix_p%dbcsr, row, col, block, found, row_size, col_size)
748 ELSE
749 cpabort("Not yet implemented for DBM.")
750 END IF
751 END SUBROUTINE dbcsr_get_readonly_block_p
752
753! **************************************************************************************************
754!> \brief ...
755!> \param matrix ...
756!> \param lb ...
757!> \param ub ...
758!> \return ...
759! **************************************************************************************************
760 FUNCTION dbcsr_get_data_p(matrix, lb, ub) RESULT(res)
761 TYPE(dbcsr_type), INTENT(IN) :: matrix
762 INTEGER, INTENT(IN), OPTIONAL :: lb, ub
763 REAL(kind=dp), DIMENSION(:), POINTER :: res
764
765 IF (use_dbcsr_backend) THEN
766 res => dbcsr_get_data_p_prv(matrix%dbcsr, select_data_type=0.0_dp, lb=lb, ub=ub)
767 ELSE
768 cpabort("Not yet implemented for DBM.")
769 END IF
770 END FUNCTION dbcsr_get_data_p
771
772! **************************************************************************************************
773!> \brief ...
774!> \param matrix ...
775!> \return ...
776! **************************************************************************************************
777 FUNCTION dbcsr_get_data_size(matrix) RESULT(data_size)
778 TYPE(dbcsr_type), INTENT(IN) :: matrix
779 INTEGER :: data_size
780
781 IF (use_dbcsr_backend) THEN
782 data_size = dbcsr_get_data_size_prv(matrix%dbcsr)
783 ELSE
784 cpabort("Not yet implemented for DBM.")
785 END IF
786 END FUNCTION dbcsr_get_data_size
787
788! **************************************************************************************************
789!> \brief ...
790!> \param matrix ...
791!> \param nblkrows_total ...
792!> \param nblkcols_total ...
793!> \param nfullrows_total ...
794!> \param nfullcols_total ...
795!> \param nblkrows_local ...
796!> \param nblkcols_local ...
797!> \param nfullrows_local ...
798!> \param nfullcols_local ...
799!> \param my_prow ...
800!> \param my_pcol ...
801!> \param local_rows ...
802!> \param local_cols ...
803!> \param proc_row_dist ...
804!> \param proc_col_dist ...
805!> \param row_blk_size ...
806!> \param col_blk_size ...
807!> \param row_blk_offset ...
808!> \param col_blk_offset ...
809!> \param distribution ...
810!> \param name ...
811!> \param matrix_type ...
812!> \param group ...
813! **************************************************************************************************
814 SUBROUTINE dbcsr_get_info(matrix, nblkrows_total, nblkcols_total, &
815 nfullrows_total, nfullcols_total, nblkrows_local, nblkcols_local, &
816 nfullrows_local, nfullcols_local, my_prow, my_pcol, &
817 local_rows, local_cols, proc_row_dist, proc_col_dist, &
818 row_blk_size, col_blk_size, row_blk_offset, col_blk_offset, &
819 distribution, name, matrix_type, group)
820 TYPE(dbcsr_type), INTENT(IN) :: matrix
821 INTEGER, INTENT(OUT), OPTIONAL :: nblkrows_total, nblkcols_total, nfullrows_total, &
822 nfullcols_total, nblkrows_local, nblkcols_local, nfullrows_local, nfullcols_local, &
823 my_prow, my_pcol
824 INTEGER, DIMENSION(:), OPTIONAL, POINTER :: local_rows, local_cols, proc_row_dist, &
825 proc_col_dist, row_blk_size, col_blk_size, row_blk_offset, col_blk_offset
826 TYPE(dbcsr_distribution_type), INTENT(OUT), &
827 OPTIONAL :: distribution
828 CHARACTER(len=*), INTENT(OUT), OPTIONAL :: name
829 CHARACTER, INTENT(OUT), OPTIONAL :: matrix_type
830 TYPE(mp_comm_type), INTENT(OUT), OPTIONAL :: group
831
832 INTEGER :: group_handle
833 TYPE(dbcsr_distribution_type_prv) :: my_distribution
834
835 IF (use_dbcsr_backend) THEN
836 CALL dbcsr_get_info_prv(matrix=matrix%dbcsr, &
837 nblkrows_total=nblkrows_total, &
838 nblkcols_total=nblkcols_total, &
839 nfullrows_total=nfullrows_total, &
840 nfullcols_total=nfullcols_total, &
841 nblkrows_local=nblkrows_local, &
842 nblkcols_local=nblkcols_local, &
843 nfullrows_local=nfullrows_local, &
844 nfullcols_local=nfullcols_local, &
845 my_prow=my_prow, &
846 my_pcol=my_pcol, &
847 local_rows=local_rows, &
848 local_cols=local_cols, &
849 proc_row_dist=proc_row_dist, &
850 proc_col_dist=proc_col_dist, &
851 row_blk_size=row_blk_size, &
852 col_blk_size=col_blk_size, &
853 row_blk_offset=row_blk_offset, &
854 col_blk_offset=col_blk_offset, &
855 distribution=my_distribution, &
856 name=name, &
857 matrix_type=matrix_type, &
858 group=group_handle)
859
860 IF (PRESENT(distribution)) distribution%dbcsr = my_distribution
861 IF (PRESENT(group)) CALL group%set_handle(group_handle)
862 ELSE
863 cpabort("Not yet implemented for DBM.")
864 END IF
865 END SUBROUTINE dbcsr_get_info
866
867! **************************************************************************************************
868!> \brief ...
869!> \param matrix ...
870!> \return ...
871! **************************************************************************************************
872 FUNCTION dbcsr_get_matrix_type(matrix) RESULT(matrix_type)
873 TYPE(dbcsr_type), INTENT(IN) :: matrix
874 CHARACTER :: matrix_type
875
876 IF (use_dbcsr_backend) THEN
877 matrix_type = dbcsr_get_matrix_type_prv(matrix%dbcsr)
878 ELSE
879 cpabort("Not yet implemented for DBM.")
880 END IF
881 END FUNCTION dbcsr_get_matrix_type
882
883! **************************************************************************************************
884!> \brief ...
885!> \param matrix ...
886!> \return ...
887! **************************************************************************************************
888 FUNCTION dbcsr_get_num_blocks(matrix) RESULT(num_blocks)
889 TYPE(dbcsr_type), INTENT(IN) :: matrix
890 INTEGER :: num_blocks
891
892 IF (use_dbcsr_backend) THEN
893 num_blocks = dbcsr_get_num_blocks_prv(matrix%dbcsr)
894 ELSE
895 cpabort("Not yet implemented for DBM.")
896 END IF
897 END FUNCTION dbcsr_get_num_blocks
898
899! **************************************************************************************************
900!> \brief ...
901!> \param matrix ...
902!> \return ...
903! **************************************************************************************************
904 FUNCTION dbcsr_get_occupation(matrix) RESULT(occupation)
905 TYPE(dbcsr_type), INTENT(IN) :: matrix
906 REAL(kind=dp) :: occupation
907
908 IF (use_dbcsr_backend) THEN
909 occupation = dbcsr_get_occupation_prv(matrix%dbcsr)
910 ELSE
911 cpabort("Not yet implemented for DBM.")
912 END IF
913 END FUNCTION dbcsr_get_occupation
914
915! **************************************************************************************************
916!> \brief ...
917!> \param matrix ...
918!> \param row ...
919!> \param column ...
920!> \param processor ...
921! **************************************************************************************************
922 SUBROUTINE dbcsr_get_stored_coordinates(matrix, row, column, processor)
923 TYPE(dbcsr_type), INTENT(IN) :: matrix
924 INTEGER, INTENT(IN) :: row, column
925 INTEGER, INTENT(OUT) :: processor
926
927 IF (use_dbcsr_backend) THEN
928 CALL dbcsr_get_stored_coordinates_prv(matrix%dbcsr, row, column, processor)
929 ELSE
930 cpabort("Not yet implemented for DBM.")
931 END IF
932 END SUBROUTINE dbcsr_get_stored_coordinates
933
934! **************************************************************************************************
935!> \brief ...
936!> \param matrix ...
937!> \return ...
938! **************************************************************************************************
939 FUNCTION dbcsr_has_symmetry(matrix) RESULT(has_symmetry)
940 TYPE(dbcsr_type), INTENT(IN) :: matrix
941 LOGICAL :: has_symmetry
942
943 IF (use_dbcsr_backend) THEN
944 has_symmetry = dbcsr_has_symmetry_prv(matrix%dbcsr)
945 ELSE
946 cpabort("Not yet implemented for DBM.")
947 END IF
948 END FUNCTION dbcsr_has_symmetry
949
950! **************************************************************************************************
951!> \brief ...
952!> \param iterator ...
953!> \return ...
954! **************************************************************************************************
955 FUNCTION dbcsr_iterator_blocks_left(iterator) RESULT(blocks_left)
956 TYPE(dbcsr_iterator_type), INTENT(IN) :: iterator
957 LOGICAL :: blocks_left
958
959 IF (use_dbcsr_backend) THEN
960 blocks_left = dbcsr_iterator_blocks_left_prv(iterator%dbcsr)
961 ELSE
962 cpabort("Not yet implemented for DBM.")
963 END IF
964 END FUNCTION dbcsr_iterator_blocks_left
965
966! **************************************************************************************************
967!> \brief ...
968!> \param iterator ...
969!> \param row ...
970!> \param column ...
971!> \param block ...
972!> \param block_number_argument_has_been_removed ...
973!> \param row_size ...
974!> \param col_size ...
975!> \param row_offset ...
976!> \param col_offset ...
977!> \param transposed ...
978! **************************************************************************************************
979 SUBROUTINE dbcsr_iterator_next_block(iterator, row, column, block, &
980 block_number_argument_has_been_removed, &
981 row_size, col_size, &
982 row_offset, col_offset, transposed)
983 TYPE(dbcsr_iterator_type), INTENT(INOUT) :: iterator
984 INTEGER, INTENT(OUT), OPTIONAL :: row, column
985 REAL(kind=dp), DIMENSION(:, :), OPTIONAL, POINTER :: block
986 LOGICAL, OPTIONAL :: block_number_argument_has_been_removed
987 INTEGER, INTENT(OUT), OPTIONAL :: row_size, col_size, row_offset, &
988 col_offset
989 LOGICAL, INTENT(OUT), OPTIONAL :: transposed
990
991 INTEGER :: my_column, my_row
992 REAL(kind=dp), DIMENSION(:, :), POINTER :: my_block
993
994 cpassert(.NOT. PRESENT(block_number_argument_has_been_removed))
995
996 IF (use_dbcsr_backend) THEN
997 IF (PRESENT(transposed)) THEN
998 CALL dbcsr_iterator_next_block_prv(iterator%dbcsr, row=my_row, column=my_column, &
999 block=my_block, row_size=row_size, col_size=col_size, &
1000 row_offset=row_offset, col_offset=col_offset, &
1001 transposed=transposed)
1002 ELSE
1003 CALL dbcsr_iterator_next_block_prv(iterator%dbcsr, row=my_row, column=my_column, &
1004 block=my_block, row_size=row_size, col_size=col_size, &
1005 row_offset=row_offset, col_offset=col_offset)
1006 END IF
1007 IF (PRESENT(block)) block => my_block
1008 IF (PRESENT(row)) row = my_row
1009 IF (PRESENT(column)) column = my_column
1010 ELSE
1011 cpabort("Not yet implemented for DBM.")
1012 END IF
1013 END SUBROUTINE dbcsr_iterator_next_block
1014
1015! **************************************************************************************************
1016!> \brief ...
1017!> \param iterator ...
1018!> \param matrix ...
1019!> \param shared ...
1020!> \param dynamic ...
1021!> \param dynamic_byrows ...
1022! **************************************************************************************************
1023 SUBROUTINE dbcsr_iterator_start(iterator, matrix, shared, dynamic, dynamic_byrows)
1024 TYPE(dbcsr_iterator_type), INTENT(OUT) :: iterator
1025 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
1026 LOGICAL, INTENT(IN), OPTIONAL :: shared, dynamic, dynamic_byrows
1027
1028 IF (use_dbcsr_backend) THEN
1029 CALL dbcsr_iterator_start_prv(iterator%dbcsr, matrix%dbcsr, shared, dynamic, dynamic_byrows)
1030 ELSE
1031 cpabort("Not yet implemented for DBM.")
1032 END IF
1033 END SUBROUTINE dbcsr_iterator_start
1034
1035! **************************************************************************************************
1036!> \brief Like dbcsr_iterator_start() but with matrix being INTENT(IN).
1037!> When invoking this routine, the caller promises not to modify the returned blocks.
1038!> \param iterator ...
1039!> \param matrix ...
1040!> \param shared ...
1041!> \param dynamic ...
1042!> \param dynamic_byrows ...
1043! **************************************************************************************************
1044 SUBROUTINE dbcsr_iterator_readonly_start(iterator, matrix, shared, dynamic, dynamic_byrows)
1045 TYPE(dbcsr_iterator_type), INTENT(OUT) :: iterator
1046 TYPE(dbcsr_type), INTENT(IN) :: matrix
1047 LOGICAL, INTENT(IN), OPTIONAL :: shared, dynamic, dynamic_byrows
1048
1049 IF (use_dbcsr_backend) THEN
1050 CALL dbcsr_iterator_start_prv(iterator%dbcsr, matrix%dbcsr, shared, dynamic, &
1051 dynamic_byrows, read_only=.true.)
1052 ELSE
1053 cpabort("Not yet implemented for DBM.")
1054 END IF
1055 END SUBROUTINE dbcsr_iterator_readonly_start
1056
1057! **************************************************************************************************
1058!> \brief ...
1059!> \param iterator ...
1060! **************************************************************************************************
1061 SUBROUTINE dbcsr_iterator_stop(iterator)
1062 TYPE(dbcsr_iterator_type), INTENT(INOUT) :: iterator
1063
1064 IF (use_dbcsr_backend) THEN
1065 CALL dbcsr_iterator_stop_prv(iterator%dbcsr)
1066 ELSE
1067 cpabort("Not yet implemented for DBM.")
1068 END IF
1069 END SUBROUTINE dbcsr_iterator_stop
1070
1071! **************************************************************************************************
1072!> \brief ...
1073!> \param dist ...
1074! **************************************************************************************************
1075 SUBROUTINE dbcsr_mp_grid_setup(dist)
1076 TYPE(dbcsr_distribution_type), INTENT(INOUT) :: dist
1077
1078 IF (use_dbcsr_backend) THEN
1079 CALL dbcsr_mp_grid_setup_prv(dist%dbcsr)
1080 ELSE
1081 cpabort("Not yet implemented for DBM.")
1082 END IF
1083 END SUBROUTINE dbcsr_mp_grid_setup
1084
1085! **************************************************************************************************
1086!> \brief ...
1087!> \param transa ...
1088!> \param transb ...
1089!> \param alpha ...
1090!> \param matrix_a ...
1091!> \param matrix_b ...
1092!> \param beta ...
1093!> \param matrix_c ...
1094!> \param first_row ...
1095!> \param last_row ...
1096!> \param first_column ...
1097!> \param last_column ...
1098!> \param first_k ...
1099!> \param last_k ...
1100!> \param retain_sparsity ...
1101!> \param filter_eps ...
1102!> \param flop ...
1103! **************************************************************************************************
1104 SUBROUTINE dbcsr_multiply(transa, transb, alpha, matrix_a, matrix_b, beta, &
1105 matrix_c, first_row, last_row, &
1106 first_column, last_column, first_k, last_k, &
1107 retain_sparsity, filter_eps, flop)
1108 CHARACTER(LEN=1), INTENT(IN) :: transa, transb
1109 REAL(kind=dp), INTENT(IN) :: alpha
1110 TYPE(dbcsr_type), INTENT(IN) :: matrix_a, matrix_b
1111 REAL(kind=dp), INTENT(IN) :: beta
1112 TYPE(dbcsr_type), INTENT(INOUT) :: matrix_c
1113 INTEGER, INTENT(IN), OPTIONAL :: first_row, last_row, first_column, &
1114 last_column, first_k, last_k
1115 LOGICAL, INTENT(IN), OPTIONAL :: retain_sparsity
1116 REAL(kind=dp), INTENT(IN), OPTIONAL :: filter_eps
1117 INTEGER(int_8), INTENT(OUT), OPTIONAL :: flop
1118
1119 IF (use_dbcsr_backend) THEN
1120 CALL dbcsr_multiply_prv(transa, transb, alpha, matrix_a%dbcsr, matrix_b%dbcsr, beta, &
1121 matrix_c%dbcsr, first_row, last_row, first_column, last_column, &
1122 first_k, last_k, retain_sparsity, filter_eps=filter_eps, flop=flop)
1123 ELSE
1124 cpabort("Not yet implemented for DBM.")
1125 END IF
1126 END SUBROUTINE dbcsr_multiply
1127
1128! **************************************************************************************************
1129!> \brief ...
1130!> \param matrix ...
1131!> \param row ...
1132!> \param col ...
1133!> \param block ...
1134!> \param summation ...
1135! **************************************************************************************************
1136 SUBROUTINE dbcsr_put_block(matrix, row, col, block, summation)
1137 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
1138 INTEGER, INTENT(IN) :: row, col
1139 REAL(kind=dp), DIMENSION(:, :), INTENT(IN) :: block
1140 LOGICAL, INTENT(IN), OPTIONAL :: summation
1141
1142 IF (use_dbcsr_backend) THEN
1143 CALL dbcsr_put_block_prv(matrix%dbcsr, row, col, block, summation=summation)
1144 ELSE
1145 cpabort("Not yet implemented for DBM.")
1146 END IF
1147 END SUBROUTINE dbcsr_put_block
1148
1149! **************************************************************************************************
1150!> \brief ...
1151!> \param matrix ...
1152! **************************************************************************************************
1153 SUBROUTINE dbcsr_release(matrix)
1154 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
1155
1156 IF (use_dbcsr_backend) THEN
1157 CALL dbcsr_release_prv(matrix%dbcsr)
1158 ELSE
1159 cpabort("Not yet implemented for DBM.")
1160 END IF
1161 END SUBROUTINE dbcsr_release
1162
1163! **************************************************************************************************
1164!> \brief ...
1165!> \param matrix ...
1166! **************************************************************************************************
1167 SUBROUTINE dbcsr_replicate_all(matrix)
1168 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
1169
1170 IF (use_dbcsr_backend) THEN
1171 CALL dbcsr_replicate_all_prv(matrix%dbcsr)
1172 ELSE
1173 cpabort("Not yet implemented for DBM.")
1174 END IF
1175 END SUBROUTINE dbcsr_replicate_all
1176
1177! **************************************************************************************************
1178!> \brief ...
1179!> \param matrix ...
1180!> \param rows ...
1181!> \param cols ...
1182! **************************************************************************************************
1183 SUBROUTINE dbcsr_reserve_blocks(matrix, rows, cols)
1184 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
1185 INTEGER, DIMENSION(:), INTENT(IN) :: rows, cols
1186
1187 IF (use_dbcsr_backend) THEN
1188 CALL dbcsr_reserve_blocks_prv(matrix%dbcsr, rows, cols)
1189 ELSE
1190 cpabort("Not yet implemented for DBM.")
1191 END IF
1192 END SUBROUTINE dbcsr_reserve_blocks
1193
1194! **************************************************************************************************
1195!> \brief ...
1196!> \param matrix ...
1197!> \param alpha_scalar ...
1198! **************************************************************************************************
1199 SUBROUTINE dbcsr_scale(matrix, alpha_scalar)
1200 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
1201 REAL(kind=dp), INTENT(IN) :: alpha_scalar
1202
1203 IF (use_dbcsr_backend) THEN
1204 CALL dbcsr_scale_prv(matrix%dbcsr, alpha_scalar)
1205 ELSE
1206 CALL dbm_scale(matrix%dbm, alpha_scalar)
1207 END IF
1208 END SUBROUTINE dbcsr_scale
1209
1210! **************************************************************************************************
1211!> \brief ...
1212!> \param matrix ...
1213!> \param alpha ...
1214! **************************************************************************************************
1215 SUBROUTINE dbcsr_set(matrix, alpha)
1216 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
1217 REAL(kind=dp), INTENT(IN) :: alpha
1218
1219 IF (use_dbcsr_backend) THEN
1220 CALL dbcsr_set_prv(matrix%dbcsr, alpha)
1221 ELSE
1222 IF (alpha == 0.0_dp) THEN
1223 CALL dbm_zero(matrix%dbm)
1224 ELSE
1225 cpabort("Not yet implemented for DBM.")
1226 END IF
1227 END IF
1228 END SUBROUTINE dbcsr_set
1229
1230! **************************************************************************************************
1231!> \brief ...
1232!> \param matrix ...
1233! **************************************************************************************************
1234 SUBROUTINE dbcsr_sum_replicated(matrix)
1235 TYPE(dbcsr_type), INTENT(inout) :: matrix
1236
1237 IF (use_dbcsr_backend) THEN
1238 CALL dbcsr_sum_replicated_prv(matrix%dbcsr)
1239 ELSE
1240 cpabort("Not yet implemented for DBM.")
1241 END IF
1242 END SUBROUTINE dbcsr_sum_replicated
1243
1244! **************************************************************************************************
1245!> \brief ...
1246!> \param transposed ...
1247!> \param normal ...
1248!> \param shallow_data_copy ...
1249!> \param transpose_distribution ...
1250!> \param use_distribution ...
1251! **************************************************************************************************
1252 SUBROUTINE dbcsr_transposed(transposed, normal, shallow_data_copy, transpose_distribution, &
1253 use_distribution)
1254 TYPE(dbcsr_type), INTENT(INOUT) :: transposed
1255 TYPE(dbcsr_type), INTENT(IN) :: normal
1256 LOGICAL, INTENT(IN), OPTIONAL :: shallow_data_copy, transpose_distribution
1257 TYPE(dbcsr_distribution_type), INTENT(IN), &
1258 OPTIONAL :: use_distribution
1259
1260 IF (use_dbcsr_backend) THEN
1261 IF (PRESENT(use_distribution)) THEN
1262 CALL dbcsr_transposed_prv(transposed%dbcsr, normal%dbcsr, &
1263 shallow_data_copy=shallow_data_copy, &
1264 transpose_distribution=transpose_distribution, &
1265 use_distribution=use_distribution%dbcsr)
1266 ELSE
1267 CALL dbcsr_transposed_prv(transposed%dbcsr, normal%dbcsr, &
1268 shallow_data_copy=shallow_data_copy, &
1269 transpose_distribution=transpose_distribution)
1270 END IF
1271 ELSE
1272 cpabort("Not yet implemented for DBM.")
1273 END IF
1274 END SUBROUTINE dbcsr_transposed
1275
1276! **************************************************************************************************
1277!> \brief ...
1278!> \param matrix ...
1279!> \return ...
1280! **************************************************************************************************
1281 FUNCTION dbcsr_valid_index(matrix) RESULT(valid_index)
1282 TYPE(dbcsr_type), INTENT(IN) :: matrix
1283 LOGICAL :: valid_index
1284
1285 IF (use_dbcsr_backend) THEN
1286 valid_index = dbcsr_valid_index_prv(matrix%dbcsr)
1287 ELSE
1288 valid_index = .true. ! Does not apply to DBM.
1289 END IF
1290 END FUNCTION dbcsr_valid_index
1291
1292! **************************************************************************************************
1293!> \brief ...
1294!> \param matrix ...
1295!> \param verbosity ...
1296!> \param local ...
1297! **************************************************************************************************
1298 SUBROUTINE dbcsr_verify_matrix(matrix, verbosity, local)
1299 TYPE(dbcsr_type), INTENT(IN) :: matrix
1300 INTEGER, INTENT(IN), OPTIONAL :: verbosity
1301 LOGICAL, INTENT(IN), OPTIONAL :: local
1302
1303 IF (use_dbcsr_backend) THEN
1304 CALL dbcsr_verify_matrix_prv(matrix%dbcsr, verbosity, local)
1305 ELSE
1306 ! Does not apply to DBM.
1307 END IF
1308 END SUBROUTINE dbcsr_verify_matrix
1309
1310! **************************************************************************************************
1311!> \brief ...
1312!> \param matrix ...
1313!> \param nblks_guess ...
1314!> \param sizedata_guess ...
1315!> \param n ...
1316!> \param work_mutable ...
1317! **************************************************************************************************
1318 SUBROUTINE dbcsr_work_create(matrix, nblks_guess, sizedata_guess, n, work_mutable)
1319 TYPE(dbcsr_type), INTENT(INOUT) :: matrix
1320 INTEGER, INTENT(IN), OPTIONAL :: nblks_guess, sizedata_guess, n
1321 LOGICAL, INTENT(in), OPTIONAL :: work_mutable
1322
1323 IF (use_dbcsr_backend) THEN
1324 CALL dbcsr_work_create_prv(matrix%dbcsr, nblks_guess, sizedata_guess, n, work_mutable)
1325 ELSE
1326 ! Does not apply to DBM.
1327 END IF
1328 END SUBROUTINE dbcsr_work_create
1329
1330! **************************************************************************************************
1331!> \brief ...
1332!> \param matrix_a ...
1333!> \param matrix_b ...
1334!> \param RESULT ...
1335! **************************************************************************************************
1336 SUBROUTINE dbcsr_dot_threadsafe(matrix_a, matrix_b, RESULT)
1337 TYPE(dbcsr_type), INTENT(IN) :: matrix_a, matrix_b
1338 REAL(kind=dp), INTENT(INOUT) :: result
1339
1340 IF (use_dbcsr_backend) THEN
1341 CALL dbcsr_dot_prv(matrix_a%dbcsr, matrix_b%dbcsr, result)
1342 ELSE
1343 cpabort("Not yet implemented for DBM.")
1344 END IF
1345 END SUBROUTINE dbcsr_dot_threadsafe
1346
1347END MODULE cp_dbcsr_api
subroutine, public dbcsr_verify_matrix(matrix, verbosity, local)
...
subroutine, public dbcsr_transposed(transposed, normal, shallow_data_copy, transpose_distribution, use_distribution)
...
subroutine, public dbcsr_distribution_release(dist)
...
logical function, public dbcsr_has_symmetry(matrix)
...
subroutine, public dbcsr_release_p(matrix)
...
integer function, public dbcsr_get_data_size(matrix)
...
subroutine, public dbcsr_get_readonly_block_p(matrix, row, col, block, found, row_size, col_size)
Like dbcsr_get_block_p() but with matrix being INTENT(IN). When invoking this routine,...
subroutine, public dbcsr_scale(matrix, alpha_scalar)
...
subroutine, public dbcsr_convert_dbcsr_to_csr(dbcsr_mat, csr_mat)
...
subroutine, public dbcsr_distribution_new(dist, template, group, pgrid, row_dist, col_dist, reuse_arrays)
...
subroutine, public dbcsr_deallocate_matrix(matrix)
...
character function, public dbcsr_get_matrix_type(matrix)
...
logical function, public dbcsr_iterator_blocks_left(iterator)
...
subroutine, public dbcsr_distribution_hold(dist)
...
subroutine, public dbcsr_iterator_stop(iterator)
...
subroutine, public dbcsr_convert_csr_to_dbcsr(dbcsr_mat, csr_mat)
...
logical function, public dbcsr_valid_index(matrix)
...
subroutine, public dbcsr_desymmetrize(matrix_a, matrix_b)
...
subroutine, public dbcsr_copy(matrix_b, matrix_a, name, keep_sparsity, keep_imaginary)
...
subroutine, public dbcsr_get_block_p(matrix, row, col, block, found, row_size, col_size)
...
subroutine, public dbcsr_multiply(transa, transb, alpha, matrix_a, matrix_b, beta, matrix_c, first_row, last_row, first_column, last_column, first_k, last_k, retain_sparsity, filter_eps, flop)
...
subroutine, public dbcsr_replicate_all(matrix)
...
subroutine, public dbcsr_get_info(matrix, nblkrows_total, nblkcols_total, nfullrows_total, nfullcols_total, nblkrows_local, nblkcols_local, nfullrows_local, nfullcols_local, my_prow, my_pcol, local_rows, local_cols, proc_row_dist, proc_col_dist, row_blk_size, col_blk_size, row_blk_offset, col_blk_offset, distribution, name, matrix_type, group)
...
subroutine, public dbcsr_reserve_blocks(matrix, rows, cols)
...
subroutine, public dbcsr_get_stored_coordinates(matrix, row, column, processor)
...
subroutine, public dbcsr_csr_create_and_convert_complex(rmatrix, imatrix, csr_mat, dist_format)
Combines csr_create_from_dbcsr and convert_dbcsr_to_csr to produce a complex CSR matrix.
subroutine, public dbcsr_init_p(matrix)
...
subroutine, public dbcsr_csr_create_from_dbcsr(dbcsr_mat, csr_mat, dist_format, csr_sparsity, numnodes)
...
subroutine, public dbcsr_distribute(matrix)
...
real(kind=dp) function, dimension(:), pointer, public dbcsr_get_data_p(matrix, lb, ub)
...
subroutine, public dbcsr_work_create(matrix, nblks_guess, sizedata_guess, n, work_mutable)
...
subroutine, public dbcsr_sum_replicated(matrix)
...
subroutine, public dbcsr_iterator_next_block(iterator, row, column, block, block_number_argument_has_been_removed, row_size, col_size, row_offset, col_offset, transposed)
...
subroutine, public dbcsr_filter(matrix, eps)
...
subroutine, public dbcsr_binary_write(matrix, filepath)
...
real(kind=dp) function, public dbcsr_get_occupation(matrix)
...
subroutine, public dbcsr_dot_threadsafe(matrix_a, matrix_b, result)
...
subroutine, public dbcsr_finalize(matrix)
...
subroutine, public dbcsr_iterator_start(iterator, matrix, shared, dynamic, dynamic_byrows)
...
subroutine, public dbcsr_set(matrix, alpha)
...
subroutine, public dbcsr_release(matrix)
...
subroutine, public dbcsr_complete_redistribute(matrix, redist)
...
integer function, public dbcsr_get_num_blocks(matrix)
...
subroutine, public dbcsr_iterator_readonly_start(iterator, matrix, shared, dynamic, dynamic_byrows)
Like dbcsr_iterator_start() but with matrix being INTENT(IN). When invoking this routine,...
subroutine, public dbcsr_mp_grid_setup(dist)
...
subroutine, public dbcsr_binary_read(filepath, distribution, matrix_new)
...
subroutine, public dbcsr_clear(matrix)
...
subroutine, public dbcsr_put_block(matrix, row, col, block, summation)
...
subroutine, public dbcsr_add(matrix_a, matrix_b, alpha_scalar, beta_scalar)
...
subroutine, public dbcsr_distribution_get(dist, row_dist, col_dist, nrows, ncols, has_threads, group, mynode, numnodes, nprows, npcols, myprow, mypcol, pgrid, subgroups_defined, prow_group, pcol_group)
...
subroutine, public dbm_redistribute(matrix, redist)
Copies content of matrix_b into matrix_a. Matrices may have different distributions.
Definition dbm_api.F:414
subroutine, public dbm_zero(matrix)
Sets all blocks in the given matrix to zero.
Definition dbm_api.F:710
subroutine, public dbm_clear(matrix)
Remove all blocks from given matrix, but does not release the underlying memory.
Definition dbm_api.F:531
subroutine, public dbm_scale(matrix, alpha)
Multiplies all entries in the given matrix by the given factor alpha.
Definition dbm_api.F:679
subroutine, public dbm_create(matrix, name, dist, row_block_sizes, col_block_sizes)
Creates a new matrix.
Definition dbm_api.F:295
subroutine, public dbm_add(matrix_a, matrix_b)
Adds matrix_b to matrix_a.
Definition dbm_api.F:740
subroutine, public dbm_copy(matrix_a, matrix_b)
Copies content of matrix_b into matrix_a. Matrices must have the same row/col block sizes and distrib...
Definition dbm_api.F:382
subroutine, public dbm_distribution_new(dist, mp_comm, row_dist_block, col_dist_block)
Creates a new two dimensional distribution.
Definition dbm_api.F:1355
Defines the basic variable types.
Definition kinds.F:23
integer, parameter, public int_8
Definition kinds.F:54
integer, parameter, public dp
Definition kinds.F:34
Definition of mathematical constants and functions.
complex(kind=dp), parameter, public z_one
complex(kind=dp), parameter, public gaussi
Interface to the message passing library MPI.