16 USE omp_lib,
ONLY: omp_get_thread_num, omp_get_num_threads, omp_get_level
42#include "../base/base_uses.f90"
46 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'dbt_block'
74 INTEGER,
DIMENSION(:),
ALLOCATABLE :: sizes
75 REAL(
dp),
DIMENSION(:),
ALLOCATABLE :: blk
79 MODULE PROCEDURE create_block_data
80 MODULE PROCEDURE create_block_nodata
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
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
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
114 FUNCTION block_size(block)
115 TYPE(block_nd),
INTENT(IN) :: block
116 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: block_size
118 ALLOCATE (block_size, source=block%sizes)
119 END FUNCTION block_size
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
173 INTEGER(KIND=int_8),
DIMENSION(2) :: ind_2d
178 IF (
PRESENT(blk_size)) blk_size(:) =
get_array_elements(iterator%tensor%blk_sizes, ind_nd)
181 IF (
PRESENT(blk_offset)) blk_offset(:) =
get_array_elements(iterator%tensor%blk_offsets, ind_nd)
215 RECURSIVE SUBROUTINE dbt_reserve_blocks_index_array(tensor, blk_ind)
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'
222 CALL timeset(routinen, handle)
226 IF (.NOT. inside_team)
THEN
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), :))
242 CALL timestop(handle)
244 END SUBROUTINE dbt_reserve_blocks_index_array
255 INTEGER,
INTENT(IN) :: dimensions(2)
256 INTEGER,
INTENT(OUT) :: pattern(:, :)
261 cpassert(omp_get_level() == 0)
262 cpassert(all(dimensions >= 1) .AND. all(dimensions <=
SIZE(ind)))
264 cpassert(all(shape(pattern) == nblks(dimensions)))
271 pattern(ind(dimensions(1)), ind(dimensions(2))) = 1
275 CALL tensor%pgrid%mp_comm_2d%max(pattern)
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
290 INTEGER,
DIMENSION(ndims_tensor(tensor)) :: iblk_nd, ind_nd, nblk_tmp
291 CHARACTER(LEN=*),
PARAMETER :: routineN =
'dbt_reserve_blocks_index'
293 CALL timeset(routinen, handle)
294 cpassert(tensor%valid)
297 blk_ind_1, blk_ind_2, blk_ind_3, blk_ind_4)
301 ALLOCATE (cols(nblk), rows(nblk))
306 rows(iblk) = ind_2d(1); cols(iblk) = ind_2d(2)
311 CALL timestop(handle)
312 END SUBROUTINE dbt_reserve_blocks_index
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
323 CHARACTER(LEN=*),
PARAMETER :: routineN =
'dbt_reserve_blocks_template'
326 INTEGER :: handle, nblk, iblk
327 INTEGER,
DIMENSION(:, :),
ALLOCATABLE :: blk_ind
329 CALL timeset(routinen, handle)
345 CALL timestop(handle)
346 END SUBROUTINE dbt_reserve_blocks_template
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
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
362 CHARACTER(LEN=*),
PARAMETER :: routineN =
'dbt_reserve_blocks_matrix_to_tensor'
364 CALL timeset(routinen, handle)
367 ALLOCATE (matrix_in_desym)
370 matrix_in_desym => matrix_in
374 ALLOCATE (blk_ind_1(nblk), blk_ind_2(nblk))
378 blk_ind_1(iblk) = ind_2d(1); blk_ind_2(iblk) = ind_2d(2)
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)
393 DEALLOCATE (matrix_in_desym)
396 CALL timestop(handle)
397 END SUBROUTINE dbt_reserve_blocks_matrix_to_tensor
403 SUBROUTINE dbt_reserve_blocks_tensor_to_matrix(tensor_in, matrix_out)
404 TYPE(
dbt_type),
INTENT(IN) :: tensor_in
407 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: blk_ind_1, blk_ind_2
409 CHARACTER(LEN=*),
PARAMETER :: routineN =
'dbt_reserve_blocks_tensor_to_matrix'
410 INTEGER :: handle, iblk, nblk
411 INTEGER,
DIMENSION(2) :: ind_2d
413 CALL timeset(routinen, handle)
416 ALLOCATE (blk_ind_1(nblk), blk_ind_2(nblk))
426 IF (ind_2d(1) > ind_2d(2))
CALL swap(ind_2d(1), ind_2d(2))
430 blk_ind_1(iblk) = ind_2d(1)
431 blk_ind_2(iblk) = ind_2d(2)
440 CALL timestop(handle)
441 END SUBROUTINE dbt_reserve_blocks_tensor_to_matrix
447 ELEMENTAL SUBROUTINE swap(a, b)
448 INTEGER,
INTENT(INOUT) :: a, b
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
465 ALLOCATE (block%sizes, source=sizes)
466 ALLOCATE (block%blk, source=array)
467 END SUBROUTINE create_block_data
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
485 TYPE(
block_nd),
INTENT(INOUT) :: block
486 DEALLOCATE (block%blk)
487 DEALLOCATE (block%sizes)
503 INTEGER,
INTENT(IN) :: row, column
506 transpose = btest(column + row, 0) .EQV. column >= row
522 SUBROUTINE dbt_put_anyd_block(tensor, ind, block, summation)
524 TYPE(
dbt_type),
INTENT(INOUT) :: tensor
525 LOGICAL,
INTENT(IN),
OPTIONAL :: summation
526 INTEGER,
DIMENSION(ndims_tensor(tensor)), &
530 END SUBROUTINE dbt_put_anyd_block
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)), &
550 INTEGER,
DIMENSION(ndims_tensor(tensor)) :: blk_size
555 END SUBROUTINE dbt_get_anyd_block
568 INTEGER,
DIMENSION(ndims_tensor(tensor)),
INTENT(IN) :: ind, sizes
569 REAL(
dp),
DIMENSION(PRODUCT(sizes)),
INTENT(OUT) :: data
570 LOGICAL,
INTENT(OUT) :: found
575 CALL dbt_get_2d_block(
tensor, ind, sizes,
data, found)
577 CALL dbt_get_3d_block(
tensor, ind, sizes,
data, found)
579 CALL dbt_get_4d_block(
tensor, ind, sizes,
data, found)
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
600 CALL dbt_put_2d_block(
tensor, ind, sizes,
data, summation=summation)
602 CALL dbt_put_3d_block(
tensor, ind, sizes,
data, summation=summation)
604 CALL dbt_put_4d_block(
tensor, ind, sizes,
data, summation=summation)
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
624 INTEGER(KIND=int_8),
DIMENSION(2) :: ind_2d
625 REAL(
dp),
DIMENSION(:, :),
POINTER,
CONTIGUOUS :: block_2d
630 IF (
ASSOCIATED(block_2d))
THEN
631 IF (
PRESENT(ind_out))
THEN
636 CALL dbt_tas_put_block(tensor_out%matrix_rep, ind_2d(1), ind_2d(2), block_2d, summation=summation)
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
666 LOGICAL,
PARAMETER :: debug = .false.
672 CALL dbt_get_block(tensor, ind, sizes, block_check, found=found)
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)
680 shape_2d = [product(sizes(map1_2d)), product(sizes(map2_2d))]
682 IF (all([map1_2d, map2_2d] == [(i, i=1, 2)]))
THEN
684 block_2d(1:shape_2d(1), 1:shape_2d(2)) => block(:,:)
687 ALLOCATE (block_2d(shape_2d(1), shape_2d(2)))
689 shape_nd(map_nd) = sizes
690 block_2d(:, :) = reshape(reshape(block, shape=shape_nd, order=map_nd), shape=shape_2d)
699 IF (new_block)
DEALLOCATE (block_2d)
701 END SUBROUTINE dbt_put_2d_block
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
728 LOGICAL,
PARAMETER :: debug = .false.
734 CALL dbt_get_block(tensor, ind, sizes, block_check, found=found)
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)
742 shape_2d = [product(sizes(map1_2d)), product(sizes(map2_2d))]
744 IF (all([map1_2d, map2_2d] == [(i, i=1, 3)]))
THEN
746 block_2d(1:shape_2d(1), 1:shape_2d(2)) => block(:,:,:)
749 ALLOCATE (block_2d(shape_2d(1), shape_2d(2)))
751 shape_nd(map_nd) = sizes
752 block_2d(:, :) = reshape(reshape(block, shape=shape_nd, order=map_nd), shape=shape_2d)
755 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
759 CALL dbt_tas_put_block(
tensor%matrix_rep, ind_2d(1), ind_2d(2), block_2d, summation=summation)
761 IF (new_block)
DEALLOCATE (block_2d)
763 END SUBROUTINE dbt_put_3d_block
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
790 LOGICAL,
PARAMETER :: debug = .false.
796 CALL dbt_get_block(tensor, ind, sizes, block_check, found=found)
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)
804 shape_2d = [product(sizes(map1_2d)), product(sizes(map2_2d))]
806 IF (all([map1_2d, map2_2d] == [(i, i=1, 4)]))
THEN
808 block_2d(1:shape_2d(1), 1:shape_2d(2)) => block(:,:,:,:)
811 ALLOCATE (block_2d(shape_2d(1), shape_2d(2)))
813 shape_nd(map_nd) = sizes
814 block_2d(:, :) = reshape(reshape(block, shape=shape_nd, order=map_nd), shape=shape_2d)
817 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
821 CALL dbt_tas_put_block(
tensor%matrix_rep, ind_2d(1), ind_2d(2), block_2d, summation=summation)
823 IF (new_block)
DEALLOCATE (block_2d)
825 END SUBROUTINE dbt_put_4d_block
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
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)
851 END SUBROUTINE dbt_allocate_and_get_2d_block
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
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)
876 END SUBROUTINE dbt_allocate_and_get_3d_block
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
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)
901 END SUBROUTINE dbt_allocate_and_get_4d_block
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)), &
917 LOGICAL,
INTENT(OUT) :: found
919 INTEGER(KIND=int_8),
DIMENSION(2) :: ind_2d
920 REAL(dp),
DIMENSION(:, :),
POINTER,
CONTIGUOUS :: block_2d_ptr
922 REAL(dp),
DIMENSION(:,:),
POINTER :: block_ptr
924 NULLIFY (block_2d_ptr)
926 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
928 associate(map1_2d => tensor%nd_index_blk%map1_2d, &
929 map2_2d => tensor%nd_index_blk%map2_2d)
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)
935 IF (all([map1_2d, map2_2d] == [(i, i=1, 2)]))
THEN
937 block_ptr(lbound(block, 1):ubound(block, 1), lbound(block, 2):ubound(block, 2)) => block_2d_ptr(:, :)
938 block(:,:) = block_ptr(:,:)
941 block(:,:) = reshape(block_2d_ptr, shape=shape(block), order=[map1_2d, map2_2d])
947 END SUBROUTINE dbt_get_2d_block
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)), &
962 LOGICAL,
INTENT(OUT) :: found
964 INTEGER(KIND=int_8),
DIMENSION(2) :: ind_2d
965 REAL(dp),
DIMENSION(:, :),
POINTER,
CONTIGUOUS :: block_2d_ptr
967 REAL(dp),
DIMENSION(:,:,:),
POINTER :: block_ptr
969 NULLIFY (block_2d_ptr)
971 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
973 associate(map1_2d => tensor%nd_index_blk%map1_2d, &
974 map2_2d => tensor%nd_index_blk%map2_2d)
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)
980 IF (all([map1_2d, map2_2d] == [(i, i=1, 3)]))
THEN
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(:,:,:)
987 block(:,:,:) = reshape(block_2d_ptr, shape=shape(block), order=[map1_2d, map2_2d])
993 END SUBROUTINE dbt_get_3d_block
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
1010 INTEGER(KIND=int_8),
DIMENSION(2) :: ind_2d
1011 REAL(dp),
DIMENSION(:, :),
POINTER,
CONTIGUOUS :: block_2d_ptr
1013 REAL(dp),
DIMENSION(:,:,:,:),
POINTER :: block_ptr
1015 NULLIFY (block_2d_ptr)
1017 ind_2d(:) = get_2d_indices_tensor(tensor%nd_index_blk, ind)
1019 associate(map1_2d => tensor%nd_index_blk%map1_2d, &
1020 map2_2d => tensor%nd_index_blk%map2_2d)
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)
1026 IF (all([map1_2d, map2_2d] == [(i, i=1, 4)]))
THEN
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(:,:,:,:)
1033 block(:,:,:,:) = reshape(block_2d_ptr, shape=shape(block), order=[map1_2d, map2_2d])
1039 END SUBROUTINE dbt_get_4d_block
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.
elemental logical function, public checker_tr(row, column)
Determines whether a transpose must be applied.
subroutine, public dbt_get_block_pattern(tensor, dimensions, pattern)
Collect the global stored-block pattern projected onto two tensor dimensions. Called outside an OpenM...
integer function, public dbt_iterator_num_blocks(iterator)
Generalization of block_iterator_num_blocks for tensors.
logical function, public dbt_iterator_blocks_left(iterator)
Generalization of block_iterator_blocks_left for tensors.
subroutine, public destroy_block(block)
pure integer function, public ndims_iterator(iterator)
Number of dimensions.
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...
subroutine, public dbt_iterator_stop(iterator)
Generalization of block_iterator_stop for tensors.
subroutine, public dbt_iterator_start(iterator, tensor)
Generalization of block_iterator_start for tensors.
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...
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_...
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,...
tensor index and mapping to DBM index
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.
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.
pure integer function, public ndims_mapping(map)
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.
subroutine, public destroy_nd_to_2d_mapping(map)
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.
subroutine, public dbt_blk_sizes(tensor, ind, blk_size)
Size of tensor block.
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.
pure integer function, public ndims_tensor(tensor)
tensor rank
pure integer function, public dbt_get_num_blocks(tensor)
As block_get_num_blocks: get number of local blocks.
subroutine, public dbt_finalize(tensor)
Finalize tensor, as block_finalize. This should be taken care of internally in DBT tensors,...
pure integer(int_8) function, public ndims_matrix_row(tensor)
how many tensor dimensions are mapped to matrix row
pure integer(int_8) function, public ndims_matrix_column(tensor)
how many tensor dimensions are mapped to matrix column
Defines the basic variable types.
integer, parameter, public int_8
integer, parameter, public dp
All kind of helpful little routines.
pure integer function, dimension(2), public get_limit(m, n, me)
divide m entries into n parts, return size of part me