(git:27c966b)
Loading...
Searching...
No Matches
dbt_block.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
8! **************************************************************************************************
9!> \brief Methods to operate on n-dimensional tensor blocks.
10!> \author Patrick Seewald
11! **************************************************************************************************
13
14
15
16 USE omp_lib, ONLY: omp_get_thread_num, omp_get_num_threads, omp_get_level
17 USE util, ONLY: get_limit
18 USE cp_dbcsr_api, ONLY: &
23 USE dbt_allocate_wrap, ONLY: &
25 USE dbt_tas_types, ONLY: &
27 USE dbt_tas_base, ONLY: &
31 USE kinds, ONLY: dp, int_8, dp
32 USE dbt_index, ONLY: &
35 USE dbt_array_list_methods, ONLY: &
38 USE dbt_types, ONLY: &
41
42#include "../base/base_uses.f90"
43
44 IMPLICIT NONE
45 PRIVATE
46 CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'dbt_block'
47
48 PUBLIC :: &
50 block_nd, &
62 checker_tr, &
67
69 TYPE(dbt_tas_iterator) :: iter
70 TYPE(dbt_type), POINTER :: tensor => null()
71 END TYPE dbt_iterator_type
72
74 INTEGER, DIMENSION(:), ALLOCATABLE :: sizes
75 REAL(dp), DIMENSION(:), ALLOCATABLE :: blk
76 END TYPE block_nd
77
78 INTERFACE create_block
79 MODULE PROCEDURE create_block_data
80 MODULE PROCEDURE create_block_nodata
81 END INTERFACE create_block
82
83 INTERFACE dbt_put_block
84 MODULE PROCEDURE dbt_put_2d_block
85 MODULE PROCEDURE dbt_put_3d_block
86 MODULE PROCEDURE dbt_put_4d_block
87 MODULE PROCEDURE dbt_put_anyd_block
88 END INTERFACE dbt_put_block
89
90 INTERFACE dbt_get_block
91 MODULE PROCEDURE dbt_get_2d_block
92 MODULE PROCEDURE dbt_allocate_and_get_2d_block
93 MODULE PROCEDURE dbt_get_3d_block
94 MODULE PROCEDURE dbt_allocate_and_get_3d_block
95 MODULE PROCEDURE dbt_get_4d_block
96 MODULE PROCEDURE dbt_allocate_and_get_4d_block
97 MODULE PROCEDURE dbt_get_anyd_block
98 END INTERFACE dbt_get_block
99
101 MODULE PROCEDURE dbt_reserve_blocks_index
102 MODULE PROCEDURE dbt_reserve_blocks_index_array
103 MODULE PROCEDURE dbt_reserve_blocks_template
104 MODULE PROCEDURE dbt_reserve_blocks_tensor_to_matrix
105 MODULE PROCEDURE dbt_reserve_blocks_matrix_to_tensor
106 END INTERFACE dbt_reserve_blocks
107
108CONTAINS
109
110! **************************************************************************************************
111!> \brief block size
112!> \author Patrick Seewald
113! **************************************************************************************************
114 FUNCTION block_size(block)
115 TYPE(block_nd), INTENT(IN) :: block
116 INTEGER, ALLOCATABLE, DIMENSION(:) :: block_size
117
118 ALLOCATE (block_size, source=block%sizes)
119 END FUNCTION block_size
120
121! **************************************************************************************************
122!> \brief Generalization of block_iterator_start for tensors.
123!> \author Patrick Seewald
124! **************************************************************************************************
125 SUBROUTINE dbt_iterator_start(iterator, tensor)
126 TYPE(dbt_iterator_type), INTENT(OUT) :: iterator
127 TYPE(dbt_type), INTENT(IN), TARGET :: tensor
128
129 cpassert(tensor%valid)
130 CALL dbt_tas_iterator_start(iterator%iter, tensor%matrix_rep)
131 iterator%tensor => tensor
132 END SUBROUTINE dbt_iterator_start
133
134! **************************************************************************************************
135!> \brief Generalization of block_iterator_stop for tensors.
136!> \author Patrick Seewald
137! **************************************************************************************************
138 SUBROUTINE dbt_iterator_stop(iterator)
139 TYPE(dbt_iterator_type), INTENT(INOUT) :: iterator
140
141 CALL dbt_tas_iterator_stop(iterator%iter)
142 END SUBROUTINE dbt_iterator_stop
143
144! **************************************************************************************************
145!> \brief Number of dimensions.
146!> \note specification function below must be defined before it is used in
147!> the source due to a bug in the IBM XL Fortran compiler (compilation fails)
148!> \author Patrick Seewald
149! **************************************************************************************************
150 PURE FUNCTION ndims_iterator(iterator)
151 TYPE(dbt_iterator_type), INTENT(IN) :: iterator
152 INTEGER :: ndims_iterator
153
154 ndims_iterator = iterator%tensor%nd_index%ndim_nd
155 END FUNCTION ndims_iterator
156
157! **************************************************************************************************
158!> \brief iterate over nd blocks of an nd rank tensor, index only (blocks must be retrieved by
159!> calling dbt_get_block on tensor).
160!> \param ind_nd nd index of block
161!> \param blk_size blk size in each dimension
162!> \param blk_offset blk offset in each dimension
163!> \author Patrick Seewald
164! **************************************************************************************************
165 SUBROUTINE dbt_iterator_next_block(iterator, ind_nd, blk_size, blk_offset)
166 !!
167 TYPE(dbt_iterator_type), INTENT(INOUT) :: iterator
168 INTEGER, DIMENSION(ndims_iterator(iterator)), &
169 INTENT(OUT) :: ind_nd
170 INTEGER, DIMENSION(ndims_iterator(iterator)), &
171 INTENT(OUT), OPTIONAL :: blk_size, blk_offset
172
173 INTEGER(KIND=int_8), DIMENSION(2) :: ind_2d
174
175 CALL dbt_tas_iterator_next_block(iterator%iter, ind_2d(1), ind_2d(2))
176
177 ind_nd(:) = get_nd_indices_tensor(iterator%tensor%nd_index_blk, ind_2d)
178 IF (PRESENT(blk_size)) blk_size(:) = get_array_elements(iterator%tensor%blk_sizes, ind_nd)
179 ! note: blk_offset needs to be determined by tensor metadata, can not be derived from 2d row/col
180 ! offset since block index mapping is not consistent with element index mapping
181 IF (PRESENT(blk_offset)) blk_offset(:) = get_array_elements(iterator%tensor%blk_offsets, ind_nd)
182
183 END SUBROUTINE dbt_iterator_next_block
184
185! **************************************************************************************************
186!> \brief Generalization of block_iterator_num_blocks for tensors.
187!> \author Ole Schuett
188! **************************************************************************************************
189 FUNCTION dbt_iterator_num_blocks(iterator)
190 TYPE(dbt_iterator_type), INTENT(IN) :: iterator
191 INTEGER :: dbt_iterator_num_blocks
192
194
195 END FUNCTION dbt_iterator_num_blocks
196
197! **************************************************************************************************
198!> \brief Generalization of block_iterator_blocks_left for tensors.
199!> \author Patrick Seewald
200! **************************************************************************************************
201 FUNCTION dbt_iterator_blocks_left(iterator)
202 TYPE(dbt_iterator_type), INTENT(IN) :: iterator
203 LOGICAL :: dbt_iterator_blocks_left
204
206
207 END FUNCTION dbt_iterator_blocks_left
208
209! **************************************************************************************************
210!> \brief reserve blocks from indices as array object
211!> A serial caller starts an OpenMP team internally. An existing team calls collectively,
212!> with each thread providing its own part of the block list.
213!> \author Patrick Seewald
214! **************************************************************************************************
215 RECURSIVE SUBROUTINE dbt_reserve_blocks_index_array(tensor, blk_ind)
216 TYPE(dbt_type), INTENT(INOUT) :: tensor
217 INTEGER, DIMENSION(:, :), INTENT(IN) :: blk_ind
218 INTEGER :: handle, block_range(2)
219 LOGICAL :: inside_team
220 CHARACTER(LEN=*), PARAMETER :: routinen = 'dbt_reserve_blocks_index_array'
221
222 CALL timeset(routinen, handle)
223 ! The array interface accepts a serial caller and keeps collective team calls intact.
224 inside_team = .true.
225!$ inside_team = omp_get_level() > 0
226 IF (.NOT. inside_team) THEN
227!$OMP PARALLEL DEFAULT(NONE) SHARED(tensor,blk_ind) PRIVATE(block_range)
228 block_range = get_limit(SIZE(blk_ind, 1), omp_get_num_threads(), omp_get_thread_num())
229 CALL dbt_reserve_blocks_index_array(tensor, blk_ind(block_range(1):block_range(2), :))
230!$OMP END PARALLEL
231 ELSE
232 IF (ndims_tensor(tensor) == 2) THEN
233 CALL dbt_reserve_blocks(tensor, blk_ind(:,1), blk_ind(:,2))
234 END IF
235 IF (ndims_tensor(tensor) == 3) THEN
236 CALL dbt_reserve_blocks(tensor, blk_ind(:,1), blk_ind(:,2), blk_ind(:,3))
237 END IF
238 IF (ndims_tensor(tensor) == 4) THEN
239 CALL dbt_reserve_blocks(tensor, blk_ind(:,1), blk_ind(:,2), blk_ind(:,3), blk_ind(:,4))
240 END IF
241 END IF
242 CALL timestop(handle)
243
244 END SUBROUTINE dbt_reserve_blocks_index_array
245
246! **************************************************************************************************
247!> \brief Collect the global stored-block pattern projected onto two tensor dimensions.
248!> Called outside an OpenMP team; iteration and reduction are internal.
249!> \param tensor source tensor
250!> \param dimensions tensor dimensions retained in the projection
251!> \param pattern output pattern, one for present entries and zero otherwise
252! **************************************************************************************************
253 SUBROUTINE dbt_get_block_pattern(tensor, dimensions, pattern)
254 TYPE(dbt_type), INTENT(IN) :: tensor
255 INTEGER, INTENT(IN) :: dimensions(2)
256 INTEGER, INTENT(OUT) :: pattern(:, :)
257
258 INTEGER :: ind(ndims_tensor(tensor)), nblks(ndims_tensor(tensor))
259 TYPE(dbt_iterator_type) :: iter
260
261 cpassert(omp_get_level() == 0)
262 cpassert(all(dimensions >= 1) .AND. all(dimensions <= SIZE(ind)))
263 CALL dbt_get_info(tensor, nblks_total=nblks)
264 cpassert(all(shape(pattern) == nblks(dimensions)))
265 pattern = 0
266!$OMP PARALLEL DEFAULT(NONE) SHARED(tensor,dimensions,pattern) PRIVATE(iter,ind)
267 CALL dbt_iterator_start(iter, tensor)
268 DO WHILE (dbt_iterator_blocks_left(iter))
269 CALL dbt_iterator_next_block(iter, ind)
270!$OMP ATOMIC WRITE
271 pattern(ind(dimensions(1)), ind(dimensions(2))) = 1
272 END DO
273 CALL dbt_iterator_stop(iter)
274!$OMP END PARALLEL
275 CALL tensor%pgrid%mp_comm_2d%max(pattern)
276 END SUBROUTINE dbt_get_block_pattern
277
278! **************************************************************************************************
279!> \brief reserve tensor blocks using block indices
280!> \param blk_ind index of blocks to reserve in each dimension
281!> \author Patrick Seewald
282! **************************************************************************************************
283 SUBROUTINE dbt_reserve_blocks_index(tensor, blk_ind_1, blk_ind_2, blk_ind_3, blk_ind_4)
284 TYPE(dbt_type), INTENT(INOUT) :: tensor
285 INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL :: blk_ind_1, blk_ind_2, blk_ind_3, blk_ind_4
286 INTEGER :: iblk, nblk, handle
287 INTEGER(KIND=int_8), ALLOCATABLE, DIMENSION(:) :: cols, rows
288 INTEGER(KIND=int_8), DIMENSION(2) :: ind_2d
289 TYPE(array_list) :: blks
290 INTEGER, DIMENSION(ndims_tensor(tensor)) :: iblk_nd, ind_nd, nblk_tmp
291 CHARACTER(LEN=*), PARAMETER :: routineN = 'dbt_reserve_blocks_index'
292
293 CALL timeset(routinen, handle)
294 cpassert(tensor%valid)
295
296 CALL create_array_list(blks, ndims_tensor(tensor), &
297 blk_ind_1, blk_ind_2, blk_ind_3, blk_ind_4)
298
299 nblk_tmp(:) = sizes_of_arrays(blks)
300 nblk = nblk_tmp(1)
301 ALLOCATE (cols(nblk), rows(nblk))
302 DO iblk = 1, nblk
303 iblk_nd(:) = iblk
304 ind_nd(:) = get_array_elements(blks, iblk_nd)
305 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind_nd)
306 rows(iblk) = ind_2d(1); cols(iblk) = ind_2d(2)
307 END DO
308
309 CALL dbt_tas_reserve_blocks(tensor%matrix_rep, rows=rows, columns=cols)
310 CALL dbt_finalize(tensor)
311 CALL timestop(handle)
312 END SUBROUTINE dbt_reserve_blocks_index
313
314! **************************************************************************************************
315!> \brief reserve tensor blocks using template
316!> \param tensor_in template tensor
317!> \author Patrick Seewald
318! **************************************************************************************************
319 SUBROUTINE dbt_reserve_blocks_template(tensor_in, tensor_out)
320 TYPE(dbt_type), INTENT(IN) :: tensor_in
321 TYPE(dbt_type), INTENT(INOUT) :: tensor_out
322
323 CHARACTER(LEN=*), PARAMETER :: routineN = 'dbt_reserve_blocks_template'
324
325 TYPE(dbt_iterator_type) :: iter
326 INTEGER :: handle, nblk, iblk
327 INTEGER, DIMENSION(:, :), ALLOCATABLE :: blk_ind
328
329 CALL timeset(routinen, handle)
330
331!$OMP PARALLEL DEFAULT(NONE) SHARED(tensor_in,tensor_out) &
332!$OMP PRIVATE(iter,nblk,iblk,blk_ind)
333 CALL dbt_iterator_start(iter, tensor_in)
334 nblk = dbt_iterator_num_blocks(iter)
335 ALLOCATE (blk_ind(nblk, ndims_tensor(tensor_in)))
336 DO iblk = 1, nblk
337 CALL dbt_iterator_next_block(iter, ind_nd=blk_ind(iblk, :))
338 END DO
339 cpassert(.NOT. dbt_iterator_blocks_left(iter))
340 CALL dbt_iterator_stop(iter)
341
342 CALL dbt_reserve_blocks(tensor_out, blk_ind)
343!$OMP END PARALLEL
344
345 CALL timestop(handle)
346 END SUBROUTINE dbt_reserve_blocks_template
347
348! **************************************************************************************************
349!> \brief reserve tensor blocks using matrix template
350!> \author Patrick Seewald
351! **************************************************************************************************
352 SUBROUTINE dbt_reserve_blocks_matrix_to_tensor(matrix_in, tensor_out)
353 TYPE(dbcsr_type), TARGET, INTENT(IN) :: matrix_in
354 TYPE(dbt_type), INTENT(INOUT) :: tensor_out
355 TYPE(dbcsr_type), POINTER :: matrix_in_desym
356
357 INTEGER :: iblk, nblk, nblk_per_thread, a, b
358 INTEGER, ALLOCATABLE, DIMENSION(:) :: blk_ind_1, blk_ind_2
359 INTEGER, DIMENSION(2) :: ind_2d
360 TYPE(dbcsr_iterator_type) :: iter
361 INTEGER :: handle
362 CHARACTER(LEN=*), PARAMETER :: routineN = 'dbt_reserve_blocks_matrix_to_tensor'
363
364 CALL timeset(routinen, handle)
365
366 IF (dbcsr_has_symmetry(matrix_in)) THEN
367 ALLOCATE (matrix_in_desym)
368 CALL dbcsr_desymmetrize(matrix_in, matrix_in_desym)
369 ELSE
370 matrix_in_desym => matrix_in
371 END IF
372
373 nblk = dbcsr_get_num_blocks(matrix_in_desym)
374 ALLOCATE (blk_ind_1(nblk), blk_ind_2(nblk))
375 CALL dbcsr_iterator_start(iter, matrix_in_desym)
376 DO iblk = 1, nblk
377 CALL dbcsr_iterator_next_block(iter, ind_2d(1), ind_2d(2))
378 blk_ind_1(iblk) = ind_2d(1); blk_ind_2(iblk) = ind_2d(2)
379 END DO
380 CALL dbcsr_iterator_stop(iter)
381
382!TODO: Parallelize creation of block list.
383!$OMP PARALLEL DEFAULT(NONE) SHARED(tensor_out,nblk,blk_ind_1,blk_ind_2) &
384!$OMP PRIVATE(nblk_per_thread,a,b)
385 nblk_per_thread = nblk/omp_get_num_threads() + 1
386 a = omp_get_thread_num()*nblk_per_thread + 1
387 b = min(a + nblk_per_thread, nblk)
388 CALL dbt_reserve_blocks(tensor_out, blk_ind_1(a:b), blk_ind_2(a:b))
389!$OMP END PARALLEL
390
391 IF (dbcsr_has_symmetry(matrix_in)) THEN
392 CALL dbcsr_release(matrix_in_desym)
393 DEALLOCATE (matrix_in_desym)
394 END IF
395
396 CALL timestop(handle)
397 END SUBROUTINE dbt_reserve_blocks_matrix_to_tensor
398
399! **************************************************************************************************
400!> \brief reserve matrix blocks using tensor template
401!> \author Patrick Seewald
402! **************************************************************************************************
403 SUBROUTINE dbt_reserve_blocks_tensor_to_matrix(tensor_in, matrix_out)
404 TYPE(dbt_type), INTENT(IN) :: tensor_in
405 TYPE(dbcsr_type), INTENT(INOUT) :: matrix_out
406 TYPE(dbt_iterator_type) :: iter
407 INTEGER, ALLOCATABLE, DIMENSION(:) :: blk_ind_1, blk_ind_2
408
409 CHARACTER(LEN=*), PARAMETER :: routineN = 'dbt_reserve_blocks_tensor_to_matrix'
410 INTEGER :: handle, iblk, nblk
411 INTEGER, DIMENSION(2) :: ind_2d
412
413 CALL timeset(routinen, handle)
414
415 nblk = dbt_get_num_blocks(tensor_in)
416 ALLOCATE (blk_ind_1(nblk), blk_ind_2(nblk))
417 iblk = 0
418
419!$OMP PARALLEL DEFAULT(NONE) SHARED(tensor_in,matrix_out,iblk,blk_ind_1,blk_ind_2) &
420!$OMP PRIVATE(iter,ind_2d)
421 CALL dbt_iterator_start(iter, tensor_in)
422 DO WHILE (dbt_iterator_blocks_left(iter))
423 CALL dbt_iterator_next_block(iter, ind_2d)
424 IF (dbcsr_has_symmetry(matrix_out)) THEN
425 IF (checker_tr(ind_2d(1), ind_2d(2))) cycle
426 IF (ind_2d(1) > ind_2d(2)) CALL swap(ind_2d(1), ind_2d(2))
427 END IF
428!$OMP CRITICAL(omp_dbt_reserve_blocks_tensor_to_matrix)
429 iblk = iblk + 1
430 blk_ind_1(iblk) = ind_2d(1)
431 blk_ind_2(iblk) = ind_2d(2)
432!$OMP END CRITICAL(omp_dbt_reserve_blocks_tensor_to_matrix)
433 END DO
434 CALL dbt_iterator_stop(iter)
435!$OMP END PARALLEL
436
437 CALL dbcsr_reserve_blocks(matrix_out, blk_ind_1(:iblk), blk_ind_2(:iblk))
438 CALL dbcsr_finalize(matrix_out)
439
440 CALL timestop(handle)
441 END SUBROUTINE dbt_reserve_blocks_tensor_to_matrix
442
443! **************************************************************************************************
444!> \brief Swaps two integers
445!> \author Patrick Seewald
446! **************************************************************************************************
447 ELEMENTAL SUBROUTINE swap(a, b)
448 INTEGER, INTENT(INOUT) :: a, b
449 INTEGER :: tmp
450
451 tmp = a
452 a = b
453 b = tmp
454 END SUBROUTINE swap
455
456! **************************************************************************************************
457!> \brief Create block from array, array can be n-dimensional.
458!> \author Patrick Seewald
459! **************************************************************************************************
460 SUBROUTINE create_block_data(block, sizes, array)
461 TYPE(block_nd), INTENT(OUT) :: block
462 INTEGER, DIMENSION(:), INTENT(IN) :: sizes
463 REAL(dp), DIMENSION(PRODUCT(sizes)), INTENT(IN) :: array
464
465 ALLOCATE (block%sizes, source=sizes)
466 ALLOCATE (block%blk, source=array)
467 END SUBROUTINE create_block_data
468
469! **************************************************************************************************
470!> \brief Create and allocate block, but no data.
471!> \author Patrick Seewald
472! **************************************************************************************************
473 SUBROUTINE create_block_nodata(block, sizes)
474 INTEGER, INTENT(IN), DIMENSION(:) :: sizes
475 TYPE(block_nd), INTENT(OUT) :: block
476 ALLOCATE (block%sizes, source=sizes)
477 ALLOCATE (block%blk(product(sizes)))
478 END SUBROUTINE create_block_nodata
479
480! **************************************************************************************************
481!> \brief
482!> \author Patrick Seewald
483! **************************************************************************************************
484 SUBROUTINE destroy_block(block)
485 TYPE(block_nd), INTENT(INOUT) :: block
486 DEALLOCATE (block%blk)
487 DEALLOCATE (block%sizes)
488 END SUBROUTINE destroy_block
489
490! **************************************************************************************************
491!> \brief Determines whether a transpose must be applied
492!> \param row The absolute matrix row.
493!> \param column The absolute matrix column
494!> \param
495!> \param
496!> \param
497!> \param
498!> \param
499!> \param
500!> \author Patrick Seewald
501! **************************************************************************************************
502 ELEMENTAL FUNCTION checker_tr(row, column) RESULT(transpose)
503 INTEGER, INTENT(IN) :: row, column
504 LOGICAL :: transpose
505
506 transpose = btest(column + row, 0) .EQV. column >= row
507
508 END FUNCTION checker_tr
509
510! **************************************************************************************************
511!> \brief Generic implementation of dbt_put_block, template for datatype
512!> \param block block to put
513!> \param summation whether block should be summed to existing block
514!> \param ind block index
515!> \param
516!> \param
517!> \param
518!> \param
519!> \param
520!> \author Patrick Seewald
521! **************************************************************************************************
522 SUBROUTINE dbt_put_anyd_block(tensor, ind, block, summation)
523 TYPE(block_nd), INTENT(IN) :: block
524 TYPE(dbt_type), INTENT(INOUT) :: tensor
525 LOGICAL, INTENT(IN), OPTIONAL :: summation
526 INTEGER, DIMENSION(ndims_tensor(tensor)), &
527 INTENT(IN) :: ind
528
529 CALL dbt_put_block_data(tensor, ind, block%sizes, block%blk, summation=summation)
530 END SUBROUTINE dbt_put_anyd_block
531
532! **************************************************************************************************
533!> \brief Generic implementation of dbt_get_block (arbitrary tensor rank)
534!> \param block block to get
535!> \param found whether block was found
536!> \param ind block index
537!> \param
538!> \param
539!> \param
540!> \param
541!> \param
542!> \author Patrick Seewald
543! **************************************************************************************************
544 SUBROUTINE dbt_get_anyd_block(tensor, ind, block, found)
545 TYPE(block_nd), INTENT(OUT) :: block
546 LOGICAL, INTENT(OUT) :: found
547 TYPE(dbt_type), INTENT(INOUT) :: tensor
548 INTEGER, DIMENSION(ndims_tensor(tensor)), &
549 INTENT(IN) :: ind
550 INTEGER, DIMENSION(ndims_tensor(tensor)) :: blk_size
551
552 CALL dbt_blk_sizes(tensor, ind, blk_size)
553 CALL create_block(block, blk_size)
554 CALL dbt_get_block_data(tensor, ind, blk_size, block%blk, found)
555 END SUBROUTINE dbt_get_anyd_block
556
557! **************************************************************************************************
558!> \brief Get a block into the given contiguous data (arbitrary tensor rank), without allocating
559!> any intermediate block.
560!> \param ind block index
561!> \param sizes block size
562!> \param data block data
563!> \param found whether block was found
564!> \author Hans Pabst
565! **************************************************************************************************
566 SUBROUTINE dbt_get_block_data(tensor, ind, sizes, data, found)
567 TYPE(dbt_type), INTENT(INOUT) :: tensor
568 INTEGER, DIMENSION(ndims_tensor(tensor)), INTENT(IN) :: ind, sizes
569 REAL(dp), DIMENSION(PRODUCT(sizes)), INTENT(OUT) :: data
570 LOGICAL, INTENT(OUT) :: found
571
572 found = .false.
573 SELECT CASE (ndims_tensor(tensor))
574 CASE (2)
575 CALL dbt_get_2d_block(tensor, ind, sizes, data, found)
576 CASE (3)
577 CALL dbt_get_3d_block(tensor, ind, sizes, data, found)
578 CASE (4)
579 CALL dbt_get_4d_block(tensor, ind, sizes, data, found)
580 END SELECT
581 END SUBROUTINE dbt_get_block_data
582
583! **************************************************************************************************
584!> \brief Put a block from the given contiguous data (arbitrary tensor rank), without allocating
585!> any intermediate block.
586!> \param ind block index
587!> \param sizes block size
588!> \param data block data
589!> \param summation whether block should be summed to existing block
590!> \author Hans Pabst
591! **************************************************************************************************
592 SUBROUTINE dbt_put_block_data(tensor, ind, sizes, data, summation)
593 TYPE(dbt_type), INTENT(INOUT) :: tensor
594 INTEGER, DIMENSION(ndims_tensor(tensor)), INTENT(IN) :: ind, sizes
595 REAL(dp), DIMENSION(PRODUCT(sizes)), INTENT(IN) :: data
596 LOGICAL, INTENT(IN), OPTIONAL :: summation
597
598 SELECT CASE (ndims_tensor(tensor))
599 CASE (2)
600 CALL dbt_put_2d_block(tensor, ind, sizes, data, summation=summation)
601 CASE (3)
602 CALL dbt_put_3d_block(tensor, ind, sizes, data, summation=summation)
603 CASE (4)
604 CALL dbt_put_4d_block(tensor, ind, sizes, data, summation=summation)
605 END SELECT
606 END SUBROUTINE dbt_put_block_data
607
608! **************************************************************************************************
609!> \brief Copy a local block between tensors with the same index mapping and matching block sizes,
610!> without an intermediate copy or reshape. Both blocks must belong to the calling rank,
611!> and the tensors must have separate block storage.
612!> \param ind block index
613!> \param summation whether block should be summed to existing block
614!> \param ind_out destination block index, defaults to ind
615!> \author Hans Pabst
616! **************************************************************************************************
617 SUBROUTINE dbt_copy_block(tensor_in, tensor_out, ind, summation, ind_out)
618 TYPE(dbt_type), INTENT(INOUT) :: tensor_in, tensor_out
619 INTEGER, DIMENSION(ndims_tensor(tensor_in)), INTENT(IN) :: ind
620 LOGICAL, INTENT(IN), OPTIONAL :: summation
621 INTEGER, DIMENSION(ndims_tensor(tensor_out)), &
622 INTENT(IN), OPTIONAL :: ind_out
623
624 INTEGER(KIND=int_8), DIMENSION(2) :: ind_2d
625 REAL(dp), DIMENSION(:, :), POINTER, CONTIGUOUS :: block_2d
626
627 NULLIFY (block_2d)
628 ind_2d(:) = get_2d_indices_tensor(tensor_in%nd_index_blk, ind)
629 CALL dbt_tas_get_block_p(tensor_in%matrix_rep, ind_2d(1), ind_2d(2), block_2d)
630 IF (ASSOCIATED(block_2d)) THEN
631 IF (PRESENT(ind_out)) THEN
632 ind_2d(:) = get_2d_indices_tensor(tensor_out%nd_index_blk, ind_out)
633 ELSE
634 ind_2d(:) = get_2d_indices_tensor(tensor_out%nd_index_blk, ind)
635 END IF
636 CALL dbt_tas_put_block(tensor_out%matrix_rep, ind_2d(1), ind_2d(2), block_2d, summation=summation)
637 END IF
638 END SUBROUTINE dbt_copy_block
639
640! **************************************************************************************************
641!> \brief Template for dbt_put_block.
642!> \param ind block index
643!> \param sizes block size
644!> \param block block to put
645!> \param summation whether block should be summed to existing block
646!> \param
647!> \param
648!> \param
649!> \param
650!> \author Patrick Seewald
651! **************************************************************************************************
652 SUBROUTINE dbt_put_2d_block(tensor, ind, sizes, block, summation)
653 TYPE(dbt_type), INTENT(INOUT) :: tensor
654 INTEGER, DIMENSION(2), INTENT(IN) :: ind
655 INTEGER, DIMENSION(2), INTENT(IN) :: sizes
656 REAL(dp), DIMENSION(sizes(1), sizes(2)), &
657 INTENT(IN), TARGET :: block
658 LOGICAL, INTENT(IN), OPTIONAL :: summation
659 INTEGER(KIND=int_8), DIMENSION(2) :: ind_2d
660 INTEGER, DIMENSION(2) :: shape_2d
661 REAL(dp), POINTER, DIMENSION(:, :) :: block_2d
662 INTEGER, DIMENSION(2) :: shape_nd
663 LOGICAL :: found, new_block
664 REAL(dp), DIMENSION(sizes(1), sizes(2)) :: block_check
665
666 LOGICAL, PARAMETER :: debug = .false.
667 INTEGER :: i
668
669 new_block = .false.
670
671 IF (debug) THEN
672 CALL dbt_get_block(tensor, ind, sizes, block_check, found=found)
673 cpassert(found)
674 END IF
675
676 associate(map_nd => tensor%nd_index_blk%map_nd, &
677 map1_2d => tensor%nd_index_blk%map1_2d, &
678 map2_2d => tensor%nd_index_blk%map2_2d)
679
680 shape_2d = [product(sizes(map1_2d)), product(sizes(map2_2d))]
681
682 IF (all([map1_2d, map2_2d] == [(i, i=1, 2)])) THEN
683 ! to avoid costly reshape can do pointer bounds remapping as long as arrays are equivalent in memory
684 block_2d(1:shape_2d(1), 1:shape_2d(2)) => block(:,:)
685 ELSE
686 ! need reshape due to rank reordering
687 ALLOCATE (block_2d(shape_2d(1), shape_2d(2)))
688 new_block = .true.
689 shape_nd(map_nd) = sizes
690 block_2d(:, :) = reshape(reshape(block, shape=shape_nd, order=map_nd), shape=shape_2d)
691 END IF
692
693 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
694
695 END associate
696
697 CALL dbt_tas_put_block(tensor%matrix_rep, ind_2d(1), ind_2d(2), block_2d, summation=summation)
698
699 IF (new_block) DEALLOCATE (block_2d)
700
701 END SUBROUTINE dbt_put_2d_block
702! **************************************************************************************************
703!> \brief Template for dbt_put_block.
704!> \param ind block index
705!> \param sizes block size
706!> \param block block to put
707!> \param summation whether block should be summed to existing block
708!> \param
709!> \param
710!> \param
711!> \param
712!> \author Patrick Seewald
713! **************************************************************************************************
714 SUBROUTINE dbt_put_3d_block(tensor, ind, sizes, block, summation)
715 TYPE(dbt_type), INTENT(INOUT) :: tensor
716 INTEGER, DIMENSION(3), INTENT(IN) :: ind
717 INTEGER, DIMENSION(3), INTENT(IN) :: sizes
718 REAL(dp), DIMENSION(sizes(1), sizes(2), sizes(3)), &
719 INTENT(IN), TARGET :: block
720 LOGICAL, INTENT(IN), OPTIONAL :: summation
721 INTEGER(KIND=int_8), DIMENSION(2) :: ind_2d
722 INTEGER, DIMENSION(2) :: shape_2d
723 REAL(dp), POINTER, DIMENSION(:, :) :: block_2d
724 INTEGER, DIMENSION(3) :: shape_nd
725 LOGICAL :: found, new_block
726 REAL(dp), DIMENSION(sizes(1), sizes(2), sizes(3)) :: block_check
727
728 LOGICAL, PARAMETER :: debug = .false.
729 INTEGER :: i
730
731 new_block = .false.
732
733 IF (debug) THEN
734 CALL dbt_get_block(tensor, ind, sizes, block_check, found=found)
735 cpassert(found)
736 END IF
737
738 associate(map_nd => tensor%nd_index_blk%map_nd, &
739 map1_2d => tensor%nd_index_blk%map1_2d, &
740 map2_2d => tensor%nd_index_blk%map2_2d)
741
742 shape_2d = [product(sizes(map1_2d)), product(sizes(map2_2d))]
743
744 IF (all([map1_2d, map2_2d] == [(i, i=1, 3)])) THEN
745 ! to avoid costly reshape can do pointer bounds remapping as long as arrays are equivalent in memory
746 block_2d(1:shape_2d(1), 1:shape_2d(2)) => block(:,:,:)
747 ELSE
748 ! need reshape due to rank reordering
749 ALLOCATE (block_2d(shape_2d(1), shape_2d(2)))
750 new_block = .true.
751 shape_nd(map_nd) = sizes
752 block_2d(:, :) = reshape(reshape(block, shape=shape_nd, order=map_nd), shape=shape_2d)
753 END IF
754
755 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
756
757 END associate
758
759 CALL dbt_tas_put_block(tensor%matrix_rep, ind_2d(1), ind_2d(2), block_2d, summation=summation)
760
761 IF (new_block) DEALLOCATE (block_2d)
762
763 END SUBROUTINE dbt_put_3d_block
764! **************************************************************************************************
765!> \brief Template for dbt_put_block.
766!> \param ind block index
767!> \param sizes block size
768!> \param block block to put
769!> \param summation whether block should be summed to existing block
770!> \param
771!> \param
772!> \param
773!> \param
774!> \author Patrick Seewald
775! **************************************************************************************************
776 SUBROUTINE dbt_put_4d_block(tensor, ind, sizes, block, summation)
777 TYPE(dbt_type), INTENT(INOUT) :: tensor
778 INTEGER, DIMENSION(4), INTENT(IN) :: ind
779 INTEGER, DIMENSION(4), INTENT(IN) :: sizes
780 REAL(dp), DIMENSION(sizes(1), sizes(2), sizes(3), sizes(4)), &
781 INTENT(IN), TARGET :: block
782 LOGICAL, INTENT(IN), OPTIONAL :: summation
783 INTEGER(KIND=int_8), DIMENSION(2) :: ind_2d
784 INTEGER, DIMENSION(2) :: shape_2d
785 REAL(dp), POINTER, DIMENSION(:, :) :: block_2d
786 INTEGER, DIMENSION(4) :: shape_nd
787 LOGICAL :: found, new_block
788 REAL(dp), DIMENSION(sizes(1), sizes(2), sizes(3), sizes(4)) :: block_check
789
790 LOGICAL, PARAMETER :: debug = .false.
791 INTEGER :: i
792
793 new_block = .false.
794
795 IF (debug) THEN
796 CALL dbt_get_block(tensor, ind, sizes, block_check, found=found)
797 cpassert(found)
798 END IF
799
800 associate(map_nd => tensor%nd_index_blk%map_nd, &
801 map1_2d => tensor%nd_index_blk%map1_2d, &
802 map2_2d => tensor%nd_index_blk%map2_2d)
803
804 shape_2d = [product(sizes(map1_2d)), product(sizes(map2_2d))]
805
806 IF (all([map1_2d, map2_2d] == [(i, i=1, 4)])) THEN
807 ! to avoid costly reshape can do pointer bounds remapping as long as arrays are equivalent in memory
808 block_2d(1:shape_2d(1), 1:shape_2d(2)) => block(:,:,:,:)
809 ELSE
810 ! need reshape due to rank reordering
811 ALLOCATE (block_2d(shape_2d(1), shape_2d(2)))
812 new_block = .true.
813 shape_nd(map_nd) = sizes
814 block_2d(:, :) = reshape(reshape(block, shape=shape_nd, order=map_nd), shape=shape_2d)
815 END IF
816
817 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
818
819 END associate
820
821 CALL dbt_tas_put_block(tensor%matrix_rep, ind_2d(1), ind_2d(2), block_2d, summation=summation)
822
823 IF (new_block) DEALLOCATE (block_2d)
824
825 END SUBROUTINE dbt_put_4d_block
826
827! **************************************************************************************************
828!> \brief allocate and get block
829!> \param ind block index
830!> \param block block to get
831!> \param found whether block was found
832!> \param
833!> \param
834!> \param
835!> \param
836!> \param
837!> \author Patrick Seewald
838! **************************************************************************************************
839 SUBROUTINE dbt_allocate_and_get_2d_block(tensor, ind, block, found)
840 TYPE(dbt_type), INTENT(INOUT) :: tensor
841 INTEGER, DIMENSION(2), INTENT(IN) :: ind
842 REAL(dp), DIMENSION(:,:), &
843 ALLOCATABLE, INTENT(OUT) :: block
844 LOGICAL, INTENT(OUT) :: found
845 INTEGER, DIMENSION(2) :: blk_size
846
847 CALL dbt_blk_sizes(tensor, ind, blk_size)
848 CALL allocate_any(block, shape_spec=blk_size)
849 CALL dbt_get_2d_block(tensor, ind, blk_size, block, found)
850
851 END SUBROUTINE dbt_allocate_and_get_2d_block
852! **************************************************************************************************
853!> \brief allocate and get block
854!> \param ind block index
855!> \param block block to get
856!> \param found whether block was found
857!> \param
858!> \param
859!> \param
860!> \param
861!> \param
862!> \author Patrick Seewald
863! **************************************************************************************************
864 SUBROUTINE dbt_allocate_and_get_3d_block(tensor, ind, block, found)
865 TYPE(dbt_type), INTENT(INOUT) :: tensor
866 INTEGER, DIMENSION(3), INTENT(IN) :: ind
867 REAL(dp), DIMENSION(:,:,:), &
868 ALLOCATABLE, INTENT(OUT) :: block
869 LOGICAL, INTENT(OUT) :: found
870 INTEGER, DIMENSION(3) :: blk_size
871
872 CALL dbt_blk_sizes(tensor, ind, blk_size)
873 CALL allocate_any(block, shape_spec=blk_size)
874 CALL dbt_get_3d_block(tensor, ind, blk_size, block, found)
875
876 END SUBROUTINE dbt_allocate_and_get_3d_block
877! **************************************************************************************************
878!> \brief allocate and get block
879!> \param ind block index
880!> \param block block to get
881!> \param found whether block was found
882!> \param
883!> \param
884!> \param
885!> \param
886!> \param
887!> \author Patrick Seewald
888! **************************************************************************************************
889 SUBROUTINE dbt_allocate_and_get_4d_block(tensor, ind, block, found)
890 TYPE(dbt_type), INTENT(INOUT) :: tensor
891 INTEGER, DIMENSION(4), INTENT(IN) :: ind
892 REAL(dp), DIMENSION(:,:,:,:), &
893 ALLOCATABLE, INTENT(OUT) :: block
894 LOGICAL, INTENT(OUT) :: found
895 INTEGER, DIMENSION(4) :: blk_size
896
897 CALL dbt_blk_sizes(tensor, ind, blk_size)
898 CALL allocate_any(block, shape_spec=blk_size)
899 CALL dbt_get_4d_block(tensor, ind, blk_size, block, found)
900
901 END SUBROUTINE dbt_allocate_and_get_4d_block
902
903! **************************************************************************************************
904!> \brief Template for dbt_get_block.
905!> \param ind block index
906!> \param sizes block size
907!> \param block block to get
908!> \param found whether block was found
909!> \author Patrick Seewald
910! **************************************************************************************************
911 SUBROUTINE dbt_get_2d_block(tensor, ind, sizes, block, found)
912 TYPE(dbt_type), INTENT(INOUT) :: tensor
913 INTEGER, DIMENSION(2), INTENT(IN) :: ind
914 INTEGER, DIMENSION(2), INTENT(IN) :: sizes
915 REAL(dp), DIMENSION(sizes(1), sizes(2)), &
916 INTENT(OUT) :: block
917 LOGICAL, INTENT(OUT) :: found
918
919 INTEGER(KIND=int_8), DIMENSION(2) :: ind_2d
920 REAL(dp), DIMENSION(:, :), POINTER, CONTIGUOUS :: block_2d_ptr
921 INTEGER :: i
922 REAL(dp), DIMENSION(:,:), POINTER :: block_ptr
923
924 NULLIFY (block_2d_ptr)
925
926 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
927
928 associate(map1_2d => tensor%nd_index_blk%map1_2d, &
929 map2_2d => tensor%nd_index_blk%map2_2d)
930
931 CALL dbt_tas_get_block_p(tensor%matrix_rep, ind_2d(1), ind_2d(2), block_2d_ptr)
932 found = ASSOCIATED(block_2d_ptr)
933
934 IF (found) THEN
935 IF (all([map1_2d, map2_2d] == [(i, i=1, 2)])) THEN
936 ! to avoid costly reshape can do pointer bounds remapping as long as arrays are equivalent in memory
937 block_ptr(lbound(block, 1):ubound(block, 1), lbound(block, 2):ubound(block, 2)) => block_2d_ptr(:, :)
938 block(:,:) = block_ptr(:,:)
939 ELSE
940 ! need reshape due to rank reordering
941 block(:,:) = reshape(block_2d_ptr, shape=shape(block), order=[map1_2d, map2_2d])
942 END IF
943 END IF
944
945 END associate
946
947 END SUBROUTINE dbt_get_2d_block
948! **************************************************************************************************
949!> \brief Template for dbt_get_block.
950!> \param ind block index
951!> \param sizes block size
952!> \param block block to get
953!> \param found whether block was found
954!> \author Patrick Seewald
955! **************************************************************************************************
956 SUBROUTINE dbt_get_3d_block(tensor, ind, sizes, block, found)
957 TYPE(dbt_type), INTENT(INOUT) :: tensor
958 INTEGER, DIMENSION(3), INTENT(IN) :: ind
959 INTEGER, DIMENSION(3), INTENT(IN) :: sizes
960 REAL(dp), DIMENSION(sizes(1), sizes(2), sizes(3)), &
961 INTENT(OUT) :: block
962 LOGICAL, INTENT(OUT) :: found
963
964 INTEGER(KIND=int_8), DIMENSION(2) :: ind_2d
965 REAL(dp), DIMENSION(:, :), POINTER, CONTIGUOUS :: block_2d_ptr
966 INTEGER :: i
967 REAL(dp), DIMENSION(:,:,:), POINTER :: block_ptr
968
969 NULLIFY (block_2d_ptr)
970
971 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
972
973 associate(map1_2d => tensor%nd_index_blk%map1_2d, &
974 map2_2d => tensor%nd_index_blk%map2_2d)
975
976 CALL dbt_tas_get_block_p(tensor%matrix_rep, ind_2d(1), ind_2d(2), block_2d_ptr)
977 found = ASSOCIATED(block_2d_ptr)
978
979 IF (found) THEN
980 IF (all([map1_2d, map2_2d] == [(i, i=1, 3)])) THEN
981 ! to avoid costly reshape can do pointer bounds remapping as long as arrays are equivalent in memory
982 block_ptr(lbound(block, 1):ubound(block, 1), lbound(block, 2):ubound(block, 2), lbound(block, 3):ubound(block,&
983 & 3)) => block_2d_ptr(:, :)
984 block(:,:,:) = block_ptr(:,:,:)
985 ELSE
986 ! need reshape due to rank reordering
987 block(:,:,:) = reshape(block_2d_ptr, shape=shape(block), order=[map1_2d, map2_2d])
988 END IF
989 END IF
990
991 END associate
992
993 END SUBROUTINE dbt_get_3d_block
994! **************************************************************************************************
995!> \brief Template for dbt_get_block.
996!> \param ind block index
997!> \param sizes block size
998!> \param block block to get
999!> \param found whether block was found
1000!> \author Patrick Seewald
1001! **************************************************************************************************
1002 SUBROUTINE dbt_get_4d_block(tensor, ind, sizes, block, found)
1003 TYPE(dbt_type), INTENT(INOUT) :: tensor
1004 INTEGER, DIMENSION(4), INTENT(IN) :: ind
1005 INTEGER, DIMENSION(4), INTENT(IN) :: sizes
1006 REAL(dp), DIMENSION(sizes(1), sizes(2), sizes(3), sizes(4)), &
1007 INTENT(OUT) :: block
1008 LOGICAL, INTENT(OUT) :: found
1009
1010 INTEGER(KIND=int_8), DIMENSION(2) :: ind_2d
1011 REAL(dp), DIMENSION(:, :), POINTER, CONTIGUOUS :: block_2d_ptr
1012 INTEGER :: i
1013 REAL(dp), DIMENSION(:,:,:,:), POINTER :: block_ptr
1014
1015 NULLIFY (block_2d_ptr)
1016
1017 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
1018
1019 associate(map1_2d => tensor%nd_index_blk%map1_2d, &
1020 map2_2d => tensor%nd_index_blk%map2_2d)
1021
1022 CALL dbt_tas_get_block_p(tensor%matrix_rep, ind_2d(1), ind_2d(2), block_2d_ptr)
1023 found = ASSOCIATED(block_2d_ptr)
1024
1025 IF (found) THEN
1026 IF (all([map1_2d, map2_2d] == [(i, i=1, 4)])) THEN
1027 ! to avoid costly reshape can do pointer bounds remapping as long as arrays are equivalent in memory
1028 block_ptr(lbound(block, 1):ubound(block, 1), lbound(block, 2):ubound(block, 2), lbound(block, 3):ubound(block,&
1029 & 3), lbound(block, 4):ubound(block, 4)) => block_2d_ptr(:, :)
1030 block(:,:,:,:) = block_ptr(:,:,:,:)
1031 ELSE
1032 ! need reshape due to rank reordering
1033 block(:,:,:,:) = reshape(block_2d_ptr, shape=shape(block), order=[map1_2d, map2_2d])
1034 END IF
1035 END IF
1036
1037 END associate
1038
1039 END SUBROUTINE dbt_get_4d_block
1040
1041END MODULE dbt_block
struct tensor_ tensor
logical function, public dbcsr_has_symmetry(matrix)
...
logical function, public dbcsr_iterator_blocks_left(iterator)
...
subroutine, public dbcsr_iterator_stop(iterator)
...
subroutine, public dbcsr_desymmetrize(matrix_a, matrix_b)
...
subroutine, public dbcsr_reserve_blocks(matrix, rows, cols)
...
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_finalize(matrix)
...
subroutine, public dbcsr_iterator_start(iterator, matrix, shared, dynamic, dynamic_byrows)
...
subroutine, public dbcsr_release(matrix)
...
integer function, public dbcsr_get_num_blocks(matrix)
...
Wrapper for allocating, copying and reshaping arrays.
Representation of arbitrary number of 1d integer arrays with arbitrary sizes. This is needed for gene...
subroutine, public get_arrays(list, data_1, data_2, data_3, data_4, i_selected)
Get all arrays contained in list.
subroutine, public create_array_list(list, ndata, data_1, data_2, data_3, data_4)
collects any number of arrays of different sizes into a single array (listcol_data),...
subroutine, public destroy_array_list(list)
destroy array list.
integer function, dimension(:), allocatable, public sizes_of_arrays(list)
sizes of arrays stored in list
pure integer function, dimension(number_of_arrays(list)), public get_array_elements(list, indices)
Get an element for each array.
Methods to operate on n-dimensional tensor blocks.
Definition dbt_block.F:12
elemental logical function, public checker_tr(row, column)
Determines whether a transpose must be applied.
Definition dbt_block.F:503
subroutine, public dbt_get_block_pattern(tensor, dimensions, pattern)
Collect the global stored-block pattern projected onto two tensor dimensions. Called outside an OpenM...
Definition dbt_block.F:254
integer function, public dbt_iterator_num_blocks(iterator)
Generalization of block_iterator_num_blocks for tensors.
Definition dbt_block.F:190
logical function, public dbt_iterator_blocks_left(iterator)
Generalization of block_iterator_blocks_left for tensors.
Definition dbt_block.F:202
subroutine, public destroy_block(block)
Definition dbt_block.F:485
pure integer function, public ndims_iterator(iterator)
Number of dimensions.
Definition dbt_block.F:151
subroutine, public dbt_get_block_data(tensor, ind, sizes, data, found)
Get a block into the given contiguous data (arbitrary tensor rank), without allocating any intermedia...
Definition dbt_block.F:567
subroutine, public dbt_iterator_stop(iterator)
Generalization of block_iterator_stop for tensors.
Definition dbt_block.F:139
subroutine, public dbt_iterator_start(iterator, tensor)
Generalization of block_iterator_start for tensors.
Definition dbt_block.F:126
subroutine, public dbt_put_block_data(tensor, ind, sizes, data, summation)
Put a block from the given contiguous data (arbitrary tensor rank), without allocating any intermedia...
Definition dbt_block.F:593
subroutine, public dbt_iterator_next_block(iterator, ind_nd, blk_size, blk_offset)
iterate over nd blocks of an nd rank tensor, index only (blocks must be retrieved by calling dbt_get_...
Definition dbt_block.F:166
subroutine, public dbt_copy_block(tensor_in, tensor_out, ind, summation, ind_out)
Copy a local block between tensors with the same index mapping and matching block sizes,...
Definition dbt_block.F:618
tensor index and mapping to DBM index
Definition dbt_index.F:12
subroutine, public create_nd_to_2d_mapping(map, dims, map1_2d, map2_2d, base, col_major)
Create all data needed to quickly map between nd index and 2d index.
Definition dbt_index.F:73
pure integer(kind=int_8) function, dimension(2), public get_2d_indices_tensor(map, ind_in)
transform nd index to 2d index, using info from index mapping.
Definition dbt_index.F:318
pure integer function, public ndims_mapping(map)
Definition dbt_index.F:130
pure integer function, dimension(map%ndim_nd), public get_nd_indices_tensor(map, ind_in)
transform 2d index to nd index, using info from index mapping.
Definition dbt_index.F:368
subroutine, public destroy_nd_to_2d_mapping(map)
Definition dbt_index.F:115
Tall-and-skinny matrices: base routines similar to DBM API, mostly wrappers around existing DBM routi...
integer function, public dbt_tas_iterator_num_blocks(iter)
As dbm_iterator_num_blocks.
subroutine, public dbt_tas_iterator_start(iter, matrix_in)
As dbm_iterator_start.
logical function, public dbt_tas_iterator_blocks_left(iter)
As dbm_iterator_blocks_left.
subroutine, public dbt_tas_iterator_stop(iter)
As dbm_iterator_stop.
subroutine, public dbt_tas_put_block(matrix, row, col, block, summation)
As dbm_put_block.
subroutine, public dbt_tas_get_block_p(matrix, row, col, block, row_size, col_size)
As dbm_get_block_p.
DBT tall-and-skinny base types. Mostly wrappers around existing DBM routines.
DBT tensor framework for block-sparse tensor contraction: Types and create/destroy routines.
Definition dbt_types.F:12
subroutine, public dbt_blk_sizes(tensor, ind, blk_size)
Size of tensor block.
Definition dbt_types.F:1468
subroutine, public dbt_get_info(tensor, nblks_total, nfull_total, nblks_local, nfull_local, pdims, my_ploc, blks_local_1, blks_local_2, blks_local_3, blks_local_4, proc_dist_1, proc_dist_2, proc_dist_3, proc_dist_4, blk_size_1, blk_size_2, blk_size_3, blk_size_4, blk_offset_1, blk_offset_2, blk_offset_3, blk_offset_4, distribution, name)
As block_get_info but for tensors.
Definition dbt_types.F:1645
pure integer function, public ndims_tensor(tensor)
tensor rank
Definition dbt_types.F:1216
pure integer function, public dbt_get_num_blocks(tensor)
As block_get_num_blocks: get number of local blocks.
Definition dbt_types.F:1748
subroutine, public dbt_finalize(tensor)
Finalize tensor, as block_finalize. This should be taken care of internally in DBT tensors,...
Definition dbt_types.F:1779
pure integer(int_8) function, public ndims_matrix_row(tensor)
how many tensor dimensions are mapped to matrix row
Definition dbt_types.F:1193
pure integer(int_8) function, public ndims_matrix_column(tensor)
how many tensor dimensions are mapped to matrix column
Definition dbt_types.F:1205
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
All kind of helpful little routines.
Definition util.F:14
pure integer function, dimension(2), public get_limit(m, n, me)
divide m entries into n parts, return size of part me
Definition util.F:333