(git:374b731)
Loading...
Searching...
No Matches
rt_make_propagators.F
Go to the documentation of this file.
1!--------------------------------------------------------------------------------------------------!
2! CP2K: A general program to perform molecular dynamics simulations !
3! Copyright 2000-2024 CP2K developers group <https://cp2k.org> !
4! !
5! SPDX-License-Identifier: GPL-2.0-or-later !
6!--------------------------------------------------------------------------------------------------!
7
8! **************************************************************************************************
9!> \brief Routines for calculating a complex matrix exponential.
10!> \author Florian Schiffmann (02.09)
11! **************************************************************************************************
12
13MODULE rt_make_propagators
14
15 USE cp_control_types, ONLY: rtp_control_type
16 USE cp_dbcsr_operations, ONLY: copy_dbcsr_to_fm,&
17 copy_fm_to_dbcsr,&
18 cp_dbcsr_sm_fm_multiply
19 USE cp_fm_types, ONLY: cp_fm_create,&
20 cp_fm_get_info,&
21 cp_fm_release,&
22 cp_fm_to_fm,&
23 cp_fm_type
24 USE dbcsr_api, ONLY: dbcsr_copy,&
25 dbcsr_create,&
26 dbcsr_deallocate_matrix,&
27 dbcsr_p_type,&
28 dbcsr_scale,&
29 dbcsr_type
30 USE input_constants, ONLY: do_etrs,&
31 do_pade,&
32 do_taylor
33 USE kinds, ONLY: dp
34 USE ls_matrix_exp, ONLY: bch_expansion_complex_propagator,&
35 bch_expansion_imaginary_propagator,&
36 cp_complex_dbcsr_gemm_3,&
37 taylor_full_complex_dbcsr,&
38 taylor_only_imaginary_dbcsr
39 USE matrix_exp, ONLY: arnoldi,&
40 exp_pade_full_complex,&
41 exp_pade_only_imaginary,&
42 taylor_full_complex,&
43 taylor_only_imaginary
44 USE rt_propagation_types, ONLY: get_rtp,&
45 rt_prop_type
46#include "../base/base_uses.f90"
47
48 IMPLICIT NONE
49
50 PRIVATE
51
52 CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'rt_make_propagators'
53
54 PUBLIC :: propagate_exp, &
55 propagate_arnoldi, &
56 compute_exponential, &
57 compute_exponential_sparse, &
58 propagate_exp_density, &
59 propagate_bch
60
61CONTAINS
62! **************************************************************************************************
63!> \brief performs propagations if explicit matrix exponentials are used
64!> ETRS: exp(i*H(t+dt)*dt/2)*exp(i*H(t)*dt/2)*MOS
65!> EM: exp[-idt/2H(t+dt/2)*MOS
66!> \param rtp ...
67!> \param rtp_control ...
68!> \author Florian Schiffmann (02.09)
69! **************************************************************************************************
70
71 SUBROUTINE propagate_exp(rtp, rtp_control)
72
73 TYPE(rt_prop_type), POINTER :: rtp
74 TYPE(rtp_control_type), POINTER :: rtp_control
75
76 CHARACTER(len=*), PARAMETER :: routinen = 'propagate_exp'
77 REAL(kind=dp), PARAMETER :: one = 1.0_dp, zero = 0.0_dp
78
79 INTEGER :: handle, i, im, nmo, re
80 TYPE(cp_fm_type), DIMENSION(:), POINTER :: mos_new, mos_next, mos_old
81 TYPE(dbcsr_p_type), DIMENSION(:), POINTER :: exp_h_new, exp_h_old, propagator_matrix
82
83 CALL timeset(routinen, handle)
84
85 CALL get_rtp(rtp=rtp, propagator_matrix=propagator_matrix, mos_old=mos_old, mos_new=mos_new, &
86 mos_next=mos_next, exp_h_new=exp_h_new, exp_h_old=exp_h_old)
87
88 ! Only compute exponential if a new propagator matrix is available
89 CALL compute_exponential(exp_h_new, propagator_matrix, rtp_control, rtp)
90
91 DO i = 1, SIZE(mos_new)/2
92 re = 2*i - 1
93 im = 2*i
94
95 CALL cp_fm_get_info(mos_new(re), ncol_global=nmo)
96 !Save some work by computing the first half of the propagation only once in case of ETRS
97 !For EM this matrix has to be the initial matrix, thus a copy is enough
98 IF (rtp%iter == 1) THEN
99 IF (rtp_control%propagator == do_etrs) THEN
100 CALL cp_dbcsr_sm_fm_multiply(exp_h_old(re)%matrix, mos_old(re), &
101 mos_next(re), nmo, alpha=one, beta=zero)
102 CALL cp_dbcsr_sm_fm_multiply(exp_h_old(im)%matrix, mos_old(im), &
103 mos_next(re), nmo, alpha=-one, beta=one)
104 CALL cp_dbcsr_sm_fm_multiply(exp_h_old(re)%matrix, mos_old(im), &
105 mos_next(im), nmo, alpha=one, beta=zero)
106 CALL cp_dbcsr_sm_fm_multiply(exp_h_old(im)%matrix, mos_old(re), &
107 mos_next(im), nmo, alpha=one, beta=one)
108 ELSE
109 CALL cp_fm_to_fm(mos_old(re), mos_next(re))
110 CALL cp_fm_to_fm(mos_old(im), mos_next(im))
111 END IF
112 END IF
113 CALL cp_dbcsr_sm_fm_multiply(exp_h_new(re)%matrix, mos_next(re), &
114 mos_new(re), nmo, alpha=one, beta=zero)
115 CALL cp_dbcsr_sm_fm_multiply(exp_h_new(im)%matrix, mos_next(im), &
116 mos_new(re), nmo, alpha=-one, beta=one)
117 CALL cp_dbcsr_sm_fm_multiply(exp_h_new(re)%matrix, mos_next(im), &
118 mos_new(im), nmo, alpha=one, beta=zero)
119 CALL cp_dbcsr_sm_fm_multiply(exp_h_new(im)%matrix, mos_next(re), &
120 mos_new(im), nmo, alpha=one, beta=one)
121 END DO
122
123 CALL timestop(handle)
124
125 END SUBROUTINE propagate_exp
126
127! **************************************************************************************************
128!> \brief Propagation of the density matrix instead of the atomic orbitals
129!> via a matrix exponential
130!> \param rtp ...
131!> \param rtp_control ...
132!> \author Samuel Andermatt (02.2014)
133! **************************************************************************************************
134
135 SUBROUTINE propagate_exp_density(rtp, rtp_control)
136
137 TYPE(rt_prop_type), POINTER :: rtp
138 TYPE(rtp_control_type), POINTER :: rtp_control
139
140 CHARACTER(len=*), PARAMETER :: routinen = 'propagate_exp_density'
141 REAL(kind=dp), PARAMETER :: one = 1.0_dp, zero = 0.0_dp
142
143 INTEGER :: handle, i, im, re
144 TYPE(dbcsr_p_type), DIMENSION(:), POINTER :: exp_h_new, exp_h_old, propagator_matrix, &
145 rho_new, rho_next, rho_old
146 TYPE(dbcsr_type), POINTER :: tmp_im, tmp_re
147
148 CALL timeset(routinen, handle)
149
150 CALL get_rtp(rtp=rtp, propagator_matrix=propagator_matrix, exp_h_new=exp_h_new, &
151 exp_h_old=exp_h_old, rho_old=rho_old, rho_new=rho_new, rho_next=rho_next)
152
153 CALL compute_exponential_sparse(exp_h_new, propagator_matrix, rtp_control, rtp)
154
155 !I could store these matrices in the type
156 NULLIFY (tmp_re)
157 ALLOCATE (tmp_re)
158 CALL dbcsr_create(tmp_re, template=propagator_matrix(1)%matrix, matrix_type="N")
159 NULLIFY (tmp_im)
160 ALLOCATE (tmp_im)
161 CALL dbcsr_create(tmp_im, template=propagator_matrix(1)%matrix, matrix_type="N")
162
163 DO i = 1, SIZE(exp_h_new)/2
164 re = 2*i - 1
165 im = 2*i
166 !Save some work by computing the first half of the propagation only once in case of ETRS
167 !For EM this matrix has to be the initial matrix, thus a copy is enough
168 IF (rtp%iter == 1) THEN
169 IF (rtp_control%propagator == do_etrs) THEN
170 CALL cp_complex_dbcsr_gemm_3("N", "N", one, exp_h_old(re)%matrix, exp_h_old(im)%matrix, &
171 rho_old(re)%matrix, rho_old(im)%matrix, zero, tmp_re, tmp_im, filter_eps=rtp%filter_eps)
172 CALL cp_complex_dbcsr_gemm_3("N", "C", one, tmp_re, tmp_im, exp_h_old(re)%matrix, exp_h_old(im)%matrix, &
173 zero, rho_next(re)%matrix, rho_next(im)%matrix, filter_eps=rtp%filter_eps)
174 ELSE
175 CALL dbcsr_copy(rho_next(re)%matrix, rho_old(re)%matrix)
176 CALL dbcsr_copy(rho_next(im)%matrix, rho_old(im)%matrix)
177 END IF
178 END IF
179 CALL cp_complex_dbcsr_gemm_3("N", "N", one, exp_h_new(re)%matrix, exp_h_new(im)%matrix, &
180 rho_next(re)%matrix, rho_next(im)%matrix, zero, tmp_re, tmp_im, filter_eps=rtp%filter_eps)
181 CALL cp_complex_dbcsr_gemm_3("N", "C", one, tmp_re, tmp_im, exp_h_new(re)%matrix, exp_h_new(im)%matrix, &
182 zero, rho_new(re)%matrix, rho_new(im)%matrix, filter_eps=rtp%filter_eps)
183 END DO
184
185 CALL dbcsr_deallocate_matrix(tmp_re)
186 CALL dbcsr_deallocate_matrix(tmp_im)
187
188 CALL timestop(handle)
189
190 END SUBROUTINE propagate_exp_density
191
192! **************************************************************************************************
193!> \brief computes U_prop*MOs using arnoldi subspace algorithm
194!> \param rtp ...
195!> \param rtp_control ...
196!> \author Florian Schiffmann (02.09)
197! **************************************************************************************************
198
199 SUBROUTINE propagate_arnoldi(rtp, rtp_control)
200 TYPE(rt_prop_type), POINTER :: rtp
201 TYPE(rtp_control_type), POINTER :: rtp_control
202
203 CHARACTER(len=*), PARAMETER :: routinen = 'propagate_arnoldi'
204
205 INTEGER :: handle, i, im, ispin, nspin, re
206 REAL(dp) :: eps_arnoldi, t
207 TYPE(cp_fm_type), ALLOCATABLE, DIMENSION(:) :: propagator_matrix_fm
208 TYPE(cp_fm_type), DIMENSION(:), POINTER :: mos_new, mos_next, mos_old
209 TYPE(dbcsr_p_type), DIMENSION(:), POINTER :: propagator_matrix
210
211 CALL timeset(routinen, handle)
212
213 CALL get_rtp(rtp=rtp, dt=t, mos_new=mos_new, mos_old=mos_old, &
214 mos_next=mos_next, propagator_matrix=propagator_matrix)
215
216 nspin = SIZE(mos_new)/2
217 eps_arnoldi = rtp_control%eps_exp
218 ! except for the first step the further propagated mos_next
219 ! must be copied on mos_old so that we have the half propagated mos
220 ! ready on mos_old and only need to perform the second half propagatioon
221 IF (rtp_control%propagator == do_etrs .AND. rtp%iter == 1) THEN
222 DO i = 1, SIZE(mos_new)
223 CALL cp_fm_to_fm(mos_next(i), mos_old(i))
224 END DO
225 END IF
226
227 ALLOCATE (propagator_matrix_fm(SIZE(propagator_matrix)))
228 DO i = 1, SIZE(propagator_matrix)
229 CALL cp_fm_create(propagator_matrix_fm(i), &
230 matrix_struct=rtp%ao_ao_fmstruct, &
231 name="prop_fm")
232 CALL copy_dbcsr_to_fm(propagator_matrix(i)%matrix, propagator_matrix_fm(i))
233 END DO
234
235 DO ispin = 1, nspin
236 re = ispin*2 - 1
237 im = ispin*2
238 IF (rtp_control%fixed_ions .AND. .NOT. rtp%propagate_complex_ks) THEN
239 CALL arnoldi(mos_old(re:im), mos_new(re:im), &
240 eps_arnoldi, him=propagator_matrix_fm(im), &
241 mos_next=mos_next(re:im), narn_old=rtp%narn_old)
242 ELSE
243 CALL arnoldi(mos_old(re:im), mos_new(re:im), &
244 eps_arnoldi, hre=propagator_matrix_fm(re), &
245 him=propagator_matrix_fm(im), mos_next=mos_next(re:im), &
246 narn_old=rtp%narn_old)
247 END IF
248 END DO
249
250! DO i=1,SIZE(propagator_matrix)
251! CALL copy_fm_to_dbcsr(propagator_matrix_fm(i), propagator_matrix(i)%matrix)
252! END DO
253 CALL cp_fm_release(propagator_matrix_fm)
254
255 CALL timestop(handle)
256
257 END SUBROUTINE propagate_arnoldi
258
259! **************************************************************************************************
260!> \brief Propagation using the Baker-Campbell-Hausdorff expansion,
261!> currently only works for rtp
262!> \param rtp ...
263!> \param rtp_control ...
264!> \author Samuel Andermatt (02.2014)
265! **************************************************************************************************
266
267 SUBROUTINE propagate_bch(rtp, rtp_control)
268
269 TYPE(rt_prop_type), POINTER :: rtp
270 TYPE(rtp_control_type), POINTER :: rtp_control
271
272 CHARACTER(len=*), PARAMETER :: routinen = 'propagate_bch'
273
274 INTEGER :: handle, im, ispin, re
275 REAL(dp) :: dt
276 REAL(kind=dp) :: prefac
277 TYPE(dbcsr_p_type), DIMENSION(:), POINTER :: exp_h_old, propagator_matrix, rho_new, &
278 rho_next, rho_old
279
280 CALL timeset(routinen, handle)
281
282 CALL get_rtp(rtp=rtp, propagator_matrix=propagator_matrix, rho_old=rho_old, rho_new=rho_new, &
283 rho_next=rho_next)
284
285 DO ispin = 1, SIZE(propagator_matrix)/2
286 re = 2*ispin - 1
287 im = 2*ispin
288
289 IF (rtp%iter == 1) THEN
290 ! For EM I have to copy rho_old onto rho_next and for ETRS,
291 ! this is the first term of the series of commutators that result in rho_next
292 CALL dbcsr_copy(rho_next(re)%matrix, rho_old(re)%matrix)
293 CALL dbcsr_copy(rho_next(im)%matrix, rho_old(im)%matrix)
294 IF (rtp_control%propagator == do_etrs) THEN
295 !since we never calculated the matrix exponential the old matrix exponential stores the unscalled propagator
296 CALL get_rtp(rtp=rtp, exp_h_old=exp_h_old, dt=dt)
297 prefac = -0.5_dp*dt
298 CALL dbcsr_scale(exp_h_old(im)%matrix, prefac)
299 IF (rtp_control%fixed_ions .AND. .NOT. rtp%propagate_complex_ks) THEN
300 CALL bch_expansion_imaginary_propagator( &
301 exp_h_old(im)%matrix, rho_next(re)%matrix, rho_next(im)%matrix, &
302 rtp%filter_eps, rtp%filter_eps_small, rtp_control%eps_exp)
303 ELSE
304 CALL dbcsr_scale(exp_h_old(re)%matrix, prefac)
305 CALL bch_expansion_complex_propagator( &
306 exp_h_old(re)%matrix, exp_h_old(im)%matrix, rho_next(re)%matrix, rho_next(im)%matrix, &
307 rtp%filter_eps, rtp%filter_eps_small, rtp_control%eps_exp)
308 END IF
309 END IF
310 END IF
311 CALL dbcsr_copy(rho_new(re)%matrix, rho_next(re)%matrix)
312 CALL dbcsr_copy(rho_new(im)%matrix, rho_next(im)%matrix)
313 IF (rtp_control%fixed_ions .AND. .NOT. rtp%propagate_complex_ks) THEN
314 CALL bch_expansion_imaginary_propagator( &
315 propagator_matrix(im)%matrix, rho_new(re)%matrix, rho_new(im)%matrix, &
316 rtp%filter_eps, rtp%filter_eps_small, rtp_control%eps_exp)
317 ELSE
318 CALL bch_expansion_complex_propagator( &
319 propagator_matrix(re)%matrix, propagator_matrix(im)%matrix, rho_new(re)%matrix, rho_new(im)%matrix, &
320 rtp%filter_eps, rtp%filter_eps_small, rtp_control%eps_exp)
321 END IF
322
323 END DO
324
325 CALL timestop(handle)
326
327 END SUBROUTINE propagate_bch
328
329! **************************************************************************************************
330!> \brief decides which type of exponential has to be computed
331!> \param propagator ...
332!> \param propagator_matrix ...
333!> \param rtp_control ...
334!> \param rtp ...
335!> \author Florian Schiffmann (02.09)
336! **************************************************************************************************
337
338 SUBROUTINE compute_exponential(propagator, propagator_matrix, rtp_control, rtp)
339 TYPE(dbcsr_p_type), DIMENSION(:), POINTER :: propagator, propagator_matrix
340 TYPE(rtp_control_type), POINTER :: rtp_control
341 TYPE(rt_prop_type), POINTER :: rtp
342
343 INTEGER :: i, im, ispin, re
344 TYPE(cp_fm_type), ALLOCATABLE, DIMENSION(:) :: propagator_fm, propagator_matrix_fm
345
346 ALLOCATE (propagator_fm(SIZE(propagator)))
347 ALLOCATE (propagator_matrix_fm(SIZE(propagator_matrix)))
348 DO i = 1, SIZE(propagator)
349 CALL cp_fm_create(propagator_fm(i), &
350 matrix_struct=rtp%ao_ao_fmstruct, &
351 name="prop_fm")
352 CALL copy_dbcsr_to_fm(propagator(i)%matrix, propagator_fm(i))
353 CALL cp_fm_create(propagator_matrix_fm(i), &
354 matrix_struct=rtp%ao_ao_fmstruct, &
355 name="prop_mat_fm")
356 CALL copy_dbcsr_to_fm(propagator_matrix(i)%matrix, propagator_matrix_fm(i))
357 END DO
358
359 DO ispin = 1, SIZE(propagator)/2
360 re = 2*ispin - 1
361 im = 2*ispin
362
363 SELECT CASE (rtp_control%mat_exp)
364
365 CASE (do_taylor)
366 IF (rtp_control%fixed_ions .AND. .NOT. rtp%propagate_complex_ks) THEN
367 CALL taylor_only_imaginary(propagator_fm(re:im), propagator_matrix_fm(im), &
368 rtp%orders(1, ispin), rtp%orders(2, ispin))
369 ELSE
370 CALL taylor_full_complex(propagator_fm(re:im), propagator_matrix_fm(re), propagator_matrix_fm(im), &
371 rtp%orders(1, ispin), rtp%orders(2, ispin))
372 END IF
373 CASE (do_pade)
374 IF (rtp_control%fixed_ions .AND. .NOT. rtp%propagate_complex_ks) THEN
375 CALL exp_pade_only_imaginary(propagator_fm(re:im), propagator_matrix_fm(im), &
376 rtp%orders(1, ispin), rtp%orders(2, ispin))
377 ELSE
378 CALL exp_pade_full_complex(propagator_fm(re:im), propagator_matrix_fm(re), propagator_matrix_fm(im), &
379 rtp%orders(1, ispin), rtp%orders(2, ispin))
380 END IF
381 END SELECT
382 END DO
383
384 DO i = 1, SIZE(propagator)
385 CALL copy_fm_to_dbcsr(propagator_fm(i), propagator(i)%matrix)
386 CALL copy_fm_to_dbcsr(propagator_matrix_fm(i), propagator_matrix(i)%matrix)
387 END DO
388 CALL cp_fm_release(propagator_fm)
389 CALL cp_fm_release(propagator_matrix_fm)
390
391 END SUBROUTINE compute_exponential
392
393! **************************************************************************************************
394!> \brief Sparse versions of the matrix exponentials
395!> \param propagator ...
396!> \param propagator_matrix ...
397!> \param rtp_control ...
398!> \param rtp ...
399!> \author Samuel Andermatt (02.14)
400! **************************************************************************************************
401
402 SUBROUTINE compute_exponential_sparse(propagator, propagator_matrix, rtp_control, rtp)
403 TYPE(dbcsr_p_type), DIMENSION(:), POINTER :: propagator, propagator_matrix
404 TYPE(rtp_control_type), POINTER :: rtp_control
405 TYPE(rt_prop_type), POINTER :: rtp
406
407 CHARACTER(len=*), PARAMETER :: routinen = 'compute_exponential_sparse'
408
409 INTEGER :: handle, im, ispin, re
410
411 CALL timeset(routinen, handle)
412
413 DO ispin = 1, SIZE(propagator)/2
414 re = 2*ispin - 1
415 im = 2*ispin
416 IF (rtp_control%fixed_ions .AND. .NOT. rtp%propagate_complex_ks) THEN
417 CALL taylor_only_imaginary_dbcsr(propagator(re:im), propagator_matrix(im)%matrix, &
418 rtp%orders(1, ispin), rtp%orders(2, ispin), rtp%filter_eps)
419 ELSE
420 CALL taylor_full_complex_dbcsr(propagator(re:im), propagator_matrix(re)%matrix, propagator_matrix(im)%matrix, &
421 rtp%orders(1, ispin), rtp%orders(2, ispin), rtp%filter_eps)
422 END IF
423 END DO
424
425 CALL timestop(handle)
426
427 END SUBROUTINE compute_exponential_sparse
428
429END MODULE rt_make_propagators
cp_fm_types::cp_fm_release
Definition cp_fm_types.F:90
cp_fm_types::cp_fm_to_fm
Definition cp_fm_types.F:85
cp_control_types
Defines control structures, which contain the parameters and the settings for the DFT-based calculati...
Definition cp_control_types.F:12
cp_dbcsr_operations
DBCSR operations in CP2K.
Definition cp_dbcsr_operations.F:18
cp_dbcsr_operations::cp_dbcsr_sm_fm_multiply
subroutine, public cp_dbcsr_sm_fm_multiply(matrix, fm_in, fm_out, ncol, alpha, beta)
multiply a dbcsr with a fm matrix
Definition cp_dbcsr_operations.F:744
cp_dbcsr_operations::copy_dbcsr_to_fm
subroutine, public copy_dbcsr_to_fm(matrix, fm)
Copy a DBCSR matrix to a BLACS matrix.
Definition cp_dbcsr_operations.F:208
cp_dbcsr_operations::copy_fm_to_dbcsr
subroutine, public copy_fm_to_dbcsr(fm, matrix, keep_sparsity)
Copy a BLACS matrix to a dbcsr matrix.
Definition cp_dbcsr_operations.F:118
cp_fm_types
represent a full matrix distributed on many processors
Definition cp_fm_types.F:15
cp_fm_types::cp_fm_get_info
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
Definition cp_fm_types.F:1016
cp_fm_types::cp_fm_create
subroutine, public cp_fm_create(matrix, matrix_struct, name, use_sp)
creates a new full matrix with the given structure
Definition cp_fm_types.F:167
input_constants
collects all constants needed in input so that they can be used without circular dependencies
Definition input_constants.F:17
input_constants::do_etrs
integer, parameter, public do_etrs
Definition input_constants.F:923
input_constants::do_pade
integer, parameter, public do_pade
Definition input_constants.F:918
input_constants::do_taylor
integer, parameter, public do_taylor
Definition input_constants.F:918
kinds
Defines the basic variable types.
Definition kinds.F:23
kinds::dp
integer, parameter, public dp
Definition kinds.F:34
ls_matrix_exp
Routines for calculating a complex matrix exponential with dbcsr matrices. Based on the code in matri...
Definition ls_matrix_exp.F:14
ls_matrix_exp::taylor_only_imaginary_dbcsr
subroutine, public taylor_only_imaginary_dbcsr(exp_h, im_matrix, nsquare, ntaylor, filter_eps)
specialized subroutine for purely imaginary matrix exponentials
Definition ls_matrix_exp.F:163
ls_matrix_exp::bch_expansion_imaginary_propagator
subroutine, public bch_expansion_imaginary_propagator(propagator, density_re, density_im, filter_eps, filter_eps_small, eps_exp)
The Baker-Campbell-Hausdorff expansion for a purely imaginary exponent (e.g. rtp) Works for a non uni...
Definition ls_matrix_exp.F:349
ls_matrix_exp::taylor_full_complex_dbcsr
subroutine, public taylor_full_complex_dbcsr(exp_h, re_part, im_part, nsquare, ntaylor, filter_eps)
subroutine for general complex matrix exponentials on input a separate dbcsr_type for real and comple...
Definition ls_matrix_exp.F:258
ls_matrix_exp::cp_complex_dbcsr_gemm_3
subroutine, public cp_complex_dbcsr_gemm_3(transa, transb, alpha, a_re, a_im, b_re, b_im, beta, c_re, c_im, filter_eps)
Convenience function. Computes the matrix multiplications needed for the multiplication of complex sp...
Definition ls_matrix_exp.F:65
ls_matrix_exp::bch_expansion_complex_propagator
subroutine, public bch_expansion_complex_propagator(propagator_re, propagator_im, density_re, density_im, filter_eps, filter_eps_small, eps_exp)
The Baker-Campbell-Hausdorff expansion for a complex exponent (e.g. rtp) Works for a non unitary prop...
Definition ls_matrix_exp.F:439
matrix_exp
Routines for calculating a complex matrix exponential.
Definition matrix_exp.F:13
matrix_exp::taylor_full_complex
subroutine, public taylor_full_complex(exp_h, re_part, im_part, nsquare, ntaylor)
subroutine for general complex matrix exponentials on input a separate cp_fm_type for real and comple...
Definition matrix_exp.F:165
matrix_exp::arnoldi
subroutine, public arnoldi(mos_old, mos_new, eps_exp, hre, him, mos_next, narn_old)
exponential of a complex matrix, calculated using arnoldi subspace method (directly applies to the MO...
Definition matrix_exp.F:683
matrix_exp::exp_pade_only_imaginary
subroutine, public exp_pade_only_imaginary(exp_h, im_part, nsquare, npade)
exponential of a complex matrix, calculated using pade approximation together with scaling and squari...
Definition matrix_exp.F:447
matrix_exp::taylor_only_imaginary
subroutine, public taylor_only_imaginary(exp_h, im_matrix, nsquare, ntaylor)
specialized subroutine for purely imaginary matrix exponentials
Definition matrix_exp.F:69
matrix_exp::exp_pade_full_complex
subroutine, public exp_pade_full_complex(exp_h, re_part, im_part, nsquare, npade)
exponential of a complex matrix, calculated using pade approximation together with scaling and squari...
Definition matrix_exp.F:342
rt_make_propagators
Routines for calculating a complex matrix exponential.
Definition rt_make_propagators.F:13
rt_make_propagators::propagate_exp
subroutine, public propagate_exp(rtp, rtp_control)
performs propagations if explicit matrix exponentials are used ETRS: exp(i*H(t+dt)*dt/2)*exp(i*H(t)*d...
Definition rt_make_propagators.F:72
rt_make_propagators::compute_exponential_sparse
subroutine, public compute_exponential_sparse(propagator, propagator_matrix, rtp_control, rtp)
Sparse versions of the matrix exponentials.
Definition rt_make_propagators.F:403
rt_make_propagators::propagate_bch
subroutine, public propagate_bch(rtp, rtp_control)
Propagation using the Baker-Campbell-Hausdorff expansion, currently only works for rtp.
Definition rt_make_propagators.F:268
rt_make_propagators::compute_exponential
subroutine, public compute_exponential(propagator, propagator_matrix, rtp_control, rtp)
decides which type of exponential has to be computed
Definition rt_make_propagators.F:339
rt_make_propagators::propagate_exp_density
subroutine, public propagate_exp_density(rtp, rtp_control)
Propagation of the density matrix instead of the atomic orbitals via a matrix exponential.
Definition rt_make_propagators.F:136
rt_make_propagators::propagate_arnoldi
subroutine, public propagate_arnoldi(rtp, rtp_control)
computes U_prop*MOs using arnoldi subspace algorithm
Definition rt_make_propagators.F:200
rt_propagation_types
Types and set_get for real time propagation depending on runtype and diagonalization method different...
Definition rt_propagation_types.F:21
rt_propagation_types::get_rtp
subroutine, public get_rtp(rtp, exp_h_old, exp_h_new, h_last_iter, rho_old, rho_next, rho_new, mos, mos_new, mos_old, mos_next, s_inv, s_half, s_minus_half, b_mat, c_mat, propagator_matrix, mixing, mixing_factor, s_der, dt, nsteps, sinvh, sinvh_imag, sinvb, admm_mos)
...
Definition rt_propagation_types.F:408
cp_control_types::rtp_control_type
Definition cp_control_types.F:65
cp_fm_types::cp_fm_type
represent a full matrix
Definition cp_fm_types.F:116
rt_propagation_types::rt_prop_type
Definition rt_propagation_types.F:76