(git:34ef472)
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 
13 MODULE 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 
61 CONTAINS
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 
429 END MODULE rt_make_propagators
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::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_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::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::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
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
matrix_exp
Routines for calculating a complex matrix exponential.
Definition: matrix_exp.F:13
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::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::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
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
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