(git:27c966b)
Loading...
Searching...
No Matches
rpa_grad.F
Go to the documentation of this file.
1!--------------------------------------------------------------------------------------------------!
2! CP2K: A general program to perform molecular dynamics simulations !
3! Copyright 2000-2026 CP2K developers group <https://cp2k.org> !
4! !
5! SPDX-License-Identifier: GPL-2.0-or-later !
6!--------------------------------------------------------------------------------------------------!
7
8! **************************************************************************************************
9!> \brief Routines to calculate RI-RPA and SOS-MP2 gradients
10!> \par History
11!> 10.2021 created [Frederick Stein]
12! **************************************************************************************************
28 USE cp_fm_types, ONLY: cp_fm_create,&
42 maxsize,&
47 USE kinds, ONLY: dp,&
48 int_8
51 USE machine, ONLY: m_flush,&
53 USE mathconstants, ONLY: pi
54 USE message_passing, ONLY: mp_comm_type,&
61 USE mp2_types, ONLY: mp2_type,&
68 USE rpa_util, ONLY: calc_fm_mat_s_rpa,&
70 USE util, ONLY: get_limit
71#include "./base/base_uses.f90"
72
73 IMPLICIT NONE
74
75 PRIVATE
76
77 CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'rpa_grad'
78
80
81 TYPE sos_mp2_grad_work_type
82 PRIVATE
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
87
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
96
98 PRIVATE
99 TYPE(cp_fm_type) :: fm_Gamma_PQ = cp_fm_type()
100 TYPE(cp_fm_type), DIMENSION(:), ALLOCATABLE :: fm_y
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
103 END TYPE rpa_grad_type
104
105 INTEGER, PARAMETER :: spla_threshold = 128*128*128*2
106 INTEGER, PARAMETER :: blksize_threshold = 4
107
108CONTAINS
109
110! **************************************************************************************************
111!> \brief Calculates the necessary minimum memory for the Gradient code ion MiB
112!> \param homo ...
113!> \param virtual ...
114!> \param dimen_RI ...
115!> \param mem_per_rank ...
116!> \param mem_per_repl ...
117!> \param do_ri_sos_laplace_mp2 ...
118!> \return ...
119! **************************************************************************************************
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
125
126 REAL(kind=dp) :: mem_iak, mem_kl, mem_pab, mem_pij
127
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
132
133 ! Required matrices iaK
134 ! Ytot_iaP = sum_tau Y_iaP(tau)
135 ! Y_iaP(tau) = S_iaP(tau)*Q_PQ(tau) (work array)
136 ! Required matrices density matrices
137 ! Pij (local)
138 ! Pab (local)
139 ! Additionally with SOS-MP2
140 ! Send and receive buffers for degenerate orbital pairs (rough estimate: everything)
141 ! Additionally with RPA
142 ! copy of work matrix
143 ! receive buffer for calculation of density matrix
144 ! copy of matrix Q
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)
149 END IF
150
151 END SUBROUTINE rpa_grad_needed_mem
152
153! **************************************************************************************************
154!> \brief Creates the arrays of a rpa_grad_type
155!> \param rpa_grad ...
156!> \param fm_mat_Q ...
157!> \param fm_mat_S ...
158!> \param homo ...
159!> \param virtual ...
160!> \param mp2_env ...
161!> \param Eigenval ...
162!> \param unit_nr ...
163!> \param do_ri_sos_laplace_mp2 ...
164! **************************************************************************************************
165 SUBROUTINE rpa_grad_create(rpa_grad, fm_mat_Q, fm_mat_S, &
166 homo, virtual, mp2_env, Eigenval, unit_nr, do_ri_sos_laplace_mp2)
167 TYPE(rpa_grad_type), INTENT(OUT) :: rpa_grad
168 TYPE(cp_fm_type), INTENT(IN) :: fm_mat_q
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
175
176 CHARACTER(LEN=*), PARAMETER :: routinen = 'rpa_grad_create'
177
178 INTEGER :: handle, ispin, nrow_local, nspins
179
180 CALL timeset(routinen, handle)
181
182 CALL cp_fm_create(rpa_grad%fm_Gamma_PQ, matrix_struct=fm_mat_q%matrix_struct)
183 CALL cp_fm_set_all(rpa_grad%fm_Gamma_PQ, 0.0_dp)
184
185 nspins = SIZE(fm_mat_s)
186
187 ALLOCATE (rpa_grad%fm_Y(nspins))
188 DO ispin = 1, nspins
189 CALL cp_fm_create(rpa_grad%fm_Y(ispin), fm_mat_s(ispin)%matrix_struct, set_zero=.true.)
190 END DO
191
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)
195 ELSE
196 CALL rpa_work_type_create(rpa_grad%rpa_work, fm_mat_q, fm_mat_s, homo, virtual)
197 END IF
198
199 ! Set blocksize
200 CALL cp_fm_struct_get(fm_mat_s(1)%matrix_struct, nrow_local=nrow_local)
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
205 CALL m_flush(unit_nr)
206 END IF
207 CALL fm_mat_s(1)%matrix_struct%para_env%sync()
208
209 CALL timestop(handle)
210
211 END SUBROUTINE rpa_grad_create
212
213! **************************************************************************************************
214!> \brief ...
215!> \param sos_mp2_work_occ ...
216!> \param sos_mp2_work_virt ...
217!> \param unit_nr ...
218!> \param Eigenval ...
219!> \param homo ...
220!> \param virtual ...
221!> \param eps_degenerate ...
222!> \param fm_mat_S ...
223! **************************************************************************************************
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
233
234 CHARACTER(LEN=*), PARAMETER :: routinen = 'sos_mp2_work_type_create'
235
236 INTEGER :: handle, ispin, nspins
237
238 CALL timeset(routinen, handle)
239
240 nspins = SIZE(fm_mat_s)
241 ALLOCATE (sos_mp2_work_occ(nspins), sos_mp2_work_virt(nspins))
242 DO ispin = 1, nspins
243
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))
251
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))
259 END DO
260
261 CALL timestop(handle)
262
263 END SUBROUTINE sos_mp2_work_type_create
264
265! **************************************************************************************************
266!> \brief ...
267!> \param rpa_work ...
268!> \param fm_mat_Q ...
269!> \param fm_mat_S ...
270!> \param homo ...
271!> \param virtual ...
272! **************************************************************************************************
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
275 TYPE(cp_fm_type), INTENT(IN) :: fm_mat_q
276 TYPE(cp_fm_type), DIMENSION(:), INTENT(IN) :: fm_mat_s
277 INTEGER, DIMENSION(:), INTENT(IN) :: homo, virtual
278
279 CHARACTER(LEN=*), PARAMETER :: routinen = 'rpa_work_type_create'
280
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, &
284 proc_virtual_send
285 INTEGER, ALLOCATABLE, DIMENSION(:) :: data2recv, data2send
286 INTEGER, DIMENSION(:), POINTER :: col_indices
287
288 CALL timeset(routinen, handle)
289
290 CALL cp_fm_create(rpa_work%fm_mat_Q_copy, matrix_struct=fm_mat_q%matrix_struct)
291
292 CALL fm_mat_s(1)%matrix_struct%context%get(number_of_process_columns=num_pe_col, my_process_column=my_pcol)
293
294 nspins = SIZE(fm_mat_s)
295
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))
301
302 ! Determine new process grid
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
306 END DO
307 proc_virtual = num_pe_col/proc_homo
308
309 rpa_work%grid(1) = proc_virtual
310 rpa_work%grid(2) = proc_homo
311
312 rpa_work%mepos(1) = mod(my_pcol, proc_virtual)
313 rpa_work%mepos(2) = my_pcol/proc_virtual
314
315 DO ispin = 1, nspins
316
317 ! Determine distributions of the orbitals
318 CALL create_group_dist(rpa_work%gd_homo(ispin), proc_homo, homo(ispin))
319 CALL create_group_dist(rpa_work%gd_virtual(ispin), proc_virtual, virtual(ispin))
320
321 CALL cp_fm_struct_get(fm_mat_s(ispin)%matrix_struct, ncol_local=ncol_local, col_indices=col_indices)
322
323 data2send = 0
324 ! Count the amount of data2send to each process
325 DO col_local = 1, ncol_local
326 col_global = col_indices(col_local)
327
328 iocc = (col_global - 1)/virtual(ispin) + 1
329 avirt = col_global - (iocc - 1)*virtual(ispin)
330
331 proc_homo_send = group_dist_proc(rpa_work%gd_homo(ispin), iocc)
332 proc_virtual_send = group_dist_proc(rpa_work%gd_virtual(ispin), avirt)
333
334 proc_send = proc_homo_send*proc_virtual + proc_virtual_send
335
336 data2send(proc_send) = data2send(proc_send) + 1
337 END DO
338
339 DO proc_send = 0, num_pe_col - 1
340 ALLOCATE (rpa_work%index2send(proc_send, ispin)%array(data2send(proc_send)))
341 END DO
342
343 ! Prepare the indices
344 data2send = 0
345 DO col_local = 1, ncol_local
346 col_global = col_indices(col_local)
347
348 iocc = (col_global - 1)/virtual(ispin) + 1
349 avirt = col_global - (iocc - 1)*virtual(ispin)
350
351 proc_homo_send = group_dist_proc(rpa_work%gd_homo(ispin), iocc)
352 proc_virtual_send = group_dist_proc(rpa_work%gd_virtual(ispin), avirt)
353
354 proc_send = proc_homo_send*proc_virtual + proc_virtual_send
355
356 data2send(proc_send) = data2send(proc_send) + 1
357
358 rpa_work%index2send(proc_send, ispin)%array(data2send(proc_send)) = col_local
359 END DO
360
361 ! Count the amount of data2recv from each process
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)
364
365 data2recv = 0
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
370 END DO
371 END DO
372
373 DO proc_recv = 0, num_pe_col - 1
374 ALLOCATE (rpa_work%index2recv(proc_recv, ispin)%array(2, data2recv(proc_recv)))
375 END DO
376
377 data2recv = 0
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
382
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
385 END DO
386 END DO
387
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
392
393 END DO
394
395 DEALLOCATE (data2send, data2recv)
396
397 CALL timestop(handle)
398
399 END SUBROUTINE rpa_work_type_create
400
401! **************************************************************************************************
402!> \brief ...
403!> \param Eigenval ...
404!> \param eps_degen ...
405!> \param pair_list ...
406! **************************************************************************************************
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
411
412 INTEGER :: my_i, my_j, num_orbitals, num_pairs, &
413 pair_counter
414
415 num_orbitals = SIZE(eigenval)
416
417! Determine number of nearly degenerate orbital pairs
418! Trivial cases: diagonal elements
419 num_pairs = 0
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
424 END DO
425 END DO
426 ALLOCATE (pair_list(2, num_pairs))
427
428! Print the required pairs
429 pair_counter = 1
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
437 END IF
438 END DO
439 END DO
440
441 END SUBROUTINE create_list_nearly_degen_pairs
442
443! **************************************************************************************************
444!> \brief ...
445!> \param sos_mp2_work ...
446!> \param virtual ...
447!> \param fm_mat_S ...
448! **************************************************************************************************
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
452 TYPE(cp_fm_type), INTENT(IN) :: fm_mat_s
453
454 CHARACTER(LEN=*), PARAMETER :: routinen = 'prepare_comm_Pij'
455
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
462 TYPE(cp_blacs_env_type), POINTER :: context
463 TYPE(mp_comm_type) :: comm_exchange
464 TYPE(mp_para_env_type), POINTER :: para_env
465
466 CALL timeset(routinen, handle)
467
468 tag = 44
469
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))
473
474 ALLOCATE (data2send(0:num_pe_col - 1))
475 ALLOCATE (data2recv(0:num_pe_col - 1))
476
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, &
481 blacs2mpi=blacs2mpi)
482
483 num_ij_pairs = SIZE(sos_mp2_work%pair_list, 2)
484
485 IF (num_ij_pairs > 0) THEN
486
487 CALL comm_exchange%from_split(para_env, my_prow)
488
489 data2send = 0
490 data2recv = 0
491
492 DO proc_shift = 0, num_pe_col - 1
493 pcol_send = modulo(my_pcol + proc_shift, num_pe_col)
494
495 counter = 0
496 DO col_local = 1, ncol_local
497 col_global = col_indices(col_local)
498
499 iocc = max(1, col_global - 1)/virtual + 1
500 avirt = col_global - (iocc - 1)*virtual
501
502 DO ij_counter = 1, num_ij_pairs
503
504 my_i = sos_mp2_work%pair_list(1, ij_counter)
505 my_j = sos_mp2_work%pair_list(2, ij_counter)
506
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
510
511 counter = counter + 1
512
513 EXIT
514
515 END DO
516 END DO
517 data2send(pcol_send) = counter
518 END DO
519
520 CALL comm_exchange%alltoall(data2send, data2recv, 1)
521
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)
525
526 ! Collect indices and exchange
527 ALLOCATE (sos_mp2_work%index2send(pcol_send)%array(data2send(pcol_send)))
528
529 counter = 0
530 DO col_local = 1, ncol_local
531 col_global = col_indices(col_local)
532
533 iocc = max(1, col_global - 1)/virtual + 1
534 avirt = col_global - (iocc - 1)*virtual
535
536 DO ij_counter = 1, num_ij_pairs
537
538 my_i = sos_mp2_work%pair_list(1, ij_counter)
539 my_j = sos_mp2_work%pair_list(2, ij_counter)
540
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
544
545 counter = counter + 1
546
547 sos_mp2_work%index2send(pcol_send)%array(counter) = col_global
548
549 EXIT
550
551 END DO
552 END DO
553
554 ALLOCATE (sos_mp2_work%index2recv(pcol_recv)%array(data2recv(pcol_recv)))
555 !
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)
558
559 ! Convert to global coordinates to local coordinates as we always work with them
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))
563 END DO
564 END DO
565
566 CALL comm_exchange%free()
567 END IF
568
569 DEALLOCATE (data2send, data2recv)
570
571 CALL timestop(handle)
572
573 END SUBROUTINE prepare_comm_pij
574
575! **************************************************************************************************
576!> \brief ...
577!> \param sos_mp2_work ...
578!> \param virtual ...
579!> \param fm_mat_S ...
580! **************************************************************************************************
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
584 TYPE(cp_fm_type), INTENT(IN) :: fm_mat_s
585
586 CHARACTER(LEN=*), PARAMETER :: routinen = 'prepare_comm_Pab'
587
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
594 TYPE(cp_blacs_env_type), POINTER :: context
595 TYPE(mp_comm_type) :: comm_exchange
596 TYPE(mp_para_env_type), POINTER :: para_env
597
598 CALL timeset(routinen, handle)
599
600 tag = 44
601
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))
605
606 num_ab_pairs = SIZE(sos_mp2_work%pair_list, 2)
607 IF (num_ab_pairs > 0) THEN
608
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, &
613 blacs2mpi=blacs2mpi)
614
615 CALL comm_exchange%from_split(para_env, my_prow)
616
617 ALLOCATE (data2send(0:num_pe_col - 1))
618 ALLOCATE (data2recv(0:num_pe_col - 1))
619
620 data2send = 0
621 data2recv = 0
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)
625
626 counter = 0
627 DO col_local = 1, ncol_local
628 col_global = col_indices(col_local)
629
630 iocc = max(1, col_global - 1)/virtual + 1
631 avirt = col_global - (iocc - 1)*virtual
632
633 DO ab_counter = 1, num_ab_pairs
634
635 my_a = sos_mp2_work%pair_list(1, ab_counter)
636 my_b = sos_mp2_work%pair_list(2, ab_counter)
637
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
641
642 counter = counter + 1
643
644 EXIT
645
646 END DO
647 END DO
648 data2send(pcol_send) = counter
649 END DO
650
651 CALL comm_exchange%alltoall(data2send, data2recv, 1)
652
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)
656
657 ! Collect indices and exchange
658 ALLOCATE (sos_mp2_work%index2send(pcol_send)%array(data2send(pcol_send)))
659
660 counter = 0
661 DO col_local = 1, ncol_local
662 col_global = col_indices(col_local)
663
664 iocc = max(1, col_global - 1)/virtual + 1
665 avirt = col_global - (iocc - 1)*virtual
666
667 DO ab_counter = 1, num_ab_pairs
668
669 my_a = sos_mp2_work%pair_list(1, ab_counter)
670 my_b = sos_mp2_work%pair_list(2, ab_counter)
671
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
675
676 counter = counter + 1
677
678 sos_mp2_work%index2send(pcol_send)%array(counter) = col_global
679
680 EXIT
681
682 END DO
683 END DO
684
685 ALLOCATE (sos_mp2_work%index2recv(pcol_recv)%array(data2recv(pcol_recv)))
686 !
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)
689
690 ! Convert to global coordinates to local coordinates as we always work with them
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))
694 END DO
695 END DO
696
697 CALL comm_exchange%free()
698 DEALLOCATE (data2send, data2recv)
699
700 END IF
701
702 CALL timestop(handle)
703
704 END SUBROUTINE prepare_comm_pab
705
706! **************************************************************************************************
707!> \brief ...
708!> \param fm_mat_Q ...
709!> \param rpa_grad ...
710! **************************************************************************************************
711 SUBROUTINE rpa_grad_copy_q(fm_mat_Q, rpa_grad)
712 TYPE(cp_fm_type), INTENT(IN) :: fm_mat_q
713 TYPE(rpa_grad_type), INTENT(INOUT) :: rpa_grad
714
715 CALL cp_fm_to_fm(fm_mat_q, rpa_grad%rpa_work%fm_mat_Q_copy)
716
717 END SUBROUTINE rpa_grad_copy_q
718
719! **************************************************************************************************
720!> \brief ...
721!> \param mp2_env ...
722!> \param rpa_grad ...
723!> \param do_ri_sos_laplace_mp2 ...
724!> \param fm_mat_Q ...
725!> \param fm_mat_Q_gemm ...
726!> \param dgemm_counter ...
727!> \param fm_mat_S ...
728!> \param omega ...
729!> \param homo ...
730!> \param virtual ...
731!> \param Eigenval ...
732!> \param weight ...
733!> \param unit_nr ...
734! **************************************************************************************************
735 SUBROUTINE rpa_grad_matrix_operations(mp2_env, rpa_grad, do_ri_sos_laplace_mp2, fm_mat_Q, fm_mat_Q_gemm, &
736 dgemm_counter, fm_mat_S, omega, homo, virtual, Eigenval, weight, unit_nr)
737 TYPE(mp2_type), INTENT(INOUT) :: mp2_env
738 TYPE(rpa_grad_type), INTENT(INOUT) :: rpa_grad
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
742 TYPE(dgemm_counter_type), INTENT(INOUT) :: dgemm_counter
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
749
750 CHARACTER(LEN=*), PARAMETER :: routinen = 'rpa_grad_matrix_operations'
751
752 INTEGER :: dimen_ia, dimen_ri, handle, handle2, &
753 ispin, jspin, nspins
754 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :, :), &
755 TARGET :: mat_s_3d, mat_work_iap_3d
756 TYPE(cp_fm_type) :: fm_work_iap, fm_work_pq
757
758 CALL timeset(routinen, handle)
759
760 nspins = SIZE(fm_mat_q)
761
762 CALL cp_fm_get_info(fm_mat_q(1), nrow_global=dimen_ri)
763
764 IF (.NOT. do_ri_sos_laplace_mp2) THEN
765 CALL cp_fm_create(fm_work_pq, fm_mat_q(1)%matrix_struct)
766
767 ! Invert [1+Q(iw')], using fm_work_PQ as temporary workspace.
768 CALL cp_fm_cholesky_invert(fm_mat_q(1), n=dimen_ri, work=fm_work_pq)
769
770 CALL cp_fm_release(fm_work_pq)
771
772 CALL cp_fm_add_on_diag(fm_mat_q(1), -1.0_dp, n_active=dimen_ri)
773
774 CALL timeset(routinen//"_PQ", handle2)
775 CALL dgemm_counter_start(dgemm_counter)
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, &
778 matrix_c=rpa_grad%fm_Gamma_PQ)
779 CALL dgemm_counter_stop(dgemm_counter, dimen_ri, dimen_ri, dimen_ri)
780 CALL timestop(handle2)
781
782 CALL cp_fm_to_fm_submat_general(fm_mat_q(1), fm_mat_q_gemm(1), dimen_ri, dimen_ri, 1, 1, 1, 1, &
783 fm_mat_q_gemm(1)%matrix_struct%context)
784 END IF
785
786 DO ispin = 1, nspins
787 IF (do_ri_sos_laplace_mp2) THEN
788 ! The spin of the other Q matrix is always the other spin
789 jspin = nspins - ispin + 1
790 ELSE
791 ! or the first matrix in the case of RPA
792 jspin = 1
793 END IF
794
795 IF (do_ri_sos_laplace_mp2) THEN
796 CALL timeset(routinen//"_PQ", handle2)
797 CALL dgemm_counter_start(dgemm_counter)
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, &
800 matrix_c=rpa_grad%fm_Gamma_PQ)
801 CALL dgemm_counter_stop(dgemm_counter, dimen_ri, dimen_ri, dimen_ri)
802 CALL timestop(handle2)
803
804 CALL cp_fm_to_fm_submat_general(fm_mat_q(jspin), fm_mat_q_gemm(jspin), dimen_ri, dimen_ri, 1, 1, 1, 1, &
805 fm_mat_q_gemm(jspin)%matrix_struct%context)
806 ELSE
807 CALL calc_fm_mat_s_rpa(fm_mat_s(ispin), .true., virtual(ispin), eigenval(:, ispin), &
808 homo(ispin), omega, 0.0_dp)
809 END IF
810
811 CALL timeset(routinen//"_contr_S", handle2)
812 CALL cp_fm_create(fm_work_iap, rpa_grad%fm_Y(ispin)%matrix_struct)
813
814 CALL cp_fm_get_info(fm_mat_s(ispin), ncol_global=dimen_ia)
815
816 CALL dgemm_counter_start(dgemm_counter)
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)
820 CALL dgemm_counter_stop(dgemm_counter, dimen_ia, dimen_ri, dimen_ri)
821 CALL timestop(handle2)
822
823 IF (do_ri_sos_laplace_mp2) THEN
824 CALL calc_p_sos_mp2(homo(ispin), fm_mat_s(ispin), fm_work_iap, &
825 rpa_grad%sos_mp2_work_occ(ispin), rpa_grad%sos_mp2_work_virt(ispin), &
826 omega, weight, virtual(ispin), eigenval(:, ispin), mp2_env%ri_grad%dot_blksize)
827
828 CALL calc_fm_mat_s_laplace(fm_work_iap, homo(ispin), virtual(ispin), eigenval(:, ispin), omega)
829
830 CALL cp_fm_scale_and_add(1.0_dp, rpa_grad%fm_Y(ispin), -weight, fm_work_iap)
831
832 CALL cp_fm_release(fm_work_iap)
833 ELSE
834 ! To save memory, we add it now
835 CALL cp_fm_scale_and_add(1.0_dp, rpa_grad%fm_Y(ispin), -weight, fm_work_iap)
836
837 ! Redistribute both matrices and deallocate fm_work_iaP
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, &
840 rpa_grad%rpa_work%gd_homo(ispin), rpa_grad%rpa_work%gd_virtual(ispin), &
841 rpa_grad%rpa_work%mepos)
842 CALL cp_fm_release(fm_work_iap)
843
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, &
846 rpa_grad%rpa_work%gd_homo(ispin), rpa_grad%rpa_work%gd_virtual(ispin), &
847 rpa_grad%rpa_work%mepos)
848
849 ! Now collect the density matrix
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), &
851 rpa_grad%rpa_work%grid, rpa_grad%rpa_work%mepos, &
852 fm_mat_s(ispin)%matrix_struct, &
853 rpa_grad%rpa_work%P_ij(ispin)%array, rpa_grad%rpa_work%P_ab(ispin)%array, &
854 weight, omega, eigenval(:, ispin), homo(ispin), unit_nr, mp2_env)
855
856 DEALLOCATE (mat_work_iap_3d, mat_s_3d)
857
858 CALL remove_scaling_factor_rpa(fm_mat_s(ispin), virtual(ispin), eigenval(:, ispin), homo(ispin), omega)
859
860 END IF
861
862 END DO
863
864 CALL timestop(handle)
865
866 END SUBROUTINE rpa_grad_matrix_operations
867
868! **************************************************************************************************
869!> \brief ...
870!> \param homo ...
871!> \param fm_mat_S ...
872!> \param fm_work_iaP ...
873!> \param sos_mp2_work_occ ...
874!> \param sos_mp2_work_virt ...
875!> \param omega ...
876!> \param weight ...
877!> \param virtual ...
878!> \param Eigenval ...
879!> \param dot_blksize ...
880! **************************************************************************************************
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
890
891 CHARACTER(LEN=*), PARAMETER :: routinen = 'calc_P_sos_mp2'
892
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
898
899 CALL timeset(routinen, handle)
900
901 CALL cp_fm_get_info(fm_mat_s, col_indices=col_indices, ncol_local=ncol_local, nrow_local=nrow_local)
902
903 CALL timeset(routinen//"_Pij_diag", handle2)
904 DO my_i = 1, homo
905 ! Collect the contributions of the matrix elements
906
907 trace = 0.0_dp
908
909 DO col_local = 1, ncol_local
910 col_global = col_indices(col_local)
911
912 iocc = max(1, col_global - 1)/virtual + 1
913 avirt = col_global - (iocc - 1)*virtual
914
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)
917 END DO
918
919 sos_mp2_work_occ%P(my_i) = sos_mp2_work_occ%P(my_i) - trace*omega*weight
920
921 END DO
922 CALL timestop(handle2)
923
924 CALL timeset(routinen//"_Pab_diag", handle2)
925 DO my_a = 1, virtual
926 ! Collect the contributions of the matrix elements
927
928 trace = 0.0_dp
929
930 DO col_local = 1, ncol_local
931 col_global = col_indices(col_local)
932
933 iocc = max(1, col_global - 1)/virtual + 1
934 avirt = col_global - (iocc - 1)*virtual
935
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)
938 END DO
939
940 sos_mp2_work_virt%P(my_a) = sos_mp2_work_virt%P(my_a) + trace*omega*weight
941
942 END DO
943 CALL timestop(handle2)
944
945 ! Loop over list and carry out operations
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)
952 END IF
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)
957 END IF
958
959 CALL timestop(handle)
960
961 END SUBROUTINE calc_p_sos_mp2
962
963! **************************************************************************************************
964!> \brief ...
965!> \param mat_S_1D ...
966!> \param mat_work_iaP_3D ...
967!> \param gd_homo ...
968!> \param gd_virtual ...
969!> \param grid ...
970!> \param mepos ...
971!> \param fm_struct_S ...
972!> \param P_ij ...
973!> \param P_ab ...
974!> \param weight ...
975!> \param omega ...
976!> \param Eigenval ...
977!> \param homo ...
978!> \param unit_nr ...
979!> \param mp2_env ...
980! **************************************************************************************************
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
985 TYPE(group_dist_d1_type), INTENT(IN) :: gd_homo, gd_virtual
986 INTEGER, DIMENSION(2), INTENT(IN) :: grid, mepos
987 TYPE(cp_fm_struct_type), INTENT(IN), POINTER :: fm_struct_s
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
993
994 CHARACTER(LEN=*), PARAMETER :: routinen = 'calc_P_rpa'
995
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
1006 TYPE(cp_1d_r_cp_type), ALLOCATABLE, DIMENSION(:) :: buffer_1d
1007 TYPE(cp_3d_r_cp_type), ALLOCATABLE, DIMENSION(:) :: buffer_3d
1008 TYPE(mp_para_env_type), POINTER :: para_env
1009 TYPE(mp_request_type), ALLOCATABLE, DIMENSION(:) :: recv_requests, send_requests
1010
1011 CALL timeset(routinen, handle)
1012
1013 ! We allocate it at every step to reduce potential memory conflicts with COSMA
1014 IF (mp2_env%ri_grad%dot_blksize >= blksize_threshold) THEN
1015 CALL mp2_env%local_gemm_ctx%create(local_gemm_pu_gpu)
1016 CALL mp2_env%local_gemm_ctx%set_op_threshold_gpu(spla_threshold)
1017 END IF
1018
1019 tag = 47
1020
1021 my_p_size = SIZE(mat_work_iap_3d, 1)
1022
1023 CALL cp_fm_struct_get(fm_struct_s, para_env=para_env)
1024 CALL fm_struct_s%context%get(my_process_row=my_prow, blacs2mpi=blacs2mpi, para_env=para_env)
1025
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)
1028
1029 ! We have to remap the indices because mp_sendrecv requires a 3D array (because of mat_work_iaP_3D)
1030 ! and dgemm requires 2D arrays
1031 ! Fortran 2008 does allow pointer remapping independently of the ranks but GCC 7 does not properly support it
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)
1033
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
1036
1037 ! Determine the available memory and estimate the number of possible parallel communication channels
1038 CALL m_memory(mem)
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)
1045 END IF
1046
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
1049 CALL m_flush(unit_nr)
1050 END IF
1051 CALL para_env%sync()
1052
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))
1056 END DO
1057
1058 ALLOCATE (buffer_3d(number_of_parallel_channels))
1059
1060 ! Allocate buffers for vector version of kahan summation
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))))
1063 END IF
1064
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))
1069 END IF
1070
1071 IF (number_of_parallel_channels > 1 .AND. grid(1) > 1) THEN
1072 CALL timeset(routinen//"_comm_a", handle2)
1073 recv_requests(:) = mp_request_null
1074 procs_recv(:) = -1
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
1078
1079 CALL get_group_dist(gd_virtual, proc_a_recv, recv_a_start, recv_a_end, recv_a_size)
1080
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)
1083
1084 CALL para_env%irecv(buffer_3d(proc_shift)%array, blacs2mpi(my_prow, proc_recv), &
1085 recv_requests(proc_shift), tag)
1086
1087 procs_recv(proc_shift) = proc_a_recv
1088 END DO
1089
1090 send_requests(:) = mp_request_null
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
1094
1095 CALL para_env%isend(mat_work_iap_3d, blacs2mpi(my_prow, proc_send), &
1096 send_requests(proc_shift), tag)
1097 END DO
1098 CALL timestop(handle2)
1099 END IF
1100
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)
1106
1107 DO proc_shift = 1, grid(1) - 1
1108 CALL timeset(routinen//"_comm_a", handle2)
1109 IF (number_of_parallel_channels > 1) THEN
1110 CALL mp_waitany(recv_requests, completed)
1111
1112 CALL get_group_dist(gd_virtual, procs_recv(completed), recv_a_start, recv_a_end, recv_a_size)
1113 ELSE
1114 proc_a_send = modulo(mepos(1) + proc_shift, grid(1))
1115 proc_a_recv = modulo(mepos(1) - proc_shift, grid(1))
1116
1117 proc_send = mepos(2)*grid(1) + proc_a_send
1118 proc_recv = mepos(2)*grid(1) + proc_a_recv
1119
1120 CALL get_group_dist(gd_virtual, proc_a_recv, recv_a_start, recv_a_end, recv_a_size)
1121
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)
1124
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)
1127 completed = 1
1128 END IF
1129 CALL timestop(handle2)
1130
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)
1136
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
1140
1141 CALL get_group_dist(gd_virtual, proc_a_recv, recv_a_start, recv_a_end, recv_a_size)
1142
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)
1145
1146 CALL para_env%irecv(buffer_3d(completed)%array, blacs2mpi(my_prow, proc_recv), &
1147 recv_requests(completed), tag)
1148
1149 procs_recv(completed) = proc_a_recv
1150 END IF
1151 END DO
1152
1153 IF (number_of_parallel_channels > 1 .AND. grid(1) > 1) THEN
1154 CALL mp_waitall(send_requests)
1155 END IF
1156
1157 IF (number_of_parallel_channels > 1 .AND. grid(2) > 1) THEN
1158 recv_requests(:) = mp_request_null
1159 procs_recv(:) = -1
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)
1163
1164 CALL get_group_dist(gd_homo, proc_i_recv, recv_i_start, recv_i_end, recv_i_size)
1165
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)
1168
1169 CALL para_env%irecv(buffer_3d(proc_shift)%array, blacs2mpi(my_prow, proc_recv), &
1170 recv_requests(proc_shift), tag)
1171
1172 procs_recv(proc_shift) = proc_i_recv
1173 END DO
1174
1175 send_requests(:) = mp_request_null
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)
1179
1180 CALL para_env%isend(mat_work_iap_3d, blacs2mpi(my_prow, proc_send), &
1181 send_requests(proc_shift), tag)
1182 END DO
1183 END IF
1184
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)
1190
1191 DO proc_shift = 1, grid(2) - 1
1192 CALL timeset(routinen//"_comm_i", handle2)
1193 IF (number_of_parallel_channels > 1) THEN
1194 CALL mp_waitany(recv_requests, completed)
1195
1196 CALL get_group_dist(gd_homo, procs_recv(completed), recv_i_start, recv_i_end, recv_i_size)
1197 ELSE
1198 proc_i_send = modulo(mepos(2) + proc_shift, grid(2))
1199 proc_i_recv = modulo(mepos(2) - proc_shift, grid(2))
1200
1201 proc_send = proc_i_send*grid(1) + mepos(1)
1202 proc_recv = proc_i_recv*grid(1) + mepos(1)
1203
1204 CALL get_group_dist(gd_homo, proc_i_recv, recv_i_start, recv_i_end, recv_i_size)
1205
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)
1208
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)
1211 completed = 1
1212 END IF
1213 CALL timestop(handle2)
1214
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)
1220
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)
1224
1225 CALL get_group_dist(gd_homo, proc_i_recv, recv_i_start, recv_a_end, recv_i_size)
1226
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)
1229
1230 CALL para_env%irecv(buffer_3d(completed)%array, blacs2mpi(my_prow, proc_recv), &
1231 recv_requests(completed), tag)
1232
1233 procs_recv(completed) = proc_i_recv
1234 END IF
1235 END DO
1236
1237 IF (number_of_parallel_channels > 1 .AND. grid(2) > 1) THEN
1238 CALL mp_waitall(send_requests)
1239 END IF
1240
1241 IF (number_of_parallel_channels > 1) THEN
1242 DEALLOCATE (procs_recv)
1243 DEALLOCATE (recv_requests)
1244 DEALLOCATE (send_requests)
1245 END IF
1246
1247 IF (mp2_env%ri_grad%dot_blksize >= blksize_threshold) THEN
1248 ! release memory allocated by local_gemm when run on GPU. local_gemm_ctx is null on cpu only runs
1249 CALL mp2_env%local_gemm_ctx%destroy()
1250 DEALLOCATE (buffer_compens_1d)
1251 END IF
1252
1253 DO proc_shift = 1, number_of_parallel_channels
1254 NULLIFY (buffer_3d(proc_shift)%array)
1255 DEALLOCATE (buffer_1d(proc_shift)%array)
1256 END DO
1257 DEALLOCATE (buffer_3d, buffer_1d)
1258
1259 CALL timestop(handle)
1260
1261 END SUBROUTINE calc_p_rpa
1262
1263! **************************************************************************************************
1264!> \brief ...
1265!> \param P_ab ...
1266!> \param mat_S ...
1267!> \param mat_work ...
1268!> \param dot_blksize ...
1269!> \param buffer_1D ...
1270!> \param local_gemm_ctx ...
1271!> \param my_eval_virt ...
1272!> \param my_eval_occ ...
1273!> \param recv_eval_virt ...
1274!> \param omega ...
1275!> \param weight ...
1276! **************************************************************************************************
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
1284 TYPE(local_gemm_ctxt_type), INTENT(INOUT) :: local_gemm_ctx
1285 REAL(kind=dp), DIMENSION(:), INTENT(IN) :: my_eval_virt, my_eval_occ, recv_eval_virt
1286 REAL(kind=dp), INTENT(IN) :: omega, weight
1287
1288 CHARACTER(LEN=*), PARAMETER :: routinen = 'calc_P_rpa_a'
1289
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
1294
1295 CALL timeset(routinen, handle)
1296
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)
1301
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)
1306
1307 ! This loop imitates the actual tensor contraction
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
1312
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)
1317
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))
1320
1321 CALL kahan_step(buffer_compens, p_ab)
1322 END DO
1323 END DO
1324 ELSE
1325 block
1326 INTEGER :: recv_a
1327 REAL(kind=dp) :: tmp, e_i, e_a, e_b, omega2, my_compens, my_p, s
1328 omega2 = -omega**2
1329!$OMP PARALLEL DO COLLAPSE(2) DEFAULT(NONE)&
1330!$OMP SHARED(my_a_size,recv_a_size,my_i_size,mat_S,my_eval_virt,recv_eval_virt,my_eval_occ,omega2,&
1331!$OMP P_ab,weight,mat_work)&
1332!$OMP PRIVATE(tmp,my_a,recv_a,my_i,e_a,e_b,e_i,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)
1338 my_compens = 0.0_dp
1339 DO my_i = 1, my_i_size
1340 e_i = -my_eval_occ(my_i)
1341 tmp = -weight*accurate_dot_product(mat_s(:, my_a, my_i), mat_work(:, recv_a, my_i)) &
1342 *(1.0_dp + omega2/((e_a + e_i)*(e_b + e_i))) - my_compens
1343 s = my_p + tmp
1344 my_compens = (s - my_p) - tmp
1345 my_p = s
1346 END DO
1347 p_ab(my_a, recv_a) = my_p
1348 END DO
1349 END DO
1350 END block
1351 END IF
1352
1353 CALL timestop(handle)
1354
1355 END SUBROUTINE calc_p_rpa_a
1356
1357! **************************************************************************************************
1358!> \brief ...
1359!> \param P_ij ...
1360!> \param mat_S ...
1361!> \param mat_work ...
1362!> \param dot_blksize ...
1363!> \param buffer_1D ...
1364!> \param local_gemm_ctx ...
1365!> \param my_eval_virt ...
1366!> \param my_eval_occ ...
1367!> \param recv_eval_occ ...
1368!> \param omega ...
1369!> \param weight ...
1370! **************************************************************************************************
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
1381
1382 CHARACTER(LEN=*), PARAMETER :: routinen = 'calc_P_rpa_i'
1383
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
1388
1389 CALL timeset(routinen, handle)
1390
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)
1395
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)
1400
1401 ! This loop imitates the actual tensor contraction
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
1406
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)
1411
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))
1414
1415 CALL kahan_step(buffer_compens, p_ij)
1416 END DO
1417 END DO
1418 ELSE
1419 block
1420 REAL(kind=dp) :: tmp, e_i, e_a, e_j, omega2, my_compens, my_p, s
1421 INTEGER :: recv_i
1422 omega2 = -omega**2
1423!$OMP PARALLEL DO COLLAPSE(2) DEFAULT(NONE)&
1424!$OMP SHARED(my_a_size,recv_i_size,my_i_size,mat_S,my_eval_occ,my_eval_virt,omega2,&
1425!$OMP recv_eval_occ,P_ij,weight,mat_work)&
1426!$OMP PRIVATE(tmp,my_a,recv_i,my_i,e_i,e_j,e_a,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)
1432 my_compens = 0.0_dp
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
1437 s = my_p + tmp
1438 my_compens = (s - my_p) - tmp
1439 my_p = s
1440 END DO
1441 p_ij(my_i, recv_i) = my_p
1442 END DO
1443 END DO
1444 END block
1445 END IF
1446
1447 CALL timestop(handle)
1448
1449 END SUBROUTINE calc_p_rpa_i
1450
1451! **************************************************************************************************
1452!> \brief ...
1453!> \param compens ...
1454!> \param P ...
1455! **************************************************************************************************
1456 SUBROUTINE kahan_step(compens, P)
1457 REAL(kind=dp), DIMENSION(:, :), INTENT(INOUT) :: compens, p
1458
1459 CHARACTER(LEN=*), PARAMETER :: routinen = 'kahan_step'
1460
1461 INTEGER :: handle, i, j
1462 REAL(kind=dp) :: my_compens, my_p, s
1463
1464 CALL timeset(routinen, handle)
1465
1466!$OMP PARALLEL DO DEFAULT(NONE) SHARED(P,compens) PRIVATE(i,my_p,my_compens,s, j) COLLAPSE(2)
1467 DO j = 1, SIZE(compens, 2)
1468 DO i = 1, SIZE(compens, 1)
1469 my_p = p(i, j)
1470 my_compens = compens(i, j)
1471 s = my_p + my_compens
1472 compens(i, j) = (s - my_p) - my_compens
1473 p(i, j) = s
1474 END DO
1475 END DO
1476!$OMP END PARALLEL DO
1477
1478 CALL timestop(handle)
1479
1480 END SUBROUTINE kahan_step
1481
1482! **************************************************************************************************
1483!> \brief ...
1484!> \param buffer_unscaled ...
1485!> \param buffer_compens ...
1486!> \param omega ...
1487!> \param my_eval_virt ...
1488!> \param recv_eval_virt ...
1489!> \param my_eval_occ ...
1490! **************************************************************************************************
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
1498
1499 CHARACTER(LEN=*), PARAMETER :: routinen = 'scale_buffer_and_add_compens_virt'
1500
1501 INTEGER :: handle, my_a, my_b
1502
1503 CALL timeset(routinen, handle)
1504
1505!$OMP PARALLEL DO DEFAULT(NONE) SHARED(buffer_unscaled,buffer_compens,omega,&
1506!$OMP my_eval_virt,recv_eval_virt,my_eval_occ) PRIVATE(my_a,my_b)
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)
1512 END DO
1513 END DO
1514!$OMP END PARALLEL DO
1515
1516 CALL timestop(handle)
1517
1518 END SUBROUTINE scale_buffer_and_add_compens_virt
1519
1520! **************************************************************************************************
1521!> \brief ...
1522!> \param buffer_unscaled ...
1523!> \param buffer_compens ...
1524!> \param omega ...
1525!> \param my_eval_occ ...
1526!> \param recv_eval_occ ...
1527!> \param my_eval_virt ...
1528! **************************************************************************************************
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
1536
1537 CHARACTER(LEN=*), PARAMETER :: routinen = 'scale_buffer_and_add_compens_occ'
1538
1539 INTEGER :: handle, my_i, my_j
1540
1541 CALL timeset(routinen, handle)
1542
1543!$OMP PARALLEL DO DEFAULT(NONE) SHARED(buffer_compens,buffer_unscaled,omega,&
1544!$OMP my_eval_virt,my_eval_occ,recv_eval_occ) PRIVATE(my_i,my_j)
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)
1550 END DO
1551 END DO
1552!$OMP END PARALLEL DO
1553
1554 CALL timestop(handle)
1555
1556 END SUBROUTINE scale_buffer_and_add_compens_occ
1557
1558! **************************************************************************************************
1559!> \brief ...
1560!> \param x ...
1561!> \return ...
1562! **************************************************************************************************
1563 ELEMENTAL FUNCTION sinh_over_x(x) RESULT(res)
1564 REAL(kind=dp), INTENT(IN) :: x
1565 REAL(kind=dp) :: res
1566
1567 ! Calculate sinh(x)/x
1568 ! Split the intervall to prevent numerical instabilities
1569 IF (abs(x) > 3.0e-4_dp) THEN
1570 res = sinh(x)/x
1571 ELSE
1572 res = 1.0_dp + x**2/6.0_dp
1573 END IF
1574
1575 END FUNCTION sinh_over_x
1576
1577! **************************************************************************************************
1578!> \brief ...
1579!> \param fm_work_iaP ...
1580!> \param fm_mat_S ...
1581!> \param pair_list ...
1582!> \param virtual ...
1583!> \param P_ij ...
1584!> \param Eigenval ...
1585!> \param omega ...
1586!> \param weight ...
1587!> \param index2send ...
1588!> \param index2recv ...
1589!> \param dot_blksize ...
1590! **************************************************************************************************
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
1601
1602 CHARACTER(LEN=*), PARAMETER :: routinen = 'calc_Pij_degen'
1603
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
1614
1615 CALL timeset(routinen, handle)
1616
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)
1622
1623 num_ij_pairs = SIZE(pair_list, 2)
1624
1625 tag = 42
1626
1627 DO ij_counter = 1, num_ij_pairs
1628
1629 my_i = pair_list(1, ij_counter)
1630 my_j = pair_list(2, ij_counter)
1631
1632 trace = 0.0_dp
1633
1634 DO col_local = 1, ncol_local
1635 col_global = col_indices(col_local)
1636
1637 iocc = max(1, col_global - 1)/virtual + 1
1638 avirt = col_global - (iocc - 1)*virtual
1639
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
1643
1644 my_col_local = fm_work_iap%matrix_struct%g2l_col((my_i - 1)*virtual + avirt)
1645
1646 trace = trace + accurate_dot_product_2(fm_mat_s%local_data(:, my_col_local), fm_work_iap%local_data(:, col_local), &
1647 dot_blksize)
1648 END DO
1649
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
1651
1652 END DO
1653
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)
1660
1661 IF (ALLOCATED(index2send(pcol_send)%array)) THEN
1662 size_send_buffer = max(size_send_buffer, SIZE(index2send(pcol_send)%array))
1663 END IF
1664
1665 IF (ALLOCATED(index2recv(pcol_recv)%array)) THEN
1666 size_recv_buffer = max(size_recv_buffer, SIZE(index2recv(pcol_recv)%array))
1667 END IF
1668 END DO
1669
1670 ALLOCATE (buffer_send(nrow_local, size_send_buffer), buffer_recv(nrow_local, size_recv_buffer))
1671
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)
1675
1676 ! Collect data and exchange
1677 send_size = 0
1678 IF (ALLOCATED(index2send(pcol_send)%array)) send_size = SIZE(index2send(pcol_send)%array)
1679
1680 DO counter = 1, send_size
1681 buffer_send(:, counter) = fm_work_iap%local_data(:, index2send(pcol_send)%array(counter))
1682 END DO
1683
1684 recv_size = 0
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)
1691 ELSE
1692 CALL para_env%recv(buffer_recv(:, :recv_size), blacs2mpi(my_prow, pcol_recv), tag)
1693 END IF
1694 CALL timestop(handle2)
1695
1696 DO ij_counter = 1, num_ij_pairs
1697 ! Collect the contributions of the matrix elements
1698
1699 my_i = pair_list(1, ij_counter)
1700 my_j = pair_list(2, ij_counter)
1701
1702 trace = 0.0_dp
1703
1704 DO col_local = 1, recv_size
1705 col_global = index2recv(pcol_recv)%array(col_local)
1706
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
1712
1713 my_col_local = fm_work_iap%matrix_struct%g2l_col((my_i - 1)*virtual + avirt)
1714
1715 trace = trace + accurate_dot_product_2(fm_mat_s%local_data(:, my_col_local), buffer_recv(:, col_local), &
1716 dot_blksize)
1717 END DO
1718
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
1721 END DO
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)
1726 END IF
1727 END DO
1728 IF (ALLOCATED(buffer_send)) DEALLOCATE (buffer_send)
1729 IF (ALLOCATED(buffer_recv)) DEALLOCATE (buffer_recv)
1730 END IF
1731
1732 CALL timestop(handle)
1733
1734 END SUBROUTINE calc_pij_degen
1735
1736! **************************************************************************************************
1737!> \brief ...
1738!> \param fm_work_iaP ...
1739!> \param fm_mat_S ...
1740!> \param pair_list ...
1741!> \param virtual ...
1742!> \param P_ab ...
1743!> \param Eigenval ...
1744!> \param omega ...
1745!> \param weight ...
1746!> \param index2send ...
1747!> \param index2recv ...
1748!> \param dot_blksize ...
1749! **************************************************************************************************
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
1760
1761 CHARACTER(LEN=*), PARAMETER :: routinen = 'calc_Pab_degen'
1762
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
1773
1774 CALL timeset(routinen, handle)
1775
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)
1781
1782 num_ab_pairs = SIZE(pair_list, 2)
1783
1784 tag = 43
1785
1786 DO ab_counter = 1, num_ab_pairs
1787
1788 my_a = pair_list(1, ab_counter)
1789 my_b = pair_list(2, ab_counter)
1790
1791 trace = 0.0_dp
1792
1793 DO col_local = 1, ncol_local
1794 col_global = col_indices(col_local)
1795
1796 iocc = max(1, col_global - 1)/virtual + 1
1797 avirt = col_global - (iocc - 1)*virtual
1798
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)
1803
1804 trace = trace + accurate_dot_product_2(fm_mat_s%local_data(:, my_col_local), fm_work_iap%local_data(:, col_local), &
1805 dot_blksize)
1806
1807 END DO
1808
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
1811
1812 END DO
1813
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)
1820
1821 IF (ALLOCATED(index2send(pcol_send)%array)) THEN
1822 size_send_buffer = max(size_send_buffer, SIZE(index2send(pcol_send)%array))
1823 END IF
1824
1825 IF (ALLOCATED(index2recv(pcol_recv)%array)) THEN
1826 size_recv_buffer = max(size_recv_buffer, SIZE(index2recv(pcol_recv)%array))
1827 END IF
1828 END DO
1829
1830 ALLOCATE (buffer_send(nrow_local, size_send_buffer), buffer_recv(nrow_local, size_recv_buffer))
1831
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)
1835
1836 ! Collect data and exchange
1837 send_size = 0
1838 IF (ALLOCATED(index2send(pcol_send)%array)) send_size = SIZE(index2send(pcol_send)%array)
1839
1840 DO counter = 1, send_size
1841 buffer_send(:, counter) = fm_work_iap%local_data(:, index2send(pcol_send)%array(counter))
1842 END DO
1843
1844 recv_size = 0
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)
1851 ELSE
1852 CALL para_env%recv(buffer_recv(:, :recv_size), blacs2mpi(my_prow, pcol_recv), tag)
1853 END IF
1854 CALL timestop(handle2)
1855
1856 DO ab_counter = 1, num_ab_pairs
1857 ! Collect the contributions of the matrix elements
1858
1859 my_a = pair_list(1, ab_counter)
1860 my_b = pair_list(2, ab_counter)
1861
1862 trace = 0.0_dp
1863
1864 DO col_local = 1, SIZE(index2recv(pcol_recv)%array)
1865 col_global = index2recv(pcol_recv)%array(col_local)
1866
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
1872
1873 my_col_local = fm_work_iap%matrix_struct%g2l_col((iocc - 1)*virtual + my_a)
1874
1875 trace = trace + accurate_dot_product_2(fm_mat_s%local_data(:, my_col_local), buffer_recv(:, col_local), &
1876 dot_blksize)
1877 END DO
1878
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
1881
1882 END DO
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)
1887 END IF
1888 END DO
1889 IF (ALLOCATED(buffer_send)) DEALLOCATE (buffer_send)
1890 IF (ALLOCATED(buffer_recv)) DEALLOCATE (buffer_recv)
1891 END IF
1892
1893 CALL timestop(handle)
1894
1895 END SUBROUTINE calc_pab_degen
1896
1897! **************************************************************************************************
1898!> \brief ...
1899!> \param index2send ...
1900!> \param index2recv ...
1901!> \param fm_mat_S ...
1902!> \param mat_S_3D ...
1903!> \param gd_homo ...
1904!> \param gd_virtual ...
1905!> \param mepos ...
1906! **************************************************************************************************
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
1915
1916 CHARACTER(LEN=*), PARAMETER :: routinen = 'redistribute_fm_mat_S'
1917
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
1924
1925 CALL timeset(routinen, handle)
1926
1927 tag = 46
1928
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)
1931
1932 CALL cp_fm_struct_get(fm_mat_s%matrix_struct, nrow_local=nrow_local, para_env=para_env)
1933
1934 CALL get_group_dist(gd_homo, mepos(2), sizes=my_homo)
1935 CALL get_group_dist(gd_virtual, mepos(1), sizes=my_virtual)
1936
1937 ALLOCATE (mat_s_3d(nrow_local, my_virtual, my_homo))
1938
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))
1944 END DO
1945 END IF
1946
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)
1953
1954 send_size = 0
1955 IF (ALLOCATED(index2send(proc_send)%array)) send_size = SIZE(index2send(proc_send)%array)
1956 size_send_buffer = max(size_send_buffer, send_size)
1957
1958 recv_size = 0
1959 IF (ALLOCATED(index2recv(proc_recv)%array)) recv_size = SIZE(index2recv(proc_recv)%array)
1960 size_recv_buffer = max(size_recv_buffer, recv_size)
1961
1962 END DO
1963
1964 ALLOCATE (buffer_send(nrow_local, size_send_buffer), buffer_recv(nrow_local, size_recv_buffer))
1965
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)
1969
1970 send_size = 0
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))
1974 END DO
1975
1976 recv_size = 0
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)
1982 ELSE
1983 CALL para_env%recv(buffer_recv(:, :recv_size), blacs2mpi(my_prow, proc_recv), tag)
1984 END IF
1985
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)
1990 END DO
1991 ELSE IF (send_size > 0) THEN
1992 CALL para_env%send(buffer_send(:, :send_size), blacs2mpi(my_prow, proc_send), tag)
1993 END IF
1994
1995 END DO
1996
1997 IF (ALLOCATED(buffer_send)) DEALLOCATE (buffer_send)
1998 IF (ALLOCATED(buffer_recv)) DEALLOCATE (buffer_recv)
1999 END IF
2000
2001 CALL timestop(handle)
2002
2003 END SUBROUTINE redistribute_fm_mat_s
2004
2005! **************************************************************************************************
2006!> \brief ...
2007!> \param rpa_grad ...
2008!> \param mp2_env ...
2009!> \param para_env_sub ...
2010!> \param para_env ...
2011!> \param qs_env ...
2012!> \param gd_array ...
2013!> \param color_sub ...
2014!> \param do_ri_sos_laplace_mp2 ...
2015!> \param homo ...
2016!> \param virtual ...
2017! **************************************************************************************************
2018 SUBROUTINE rpa_grad_finalize(rpa_grad, mp2_env, para_env_sub, para_env, qs_env, gd_array, &
2019 color_sub, do_ri_sos_laplace_mp2, homo, virtual)
2020 TYPE(rpa_grad_type), INTENT(INOUT) :: rpa_grad
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
2028
2029 CHARACTER(LEN=*), PARAMETER :: routinen = 'rpa_grad_finalize'
2030
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, &
2033 nspins
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, &
2040 operator_half
2041 TYPE(group_dist_d1_type) :: gd_ia, gd_p
2042
2043 CALL timeset(routinen, handle)
2044
2045 ! Release unnecessary matrices to save memory for next steps
2046
2047 nspins = SIZE(rpa_grad%fm_Y)
2048
2049 ! Scaling factor is required to scale the density matrices and the Gamma matrices later
2050 IF (do_ri_sos_laplace_mp2) THEN
2051 my_scale = mp2_env%scale_s
2052 ELSE
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
2055 END IF
2056
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)
2060 ELSE
2061 CALL rpa_grad_work_finalize(rpa_grad%rpa_work, mp2_env, homo, &
2062 virtual, para_env, para_env_sub)
2063 END IF
2064
2065 CALL get_qs_env(qs_env, blacs_env=blacs_env)
2066
2067 CALL cp_fm_get_info(rpa_grad%fm_Gamma_PQ, ncol_global=dimen_ri)
2068
2069 NULLIFY (fm_struct)
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)
2076 END IF
2077 CALL cp_fm_struct_release(fm_struct)
2078 CALL cp_fm_set_all(fm_pq, 0.0_dp)
2079
2080 ! We still have to left- and right multiply it with PQhalf
2081 CALL dereplicate_and_sum_fm(rpa_grad%fm_Gamma_PQ, fm_pq)
2082
2083 ! Create fm_PQ_half
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)
2086
2087 CALL get_group_dist(gd_array, color_sub, my_group_l_start, my_group_l_end, my_group_l_size)
2088
2089 CALL release_group_dist(gd_p)
2090
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)
2093
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)
2097 END IF
2098
2099 IF (compare_potential_types(mp2_env%ri_metric, mp2_env%potential_parameter)) THEN
2100! Finish Gamma_PQ
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)
2104
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, &
2107 matrix_c=fm_pq)
2108
2109 CALL cp_fm_release(fm_work_pq)
2110 ELSE
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)
2114
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, &
2117 matrix_c=fm_pq)
2118 CALL cp_fm_release(operator_half)
2119
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)
2128 END IF
2129
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, &
2131 fm_pq)
2132
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)
2136 END IF
2137
2138! Now, Gamma_Pia
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)
2143 END DO
2144 END DO
2145
2146 ! Redistribute the Y matrix
2147 DO ispin = 1, nspins
2148 ! Collect all data of columns for the own sub group locally
2149 CALL cp_fm_get_info(rpa_grad%fm_Y(ispin), ncol_global=dimen_ia)
2150
2151 CALL get_qs_env(qs_env, blacs_env=blacs_env)
2152
2153 NULLIFY (fm_struct)
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)
2158
2159 CALL dereplicate_and_sum_fm(rpa_grad%fm_Y(ispin), fm_y)
2160
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)
2163
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, &
2166 matrix_c=fm_g_p_ia)
2167
2168 CALL cp_fm_release(fm_y)
2169
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)
2172
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)
2174
2175 ! create the Gamma_ia_P in DBCSR style
2176 CALL cp_array_to_dbcsr_slices(gamma_2d, homo(ispin), virtual(ispin), para_env_sub, my_ia_start, &
2177 my_ia_end, &
2178 mp2_env%ri_grad%mo_coeff_o(ispin)%matrix, &
2179 matrix_ptrs=mp2_env%ri_grad%G_P_ia(:, ispin))
2180
2181 CALL release_group_dist(gd_ia)
2182
2183 END DO
2184 DEALLOCATE (rpa_grad%fm_Y)
2185 CALL cp_fm_release(fm_pq_half)
2186
2187 CALL timestop(handle)
2188
2189 END SUBROUTINE rpa_grad_finalize
2190
2191! **************************************************************************************************
2192!> \brief ...
2193!> \param sos_mp2_work_occ ...
2194!> \param sos_mp2_work_virt ...
2195!> \param para_env ...
2196!> \param para_env_sub ...
2197!> \param homo ...
2198!> \param virtual ...
2199!> \param mp2_env ...
2200! **************************************************************************************************
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
2207
2208 CHARACTER(LEN=*), PARAMETER :: routinen = 'sos_mp2_grad_finalize'
2209
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, &
2213 nspins, pcol
2214 REAL(kind=dp) :: my_scale
2215
2216 CALL timeset(routinen, handle)
2217
2218 nspins = SIZE(sos_mp2_work_occ)
2219 my_scale = mp2_env%scale_s
2220
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)
2225 END IF
2226 IF (ALLOCATED(sos_mp2_work_occ(ispin)%index2send(pcol)%array)) THEN
2227 DEALLOCATE (sos_mp2_work_occ(ispin)%index2send(pcol)%array)
2228 END IF
2229 IF (ALLOCATED(sos_mp2_work_virt(ispin)%index2recv(pcol)%array)) THEN
2230 DEALLOCATE (sos_mp2_work_virt(ispin)%index2recv(pcol)%array)
2231 END IF
2232 IF (ALLOCATED(sos_mp2_work_virt(ispin)%index2recv(pcol)%array)) THEN
2233 DEALLOCATE (sos_mp2_work_virt(ispin)%index2recv(pcol)%array)
2234 END IF
2235 END DO
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)
2240 END DO
2241
2242 ! Sum P_ij and P_ab and redistribute them
2243 DO ispin = 1, nspins
2244 CALL para_env%sum(sos_mp2_work_occ(ispin)%P)
2245
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)
2250 END DO
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)
2254
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)
2256 END DO
2257 DEALLOCATE (sos_mp2_work_occ(ispin)%P, sos_mp2_work_occ(ispin)%pair_list)
2258
2259 ! Symmetrize P_ij
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))
2262
2263 ! The first index of P_ab has to be distributed within the subgroups,
2264 ! so sum it up first and add the required elements later
2265 CALL para_env%sum(sos_mp2_work_virt(ispin)%P)
2266
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)
2270 my_b_end = itmp(2)
2271
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)
2276 END DO
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)
2280
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)
2283 END DO
2284
2285 DEALLOCATE (sos_mp2_work_virt(ispin)%P, sos_mp2_work_virt(ispin)%pair_list)
2286
2287 ! Symmetrize P_ab
2288 IF (para_env_sub%num_pe > 1) THEN
2289 block
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
2296
2297 CALL create_group_dist(gd_virtual_sub, para_env_sub%num_pe, virtual(ispin))
2298
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)))
2302
2303 ALLOCATE (buffer_send_1d(my_b_size*maxsize(gd_virtual_sub)))
2304 ALLOCATE (buffer_recv(my_b_size, maxsize(gd_virtual_sub)))
2305
2306 DO proc_shift = 1, para_env_sub%num_pe - 1
2307
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)
2310
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)
2313
2314 buffer_send(1:send_a_size, 1:my_b_size) => buffer_send_1d(1:my_b_size*send_a_size)
2315
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)
2319
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))
2322
2323 END DO
2324
2325 DEALLOCATE (buffer_send_1d, buffer_recv)
2326
2327 CALL release_group_dist(gd_virtual_sub)
2328 END block
2329 ELSE
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))
2332 END IF
2333
2334 END DO
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
2339 END IF
2340
2341 CALL timestop(handle)
2342
2343 END SUBROUTINE sos_mp2_grad_finalize
2344
2345! **************************************************************************************************
2346!> \brief ...
2347!> \param rpa_work ...
2348!> \param mp2_env ...
2349!> \param homo ...
2350!> \param virtual ...
2351!> \param para_env ...
2352!> \param para_env_sub ...
2353! **************************************************************************************************
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
2359
2360 CHARACTER(LEN=*), PARAMETER :: routinen = 'rpa_grad_work_finalize'
2361
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
2369
2370 CALL timeset(routinen, handle)
2371
2372 nspins = SIZE(homo)
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
2375
2376 CALL cp_fm_release(rpa_work%fm_mat_Q_copy)
2377
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)
2382 END DO
2383 END DO
2384 DEALLOCATE (rpa_work%index2send, rpa_work%index2recv)
2385
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))
2389
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)
2395
2396 ! Symmetrize P_ij
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))
2399
2400 itmp = get_limit(virtual(ispin), para_env_sub%num_pe, para_env_sub%mepos)
2401 my_b_start = itmp(1)
2402 my_b_end = itmp(2)
2403 my_b_size = my_b_end - my_b_start + 1
2404
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
2407
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))
2410 ! This group dist contains the info which parts of Pab a process currently owns
2411 CALL create_group_dist(gd_a_sub, my_a_start, my_a_end, my_a_size, para_env_sub)
2412 ! This group dist contains the info which parts of Pab a process is supposed to own later
2413 CALL create_group_dist(gd_virtual_sub, para_env_sub%num_pe, virtual(ispin))
2414
2415 ! Calculate local indices of the common range of own matrix and send process
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)
2418
2419 ! Same for recv process but with reverse positions
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)
2422
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, :)
2425
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)
2432
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)
2435
2436 ! Calculate local indices of the common range of own matrix and send process
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)
2439
2440 size_send_buffer = max(size_send_buffer, max(send_end - send_start + 1, 0))
2441
2442 ! Same for recv process but with reverse positions
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)
2445
2446 size_recv_buffer = max(size_recv_buffer, max(recv_end - recv_start + 1, 0))
2447 END DO
2448 ALLOCATE (buffer_send(size_send_buffer, virtual(ispin)), buffer_recv(size_recv_buffer, virtual(ispin)))
2449
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)
2453
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)
2456
2457 ! Calculate local indices of the common range of own matrix and send process
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, :)
2461
2462 ! Same for recv process but with reverse positions
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)
2465
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)
2468
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), :)
2472
2473 END DO
2474
2475 IF (ALLOCATED(buffer_send)) DEALLOCATE (buffer_send)
2476 IF (ALLOCATED(buffer_recv)) DEALLOCATE (buffer_recv)
2477 END IF
2478 DEALLOCATE (rpa_work%P_ab(ispin)%array)
2479
2480 CALL release_group_dist(gd_a_sub)
2481
2482 block
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()
2487 END block
2488
2489 ! Symmetrize P_ab
2490 IF (para_env_sub%num_pe > 1) THEN
2491 block
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
2495
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)))
2499
2500 ALLOCATE (buffer_send_1d(my_b_size*maxsize(gd_virtual_sub)))
2501 ALLOCATE (buffer_recv(my_b_size, maxsize(gd_virtual_sub)))
2502
2503 DO proc_shift = 1, para_env_sub%num_pe - 1
2504
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)
2507
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)
2510
2511 buffer_send(1:send_a_size, 1:my_b_size) => buffer_send_1d(1:my_b_size*send_a_size)
2512
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)
2516
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))
2519
2520 END DO
2521
2522 DEALLOCATE (buffer_send_1d, buffer_recv)
2523 END block
2524 ELSE
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))
2527 END IF
2528
2529 CALL release_group_dist(gd_virtual_sub)
2530
2531 END DO
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
2536 END IF
2537
2538 CALL timestop(handle)
2539 END SUBROUTINE rpa_grad_work_finalize
2540
2541! **************************************************************************************************
2542!> \brief Dereplicate data from fm_sub and collect in fm_global, overlapping data will be added
2543!> \param fm_sub replicated matrix, all subgroups have the same size, will be release on output
2544!> \param fm_global global matrix, on output it will contain the sum of the replicated matrices redistributed
2545! **************************************************************************************************
2546 SUBROUTINE dereplicate_and_sum_fm(fm_sub, fm_global)
2547 TYPE(cp_fm_type), INTENT(INOUT) :: fm_sub, fm_global
2548
2549 CHARACTER(LEN=*), PARAMETER :: routinen = 'dereplicate_and_sum_fm'
2550
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, &
2559 subgroup2mepos
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
2569
2570 CALL timeset(routinen, handle)
2571
2572 tag = 1
2573
2574 nprow_sub = fm_sub%matrix_struct%context%num_pe(1)
2575 npcol_sub = fm_sub%matrix_struct%context%num_pe(2)
2576
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)
2581
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)
2590
2591 IF (para_env%num_pe /= para_env_sub%num_pe) THEN
2592 block
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()
2597 END block
2598 END IF
2599
2600 ALLOCATE (subgroup2mepos(0:para_env_sub%num_pe - 1))
2601 CALL para_env_sub%allgather(para_env%mepos, subgroup2mepos)
2602
2603 CALL timeset(routinen//"_data2", handle2)
2604 ! Create a map how much data has to be sent to what process coordinate, interchange rows and columns to transpose the matrices
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)
2607
2608 ! Create a map how much data has to be sent to what process coordinate, interchange rows and columns to transpose the matrices
2609 ! Do the reverse for the recieve processes
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)
2613
2614 CALL timeset(routinen//"_local", handle2)
2615 ! Loop over local data and transpose
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)
2622
2623!$OMP PARALLEL DO DEFAULT(NONE) PRIVATE(row_local,col_local) &
2624!$OMP SHARED(elements2recv_col,elements2recv_row,recv_buffer,fm_global,&
2625!$OMP index2recv_col,index2recv_row,pcol_recv,prow_recv, &
2626!$OMP fm_sub,index2send_col,index2send_row,pcol_send,prow_send)
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))
2633 END DO
2634 END DO
2635!$OMP END PARALLEL DO
2636 CALL timestop(handle2)
2637
2638 IF (para_env_sub%num_pe > 1) THEN
2639 size_send_buffer = 0_int_8
2640 size_recv_buffer = 0_int_8
2641 ! Loop over all processes in para_env_sub
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)
2645
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)
2651
2652 size_send_buffer = max(size_send_buffer, int(elements2send_col, int_8)*elements2send_row)
2653
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)
2658
2659 size_recv_buffer = max(size_recv_buffer, int(elements2recv_col, int_8)*elements2recv_row)
2660 END DO
2661 ALLOCATE (send_buffer_1d(size_send_buffer), recv_buffer_1d(size_recv_buffer))
2662
2663 ! Loop over all processes in para_env_sub
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)
2667
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)
2673
2674 CALL timeset(routinen//"_pack", handle2)
2675 ! Loop over local data and pack the buffer
2676 ! Transpose the matrix already
2677 send_buffer(1:elements2send_row, 1:elements2send_col) => send_buffer_1d(1:int(elements2send_row, int_8)*elements2send_col)
2678!$OMP PARALLEL DO DEFAULT(NONE) PRIVATE(row_local,col_local) &
2679!$OMP SHARED(elements2send_col,elements2send_row,send_buffer,fm_sub,&
2680!$OMP index2send_col,index2send_row,pcol_send,prow_send)
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))
2686 END DO
2687 END DO
2688!$OMP END PARALLEL DO
2689 CALL timestop(handle2)
2690
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)
2695
2696 ! Send data
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)
2701 ELSE
2702 CALL para_env_sub%recv(recv_buffer, proc_recv, tag)
2703 END IF
2704
2705 CALL timeset(routinen//"_unpack", handle2)
2706!$OMP PARALLEL DO DEFAULT(NONE) PRIVATE(row_local,col_local) &
2707!$OMP SHARED(elements2recv_col,elements2recv_row,recv_buffer,fm_global,&
2708!$OMP index2recv_col,index2recv_row,pcol_recv,prow_recv)
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)
2714 END DO
2715 END DO
2716!$OMP END PARALLEL DO
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)
2720 END IF
2721 END DO
2722 END IF
2723
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)
2727 END DO
2728 DO proc_shift = 0, npcol_sub - 1
2729 DEALLOCATE (index2recv_col(proc_shift)%array)
2730 END DO
2731 DO proc_shift = 0, nprow_global - 1
2732 DEALLOCATE (index2send_row(proc_shift)%array)
2733 END DO
2734 DO proc_shift = 0, nprow_sub - 1
2735 DEALLOCATE (index2recv_row(proc_shift)%array)
2736 END DO
2737 DEALLOCATE (index2send_col, index2recv_col, index2send_row, index2recv_row)
2738
2739 CALL cp_fm_release(fm_sub)
2740
2741 CALL timestop(handle)
2742
2743 END SUBROUTINE dereplicate_and_sum_fm
2744
2745! **************************************************************************************************
2746!> \brief ...
2747!> \param data2send ...
2748!> \param struct_global ...
2749!> \param indices_sub ...
2750!> \param index2send ...
2751! **************************************************************************************************
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
2758
2759 INTEGER :: i_global, i_local, np_global, proc
2760
2761 CALL struct_global%context%get(number_of_process_columns=np_global)
2762
2763 ALLOCATE (data2send(0:np_global - 1))
2764 data2send = 0
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
2769 END DO
2770
2771 ALLOCATE (index2send(0:np_global - 1))
2772 DO proc = 0, np_global - 1
2773 ALLOCATE (index2send(proc)%array(data2send(proc)))
2774 ! We want to crash if there is an error
2775 index2send(proc)%array = -1
2776 END DO
2777
2778 data2send = 0
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
2784 END DO
2785
2786 END SUBROUTINE get_elements2send_col
2787
2788! **************************************************************************************************
2789!> \brief ...
2790!> \param data2send ...
2791!> \param struct_global ...
2792!> \param indices_sub ...
2793!> \param index2send ...
2794! **************************************************************************************************
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
2801
2802 INTEGER :: i_global, i_local, np_global, proc
2803
2804 CALL struct_global%context%get(number_of_process_rows=np_global)
2805
2806 ALLOCATE (data2send(0:np_global - 1))
2807 data2send = 0
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
2812 END DO
2813
2814 ALLOCATE (index2send(0:np_global - 1))
2815 DO proc = 0, np_global - 1
2816 ALLOCATE (index2send(proc)%array(data2send(proc)))
2817 ! We want to crash if there is an error
2818 index2send(proc)%array = -1
2819 END DO
2820
2821 data2send = 0
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
2827 END DO
2828
2829 END SUBROUTINE get_elements2send_row
2830
2831END MODULE rpa_grad
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
Definition cp_fm_types.F:15
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...
Definition kahan_sum.F:29
Defines the basic variable types.
Definition kinds.F:23
integer, parameter, public int_8
Definition kinds.F:54
integer, parameter, public dp
Definition kinds.F:34
integer, parameter, public local_gemm_pu_gpu
Machine interface based on Fortran 2003 and POSIX.
Definition machine.F:17
subroutine, public m_memory(mem)
Returns the total amount of memory [bytes] in use, if known, zero otherwise.
Definition machine.F:443
subroutine, public m_flush(lunit)
flushes units if the &GLOBAL flag is set accordingly
Definition machine.F:127
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.
Definition mp2_laplace.F:13
subroutine, public calc_fm_mat_s_laplace(fm_mat_s, homo, virtual, eigenval, dajquad)
...
Definition mp2_laplace.F:39
Types needed for MP2 calculations.
Definition mp2_types.F:14
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.
Definition rpa_grad.F:13
integer, parameter spla_threshold
Definition rpa_grad.F:105
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)
...
Definition rpa_grad.F:2020
subroutine, public rpa_grad_copy_q(fm_mat_q, rpa_grad)
...
Definition rpa_grad.F:712
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.
Definition rpa_grad.F:121
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.
Definition rpa_grad.F:167
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)
...
Definition rpa_grad.F:737
Utility functions for RPA calculations.
Definition rpa_util.F:13
subroutine, public remove_scaling_factor_rpa(fm_mat_s, virtual, eigenval_last, homo, omega_old)
...
Definition rpa_util.F:642
subroutine, public calc_fm_mat_s_rpa(fm_mat_s, first_cycle, virtual, eigenval, homo, omega, omega_old)
...
Definition rpa_util.F:692
All kind of helpful little routines.
Definition util.F:14
pure integer function, dimension(2), public get_limit(m, n, me)
divide m entries into n parts, return size of part me
Definition util.F:333
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
represent a full matrix
stores all the informations relevant to an mpi environment