(git:27c966b)
Loading...
Searching...
No Matches
bse_iterative.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 Iterative solution of the Bethe-Salpeter equation: the block Davidson solvers on top of
10!> the matrix-free application of A and B, and the post-processing of their eigenvectors.
11!> The solvers live in bse_davidson, apart from this driver, so that a later Lanczos-Haydock
12!> solver for the spectrum can share the matrix-free A and B of bse_matvec and this driver
13!> \par History
14!> 09.2026 created [Maximilian Graml]
15! **************************************************************************************************
17
18 USE bse_davidson, ONLY: abba_indefinite,&
23 USE bse_full_diag, ONLY: create_a_and_b,&
25 USE bse_matvec, ONLY: bse_matvec_create,&
30 USE bse_types, ONLY: bse_env_type
37 USE cp_fm_types, ONLY: cp_fm_create,&
49 USE kinds, ONLY: dp
50 USE physcon, ONLY: evolt
51#include "./base/base_uses.f90"
52
53 IMPLICIT NONE
54
55 PRIVATE
56
57 CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'bse_iterative'
58
59 PUBLIC :: solve_bse_iteratively
60
61CONTAINS
62
63! **************************************************************************************************
64!> \brief Lowest excitations of a closed-shell reference from the block Davidson solvers on top of
65!> the matrix-free application of A and B, post-processed as in the full diagonalization.
66!> TDA (bse_davidson_tda): sum_jb A_ia,jb X_jb^n = Ω^n X_ia^n. Full problem, by ABBA_SOLVER:
67!> MK_DAVIDSON, sum_jb [(A+B)(A-B)]_ia,jb x_jb^n = (Ω^n)^2 x_ia^n with x^n = X^n - Y^n;
68!> OLSEN_STRATMANN, sum_jb (A+B)_ia,jb y_jb^n = Ω^n x_ia^n and sum_jb (A-B)_ia,jb x_jb^n = Ω^n y_ia^n
69!> with y^n = X^n + Y^n. Neither A nor B is formed: bse_matvec_apply contracts the RI slabs,
70!> (A Z)_ia = (ε_a-ε_i) Z_ia + α sum_P B^P_ia sum_jb B^P_jb Z_jb - w sum_Pjb \bar{B}^P_ij B^P_ab Z_jb
71!> (B Z)_ia = α sum_P B^P_ia sum_jb B^P_jb Z_jb - w sum_Pjb \bar{B}^P_ib B^P_ja Z_jb
72!> with α, w and \bar{B} set by create_matvec_env from SPIN_CONFIG and SCREENING_IN_W.
73!> The five slabs are released once the solver holds its RI-sliced copies
74!> \param Eigenval_reduced energies of the homo_red + virt_red active levels in Hartree, QP or DFT per USE_KS_ENERGIES
75!> \param homo_red_arr occupied levels in the active window, per spin; entry 1 is used
76!> \param virt_red_arr virtual levels in the active window, per spin; entry 1 is used
77!> \param homo occupied levels of the full reference, per spin; postprocess_bse indexes the MOs with it
78!> \param dimen_RI number of RI functions; only the debug construction of the explicit A and B uses it
79!> \param do_tda solve the TDA problem
80!> \param do_abba solve the full problem; after the TDA in a TDA+ABBA run, seeded with X^TDA
81!> \param bse_env the BSE environment: the BSE_ITERAT settings, BSE_DEBUG_PRINT and the TDDFPT control flags;
82!> the five slabs of spin 1, released here: fm_S_ia = B^P_ia (N_RI x homo_red*virt_red), fm_S_ij = B^P_ij,
83!> fm_S_ab = B^P_ab, fm_S_bar_ia = \bar{B}^P_ia = sum_Q [1+Q(0)]^-1_PQ B^Q_ia (the slab of W_ib,aj) and
84!> fm_S_bar_ij = \bar{B}^P_ij (the slab of W_ij,ab)
85!> \param mo_coeff MO coefficients of the reference, handed to postprocess_bse
86!> \param unit_nr output unit, positive on the writing rank only
87! **************************************************************************************************
88 SUBROUTINE solve_bse_iteratively(Eigenval_reduced, &
89 homo_red_arr, virt_red_arr, homo, dimen_RI, &
90 do_tda, do_abba, bse_env, mo_coeff, unit_nr)
91
92 REAL(kind=dp), DIMENSION(:), INTENT(IN) :: eigenval_reduced
93 INTEGER, DIMENSION(:), INTENT(IN) :: homo_red_arr, virt_red_arr, homo
94 INTEGER, INTENT(IN) :: dimen_ri
95 LOGICAL, INTENT(IN) :: do_tda, do_abba
96 TYPE(bse_env_type), INTENT(INOUT) :: bse_env
97 TYPE(cp_fm_type), DIMENSION(:), INTENT(IN) :: mo_coeff
98 INTEGER, INTENT(IN) :: unit_nr
99
100 CHARACTER(LEN=*), PARAMETER :: routinen = 'solve_bse_iteratively'
101 INTEGER, PARAMETER :: n_ov_max_debug = 20000
102
103 CHARACTER(LEN=16) :: margin_str, n_ov_str, solver_str
104 INTEGER :: abba_status, handle, n_ov
105 LOGICAL :: do_debug
106 REAL(kind=dp) :: ab_margin
107 REAL(kind=dp), ALLOCATABLE, DIMENSION(:) :: exc_ens, exc_ens_abba
108 TYPE(bse_matvec_env_type) :: mv_env
109 TYPE(cp_blacs_env_type), POINTER :: blacs_env_ia
110 TYPE(cp_fm_type) :: fm_a_bse, fm_b_bse, fm_x_abba, fm_x_ia, &
111 fm_y_abba, fm_y_ia
112 TYPE(cp_fm_type), POINTER :: fm_tda_guess
113 TYPE(cp_fm_type), TARGET :: fm_x
114 TYPE(dft_control_type), POINTER :: dft_control
115
116 CALL timeset(routinen, handle)
117
118 dft_control => bse_env%dft_control
119 IF (dft_control%tddfpt2_control%do_bse .OR. dft_control%tddfpt2_control%do_bse_w_only .OR. &
120 dft_control%tddfpt2_control%do_bse_gw_only) THEN
121 ! the TDDFPT path reads the explicit A and W matrices that create_A_and_B (FULLDIAG) stashes in the
122 ! excited-state environment; ITERDIAG never forms them
123 CALL cp_abort(__location__, &
124 "BSE_DIAG_METHOD ITERDIAG cannot provide the BSE kernel of TDDFPT "// &
125 "(DO_BSE, DO_BSE_W_ONLY, DO_BSE_GW_ONLY). Use BSE_DIAG_METHOD FULLDIAG.")
126 END IF
127
128 n_ov = homo_red_arr(1)*virt_red_arr(1)
129 ! the debug checks hold the explicit N_ov x N_ov matrices
130 do_debug = bse_env%bse_debug_print .AND. n_ov <= n_ov_max_debug
131 IF (bse_env%bse_debug_print .AND. .NOT. do_debug .AND. unit_nr > 0) THEN
132 WRITE (n_ov_str, '(I0)') n_ov_max_debug
133 CALL cp_warn(__location__, &
134 "BSE_DEBUG_PRINT: the checks of the iterative solver against the explicit A "// &
135 "and B are skipped above N_ov = "//trim(n_ov_str)//".")
136 END IF
137
138 CALL create_matvec_env(mv_env, bse_env%fm_S_ia(1), bse_env%fm_S_ij(1), &
139 bse_env%fm_S_ab(1), bse_env%fm_S_bar_ia(1), &
140 bse_env%fm_S_bar_ij(1), eigenval_reduced, &
141 homo_red_arr(1), virt_red_arr(1), do_abba, bse_env, unit_nr)
142
143 IF (do_debug) THEN
144 CALL create_a_and_b(bse_env%fm_S_ia, bse_env%fm_S_ij, bse_env%fm_S_ab, &
145 bse_env%fm_S_bar_ia, bse_env%fm_S_bar_ij, fm_a_bse, fm_b_bse, &
146 do_abba, eigenval_reduced, unit_nr, homo_red_arr, virt_red_arr, dimen_ri, &
147 bse_env)
148 IF (do_abba) THEN
149 CALL bse_matvec_selfcheck(mv_env, fm_a_bse, unit_nr, fm_b_bse)
150 ELSE
151 CALL bse_matvec_selfcheck(mv_env, fm_a_bse, unit_nr)
152 END IF
153 END IF
154
155 ! the solver works on its RI-sliced copies; only the grid of the slabs is kept, for the eigenvectors
156 blacs_env_ia => bse_env%fm_S_ia(1)%matrix_struct%context
157 CALL blacs_env_ia%retain()
158 CALL cp_fm_release(bse_env%fm_S_ia(1))
159 CALL cp_fm_release(bse_env%fm_S_ij(1))
160 CALL cp_fm_release(bse_env%fm_S_ab(1))
161 CALL cp_fm_release(bse_env%fm_S_bar_ia(1))
162 CALL cp_fm_release(bse_env%fm_S_bar_ij(1))
163
164 IF (do_tda) THEN
165 CALL print_output_header(homo_red_arr(1), virt_red_arr(1), homo(1), .true., bse_env, unit_nr)
166 CALL bse_davidson_tda(mv_env, bse_env, unit_nr, exc_ens, fm_x)
167 IF (do_debug) CALL bse_davidson_refcheck(fm_a_bse, exc_ens, fm_x, bse_env, unit_nr)
168
169 CALL copy_to_ia_context(fm_x, blacs_env_ia, fm_x_ia)
170 CALL postprocess_bse(exc_ens, fm_x_ia, bse_env, mo_coeff, &
171 homo_red_arr(1), virt_red_arr(1), homo(1), unit_nr, .true.)
172 CALL cp_fm_release(fm_x_ia)
173 DEALLOCATE (exc_ens)
174 END IF
175
176 IF (do_abba) THEN
177 ! the TDA vectors are the initial guess of a combined run; a null pointer passed to the
178 ! optional argument counts as absent (Fortran 2008)
179 NULLIFY (fm_tda_guess)
180 IF (do_tda) fm_tda_guess => fm_x
181 CALL print_output_header(homo_red_arr(1), virt_red_arr(1), homo(1), .false., bse_env, unit_nr)
182 SELECT CASE (bse_env%abba_solver)
184 solver_str = 'MK_DAVIDSON'
185 CALL bse_davidson_abba_mk(mv_env, bse_env, unit_nr, exc_ens_abba, fm_x_abba, fm_y_abba, &
186 abba_status, ab_margin, fm_tda_guess)
188 solver_str = 'OLSEN_STRATMANN'
189 CALL bse_davidson_abba_os(mv_env, bse_env, unit_nr, exc_ens_abba, fm_x_abba, fm_y_abba, &
190 abba_status, ab_margin, fm_tda_guess)
191 CASE DEFAULT
192 cpabort("Unknown BSE_ITERAT%ABBA_SOLVER")
193 END SELECT
194 IF (abba_status == abba_indefinite) THEN
195 WRITE (margin_str, '(F16.6)') ab_margin*evolt
196 IF (.NOT. do_tda) THEN
197 CALL cp_abort(__location__, &
198 "Matrix (A-B) is not positive definite on the trial space of the "// &
199 trim(solver_str)//" solver (eigenvalue "//trim(adjustl(margin_str))//" eV). "// &
200 "The full ABBA problem is ill-defined for this reference.")
201 END IF
202 ! the TDA results of a combined run stand on their own
203 IF (unit_nr > 0) THEN
204 CALL cp_warn(__location__, &
205 "BSE: A-B is not positive definite on the trial space (margin "// &
206 trim(adjustl(margin_str))//" eV); the ABBA calculation is skipped, "// &
207 "TDA results above are complete.")
208 WRITE (unit_nr, '(T2,A4)') 'BSE|'
209 WRITE (unit_nr, '(T2,A4,T7,A,T67,F14.6)') 'BSE|', &
210 'A-B is not positive definite on the trial space (eV)', ab_margin*evolt
211 WRITE (unit_nr, '(T2,A4,T7,A)') 'BSE|', &
212 'The ABBA calculation is skipped, the TDA results above are complete'
213 END IF
214 ELSE
215 IF (do_debug) THEN
216 CALL bse_davidson_refcheck(fm_a_bse, exc_ens_abba, fm_x_abba, bse_env, unit_nr, &
217 fm_b_bse, fm_y_abba)
218 END IF
219
220 CALL copy_to_ia_context(fm_x_abba, blacs_env_ia, fm_x_ia)
221 CALL copy_to_ia_context(fm_y_abba, blacs_env_ia, fm_y_ia)
222 CALL cp_fm_release(fm_x_abba)
223 CALL cp_fm_release(fm_y_abba)
224 CALL postprocess_bse(exc_ens_abba, fm_x_ia, bse_env, mo_coeff, &
225 homo_red_arr(1), virt_red_arr(1), homo(1), unit_nr, .false., fm_y_ia)
226 CALL cp_fm_release(fm_x_ia)
227 CALL cp_fm_release(fm_y_ia)
228 DEALLOCATE (exc_ens_abba)
229 END IF
230 END IF
231
232 IF (do_tda) CALL cp_fm_release(fm_x)
233 IF (do_debug) THEN
234 CALL cp_fm_release(fm_a_bse)
235 IF (do_abba) CALL cp_fm_release(fm_b_bse)
236 END IF
237 CALL cp_blacs_env_release(blacs_env_ia)
238 CALL bse_matvec_release(mv_env)
239
240 CALL timestop(handle)
241
242 END SUBROUTINE solve_bse_iteratively
243
244! **************************************************************************************************
245!> \brief Copies eigenvectors from the process grid of the solver to the one of the RI slabs, from
246!> which postprocess_bse takes its grid
247!> \param fm_vec eigenvectors on the npe x 1 process grid of the solver
248!> \param blacs_env_ia process grid of the RI slabs
249!> \param fm_vec_ia the copy on blacs_env_ia, created here
250! **************************************************************************************************
251 SUBROUTINE copy_to_ia_context(fm_vec, blacs_env_ia, fm_vec_ia)
252
253 TYPE(cp_fm_type), INTENT(IN) :: fm_vec
254 TYPE(cp_blacs_env_type), POINTER :: blacs_env_ia
255 TYPE(cp_fm_type), INTENT(OUT) :: fm_vec_ia
256
257 INTEGER :: n_exc, n_ov
258 TYPE(cp_fm_struct_type), POINTER :: fm_struct
259
260 CALL cp_fm_get_info(fm_vec, nrow_global=n_ov, ncol_global=n_exc)
261 NULLIFY (fm_struct)
262 CALL cp_fm_struct_create(fm_struct, para_env=blacs_env_ia%para_env, context=blacs_env_ia, &
263 nrow_global=n_ov, ncol_global=n_exc)
264 CALL cp_fm_create(fm_vec_ia, fm_struct, name="fm_davidson_ia")
265 CALL cp_fm_struct_release(fm_struct)
266 CALL cp_fm_to_fm_submat_general(fm_vec, fm_vec_ia, n_ov, n_exc, 1, 1, 1, 1, blacs_env_ia)
267
268 END SUBROUTINE copy_to_ia_context
269
270! **************************************************************************************************
271!> \brief Sets up the matrix-free application of A and B with the prefactors and the screened
272!> slabs that create_A and create_B use for the chosen SPIN_CONFIG and SCREENING_IN_W:
273!> α = 2 (SINGLET) or 0 (TRIPLET); w = 1 with the W-screened \bar{B} (default screening),
274!> w = SCREENING_FACTOR with \bar{B} = B (ALPHA), w = 1 with \bar{B} = B (TDHF), w = 0 (RPA)
275!> \param mv_env the environment created here
276!> \param fm_S_ia B^P_ia, N_RI x homo_red*virt_red
277!> \param fm_S_ij B^P_ij, N_RI x homo_red^2
278!> \param fm_S_ab B^P_ab, N_RI x virt_red^2
279!> \param fm_S_bar_ia W-screened \bar{B}^P_ia
280!> \param fm_S_bar_ij W-screened \bar{B}^P_ij
281!> \param Eigenval_reduced energies of the homo_red + virt_red active levels in Hartree, QP or DFT per USE_KS_ENERGIES
282!> \param homo_red occupied levels in the active window
283!> \param virt_red virtual levels in the active window
284!> \param do_abba B is applied too, so the \bar{B}^P_ia slab is sliced as well
285!> \param bse_env SPIN_CONFIG, SCREENING_IN_W, SCREENING_FACTOR and MATVEC_BLOCK_COLUMNS
286!> \param unit_nr output unit, positive on the writing rank only
287! **************************************************************************************************
288 SUBROUTINE create_matvec_env(mv_env, fm_S_ia, fm_S_ij, fm_S_ab, fm_S_bar_ia, fm_S_bar_ij, &
289 Eigenval_reduced, homo_red, virt_red, do_abba, bse_env, unit_nr)
290
291 TYPE(bse_matvec_env_type), INTENT(OUT) :: mv_env
292 TYPE(cp_fm_type), INTENT(IN), TARGET :: fm_s_ia, fm_s_ij, fm_s_ab, fm_s_bar_ia, &
293 fm_s_bar_ij
294 REAL(kind=dp), DIMENSION(:), INTENT(IN) :: eigenval_reduced
295 INTEGER, INTENT(IN) :: homo_red, virt_red
296 LOGICAL, INTENT(IN) :: do_abba
297 TYPE(bse_env_type), INTENT(IN) :: bse_env
298 INTEGER, INTENT(IN) :: unit_nr
299
300 REAL(kind=dp) :: alpha, w_fac
301 TYPE(cp_fm_type), POINTER :: fm_w_ia, fm_w_ij
302
303 alpha = 0.0_dp
304 SELECT CASE (bse_env%bse_spin_config)
305 CASE (bse_singlet)
306 alpha = 2.0_dp
307 CASE (bse_triplet)
308 alpha = 0.0_dp
309 END SELECT
310
311 SELECT CASE (bse_env%screening_method)
313 w_fac = bse_env%screening_factor
314 CASE (bse_screening_rpa)
315 w_fac = 0.0_dp
316 CASE DEFAULT
317 w_fac = 1.0_dp
318 END SELECT
319
320 ! Only W0 needs screened slabs; RPA sets w_fac=0 and does not read either W slab.
321 IF (bse_env%screening_method /= bse_screening_w0) THEN
322 fm_w_ij => fm_s_ij
323 fm_w_ia => fm_s_ia
324 ELSE
325 fm_w_ij => fm_s_bar_ij
326 fm_w_ia => fm_s_bar_ia
327 END IF
328 CALL bse_matvec_create(mv_env, fm_s_ia, fm_w_ij, fm_s_ab, fm_w_ia, eigenval_reduced, &
329 homo_red, virt_red, alpha, w_fac, do_abba, unit_nr, &
330 block_cols=bse_env%matvec_block_columns, memory_per_proc_gb=bse_env%memory_per_proc_gb)
331
332 END SUBROUTINE create_matvec_env
333
334END MODULE bse_iterative
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_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 postprocess_bse(exc_ens, fm_eigvec_x, bse_env, mo_coeff, homo, virtual, homo_irred, unit_nr, flag_tda, fm_eigvec_y)
Prints the success message (incl. energies) for full diag of BSE (TDA/full ABBA via flag).
subroutine, public create_a_and_b(fm_s_ia, fm_s_ij, fm_s_ab, fm_s_bar_ia, fm_s_bar_ij, fm_a, fm_b, do_abba, eigenval, unit_nr, homo, virtual, dimen_ri, bse_env)
Explicit A, and B for ABBA, from the slabs the screening method contracts: the bare ones for TDHF and...
Iterative solution of the Bethe-Salpeter equation: the block Davidson solvers on top of the matrix-fr...
subroutine, public solve_bse_iteratively(eigenval_reduced, homo_red_arr, virt_red_arr, homo, dimen_ri, do_tda, do_abba, bse_env, mo_coeff, unit_nr)
Lowest excitations of a closed-shell reference from the block Davidson solvers on top of the matrix-f...
Matrix-free application of the BSE matrices A and B to trial vectors from RI slabs that are sliced al...
Definition bse_matvec.F:14
subroutine, public bse_matvec_create(mv_env, fm_s_ia, fm_s_bar_ij, fm_s_ab, fm_s_bar_ia, eps_reduced, homo, virt, alpha, w_fac, do_abba, unit_nr, block_cols, memory_per_proc_gb)
Moves the RI slabs onto an npe x 1 process grid, such that every rank owns whole RI slices,...
Definition bse_matvec.F:160
subroutine, public bse_matvec_release(mv_env)
Frees the sliced slabs, the transition energies and the process grid of mv_env.
Definition bse_matvec.F:327
subroutine, public bse_matvec_selfcheck(mv_env, fm_a_explicit, unit_nr, fm_b_explicit)
Debug check of the matrix-free application against the explicit matrices A (and B),...
Definition bse_matvec.F:753
Routines for printing information in context of the BSE calculation.
Definition bse_print.F:13
subroutine, public print_output_header(homo, virtual, homo_irred, flag_tda, bse_env, unit_nr)
Banner, defining equations and legend of one BSE problem, printed before it is solved.
Definition bse_print.F:100
The BSE environment: the settings of the &BSE section and the state a GW path prepares for the solver...
Definition bse_types.F:14
methods related to the blacs parallel environment
subroutine, public cp_blacs_env_release(blacs_env)
releases the given blacs_env
Defines control structures, which contain the parameters and the settings for the DFT-based calculati...
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
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_create(matrix, matrix_struct, name, nrow, ncol, set_zero)
creates a new full matrix with the given structure
collects all constants needed in input so that they can be used without circular dependencies
integer, parameter, public bse_singlet
integer, parameter, public bse_triplet
integer, parameter, public bse_screening_w0
integer, parameter, public bse_screening_alpha
integer, parameter, public bse_screening_rpa
integer, parameter, public bse_abba_mk_davidson
integer, parameter, public bse_abba_olsen_stratmann
Defines the basic variable types.
Definition kinds.F:23
integer, parameter, public dp
Definition kinds.F:34
Definition of physical constants:
Definition physcon.F:68
real(kind=dp), parameter, public evolt
Definition physcon.F:183
RI slabs of one spin channel, every rank holding n_ri_loc whole RI slices.
Definition bse_matvec.F:70
Settings of the &BSE section (read_bse_section, re-read before every BSE run, normalised in place by ...
Definition bse_types.F:44
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