61#include "./base/base_uses.f90"
67 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'bse_davidson'
70 REAL(KIND=
dp),
PARAMETER,
PRIVATE :: deg_thresh = 1.0e-6_dp
72 REAL(KIND=
dp),
PARAMETER,
PRIVATE :: ortho_tol = 1.0e-8_dp
78 INTEGER,
PARAMETER,
PRIVATE :: driver_tda = 1, driver_mk = 2, driver_os = 3
103 INTEGER,
INTENT(IN) :: unit_nr
104 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:), &
105 INTENT(OUT) :: exc_ens
108 CHARACTER(LEN=*),
PARAMETER :: routinen =
'bse_davidson_tda'
110 INTEGER :: block_size, handle, iter, k, m, m_max, &
111 n_act, n_cand, n_dependent, n_kernel, &
112 n_ov, n_req, n_restart, n_want, nt
113 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: selected
114 LOGICAL :: all_conv, has_prev, stalled
115 LOGICAL,
ALLOCATABLE,
DIMENSION(:) :: conv, need
116 REAL(kind=
dp) :: dev, t_iter
117 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: de,
diag, res, theta, theta_prev, &
119 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: coef_restart, coef_restart_cand, &
120 coef_ritz, coef_ritz_theta, red_block
123 TYPE(
cp_fm_type) :: fm_az, fm_red_a, fm_work, fm_z
126 CALL timeset(routinen, handle)
131 para_env => mv_env%para_env
133 cpassert(mv_env%blacs_env%num_pe(2) == 1)
135 NULLIFY (diag_blacs_env)
138 CALL davidson_sizes(bse_env, n_ov, unit_nr, n_want, n_act, block_size)
140 ALLOCATE (
diag(n_ov))
143 CALL subspace_ceiling(bse_env, mv_env, driver_tda, n_act, block_size, unit_nr, m_max)
146 CALL cp_fm_create(fm_z, fm_struct, name=
"fm_Z_davidson", set_zero=.true.)
147 CALL cp_fm_create(fm_az, fm_struct, name=
"fm_AZ_davidson", set_zero=.true.)
150 CALL cp_fm_create(fm_work, fm_struct, name=
"fm_work_davidson", set_zero=.true.)
154 nrow_global=m_max, ncol_global=m_max)
155 CALL cp_fm_create(fm_red_a, fm_struct, name=
"fm_red_A_davidson", set_zero=.true.)
159 ALLOCATE (coef_ritz(m_max, n_act), coef_restart_cand(m_max, 2*n_act), coef_ritz_theta(m_max, n_act))
160 ALLOCATE (coef_restart(m_max, 2*n_act))
161 ALLOCATE (theta(m_max), theta_prev(n_act), res(n_act), de(n_act), conv(n_act), need(n_act), &
163 coef_restart_cand(:, :) = 0.0_dp
164 theta_prev(:) = 0.0_dp
170 IF (bse_env%num_guess_transitions > 0)
THEN
171 CALL initial_guess_subblock(mv_env, bse_env,
diag, n_act, m_max, deg_thresh, fm_z, m, theta_sub, &
174 CALL initial_guess(
diag, n_act, m_max, deg_thresh, fm_z, m)
177 IF (extension_deviation(fm_z, fm_z, 0, m, para_env) > ortho_tol)
THEN
178 cpabort(
"BSE Davidson: the initial guess is not orthonormal")
183 CALL reduced_gram_blocks(fm_z, m, fm_az, 1, m, block_size, para_env, fm_red_a)
185 CALL print_iteration_header(
'Block Davidson iterations within the TDA:', unit_nr)
188 DO iter = 1, bse_env%max_iter
192 CALL solve_reduced(fm_red_a, m, n_act, para_env, diag_blacs_env, theta, coef_ritz)
196 IF (m + block_size > m_max .AND. m > n_act .AND. m < n_ov)
THEN
197 coef_restart_cand(1:m, 1:n_act) = coef_ritz(1:m, 1:n_act)
199 IF (has_prev) n_cand = 2*n_act
200 CALL restart_basis(coef_restart_cand, m, n_cand, 2*n_act, coef_restart, k)
201 CALL rotate_in_place(fm_z, m, coef_restart, k, fm_work, fm_az)
202 CALL reduced_rotate(fm_red_a, m, coef_restart, k, para_env, diag_blacs_env)
204 n_restart = n_restart + 1
205 CALL solve_reduced(fm_red_a, m, n_act, para_env, diag_blacs_env, theta, coef_ritz)
210 coef_ritz_theta(1:m, k) = coef_ritz(1:m, k)*theta(k)
212 CALL subspace_rotate(fm_az, m, coef_ritz(1:m, 1:n_act), n_act, fm_work, 1.0_dp, 0.0_dp)
213 CALL subspace_rotate(fm_z, m, coef_ritz_theta(1:m, 1:n_act), n_act, fm_work, -1.0_dp, 1.0_dp)
214 CALL column_norms(fm_work, 1, n_act, para_env, res)
216 CALL convergence_step(bse_env, theta, theta_prev, res, m, n_ov, n_want, iter, t_iter, unit_nr, &
217 de, conv, n_req, need)
218 all_conv = .NOT. any(need)
221 IF (iter == bse_env%max_iter)
EXIT
224 CALL select_roots(bse_env, need, res, min(block_size, m_max - m), selected, nt)
225 CALL davidson_corrections(fm_work, selected(1:nt), theta,
diag, fm_z, m + 1)
226 CALL extend_orthonormal(fm_z, m, nt, para_env, n_dependent)
229 IF (nt == 0 .AND. stalled)
THEN
230 cpabort(
"BSE Davidson: correction vectors vanished before convergence")
234 IF (extension_deviation(fm_z, fm_z, m, nt, para_env) > ortho_tol)
THEN
235 cpabort(
"BSE Davidson: the basis lost orthonormality")
240 n_kernel = n_kernel + nt
243 ALLOCATE (red_block(m + nt, nt))
244 CALL subspace_gram(fm_z, 1, m + nt, fm_az, m + 1, nt, para_env, red_block)
245 CALL reduced_extend(fm_red_a, red_block, m, nt)
246 DEALLOCATE (red_block)
250 coef_restart_cand(:, n_act + 1:2*n_act) = 0.0_dp
251 coef_restart_cand(1:m, n_act + 1:2*n_act) = coef_ritz(1:m, 1:n_act)
253 theta_prev(:) = theta(1:n_act)
257 IF (.NOT. all_conv)
CALL abort_unconverged(theta, res, conv, need, n_req, unit_nr)
258 IF (bse_env%bse_debug_print)
CALL print_tracked_roots(theta, res, n_want, n_act, unit_nr)
260 IF (bse_env%bse_debug_print)
THEN
261 dev = orthonormality_deviation(fm_z, fm_z, m, block_size, para_env)
262 IF (unit_nr > 0)
THEN
263 WRITE (unit_nr,
'(T2,A10,T13,A,T63,ES18.6)')
'BSE|DEBUG|', &
264 'Max deviation of the basis from orthonormality', dev
268 IF (
ALLOCATED(theta_sub))
CALL check_guess_bound(theta_sub, theta, n_req, unit_nr)
269 CALL print_summary(iter, n_kernel, n_restart, n_want, n_req, n_act, n_ov, unit_nr, n_dependent=n_dependent)
271 ALLOCATE (exc_ens(n_want))
272 exc_ens(:) = theta(1:n_want)
274 CALL cp_fm_create(fm_x, fm_struct, name=
"fm_X_davidson", set_zero=.true.)
277 CALL subspace_rotate(fm_z, m, coef_ritz(1:m, 1:n_want), n_want, fm_x, 1.0_dp, 0.0_dp)
284 DEALLOCATE (coef_ritz, coef_restart_cand, coef_ritz_theta, coef_restart, theta, theta_prev, res, de, conv, &
285 need, selected,
diag)
286 IF (
ALLOCATED(theta_sub))
DEALLOCATE (theta_sub)
288 CALL timestop(handle)
318 INTEGER,
INTENT(IN) :: unit_nr
319 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:), &
320 INTENT(OUT) :: exc_ens
322 INTEGER,
INTENT(OUT) :: abba_status
323 REAL(kind=
dp),
INTENT(OUT) :: ab_margin
324 TYPE(
cp_fm_type),
INTENT(IN),
OPTIONAL :: fm_x_tda
326 CHARACTER(LEN=*),
PARAMETER :: routinen =
'bse_davidson_abba_mk'
328 INTEGER :: block_size, guess_col, handle, iter, k, m, m_max, n_act, n_cand, n_dependent, &
329 n_guess_cols, n_kernel, n_ov, n_req, n_restart, n_seed, n_want, nrow_local, nt, nt_guess
330 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: selected
331 LOGICAL :: all_conv, has_prev, stalled
332 LOGICAL,
ALLOCATABLE,
DIMENSION(:) :: conv, need
333 REAL(kind=
dp) :: dev, t_iter
334 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: de,
diag, diag_sq, omega, omega_prev, &
335 omega_sq, res, theta, theta_sub
336 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: coef_restart, coef_restart_cand, &
337 coef_ritz, coef_x, coef_x_omega, &
341 TYPE(
cp_fm_type) :: fm_metric, fm_metric_vec, fm_mw, &
342 fm_red_m, fm_scratch, fm_v, fm_w, &
346 CALL timeset(routinen, handle)
355 para_env => mv_env%para_env
357 cpassert(mv_env%blacs_env%num_pe(2) == 1)
359 NULLIFY (diag_blacs_env)
362 CALL davidson_sizes(bse_env, n_ov, unit_nr, n_want, n_act, block_size)
364 ALLOCATE (
diag(n_ov))
367 CALL subspace_ceiling(bse_env, mv_env, driver_mk, n_act, block_size, unit_nr, m_max)
370 CALL cp_fm_create(fm_v, fm_struct, name=
"fm_V_davidson", set_zero=.true.)
371 CALL cp_fm_create(fm_w, fm_struct, name=
"fm_W_davidson", set_zero=.true.)
372 CALL cp_fm_create(fm_mw, fm_struct, name=
"fm_MW_davidson", set_zero=.true.)
375 CALL cp_fm_create(fm_work, fm_struct, name=
"fm_work_davidson", set_zero=.true.)
378 CALL cp_fm_create(fm_scratch, fm_struct, name=
"fm_scratch_davidson", set_zero=.true.)
382 nrow_global=m_max, ncol_global=m_max)
383 CALL cp_fm_create(fm_red_m, fm_struct, name=
"fm_red_M_davidson", set_zero=.true.)
388 ALLOCATE (coef_ritz(m_max, n_act), coef_restart_cand(m_max, 2*n_act), coef_restart(m_max, 2*n_act))
389 ALLOCATE (coef_x(m_max, n_act), coef_y(m_max, n_act), coef_x_omega(m_max, n_act))
390 ALLOCATE (theta(m_max), omega(n_act), omega_prev(n_act), res(n_act), de(n_act), conv(n_act), &
391 need(n_act), selected(n_act))
392 coef_restart_cand(:, :) = 0.0_dp
393 omega_prev(:) = 0.0_dp
404 IF (
PRESENT(fm_x_tda))
THEN
406 n_seed = min(n_seed, n_act)
409 IF (bse_env%num_guess_transitions > 0)
THEN
410 CALL initial_guess_subblock(mv_env, bse_env,
diag, n_act, m_max, deg_thresh, fm_v, n_guess_cols, theta_sub, &
411 unit_nr, n_seed, abba_status, ab_margin)
413 CALL initial_guess(
diag, n_act, m_max, deg_thresh, fm_v, n_guess_cols, n_seed)
416 ALLOCATE (diag_sq(n_ov))
417 diag_sq(:) =
diag(:)**2
422 DO WHILE (guess_col <= n_guess_cols)
423 nt_guess = min(block_size, n_guess_cols - guess_col + 1)
425 IF (guess_col > m + 1)
THEN
428 CALL extend_basis_mk(mv_env, fm_v, fm_w, fm_mw, fm_scratch, m, nt, n_kernel, n_dependent, abba_status, &
430 IF (abba_status /=
abba_ok)
EXIT
431 guess_col = guess_col + nt_guess
435 IF (abba_status ==
abba_ok)
THEN
436 fm_v%local_data(1:nrow_local, m + 1:n_guess_cols) = 0.0_dp
438 CALL reduced_gram_blocks(fm_w, m, fm_mw, 1, m, block_size, para_env, fm_red_m)
440 CALL print_iteration_header(
'Block Davidson iterations for ABBA, (A+B)(A-B) x = E^2 x:', unit_nr)
442 DO iter = 1, bse_env%max_iter
446 CALL solve_reduced(fm_red_m, m, n_act, para_env, diag_blacs_env, theta, coef_ritz)
450 IF (m + block_size > m_max .AND. m > n_act .AND. m < n_ov)
THEN
451 coef_restart_cand(1:m, 1:n_act) = coef_ritz(1:m, 1:n_act)
453 IF (has_prev) n_cand = 2*n_act
454 CALL restart_basis(coef_restart_cand, m, n_cand, 2*n_act, coef_restart, k)
455 CALL rotate_in_place(fm_v, m, coef_restart, k, fm_work, fm_w, fm_mw)
456 CALL reduced_rotate(fm_red_m, m, coef_restart, k, para_env, diag_blacs_env)
458 n_restart = n_restart + 1
459 CALL solve_reduced(fm_red_m, m, n_act, para_env, diag_blacs_env, theta, coef_ritz)
463 IF (theta(1) <= 0.0_dp)
THEN
464 CALL cp_abort(__location__, &
465 "BSE Davidson (MK_DAVIDSON): negative squared excitation energy. Matrix "// &
466 "(A+B) is not positive definite, or the basis lost its orthonormality.")
468 omega(:) = sqrt(theta(1:n_act))
472 coef_y(1:m, k) = coef_ritz(1:m, k)/sqrt(omega(k))
473 coef_x_omega(1:m, k) = coef_ritz(1:m, k)*omega(k)*sqrt(omega(k))
475 CALL subspace_rotate(fm_mw, m, coef_y(1:m, 1:n_act), n_act, fm_work, 1.0_dp, 0.0_dp)
476 CALL subspace_rotate(fm_v, m, coef_x_omega(1:m, 1:n_act), n_act, fm_work, -1.0_dp, 1.0_dp)
477 CALL column_norms(fm_work, 1, n_act, para_env, res)
479 CALL convergence_step(bse_env, omega, omega_prev, res, m, n_ov, n_want, iter, t_iter, unit_nr, &
480 de, conv, n_req, need)
481 all_conv = .NOT. any(need)
484 IF (iter == bse_env%max_iter)
EXIT
487 CALL select_roots(bse_env, need, res, min(block_size, m_max - m), selected, nt)
488 CALL davidson_corrections(fm_work, selected(1:nt), theta, diag_sq, fm_v, m + 1)
489 CALL extend_basis_mk(mv_env, fm_v, fm_w, fm_mw, fm_scratch, m, nt, n_kernel, n_dependent, abba_status, &
491 IF (abba_status /=
abba_ok)
EXIT
494 IF (nt == 0 .AND. stalled)
THEN
495 cpabort(
"BSE Davidson: correction vectors vanished before convergence")
501 ALLOCATE (red_block(m + nt, nt))
502 CALL subspace_gram(fm_w, 1, m + nt, fm_mw, m + 1, nt, para_env, red_block)
503 CALL reduced_extend(fm_red_m, red_block, m, nt)
504 DEALLOCATE (red_block)
508 coef_restart_cand(:, n_act + 1:2*n_act) = 0.0_dp
509 coef_restart_cand(1:m, n_act + 1:2*n_act) = coef_ritz(1:m, 1:n_act)
511 omega_prev(:) = omega(:)
516 IF (abba_status ==
abba_ok)
THEN
517 IF (.NOT. all_conv)
CALL abort_unconverged(omega, res, conv, need, n_req, unit_nr)
518 IF (bse_env%bse_debug_print)
CALL print_tracked_roots(omega, res, n_want, n_act, unit_nr)
520 IF (bse_env%bse_debug_print)
THEN
521 dev = orthonormality_deviation(fm_v, fm_w, m, block_size, para_env)
522 IF (unit_nr > 0)
THEN
523 WRITE (unit_nr,
'(T2,A10,T13,A,T63,ES18.6)')
'BSE|DEBUG|', &
524 'Max deviation of the basis from orthonormality', dev
532 nrow_global=m, ncol_global=m)
533 CALL cp_fm_create(fm_metric, fm_struct, name=
"bse_basis_metric")
534 CALL cp_fm_create(fm_metric_vec, fm_struct, name=
"bse_basis_metric_vectors")
536 CALL reduced_gram_blocks(fm_v, m, fm_v, 1, m, block_size, para_env, fm_metric)
537 ALLOCATE (omega_sq(m))
540 ab_margin = 1.0_dp/omega_sq(m)
541 DEALLOCATE (omega_sq)
545 IF (
ALLOCATED(theta_sub))
CALL check_guess_bound(theta_sub, omega, n_req, unit_nr)
546 CALL print_summary(iter, n_kernel, n_restart, n_want, n_req, n_act, n_ov, unit_nr, ab_margin, n_dependent)
550 ALLOCATE (exc_ens(n_want))
551 exc_ens(:) = omega(1:n_want)
553 coef_x(1:m, k) = coef_ritz(1:m, k)*sqrt(omega(k))
554 coef_y(1:m, k) = coef_ritz(1:m, k)/sqrt(omega(k))
557 CALL cp_fm_create(fm_x, fm_struct, name=
"fm_X_davidson", set_zero=.true.)
558 CALL cp_fm_create(fm_y, fm_struct, name=
"fm_Y_davidson", set_zero=.true.)
560 CALL subspace_rotate(fm_w, m, coef_y(1:m, 1:n_want), n_want, fm_x, 0.5_dp, 0.0_dp)
561 CALL subspace_rotate(fm_v, m, coef_x(1:m, 1:n_want), n_want, fm_x, 0.5_dp, 1.0_dp)
562 CALL subspace_rotate(fm_w, m, coef_y(1:m, 1:n_want), n_want, fm_y, 0.5_dp, 0.0_dp)
563 CALL subspace_rotate(fm_v, m, coef_x(1:m, 1:n_want), n_want, fm_y, -0.5_dp, 1.0_dp)
573 DEALLOCATE (coef_ritz, coef_restart_cand, coef_x, coef_y, coef_x_omega, coef_restart, theta, omega, omega_prev, &
574 res, de, conv, need, selected,
diag, diag_sq)
575 IF (
ALLOCATED(theta_sub))
DEALLOCATE (theta_sub)
577 CALL timestop(handle)
608 INTEGER,
INTENT(IN) :: unit_nr
609 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:), &
610 INTENT(OUT) :: exc_ens
612 INTEGER,
INTENT(OUT) :: abba_status
613 REAL(kind=
dp),
INTENT(OUT) :: ab_margin
614 TYPE(
cp_fm_type),
INTENT(IN),
OPTIONAL :: fm_x_tda
616 CHARACTER(LEN=*),
PARAMETER :: routinen =
'bse_davidson_abba_os'
618 INTEGER :: block_size, guess_col, handle, iter, k, m, m_max, n_act, n_cand, n_dependent, &
619 n_guess_cols, n_kernel, n_ov, n_pair, n_req, n_restart, n_seed, n_want, nrow_local, nt, &
620 nt_guess, nt_l, nt_r, nt_sel
621 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: selected
622 LOGICAL :: all_conv, has_prev, stalled
623 LOGICAL,
ALLOCATABLE,
DIMENSION(:) :: conv, need
624 REAL(kind=
dp) :: dev, kr_min, t_iter
625 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: de,
diag, omega, omega_prev, res, res_l, &
627 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: coef_left, coef_restart, &
628 coef_restart_cand, coef_right, &
629 coef_work, red_block_k, red_block_m
632 TYPE(
cp_fm_type) :: fm_b, fm_kb, fm_mb, fm_red_k, fm_red_m, &
636 CALL timeset(routinen, handle)
646 para_env => mv_env%para_env
648 cpassert(mv_env%blacs_env%num_pe(2) == 1)
650 NULLIFY (diag_blacs_env)
653 CALL davidson_sizes(bse_env, n_ov, unit_nr, n_want, n_act, block_size)
655 ALLOCATE (
diag(n_ov))
658 CALL subspace_ceiling(bse_env, mv_env, driver_os, n_act, block_size, unit_nr, m_max)
661 CALL cp_fm_create(fm_b, fm_struct, name=
"fm_b_davidson", set_zero=.true.)
662 CALL cp_fm_create(fm_mb, fm_struct, name=
"fm_Mb_davidson", set_zero=.true.)
663 CALL cp_fm_create(fm_kb, fm_struct, name=
"fm_Kb_davidson", set_zero=.true.)
667 CALL cp_fm_create(fm_work, fm_struct, name=
"fm_work_davidson", set_zero=.true.)
670 CALL cp_fm_create(fm_scratch, fm_struct, name=
"fm_scratch_davidson", set_zero=.true.)
674 nrow_global=m_max, ncol_global=m_max)
675 CALL cp_fm_create(fm_red_m, fm_struct, name=
"fm_red_M_davidson", set_zero=.true.)
676 CALL cp_fm_create(fm_red_k, fm_struct, name=
"fm_red_K_davidson", set_zero=.true.)
681 ALLOCATE (coef_right(m_max, n_act), coef_left(m_max, n_act), coef_work(m_max, n_act))
682 ALLOCATE (coef_restart_cand(m_max, 4*n_act), coef_restart(m_max, 4*n_act))
683 ALLOCATE (omega(n_act), omega_prev(n_act), res(n_act), res_l(n_act), de(n_act), conv(n_act), &
684 need(n_act), selected(n_act))
685 coef_restart_cand(:, :) = 0.0_dp
686 omega_prev(:) = 0.0_dp
698 IF (
PRESENT(fm_x_tda))
THEN
700 n_seed = min(n_seed, n_act)
704 IF (bse_env%num_guess_transitions > 0)
THEN
705 CALL initial_guess_subblock(mv_env, bse_env,
diag, n_act, m_max, deg_thresh, fm_b, n_guess_cols, theta_sub, &
706 unit_nr, n_seed, abba_status, ab_margin, n_pair)
708 CALL initial_guess(
diag, n_act, m_max, deg_thresh, fm_b, n_guess_cols, n_seed)
710 n_guess_cols = n_guess_cols + n_pair
715 DO WHILE (guess_col <= n_guess_cols)
716 nt_guess = min(2*block_size, n_guess_cols - guess_col + 1)
718 IF (guess_col > m + 1)
THEN
721 CALL extend_basis_os(mv_env, fm_b, fm_mb, fm_kb, fm_scratch, m, nt, n_kernel, n_dependent)
722 guess_col = guess_col + nt_guess
726 IF (abba_status ==
abba_ok)
THEN
727 fm_b%local_data(1:nrow_local, m + 1:n_guess_cols) = 0.0_dp
729 CALL reduced_gram_blocks(fm_b, m, fm_mb, 1, m, block_size, para_env, fm_red_m)
730 CALL reduced_gram_blocks(fm_b, m, fm_kb, 1, m, block_size, para_env, fm_red_k)
732 CALL print_iteration_header(
'Block Davidson iterations for ABBA, Olsen-Stratmann paired subspace:', &
735 DO iter = 1, bse_env%max_iter
739 CALL solve_reduced_paired(fm_red_m, fm_red_k, m, n_act, para_env, omega, coef_right, coef_left, kr_min, &
740 abba_status, diag_blacs_env)
743 IF (abba_status /=
abba_ok)
EXIT
748 IF (m + 2*block_size > m_max .AND. m > 2*n_act .AND. m < n_ov)
THEN
749 coef_restart_cand(1:m, 1:n_act) = coef_right(1:m, :)
750 coef_restart_cand(1:m, n_act + 1:2*n_act) = coef_left(1:m, :)
752 IF (has_prev) n_cand = 4*n_act
753 CALL restart_basis(coef_restart_cand, m, n_cand, m_max - 2*block_size, coef_restart, k)
754 CALL rotate_in_place(fm_b, m, coef_restart, k, fm_work, fm_mb, fm_kb)
755 CALL reduced_rotate(fm_red_m, m, coef_restart, k, para_env, diag_blacs_env)
756 CALL reduced_rotate(fm_red_k, m, coef_restart, k, para_env, diag_blacs_env)
758 n_restart = n_restart + 1
759 CALL solve_reduced_paired(fm_red_m, fm_red_k, m, n_act, para_env, omega, coef_right, coef_left, kr_min, &
760 abba_status, diag_blacs_env)
762 IF (abba_status /=
abba_ok)
EXIT
768 coef_work(1:m, k) = coef_left(1:m, k)*omega(k)
770 CALL subspace_rotate(fm_mb, m, coef_right(1:m, 1:n_act), n_act, fm_work, 1.0_dp, 0.0_dp)
771 CALL subspace_rotate(fm_b, m, coef_work(1:m, 1:n_act), n_act, fm_work, -1.0_dp, 1.0_dp)
773 coef_work(1:m, k) = coef_right(1:m, k)*omega(k)
775 CALL subspace_rotate(fm_kb, m, coef_left(1:m, 1:n_act), n_act, fm_work, 1.0_dp, 0.0_dp, n_act + 1)
776 CALL subspace_rotate(fm_b, m, coef_work(1:m, 1:n_act), n_act, fm_work, -1.0_dp, 1.0_dp, n_act + 1)
777 CALL column_norms(fm_work, 1, n_act, para_env, res)
778 CALL column_norms(fm_work, n_act + 1, n_act, para_env, res_l)
779 res(:) = max(res(:), res_l(:))
781 CALL convergence_step(bse_env, omega, omega_prev, res, m, n_ov, n_want, iter, t_iter, unit_nr, &
782 de, conv, n_req, need)
783 all_conv = .NOT. any(need)
786 IF (iter == bse_env%max_iter)
EXIT
791 CALL select_roots(bse_env, need, res, min(block_size, (m_max - m + 1)/2), selected, nt_sel)
793 CALL davidson_corrections(fm_work, selected(1:nt_r), omega,
diag, fm_b, m + 1)
794 CALL extend_basis_os(mv_env, fm_b, fm_mb, fm_kb, fm_scratch, m, nt_r, n_kernel, n_dependent)
795 nt_l = min(nt_sel, m_max - m - nt_r)
796 CALL davidson_corrections(fm_work, selected(1:nt_l), omega,
diag, fm_b, m + nt_r + 1, n_act)
797 CALL extend_basis_os(mv_env, fm_b, fm_mb, fm_kb, fm_scratch, m + nt_r, nt_l, n_kernel, n_dependent)
801 IF (nt == 0 .AND. stalled)
THEN
802 cpabort(
"BSE Davidson: correction vectors vanished before convergence")
808 ALLOCATE (red_block_m(m + nt, nt), red_block_k(m + nt, nt))
809 CALL subspace_gram(fm_b, 1, m + nt, fm_mb, m + 1, nt, para_env, red_block_m)
810 CALL subspace_gram(fm_b, 1, m + nt, fm_kb, m + 1, nt, para_env, red_block_k)
811 CALL reduced_extend(fm_red_m, red_block_m, m, nt)
812 CALL reduced_extend(fm_red_k, red_block_k, m, nt)
813 DEALLOCATE (red_block_m, red_block_k)
817 coef_restart_cand(:, 2*n_act + 1:4*n_act) = 0.0_dp
818 coef_restart_cand(1:m, 2*n_act + 1:3*n_act) = coef_right(1:m, :)
819 coef_restart_cand(1:m, 3*n_act + 1:4*n_act) = coef_left(1:m, :)
821 omega_prev(:) = omega(:)
826 IF (abba_status ==
abba_ok)
THEN
827 IF (.NOT. all_conv)
CALL abort_unconverged(omega, res, conv, need, n_req, unit_nr)
828 IF (bse_env%bse_debug_print)
CALL print_tracked_roots(omega, res, n_want, n_act, unit_nr)
830 IF (bse_env%bse_debug_print)
THEN
831 dev = orthonormality_deviation(fm_b, fm_b, m, block_size, para_env)
832 IF (unit_nr > 0)
THEN
833 WRITE (unit_nr,
'(T2,A10,T13,A,T63,ES18.6)')
'BSE|DEBUG|', &
834 'Max deviation of the basis from orthonormality', dev
838 IF (
ALLOCATED(theta_sub))
CALL check_guess_bound(theta_sub, omega, n_req, unit_nr)
839 CALL print_summary(iter, n_kernel, n_restart, n_want, n_req, n_act, n_ov, unit_nr, ab_margin, n_dependent)
842 ALLOCATE (exc_ens(n_want))
843 exc_ens(:) = omega(1:n_want)
845 CALL cp_fm_create(fm_x, fm_struct, name=
"fm_X_davidson", set_zero=.true.)
846 CALL cp_fm_create(fm_y, fm_struct, name=
"fm_Y_davidson", set_zero=.true.)
848 coef_work(1:m, 1:n_want) = 0.5_dp*(coef_right(1:m, 1:n_want) + coef_left(1:m, 1:n_want))
849 CALL subspace_rotate(fm_b, m, coef_work(1:m, 1:n_want), n_want, fm_x, 1.0_dp, 0.0_dp)
850 coef_work(1:m, 1:n_want) = 0.5_dp*(coef_right(1:m, 1:n_want) - coef_left(1:m, 1:n_want))
851 CALL subspace_rotate(fm_b, m, coef_work(1:m, 1:n_want), n_want, fm_y, 1.0_dp, 0.0_dp)
862 DEALLOCATE (coef_right, coef_left, coef_work, coef_restart_cand, coef_restart, omega, omega_prev, res, res_l, &
863 de, conv, need, selected,
diag)
864 IF (
ALLOCATED(theta_sub))
DEALLOCATE (theta_sub)
866 CALL timestop(handle)
887 SUBROUTINE extend_basis_mk(mv_env, fm_V, fm_W, fm_MW, fm_scratch, m, nt, n_kernel, n_dependent, abba_status, &
891 TYPE(
cp_fm_type),
INTENT(IN) :: fm_v, fm_w, fm_mw, fm_scratch
892 INTEGER,
INTENT(IN) :: m
893 INTEGER,
INTENT(INOUT) :: nt, n_kernel, n_dependent, abba_status
894 REAL(kind=
dp),
INTENT(INOUT) :: ab_margin
896 CHARACTER(LEN=*),
PARAMETER :: routinen =
'extend_basis_mk'
900 CALL timeset(routinen, handle)
903 CALL extend_orthonormal(fm_v, m, nt, mv_env%para_env, n_dependent, fm_w)
908 CALL columns_axpy(-1.0_dp, fm_scratch, 1, fm_w, m + 1, nt)
909 n_kernel = n_kernel + nt
912 CALL cholqr2_metric(fm_v, fm_w, m + 1, nt, mv_env%para_env, abba_status, ab_margin)
914 IF (abba_status ==
abba_ok)
THEN
916 IF (extension_deviation(fm_v, fm_w, m, nt, mv_env%para_env) > ortho_tol)
THEN
917 cpabort(
"BSE Davidson: the basis lost orthonormality in the (A-B) inner product")
921 CALL columns_axpy(1.0_dp, fm_scratch, 1, fm_mw, m + 1, nt)
922 n_kernel = n_kernel + nt
926 CALL timestop(handle)
928 END SUBROUTINE extend_basis_mk
944 SUBROUTINE cholqr2_metric(fm_T, fm_KT, first_col, nt, para_env, abba_status, eig_min)
947 INTEGER,
INTENT(IN) :: first_col, nt
949 INTEGER,
INTENT(INOUT) :: abba_status
950 REAL(kind=
dp),
INTENT(INOUT) :: eig_min
952 CHARACTER(LEN=*),
PARAMETER :: routinen =
'cholqr2_metric'
954 INTEGER :: handle, info, ipass, k, n_ov, n_pass, &
956 REAL(kind=
dp) :: shift
957 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: eigval
958 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: chol_factor, gram, gram_raw
960 CALL timeset(routinen, handle)
961 CALL cp_fm_get_info(fm_t, nrow_local=nrow_local, nrow_global=n_ov)
962 ALLOCATE (gram_raw(nt, nt), gram(nt, nt), chol_factor(nt, nt), eigval(nt))
966 DO WHILE (ipass < n_pass)
969 CALL subspace_gram(fm_t, first_col, nt, fm_kt, first_col, nt, para_env, gram_raw)
970 gram(:, :) = 0.5_dp*(gram_raw(:, :) + transpose(gram_raw(:, :)))
971 chol_factor(:, :) = gram(:, :)
973 IF (para_env%is_source())
CALL dpotrf(
'U', nt, chol_factor, nt, info)
974 CALL para_env%bcast(info)
976 IF (n_pass == 3)
THEN
977 CALL cp_abort(__location__, &
978 "BSE Davidson: orthonormalisation in the (A-B) inner product broke down")
980 chol_factor(:, :) = gram(:, :)
982 IF (para_env%is_source())
CALL diamat_all(chol_factor, eigval)
983 CALL para_env%bcast(eigval)
984 IF (eigval(1) < 0.0_dp)
THEN
992 shift = 11.0_dp*(real(n_ov,
dp)*real(nt,
dp) + real(nt,
dp)*real(nt + 1,
dp))* &
993 epsilon(1.0_dp)*norm2(gram)
994 chol_factor(:, :) = gram(:, :)
996 chol_factor(k, k) = chol_factor(k, k) + shift
998 IF (para_env%is_source())
CALL dpotrf(
'U', nt, chol_factor, nt, info)
999 CALL para_env%bcast(info)
1001 CALL cp_abort(__location__, &
1002 "BSE Davidson: orthonormalisation in the (A-B) inner product broke down")
1006 CALL para_env%bcast(chol_factor)
1007 IF (nrow_local > 0)
THEN
1008 CALL dtrsm(
'R',
'U',
'N',
'N', nrow_local, nt, 1.0_dp, chol_factor, nt, &
1009 fm_t%local_data(:, first_col:first_col + nt - 1),
SIZE(fm_t%local_data, 1))
1010 CALL dtrsm(
'R',
'U',
'N',
'N', nrow_local, nt, 1.0_dp, chol_factor, nt, &
1011 fm_kt%local_data(:, first_col:first_col + nt - 1),
SIZE(fm_kt%local_data, 1))
1015 DEALLOCATE (gram_raw, gram, chol_factor, eigval)
1016 CALL timestop(handle)
1018 END SUBROUTINE cholqr2_metric
1044 SUBROUTINE solve_reduced_paired(fm_red_M, fm_red_K, m, n_act, para_env, omega, coef_right, coef_left, kr_min, &
1045 abba_status, blacs_env)
1047 TYPE(
cp_fm_type),
INTENT(IN) :: fm_red_m, fm_red_k
1048 INTEGER,
INTENT(IN) :: m, n_act
1050 REAL(kind=
dp),
DIMENSION(:),
INTENT(OUT) :: omega
1051 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(OUT) :: coef_right, coef_left
1052 REAL(kind=
dp),
INTENT(OUT) :: kr_min
1053 INTEGER,
INTENT(INOUT) :: abba_status
1056 CHARACTER(LEN=*),
PARAMETER :: routinen =
'solve_reduced_paired'
1059 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: kappa, lambda
1061 TYPE(
cp_fm_type) :: fm_h, fm_h_eigvec, fm_k_eigvec, &
1062 fm_k_sqrt, fm_l, fm_mr, fm_r, fm_work
1064 CALL timeset(routinen, handle)
1066 cpassert(n_act <= m)
1071 ALLOCATE (kappa(m), lambda(m))
1074 nrow_global=m, ncol_global=m)
1075 CALL cp_fm_create(fm_k_eigvec, fm_struct, name=
"bse_paired_U")
1076 CALL cp_fm_create(fm_k_sqrt, fm_struct, name=
"bse_paired_S")
1077 CALL cp_fm_create(fm_mr, fm_struct, name=
"bse_paired_Mr")
1078 CALL cp_fm_create(fm_h, fm_struct, name=
"bse_paired_H")
1079 CALL cp_fm_create(fm_h_eigvec, fm_struct, name=
"bse_paired_T")
1080 CALL cp_fm_create(fm_work, fm_struct, name=
"bse_paired_work")
1085 CALL symmetrise_in_place(fm_work, fm_k_eigvec)
1090 IF (kappa(1) <= 0.0_dp)
THEN
1096 CALL parallel_gemm(
'N',
'T', m, m, m, 1.0_dp, fm_work, fm_k_eigvec, 0.0_dp, fm_k_sqrt)
1100 CALL symmetrise_in_place(fm_mr, fm_h_eigvec)
1101 CALL parallel_gemm(
'N',
'N', m, m, m, 1.0_dp, fm_mr, fm_k_sqrt, 0.0_dp, fm_work)
1102 CALL parallel_gemm(
'N',
'N', m, m, m, 1.0_dp, fm_k_sqrt, fm_work, 0.0_dp, fm_h)
1107 IF (lambda(1) <= 0.0_dp)
THEN
1108 CALL cp_abort(__location__, &
1109 "BSE Davidson (OLSEN_STRATMANN): negative squared excitation energy. Matrix "// &
1110 "(A+B) is not positive definite on the trial space, or the basis lost its "// &
1113 omega(1:n_act) = sqrt(lambda(1:n_act))
1118 nrow_global=m, ncol_global=n_act)
1119 CALL cp_fm_create(fm_r, fm_struct, name=
"bse_paired_R")
1120 CALL cp_fm_create(fm_l, fm_struct, name=
"bse_paired_L")
1122 CALL parallel_gemm(
'N',
'N', m, n_act, m, 1.0_dp, fm_k_sqrt, fm_h_eigvec, 0.0_dp, fm_r)
1124 CALL parallel_gemm(
'N',
'N', m, n_act, m, 1.0_dp, fm_mr, fm_r, 0.0_dp, fm_l)
1127 coef_right(:, :) = 0.0_dp
1128 coef_left(:, :) = 0.0_dp
1141 DEALLOCATE (kappa, lambda)
1142 CALL timestop(handle)
1144 END SUBROUTINE solve_reduced_paired
1162 SUBROUTINE extend_basis_os(mv_env, fm_b, fm_Mb, fm_Kb, fm_scratch, m, nt, n_kernel, n_dependent)
1165 TYPE(
cp_fm_type),
INTENT(IN) :: fm_b, fm_mb, fm_kb, fm_scratch
1166 INTEGER,
INTENT(IN) :: m
1167 INTEGER,
INTENT(INOUT) :: nt, n_kernel, n_dependent
1169 CHARACTER(LEN=*),
PARAMETER :: routinen =
'extend_basis_os'
1173 CALL timeset(routinen, handle)
1175 CALL extend_orthonormal(fm_b, m, nt, mv_env%para_env, n_dependent)
1179 IF (extension_deviation(fm_b, fm_b, m, nt, mv_env%para_env) > ortho_tol)
THEN
1180 cpabort(
"BSE Davidson: the basis lost orthonormality")
1185 CALL columns_axpy(-1.0_dp, fm_scratch, 1, fm_kb, m + 1, nt)
1186 CALL columns_axpy(1.0_dp, fm_scratch, 1, fm_mb, m + 1, nt)
1187 n_kernel = n_kernel + nt
1190 CALL timestop(handle)
1192 END SUBROUTINE extend_basis_os
1213 SUBROUTINE convergence_step(bse_env, energies, energies_prev, res, m, n_ov, n_want, iter, t_iter, unit_nr, &
1214 dE, conv, n_req, need)
1217 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: energies, energies_prev, res
1218 INTEGER,
INTENT(IN) :: m, n_ov, n_want, iter
1219 REAL(kind=
dp),
INTENT(IN) :: t_iter
1220 INTEGER,
INTENT(IN) :: unit_nr
1221 REAL(kind=
dp),
DIMENSION(:),
INTENT(OUT) :: de
1222 LOGICAL,
DIMENSION(:),
INTENT(OUT) :: conv
1223 INTEGER,
INTENT(OUT) :: n_req
1224 LOGICAL,
DIMENSION(:),
INTENT(OUT) :: need
1229 de(:) = abs(energies(1:n_act) - energies_prev(1:n_act))
1230 CALL convergence_flags(bse_env, de, res, conv)
1231 n_req = multiplet_end(energies, n_want, n_act, deg_thresh)
1233 IF (m == n_ov) conv(:) = .true.
1234 CALL roots_in_need(conv, energies, res, n_req, need)
1236 CALL print_iteration(iter, m, count(conv(1:n_want)), &
1237 max(maxval(res(1:n_req)), maxval(res, mask=need)), &
1238 maxval(de(1:n_req)), energies(1),
m_walltime() - t_iter, unit_nr)
1240 END SUBROUTINE convergence_step
1250 SUBROUTINE convergence_flags(bse_env, dE, res, conv)
1253 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: de, res
1254 LOGICAL,
DIMENSION(:),
INTENT(OUT) :: conv
1258 DO k = 1,
SIZE(conv)
1259 SELECT CASE (bse_env%convergence_criterion)
1261 conv(k) = de(k) < bse_env%eps_energy
1263 conv(k) = res(k) < bse_env%eps_res
1265 conv(k) = de(k) < bse_env%eps_energy .OR. res(k) < bse_env%eps_res
1267 conv(k) = de(k) < bse_env%eps_energy .AND. res(k) < bse_env%eps_res
1271 END SUBROUTINE convergence_flags
1282 PURE FUNCTION multiplet_end(energies, n_first, n_limit, thresh)
RESULT(n_last)
1284 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: energies
1285 INTEGER,
INTENT(IN) :: n_first, n_limit
1286 REAL(kind=
dp),
INTENT(IN) :: thresh
1290 DO WHILE (n_last < n_limit)
1291 IF (energies(n_last + 1) - energies(n_last) >= thresh)
EXIT
1295 END FUNCTION multiplet_end
1307 SUBROUTINE roots_in_need(conv, energies, res, n_req, need)
1309 LOGICAL,
DIMENSION(:),
INTENT(IN) :: conv
1310 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: energies, res
1311 INTEGER,
INTENT(IN) :: n_req
1312 LOGICAL,
DIMENSION(:),
INTENT(OUT) :: need
1316 DO k = 1,
SIZE(need)
1317 need(k) = .NOT. conv(k)
1318 IF (k > n_req) need(k) = need(k) .AND. energies(k) - res(k) < energies(n_req)
1321 END SUBROUTINE roots_in_need
1332 SUBROUTINE select_roots(bse_env, need, res, n_max, selected, nt)
1335 LOGICAL,
DIMENSION(:),
INTENT(IN) :: need
1336 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: res
1337 INTEGER,
INTENT(IN) :: n_max
1338 INTEGER,
DIMENSION(:),
INTENT(OUT) :: selected
1339 INTEGER,
INTENT(OUT) :: nt
1345 DO k = 1,
SIZE(need)
1346 IF (.NOT. need(k)) cycle
1349 res(k) < bse_env%eps_res) cycle
1350 IF (nt == n_max)
EXIT
1355 END SUBROUTINE select_roots
1362 SUBROUTINE print_iteration_header(title, unit_nr)
1364 CHARACTER(LEN=*),
INTENT(IN) :: title
1365 INTEGER,
INTENT(IN) :: unit_nr
1367 IF (unit_nr > 0)
THEN
1368 WRITE (unit_nr,
'(T2,A4)')
'BSE|'
1369 WRITE (unit_nr,
'(T2,A4,T7,A)')
'BSE|', title
1370 WRITE (unit_nr,
'(T2,A4)')
'BSE|'
1371 WRITE (unit_nr,
'(T2,A4,T7,A)')
'BSE|', &
1372 '|r| in a.u., energies in eV, t the wall time of the iteration'
1373 WRITE (unit_nr,
'(T2,A4)')
'BSE|'
1374 WRITE (unit_nr,
'(T2,A4,T7,A5,T14,A8,T24,A6,T33,A12,T47,A12,T61,A12,T74,A7)')
'BSE|', &
1375 'Iter.',
'Z-space',
'Conv.',
'Max |r|',
'Max dE',
'Lowest E',
't (s)'
1378 END SUBROUTINE print_iteration_header
1391 SUBROUTINE print_iteration(iter, m, n_conv, max_res, max_dE, lowest_E, t_iter, unit_nr)
1393 INTEGER,
INTENT(IN) :: iter, m, n_conv
1394 REAL(kind=
dp),
INTENT(IN) :: max_res, max_de, lowest_e, t_iter
1395 INTEGER,
INTENT(IN) :: unit_nr
1397 IF (unit_nr > 0)
THEN
1398 WRITE (unit_nr,
'(T2,A4,T7,I5,T14,I8,T24,I6,T33,ES12.4,T47,ES12.4,T61,F12.6,T74,F7.2)') &
1399 'BSE|', iter, m, n_conv, max_res, max_de*
evolt, lowest_e*
evolt, t_iter
1402 END SUBROUTINE print_iteration
1413 SUBROUTINE abort_unconverged(energies, res, conv, need, n_req, unit_nr)
1415 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: energies, res
1416 LOGICAL,
DIMENSION(:),
INTENT(IN) :: conv, need
1417 INTEGER,
INTENT(IN) :: n_req, unit_nr
1421 IF (unit_nr > 0)
THEN
1422 WRITE (unit_nr,
'(T2,A4)')
'BSE|'
1423 WRITE (unit_nr,
'(T2,A4,T7,A12,T30,A11,T50,A10,T67,A14)')
'BSE|', &
1424 'Excitation n',
'Energy (eV)',
'|r| (a.u.)',
'Converged'
1425 DO k = 1,
SIZE(need)
1426 IF (k > n_req .AND. .NOT. need(k)) cycle
1427 WRITE (unit_nr,
'(T2,A4,T7,I12,T27,F14.6,T46,ES14.4,T67,L14)')
'BSE|', &
1428 k, energies(k)*
evolt, res(k), conv(k)
1432 cpabort(
"BSE Davidson: MAX_ITER reached before convergence")
1434 END SUBROUTINE abort_unconverged
1444 SUBROUTINE print_tracked_roots(energies, res, n_want, n_act, unit_nr)
1446 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: energies, res
1447 INTEGER,
INTENT(IN) :: n_want, n_act, unit_nr
1451 IF (unit_nr > 0)
THEN
1452 WRITE (unit_nr,
'(T2,A10,T13,A13,T27,A9,T45,A18,T67,A14)')
'BSE|DEBUG|', &
1453 'Tracked state',
'Requested',
'Energy (eV)',
'|r| (a.u.)'
1455 WRITE (unit_nr,
'(T2,A10,T13,I13,T27,L9,T45,F18.10,T67,ES14.4)')
'BSE|DEBUG|', &
1456 k, k <= n_want, energies(k)*
evolt, res(k)
1460 END SUBROUTINE print_tracked_roots
1476 SUBROUTINE print_summary(iter, n_kernel, n_restart, n_want, n_req, n_act, n_ov, unit_nr, ab_margin, &
1479 INTEGER,
INTENT(IN) :: iter, n_kernel, n_restart, n_want, &
1480 n_req, n_act, n_ov, unit_nr
1481 REAL(kind=
dp),
INTENT(IN),
OPTIONAL :: ab_margin
1482 INTEGER,
INTENT(IN),
OPTIONAL :: n_dependent
1484 IF (unit_nr > 0)
THEN
1485 WRITE (unit_nr,
'(T2,A4)')
'BSE|'
1486 WRITE (unit_nr,
'(T2,A4,T7,A,T71,I10)')
'BSE|',
'Davidson iterations', iter
1487 WRITE (unit_nr,
'(T2,A4,T7,A,T71,I10)')
'BSE|',
'Kernel applications', n_kernel
1488 WRITE (unit_nr,
'(T2,A4,T7,A,T71,I10)')
'BSE|',
'Thick restarts', n_restart
1489 IF (
PRESENT(n_dependent))
THEN
1490 IF (n_dependent > 0)
THEN
1491 WRITE (unit_nr,
'(T2,A4,T7,A,T71,I10)')
'BSE|',
'Correction vectors dropped as dependent', n_dependent
1494 IF (
PRESENT(ab_margin))
THEN
1495 WRITE (unit_nr,
'(T2,A4,T7,A,T65,F16.6)')
'BSE|', &
1496 'A-B margin on the trial space (eV)', ab_margin*
evolt
1498 IF (n_req > n_want)
THEN
1499 WRITE (unit_nr,
'(T2,A4,T7,A)')
'BSE|', &
1500 'Note: the requested states end inside a degenerate multiplet.'
1502 WRITE (unit_nr,
'(T2,A4)')
'BSE|'
1505 IF (n_req > n_want .AND. n_req == n_act .AND. n_act < n_ov .AND. unit_nr > 0)
THEN
1506 CALL cp_warn(__location__, &
1507 "BSE Davidson: the degenerate group at NUM_EXC_EN reaches the last buffer state, "// &
1508 "further members may lie above it. Increase BSE_ITERAT%NUM_BUFFER_STATES.")
1511 END SUBROUTINE print_summary
1522 SUBROUTINE davidson_sizes(bse_env, n_ov, unit_nr, n_want, n_act, block_size)
1525 INTEGER,
INTENT(IN) :: n_ov, unit_nr
1526 INTEGER,
INTENT(OUT) :: n_want, n_act, block_size
1528 IF (bse_env%num_exc_en < 1) cpabort(
"BSE_ITERAT%NUM_EXC_EN must be at least 1")
1529 IF (bse_env%num_buffer_states < 0) cpabort(
"BSE_ITERAT%NUM_BUFFER_STATES must not be negative")
1530 IF (bse_env%block_size < 1 .AND. bse_env%block_size /= -1)
THEN
1531 cpabort(
"BSE_ITERAT%BLOCK_SIZE must be at least 1, or -1 for the default")
1533 IF (bse_env%max_iter < 1) cpabort(
"BSE_ITERAT%MAX_ITER must be at least 1")
1535 n_want = bse_env%num_exc_en
1536 IF (n_want > n_ov)
THEN
1537 IF (unit_nr > 0)
CALL cp_warn(__location__, &
1538 "BSE_ITERAT%NUM_EXC_EN exceeds the number of transitions and is reduced to it.")
1541 n_act = min(n_want + bse_env%num_buffer_states, n_ov)
1542 block_size = bse_env%block_size
1544 IF (block_size == -1) block_size = min(32, n_act)
1545 IF (block_size > n_act)
THEN
1546 IF (unit_nr > 0)
CALL cp_warn(__location__, &
1547 "BSE_ITERAT%BLOCK_SIZE exceeds the number of tracked states and is reduced to it.")
1551 END SUBROUTINE davidson_sizes
1566 SUBROUTINE subspace_ceiling(bse_env, mv_env, driver, n_act, block_size, unit_nr, m_max)
1570 INTEGER,
INTENT(IN) :: driver, n_act, block_size, unit_nr
1571 INTEGER,
INTENT(OUT) :: m_max
1573 CHARACTER(LEN=16) :: bud_str, fac_str, mem_str
1574 INTEGER :: m_floor, m_hi, m_lo, m_mid, m_start, &
1575 min_fac, n_ri_max, nb
1576 LOGICAL :: floor_over, lowered
1577 REAL(kind=
dp) :: dist_gb, mem_left_gb, repl_gb
1582 IF (driver == driver_os)
THEN
1587 WRITE (fac_str,
'(I16)') min_fac
1590 IF (bse_env%max_subspace_factor == -1)
THEN
1592 ELSE IF (bse_env%max_subspace_factor >= min_fac)
THEN
1593 m_start = bse_env%max_subspace_factor*n_act
1595 CALL cp_abort(__location__, &
1596 "BSE_ITERAT%MAX_SUBSPACE_FACTOR must be at least "//trim(adjustl(fac_str))// &
1597 " (or -1) for the chosen solver")
1599 m_floor = min(min_fac*n_act, mv_env%n_ov)
1600 m_start = min(max(m_start, m_floor), mv_env%n_ov)
1605 SELECT CASE (driver)
1613 IF (mv_env%block_cols > 0) nb = min(nb, mv_env%block_cols)
1614 n_ri_max = mv_env%n_ri_loc
1615 CALL mv_env%para_env%max(n_ri_max)
1619 CALL davidson_footprint(driver, mv_env, m_max, n_act, block_size, nb, n_ri_max, dist_gb, repl_gb)
1620 lowered = dist_gb + repl_gb > mem_left_gb
1621 floor_over = .false.
1623 CALL davidson_footprint(driver, mv_env, m_floor, n_act, block_size, nb, n_ri_max, dist_gb, repl_gb)
1624 IF (dist_gb + repl_gb > mem_left_gb)
THEN
1632 DO WHILE (m_hi - m_lo > 1)
1633 m_mid = (m_lo + m_hi)/2
1634 CALL davidson_footprint(driver, mv_env, m_mid, n_act, block_size, nb, n_ri_max, dist_gb, repl_gb)
1635 IF (dist_gb + repl_gb <= mem_left_gb)
THEN
1642 CALL davidson_footprint(driver, mv_env, m_max, n_act, block_size, nb, n_ri_max, dist_gb, repl_gb)
1645 IF (unit_nr > 0)
THEN
1646 WRITE (unit_nr,
'(T2,A4)')
'BSE|'
1647 IF (bse_env%max_subspace_factor == -1)
THEN
1648 WRITE (unit_nr,
'(T2,A4,T7,A,T71,I10)')
'BSE|',
'Maximum subspace dimension (20 x buffered states)', &
1651 WRITE (unit_nr,
'(T2,A4,T7,A,T71,I10)')
'BSE|',
'Maximum subspace dimension (MAX_SUBSPACE_FACTOR)', &
1654 IF (m_max < m_start)
THEN
1655 WRITE (unit_nr,
'(T2,A4,T7,A,T71,I10)')
'BSE|',
'Maximum subspace dimension lowered to the memory left', &
1658 WRITE (unit_nr,
'(T2,A4,T7,A)')
'BSE|',
'Memory per MPI rank at the subspace ceiling (GB)'
1659 WRITE (unit_nr,
'(T2,A4,T9,A,T67,F14.3)')
'BSE|',
'Distributed arrays', dist_gb
1660 WRITE (unit_nr,
'(T2,A4,T9,A,T67,F14.3)')
'BSE|',
'Replicated arrays', repl_gb
1661 WRITE (unit_nr,
'(T2,A4,T9,A,T67,F14.3)')
'BSE|',
'Total', dist_gb + repl_gb
1662 WRITE (unit_nr,
'(T2,A4,T7,A,T67,F14.3)')
'BSE|',
'Memory per MPI rank for the BSE, MEMORY_PER_PROC (GB)', &
1663 bse_env%memory_per_proc_gb
1664 WRITE (unit_nr,
'(T2,A4,T7,A,T67,F14.3)')
'BSE|',
'Left for the solver after the memory held (GB)', &
1666 WRITE (unit_nr,
'(T2,A4)')
'BSE|'
1668 IF (floor_over)
THEN
1669 WRITE (mem_str,
'(F16.3)') dist_gb + repl_gb
1670 WRITE (bud_str,
'(F16.3)') mem_left_gb
1671 CALL cp_warn(__location__, &
1672 "BSE Davidson: the minimal subspace of "//trim(adjustl(fac_str))//
" vectors per state needs "// &
1673 trim(adjustl(mem_str))//
" GB per MPI rank, "//trim(adjustl(bud_str))// &
1674 " GB are left of MEMORY_PER_PROC; running with it. Raise MEMORY_PER_PROC or use more MPI ranks.")
1677 END SUBROUTINE subspace_ceiling
1695 SUBROUTINE davidson_footprint(driver, mv_env, m, n_act, block_size, nb, n_ri, dist_GB, repl_GB)
1697 INTEGER,
INTENT(IN) :: driver
1699 INTEGER,
INTENT(IN) :: m, n_act, block_size, nb, n_ri
1700 REAL(kind=
dp),
INTENT(OUT) :: dist_gb, repl_gb
1702 INTEGER :: c_coef, n_basis, n_mv, n_red, n_scratch, &
1703 n_solve, n_virt, n_work
1704 REAL(kind=
dp) :: m_real, n_ov_real
1710 SELECT CASE (driver)
1713 n_work = min(2*n_act, m)
1722 n_work = min(2*n_act, m)
1723 n_scratch = block_size
1731 n_work = max(2*n_act, min(4*n_act, m))
1732 n_scratch = 2*block_size
1740 cpabort(
"BSE Davidson: unknown driver in the memory estimate")
1744 m_real = real(m,
dp)
1745 n_ov_real = real(mv_env%n_ov,
dp)
1746 dist_gb = 8.0e-9_dp*(n_ov_real*real(n_basis*m + n_work + n_scratch,
dp) + real(n_red + n_solve,
dp)*m_real*m_real)/ &
1747 REAL(mv_env%para_env%num_pe,
dp)
1748 repl_gb = 8.0e-9_dp*(real(c_coef,
dp)*m_real*real(n_act,
dp) + m_real*real(block_size,
dp) + &
1749 REAL(n_mv,
dp)*n_ov_real*
REAL(nb, dp) +
REAL(n_ri,
dp)*
REAL(nb, dp) + &
1750 REAL(n_virt,
dp)*
REAL(mv_env%virt,
dp)**2)
1752 END SUBROUTINE davidson_footprint
1766 SUBROUTINE initial_guess(diag, n_guess, n_max, deg_thresh_diag, fm_Z, n_used, n_given)
1768 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) ::
diag
1769 INTEGER,
INTENT(IN) :: n_guess, n_max
1770 REAL(kind=
dp),
INTENT(IN) :: deg_thresh_diag
1772 INTEGER,
INTENT(OUT) :: n_used
1773 INTEGER,
INTENT(IN),
OPTIONAL :: n_given
1775 INTEGER :: iloc, k, k_first, n_ov, nrow_local
1776 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: diag_order
1777 INTEGER,
DIMENSION(:),
POINTER :: row_indices
1778 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: diag_sorted
1781 ALLOCATE (diag_sorted(n_ov), diag_order(n_ov))
1782 diag_sorted(:) =
diag(:)
1783 CALL sort(diag_sorted, n_ov, diag_order)
1785 n_used = multiplet_end(diag_sorted, n_guess, n_max, deg_thresh_diag)
1788 IF (
PRESENT(n_given)) k_first = n_given + 1
1790 CALL cp_fm_get_info(fm_z, nrow_local=nrow_local, row_indices=row_indices)
1791 DO k = k_first, n_used
1792 DO iloc = 1, nrow_local
1793 IF (row_indices(iloc) == diag_order(k)) fm_z%local_data(iloc, k) = 1.0_dp
1797 DEALLOCATE (diag_sorted, diag_order)
1799 END SUBROUTINE initial_guess
1825 SUBROUTINE initial_guess_subblock(mv_env, bse_env, diag, n_guess, n_max, deg_thresh_diag, fm_Z, n_used, &
1826 theta_sub, unit_nr, n_given, abba_status, ab_margin, n_pair)
1830 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) ::
diag
1831 INTEGER,
INTENT(IN) :: n_guess, n_max
1832 REAL(kind=
dp),
INTENT(IN) :: deg_thresh_diag
1834 INTEGER,
INTENT(OUT) :: n_used
1835 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:), &
1836 INTENT(OUT) :: theta_sub
1837 INTEGER,
INTENT(IN) :: unit_nr
1838 INTEGER,
INTENT(IN),
OPTIONAL :: n_given
1839 INTEGER,
INTENT(OUT),
OPTIONAL :: abba_status
1840 REAL(kind=
dp),
INTENT(OUT),
OPTIONAL :: ab_margin
1841 INTEGER,
INTENT(OUT),
OPTIONAL :: n_pair
1843 CHARACTER(LEN=*),
PARAMETER :: routinen =
'initial_guess_subblock'
1845 INTEGER :: handle, iloc, k, k_first, n_ov, n_sub, &
1847 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: diag_order, rank_in_block
1848 INTEGER,
DIMENSION(:),
POINTER :: row_indices
1850 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: diag_sorted, eig_k
1851 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: a_sub, b_sub, eigvec_h, eigvec_k, &
1852 guess_x, guess_y, h_sub, k_mhalf, &
1853 k_phalf, k_sub, m_sub
1856 CALL timeset(routinen, handle)
1858 IF (
PRESENT(n_pair)) n_pair = 0
1859 para_env => mv_env%para_env
1861 n_sub = min(n_ov, max(bse_env%num_guess_transitions, n_guess))
1862 ALLOCATE (diag_sorted(n_ov), diag_order(n_ov), rank_in_block(n_ov))
1863 diag_sorted(:) =
diag(:)
1864 CALL sort(diag_sorted, n_ov, diag_order)
1866 ALLOCATE (a_sub(n_sub, n_sub), guess_x(n_sub, n_sub), theta_sub(n_sub))
1868 IF (
PRESENT(abba_status))
THEN
1870 ALLOCATE (b_sub(n_sub, n_sub), k_sub(n_sub, n_sub), m_sub(n_sub, n_sub), h_sub(n_sub, n_sub), &
1871 eigvec_k(n_sub, n_sub), eigvec_h(n_sub, n_sub), k_phalf(n_sub, n_sub), &
1872 k_mhalf(n_sub, n_sub), eig_k(n_sub))
1875 k_sub(:, :) = a_sub(:, :) - b_sub(:, :)
1876 CALL solve_replicated(k_sub, n_sub, para_env, eig_k, eigvec_k)
1877 ab_margin = eig_k(1)
1878 IF (eig_k(1) <= 0.0_dp)
THEN
1884 k_phalf(:, k) = eigvec_k(:, k)*sqrt(eig_k(k))
1885 k_mhalf(:, k) = eigvec_k(:, k)/sqrt(eig_k(k))
1887 k_phalf(:, :) = matmul(k_phalf, transpose(eigvec_k))
1888 k_mhalf(:, :) = matmul(k_mhalf, transpose(eigvec_k))
1890 m_sub(:, :) = 2.0_dp*a_sub(:, :) - k_sub(:, :)
1891 h_sub(:, :) = matmul(k_phalf, matmul(m_sub, k_phalf))
1892 CALL solve_replicated(h_sub, n_sub, para_env, theta_sub, eigvec_h)
1894 IF (theta_sub(1) <= 0.0_dp)
THEN
1895 cpabort(
"BSE Davidson: the guess block gives a non-positive squared excitation energy")
1897 theta_sub(:) = sqrt(theta_sub(:))
1898 guess_x(:, :) = matmul(k_mhalf, eigvec_h)
1899 IF (
PRESENT(n_pair))
THEN
1901 ALLOCATE (guess_y(n_sub, n_sub))
1902 guess_y(:, :) = matmul(k_sub, guess_x)
1904 guess_y(:, k) = guess_y(:, k)/theta_sub(k)
1908 DEALLOCATE (b_sub, k_sub, m_sub, h_sub, eigvec_k, eigvec_h, k_phalf, k_mhalf, eig_k)
1911 CALL solve_replicated(a_sub, n_sub, para_env, theta_sub, guess_x)
1916 IF (
PRESENT(n_given)) k_first = n_given + 1
1918 n_top = min(n_max, n_sub)
1920 IF (
PRESENT(n_pair)) n_top = min(n_top, (n_max + k_first - 1)/2)
1921 n_used = multiplet_end(theta_sub, n_guess, n_top, deg_thresh_diag)
1923 rank_in_block(:) = 0
1925 rank_in_block(diag_order(k)) = k
1927 CALL cp_fm_get_info(fm_z, nrow_local=nrow_local, row_indices=row_indices)
1928 DO k = k_first, n_used
1929 DO iloc = 1, nrow_local
1930 IF (rank_in_block(row_indices(iloc)) > 0) fm_z%local_data(iloc, k) = guess_x(rank_in_block(row_indices(iloc)), k)
1933 IF (
PRESENT(n_pair))
THEN
1934 n_pair = min(n_used - k_first + 1, n_max - n_used)
1936 DO iloc = 1, nrow_local
1937 IF (rank_in_block(row_indices(iloc)) > 0)
THEN
1938 fm_z%local_data(iloc, n_used + k) = guess_y(rank_in_block(row_indices(iloc)), k_first + k - 1)
1944 IF (unit_nr > 0)
THEN
1945 WRITE (unit_nr,
'(T2,A4,T7,A,T71,I10)')
'BSE|',
'Transitions in the exact guess block', n_sub
1946 IF (bse_env%bse_debug_print)
THEN
1947 WRITE (unit_nr,
'(T2,A10,T13,A,T67,F14.6)')
'BSE|DEBUG|', &
1948 'Lowest Ritz value of the guess block (eV)', theta_sub(1)*
evolt
1953 DEALLOCATE (diag_sorted, diag_order, rank_in_block, a_sub, guess_x)
1954 IF (
ALLOCATED(guess_y))
DEALLOCATE (guess_y)
1956 CALL timestop(handle)
1958 END SUBROUTINE initial_guess_subblock
1968 SUBROUTINE check_guess_bound(theta_sub, energies, n_req, unit_nr)
1970 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: theta_sub, energies
1971 INTEGER,
INTENT(IN) :: n_req, unit_nr
1973 REAL(kind=
dp) :: excess
1975 excess = maxval(energies(1:n_req) - theta_sub(1:n_req))
1976 IF (unit_nr > 0)
THEN
1977 WRITE (unit_nr,
'(T2,A4,T7,A,T65,F16.6)')
'BSE|', &
1978 'Largest excess over the guess-block bound (eV)', excess*
evolt
1980 IF (excess > deg_thresh .AND. unit_nr > 0)
THEN
1981 CALL cp_warn(__location__, &
1982 "A converged BSE state lies above the upper bound given by the guess block, "// &
1983 "so a lower state was missed. Raise BSE_ITERAT%NUM_GUESS_TRANSITIONS or "// &
1984 "BSE_ITERAT%NUM_BUFFER_STATES.")
1987 END SUBROUTINE check_guess_bound
2001 SUBROUTINE solve_reduced(fm_red, m, n_vec, para_env, blacs_env, theta, coef_ritz)
2004 INTEGER,
INTENT(IN) :: m, n_vec
2007 REAL(kind=
dp),
DIMENSION(:),
INTENT(OUT) :: theta
2008 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(OUT) :: coef_ritz
2010 CHARACTER(LEN=*),
PARAMETER :: routinen =
'solve_reduced'
2012 INTEGER :: handle, n_get
2013 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: eigval
2014 TYPE(
cp_fm_type) :: fm_reduced_eigvec, fm_reduced_sym
2016 CALL timeset(routinen, handle)
2018 CALL reduced_live_block(fm_red, m, para_env, blacs_env,
"bse_reduced", fm_reduced_sym)
2019 CALL cp_fm_create(fm_reduced_eigvec, fm_reduced_sym%matrix_struct, name=
"bse_reduced_vectors")
2021 CALL symmetrise_in_place(fm_reduced_sym, fm_reduced_eigvec)
2022 ALLOCATE (eigval(m))
2027 theta(1:m) = eigval(:)
2028 coef_ritz(:, :) = 0.0_dp
2029 n_get = min(m, n_vec)
2036 CALL timestop(handle)
2038 END SUBROUTINE solve_reduced
2050 SUBROUTINE solve_replicated(mat, m, para_env, theta, coef)
2052 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN) :: mat
2053 INTEGER,
INTENT(IN) :: m
2055 REAL(kind=
dp),
DIMENSION(:),
INTENT(OUT) :: theta
2056 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(OUT) :: coef
2058 CHARACTER(LEN=*),
PARAMETER :: routinen =
'solve_replicated'
2061 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: eigval
2062 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: mat_sym
2064 CALL timeset(routinen, handle)
2066 ALLOCATE (mat_sym(m, m), eigval(m))
2067 mat_sym(:, :) = 0.5_dp*(mat(1:m, 1:m) + transpose(mat(1:m, 1:m)))
2069 IF (para_env%is_source())
CALL diamat_all(mat_sym, eigval)
2070 CALL para_env%bcast(mat_sym)
2071 CALL para_env%bcast(eigval)
2074 theta(1:m) = eigval(:)
2076 coef(1:m, 1:m) = mat_sym(:, :)
2077 DEALLOCATE (mat_sym, eigval)
2079 CALL timestop(handle)
2081 END SUBROUTINE solve_replicated
2088 SUBROUTINE symmetrise_in_place(fm_a, fm_scratch)
2090 TYPE(
cp_fm_type),
INTENT(IN) :: fm_a, fm_scratch
2095 END SUBROUTINE symmetrise_in_place
2110 SUBROUTINE restart_basis(cand, m, n_cand, n_cap, coef_restart, n_new)
2112 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN) :: cand
2113 INTEGER,
INTENT(IN) :: m, n_cand, n_cap
2114 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(OUT) :: coef_restart
2115 INTEGER,
INTENT(OUT) :: n_new
2117 CHARACTER(LEN=*),
PARAMETER :: routinen =
'restart_basis'
2118 REAL(kind=
dp),
PARAMETER :: coef_norm_drop = 1.0e-8_dp
2120 INTEGER :: handle, ipass, j, k
2121 REAL(kind=
dp) :: norm
2122 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: basis
2124 CALL timeset(routinen, handle)
2127 ALLOCATE (basis(m, min(n_cap, n_cand)))
2130 IF (n_new == n_cap)
EXIT
2131 basis(:, n_new + 1) = cand(1:m, k)
2136 basis(:, n_new + 1) = basis(:, n_new + 1) - &
2137 dot_product(basis(:, j), basis(:, n_new + 1))*basis(:, j)
2139 norm = norm2(basis(:, n_new + 1))
2140 IF (norm < coef_norm_drop)
EXIT
2141 basis(:, n_new + 1) = basis(:, n_new + 1)/norm
2144 IF (norm < coef_norm_drop) cycle
2147 coef_restart(:, :) = 0.0_dp
2148 coef_restart(1:m, 1:n_new) = basis(:, 1:n_new)
2151 CALL timestop(handle)
2153 END SUBROUTINE restart_basis
2167 SUBROUTINE subspace_rotate(fm_V, nv, coef, nc, fm_out, alpha, beta, out_col)
2170 INTEGER,
INTENT(IN) :: nv
2171 REAL(kind=
dp),
CONTIGUOUS,
DIMENSION(:, :), &
2173 INTEGER,
INTENT(IN) :: nc
2175 REAL(kind=
dp),
INTENT(IN) :: alpha, beta
2176 INTEGER,
INTENT(IN),
OPTIONAL :: out_col
2178 CHARACTER(LEN=*),
PARAMETER :: routinen =
'subspace_rotate'
2180 INTEGER :: handle, nrow_local, o_col
2182 CALL timeset(routinen, handle)
2185 IF (
PRESENT(out_col)) o_col = out_col
2187 IF (nrow_local > 0)
THEN
2188 CALL dgemm(
'N',
'N', nrow_local, nc, nv, alpha, fm_v%local_data,
SIZE(fm_v%local_data, 1), &
2189 coef,
SIZE(coef, 1), beta, fm_out%local_data(:, o_col:o_col + nc - 1),
SIZE(fm_out%local_data, 1))
2192 CALL timestop(handle)
2194 END SUBROUTINE subspace_rotate
2207 SUBROUTINE rotate_in_place(fm_V, m, coef, nq, fm_work, fm_V2, fm_V3)
2210 INTEGER,
INTENT(IN) :: m
2211 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN) :: coef
2212 INTEGER,
INTENT(IN) :: nq
2214 TYPE(
cp_fm_type),
INTENT(IN),
OPTIONAL :: fm_v2, fm_v3
2216 CALL rotate_one(fm_v)
2217 IF (
PRESENT(fm_v2))
CALL rotate_one(fm_v2)
2218 IF (
PRESENT(fm_v3))
CALL rotate_one(fm_v3)
2226 SUBROUTINE rotate_one(fm)
2230 INTEGER :: nrow_local
2232 CALL subspace_rotate(fm, m, coef(1:m, 1:nq), nq, fm_work, 1.0_dp, 0.0_dp)
2235 fm%local_data(1:nrow_local, nq + 1:m) = 0.0_dp
2237 END SUBROUTINE rotate_one
2239 END SUBROUTINE rotate_in_place
2250 SUBROUTINE columns_axpy(alpha, fm_U, u0, fm_T, t0, n)
2252 REAL(kind=
dp),
INTENT(IN) :: alpha
2254 INTEGER,
INTENT(IN) :: u0
2256 INTEGER,
INTENT(IN) :: t0, n
2258 INTEGER :: nrow_local
2261 fm_t%local_data(1:nrow_local, t0:t0 + n - 1) = fm_t%local_data(1:nrow_local, t0:t0 + n - 1) + &
2262 alpha*fm_u%local_data(1:nrow_local, u0:u0 + n - 1)
2264 END SUBROUTINE columns_axpy
2278 SUBROUTINE subspace_gram(fm_U, u0, nu, fm_V, v0, nv, para_env, gram)
2281 INTEGER,
INTENT(IN) :: u0, nu
2283 INTEGER,
INTENT(IN) :: v0, nv
2285 REAL(kind=
dp),
CONTIGUOUS,
DIMENSION(:, :), &
2288 CHARACTER(LEN=*),
PARAMETER :: routinen =
'subspace_gram'
2290 INTEGER :: handle, nrow_local
2292 CALL timeset(routinen, handle)
2296 IF (nrow_local > 0)
THEN
2297 CALL dgemm(
'T',
'N', nu, nv, nrow_local, 1.0_dp, &
2298 fm_u%local_data(:, u0:u0 + nu - 1),
SIZE(fm_u%local_data, 1), &
2299 fm_v%local_data(:, v0:v0 + nv - 1),
SIZE(fm_v%local_data, 1), &
2300 0.0_dp, gram,
SIZE(gram, 1))
2302 CALL para_env%sum(gram)
2304 CALL timestop(handle)
2306 END SUBROUTINE subspace_gram
2321 SUBROUTINE reduced_gram_blocks(fm_U, nu, fm_V, v0, nv, nb, para_env, fm_red)
2324 INTEGER,
INTENT(IN) :: nu
2326 INTEGER,
INTENT(IN) :: v0, nv, nb
2330 CHARACTER(LEN=*),
PARAMETER :: routinen =
'reduced_gram_blocks'
2332 INTEGER :: c0, handle, nc
2333 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: gram_block
2335 CALL timeset(routinen, handle)
2337 ALLOCATE (gram_block(nu, nb))
2338 DO c0 = v0, v0 + nv - 1, nb
2339 nc = min(nb, v0 + nv - c0)
2340 CALL subspace_gram(fm_u, 1, nu, fm_v, c0, nc, para_env, gram_block(:, 1:nc))
2343 DEALLOCATE (gram_block)
2345 CALL timestop(handle)
2347 END SUBROUTINE reduced_gram_blocks
2357 SUBROUTINE reduced_extend(fm_red, red_block, m, nt)
2360 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN) :: red_block
2361 INTEGER,
INTENT(IN) :: m, nt
2364 IF (m > 0)
CALL cp_fm_set_submatrix(fm_red, red_block(1:m, :), m + 1, 1, nt, m, transpose=.true.)
2366 END SUBROUTINE reduced_extend
2377 SUBROUTINE reduced_live_block(fm_red, m, para_env, blacs_env, name, fm_live)
2380 INTEGER,
INTENT(IN) :: m
2383 CHARACTER(LEN=*),
INTENT(IN) :: name
2390 nrow_global=m, ncol_global=m)
2395 END SUBROUTINE reduced_live_block
2407 SUBROUTINE reduced_rotate(fm_red, m, coef_restart, k, para_env, blacs_env)
2410 INTEGER,
INTENT(IN) :: m
2411 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN) :: coef_restart
2412 INTEGER,
INTENT(IN) :: k
2416 CHARACTER(LEN=*),
PARAMETER :: routinen =
'reduced_rotate'
2420 TYPE(
cp_fm_type) :: fm_gq, fm_live, fm_q, fm_qgq
2422 CALL timeset(routinen, handle)
2424 CALL reduced_live_block(fm_red, m, para_env, blacs_env,
"bse_reduced_live", fm_live)
2427 nrow_global=m, ncol_global=k)
2428 CALL cp_fm_create(fm_q, fm_struct, name=
"bse_restart_basis")
2429 CALL cp_fm_create(fm_gq, fm_struct, name=
"bse_reduced_GQ")
2432 nrow_global=k, ncol_global=k)
2433 CALL cp_fm_create(fm_qgq, fm_struct, name=
"bse_reduced_QGQ")
2438 CALL parallel_gemm(
'N',
'N', m, k, m, 1.0_dp, fm_live, fm_q, 0.0_dp, fm_gq)
2439 CALL parallel_gemm(
'T',
'N', k, k, m, 1.0_dp, fm_q, fm_gq, 0.0_dp, fm_qgq)
2448 CALL timestop(handle)
2450 END SUBROUTINE reduced_rotate
2461 FUNCTION orthonormality_deviation(fm_U, fm_V, m, nb, para_env)
RESULT(dev)
2464 INTEGER,
INTENT(IN) :: m, nb
2466 REAL(kind=
dp) :: dev
2468 INTEGER :: c0, l, nc
2469 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: gram_block
2471 ALLOCATE (gram_block(m, nb))
2474 nc = min(nb, m - c0 + 1)
2475 CALL subspace_gram(fm_u, 1, m, fm_v, c0, nc, para_env, gram_block(:, 1:nc))
2477 gram_block(c0 + l - 1, l) = gram_block(c0 + l - 1, l) - 1.0_dp
2479 dev = max(dev, maxval(abs(gram_block(:, 1:nc))))
2481 DEALLOCATE (gram_block)
2483 END FUNCTION orthonormality_deviation
2494 SUBROUTINE column_norms(fm_T, first_col, nt, para_env, norms)
2497 INTEGER,
INTENT(IN) :: first_col, nt
2499 REAL(kind=
dp),
DIMENSION(:),
INTENT(OUT) :: norms
2501 INTEGER :: k, nrow_local
2506 norms(k) = sum(fm_t%local_data(1:nrow_local, first_col + k - 1)**2)
2508 CALL para_env%sum(norms)
2509 norms(:) = sqrt(norms(:))
2511 END SUBROUTINE column_norms
2524 SUBROUTINE davidson_corrections(fm_R, selected, theta, diag, fm_Z, first_col, r_offset)
2527 INTEGER,
DIMENSION(:),
INTENT(IN) :: selected
2528 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: theta,
diag
2530 INTEGER,
INTENT(IN) :: first_col
2531 INTEGER,
INTENT(IN),
OPTIONAL :: r_offset
2533 CHARACTER(LEN=*),
PARAMETER :: routinen =
'davidson_corrections'
2534 REAL(kind=
dp),
PARAMETER :: eref_scale = 0.99_dp, threshold = 16.0_dp*epsilon(1.0_dp)
2536 INTEGER :: handle, iloc, it, k, nrow_local, r_off
2537 INTEGER,
DIMENSION(:),
POINTER :: row_indices
2538 REAL(kind=
dp) :: denom
2540 CALL timeset(routinen, handle)
2543 IF (
PRESENT(r_offset)) r_off = r_offset
2544 CALL cp_fm_get_info(fm_z, nrow_local=nrow_local, row_indices=row_indices)
2545 DO it = 1,
SIZE(selected)
2547 DO iloc = 1, nrow_local
2548 denom =
diag(row_indices(iloc)) - theta(k)
2551 IF (abs(denom) < threshold) denom = denom + (1.0_dp - eref_scale)*theta(k)
2552 fm_z%local_data(iloc, first_col + it - 1) = fm_r%local_data(iloc, r_off + k)/denom
2556 CALL timestop(handle)
2558 END SUBROUTINE davidson_corrections
2572 SUBROUTINE project_out(fm_T, first_col, nt, fm_V, nv, para_env, fm_dual)
2575 INTEGER,
INTENT(IN) :: first_col, nt
2577 INTEGER,
INTENT(IN) :: nv
2579 TYPE(
cp_fm_type),
INTENT(IN),
OPTIONAL :: fm_dual
2581 CHARACTER(LEN=*),
PARAMETER :: routinen =
'project_out'
2583 INTEGER :: handle, ipass, nrow_local
2584 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: coeff
2586 IF (nt == 0 .OR. nv == 0)
RETURN
2587 CALL timeset(routinen, handle)
2589 ALLOCATE (coeff(nv, nt))
2591 IF (
PRESENT(fm_dual))
THEN
2592 CALL subspace_gram(fm_dual, 1, nv, fm_t, first_col, nt, para_env, coeff)
2594 CALL subspace_gram(fm_v, 1, nv, fm_t, first_col, nt, para_env, coeff)
2596 IF (nrow_local > 0)
THEN
2597 CALL dgemm(
'N',
'N', nrow_local, nt, nv, -1.0_dp, &
2598 fm_v%local_data,
SIZE(fm_v%local_data, 1), coeff, nv, 1.0_dp, &
2599 fm_t%local_data(:, first_col:first_col + nt - 1),
SIZE(fm_t%local_data, 1))
2603 CALL timestop(handle)
2605 END SUBROUTINE project_out
2615 SUBROUTINE drop_small_columns(fm_T, first_col, nt, para_env)
2618 INTEGER,
INTENT(IN) :: first_col
2619 INTEGER,
INTENT(INOUT) :: nt
2622 REAL(kind=
dp),
PARAMETER :: col_norm_drop = 1.0e-10_dp
2624 INTEGER :: k, n_kept, nrow_local
2625 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: norms
2629 ALLOCATE (norms(nt))
2630 CALL column_norms(fm_t, first_col, nt, para_env, norms)
2634 IF (norms(k) < col_norm_drop) cycle
2636 fm_t%local_data(1:nrow_local, first_col + n_kept - 1) = &
2637 fm_t%local_data(1:nrow_local, first_col + k - 1)/norms(k)
2639 fm_t%local_data(1:nrow_local, first_col + n_kept:first_col + nt - 1) = 0.0_dp
2643 END SUBROUTINE drop_small_columns
2659 SUBROUTINE cholqr2(fm_T, first_col, nt, para_env, ok, n_dropped)
2662 INTEGER,
INTENT(IN) :: first_col
2663 INTEGER,
INTENT(INOUT) :: nt
2665 LOGICAL,
INTENT(OUT) :: ok
2666 INTEGER,
INTENT(OUT),
OPTIONAL :: n_dropped
2668 CHARACTER(LEN=*),
PARAMETER :: routinen =
'cholqr2'
2669 REAL(kind=
dp),
PARAMETER :: eig_drop_rel = 1.0e-10_dp
2671 INTEGER :: handle, info, ipass, k, n_drop_calls, &
2673 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: eig
2674 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: chol_factor, gram, gram_eigvec, t_reduced
2677 IF (
PRESENT(n_dropped)) n_dropped = 0
2679 CALL timeset(routinen, handle)
2681 ALLOCATE (gram(nt, nt), chol_factor(nt, nt))
2685 DO WHILE (ipass < 2)
2688 CALL subspace_gram(fm_t, first_col, nt, fm_t, first_col, nt, para_env, gram)
2689 chol_factor(:, :) = gram(:, :)
2691 IF (para_env%is_source())
CALL dpotrf(
'U', nt, chol_factor, nt, info)
2692 CALL para_env%bcast(info)
2694 n_drop_calls = n_drop_calls + 1
2695 IF (n_drop_calls > 2)
THEN
2701 ALLOCATE (eig(nt), gram_eigvec(nt, nt))
2702 CALL solve_replicated(gram, nt, para_env, eig, gram_eigvec)
2703 n_keep = count(eig > eig_drop_rel*eig(nt))
2704 IF (n_keep == 0)
THEN
2706 DEALLOCATE (eig, gram_eigvec)
2710 gram_eigvec(:, nt - n_keep + k) = gram_eigvec(:, nt - n_keep + k)/sqrt(eig(nt - n_keep + k))
2712 IF (nrow_local > 0)
THEN
2713 ALLOCATE (t_reduced(nrow_local, n_keep))
2714 CALL dgemm(
'N',
'N', nrow_local, n_keep, nt, 1.0_dp, &
2715 fm_t%local_data(:, first_col:first_col + nt - 1),
SIZE(fm_t%local_data, 1), &
2716 gram_eigvec(:, nt - n_keep + 1:nt), nt, 0.0_dp, t_reduced, nrow_local)
2717 fm_t%local_data(1:nrow_local, first_col:first_col + n_keep - 1) = t_reduced(:, :)
2718 fm_t%local_data(1:nrow_local, first_col + n_keep:first_col + nt - 1) = 0.0_dp
2719 DEALLOCATE (t_reduced)
2721 IF (
PRESENT(n_dropped)) n_dropped = n_dropped + nt - n_keep
2723 DEALLOCATE (eig, gram_eigvec, gram, chol_factor)
2724 ALLOCATE (gram(nt, nt), chol_factor(nt, nt))
2729 CALL para_env%bcast(chol_factor)
2730 IF (nrow_local > 0)
THEN
2731 CALL dtrsm(
'R',
'U',
'N',
'N', nrow_local, nt, 1.0_dp, chol_factor, nt, &
2732 fm_t%local_data(:, first_col:first_col + nt - 1),
SIZE(fm_t%local_data, 1))
2736 DEALLOCATE (gram, chol_factor)
2737 CALL timestop(handle)
2739 END SUBROUTINE cholqr2
2752 SUBROUTINE extend_orthonormal(fm_V, m, nt, para_env, n_dependent, fm_dual)
2755 INTEGER,
INTENT(IN) :: m
2756 INTEGER,
INTENT(INOUT) :: nt
2758 INTEGER,
INTENT(INOUT) :: n_dependent
2759 TYPE(
cp_fm_type),
INTENT(IN),
OPTIONAL :: fm_dual
2761 INTEGER :: n_dropped
2764 CALL project_out(fm_v, m + 1, nt, fm_v, m, para_env, fm_dual)
2765 CALL drop_small_columns(fm_v, m + 1, nt, para_env)
2766 CALL cholqr2(fm_v, m + 1, nt, para_env, ok, n_dropped)
2768 IF (.NOT. ok) cpabort(
"BSE Davidson: orthonormalisation broke down")
2769 n_dependent = n_dependent + n_dropped
2771 END SUBROUTINE extend_orthonormal
2783 FUNCTION extension_deviation(fm_V, fm_dual, nv, nt, para_env)
RESULT(dev)
2785 TYPE(
cp_fm_type),
INTENT(IN) :: fm_v, fm_dual
2786 INTEGER,
INTENT(IN) :: nv, nt
2788 REAL(kind=
dp) :: dev
2791 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: gram
2795 ALLOCATE (gram(nv + nt, nt))
2796 CALL subspace_gram(fm_v, 1, nv + nt, fm_dual, nv + 1, nt, para_env, gram)
2798 gram(nv + k, k) = gram(nv + k, k) - 1.0_dp
2800 dev = maxval(abs(gram))
2803 END FUNCTION extension_deviation
2822 TYPE(
cp_fm_type),
INTENT(IN) :: fm_a_explicit
2823 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: exc_ens
2826 INTEGER,
INTENT(IN) :: unit_nr
2827 TYPE(
cp_fm_type),
INTENT(IN),
OPTIONAL :: fm_b_explicit, fm_y
2829 CHARACTER(LEN=*),
PARAMETER :: routinen =
'bse_davidson_refcheck'
2831 INTEGER :: diag_info, handle, k, n_ov, n_ref, n_want
2832 REAL(kind=
dp) :: min_overlap
2833 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: ref_ens
2834 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: diff_ref, sum_ref, x_dav, x_ref, y_dav, &
2836 TYPE(
cp_fm_type) :: fm_c, fm_eigvec, fm_inv_sqrt_a_minus_b, &
2837 fm_sqrt_a_minus_b, fm_work
2839 CALL timeset(routinen, handle)
2842 cpassert(
PRESENT(fm_b_explicit) .EQV.
PRESENT(fm_y))
2843 IF (unit_nr > 0)
THEN
2844 WRITE (unit_nr,
'(T2,A4)')
'BSE|'
2845 IF (
PRESENT(fm_b_explicit))
THEN
2846 WRITE (unit_nr,
'(T2,A10,T13,A)')
'BSE|DEBUG|',
'Reference check against the explicit A and B'
2848 WRITE (unit_nr,
'(T2,A10,T13,A)')
'BSE|DEBUG|',
'Reference check against the explicit A'
2852 n_want =
SIZE(exc_ens)
2853 ALLOCATE (ref_ens(n_ov))
2855 IF (
PRESENT(fm_b_explicit))
THEN
2857 fm_inv_sqrt_a_minus_b, unit_nr, bse_env, 0.0_dp)
2860 IF (diag_info /= 0) cpabort(
"Reference diagonalization of C failed in the BSE Davidson check")
2861 IF (ref_ens(1) <= 0.0_dp)
THEN
2862 CALL cp_abort(__location__, &
2863 "Reference matrix C has a non-positive eigenvalue in the BSE Davidson check")
2865 ref_ens(:) = sqrt(ref_ens(:))
2867 n_ref = multiplet_end(ref_ens, n_want, n_ov, deg_thresh)
2868 ALLOCATE (sum_ref(n_ov, n_ref), diff_ref(n_ov, n_ref))
2870 CALL parallel_gemm(
"N",
"N", n_ov, n_ref, n_ov, 1.0_dp, fm_sqrt_a_minus_b, fm_eigvec, 0.0_dp, &
2873 CALL parallel_gemm(
"N",
"N", n_ov, n_ref, n_ov, 1.0_dp, fm_inv_sqrt_a_minus_b, fm_eigvec, &
2881 ALLOCATE (x_ref(n_ov, n_ref), y_ref(n_ov, n_ref), y_dav(n_ov, n_want))
2883 sum_ref(:, k) = sum_ref(:, k)/sqrt(ref_ens(k))
2884 diff_ref(:, k) = diff_ref(:, k)*sqrt(ref_ens(k))
2886 x_ref(:, :) = 0.5_dp*(sum_ref(:, :) + diff_ref(:, :))
2887 y_ref(:, :) = 0.5_dp*(sum_ref(:, :) - diff_ref(:, :))
2888 DEALLOCATE (sum_ref, diff_ref)
2892 CALL cp_fm_create(fm_work, fm_a_explicit%matrix_struct)
2894 CALL cp_fm_create(fm_eigvec, fm_a_explicit%matrix_struct)
2896 IF (diag_info /= 0) cpabort(
"Reference diagonalization of A failed in the BSE Davidson check")
2899 n_ref = multiplet_end(ref_ens, n_want, n_ov, deg_thresh)
2900 ALLOCATE (x_ref(n_ov, n_ref))
2905 ALLOCATE (x_dav(n_ov, n_want))
2909 CALL min_multiplet_overlap(ref_ens, n_want, n_ref, x_ref, x_dav, min_overlap, y_ref, y_dav)
2910 CALL print_refcheck(maxval(abs(exc_ens(:) - ref_ens(1:n_want))), min_overlap, unit_nr)
2912 DEALLOCATE (ref_ens, x_ref, x_dav)
2913 IF (
ALLOCATED(y_ref))
DEALLOCATE (y_ref, y_dav)
2915 CALL timestop(handle)
2933 SUBROUTINE min_multiplet_overlap(ref_ens, n_want, n_ref, X_ref, X_dav, min_overlap, Y_ref, Y_dav)
2935 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: ref_ens
2936 INTEGER,
INTENT(IN) :: n_want, n_ref
2937 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN) :: x_ref, x_dav
2938 REAL(kind=
dp),
INTENT(OUT) :: min_overlap
2939 REAL(kind=
dp),
DIMENSION(:, :),
INTENT(IN), &
2940 OPTIONAL :: y_ref, y_dav
2942 INTEGER :: info, lwork, mult_first, mult_last, &
2944 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: sing_vals, work
2945 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: overlap
2946 REAL(kind=
dp),
DIMENSION(1, 1) :: dummy
2948 min_overlap = 1.0_dp
2950 DO WHILE (mult_first <= n_want)
2951 mult_last = multiplet_end(ref_ens, mult_first, n_ref, deg_thresh)
2952 mult_last_dav = min(mult_last, n_want)
2953 ALLOCATE (overlap(mult_last - mult_first + 1, mult_last_dav - mult_first + 1), sing_vals(mult_last_dav - mult_first + 1))
2954 overlap(:, :) = matmul(transpose(x_ref(:, mult_first:mult_last)), x_dav(:, mult_first:mult_last_dav))
2955 IF (
PRESENT(y_ref))
THEN
2956 overlap(:, :) = overlap(:, :) - matmul(transpose(y_ref(:, mult_first:mult_last)), y_dav(:, mult_first:mult_last_dav))
2959 lwork = 5*(mult_last - mult_first + 1) + 10
2960 ALLOCATE (work(lwork))
2961 CALL dgesvd(
'N',
'N', mult_last - mult_first + 1, mult_last_dav - mult_first + 1, overlap, mult_last - mult_first + 1, sing_vals, &
2962 dummy, 1, dummy, 1, work, lwork, info)
2963 IF (info /= 0) cpabort(
"SVD failed in the BSE Davidson check")
2964 min_overlap = min(min_overlap, minval(sing_vals))
2965 DEALLOCATE (overlap, sing_vals, work)
2966 mult_first = mult_last + 1
2969 END SUBROUTINE min_multiplet_overlap
2977 SUBROUTINE print_refcheck(dev_E, min_overlap, unit_nr)
2979 REAL(kind=
dp),
INTENT(IN) :: dev_e, min_overlap
2980 INTEGER,
INTENT(IN) :: unit_nr
2982 IF (unit_nr > 0)
THEN
2983 WRITE (unit_nr,
'(T2,A10,T13,A,T63,ES18.6)')
'BSE|DEBUG|', &
2984 'Max energy deviation vs full diagonalization (eV)', dev_e*
evolt
2985 WRITE (unit_nr,
'(T2,A10,T13,A,T63,F18.12)')
'BSE|DEBUG|', &
2986 'Min subspace overlap vs full diagonalization', min_overlap
2989 END SUBROUTINE print_refcheck
static void dgemm(const char transa, const char transb, const int m, const int n, const int k, const double alpha, const double *a, const int lda, const double *b, const int ldb, const double beta, double *c, const int ldc)
Convenient wrapper to hide Fortran nature of dgemm_, swapping a and b.
collects all references to literature in CP2K as new algorithms / method are included from literature...
integer, save, public olsen1988
integer, save, public fukaya2014
integer, save, public davidson1975
integer, save, public bai2012
integer, save, public stathopoulos1998
integer, save, public stratmann1998
integer, save, public vecharynski2017
Block Davidson solvers for the lowest excitations of the Bethe-Salpeter equation on top of the matrix...
subroutine, public bse_davidson_abba_os(mv_env, bse_env, unit_nr, exc_ens, fm_x, fm_y, abba_status, ab_margin, fm_x_tda)
Block Davidson with thick restart for the NUM_EXC_EN lowest solutions of the full problem in the pair...
integer, parameter, public abba_ok
integer, parameter, public abba_indefinite
subroutine, public bse_davidson_abba_mk(mv_env, bse_env, unit_nr, exc_ens, fm_x, fm_y, abba_status, ab_margin, fm_x_tda)
Block Davidson with thick restart for the NUM_EXC_EN lowest solutions of the full problem,...
subroutine, public bse_davidson_tda(mv_env, bse_env, unit_nr, exc_ens, fm_x)
Block Davidson with thick restart for the NUM_EXC_EN lowest solutions of sum_jb A_ia,...
subroutine, public bse_davidson_refcheck(fm_a_explicit, exc_ens, fm_x, bse_env, unit_nr, fm_b_explicit, fm_y)
Debug check of a Davidson result against the full diagonalization of the explicit matrices: energies,...
Routines for the full diagonalization of GW + Bethe-Salpeter for computing electronic excitations.
subroutine, public create_hermitian_form_of_abba(fm_a, fm_b, fm_c, fm_sqrt_a_minus_b, fm_inv_sqrt_a_minus_b, unit_nr, bse_env, diag_est)
Construct Matrix C=(A-B)^0.5 (A+B) (A-B)^0.5 to solve full BSE matrix as a hermitian problem (cf....
Matrix-free application of the BSE matrices A and B to trial vectors from RI slabs that are sliced al...
real(kind=dp) function, public bse_memory_left_gb(memory_per_proc_gb, para_env)
What MEMORY_PER_PROC leaves to a step: the resolved memory per MPI rank minus the memory the rank hol...
subroutine, public bse_matvec_subblock(mv_env, ia_list, a_sub, b_sub)
Exact A (and B) on a list of transitions, replicated on every rank, A_kl = δ_kl (ε_a-ε_i) + α sum_P B...
subroutine, public bse_matvec_apply(mv_env, fm_z, first_col, ncol, fm_az, fm_bz, first_col_bz)
Applies A (and B) to ncol trial vectors without forming an N_ov x N_ov object, (A Z)_ia = (ε_a-ε_i) Z...
subroutine, public bse_matvec_diagonal(mv_env, precond_kind, diag)
Diagonal used by the Davidson correction, either ε_a-ε_i or the full diagonal A_ia,...
subroutine, public bse_matvec_vector_struct(mv_env, ncol_global, fm_struct)
Matrix structure of a block of trial vectors: rows ia distributed, all columns local.
The BSE environment: the settings of the &BSE section and the state a GW path prepares for the solver...
methods related to the blacs parallel environment
subroutine, public cp_blacs_env_release(blacs_env)
releases the given blacs_env
subroutine, public cp_blacs_env_create(blacs_env, para_env, blacs_grid_layout, blacs_repeatable, row_major, grid_2d)
allocates and initializes a type that represent a blacs context
Basic linear algebra operations for full matrices.
subroutine, public cp_fm_transpose(matrix, matrixt)
transposes a matrix matrixt = matrix ^ T
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....
subroutine, public cp_fm_column_scale(matrixa, scaling, first_col, source)
Scales columns of the full matrix by corresponding factors.
used for collecting some of the diagonalization schemes available for cp_fm_type. cp_fm_power also mo...
subroutine, public choose_eigv_solver(matrix, eigenvectors, eigenvalues, info)
Choose the Eigensolver depending on which library is available ELPA seems to be unstable for small sy...
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_release(fmstruct)
releases a full matrix structure
represent a full matrix distributed on many processors
subroutine, public cp_fm_get_info(matrix, name, nrow_global, ncol_global, nrow_block, ncol_block, nrow_local, ncol_local, row_indices, col_indices, local_data, context, nrow_locals, ncol_locals, matrix_struct, para_env)
returns all kind of information about the full matrix
subroutine, public cp_fm_set_submatrix(fm, new_values, start_row, start_col, n_rows, n_cols, alpha, beta, transpose)
sets a submatrix of a full matrix fm(start_row:start_row+n_rows,start_col:start_col+n_cols) = alpha*o...
subroutine, public cp_fm_to_fm_submat(msource, mtarget, nrow, ncol, s_firstrow, s_firstcol, t_firstrow, t_firstcol)
copy just a part ot the matrix
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
subroutine, public cp_fm_get_submatrix(fm, target_m, start_row, start_col, n_rows, n_cols, transpose)
gets a submatrix of a full matrix op(target_m)(1:n_rows,1:n_cols) =fm(start_row:start_row+n_rows,...
Defines the basic variable types.
integer, parameter, public dp
Machine interface based on Fortran 2003 and POSIX.
real(kind=dp) function, public m_walltime()
returns time from a real-time clock, protected against rolling early/easily
Collection of simple mathematical functions and subroutines.
subroutine, public diamat_all(a, eigval, dac)
Diagonalize the symmetric n by n matrix a using the LAPACK library. Only the upper triangle of matrix...
subroutine, public diag(n, a, d, v)
Diagonalize matrix a. The eigenvalues are returned in vector d and the eigenvectors are returned in m...
Interface to the message passing library MPI.
basic linear algebra operations for full matrixes
Definition of physical constants:
real(kind=dp), parameter, public evolt
All kind of helpful little routines.
RI slabs of one spin channel, every rank holding n_ri_loc whole RI slices.
Settings of the &BSE section (read_bse_section, re-read before every BSE run, normalised in place by ...
represent a blacs multidimensional parallel environment (for the mpi corrispective see cp_paratypes/m...
keeps the information about the structure of a full matrix
stores all the informations relevant to an mpi environment