71#include "./base/base_uses.f90"
77 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'rpa_grad'
81 TYPE sos_mp2_grad_work_type
83 INTEGER,
DIMENSION(:, :),
ALLOCATABLE :: pair_list
84 TYPE(one_dim_int_array),
DIMENSION(:),
ALLOCATABLE :: index2send, index2recv
85 REAL(KIND=
dp),
DIMENSION(:),
ALLOCATABLE :: p
86 END TYPE sos_mp2_grad_work_type
88 TYPE rpa_grad_work_type
89 TYPE(cp_fm_type) :: fm_mat_Q_copy =
cp_fm_type()
90 TYPE(one_dim_int_array),
DIMENSION(:, :),
ALLOCATABLE :: index2send
91 TYPE(two_dim_int_array),
DIMENSION(:, :),
ALLOCATABLE :: index2recv
92 TYPE(group_dist_d1_type),
DIMENSION(:),
ALLOCATABLE :: gd_homo, gd_virtual
93 INTEGER,
DIMENSION(2) :: grid = -1, mepos = -1
94 TYPE(two_dim_real_array),
DIMENSION(:),
ALLOCATABLE :: P_ij, P_ab
95 END TYPE rpa_grad_work_type
101 TYPE(sos_mp2_grad_work_type),
ALLOCATABLE,
DIMENSION(:) :: sos_mp2_work_occ, sos_mp2_work_virt
102 TYPE(rpa_grad_work_type) :: rpa_work
106 INTEGER,
PARAMETER :: blksize_threshold = 4
120 PURE SUBROUTINE rpa_grad_needed_mem(homo, virtual, dimen_RI, mem_per_rank, mem_per_repl, do_ri_sos_laplace_mp2)
121 INTEGER,
DIMENSION(:),
INTENT(IN) :: homo, virtual
122 INTEGER,
INTENT(IN) :: dimen_ri
123 REAL(kind=
dp),
INTENT(INOUT) :: mem_per_rank, mem_per_repl
124 LOGICAL,
INTENT(IN) :: do_ri_sos_laplace_mp2
126 REAL(kind=
dp) :: mem_iak, mem_kl, mem_pab, mem_pij
128 mem_iak = sum(real(virtual, kind=
dp)*homo)*dimen_ri
129 mem_pij = sum(real(homo, kind=
dp)**2)
130 mem_pab = sum(real(virtual, kind=
dp)**2)
131 mem_kl = real(dimen_ri, kind=
dp)*dimen_ri
145 mem_per_rank = mem_per_rank + (mem_pij + mem_pab)*8.0_dp/(1024**2)
146 mem_per_repl = mem_per_repl + (mem_iak + 2.0_dp*mem_iak/
SIZE(homo) + mem_kl)*8.0_dp/(1024**2)
147 IF (.NOT. do_ri_sos_laplace_mp2)
THEN
148 mem_per_repl = mem_per_rank + (mem_iak/
SIZE(homo) + mem_kl)*8.0_dp/(1024**2)
166 homo, virtual, mp2_env, Eigenval, unit_nr, do_ri_sos_laplace_mp2)
169 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: fm_mat_s
170 INTEGER,
DIMENSION(:),
INTENT(IN) :: homo, virtual
171 TYPE(
mp2_type),
INTENT(INOUT) :: mp2_env
172 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN) :: eigenval
173 INTEGER,
INTENT(IN) :: unit_nr
174 LOGICAL,
INTENT(IN) :: do_ri_sos_laplace_mp2
176 CHARACTER(LEN=*),
PARAMETER :: routinen =
'rpa_grad_create'
178 INTEGER :: handle, ispin, nrow_local, nspins
180 CALL timeset(routinen, handle)
185 nspins =
SIZE(fm_mat_s)
192 IF (do_ri_sos_laplace_mp2)
THEN
193 CALL sos_mp2_work_type_create(
rpa_grad%sos_mp2_work_occ,
rpa_grad%sos_mp2_work_virt, &
194 unit_nr, eigenval, homo, virtual, mp2_env%ri_grad%eps_canonical, fm_mat_s)
196 CALL rpa_work_type_create(
rpa_grad%rpa_work, fm_mat_q, fm_mat_s, homo, virtual)
201 IF (mp2_env%ri_grad%dot_blksize < 1) mp2_env%ri_grad%dot_blksize = nrow_local
202 mp2_env%ri_grad%dot_blksize = min(mp2_env%ri_grad%dot_blksize, nrow_local)
203 IF (unit_nr > 0)
THEN
204 WRITE (unit_nr,
'(T3,A,T75,I6)')
'GRAD_INFO| Block size for the contraction:', mp2_env%ri_grad%dot_blksize
207 CALL fm_mat_s(1)%matrix_struct%para_env%sync()
209 CALL timestop(handle)
224 SUBROUTINE sos_mp2_work_type_create(sos_mp2_work_occ, sos_mp2_work_virt, unit_nr, &
225 Eigenval, homo, virtual, eps_degenerate, fm_mat_S)
226 TYPE(sos_mp2_grad_work_type),
ALLOCATABLE, &
227 DIMENSION(:),
INTENT(OUT) :: sos_mp2_work_occ, sos_mp2_work_virt
228 INTEGER,
INTENT(IN) :: unit_nr
229 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN) :: eigenval
230 INTEGER,
DIMENSION(:),
INTENT(IN) :: homo, virtual
231 REAL(kind=
dp),
INTENT(IN) :: eps_degenerate
232 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: fm_mat_s
234 CHARACTER(LEN=*),
PARAMETER :: routinen =
'sos_mp2_work_type_create'
236 INTEGER :: handle, ispin, nspins
238 CALL timeset(routinen, handle)
240 nspins =
SIZE(fm_mat_s)
241 ALLOCATE (sos_mp2_work_occ(nspins), sos_mp2_work_virt(nspins))
244 CALL create_list_nearly_degen_pairs(eigenval(1:homo(ispin), ispin), &
245 eps_degenerate, sos_mp2_work_occ(ispin)%pair_list)
246 IF (unit_nr > 0)
WRITE (unit_nr,
"(T3,A,T75,i6)") &
247 "MO_INFO| Number of ij pairs below EPS_CANONICAL:",
SIZE(sos_mp2_work_occ(ispin)%pair_list, 2)
248 ALLOCATE (sos_mp2_work_occ(ispin)%P(homo(ispin) +
SIZE(sos_mp2_work_occ(ispin)%pair_list, 2)))
249 sos_mp2_work_occ(ispin)%P = 0.0_dp
250 CALL prepare_comm_pij(sos_mp2_work_occ(ispin), virtual(ispin), fm_mat_s(ispin))
252 CALL create_list_nearly_degen_pairs(eigenval(homo(ispin) + 1:, ispin), &
253 eps_degenerate, sos_mp2_work_virt(ispin)%pair_list)
254 IF (unit_nr > 0)
WRITE (unit_nr,
"(T3,A,T75,i6)") &
255 "MO_INFO| Number of ab pairs below EPS_CANONICAL:",
SIZE(sos_mp2_work_virt(ispin)%pair_list, 2)
256 ALLOCATE (sos_mp2_work_virt(ispin)%P(virtual(ispin) +
SIZE(sos_mp2_work_virt(ispin)%pair_list, 2)))
257 sos_mp2_work_virt(ispin)%P = 0.0_dp
258 CALL prepare_comm_pab(sos_mp2_work_virt(ispin), virtual(ispin), fm_mat_s(ispin))
261 CALL timestop(handle)
263 END SUBROUTINE sos_mp2_work_type_create
273 SUBROUTINE rpa_work_type_create(rpa_work, fm_mat_Q, fm_mat_S, homo, virtual)
274 TYPE(rpa_grad_work_type),
INTENT(OUT) :: rpa_work
276 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: fm_mat_s
277 INTEGER,
DIMENSION(:),
INTENT(IN) :: homo, virtual
279 CHARACTER(LEN=*),
PARAMETER :: routinen =
'rpa_work_type_create'
281 INTEGER :: avirt, col_global, col_local, handle, iocc, ispin, my_a, my_a_end, my_a_size, &
282 my_a_start, my_i, my_i_end, my_i_size, my_i_start, my_pcol, ncol_local, nspins, &
283 num_pe_col, proc_homo, proc_homo_send, proc_recv, proc_send, proc_virtual, &
285 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: data2recv, data2send
286 INTEGER,
DIMENSION(:),
POINTER :: col_indices
288 CALL timeset(routinen, handle)
290 CALL cp_fm_create(rpa_work%fm_mat_Q_copy, matrix_struct=fm_mat_q%matrix_struct)
292 CALL fm_mat_s(1)%matrix_struct%context%get(number_of_process_columns=num_pe_col, my_process_column=my_pcol)
294 nspins =
SIZE(fm_mat_s)
296 ALLOCATE (rpa_work%index2send(0:num_pe_col - 1, nspins), &
297 rpa_work%index2recv(0:num_pe_col - 1, nspins), &
298 rpa_work%gd_homo(nspins), rpa_work%gd_virtual(nspins), &
299 data2send(0:num_pe_col - 1), data2recv(0:num_pe_col - 1), &
300 rpa_work%P_ij(nspins), rpa_work%P_ab(nspins))
303 proc_homo = max(1, ceiling(sqrt(real(num_pe_col, kind=
dp))))
304 DO WHILE (mod(num_pe_col, proc_homo) /= 0)
305 proc_homo = proc_homo - 1
307 proc_virtual = num_pe_col/proc_homo
309 rpa_work%grid(1) = proc_virtual
310 rpa_work%grid(2) = proc_homo
312 rpa_work%mepos(1) = mod(my_pcol, proc_virtual)
313 rpa_work%mepos(2) = my_pcol/proc_virtual
321 CALL cp_fm_struct_get(fm_mat_s(ispin)%matrix_struct, ncol_local=ncol_local, col_indices=col_indices)
325 DO col_local = 1, ncol_local
326 col_global = col_indices(col_local)
328 iocc = (col_global - 1)/virtual(ispin) + 1
329 avirt = col_global - (iocc - 1)*virtual(ispin)
334 proc_send = proc_homo_send*proc_virtual + proc_virtual_send
336 data2send(proc_send) = data2send(proc_send) + 1
339 DO proc_send = 0, num_pe_col - 1
340 ALLOCATE (rpa_work%index2send(proc_send, ispin)%array(data2send(proc_send)))
345 DO col_local = 1, ncol_local
346 col_global = col_indices(col_local)
348 iocc = (col_global - 1)/virtual(ispin) + 1
349 avirt = col_global - (iocc - 1)*virtual(ispin)
354 proc_send = proc_homo_send*proc_virtual + proc_virtual_send
356 data2send(proc_send) = data2send(proc_send) + 1
358 rpa_work%index2send(proc_send, ispin)%array(data2send(proc_send)) = col_local
362 CALL get_group_dist(rpa_work%gd_homo(ispin), my_pcol/proc_virtual, my_i_start, my_i_end, my_i_size)
363 CALL get_group_dist(rpa_work%gd_virtual(ispin), mod(my_pcol, proc_virtual), my_a_start, my_a_end, my_a_size)
366 DO my_i = my_i_start, my_i_end
367 DO my_a = my_a_start, my_a_end
368 proc_recv = fm_mat_s(ispin)%matrix_struct%g2p_col((my_i - 1)*virtual(ispin) + my_a)
369 data2recv(proc_recv) = data2recv(proc_recv) + 1
373 DO proc_recv = 0, num_pe_col - 1
374 ALLOCATE (rpa_work%index2recv(proc_recv, ispin)%array(2, data2recv(proc_recv)))
378 DO my_i = my_i_start, my_i_end
379 DO my_a = my_a_start, my_a_end
380 proc_recv = fm_mat_s(ispin)%matrix_struct%g2p_col((my_i - 1)*virtual(ispin) + my_a)
381 data2recv(proc_recv) = data2recv(proc_recv) + 1
383 rpa_work%index2recv(proc_recv, ispin)%array(2, data2recv(proc_recv)) = my_i - my_i_start + 1
384 rpa_work%index2recv(proc_recv, ispin)%array(1, data2recv(proc_recv)) = my_a - my_a_start + 1
388 ALLOCATE (rpa_work%P_ij(ispin)%array(my_i_size, homo(ispin)), &
389 rpa_work%P_ab(ispin)%array(my_a_size, virtual(ispin)))
390 rpa_work%P_ij(ispin)%array(:, :) = 0.0_dp
391 rpa_work%P_ab(ispin)%array(:, :) = 0.0_dp
395 DEALLOCATE (data2send, data2recv)
397 CALL timestop(handle)
399 END SUBROUTINE rpa_work_type_create
407 SUBROUTINE create_list_nearly_degen_pairs(Eigenval, eps_degen, pair_list)
408 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: eigenval
409 REAL(kind=
dp),
INTENT(IN) :: eps_degen
410 INTEGER,
ALLOCATABLE,
DIMENSION(:, :),
INTENT(OUT) :: pair_list
412 INTEGER :: my_i, my_j, num_orbitals, num_pairs, &
415 num_orbitals =
SIZE(eigenval)
420 DO my_i = 1, num_orbitals
421 DO my_j = 1, num_orbitals
422 IF (my_i == my_j) cycle
423 IF (abs(eigenval(my_i) - eigenval(my_j)) < eps_degen) num_pairs = num_pairs + 1
426 ALLOCATE (pair_list(2, num_pairs))
430 DO my_i = 1, num_orbitals
431 DO my_j = 1, num_orbitals
432 IF (my_i == my_j) cycle
433 IF (abs(eigenval(my_i) - eigenval(my_j)) < eps_degen)
THEN
434 pair_list(1, pair_counter) = my_i
435 pair_list(2, pair_counter) = my_j
436 pair_counter = pair_counter + 1
441 END SUBROUTINE create_list_nearly_degen_pairs
449 SUBROUTINE prepare_comm_pij(sos_mp2_work, virtual, fm_mat_S)
450 TYPE(sos_mp2_grad_work_type),
INTENT(INOUT) :: sos_mp2_work
451 INTEGER,
INTENT(IN) :: virtual
454 CHARACTER(LEN=*),
PARAMETER :: routinen =
'prepare_comm_Pij'
456 INTEGER :: avirt, col_global, col_local, counter, handle, ij_counter, iocc, my_i, my_j, &
457 my_pcol, my_prow, ncol_local, nrow_local, num_ij_pairs, num_pe_col, pcol, pcol_recv, &
458 pcol_send, proc_shift, tag
459 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: data2recv, data2send
460 INTEGER,
DIMENSION(:),
POINTER :: col_indices, ncol_locals
461 INTEGER,
DIMENSION(:, :),
POINTER :: blacs2mpi
466 CALL timeset(routinen, handle)
470 CALL fm_mat_s%matrix_struct%context%get(number_of_process_columns=num_pe_col)
471 ALLOCATE (sos_mp2_work%index2send(0:num_pe_col - 1), &
472 sos_mp2_work%index2recv(0:num_pe_col - 1))
474 ALLOCATE (data2send(0:num_pe_col - 1))
475 ALLOCATE (data2recv(0:num_pe_col - 1))
477 CALL cp_fm_struct_get(fm_mat_s%matrix_struct, para_env=para_env, ncol_locals=ncol_locals, &
478 ncol_local=ncol_local, col_indices=col_indices, &
479 context=context, nrow_local=nrow_local)
480 CALL context%get(my_process_row=my_prow, my_process_column=my_pcol, &
483 num_ij_pairs =
SIZE(sos_mp2_work%pair_list, 2)
485 IF (num_ij_pairs > 0)
THEN
487 CALL comm_exchange%from_split(para_env, my_prow)
492 DO proc_shift = 0, num_pe_col - 1
493 pcol_send =
modulo(my_pcol + proc_shift, num_pe_col)
496 DO col_local = 1, ncol_local
497 col_global = col_indices(col_local)
499 iocc = max(1, col_global - 1)/virtual + 1
500 avirt = col_global - (iocc - 1)*virtual
502 DO ij_counter = 1, num_ij_pairs
504 my_i = sos_mp2_work%pair_list(1, ij_counter)
505 my_j = sos_mp2_work%pair_list(2, ij_counter)
507 IF (iocc /= my_j) cycle
508 pcol = fm_mat_s%matrix_struct%g2p_col((my_i - 1)*virtual + avirt)
509 IF (pcol /= pcol_send) cycle
511 counter = counter + 1
517 data2send(pcol_send) = counter
520 CALL comm_exchange%alltoall(data2send, data2recv, 1)
522 DO proc_shift = 0, num_pe_col - 1
523 pcol_send =
modulo(my_pcol + proc_shift, num_pe_col)
524 pcol_recv =
modulo(my_pcol - proc_shift, num_pe_col)
527 ALLOCATE (sos_mp2_work%index2send(pcol_send)%array(data2send(pcol_send)))
530 DO col_local = 1, ncol_local
531 col_global = col_indices(col_local)
533 iocc = max(1, col_global - 1)/virtual + 1
534 avirt = col_global - (iocc - 1)*virtual
536 DO ij_counter = 1, num_ij_pairs
538 my_i = sos_mp2_work%pair_list(1, ij_counter)
539 my_j = sos_mp2_work%pair_list(2, ij_counter)
541 IF (iocc /= my_j) cycle
542 pcol = fm_mat_s%matrix_struct%g2p_col((my_i - 1)*virtual + avirt)
543 IF (pcol /= pcol_send) cycle
545 counter = counter + 1
547 sos_mp2_work%index2send(pcol_send)%array(counter) = col_global
554 ALLOCATE (sos_mp2_work%index2recv(pcol_recv)%array(data2recv(pcol_recv)))
556 CALL para_env%sendrecv(sos_mp2_work%index2send(pcol_send)%array, blacs2mpi(my_prow, pcol_send), &
557 sos_mp2_work%index2recv(pcol_recv)%array, blacs2mpi(my_prow, pcol_recv), tag)
560 DO counter = 1, data2send(pcol_send)
561 sos_mp2_work%index2send(pcol_send)%array(counter) = &
562 fm_mat_s%matrix_struct%g2l_col(sos_mp2_work%index2send(pcol_send)%array(counter))
566 CALL comm_exchange%free()
569 DEALLOCATE (data2send, data2recv)
571 CALL timestop(handle)
573 END SUBROUTINE prepare_comm_pij
581 SUBROUTINE prepare_comm_pab(sos_mp2_work, virtual, fm_mat_S)
582 TYPE(sos_mp2_grad_work_type),
INTENT(INOUT) :: sos_mp2_work
583 INTEGER,
INTENT(IN) :: virtual
586 CHARACTER(LEN=*),
PARAMETER :: routinen =
'prepare_comm_Pab'
588 INTEGER :: ab_counter, avirt, col_global, col_local, counter, handle, iocc, my_a, my_b, &
589 my_pcol, my_prow, ncol_local, nrow_local, num_ab_pairs, num_pe_col, pcol, pcol_recv, &
590 pcol_send, proc_shift, tag
591 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: data2recv, data2send
592 INTEGER,
DIMENSION(:),
POINTER :: col_indices, ncol_locals
593 INTEGER,
DIMENSION(:, :),
POINTER :: blacs2mpi
598 CALL timeset(routinen, handle)
602 CALL fm_mat_s%matrix_struct%context%get(number_of_process_columns=num_pe_col)
603 ALLOCATE (sos_mp2_work%index2send(0:num_pe_col - 1), &
604 sos_mp2_work%index2recv(0:num_pe_col - 1))
606 num_ab_pairs =
SIZE(sos_mp2_work%pair_list, 2)
607 IF (num_ab_pairs > 0)
THEN
609 CALL cp_fm_struct_get(fm_mat_s%matrix_struct, para_env=para_env, ncol_locals=ncol_locals, &
610 ncol_local=ncol_local, col_indices=col_indices, &
611 context=context, nrow_local=nrow_local)
612 CALL context%get(my_process_row=my_prow, my_process_column=my_pcol, &
615 CALL comm_exchange%from_split(para_env, my_prow)
617 ALLOCATE (data2send(0:num_pe_col - 1))
618 ALLOCATE (data2recv(0:num_pe_col - 1))
622 DO proc_shift = 0, num_pe_col - 1
623 pcol_send =
modulo(my_pcol + proc_shift, num_pe_col)
624 pcol_recv =
modulo(my_pcol - proc_shift, num_pe_col)
627 DO col_local = 1, ncol_local
628 col_global = col_indices(col_local)
630 iocc = max(1, col_global - 1)/virtual + 1
631 avirt = col_global - (iocc - 1)*virtual
633 DO ab_counter = 1, num_ab_pairs
635 my_a = sos_mp2_work%pair_list(1, ab_counter)
636 my_b = sos_mp2_work%pair_list(2, ab_counter)
638 IF (avirt /= my_b) cycle
639 pcol = fm_mat_s%matrix_struct%g2p_col((iocc - 1)*virtual + my_a)
640 IF (pcol /= pcol_send) cycle
642 counter = counter + 1
648 data2send(pcol_send) = counter
651 CALL comm_exchange%alltoall(data2send, data2recv, 1)
653 DO proc_shift = 0, num_pe_col - 1
654 pcol_send =
modulo(my_pcol + proc_shift, num_pe_col)
655 pcol_recv =
modulo(my_pcol - proc_shift, num_pe_col)
658 ALLOCATE (sos_mp2_work%index2send(pcol_send)%array(data2send(pcol_send)))
661 DO col_local = 1, ncol_local
662 col_global = col_indices(col_local)
664 iocc = max(1, col_global - 1)/virtual + 1
665 avirt = col_global - (iocc - 1)*virtual
667 DO ab_counter = 1, num_ab_pairs
669 my_a = sos_mp2_work%pair_list(1, ab_counter)
670 my_b = sos_mp2_work%pair_list(2, ab_counter)
672 IF (avirt /= my_b) cycle
673 pcol = fm_mat_s%matrix_struct%g2p_col((iocc - 1)*virtual + my_a)
674 IF (pcol /= pcol_send) cycle
676 counter = counter + 1
678 sos_mp2_work%index2send(pcol_send)%array(counter) = col_global
685 ALLOCATE (sos_mp2_work%index2recv(pcol_recv)%array(data2recv(pcol_recv)))
687 CALL para_env%sendrecv(sos_mp2_work%index2send(pcol_send)%array, blacs2mpi(my_prow, pcol_send), &
688 sos_mp2_work%index2recv(pcol_recv)%array, blacs2mpi(my_prow, pcol_recv), tag)
691 DO counter = 1, data2send(pcol_send)
692 sos_mp2_work%index2send(pcol_send)%array(counter) = &
693 fm_mat_s%matrix_struct%g2l_col(sos_mp2_work%index2send(pcol_send)%array(counter))
697 CALL comm_exchange%free()
698 DEALLOCATE (data2send, data2recv)
702 CALL timestop(handle)
704 END SUBROUTINE prepare_comm_pab
736 dgemm_counter, fm_mat_S, omega, homo, virtual, Eigenval, weight, unit_nr)
737 TYPE(
mp2_type),
INTENT(INOUT) :: mp2_env
739 LOGICAL,
INTENT(IN) :: do_ri_sos_laplace_mp2
740 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(INOUT) :: fm_mat_q
741 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: fm_mat_q_gemm
743 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: fm_mat_s
744 REAL(kind=
dp),
INTENT(IN) :: omega
745 INTEGER,
DIMENSION(:),
INTENT(IN) :: homo, virtual
746 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN) :: eigenval
747 REAL(kind=
dp),
INTENT(IN) :: weight
748 INTEGER,
INTENT(IN) :: unit_nr
750 CHARACTER(LEN=*),
PARAMETER :: routinen =
'rpa_grad_matrix_operations'
752 INTEGER :: dimen_ia, dimen_ri, handle, handle2, &
754 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
755 TARGET :: mat_s_3d, mat_work_iap_3d
758 CALL timeset(routinen, handle)
760 nspins =
SIZE(fm_mat_q)
764 IF (.NOT. do_ri_sos_laplace_mp2)
THEN
765 CALL cp_fm_create(fm_work_pq, fm_mat_q(1)%matrix_struct)
774 CALL timeset(routinen//
"_PQ", handle2)
776 CALL parallel_gemm(transa=
"N", transb=
"N", m=dimen_ri, n=dimen_ri, k=dimen_ri, alpha=weight, &
777 matrix_a=
rpa_grad%rpa_work%fm_mat_Q_copy, matrix_b=fm_mat_q(1), beta=1.0_dp, &
780 CALL timestop(handle2)
783 fm_mat_q_gemm(1)%matrix_struct%context)
787 IF (do_ri_sos_laplace_mp2)
THEN
789 jspin = nspins - ispin + 1
795 IF (do_ri_sos_laplace_mp2)
THEN
796 CALL timeset(routinen//
"_PQ", handle2)
798 CALL parallel_gemm(transa=
"N", transb=
"N", m=dimen_ri, n=dimen_ri, k=dimen_ri, alpha=weight, &
799 matrix_a=fm_mat_q(ispin), matrix_b=fm_mat_q(jspin), beta=1.0_dp, &
802 CALL timestop(handle2)
805 fm_mat_q_gemm(jspin)%matrix_struct%context)
807 CALL calc_fm_mat_s_rpa(fm_mat_s(ispin), .true., virtual(ispin), eigenval(:, ispin), &
808 homo(ispin), omega, 0.0_dp)
811 CALL timeset(routinen//
"_contr_S", handle2)
817 CALL parallel_gemm(transa=
"N", transb=
"N", m=dimen_ri, n=dimen_ia, k=dimen_ri, alpha=1.0_dp, &
818 matrix_a=fm_mat_q_gemm(jspin), matrix_b=fm_mat_s(ispin), beta=0.0_dp, &
819 matrix_c=fm_work_iap)
821 CALL timestop(handle2)
823 IF (do_ri_sos_laplace_mp2)
THEN
824 CALL calc_p_sos_mp2(homo(ispin), fm_mat_s(ispin), fm_work_iap, &
826 omega, weight, virtual(ispin), eigenval(:, ispin), mp2_env%ri_grad%dot_blksize)
838 CALL redistribute_fm_mat_s(
rpa_grad%rpa_work%index2send(:, ispin),
rpa_grad%rpa_work%index2recv(:, ispin), &
839 fm_work_iap, mat_work_iap_3d, &
844 CALL redistribute_fm_mat_s(
rpa_grad%rpa_work%index2send(:, ispin),
rpa_grad%rpa_work%index2recv(:, ispin), &
845 fm_mat_s(ispin), mat_s_3d, &
850 CALL calc_p_rpa(mat_s_3d, mat_work_iap_3d,
rpa_grad%rpa_work%gd_homo(ispin),
rpa_grad%rpa_work%gd_virtual(ispin), &
852 fm_mat_s(ispin)%matrix_struct, &
854 weight, omega, eigenval(:, ispin), homo(ispin), unit_nr, mp2_env)
856 DEALLOCATE (mat_work_iap_3d, mat_s_3d)
864 CALL timestop(handle)
881 SUBROUTINE calc_p_sos_mp2(homo, fm_mat_S, fm_work_iaP, sos_mp2_work_occ, sos_mp2_work_virt, &
882 omega, weight, virtual, Eigenval, dot_blksize)
883 INTEGER,
INTENT(IN) :: homo
884 TYPE(
cp_fm_type),
INTENT(IN) :: fm_mat_s, fm_work_iap
885 TYPE(sos_mp2_grad_work_type),
INTENT(INOUT) :: sos_mp2_work_occ, sos_mp2_work_virt
886 REAL(kind=
dp),
INTENT(IN) :: omega, weight
887 INTEGER,
INTENT(IN) :: virtual
888 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: eigenval
889 INTEGER,
INTENT(IN) :: dot_blksize
891 CHARACTER(LEN=*),
PARAMETER :: routinen =
'calc_P_sos_mp2'
893 INTEGER :: avirt, col_global, col_local, handle, &
894 handle2, iocc, my_a, my_i, ncol_local, &
895 nrow_local, num_ab_pairs, num_ij_pairs
896 INTEGER,
DIMENSION(:),
POINTER :: col_indices
897 REAL(kind=
dp) :: ddot, trace
899 CALL timeset(routinen, handle)
901 CALL cp_fm_get_info(fm_mat_s, col_indices=col_indices, ncol_local=ncol_local, nrow_local=nrow_local)
903 CALL timeset(routinen//
"_Pij_diag", handle2)
909 DO col_local = 1, ncol_local
910 col_global = col_indices(col_local)
912 iocc = max(1, col_global - 1)/virtual + 1
913 avirt = col_global - (iocc - 1)*virtual
915 IF (iocc == my_i) trace = trace + &
916 ddot(nrow_local, fm_mat_s%local_data(:, col_local), 1, fm_work_iap%local_data(:, col_local), 1)
919 sos_mp2_work_occ%P(my_i) = sos_mp2_work_occ%P(my_i) - trace*omega*weight
922 CALL timestop(handle2)
924 CALL timeset(routinen//
"_Pab_diag", handle2)
930 DO col_local = 1, ncol_local
931 col_global = col_indices(col_local)
933 iocc = max(1, col_global - 1)/virtual + 1
934 avirt = col_global - (iocc - 1)*virtual
936 IF (avirt == my_a) trace = trace + &
937 ddot(nrow_local, fm_mat_s%local_data(:, col_local), 1, fm_work_iap%local_data(:, col_local), 1)
940 sos_mp2_work_virt%P(my_a) = sos_mp2_work_virt%P(my_a) + trace*omega*weight
943 CALL timestop(handle2)
946 num_ij_pairs =
SIZE(sos_mp2_work_occ%pair_list, 2)
947 num_ab_pairs =
SIZE(sos_mp2_work_virt%pair_list, 2)
948 IF (num_ij_pairs > 0)
THEN
949 CALL calc_pij_degen(fm_work_iap, fm_mat_s, sos_mp2_work_occ%pair_list, &
950 virtual, sos_mp2_work_occ%P(homo + 1:), eigenval(:homo), omega, weight, &
951 sos_mp2_work_occ%index2send, sos_mp2_work_occ%index2recv, dot_blksize)
953 IF (num_ab_pairs > 0)
THEN
954 CALL calc_pab_degen(fm_work_iap, fm_mat_s, sos_mp2_work_virt%pair_list, &
955 virtual, sos_mp2_work_virt%P(virtual + 1:), eigenval(homo + 1:), omega, weight, &
956 sos_mp2_work_virt%index2send, sos_mp2_work_virt%index2recv, dot_blksize)
959 CALL timestop(handle)
961 END SUBROUTINE calc_p_sos_mp2
981 SUBROUTINE calc_p_rpa(mat_S_1D, mat_work_iaP_3D, gd_homo, gd_virtual, grid, mepos, &
982 fm_struct_S, P_ij, P_ab, weight, omega, Eigenval, homo, unit_nr, mp2_env)
983 REAL(kind=
dp),
DIMENSION(*),
INTENT(INOUT),
TARGET :: mat_s_1d
984 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: mat_work_iap_3d
986 INTEGER,
DIMENSION(2),
INTENT(IN) :: grid, mepos
988 REAL(kind=
dp),
DIMENSION(:, :) :: p_ij, p_ab
989 REAL(kind=
dp),
INTENT(IN) :: weight, omega
990 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: eigenval
991 INTEGER,
INTENT(IN) :: homo, unit_nr
992 TYPE(
mp2_type),
INTENT(INOUT) :: mp2_env
994 CHARACTER(LEN=*),
PARAMETER :: routinen =
'calc_P_rpa'
996 INTEGER :: completed, handle, handle2, my_a_end, my_a_size, my_a_start, my_i_end, my_i_size, &
997 my_i_start, my_p_size, my_prow, number_of_parallel_channels, proc_a_recv, proc_a_send, &
998 proc_i_recv, proc_i_send, proc_recv, proc_send, proc_shift, recv_a_end, recv_a_size, &
999 recv_a_start, recv_i_end, recv_i_size, recv_i_start, tag
1000 INTEGER(KIND=int_8) :: mem, number_of_elements_per_blk
1001 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: procs_recv
1002 INTEGER,
DIMENSION(:, :),
POINTER :: blacs2mpi
1003 REAL(kind=
dp) :: mem_per_block, mem_real
1004 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:),
TARGET :: buffer_compens_1d
1005 REAL(kind=
dp),
DIMENSION(:, :, :),
POINTER :: mat_s_3d
1009 TYPE(
mp_request_type),
ALLOCATABLE,
DIMENSION(:) :: recv_requests, send_requests
1011 CALL timeset(routinen, handle)
1014 IF (mp2_env%ri_grad%dot_blksize >= blksize_threshold)
THEN
1021 my_p_size =
SIZE(mat_work_iap_3d, 1)
1024 CALL fm_struct_s%context%get(my_process_row=my_prow, blacs2mpi=blacs2mpi, para_env=para_env)
1026 CALL get_group_dist(gd_virtual, mepos(1), my_a_start, my_a_end, my_a_size)
1027 CALL get_group_dist(gd_homo, mepos(2), my_i_start, my_i_end, my_i_size)
1032 mat_s_3d(1:my_p_size, 1:my_a_size, 1:my_i_size) => mat_s_1d(1:int(my_p_size,
int_8)*my_a_size*my_i_size)
1034 number_of_elements_per_blk = max(int(
maxsize(gd_homo), kind=
int_8)*my_a_size, &
1035 int(
maxsize(gd_virtual), kind=
int_8)*my_i_size)*my_p_size
1039 mem_real = real(mem, kind=
dp)
1040 mem_per_block = real(number_of_elements_per_blk, kind=
dp)*8.0_dp
1041 number_of_parallel_channels = max(1, min(maxval(grid) - 1, floor(mem_real/mem_per_block)))
1042 CALL para_env%min(number_of_parallel_channels)
1043 IF (mp2_env%ri_grad%max_parallel_comm > 0)
THEN
1044 number_of_parallel_channels = min(number_of_parallel_channels, mp2_env%ri_grad%max_parallel_comm)
1047 IF (unit_nr > 0)
THEN
1048 WRITE (unit_nr,
'(T3,A,T75,I6)')
'GRAD_INFO| Number of parallel communication channels:', number_of_parallel_channels
1051 CALL para_env%sync()
1053 ALLOCATE (buffer_1d(number_of_parallel_channels))
1054 DO proc_shift = 1, number_of_parallel_channels
1055 ALLOCATE (buffer_1d(proc_shift)%array(number_of_elements_per_blk))
1058 ALLOCATE (buffer_3d(number_of_parallel_channels))
1061 IF (mp2_env%ri_grad%dot_blksize >= blksize_threshold)
THEN
1062 ALLOCATE (buffer_compens_1d(2*max(my_a_size*
maxsize(gd_virtual), my_i_size*
maxsize(gd_homo))))
1065 IF (number_of_parallel_channels > 1)
THEN
1066 ALLOCATE (procs_recv(number_of_parallel_channels))
1067 ALLOCATE (recv_requests(number_of_parallel_channels))
1068 ALLOCATE (send_requests(maxval(grid) - 1))
1071 IF (number_of_parallel_channels > 1 .AND. grid(1) > 1)
THEN
1072 CALL timeset(routinen//
"_comm_a", handle2)
1075 DO proc_shift = 1, min(grid(1) - 1, number_of_parallel_channels)
1076 proc_a_recv =
modulo(mepos(1) - proc_shift, grid(1))
1077 proc_recv = mepos(2)*grid(1) + proc_a_recv
1079 CALL get_group_dist(gd_virtual, proc_a_recv, recv_a_start, recv_a_end, recv_a_size)
1081 buffer_3d(proc_shift)%array(1:my_p_size, 1:recv_a_size, 1:my_i_size) => &
1082 buffer_1d(proc_shift)%array(1:int(my_p_size, kind=
int_8)*recv_a_size*my_i_size)
1084 CALL para_env%irecv(buffer_3d(proc_shift)%array, blacs2mpi(my_prow, proc_recv), &
1085 recv_requests(proc_shift), tag)
1087 procs_recv(proc_shift) = proc_a_recv
1091 DO proc_shift = 1, grid(1) - 1
1092 proc_a_send =
modulo(mepos(1) + proc_shift, grid(1))
1093 proc_send = mepos(2)*grid(1) + proc_a_send
1095 CALL para_env%isend(mat_work_iap_3d, blacs2mpi(my_prow, proc_send), &
1096 send_requests(proc_shift), tag)
1098 CALL timestop(handle2)
1101 CALL calc_p_rpa_a(p_ab(:, my_a_start:my_a_end), &
1102 mat_s_3d, mat_work_iap_3d, &
1103 mp2_env%ri_grad%dot_blksize, buffer_compens_1d, mp2_env%local_gemm_ctx, &
1104 eigenval(homo + my_a_start:homo + my_a_end), eigenval(my_i_start:my_i_end), &
1105 eigenval(homo + my_a_start:homo + my_a_end), omega, weight)
1107 DO proc_shift = 1, grid(1) - 1
1108 CALL timeset(routinen//
"_comm_a", handle2)
1109 IF (number_of_parallel_channels > 1)
THEN
1112 CALL get_group_dist(gd_virtual, procs_recv(completed), recv_a_start, recv_a_end, recv_a_size)
1114 proc_a_send =
modulo(mepos(1) + proc_shift, grid(1))
1115 proc_a_recv =
modulo(mepos(1) - proc_shift, grid(1))
1117 proc_send = mepos(2)*grid(1) + proc_a_send
1118 proc_recv = mepos(2)*grid(1) + proc_a_recv
1120 CALL get_group_dist(gd_virtual, proc_a_recv, recv_a_start, recv_a_end, recv_a_size)
1122 buffer_3d(1)%array(1:my_p_size, 1:recv_a_size, 1:my_i_size) => &
1123 buffer_1d(1)%array(1:int(my_p_size, kind=
int_8)*recv_a_size*my_i_size)
1125 CALL para_env%sendrecv(mat_work_iap_3d, blacs2mpi(my_prow, proc_send), &
1126 buffer_3d(1)%array, blacs2mpi(my_prow, proc_recv), tag)
1129 CALL timestop(handle2)
1131 CALL calc_p_rpa_a(p_ab(:, recv_a_start:recv_a_end), &
1132 mat_s_3d, buffer_3d(completed)%array, &
1133 mp2_env%ri_grad%dot_blksize, buffer_compens_1d, mp2_env%local_gemm_ctx, &
1134 eigenval(homo + my_a_start:homo + my_a_end), eigenval(my_i_start:my_i_end), &
1135 eigenval(homo + recv_a_start:homo + recv_a_end), omega, weight)
1137 IF (number_of_parallel_channels > 1 .AND. number_of_parallel_channels + proc_shift < grid(1))
THEN
1138 proc_a_recv =
modulo(mepos(1) - proc_shift - number_of_parallel_channels, grid(1))
1139 proc_recv = mepos(2)*grid(1) + proc_a_recv
1141 CALL get_group_dist(gd_virtual, proc_a_recv, recv_a_start, recv_a_end, recv_a_size)
1143 buffer_3d(completed)%array(1:my_p_size, 1:recv_a_size, 1:my_i_size) => &
1144 buffer_1d(completed)%array(1:int(my_p_size, kind=
int_8)*recv_a_size*my_i_size)
1146 CALL para_env%irecv(buffer_3d(completed)%array, blacs2mpi(my_prow, proc_recv), &
1147 recv_requests(completed), tag)
1149 procs_recv(completed) = proc_a_recv
1153 IF (number_of_parallel_channels > 1 .AND. grid(1) > 1)
THEN
1157 IF (number_of_parallel_channels > 1 .AND. grid(2) > 1)
THEN
1160 DO proc_shift = 1, min(grid(2) - 1, number_of_parallel_channels)
1161 proc_i_recv =
modulo(mepos(2) - proc_shift, grid(2))
1162 proc_recv = proc_i_recv*grid(1) + mepos(1)
1164 CALL get_group_dist(gd_homo, proc_i_recv, recv_i_start, recv_i_end, recv_i_size)
1166 buffer_3d(proc_shift)%array(1:my_p_size, 1:my_a_size, 1:recv_i_size) => &
1167 buffer_1d(proc_shift)%array(1:int(my_p_size, kind=
int_8)*my_a_size*recv_i_size)
1169 CALL para_env%irecv(buffer_3d(proc_shift)%array, blacs2mpi(my_prow, proc_recv), &
1170 recv_requests(proc_shift), tag)
1172 procs_recv(proc_shift) = proc_i_recv
1176 DO proc_shift = 1, grid(2) - 1
1177 proc_i_send =
modulo(mepos(2) + proc_shift, grid(2))
1178 proc_send = proc_i_send*grid(1) + mepos(1)
1180 CALL para_env%isend(mat_work_iap_3d, blacs2mpi(my_prow, proc_send), &
1181 send_requests(proc_shift), tag)
1185 CALL calc_p_rpa_i(p_ij(:, my_i_start:my_i_end), &
1186 mat_s_3d, mat_work_iap_3d, &
1187 mp2_env%ri_grad%dot_blksize, buffer_compens_1d, mp2_env%local_gemm_ctx, &
1188 eigenval(homo + my_a_start:homo + my_a_end), eigenval(my_i_start:my_i_end), &
1189 eigenval(my_i_start:my_i_end), omega, weight)
1191 DO proc_shift = 1, grid(2) - 1
1192 CALL timeset(routinen//
"_comm_i", handle2)
1193 IF (number_of_parallel_channels > 1)
THEN
1196 CALL get_group_dist(gd_homo, procs_recv(completed), recv_i_start, recv_i_end, recv_i_size)
1198 proc_i_send =
modulo(mepos(2) + proc_shift, grid(2))
1199 proc_i_recv =
modulo(mepos(2) - proc_shift, grid(2))
1201 proc_send = proc_i_send*grid(1) + mepos(1)
1202 proc_recv = proc_i_recv*grid(1) + mepos(1)
1204 CALL get_group_dist(gd_homo, proc_i_recv, recv_i_start, recv_i_end, recv_i_size)
1206 buffer_3d(1)%array(1:my_p_size, 1:my_a_size, 1:recv_i_size) => &
1207 buffer_1d(1)%array(1:int(my_p_size, kind=
int_8)*my_a_size*recv_i_size)
1209 CALL para_env%sendrecv(mat_work_iap_3d, blacs2mpi(my_prow, proc_send), &
1210 buffer_3d(1)%array, blacs2mpi(my_prow, proc_recv), tag)
1213 CALL timestop(handle2)
1215 CALL calc_p_rpa_i(p_ij(:, recv_i_start:recv_i_end), &
1216 mat_s_3d, buffer_3d(completed)%array, &
1217 mp2_env%ri_grad%dot_blksize, buffer_compens_1d, mp2_env%local_gemm_ctx, &
1218 eigenval(homo + my_a_start:homo + my_a_end), eigenval(my_i_start:my_i_end), &
1219 eigenval(recv_i_start:recv_i_end), omega, weight)
1221 IF (number_of_parallel_channels > 1 .AND. number_of_parallel_channels + proc_shift < grid(2))
THEN
1222 proc_i_recv =
modulo(mepos(2) - proc_shift - number_of_parallel_channels, grid(2))
1223 proc_recv = proc_i_recv*grid(1) + mepos(1)
1225 CALL get_group_dist(gd_homo, proc_i_recv, recv_i_start, recv_a_end, recv_i_size)
1227 buffer_3d(completed)%array(1:my_p_size, 1:my_a_size, 1:recv_i_size) => &
1228 buffer_1d(completed)%array(1:int(my_p_size, kind=
int_8)*my_a_size*recv_i_size)
1230 CALL para_env%irecv(buffer_3d(completed)%array, blacs2mpi(my_prow, proc_recv), &
1231 recv_requests(completed), tag)
1233 procs_recv(completed) = proc_i_recv
1237 IF (number_of_parallel_channels > 1 .AND. grid(2) > 1)
THEN
1241 IF (number_of_parallel_channels > 1)
THEN
1242 DEALLOCATE (procs_recv)
1243 DEALLOCATE (recv_requests)
1244 DEALLOCATE (send_requests)
1247 IF (mp2_env%ri_grad%dot_blksize >= blksize_threshold)
THEN
1249 CALL mp2_env%local_gemm_ctx%destroy()
1250 DEALLOCATE (buffer_compens_1d)
1253 DO proc_shift = 1, number_of_parallel_channels
1254 NULLIFY (buffer_3d(proc_shift)%array)
1255 DEALLOCATE (buffer_1d(proc_shift)%array)
1257 DEALLOCATE (buffer_3d, buffer_1d)
1259 CALL timestop(handle)
1261 END SUBROUTINE calc_p_rpa
1277 SUBROUTINE calc_p_rpa_a(P_ab, mat_S, mat_work, dot_blksize, buffer_1D, local_gemm_ctx, &
1278 my_eval_virt, my_eval_occ, recv_eval_virt, omega, weight)
1279 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(INOUT) :: p_ab
1280 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: mat_s, mat_work
1281 INTEGER,
INTENT(IN) :: dot_blksize
1282 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:), &
1283 INTENT(INOUT),
TARGET :: buffer_1d
1285 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: my_eval_virt, my_eval_occ, recv_eval_virt
1286 REAL(kind=
dp),
INTENT(IN) :: omega, weight
1288 CHARACTER(LEN=*),
PARAMETER :: routinen =
'calc_P_rpa_a'
1290 INTEGER :: handle, my_a, my_a_size, my_i, &
1291 my_i_size, my_p_size, p_end, p_start, &
1292 recv_a_size, stripesize
1293 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: buffer_compens, buffer_unscaled
1295 CALL timeset(routinen, handle)
1297 my_i_size =
SIZE(mat_s, 3)
1298 recv_a_size =
SIZE(mat_work, 2)
1299 my_a_size =
SIZE(mat_s, 2)
1300 my_p_size =
SIZE(mat_s, 1)
1302 IF (dot_blksize >= blksize_threshold)
THEN
1303 buffer_compens(1:my_a_size, 1:recv_a_size) => buffer_1d(1:my_a_size*recv_a_size)
1304 buffer_compens = 0.0_dp
1305 buffer_unscaled(1:my_a_size, 1:recv_a_size) => buffer_1d(my_a_size*recv_a_size + 1:2*my_a_size*recv_a_size)
1308 DO my_i = 1, my_i_size
1309 DO p_start = 1, my_p_size, dot_blksize
1310 stripesize = min(dot_blksize, my_p_size - p_start + 1)
1311 p_end = p_start + stripesize - 1
1313 CALL local_gemm_ctx%gemm(
"T",
"N", my_a_size, recv_a_size, stripesize, &
1314 -weight, mat_s(p_start:p_end, :, my_i), stripesize, &
1315 mat_work(p_start:p_end, :, my_i), stripesize, &
1316 0.0_dp, buffer_unscaled, my_a_size)
1318 CALL scale_buffer_and_add_compens_virt(buffer_unscaled, buffer_compens, omega, &
1319 my_eval_virt, recv_eval_virt, my_eval_occ(my_i))
1321 CALL kahan_step(buffer_compens, p_ab)
1327 REAL(kind=
dp) :: tmp, e_i, e_a, e_b, omega2, my_compens, my_p, s
1333 DO my_a = 1, my_a_size
1334 DO recv_a = 1, recv_a_size
1335 e_a = my_eval_virt(my_a)
1336 e_b = recv_eval_virt(recv_a)
1337 my_p = p_ab(my_a, recv_a)
1339 DO my_i = 1, my_i_size
1340 e_i = -my_eval_occ(my_i)
1342 *(1.0_dp + omega2/((e_a + e_i)*(e_b + e_i))) - my_compens
1344 my_compens = (s - my_p) - tmp
1347 p_ab(my_a, recv_a) = my_p
1353 CALL timestop(handle)
1355 END SUBROUTINE calc_p_rpa_a
1371 SUBROUTINE calc_p_rpa_i(P_ij, mat_S, mat_work, dot_blksize, buffer_1D, local_gemm_ctx, &
1372 my_eval_virt, my_eval_occ, recv_eval_occ, omega, weight)
1373 REAL(kind=dp),
DIMENSION(:, :),
INTENT(INOUT) :: p_ij
1374 REAL(kind=dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: mat_s, mat_work
1375 INTEGER,
INTENT(IN) :: dot_blksize
1376 REAL(kind=dp),
ALLOCATABLE,
DIMENSION(:), &
1377 INTENT(INOUT),
TARGET :: buffer_1d
1378 TYPE(local_gemm_ctxt_type),
INTENT(INOUT) :: local_gemm_ctx
1379 REAL(kind=dp),
DIMENSION(:),
INTENT(IN) :: my_eval_virt, my_eval_occ, recv_eval_occ
1380 REAL(kind=dp),
INTENT(IN) :: omega, weight
1382 CHARACTER(LEN=*),
PARAMETER :: routinen =
'calc_P_rpa_i'
1384 INTEGER :: handle, my_a, my_a_size, my_i, &
1385 my_i_size, my_p_size, p_end, p_start, &
1386 recv_i_size, stripesize
1387 REAL(kind=dp),
DIMENSION(:, :),
POINTER :: buffer_compens, buffer_unscaled
1389 CALL timeset(routinen, handle)
1391 my_i_size =
SIZE(mat_s, 3)
1392 recv_i_size =
SIZE(mat_work, 3)
1393 my_a_size =
SIZE(mat_s, 2)
1394 my_p_size =
SIZE(mat_s, 1)
1396 IF (dot_blksize >= blksize_threshold)
THEN
1397 buffer_compens(1:my_i_size, 1:recv_i_size) => buffer_1d(1:my_i_size*recv_i_size)
1398 buffer_compens = 0.0_dp
1399 buffer_unscaled(1:my_i_size, 1:recv_i_size) => buffer_1d(my_i_size*recv_i_size + 1:2*my_i_size*recv_i_size)
1402 DO my_a = 1, my_a_size
1403 DO p_start = 1, my_p_size, dot_blksize
1404 stripesize = min(dot_blksize, my_p_size - p_start + 1)
1405 p_end = p_start + stripesize - 1
1407 CALL local_gemm_ctx%gemm(
"T",
"N", my_i_size, recv_i_size, stripesize, &
1408 weight, mat_s(p_start:p_end, my_a, :), stripesize, &
1409 mat_work(p_start:p_end, my_a, :), stripesize, &
1410 0.0_dp, buffer_unscaled, my_i_size)
1412 CALL scale_buffer_and_add_compens_occ(buffer_unscaled, buffer_compens, omega, &
1413 my_eval_occ, recv_eval_occ, my_eval_virt(my_a))
1415 CALL kahan_step(buffer_compens, p_ij)
1420 REAL(kind=dp) :: tmp, e_i, e_a, e_j, omega2, my_compens, my_p, s
1427 DO my_i = 1, my_i_size
1428 DO recv_i = 1, recv_i_size
1429 e_i = my_eval_occ(my_i)
1430 e_j = recv_eval_occ(recv_i)
1431 my_p = p_ij(my_i, recv_i)
1433 DO my_a = 1, my_a_size
1434 e_a = my_eval_virt(my_a)
1435 tmp = weight*accurate_dot_product(mat_s(:, my_a, my_i), mat_work(:, my_a, recv_i)) &
1436 *(1.0_dp + omega2/((e_a - e_i)*(e_a - e_j))) - my_compens
1438 my_compens = (s - my_p) - tmp
1441 p_ij(my_i, recv_i) = my_p
1447 CALL timestop(handle)
1449 END SUBROUTINE calc_p_rpa_i
1456 SUBROUTINE kahan_step(compens, P)
1457 REAL(kind=dp),
DIMENSION(:, :),
INTENT(INOUT) :: compens, p
1459 CHARACTER(LEN=*),
PARAMETER :: routinen =
'kahan_step'
1461 INTEGER :: handle, i, j
1462 REAL(kind=dp) :: my_compens, my_p, s
1464 CALL timeset(routinen, handle)
1467 DO j = 1,
SIZE(compens, 2)
1468 DO i = 1,
SIZE(compens, 1)
1470 my_compens = compens(i, j)
1471 s = my_p + my_compens
1472 compens(i, j) = (s - my_p) - my_compens
1478 CALL timestop(handle)
1480 END SUBROUTINE kahan_step
1491 SUBROUTINE scale_buffer_and_add_compens_virt(buffer_unscaled, buffer_compens, omega, &
1492 my_eval_virt, recv_eval_virt, my_eval_occ)
1493 REAL(kind=dp),
DIMENSION(:, :),
INTENT(IN) :: buffer_unscaled
1494 REAL(kind=dp),
DIMENSION(:, :),
INTENT(INOUT) :: buffer_compens
1495 REAL(kind=dp),
INTENT(IN) :: omega
1496 REAL(kind=dp),
DIMENSION(:),
INTENT(IN) :: my_eval_virt, recv_eval_virt
1497 REAL(kind=dp),
INTENT(IN) :: my_eval_occ
1499 CHARACTER(LEN=*),
PARAMETER :: routinen =
'scale_buffer_and_add_compens_virt'
1501 INTEGER :: handle, my_a, my_b
1503 CALL timeset(routinen, handle)
1507 DO my_b = 1,
SIZE(buffer_compens, 2)
1508 DO my_a = 1,
SIZE(buffer_compens, 1)
1509 buffer_compens(my_a, my_b) = buffer_unscaled(my_a, my_b) &
1510 *(1.0_dp - omega**2/((my_eval_virt(my_a) - my_eval_occ)*(recv_eval_virt(my_b) - my_eval_occ))) &
1511 - buffer_compens(my_a, my_b)
1516 CALL timestop(handle)
1518 END SUBROUTINE scale_buffer_and_add_compens_virt
1529 SUBROUTINE scale_buffer_and_add_compens_occ(buffer_unscaled, buffer_compens, omega, &
1530 my_eval_occ, recv_eval_occ, my_eval_virt)
1531 REAL(kind=dp),
DIMENSION(:, :),
INTENT(IN) :: buffer_unscaled
1532 REAL(kind=dp),
DIMENSION(:, :),
INTENT(INOUT) :: buffer_compens
1533 REAL(kind=dp),
INTENT(IN) :: omega
1534 REAL(kind=dp),
DIMENSION(:),
INTENT(IN) :: my_eval_occ, recv_eval_occ
1535 REAL(kind=dp),
INTENT(IN) :: my_eval_virt
1537 CHARACTER(LEN=*),
PARAMETER :: routinen =
'scale_buffer_and_add_compens_occ'
1539 INTEGER :: handle, my_i, my_j
1541 CALL timeset(routinen, handle)
1545 DO my_j = 1,
SIZE(buffer_compens, 2)
1546 DO my_i = 1,
SIZE(buffer_compens, 1)
1547 buffer_compens(my_i, my_j) = buffer_unscaled(my_i, my_j) &
1548 *(1.0_dp - omega**2/((my_eval_virt - my_eval_occ(my_i))*(my_eval_virt - recv_eval_occ(my_j)))) &
1549 - buffer_compens(my_i, my_j)
1554 CALL timestop(handle)
1556 END SUBROUTINE scale_buffer_and_add_compens_occ
1563 ELEMENTAL FUNCTION sinh_over_x(x)
RESULT(res)
1564 REAL(kind=dp),
INTENT(IN) :: x
1565 REAL(kind=dp) :: res
1569 IF (abs(x) > 3.0e-4_dp)
THEN
1572 res = 1.0_dp + x**2/6.0_dp
1575 END FUNCTION sinh_over_x
1591 SUBROUTINE calc_pij_degen(fm_work_iaP, fm_mat_S, pair_list, virtual, P_ij, Eigenval, &
1592 omega, weight, index2send, index2recv, dot_blksize)
1593 TYPE(cp_fm_type),
INTENT(IN) :: fm_work_iap, fm_mat_s
1594 INTEGER,
DIMENSION(:, :),
INTENT(IN) :: pair_list
1595 INTEGER,
INTENT(IN) :: virtual
1596 REAL(kind=dp),
DIMENSION(:),
INTENT(INOUT) :: p_ij
1597 REAL(kind=dp),
DIMENSION(:),
INTENT(IN) :: eigenval
1598 REAL(kind=dp),
INTENT(IN) :: omega, weight
1599 TYPE(one_dim_int_array),
DIMENSION(0:),
INTENT(IN) :: index2send, index2recv
1600 INTEGER,
INTENT(IN) :: dot_blksize
1602 CHARACTER(LEN=*),
PARAMETER :: routinen =
'calc_Pij_degen'
1604 INTEGER :: avirt, col_global, col_local, counter, handle, handle2, ij_counter, iocc, &
1605 my_col_local, my_i, my_j, my_pcol, my_prow, ncol_local, nrow_local, num_ij_pairs, &
1606 num_pe_col, pcol, pcol_recv, pcol_send, proc_shift, recv_size, send_size, &
1607 size_recv_buffer, size_send_buffer, tag
1608 INTEGER,
DIMENSION(:),
POINTER :: col_indices, ncol_locals
1609 INTEGER,
DIMENSION(:, :),
POINTER :: blacs2mpi
1610 REAL(kind=dp) :: trace
1611 REAL(kind=dp),
ALLOCATABLE,
DIMENSION(:, :) :: buffer_recv, buffer_send
1612 TYPE(cp_blacs_env_type),
POINTER :: context
1613 TYPE(mp_para_env_type),
POINTER :: para_env
1615 CALL timeset(routinen, handle)
1617 CALL cp_fm_struct_get(fm_work_iap%matrix_struct, para_env=para_env, ncol_locals=ncol_locals, &
1618 ncol_local=ncol_local, col_indices=col_indices, &
1619 context=context, nrow_local=nrow_local)
1620 CALL context%get(my_process_row=my_prow, my_process_column=my_pcol, &
1621 number_of_process_columns=num_pe_col, blacs2mpi=blacs2mpi)
1623 num_ij_pairs =
SIZE(pair_list, 2)
1627 DO ij_counter = 1, num_ij_pairs
1629 my_i = pair_list(1, ij_counter)
1630 my_j = pair_list(2, ij_counter)
1634 DO col_local = 1, ncol_local
1635 col_global = col_indices(col_local)
1637 iocc = max(1, col_global - 1)/virtual + 1
1638 avirt = col_global - (iocc - 1)*virtual
1640 IF (iocc /= my_j) cycle
1641 pcol = fm_work_iap%matrix_struct%g2p_col((my_i - 1)*virtual + avirt)
1642 IF (pcol /= my_pcol) cycle
1644 my_col_local = fm_work_iap%matrix_struct%g2l_col((my_i - 1)*virtual + avirt)
1646 trace = trace + accurate_dot_product_2(fm_mat_s%local_data(:, my_col_local), fm_work_iap%local_data(:, col_local), &
1650 p_ij(ij_counter) = p_ij(ij_counter) - trace*sinh_over_x(0.5_dp*(eigenval(my_i) - eigenval(my_j))*omega)*omega*weight
1654 IF (num_pe_col > 1)
THEN
1655 size_send_buffer = 0
1656 size_recv_buffer = 0
1657 DO proc_shift = 1, num_pe_col - 1
1658 pcol_send =
modulo(my_pcol + proc_shift, num_pe_col)
1659 pcol_recv =
modulo(my_pcol - proc_shift, num_pe_col)
1661 IF (
ALLOCATED(index2send(pcol_send)%array))
THEN
1662 size_send_buffer = max(size_send_buffer,
SIZE(index2send(pcol_send)%array))
1665 IF (
ALLOCATED(index2recv(pcol_recv)%array))
THEN
1666 size_recv_buffer = max(size_recv_buffer,
SIZE(index2recv(pcol_recv)%array))
1670 ALLOCATE (buffer_send(nrow_local, size_send_buffer), buffer_recv(nrow_local, size_recv_buffer))
1672 DO proc_shift = 1, num_pe_col - 1
1673 pcol_send =
modulo(my_pcol + proc_shift, num_pe_col)
1674 pcol_recv =
modulo(my_pcol - proc_shift, num_pe_col)
1678 IF (
ALLOCATED(index2send(pcol_send)%array)) send_size =
SIZE(index2send(pcol_send)%array)
1680 DO counter = 1, send_size
1681 buffer_send(:, counter) = fm_work_iap%local_data(:, index2send(pcol_send)%array(counter))
1685 IF (
ALLOCATED(index2recv(pcol_recv)%array)) recv_size =
SIZE(index2recv(pcol_recv)%array)
1686 IF (recv_size > 0)
THEN
1687 CALL timeset(routinen//
"_send", handle2)
1688 IF (send_size > 0)
THEN
1689 CALL para_env%sendrecv(buffer_send(:, :send_size), blacs2mpi(my_prow, pcol_send), &
1690 buffer_recv(:, :recv_size), blacs2mpi(my_prow, pcol_recv), tag)
1692 CALL para_env%recv(buffer_recv(:, :recv_size), blacs2mpi(my_prow, pcol_recv), tag)
1694 CALL timestop(handle2)
1696 DO ij_counter = 1, num_ij_pairs
1699 my_i = pair_list(1, ij_counter)
1700 my_j = pair_list(2, ij_counter)
1704 DO col_local = 1, recv_size
1705 col_global = index2recv(pcol_recv)%array(col_local)
1707 iocc = max(1, col_global - 1)/virtual + 1
1708 IF (iocc /= my_j) cycle
1709 avirt = col_global - (iocc - 1)*virtual
1710 pcol = fm_work_iap%matrix_struct%g2p_col((my_i - 1)*virtual + avirt)
1711 IF (pcol /= my_pcol) cycle
1713 my_col_local = fm_work_iap%matrix_struct%g2l_col((my_i - 1)*virtual + avirt)
1715 trace = trace + accurate_dot_product_2(fm_mat_s%local_data(:, my_col_local), buffer_recv(:, col_local), &
1719 p_ij(ij_counter) = p_ij(ij_counter) &
1720 - trace*sinh_over_x(0.5_dp*(eigenval(my_i) - eigenval(my_j))*omega)*omega*weight
1722 ELSE IF (send_size > 0)
THEN
1723 CALL timeset(routinen//
"_send", handle2)
1724 CALL para_env%send(buffer_send(:, :send_size), blacs2mpi(my_prow, pcol_send), tag)
1725 CALL timestop(handle2)
1728 IF (
ALLOCATED(buffer_send))
DEALLOCATE (buffer_send)
1729 IF (
ALLOCATED(buffer_recv))
DEALLOCATE (buffer_recv)
1732 CALL timestop(handle)
1734 END SUBROUTINE calc_pij_degen
1750 SUBROUTINE calc_pab_degen(fm_work_iaP, fm_mat_S, pair_list, virtual, P_ab, Eigenval, &
1751 omega, weight, index2send, index2recv, dot_blksize)
1752 TYPE(cp_fm_type),
INTENT(IN) :: fm_work_iap, fm_mat_s
1753 INTEGER,
DIMENSION(:, :),
INTENT(IN) :: pair_list
1754 INTEGER,
INTENT(IN) :: virtual
1755 REAL(kind=dp),
DIMENSION(:),
INTENT(INOUT) :: p_ab
1756 REAL(kind=dp),
DIMENSION(:),
INTENT(IN) :: eigenval
1757 REAL(kind=dp),
INTENT(IN) :: omega, weight
1758 TYPE(one_dim_int_array),
DIMENSION(0:),
INTENT(IN) :: index2send, index2recv
1759 INTEGER,
INTENT(IN) :: dot_blksize
1761 CHARACTER(LEN=*),
PARAMETER :: routinen =
'calc_Pab_degen'
1763 INTEGER :: ab_counter, avirt, col_global, col_local, counter, handle, handle2, iocc, my_a, &
1764 my_b, my_col_local, my_pcol, my_prow, ncol_local, nrow_local, num_ab_pairs, num_pe_col, &
1765 pcol, pcol_recv, pcol_send, proc_shift, recv_size, send_size, size_recv_buffer, &
1766 size_send_buffer, tag
1767 INTEGER,
DIMENSION(:),
POINTER :: col_indices, ncol_locals
1768 INTEGER,
DIMENSION(:, :),
POINTER :: blacs2mpi
1769 REAL(kind=dp) :: trace
1770 REAL(kind=dp),
ALLOCATABLE,
DIMENSION(:, :) :: buffer_recv, buffer_send
1771 TYPE(cp_blacs_env_type),
POINTER :: context
1772 TYPE(mp_para_env_type),
POINTER :: para_env
1774 CALL timeset(routinen, handle)
1776 CALL cp_fm_struct_get(fm_work_iap%matrix_struct, para_env=para_env, ncol_locals=ncol_locals, &
1777 ncol_local=ncol_local, col_indices=col_indices, &
1778 context=context, nrow_local=nrow_local)
1779 CALL context%get(my_process_row=my_prow, my_process_column=my_pcol, &
1780 number_of_process_columns=num_pe_col, blacs2mpi=blacs2mpi)
1782 num_ab_pairs =
SIZE(pair_list, 2)
1786 DO ab_counter = 1, num_ab_pairs
1788 my_a = pair_list(1, ab_counter)
1789 my_b = pair_list(2, ab_counter)
1793 DO col_local = 1, ncol_local
1794 col_global = col_indices(col_local)
1796 iocc = max(1, col_global - 1)/virtual + 1
1797 avirt = col_global - (iocc - 1)*virtual
1799 IF (avirt /= my_b) cycle
1800 pcol = fm_work_iap%matrix_struct%g2p_col((iocc - 1)*virtual + my_a)
1801 IF (pcol /= my_pcol) cycle
1802 my_col_local = fm_work_iap%matrix_struct%g2l_col((iocc - 1)*virtual + my_a)
1804 trace = trace + accurate_dot_product_2(fm_mat_s%local_data(:, my_col_local), fm_work_iap%local_data(:, col_local), &
1809 p_ab(ab_counter) = p_ab(ab_counter) &
1810 + trace*sinh_over_x(0.5_dp*(eigenval(my_a) - eigenval(my_b))*omega)*omega*weight
1814 IF (num_pe_col > 1)
THEN
1815 size_send_buffer = 0
1816 size_recv_buffer = 0
1817 DO proc_shift = 1, num_pe_col - 1
1818 pcol_send =
modulo(my_pcol + proc_shift, num_pe_col)
1819 pcol_recv =
modulo(my_pcol - proc_shift, num_pe_col)
1821 IF (
ALLOCATED(index2send(pcol_send)%array))
THEN
1822 size_send_buffer = max(size_send_buffer,
SIZE(index2send(pcol_send)%array))
1825 IF (
ALLOCATED(index2recv(pcol_recv)%array))
THEN
1826 size_recv_buffer = max(size_recv_buffer,
SIZE(index2recv(pcol_recv)%array))
1830 ALLOCATE (buffer_send(nrow_local, size_send_buffer), buffer_recv(nrow_local, size_recv_buffer))
1832 DO proc_shift = 1, num_pe_col - 1
1833 pcol_send =
modulo(my_pcol + proc_shift, num_pe_col)
1834 pcol_recv =
modulo(my_pcol - proc_shift, num_pe_col)
1838 IF (
ALLOCATED(index2send(pcol_send)%array)) send_size =
SIZE(index2send(pcol_send)%array)
1840 DO counter = 1, send_size
1841 buffer_send(:, counter) = fm_work_iap%local_data(:, index2send(pcol_send)%array(counter))
1845 IF (
ALLOCATED(index2recv(pcol_recv)%array)) recv_size =
SIZE(index2recv(pcol_recv)%array)
1846 IF (recv_size > 0)
THEN
1847 CALL timeset(routinen//
"_send", handle2)
1848 IF (send_size > 0)
THEN
1849 CALL para_env%sendrecv(buffer_send(:, :send_size), blacs2mpi(my_prow, pcol_send), &
1850 buffer_recv(:, :recv_size), blacs2mpi(my_prow, pcol_recv), tag)
1852 CALL para_env%recv(buffer_recv(:, :recv_size), blacs2mpi(my_prow, pcol_recv), tag)
1854 CALL timestop(handle2)
1856 DO ab_counter = 1, num_ab_pairs
1859 my_a = pair_list(1, ab_counter)
1860 my_b = pair_list(2, ab_counter)
1864 DO col_local = 1,
SIZE(index2recv(pcol_recv)%array)
1865 col_global = index2recv(pcol_recv)%array(col_local)
1867 iocc = max(1, col_global - 1)/virtual + 1
1868 avirt = col_global - (iocc - 1)*virtual
1869 IF (avirt /= my_b) cycle
1870 pcol = fm_work_iap%matrix_struct%g2p_col((iocc - 1)*virtual + my_a)
1871 IF (pcol /= my_pcol) cycle
1873 my_col_local = fm_work_iap%matrix_struct%g2l_col((iocc - 1)*virtual + my_a)
1875 trace = trace + accurate_dot_product_2(fm_mat_s%local_data(:, my_col_local), buffer_recv(:, col_local), &
1879 p_ab(ab_counter) = p_ab(ab_counter) &
1880 + trace*sinh_over_x(0.5_dp*(eigenval(my_a) - eigenval(my_b))*omega)*omega*weight
1883 ELSE IF (send_size > 0)
THEN
1884 CALL timeset(routinen//
"_send", handle2)
1885 CALL para_env%send(buffer_send(:, :send_size), blacs2mpi(my_prow, pcol_send), tag)
1886 CALL timestop(handle2)
1889 IF (
ALLOCATED(buffer_send))
DEALLOCATE (buffer_send)
1890 IF (
ALLOCATED(buffer_recv))
DEALLOCATE (buffer_recv)
1893 CALL timestop(handle)
1895 END SUBROUTINE calc_pab_degen
1907 SUBROUTINE redistribute_fm_mat_s(index2send, index2recv, fm_mat_S, mat_S_3D, gd_homo, gd_virtual, mepos)
1908 TYPE(one_dim_int_array),
DIMENSION(0:),
INTENT(IN) :: index2send
1909 TYPE(two_dim_int_array),
DIMENSION(0:),
INTENT(IN) :: index2recv
1910 TYPE(cp_fm_type),
INTENT(IN) :: fm_mat_s
1911 REAL(kind=dp),
ALLOCATABLE,
DIMENSION(:, :, :), &
1912 INTENT(OUT) :: mat_s_3d
1913 TYPE(group_dist_d1_type),
INTENT(IN) :: gd_homo, gd_virtual
1914 INTEGER,
DIMENSION(2),
INTENT(IN) :: mepos
1916 CHARACTER(LEN=*),
PARAMETER :: routinen =
'redistribute_fm_mat_S'
1918 INTEGER :: col_local, handle, my_a, my_homo, my_i, my_pcol, my_prow, my_virtual, nrow_local, &
1919 num_pe_col, proc_recv, proc_send, proc_shift, recv_size, send_size, size_recv_buffer, &
1920 size_send_buffer, tag
1921 INTEGER,
DIMENSION(:, :),
POINTER :: blacs2mpi
1922 REAL(kind=dp),
ALLOCATABLE,
DIMENSION(:, :) :: buffer_recv, buffer_send
1923 TYPE(mp_para_env_type),
POINTER :: para_env
1925 CALL timeset(routinen, handle)
1929 CALL fm_mat_s%matrix_struct%context%get(my_process_row=my_prow, my_process_column=my_pcol, &
1930 number_of_process_columns=num_pe_col, blacs2mpi=blacs2mpi)
1932 CALL cp_fm_struct_get(fm_mat_s%matrix_struct, nrow_local=nrow_local, para_env=para_env)
1934 CALL get_group_dist(gd_homo, mepos(2), sizes=my_homo)
1935 CALL get_group_dist(gd_virtual, mepos(1), sizes=my_virtual)
1937 ALLOCATE (mat_s_3d(nrow_local, my_virtual, my_homo))
1939 IF (
ALLOCATED(index2send(my_pcol)%array))
THEN
1940 DO col_local = 1,
SIZE(index2send(my_pcol)%array)
1941 my_a = index2recv(my_pcol)%array(1, col_local)
1942 my_i = index2recv(my_pcol)%array(2, col_local)
1943 mat_s_3d(:, my_a, my_i) = fm_mat_s%local_data(:, index2send(my_pcol)%array(col_local))
1947 IF (num_pe_col > 1)
THEN
1948 size_send_buffer = 0
1949 size_recv_buffer = 0
1950 DO proc_shift = 1, num_pe_col - 1
1951 proc_send =
modulo(my_pcol + proc_shift, num_pe_col)
1952 proc_recv =
modulo(my_pcol - proc_shift, num_pe_col)
1955 IF (
ALLOCATED(index2send(proc_send)%array)) send_size =
SIZE(index2send(proc_send)%array)
1956 size_send_buffer = max(size_send_buffer, send_size)
1959 IF (
ALLOCATED(index2recv(proc_recv)%array)) recv_size =
SIZE(index2recv(proc_recv)%array)
1960 size_recv_buffer = max(size_recv_buffer, recv_size)
1964 ALLOCATE (buffer_send(nrow_local, size_send_buffer), buffer_recv(nrow_local, size_recv_buffer))
1966 DO proc_shift = 1, num_pe_col - 1
1967 proc_send =
modulo(my_pcol + proc_shift, num_pe_col)
1968 proc_recv =
modulo(my_pcol - proc_shift, num_pe_col)
1971 IF (
ALLOCATED(index2send(proc_send)%array)) send_size =
SIZE(index2send(proc_send)%array)
1972 DO col_local = 1, send_size
1973 buffer_send(:, col_local) = fm_mat_s%local_data(:, index2send(proc_send)%array(col_local))
1977 IF (
ALLOCATED(index2recv(proc_recv)%array)) recv_size =
SIZE(index2recv(proc_recv)%array, 2)
1978 IF (recv_size > 0)
THEN
1979 IF (send_size > 0)
THEN
1980 CALL para_env%sendrecv(buffer_send(:, :send_size), blacs2mpi(my_prow, proc_send), &
1981 buffer_recv(:, :recv_size), blacs2mpi(my_prow, proc_recv), tag)
1983 CALL para_env%recv(buffer_recv(:, :recv_size), blacs2mpi(my_prow, proc_recv), tag)
1986 DO col_local = 1, recv_size
1987 my_a = index2recv(proc_recv)%array(1, col_local)
1988 my_i = index2recv(proc_recv)%array(2, col_local)
1989 mat_s_3d(:, my_a, my_i) = buffer_recv(:, col_local)
1991 ELSE IF (send_size > 0)
THEN
1992 CALL para_env%send(buffer_send(:, :send_size), blacs2mpi(my_prow, proc_send), tag)
1997 IF (
ALLOCATED(buffer_send))
DEALLOCATE (buffer_send)
1998 IF (
ALLOCATED(buffer_recv))
DEALLOCATE (buffer_recv)
2001 CALL timestop(handle)
2003 END SUBROUTINE redistribute_fm_mat_s
2019 color_sub, do_ri_sos_laplace_mp2, homo, virtual)
2021 TYPE(mp2_type),
INTENT(INOUT) :: mp2_env
2022 TYPE(mp_para_env_type),
INTENT(IN),
POINTER :: para_env_sub, para_env
2023 TYPE(qs_environment_type),
INTENT(IN),
POINTER :: qs_env
2024 TYPE(group_dist_d1_type) :: gd_array
2025 INTEGER,
INTENT(IN) :: color_sub
2026 LOGICAL,
INTENT(IN) :: do_ri_sos_laplace_mp2
2027 INTEGER,
DIMENSION(:),
INTENT(IN) :: homo, virtual
2029 CHARACTER(LEN=*),
PARAMETER :: routinen =
'rpa_grad_finalize'
2031 INTEGER :: dimen_ia, dimen_ri, handle, iib, ispin, my_group_l_end, my_group_l_size, &
2032 my_group_l_start, my_ia_end, my_ia_size, my_ia_start, my_p_end, my_p_size, my_p_start, &
2034 REAL(kind=dp) :: my_scale
2035 REAL(kind=dp),
ALLOCATABLE,
DIMENSION(:, :) :: gamma_2d
2036 TYPE(cp_blacs_env_type),
POINTER :: blacs_env
2037 TYPE(cp_fm_struct_type),
POINTER :: fm_struct
2038 TYPE(cp_fm_type) :: fm_g_p_ia, fm_pq, fm_pq_2, fm_pq_half, &
2039 fm_work_pq, fm_work_pq_2, fm_y, &
2041 TYPE(group_dist_d1_type) :: gd_ia, gd_p
2043 CALL timeset(routinen, handle)
2050 IF (do_ri_sos_laplace_mp2)
THEN
2051 my_scale = mp2_env%scale_s
2053 my_scale = -mp2_env%ri_rpa%scale_rpa/(2.0_dp*pi)
2054 IF (mp2_env%ri_rpa%minimax_quad) my_scale = my_scale/2.0_dp
2057 IF (do_ri_sos_laplace_mp2)
THEN
2058 CALL sos_mp2_grad_finalize(
rpa_grad%sos_mp2_work_occ,
rpa_grad%sos_mp2_work_virt, &
2059 para_env, para_env_sub, homo, virtual, mp2_env)
2061 CALL rpa_grad_work_finalize(
rpa_grad%rpa_work, mp2_env, homo, &
2062 virtual, para_env, para_env_sub)
2065 CALL get_qs_env(qs_env, blacs_env=blacs_env)
2067 CALL cp_fm_get_info(
rpa_grad%fm_Gamma_PQ, ncol_global=dimen_ri)
2070 CALL cp_fm_struct_create(fm_struct, context=blacs_env, nrow_global=dimen_ri, &
2071 ncol_global=dimen_ri, para_env=para_env)
2072 CALL cp_fm_create(fm_pq, fm_struct)
2073 CALL cp_fm_create(fm_work_pq, fm_struct)
2074 IF (.NOT. compare_potential_types(mp2_env%ri_metric, mp2_env%potential_parameter))
THEN
2075 CALL cp_fm_create(fm_pq_2, fm_struct)
2077 CALL cp_fm_struct_release(fm_struct)
2078 CALL cp_fm_set_all(fm_pq, 0.0_dp)
2081 CALL dereplicate_and_sum_fm(
rpa_grad%fm_Gamma_PQ, fm_pq)
2084 CALL create_group_dist(gd_p, para_env_sub%num_pe, dimen_ri)
2085 CALL get_group_dist(gd_p, para_env_sub%mepos, my_p_start, my_p_end, my_p_size)
2087 CALL get_group_dist(gd_array, color_sub, my_group_l_start, my_group_l_end, my_group_l_size)
2089 CALL release_group_dist(gd_p)
2091 CALL cp_array_to_fm(mp2_env%ri_grad%PQ_half, fm_pq%matrix_struct, my_p_start, my_p_end, &
2092 my_group_l_start, my_group_l_end, fm_pq_half)
2094 IF (.NOT. compare_potential_types(mp2_env%ri_metric, mp2_env%potential_parameter))
THEN
2095 CALL cp_array_to_fm(mp2_env%ri_grad%operator_half, fm_pq%matrix_struct, my_p_start, my_p_end, &
2096 my_group_l_start, my_group_l_end, operator_half)
2099 IF (compare_potential_types(mp2_env%ri_metric, mp2_env%potential_parameter))
THEN
2101 CALL parallel_gemm(transa=
"N", transb=
"T", m=dimen_ri, n=dimen_ri, k=dimen_ri, alpha=1.0_dp, &
2102 matrix_a=fm_pq, matrix_b=fm_pq_half, beta=0.0_dp, &
2103 matrix_c=fm_work_pq)
2105 CALL parallel_gemm(transa=
"N", transb=
"N", m=dimen_ri, n=dimen_ri, k=dimen_ri, alpha=-my_scale, &
2106 matrix_a=fm_pq_half, matrix_b=fm_work_pq, beta=0.0_dp, &
2109 CALL cp_fm_release(fm_work_pq)
2111 CALL parallel_gemm(transa=
"N", transb=
"T", m=dimen_ri, n=dimen_ri, k=dimen_ri, alpha=1.0_dp, &
2112 matrix_a=fm_pq, matrix_b=operator_half, beta=0.0_dp, &
2113 matrix_c=fm_work_pq)
2115 CALL parallel_gemm(transa=
"N", transb=
"N", m=dimen_ri, n=dimen_ri, k=dimen_ri, alpha=my_scale, &
2116 matrix_a=operator_half, matrix_b=fm_work_pq, beta=0.0_dp, &
2118 CALL cp_fm_release(operator_half)
2120 CALL cp_fm_create(fm_work_pq_2, fm_pq%matrix_struct, name=
"fm_Gamma_PQ_2")
2121 CALL parallel_gemm(transa=
"N", transb=
"N", m=dimen_ri, n=dimen_ri, k=dimen_ri, alpha=-my_scale, &
2122 matrix_a=fm_pq_half, matrix_b=fm_work_pq, beta=0.0_dp, &
2123 matrix_c=fm_work_pq_2)
2124 CALL cp_fm_to_fm(fm_work_pq_2, fm_pq_2)
2125 CALL cp_fm_geadd(1.0_dp,
"T", fm_work_pq_2, 1.0_dp, fm_pq_2)
2126 CALL cp_fm_release(fm_work_pq_2)
2127 CALL cp_fm_release(fm_work_pq)
2130 CALL cp_fm_to_array(mp2_env%ri_grad%Gamma_PQ, my_p_start, my_p_end, my_group_l_start, my_group_l_end, &
2133 IF (.NOT. compare_potential_types(mp2_env%ri_metric, mp2_env%potential_parameter))
THEN
2134 CALL cp_fm_to_array(mp2_env%ri_grad%Gamma_PQ_2, my_p_start, my_p_end, my_group_l_start, &
2135 my_group_l_end, fm_pq_2)
2139 ALLOCATE (mp2_env%ri_grad%G_P_ia(my_group_l_size, nspins))
2140 DO ispin = 1, nspins
2141 DO iib = 1, my_group_l_size
2142 NULLIFY (mp2_env%ri_grad%G_P_ia(iib, ispin)%matrix)
2147 DO ispin = 1, nspins
2149 CALL cp_fm_get_info(
rpa_grad%fm_Y(ispin), ncol_global=dimen_ia)
2151 CALL get_qs_env(qs_env, blacs_env=blacs_env)
2154 CALL cp_fm_struct_create(fm_struct, template_fmstruct=fm_pq_half%matrix_struct, nrow_global=dimen_ia)
2155 CALL cp_fm_create(fm_y, fm_struct)
2156 CALL cp_fm_struct_release(fm_struct)
2157 CALL cp_fm_set_all(fm_y, 0.0_dp)
2159 CALL dereplicate_and_sum_fm(
rpa_grad%fm_Y(ispin), fm_y)
2161 CALL cp_fm_create(fm_g_p_ia, fm_y%matrix_struct)
2162 CALL cp_fm_set_all(fm_g_p_ia, 0.0_dp)
2164 CALL parallel_gemm(transa=
"N", transb=
"T", m=dimen_ia, n=dimen_ri, k=dimen_ri, alpha=my_scale, &
2165 matrix_a=fm_y, matrix_b=fm_pq_half, beta=0.0_dp, &
2168 CALL cp_fm_release(fm_y)
2170 CALL create_group_dist(gd_ia, para_env_sub%num_pe, dimen_ia)
2171 CALL get_group_dist(gd_ia, para_env_sub%mepos, my_ia_start, my_ia_end, my_ia_size)
2173 CALL cp_fm_to_array(gamma_2d, my_ia_start, my_ia_end, my_group_l_start, my_group_l_end, fm_g_p_ia)
2176 CALL cp_array_to_dbcsr_slices(gamma_2d, homo(ispin), virtual(ispin), para_env_sub, my_ia_start, &
2178 mp2_env%ri_grad%mo_coeff_o(ispin)%matrix, &
2179 matrix_ptrs=mp2_env%ri_grad%G_P_ia(:, ispin))
2181 CALL release_group_dist(gd_ia)
2185 CALL cp_fm_release(fm_pq_half)
2187 CALL timestop(handle)
2201 SUBROUTINE sos_mp2_grad_finalize(sos_mp2_work_occ, sos_mp2_work_virt, para_env, para_env_sub, homo, virtual, mp2_env)
2202 TYPE(sos_mp2_grad_work_type),
ALLOCATABLE, &
2203 DIMENSION(:),
INTENT(INOUT) :: sos_mp2_work_occ, sos_mp2_work_virt
2204 TYPE(mp_para_env_type),
INTENT(IN),
POINTER :: para_env, para_env_sub
2205 INTEGER,
DIMENSION(:),
INTENT(IN) :: homo, virtual
2206 TYPE(mp2_type),
INTENT(INOUT) :: mp2_env
2208 CHARACTER(LEN=*),
PARAMETER :: routinen =
'sos_mp2_grad_finalize'
2210 INTEGER :: ab_counter, handle, ij_counter, ispin, &
2211 itmp(2), my_a, my_b, my_b_end, &
2212 my_b_size, my_b_start, my_i, my_j, &
2214 REAL(kind=dp) :: my_scale
2216 CALL timeset(routinen, handle)
2218 nspins =
SIZE(sos_mp2_work_occ)
2219 my_scale = mp2_env%scale_s
2221 DO ispin = 1, nspins
2222 DO pcol = 0,
SIZE(sos_mp2_work_occ(ispin)%index2send, 1) - 1
2223 IF (
ALLOCATED(sos_mp2_work_occ(ispin)%index2send(pcol)%array))
THEN
2224 DEALLOCATE (sos_mp2_work_occ(ispin)%index2send(pcol)%array)
2226 IF (
ALLOCATED(sos_mp2_work_occ(ispin)%index2send(pcol)%array))
THEN
2227 DEALLOCATE (sos_mp2_work_occ(ispin)%index2send(pcol)%array)
2229 IF (
ALLOCATED(sos_mp2_work_virt(ispin)%index2recv(pcol)%array))
THEN
2230 DEALLOCATE (sos_mp2_work_virt(ispin)%index2recv(pcol)%array)
2232 IF (
ALLOCATED(sos_mp2_work_virt(ispin)%index2recv(pcol)%array))
THEN
2233 DEALLOCATE (sos_mp2_work_virt(ispin)%index2recv(pcol)%array)
2236 DEALLOCATE (sos_mp2_work_occ(ispin)%index2send, &
2237 sos_mp2_work_occ(ispin)%index2recv, &
2238 sos_mp2_work_virt(ispin)%index2send, &
2239 sos_mp2_work_virt(ispin)%index2recv)
2243 DO ispin = 1, nspins
2244 CALL para_env%sum(sos_mp2_work_occ(ispin)%P)
2246 ALLOCATE (mp2_env%ri_grad%P_ij(ispin)%array(homo(ispin), homo(ispin)))
2247 mp2_env%ri_grad%P_ij(ispin)%array = 0.0_dp
2248 DO my_i = 1, homo(ispin)
2249 mp2_env%ri_grad%P_ij(ispin)%array(my_i, my_i) = my_scale*sos_mp2_work_occ(ispin)%P(my_i)
2251 DO ij_counter = 1,
SIZE(sos_mp2_work_occ(ispin)%pair_list, 2)
2252 my_i = sos_mp2_work_occ(ispin)%pair_list(1, ij_counter)
2253 my_j = sos_mp2_work_occ(ispin)%pair_list(2, ij_counter)
2255 mp2_env%ri_grad%P_ij(ispin)%array(my_i, my_j) = my_scale*sos_mp2_work_occ(ispin)%P(homo(ispin) + ij_counter)
2257 DEALLOCATE (sos_mp2_work_occ(ispin)%P, sos_mp2_work_occ(ispin)%pair_list)
2260 mp2_env%ri_grad%P_ij(ispin)%array(:, :) = 0.5_dp*(mp2_env%ri_grad%P_ij(ispin)%array + &
2261 transpose(mp2_env%ri_grad%P_ij(ispin)%array))
2265 CALL para_env%sum(sos_mp2_work_virt(ispin)%P)
2267 itmp = get_limit(virtual(ispin), para_env_sub%num_pe, para_env_sub%mepos)
2268 my_b_size = itmp(2) - itmp(1) + 1
2269 my_b_start = itmp(1)
2272 ALLOCATE (mp2_env%ri_grad%P_ab(ispin)%array(my_b_size, virtual(ispin)))
2273 mp2_env%ri_grad%P_ab(ispin)%array = 0.0_dp
2274 DO my_a = itmp(1), itmp(2)
2275 mp2_env%ri_grad%P_ab(ispin)%array(my_a - itmp(1) + 1, my_a) = my_scale*sos_mp2_work_virt(ispin)%P(my_a)
2277 DO ab_counter = 1,
SIZE(sos_mp2_work_virt(ispin)%pair_list, 2)
2278 my_a = sos_mp2_work_virt(ispin)%pair_list(1, ab_counter)
2279 my_b = sos_mp2_work_virt(ispin)%pair_list(2, ab_counter)
2281 IF (my_a >= itmp(1) .AND. my_a <= itmp(2)) mp2_env%ri_grad%P_ab(ispin)%array(my_a - itmp(1) + 1, my_b) = &
2282 my_scale*sos_mp2_work_virt(ispin)%P(virtual(ispin) + ab_counter)
2285 DEALLOCATE (sos_mp2_work_virt(ispin)%P, sos_mp2_work_virt(ispin)%pair_list)
2288 IF (para_env_sub%num_pe > 1)
THEN
2290 INTEGER :: send_a_start, send_a_end, send_a_size, &
2291 recv_a_start, recv_a_end, recv_a_size, proc_shift, proc_send, proc_recv
2292 REAL(kind=dp),
DIMENSION(:),
ALLOCATABLE,
TARGET :: buffer_send_1d
2293 REAL(kind=dp),
DIMENSION(:, :),
POINTER :: buffer_send
2294 REAL(kind=dp),
DIMENSION(:, :),
ALLOCATABLE :: buffer_recv
2295 TYPE(group_dist_d1_type) :: gd_virtual_sub
2297 CALL create_group_dist(gd_virtual_sub, para_env_sub%num_pe, virtual(ispin))
2299 mp2_env%ri_grad%P_ab(ispin)%array(:, my_b_start:my_b_end) = &
2300 0.5_dp*(mp2_env%ri_grad%P_ab(ispin)%array(:, my_b_start:my_b_end) &
2301 + transpose(mp2_env%ri_grad%P_ab(ispin)%array(:, my_b_start:my_b_end)))
2303 ALLOCATE (buffer_send_1d(my_b_size*maxsize(gd_virtual_sub)))
2304 ALLOCATE (buffer_recv(my_b_size, maxsize(gd_virtual_sub)))
2306 DO proc_shift = 1, para_env_sub%num_pe - 1
2308 proc_send =
modulo(para_env_sub%mepos + proc_shift, para_env_sub%num_pe)
2309 proc_recv =
modulo(para_env_sub%mepos - proc_shift, para_env_sub%num_pe)
2311 CALL get_group_dist(gd_virtual_sub, proc_send, send_a_start, send_a_end, send_a_size)
2312 CALL get_group_dist(gd_virtual_sub, proc_recv, recv_a_start, recv_a_end, recv_a_size)
2314 buffer_send(1:send_a_size, 1:my_b_size) => buffer_send_1d(1:my_b_size*send_a_size)
2316 buffer_send(:send_a_size, :) = transpose(mp2_env%ri_grad%P_ab(ispin)%array(:, send_a_start:send_a_end))
2317 CALL para_env_sub%sendrecv(buffer_send(:send_a_size, :), proc_send, &
2318 buffer_recv(:, :recv_a_size), proc_recv)
2320 mp2_env%ri_grad%P_ab(ispin)%array(:, recv_a_start:recv_a_end) = &
2321 0.5_dp*(mp2_env%ri_grad%P_ab(ispin)%array(:, recv_a_start:recv_a_end) + buffer_recv(:, 1:recv_a_size))
2325 DEALLOCATE (buffer_send_1d, buffer_recv)
2327 CALL release_group_dist(gd_virtual_sub)
2330 mp2_env%ri_grad%P_ab(ispin)%array(:, :) = 0.5_dp*(mp2_env%ri_grad%P_ab(ispin)%array + &
2331 transpose(mp2_env%ri_grad%P_ab(ispin)%array))
2335 DEALLOCATE (sos_mp2_work_occ, sos_mp2_work_virt)
2336 IF (nspins == 1)
THEN
2337 mp2_env%ri_grad%P_ij(1)%array(:, :) = 2.0_dp*mp2_env%ri_grad%P_ij(1)%array
2338 mp2_env%ri_grad%P_ab(1)%array(:, :) = 2.0_dp*mp2_env%ri_grad%P_ab(1)%array
2341 CALL timestop(handle)
2343 END SUBROUTINE sos_mp2_grad_finalize
2354 SUBROUTINE rpa_grad_work_finalize(rpa_work, mp2_env, homo, virtual, para_env, para_env_sub)
2355 TYPE(rpa_grad_work_type),
INTENT(INOUT) :: rpa_work
2356 TYPE(mp2_type),
INTENT(INOUT) :: mp2_env
2357 INTEGER,
DIMENSION(:),
INTENT(IN) :: homo, virtual
2358 TYPE(mp_para_env_type),
INTENT(IN),
POINTER :: para_env, para_env_sub
2360 CHARACTER(LEN=*),
PARAMETER :: routinen =
'rpa_grad_work_finalize'
2362 INTEGER :: handle, ispin, itmp(2), my_a_end, my_a_size, my_a_start, my_b_end, my_b_size, &
2363 my_b_start, my_i_end, my_i_size, my_i_start, nspins, proc, proc_recv, proc_send, &
2364 proc_shift, recv_a_end, recv_a_size, recv_a_start, recv_end, recv_start, send_a_end, &
2365 send_a_size, send_a_start, send_end, send_start, size_recv_buffer, size_send_buffer
2366 REAL(kind=dp) :: my_scale
2367 REAL(kind=dp),
ALLOCATABLE,
DIMENSION(:, :) :: buffer_recv, buffer_send
2368 TYPE(group_dist_d1_type) :: gd_a_sub, gd_virtual_sub
2370 CALL timeset(routinen, handle)
2373 my_scale = mp2_env%ri_rpa%scale_rpa/(2.0_dp*pi)
2374 IF (mp2_env%ri_rpa%minimax_quad) my_scale = my_scale/2.0_dp
2376 CALL cp_fm_release(rpa_work%fm_mat_Q_copy)
2378 DO ispin = 1, nspins
2379 DO proc = 0,
SIZE(rpa_work%index2send, 1) - 1
2380 IF (
ALLOCATED(rpa_work%index2send(proc, ispin)%array))
DEALLOCATE (rpa_work%index2send(proc, ispin)%array)
2381 IF (
ALLOCATED(rpa_work%index2recv(proc, ispin)%array))
DEALLOCATE (rpa_work%index2recv(proc, ispin)%array)
2384 DEALLOCATE (rpa_work%index2send, rpa_work%index2recv)
2386 DO ispin = 1, nspins
2387 CALL get_group_dist(rpa_work%gd_homo(ispin), rpa_work%mepos(2), my_i_start, my_i_end, my_i_size)
2388 CALL release_group_dist(rpa_work%gd_homo(ispin))
2390 ALLOCATE (mp2_env%ri_grad%P_ij(ispin)%array(homo(ispin), homo(ispin)))
2391 mp2_env%ri_grad%P_ij(ispin)%array = 0.0_dp
2392 mp2_env%ri_grad%P_ij(ispin)%array(my_i_start:my_i_end, :) = my_scale*rpa_work%P_ij(ispin)%array
2393 DEALLOCATE (rpa_work%P_ij(ispin)%array)
2394 CALL para_env%sum(mp2_env%ri_grad%P_ij(ispin)%array)
2397 mp2_env%ri_grad%P_ij(ispin)%array(:, :) = 0.5_dp*(mp2_env%ri_grad%P_ij(ispin)%array + &
2398 transpose(mp2_env%ri_grad%P_ij(ispin)%array))
2400 itmp = get_limit(virtual(ispin), para_env_sub%num_pe, para_env_sub%mepos)
2401 my_b_start = itmp(1)
2403 my_b_size = my_b_end - my_b_start + 1
2405 ALLOCATE (mp2_env%ri_grad%P_ab(ispin)%array(my_b_size, virtual(ispin)))
2406 mp2_env%ri_grad%P_ab(ispin)%array = 0.0_dp
2408 CALL get_group_dist(rpa_work%gd_virtual(ispin), rpa_work%mepos(1), my_a_start, my_a_end, my_a_size)
2409 CALL release_group_dist(rpa_work%gd_virtual(ispin))
2411 CALL create_group_dist(gd_a_sub, my_a_start, my_a_end, my_a_size, para_env_sub)
2413 CALL create_group_dist(gd_virtual_sub, para_env_sub%num_pe, virtual(ispin))
2416 send_start = max(1, my_b_start - my_a_start + 1)
2417 send_end = min(my_a_size, my_b_end - my_a_start + 1)
2420 recv_start = max(1, my_a_start - my_b_start + 1)
2421 recv_end = min(my_b_size, my_a_end - my_b_start + 1)
2423 mp2_env%ri_grad%P_ab(ispin)%array(recv_start:recv_end, :) = &
2424 my_scale*rpa_work%P_ab(ispin)%array(send_start:send_end, :)
2426 IF (para_env_sub%num_pe > 1)
THEN
2427 size_send_buffer = 0
2428 size_recv_buffer = 0
2429 DO proc_shift = 1, para_env_sub%num_pe - 1
2430 proc_send =
modulo(para_env_sub%mepos + proc_shift, para_env_sub%num_pe)
2431 proc_recv =
modulo(para_env_sub%mepos - proc_shift, para_env_sub%num_pe)
2433 CALL get_group_dist(gd_virtual_sub, proc_send, send_a_start, send_a_end)
2434 CALL get_group_dist(gd_a_sub, proc_recv, recv_a_start, recv_a_end)
2437 send_start = max(1, send_a_start - my_a_start + 1)
2438 send_end = min(my_a_size, send_a_end - my_a_start + 1)
2440 size_send_buffer = max(size_send_buffer, max(send_end - send_start + 1, 0))
2443 recv_start = max(1, recv_a_start - my_b_start + 1)
2444 recv_end = min(my_b_size, recv_a_end - my_b_start + 1)
2446 size_recv_buffer = max(size_recv_buffer, max(recv_end - recv_start + 1, 0))
2448 ALLOCATE (buffer_send(size_send_buffer, virtual(ispin)), buffer_recv(size_recv_buffer, virtual(ispin)))
2450 DO proc_shift = 1, para_env_sub%num_pe - 1
2451 proc_send =
modulo(para_env_sub%mepos + proc_shift, para_env_sub%num_pe)
2452 proc_recv =
modulo(para_env_sub%mepos - proc_shift, para_env_sub%num_pe)
2454 CALL get_group_dist(gd_virtual_sub, proc_send, send_a_start, send_a_end)
2455 CALL get_group_dist(gd_a_sub, proc_recv, recv_a_start, recv_a_end)
2458 send_start = max(1, send_a_start - my_a_start + 1)
2459 send_end = min(my_a_size, send_a_end - my_a_start + 1)
2460 buffer_send(1:max(send_end - send_start + 1, 0), :) = rpa_work%P_ab(ispin)%array(send_start:send_end, :)
2463 recv_start = max(1, recv_a_start - my_b_start + 1)
2464 recv_end = min(my_b_size, recv_a_end - my_b_start + 1)
2466 CALL para_env_sub%sendrecv(buffer_send(1:max(send_end - send_start + 1, 0), :), proc_send, &
2467 buffer_recv(1:max(recv_end - recv_start + 1, 0), :), proc_recv)
2469 mp2_env%ri_grad%P_ab(ispin)%array(recv_start:recv_end, :) = &
2470 mp2_env%ri_grad%P_ab(ispin)%array(recv_start:recv_end, :) + &
2471 my_scale*buffer_recv(1:max(recv_end - recv_start + 1, 0), :)
2475 IF (
ALLOCATED(buffer_send))
DEALLOCATE (buffer_send)
2476 IF (
ALLOCATED(buffer_recv))
DEALLOCATE (buffer_recv)
2478 DEALLOCATE (rpa_work%P_ab(ispin)%array)
2480 CALL release_group_dist(gd_a_sub)
2483 TYPE(mp_comm_type) :: comm_exchange
2484 CALL comm_exchange%from_split(para_env, para_env_sub%mepos)
2485 CALL comm_exchange%sum(mp2_env%ri_grad%P_ab(ispin)%array)
2486 CALL comm_exchange%free()
2490 IF (para_env_sub%num_pe > 1)
THEN
2492 REAL(kind=dp),
DIMENSION(:),
ALLOCATABLE,
TARGET :: buffer_send_1d
2493 REAL(kind=dp),
DIMENSION(:, :),
POINTER :: buffer_send
2494 REAL(kind=dp),
DIMENSION(:, :),
ALLOCATABLE :: buffer_recv
2496 mp2_env%ri_grad%P_ab(ispin)%array(:, my_b_start:my_b_end) = &
2497 0.5_dp*(mp2_env%ri_grad%P_ab(ispin)%array(:, my_b_start:my_b_end) &
2498 + transpose(mp2_env%ri_grad%P_ab(ispin)%array(:, my_b_start:my_b_end)))
2500 ALLOCATE (buffer_send_1d(my_b_size*maxsize(gd_virtual_sub)))
2501 ALLOCATE (buffer_recv(my_b_size, maxsize(gd_virtual_sub)))
2503 DO proc_shift = 1, para_env_sub%num_pe - 1
2505 proc_send =
modulo(para_env_sub%mepos + proc_shift, para_env_sub%num_pe)
2506 proc_recv =
modulo(para_env_sub%mepos - proc_shift, para_env_sub%num_pe)
2508 CALL get_group_dist(gd_virtual_sub, proc_send, send_a_start, send_a_end, send_a_size)
2509 CALL get_group_dist(gd_virtual_sub, proc_recv, recv_a_start, recv_a_end, recv_a_size)
2511 buffer_send(1:send_a_size, 1:my_b_size) => buffer_send_1d(1:my_b_size*send_a_size)
2513 buffer_send(:send_a_size, :) = transpose(mp2_env%ri_grad%P_ab(ispin)%array(:, send_a_start:send_a_end))
2514 CALL para_env_sub%sendrecv(buffer_send(:send_a_size, :), proc_send, &
2515 buffer_recv(:, :recv_a_size), proc_recv)
2517 mp2_env%ri_grad%P_ab(ispin)%array(:, recv_a_start:recv_a_end) = &
2518 0.5_dp*(mp2_env%ri_grad%P_ab(ispin)%array(:, recv_a_start:recv_a_end) + buffer_recv(:, 1:recv_a_size))
2522 DEALLOCATE (buffer_send_1d, buffer_recv)
2525 mp2_env%ri_grad%P_ab(ispin)%array(:, :) = 0.5_dp*(mp2_env%ri_grad%P_ab(ispin)%array + &
2526 transpose(mp2_env%ri_grad%P_ab(ispin)%array))
2529 CALL release_group_dist(gd_virtual_sub)
2532 DEALLOCATE (rpa_work%gd_homo, rpa_work%gd_virtual, rpa_work%P_ij, rpa_work%P_ab)
2533 IF (nspins == 1)
THEN
2534 mp2_env%ri_grad%P_ij(1)%array(:, :) = 2.0_dp*mp2_env%ri_grad%P_ij(1)%array
2535 mp2_env%ri_grad%P_ab(1)%array(:, :) = 2.0_dp*mp2_env%ri_grad%P_ab(1)%array
2538 CALL timestop(handle)
2539 END SUBROUTINE rpa_grad_work_finalize
2546 SUBROUTINE dereplicate_and_sum_fm(fm_sub, fm_global)
2547 TYPE(cp_fm_type),
INTENT(INOUT) :: fm_sub, fm_global
2549 CHARACTER(LEN=*),
PARAMETER :: routinen =
'dereplicate_and_sum_fm'
2551 INTEGER :: col_local, elements2recv_col, elements2recv_row, elements2send_col, &
2552 elements2send_row, handle, handle2, mypcol_global, myprow_global, ncol_local_global, &
2553 ncol_local_sub, npcol_global, npcol_sub, nprow_global, nprow_sub, nrow_local_global, &
2554 nrow_local_sub, pcol_recv, pcol_send, proc_recv, proc_send, proc_send_global, proc_shift, &
2555 prow_recv, prow_send, row_local, tag
2556 INTEGER(int_8) :: size_recv_buffer, size_send_buffer
2557 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: data2recv_col, data2recv_row, &
2558 data2send_col, data2send_row, &
2560 INTEGER,
DIMENSION(:),
POINTER :: col_indices_global, col_indices_sub, &
2561 row_indices_global, row_indices_sub
2562 INTEGER,
DIMENSION(:, :),
POINTER :: blacs2mpi_global, blacs2mpi_sub, &
2563 mpi2blacs_global, mpi2blacs_sub
2564 REAL(kind=dp),
ALLOCATABLE,
DIMENSION(:),
TARGET :: recv_buffer_1d, send_buffer_1d
2565 REAL(kind=dp),
DIMENSION(:, :),
POINTER :: recv_buffer, send_buffer
2566 TYPE(mp_para_env_type),
POINTER :: para_env, para_env_sub
2567 TYPE(one_dim_int_array),
ALLOCATABLE,
DIMENSION(:) :: index2recv_col, index2recv_row, &
2568 index2send_col, index2send_row
2570 CALL timeset(routinen, handle)
2574 nprow_sub = fm_sub%matrix_struct%context%num_pe(1)
2575 npcol_sub = fm_sub%matrix_struct%context%num_pe(2)
2577 myprow_global = fm_global%matrix_struct%context%mepos(1)
2578 mypcol_global = fm_global%matrix_struct%context%mepos(2)
2579 nprow_global = fm_global%matrix_struct%context%num_pe(1)
2580 npcol_global = fm_global%matrix_struct%context%num_pe(2)
2582 CALL cp_fm_get_info(fm_sub, col_indices=col_indices_sub, row_indices=row_indices_sub, &
2583 nrow_local=nrow_local_sub, ncol_local=ncol_local_sub)
2584 CALL cp_fm_struct_get(fm_sub%matrix_struct, para_env=para_env_sub)
2585 CALL cp_fm_struct_get(fm_global%matrix_struct, para_env=para_env, &
2586 col_indices=col_indices_global, row_indices=row_indices_global, &
2587 nrow_local=nrow_local_global, ncol_local=ncol_local_global)
2588 CALL fm_sub%matrix_struct%context%get(blacs2mpi=blacs2mpi_sub, mpi2blacs=mpi2blacs_sub)
2589 CALL fm_global%matrix_struct%context%get(blacs2mpi=blacs2mpi_global, mpi2blacs=mpi2blacs_global)
2591 IF (para_env%num_pe /= para_env_sub%num_pe)
THEN
2593 TYPE(mp_comm_type) :: comm_exchange
2594 comm_exchange = fm_sub%matrix_struct%context%interconnect(para_env)
2595 CALL comm_exchange%sum(fm_sub%local_data)
2596 CALL comm_exchange%free()
2600 ALLOCATE (subgroup2mepos(0:para_env_sub%num_pe - 1))
2601 CALL para_env_sub%allgather(para_env%mepos, subgroup2mepos)
2603 CALL timeset(routinen//
"_data2", handle2)
2605 CALL get_elements2send_col(data2send_col, fm_global%matrix_struct, row_indices_sub, index2send_col)
2606 CALL get_elements2send_row(data2send_row, fm_global%matrix_struct, col_indices_sub, index2send_row)
2610 CALL get_elements2send_col(data2recv_col, fm_sub%matrix_struct, row_indices_global, index2recv_col)
2611 CALL get_elements2send_row(data2recv_row, fm_sub%matrix_struct, col_indices_global, index2recv_row)
2612 CALL timestop(handle2)
2614 CALL timeset(routinen//
"_local", handle2)
2616 prow_send = mpi2blacs_global(1, para_env%mepos)
2617 pcol_send = mpi2blacs_global(2, para_env%mepos)
2618 prow_recv = mpi2blacs_sub(1, para_env_sub%mepos)
2619 pcol_recv = mpi2blacs_sub(2, para_env_sub%mepos)
2620 elements2recv_col = data2recv_col(pcol_recv)
2621 elements2recv_row = data2recv_row(prow_recv)
2627 DO col_local = 1, elements2recv_col
2628 DO row_local = 1, elements2recv_row
2629 fm_global%local_data(index2recv_col(pcol_recv)%array(col_local), &
2630 index2recv_row(prow_recv)%array(row_local)) &
2631 = fm_sub%local_data(index2send_col(pcol_send)%array(row_local), &
2632 index2send_row(prow_send)%array(col_local))
2636 CALL timestop(handle2)
2638 IF (para_env_sub%num_pe > 1)
THEN
2639 size_send_buffer = 0_int_8
2640 size_recv_buffer = 0_int_8
2642 DO proc_shift = 1, para_env_sub%num_pe - 1
2643 proc_send =
modulo(para_env_sub%mepos + proc_shift, para_env_sub%num_pe)
2644 proc_recv =
modulo(para_env_sub%mepos - proc_shift, para_env_sub%num_pe)
2646 proc_send_global = subgroup2mepos(proc_send)
2647 prow_send = mpi2blacs_global(1, proc_send_global)
2648 pcol_send = mpi2blacs_global(2, proc_send_global)
2649 elements2send_col = data2send_col(pcol_send)
2650 elements2send_row = data2send_row(prow_send)
2652 size_send_buffer = max(size_send_buffer, int(elements2send_col, int_8)*elements2send_row)
2654 prow_recv = mpi2blacs_sub(1, proc_recv)
2655 pcol_recv = mpi2blacs_sub(2, proc_recv)
2656 elements2recv_col = data2recv_col(pcol_recv)
2657 elements2recv_row = data2recv_row(prow_recv)
2659 size_recv_buffer = max(size_recv_buffer, int(elements2recv_col, int_8)*elements2recv_row)
2661 ALLOCATE (send_buffer_1d(size_send_buffer), recv_buffer_1d(size_recv_buffer))
2664 DO proc_shift = 1, para_env_sub%num_pe - 1
2665 proc_send =
modulo(para_env_sub%mepos + proc_shift, para_env_sub%num_pe)
2666 proc_recv =
modulo(para_env_sub%mepos - proc_shift, para_env_sub%num_pe)
2668 proc_send_global = subgroup2mepos(proc_send)
2669 prow_send = mpi2blacs_global(1, proc_send_global)
2670 pcol_send = mpi2blacs_global(2, proc_send_global)
2671 elements2send_col = data2send_col(pcol_send)
2672 elements2send_row = data2send_row(prow_send)
2674 CALL timeset(routinen//
"_pack", handle2)
2677 send_buffer(1:elements2send_row, 1:elements2send_col) => send_buffer_1d(1:int(elements2send_row, int_8)*elements2send_col)
2681 DO row_local = 1, elements2send_col
2682 DO col_local = 1, elements2send_row
2683 send_buffer(col_local, row_local) = &
2684 fm_sub%local_data(index2send_col(pcol_send)%array(row_local), &
2685 index2send_row(prow_send)%array(col_local))
2689 CALL timestop(handle2)
2691 prow_recv = mpi2blacs_sub(1, proc_recv)
2692 pcol_recv = mpi2blacs_sub(2, proc_recv)
2693 elements2recv_col = data2recv_col(pcol_recv)
2694 elements2recv_row = data2recv_row(prow_recv)
2697 recv_buffer(1:elements2recv_col, 1:elements2recv_row) => recv_buffer_1d(1:int(elements2recv_row, int_8)*elements2recv_col)
2698 IF (
SIZE(recv_buffer) > 0_int_8)
THEN
2699 IF (
SIZE(send_buffer) > 0_int_8)
THEN
2700 CALL para_env_sub%sendrecv(send_buffer, proc_send, recv_buffer, proc_recv, tag)
2702 CALL para_env_sub%recv(recv_buffer, proc_recv, tag)
2705 CALL timeset(routinen//
"_unpack", handle2)
2709 DO col_local = 1, elements2recv_col
2710 DO row_local = 1, elements2recv_row
2711 fm_global%local_data(index2recv_col(pcol_recv)%array(col_local), &
2712 index2recv_row(prow_recv)%array(row_local)) &
2713 = recv_buffer(col_local, row_local)
2717 CALL timestop(handle2)
2718 ELSE IF (
SIZE(send_buffer) > 0_int_8)
THEN
2719 CALL para_env_sub%send(send_buffer, proc_send, tag)
2724 DEALLOCATE (data2send_col, data2send_row, data2recv_col, data2recv_row)
2725 DO proc_shift = 0, npcol_global - 1
2726 DEALLOCATE (index2send_col(proc_shift)%array)
2728 DO proc_shift = 0, npcol_sub - 1
2729 DEALLOCATE (index2recv_col(proc_shift)%array)
2731 DO proc_shift = 0, nprow_global - 1
2732 DEALLOCATE (index2send_row(proc_shift)%array)
2734 DO proc_shift = 0, nprow_sub - 1
2735 DEALLOCATE (index2recv_row(proc_shift)%array)
2737 DEALLOCATE (index2send_col, index2recv_col, index2send_row, index2recv_row)
2739 CALL cp_fm_release(fm_sub)
2741 CALL timestop(handle)
2743 END SUBROUTINE dereplicate_and_sum_fm
2752 SUBROUTINE get_elements2send_col(data2send, struct_global, indices_sub, index2send)
2753 INTEGER,
ALLOCATABLE,
DIMENSION(:),
INTENT(OUT) :: data2send
2754 TYPE(cp_fm_struct_type),
INTENT(INOUT) :: struct_global
2755 INTEGER,
DIMENSION(:),
INTENT(IN) :: indices_sub
2756 TYPE(one_dim_int_array),
ALLOCATABLE, &
2757 DIMENSION(:),
INTENT(OUT) :: index2send
2759 INTEGER :: i_global, i_local, np_global, proc
2761 CALL struct_global%context%get(number_of_process_columns=np_global)
2763 ALLOCATE (data2send(0:np_global - 1))
2765 DO i_local = 1,
SIZE(indices_sub)
2766 i_global = indices_sub(i_local)
2767 proc = struct_global%g2p_col(i_global)
2768 data2send(proc) = data2send(proc) + 1
2771 ALLOCATE (index2send(0:np_global - 1))
2772 DO proc = 0, np_global - 1
2773 ALLOCATE (index2send(proc)%array(data2send(proc)))
2775 index2send(proc)%array = -1
2779 DO i_local = 1,
SIZE(indices_sub)
2780 i_global = indices_sub(i_local)
2781 proc = struct_global%g2p_col(i_global)
2782 data2send(proc) = data2send(proc) + 1
2783 index2send(proc)%array(data2send(proc)) = i_local
2786 END SUBROUTINE get_elements2send_col
2795 SUBROUTINE get_elements2send_row(data2send, struct_global, indices_sub, index2send)
2796 INTEGER,
ALLOCATABLE,
DIMENSION(:),
INTENT(OUT) :: data2send
2797 TYPE(cp_fm_struct_type),
INTENT(INOUT) :: struct_global
2798 INTEGER,
DIMENSION(:),
INTENT(IN) :: indices_sub
2799 TYPE(one_dim_int_array),
ALLOCATABLE, &
2800 DIMENSION(:),
INTENT(OUT) :: index2send
2802 INTEGER :: i_global, i_local, np_global, proc
2804 CALL struct_global%context%get(number_of_process_rows=np_global)
2806 ALLOCATE (data2send(0:np_global - 1))
2808 DO i_local = 1,
SIZE(indices_sub)
2809 i_global = indices_sub(i_local)
2810 proc = struct_global%g2p_row(i_global)
2811 data2send(proc) = data2send(proc) + 1
2814 ALLOCATE (index2send(0:np_global - 1))
2815 DO proc = 0, np_global - 1
2816 ALLOCATE (index2send(proc)%array(data2send(proc)))
2818 index2send(proc)%array = -1
2822 DO i_local = 1,
SIZE(indices_sub)
2823 i_global = indices_sub(i_local)
2824 proc = struct_global%g2p_row(i_global)
2825 data2send(proc) = data2send(proc) + 1
2826 index2send(proc)%array(data2send(proc)) = i_local
2829 END SUBROUTINE get_elements2send_row
static GRID_HOST_DEVICE int modulo(int a, int m)
Equivalent of Fortran's MODULO, which always return a positive number. https://gcc....
various utilities that regard array of different kinds: output, allocation,... maybe it is not a good...
methods related to the blacs parallel environment
Redistribution of DBCSR blocks and distributed matrix slices.
subroutine, public cp_array_to_dbcsr_slices(array, nrows, ncols, para_env_sub, first_row, last_row, template, matrices, matrix_ptrs)
Consume a distributed flattened array and create a DBCSR matrix per slice.
Basic linear algebra operations for full matrices.
subroutine, public cp_fm_add_on_diag(matrix, alpha, n_active)
Adds a scalar to the diagonal of a distributed real full matrix.
subroutine, public cp_fm_geadd(alpha, trans, matrix_a, beta, matrix_b)
interface to BLACS geadd: matrix_b = beta*matrix_b + alpha*opt(matrix_a) where opt(matrix_a) can be e...
subroutine, public cp_fm_scale_and_add(alpha, matrix_a, beta, matrix_b)
calc A <- alpha*A + beta*B optimized for alpha == 1.0 (just add beta*B) and beta == 0....
various cholesky decomposition related routines
subroutine, public cp_fm_cholesky_invert(matrix, n, info_out, work)
Replace the upper Cholesky factor by the upper triangle of the inverse. When work is provided,...
Redistribution of full matrices and distributed arrays.
subroutine, public cp_fm_to_array(mat2d, my_start_row, my_end_row, my_start_col, my_end_col, fm_mat)
Extract distributed rectangular array tiles from a full matrix.
subroutine, public cp_array_to_fm(mat2d, fm_struct, my_start_row, my_end_row, my_start_col, my_end_col, fm_mat, do_release_mat)
Assemble a full matrix from distributed rectangular array tiles.
represent the structure of a full matrix
subroutine, public cp_fm_struct_create(fmstruct, para_env, context, nrow_global, ncol_global, nrow_block, ncol_block, descriptor, first_p_pos, local_leading_dimension, template_fmstruct, square_blocks, force_block)
allocates and initializes a full matrix structure
subroutine, public cp_fm_struct_get(fmstruct, para_env, context, descriptor, ncol_block, nrow_block, nrow_global, ncol_global, first_p_pos, row_indices, col_indices, nrow_local, ncol_local, nrow_locals, ncol_locals, local_leading_dimension)
returns the values of various attributes of the matrix structure
subroutine, public cp_fm_struct_release(fmstruct)
releases a full matrix structure
represent a full matrix distributed on many processors
subroutine, public cp_fm_get_info(matrix, name, nrow_global, ncol_global, nrow_block, ncol_block, nrow_local, ncol_local, row_indices, col_indices, local_data, context, nrow_locals, ncol_locals, matrix_struct, para_env)
returns all kind of information about the full matrix
subroutine, public cp_fm_to_fm_submat_general(source, destination, nrows, ncols, s_firstrow, s_firstcol, d_firstrow, d_firstcol, global_context)
General copy of a submatrix of fm matrix to a submatrix of another fm matrix. The two matrices can ha...
subroutine, public cp_fm_set_all(matrix, alpha, beta)
set all elements of a matrix to the same value, and optionally the diagonal to a different one
subroutine, public cp_fm_create(matrix, matrix_struct, name, nrow, ncol, set_zero)
creates a new full matrix with the given structure
Counters to determine the performance of parallel DGEMMs.
subroutine, public dgemm_counter_start(dgemm_counter)
start timer of the counter
subroutine, public dgemm_counter_stop(dgemm_counter, size1, size2, size3)
stop timer of the counter and provide matrix sizes
Types to describe group distributions.
elemental integer function, public maxsize(this)
...
elemental integer function, public group_dist_proc(this, pos)
...
Library choices for electronic integral APIs.
pure logical function, public compare_potential_types(potential1, potential2)
Compare the parameters defining two radial operators.
sums arrays of real/complex numbers with much reduced round-off as compared to a naive implementation...
Defines the basic variable types.
integer, parameter, public int_8
integer, parameter, public dp
integer, parameter, public local_gemm_pu_gpu
Machine interface based on Fortran 2003 and POSIX.
subroutine, public m_memory(mem)
Returns the total amount of memory [bytes] in use, if known, zero otherwise.
subroutine, public m_flush(lunit)
flushes units if the &GLOBAL flag is set accordingly
Definition of mathematical constants and functions.
real(kind=dp), parameter, public pi
Interface to the message passing library MPI.
subroutine, public mp_waitany(requests, completed)
waits for completion of any of the given requests
type(mp_request_type), parameter, public mp_request_null
Routines to calculate MP2 energy with laplace approach.
subroutine, public calc_fm_mat_s_laplace(fm_mat_s, homo, virtual, eigenval, dajquad)
...
Types needed for MP2 calculations.
basic linear algebra operations for full matrixes
subroutine, public get_qs_env(qs_env, atomic_kind_set, qs_kind_set, cell, super_cell, cell_ref, use_ref_cell, kpoints, dft_control, mos, sab_orb, sab_all, qmmm, qmmm_periodic, mimic, sac_ae, sac_ppl, sac_lri, sap_ppnl, sab_vdw, sab_scp, sap_oce, sab_lrc, sab_se, sab_xtbe, sab_tbe, sab_core, sab_xb, sab_xtb_pp, sab_xtb_nonbond, sab_almo, sab_kp, sab_kp_nosym, sab_cneo, particle_set, energy, force, matrix_h, matrix_h_im, matrix_ks, matrix_ks_im, matrix_vxc, run_rtp, rtp, matrix_h_kp, matrix_h_im_kp, matrix_ks_kp, matrix_ks_im_kp, matrix_vxc_kp, kinetic_kp, matrix_s_kp, matrix_w_kp, matrix_s_ri_aux_kp, matrix_s, matrix_s_ri_aux, matrix_w, matrix_p_mp2, matrix_p_mp2_admm, matrix_vhxc, rho, rho_xc, pw_env, ewald_env, ewald_pw, active_space, mpools, input, para_env, blacs_env, scf_control, rel_control, kinetic, qs_charges, vppl, xcint_weights, rho_core, rho_nlcc, rho_nlcc_g, ks_env, ks_qmmm_env, wf_history, scf_env, local_particles, local_molecules, distribution_2d, dbcsr_dist, molecule_kind_set, molecule_set, subsys, cp_subsys, oce, local_rho_set, rho_atom_set, task_list, task_list_soft, rho0_atom_set, rho0_mpole, rhoz_set, rhoz_cneo_set, ecoul_1c, rho0_s_rs, rho0_s_gs, rhoz_cneo_s_rs, rhoz_cneo_s_gs, do_kpoints, has_unit_metric, requires_mo_derivs, mo_derivs, mo_loc_history, nkind, natom, nelectron_total, nelectron_spin, efield, neighbor_list_id, linres_control, xas_env, virial, cp_ddapc_env, cp_ddapc_ewald, outer_scf_history, outer_scf_ihistory, x_data, et_coupling, dftb_potential, results, se_taper, se_store_int_env, se_nddo_mpole, se_nonbond_env, admm_env, lri_env, lri_density, exstate_env, ec_env, harris_env, dispersion_env, gcp_env, vee, rho_external, external_vxc, mask, mp2_env, bs_env, kg_env, wanniercentres, atprop, ls_scf_env, do_transport, transport_env, v_hartree_rspace, s_mstruct_changed, rho_changed, potential_changed, forces_up_to_date, mscfg_env, almo_scf_env, gradient_history, variable_history, embed_pot, spin_embed_pot, polar_env, mos_last_converged, eeq, rhs, do_rixs, tb_tblite)
Get the QUICKSTEP environment.
Routines to calculate RI-RPA and SOS-MP2 gradients.
integer, parameter spla_threshold
subroutine, public rpa_grad_finalize(rpa_grad, mp2_env, para_env_sub, para_env, qs_env, gd_array, color_sub, do_ri_sos_laplace_mp2, homo, virtual)
...
subroutine, public rpa_grad_copy_q(fm_mat_q, rpa_grad)
...
pure subroutine, public rpa_grad_needed_mem(homo, virtual, dimen_ri, mem_per_rank, mem_per_repl, do_ri_sos_laplace_mp2)
Calculates the necessary minimum memory for the Gradient code ion MiB.
subroutine, public rpa_grad_create(rpa_grad, fm_mat_q, fm_mat_s, homo, virtual, mp2_env, eigenval, unit_nr, do_ri_sos_laplace_mp2)
Creates the arrays of a rpa_grad_type.
subroutine, public rpa_grad_matrix_operations(mp2_env, rpa_grad, do_ri_sos_laplace_mp2, fm_mat_q, fm_mat_q_gemm, dgemm_counter, fm_mat_s, omega, homo, virtual, eigenval, weight, unit_nr)
...
Utility functions for RPA calculations.
subroutine, public remove_scaling_factor_rpa(fm_mat_s, virtual, eigenval_last, homo, omega_old)
...
subroutine, public calc_fm_mat_s_rpa(fm_mat_s, first_cycle, virtual, eigenval, homo, omega, omega_old)
...
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
represent a pointer to a contiguous 1d array
represent a pointer to a contiguous 3d array
represent a blacs multidimensional parallel environment (for the mpi corrispective see cp_paratypes/m...
keeps the information about the structure of a full matrix
stores all the informations relevant to an mpi environment