42 USE dbcsr_api,
ONLY: &
43 dbcsr_add_on_diag, dbcsr_create, dbcsr_distribution_type, dbcsr_filter, dbcsr_finalize, &
44 dbcsr_get_block_p, dbcsr_iterator_blocks_left, dbcsr_iterator_next_block, &
45 dbcsr_iterator_start, dbcsr_iterator_stop, dbcsr_iterator_type, dbcsr_p_type, &
46 dbcsr_release, dbcsr_set, dbcsr_type, dbcsr_type_antisymmetric, dbcsr_type_no_symmetry, &
51 ewald_environment_type,&
72 neighbor_list_iterator_p_type,&
74 neighbor_list_set_p_type
81 #include "./base/base_uses.f90"
87 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'qs_tddfpt2_stda_utils'
104 TYPE(qs_environment_type),
POINTER :: qs_env
105 TYPE(stda_env_type) :: stda_kernel
106 TYPE(tddfpt_subgroup_env_type),
INTENT(in) :: sub_env
107 TYPE(tddfpt_work_matrices) :: work
108 TYPE(tddfpt2_control_type),
POINTER :: tddfpt_control
110 CHARACTER(len=*),
PARAMETER :: routinen =
'stda_init_matrices'
113 LOGICAL :: do_coulomb
114 TYPE(cell_type),
POINTER :: cell, cell_ref
115 TYPE(ewald_environment_type),
POINTER :: ewald_env
116 TYPE(ewald_pw_type),
POINTER :: ewald_pw
117 TYPE(section_vals_type),
POINTER :: ewald_section, poisson_section, &
120 CALL timeset(routinen, handle)
122 do_coulomb = .NOT. tddfpt_control%rks_triplets
125 CALL setup_gamma(qs_env, stda_kernel, sub_env, work%gamma_exchange)
132 IF (tddfpt_control%stda_control%do_ewald)
THEN
133 NULLIFY (ewald_env, ewald_pw)
137 CALL ewald_env_set(ewald_env, poisson_section=poisson_section)
140 CALL get_qs_env(qs_env, cell=cell, cell_ref=cell_ref)
143 CALL ewald_pw_create(ewald_pw, ewald_env, cell, cell_ref, print_section=print_section)
144 work%ewald_env => ewald_env
145 work%ewald_pw => ewald_pw
148 CALL timestop(handle)
160 SUBROUTINE setup_gamma(qs_env, stda_env, sub_env, gamma_matrix, ndim)
162 TYPE(qs_environment_type),
POINTER :: qs_env
163 TYPE(stda_env_type) :: stda_env
164 TYPE(tddfpt_subgroup_env_type),
INTENT(in) :: sub_env
165 TYPE(dbcsr_p_type),
DIMENSION(:),
POINTER :: gamma_matrix
166 INTEGER,
INTENT(IN),
OPTIONAL :: ndim
168 CHARACTER(len=*),
PARAMETER :: routinen =
'setup_gamma'
169 REAL(kind=
dp),
PARAMETER :: rsmooth = 1.0_dp
171 INTEGER :: handle, i, iatom, icol, ikind, imat, &
172 irow, jatom, jkind, natom, nmat
173 INTEGER,
DIMENSION(:),
POINTER :: row_blk_sizes
175 REAL(kind=
dp) :: dfcut, dgb, dr, eta, fcut, r, rcut, &
177 REAL(kind=
dp),
DIMENSION(3) :: rij
178 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: dgblock, gblock
179 TYPE(dbcsr_distribution_type),
POINTER :: dbcsr_dist
180 TYPE(neighbor_list_iterator_p_type), &
181 DIMENSION(:),
POINTER :: nl_iterator
182 TYPE(neighbor_list_set_p_type),
DIMENSION(:), &
185 CALL timeset(routinen, handle)
188 dbcsr_dist => sub_env%dbcsr_dist
191 n_list => sub_env%sab_orb
193 IF (
PRESENT(ndim))
THEN
198 cpassert(nmat == 1 .OR. nmat == 4)
199 cpassert(.NOT.
ASSOCIATED(gamma_matrix))
202 ALLOCATE (row_blk_sizes(natom))
203 row_blk_sizes(1:natom) = 1
205 ALLOCATE (gamma_matrix(imat)%matrix)
208 CALL dbcsr_create(gamma_matrix(1)%matrix, name=
"gamma", dist=dbcsr_dist, &
209 matrix_type=dbcsr_type_symmetric, row_blk_size=row_blk_sizes, &
210 col_blk_size=row_blk_sizes, nze=0)
212 CALL dbcsr_create(gamma_matrix(imat)%matrix, name=
"dgamma", dist=dbcsr_dist, &
213 matrix_type=dbcsr_type_antisymmetric, row_blk_size=row_blk_sizes, &
214 col_blk_size=row_blk_sizes, nze=0)
217 DEALLOCATE (row_blk_sizes)
222 CALL dbcsr_set(gamma_matrix(imat)%matrix, 0.0_dp)
225 NULLIFY (nl_iterator)
229 iatom=iatom, jatom=jatom, r=rij)
231 dr = sqrt(sum(rij(:)**2))
233 eta = (stda_env%kind_param_set(ikind)%kind_param%hardness_param + &
234 stda_env%kind_param_set(jkind)%kind_param%hardness_param)/2.0_dp
236 icol = max(iatom, jatom)
237 irow = min(iatom, jatom)
240 CALL dbcsr_get_block_p(matrix=gamma_matrix(1)%matrix, &
241 row=irow, col=icol, block=gblock, found=found)
245 rcuta = stda_env%kind_param_set(ikind)%kind_param%rcut
246 rcutb = stda_env%kind_param_set(jkind)%kind_param%rcut
253 gblock(:, :) = gblock(:, :) + eta
254 ELSEIF (dr > rcut)
THEN
257 IF (dr < rcut - rsmooth)
THEN
260 r = dr - (rcut - rsmooth)
262 fcut = -6._dp*x**5 + 15._dp*x**4 - 10._dp*x**3 + 1._dp
264 gblock(:, :) = gblock(:, :) + &
265 fcut*(1._dp/(dr**(stda_env%alpha_param) + eta**(-stda_env%alpha_param))) &
266 **(1._dp/stda_env%alpha_param) - fcut/dr
273 IF (dr < 1.e-6 .OR. dr > rcut)
THEN
277 IF (dr < rcut - rsmooth)
THEN
281 r = dr - (rcut - rsmooth)
283 fcut = -6._dp*x**5 + 15._dp*x**4 - 10._dp*x**3 + 1._dp
284 dfcut = -30._dp*x**4 + 60._dp*x**3 - 30._dp*x**2
285 dfcut = dfcut/rsmooth
287 dgb = dfcut*(1._dp/(dr**(stda_env%alpha_param) + eta**(-stda_env%alpha_param))) &
288 **(1._dp/stda_env%alpha_param)
289 dgb = dgb - dfcut/dr + fcut/dr**2
290 dgb = dgb - fcut*(1._dp/(dr**(stda_env%alpha_param) + eta**(-stda_env%alpha_param))) &
291 **(1._dp/stda_env%alpha_param + 1._dp)*dr**(stda_env%alpha_param - 1._dp)
295 CALL dbcsr_get_block_p(matrix=gamma_matrix(imat)%matrix, &
296 row=irow, col=icol, block=dgblock, found=found)
300 IF (irow == iatom)
THEN
301 dgblock(:, :) = dgblock(:, :) + dgb*rij(i)/dr
303 dgblock(:, :) = dgblock(:, :) - dgb*rij(i)/dr
315 CALL dbcsr_finalize(gamma_matrix(imat)%matrix)
318 CALL timestop(handle)
330 TYPE(qs_environment_type),
POINTER :: qs_env
331 TYPE(tddfpt_subgroup_env_type),
INTENT(in) :: sub_env
332 TYPE(tddfpt_work_matrices) :: work
334 CHARACTER(len=*),
PARAMETER :: routinen =
'get_lowdin_mo_coefficients'
336 INTEGER :: handle, i, iounit, ispin, j, &
337 max_iter_lanczos, nactive, ndep, nsgf, &
338 nspins, order_lanczos
340 REAL(kind=
dp) :: eps_lanczos, sij, threshold
341 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: slam
342 REAL(kind=
dp),
CONTIGUOUS,
DIMENSION(:, :), &
343 POINTER :: local_data
344 TYPE(cp_fm_struct_type),
POINTER :: fmstruct
345 TYPE(cp_fm_type) :: fm_s_half, fm_work1
346 TYPE(cp_logger_type),
POINTER :: logger
347 TYPE(dbcsr_p_type),
DIMENSION(:, :),
POINTER :: matrixkp_s
348 TYPE(dbcsr_type) :: sm_hinv
349 TYPE(dbcsr_type),
POINTER :: sm_h, sm_s
350 TYPE(qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
351 TYPE(scf_control_type),
POINTER :: scf_control
353 CALL timeset(routinen, handle)
361 WRITE (iounit,
"(1X,A)")
"", &
362 "-------------------------------------------------------------------------------", &
363 "- Create Matrix SQRT(S) -", &
364 "-------------------------------------------------------------------------------"
367 IF (sub_env%is_split)
THEN
370 CALL get_qs_env(qs_env=qs_env, matrix_s_kp=matrixkp_s)
371 cpassert(
ASSOCIATED(matrixkp_s))
372 IF (
SIZE(matrixkp_s, 2) > 1) cpwarn(
"not implemented for k-points.")
373 sm_s => matrixkp_s(1, 1)%matrix
377 CALL dbcsr_create(sm_hinv, template=sm_s)
378 CALL dbcsr_add_on_diag(sm_h, 1.0_dp)
379 threshold = 1.0e-8_dp
381 eps_lanczos = 1.0e-4_dp
382 max_iter_lanczos = 40
384 threshold, order_lanczos, eps_lanczos, max_iter_lanczos, &
386 CALL dbcsr_release(sm_hinv)
388 NULLIFY (qs_kind_set)
389 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
393 IF (.NOT. converged)
THEN
395 WRITE (iounit,
"(T3,A)")
"STDA| Newton-Schulz iteration did not converge"
396 WRITE (iounit,
"(T3,A)")
"STDA| Calculate SQRT(S) from diagonalization"
398 CALL get_qs_env(qs_env=qs_env, scf_control=scf_control)
401 para_env=sub_env%para_env, &
402 context=sub_env%blacs_env, &
405 CALL cp_fm_create(matrix=fm_s_half, matrix_struct=fmstruct, name=
"S^(1/2) MATRIX")
406 CALL cp_fm_create(matrix=fm_work1, matrix_struct=fmstruct, name=
"TMP MATRIX")
409 CALL cp_fm_power(fm_s_half, fm_work1, 0.5_dp, scf_control%eps_eigval, ndep)
411 CALL cp_warn(__location__, &
412 "Overlap matrix exhibits linear dependencies. At least some "// &
413 "eigenvalues have been quenched.")
415 CALL cp_fm_release(fm_s_half)
416 CALL cp_fm_release(fm_work1)
417 IF (iounit > 0)
WRITE (iounit, *)
420 nspins =
SIZE(sub_env%mos_occ)
423 CALL cp_fm_get_info(work%ctransformed(ispin), ncol_global=nactive)
425 work%ctransformed(ispin), nactive, alpha=1.0_dp, beta=0.0_dp)
429 CALL cp_fm_create(matrix=fm_work1, matrix_struct=work%S_eigenvectors%matrix_struct, name=
"TMP MATRIX")
432 CALL cp_fm_release(fm_work1)
434 ALLOCATE (slam(nsgf, 1))
436 IF (work%S_eigenvalues(i) > 0._dp)
THEN
437 slam(i, 1) = sqrt(work%S_eigenvalues(i))
439 cpabort(
"S matrix not positive definit")
449 DO i = 1,
SIZE(local_data, 2)
450 DO j = 1,
SIZE(local_data, 1)
451 sij = local_data(j, i)
452 IF (sij > 0.0_dp) sij = 1.0_dp/sij
453 local_data(j, i) = sij
458 CALL timestop(handle)
471 TYPE(dbcsr_type) :: shalf
472 TYPE(cp_fm_type),
DIMENSION(:),
INTENT(IN) :: xvec, xt
474 CHARACTER(len=*),
PARAMETER :: routinen =
'get_lowdin_x'
476 INTEGER :: handle, ispin, nactive, nspins
478 CALL timeset(routinen, handle)
486 xt(ispin), nactive, alpha=1.0_dp, beta=0.0_dp)
489 CALL timestop(handle)
507 work, is_rks_triplets, X, res)
509 TYPE(qs_environment_type),
POINTER :: qs_env
510 TYPE(stda_control_type) :: stda_control
511 TYPE(stda_env_type) :: stda_env
512 TYPE(tddfpt_subgroup_env_type) :: sub_env
513 TYPE(tddfpt_work_matrices) :: work
514 LOGICAL,
INTENT(IN) :: is_rks_triplets
515 TYPE(cp_fm_type),
DIMENSION(:),
INTENT(IN) :: x, res
517 CHARACTER(len=*),
PARAMETER :: routinen =
'stda_calculate_kernel'
519 INTEGER :: blk, ewald_type, handle, ia, iatom, &
520 ikind, is, ispin, jatom, jkind, jspin, &
522 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: first_sgf, kind_of, last_sgf
523 INTEGER,
DIMENSION(2) :: nactive, nlim
524 LOGICAL :: calculate_forces, do_coulomb, do_ewald, &
525 do_exchange, use_virial
526 REAL(kind=
dp) :: alpha, bp, dr, eta, gabr, hfx, rbeta, &
528 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: tcharge, tv
529 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: gtcharge
530 REAL(kind=
dp),
DIMENSION(3) :: rij
531 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: gab, pblock
532 TYPE(atomic_kind_type),
DIMENSION(:),
POINTER :: atomic_kind_set
533 TYPE(cell_type),
POINTER :: cell
534 TYPE(cp_fm_struct_type),
POINTER :: fmstruct, fmstructjspin
535 TYPE(cp_fm_type) :: cvec, cvecjspin
536 TYPE(cp_fm_type),
ALLOCATABLE,
DIMENSION(:) :: xtransformed
537 TYPE(cp_fm_type),
POINTER :: ct, ctjspin
538 TYPE(dbcsr_iterator_type) :: iter
539 TYPE(dbcsr_type) :: pdens
540 TYPE(dbcsr_type),
POINTER :: tempmat
541 TYPE(ewald_environment_type),
POINTER :: ewald_env
542 TYPE(ewald_pw_type),
POINTER :: ewald_pw
543 TYPE(mp_para_env_type),
POINTER :: para_env
544 TYPE(neighbor_list_set_p_type),
DIMENSION(:), &
546 TYPE(particle_type),
DIMENSION(:),
POINTER :: particle_set
547 TYPE(qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
548 TYPE(virial_type),
POINTER :: virial
550 CALL timeset(routinen, handle)
552 nactive(:) = stda_env%nactive(:)
555 IF (nspins == 2) spinfac = 1.0_dp
557 IF (nspins == 1 .AND. is_rks_triplets)
THEN
562 do_ewald = stda_control%do_ewald
563 do_exchange = stda_control%do_exchange
565 para_env => sub_env%para_env
567 CALL get_qs_env(qs_env, natom=natom, cell=cell, &
568 particle_set=particle_set, qs_kind_set=qs_kind_set)
569 ALLOCATE (first_sgf(natom))
570 ALLOCATE (last_sgf(natom))
571 CALL get_particle_set(particle_set, qs_kind_set, first_sgf=first_sgf, last_sgf=last_sgf)
575 ALLOCATE (xtransformed(nspins))
578 ct => work%ctransformed(ispin)
580 CALL cp_fm_create(matrix=xtransformed(ispin), matrix_struct=fmstruct, name=
"XTRANSFORMED")
584 ALLOCATE (tcharge(natom), gtcharge(natom, 1))
591 ct => work%ctransformed(ispin)
601 ctjspin => work%ctransformed(jspin)
603 CALL cp_fm_get_info(ctjspin, matrix_struct=fmstructjspin, nrow_global=nsgf)
612 DO is = first_sgf(ia), last_sgf(ia)
613 tcharge(ia) = tcharge(ia) + tv(is)
616 CALL cp_fm_release(cvecjspin)
623 tempmat => work%gamma_exchange(1)%matrix
624 CALL dbcsr_iterator_start(iter, tempmat)
625 DO WHILE (dbcsr_iterator_blocks_left(iter))
626 CALL dbcsr_iterator_next_block(iter, iatom, jatom, gab, blk)
627 gtcharge(iatom, 1) = gtcharge(iatom, 1) + gab(1, 1)*tcharge(jatom)
628 IF (iatom /= jatom)
THEN
629 gtcharge(jatom, 1) = gtcharge(jatom, 1) + gab(1, 1)*tcharge(iatom)
632 CALL dbcsr_iterator_stop(iter)
635 ewald_env => work%ewald_env
636 ewald_pw => work%ewald_pw
637 CALL ewald_env_get(ewald_env, alpha=alpha, ewald_type=ewald_type)
640 calculate_forces = .false.
641 n_list => sub_env%sab_orb
644 gtcharge, tcharge, calculate_forces, virial, use_virial)
646 IF (para_env%is_source())
THEN
647 gtcharge(:, 1) = gtcharge(:, 1) - 2._dp*alpha*
oorootpi*tcharge(:)
650 nlim =
get_limit(natom, para_env%num_pe, para_env%mepos)
651 DO iatom = nlim(1), nlim(2)
652 DO jatom = 1, iatom - 1
653 rij = particle_set(iatom)%r - particle_set(jatom)%r
655 dr = sqrt(sum(rij(:)**2))
656 IF (dr > 1.e-6_dp)
THEN
657 gtcharge(iatom, 1) = gtcharge(iatom, 1) + tcharge(jatom)/dr
658 gtcharge(jatom, 1) = gtcharge(jatom, 1) + tcharge(iatom)/dr
663 CALL para_env%sum(gtcharge)
668 DO is = first_sgf(ia), last_sgf(ia)
669 tv(is) = gtcharge(ia, 1)
673 ct => work%ctransformed(ispin)
674 CALL cp_fm_to_fm(ct, cvec)
682 IF (do_exchange)
THEN
684 CALL get_qs_env(qs_env=qs_env, atomic_kind_set=atomic_kind_set)
687 tempmat => work%shalf
688 CALL dbcsr_create(pdens, template=tempmat, matrix_type=dbcsr_type_no_symmetry)
690 ct => work%ctransformed(ispin)
691 CALL dbcsr_set(pdens, 0.0_dp)
693 1.0_dp, keep_sparsity=.false.)
694 CALL dbcsr_filter(pdens, stda_env%eps_td_filter)
697 bp = stda_env%beta_param
698 hfx = stda_env%hfx_fraction
699 CALL dbcsr_iterator_start(iter, pdens)
700 DO WHILE (dbcsr_iterator_blocks_left(iter))
701 CALL dbcsr_iterator_next_block(iter, iatom, jatom, pblock, blk)
702 rij = particle_set(iatom)%r - particle_set(jatom)%r
704 dr = sqrt(sum(rij(:)**2))
705 ikind = kind_of(iatom)
706 jkind = kind_of(jatom)
707 eta = (stda_env%kind_param_set(ikind)%kind_param%hardness_param + &
708 stda_env%kind_param_set(jkind)%kind_param%hardness_param)/2.0_dp
710 IF (hfx > 0.0_dp)
THEN
711 gabr = (1._dp/(rbeta + (hfx*eta)**(-bp)))**(1._dp/bp)
721 CALL dbcsr_iterator_stop(iter)
727 CALL dbcsr_release(pdens)
731 CALL cp_fm_release(cvec)
735 CALL cp_fm_release(xtransformed)
736 DEALLOCATE (tcharge, gtcharge)
737 DEALLOCATE (first_sgf, last_sgf)
739 CALL timestop(handle)
subroutine pbc(r, r_pbc, s, s_pbc, a, b, c, alpha, beta, gamma, debug, info, pbc0, h, hinv)
...
Define the atomic kind types and their sub types.
subroutine, public get_atomic_kind_set(atomic_kind_set, atom_of_kind, kind_of, natom_of_kind, maxatom, natom, nshell, fist_potential_present, shell_present, shell_adiabatic, shell_check_distance, damping_present)
Get attributes of an atomic kind set.
Handles all functions related to the CELL.
Defines control structures, which contain the parameters and the settings for the DFT-based calculati...
Routines that link DBCSR and CP2K concepts together.
subroutine, public cp_dbcsr_alloc_block_from_nbl(matrix, sab_orb, desymmetrize)
allocate the blocks of a dbcsr based on the neighbor list
DBCSR operations in CP2K.
subroutine, public cp_dbcsr_sm_fm_multiply(matrix, fm_in, fm_out, ncol, alpha, beta)
multiply a dbcsr with a fm matrix
subroutine, public copy_dbcsr_to_fm(matrix, fm)
Copy a DBCSR matrix to a BLACS matrix.
subroutine, public cp_dbcsr_plus_fm_fm_t(sparse_matrix, matrix_v, matrix_g, ncol, alpha, keep_sparsity, symmetry_mode)
performs the multiplication sparse_matrix+dense_mat*dens_mat^T if matrix_g is not explicitly given,...
subroutine, public copy_fm_to_dbcsr(fm, matrix, keep_sparsity)
Copy a BLACS matrix to a dbcsr matrix.
basic linear algebra operations for full matrices
subroutine, public cp_fm_row_scale(matrixa, scaling)
scales row i of matrix a with scaling(i)
subroutine, public cp_fm_schur_product(matrix_a, matrix_b, matrix_c)
computes the schur product of two matrices c_ij = a_ij * b_ij
used for collecting some of the diagonalization schemes available for cp_fm_type. cp_fm_power also mo...
subroutine, public cp_fm_power(matrix, work, exponent, threshold, n_dependent, verbose, eigvals)
...
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_vectorssum(matrix, sum_array, dir)
summing up all the elements along the matrix's i-th index or
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_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, use_sp)
creates a new full matrix with the given structure
various routines to log and control the output. The idea is that decisions about where to log should ...
integer function, public cp_logger_get_default_io_unit(logger)
returns the unit nr for the ionode (-1 on all other processors) skips as well checks if the procs cal...
type(cp_logger_type) function, pointer, public cp_get_default_logger()
returns the default logger
subroutine, public ewald_env_set(ewald_env, ewald_type, alpha, epsilon, eps_pol, gmax, ns_max, precs, o_spline, para_env, poisson_section, interaction_cutoffs, cell_hmat)
Purpose: Set the EWALD environment.
subroutine, public ewald_env_create(ewald_env, para_env)
allocates and intitializes a ewald_env
subroutine, public read_ewald_section_tb(ewald_env, ewald_section, hmat)
Purpose: read the EWALD section for TB methods.
subroutine, public ewald_env_get(ewald_env, ewald_type, alpha, eps_pol, epsilon, gmax, ns_max, o_spline, group, para_env, poisson_section, precs, rcut, do_multipoles, max_multipole, do_ipol, max_ipol_iter, interaction_cutoffs, cell_hmat)
Purpose: Get the EWALD environment.
Calculation of Ewald contributions in DFTB.
subroutine, public tb_ewald_overlap(gmcharge, mcharge, alpha, n_list, virial, use_virial, atprop)
...
subroutine, public tb_spme_evaluate(ewald_env, ewald_pw, particle_set, box, gmcharge, mcharge, calculate_forces, virial, use_virial, atprop)
...
subroutine, public ewald_pw_create(ewald_pw, ewald_env, cell, cell_ref, print_section)
creates the structure ewald_pw_type
Routines useful for iterative matrix calculations.
subroutine, public matrix_sqrt_newton_schulz(matrix_sqrt, matrix_sqrt_inv, matrix, threshold, order, eps_lanczos, max_iter_lanczos, symmetrize, converged)
compute the sqrt of a matrix via the sign function and the corresponding Newton-Schulz iterations the...
Defines the basic variable types.
integer, parameter, public dp
Definition of mathematical constants and functions.
real(kind=dp), parameter, public oorootpi
Interface to the message passing library MPI.
Define methods related to particle_type.
subroutine, public get_particle_set(particle_set, qs_kind_set, first_sgf, last_sgf, nsgf, nmao, basis)
Get the components of a particle set.
Define the data structure for the particle information.
subroutine, public get_qs_env(qs_env, atomic_kind_set, qs_kind_set, cell, super_cell, cell_ref, use_ref_cell, kpoints, dft_control, mos, sab_orb, sab_all, qmmm, qmmm_periodic, sac_ae, sac_ppl, sac_lri, sap_ppnl, sab_vdw, sab_scp, sap_oce, sab_lrc, sab_se, sab_xtbe, sab_tbe, sab_core, sab_xb, sab_xtb_nonbond, sab_almo, sab_kp, sab_kp_nosym, particle_set, energy, force, matrix_h, matrix_h_im, matrix_ks, matrix_ks_im, matrix_vxc, run_rtp, rtp, matrix_h_kp, matrix_h_im_kp, matrix_ks_kp, matrix_ks_im_kp, matrix_vxc_kp, kinetic_kp, matrix_s_kp, matrix_w_kp, matrix_s_RI_aux_kp, matrix_s, matrix_s_RI_aux, matrix_w, matrix_p_mp2, matrix_p_mp2_admm, rho, rho_xc, pw_env, ewald_env, ewald_pw, active_space, mpools, input, para_env, blacs_env, scf_control, rel_control, kinetic, qs_charges, vppl, rho_core, rho_nlcc, rho_nlcc_g, ks_env, ks_qmmm_env, wf_history, scf_env, local_particles, local_molecules, distribution_2d, dbcsr_dist, molecule_kind_set, molecule_set, subsys, cp_subsys, oce, local_rho_set, rho_atom_set, task_list, task_list_soft, rho0_atom_set, rho0_mpole, rhoz_set, ecoul_1c, rho0_s_rs, rho0_s_gs, do_kpoints, has_unit_metric, requires_mo_derivs, mo_derivs, mo_loc_history, nkind, natom, nelectron_total, nelectron_spin, efield, neighbor_list_id, linres_control, xas_env, virial, cp_ddapc_env, cp_ddapc_ewald, outer_scf_history, outer_scf_ihistory, x_data, et_coupling, dftb_potential, results, se_taper, se_store_int_env, se_nddo_mpole, se_nonbond_env, admm_env, lri_env, lri_density, exstate_env, ec_env, dispersion_env, gcp_env, vee, rho_external, external_vxc, mask, mp2_env, bs_env, kg_env, WannierCentres, atprop, ls_scf_env, do_transport, transport_env, v_hartree_rspace, s_mstruct_changed, rho_changed, potential_changed, forces_up_to_date, mscfg_env, almo_scf_env, gradient_history, variable_history, embed_pot, spin_embed_pot, polar_env, mos_last_converged, rhs)
Get the QUICKSTEP environment.
Define the quickstep kind type and their sub types.
subroutine, public get_qs_kind_set(qs_kind_set, all_potential_present, tnadd_potential_present, gth_potential_present, sgp_potential_present, paw_atom_present, dft_plus_u_atom_present, maxcgf, maxsgf, maxco, maxco_proj, maxgtops, maxlgto, maxlprj, maxnset, maxsgf_set, ncgf, npgf, nset, nsgf, nshell, maxpol, maxlppl, maxlppnl, maxppnl, nelectron, maxder, max_ngrid_rad, max_sph_harm, maxg_iso_not0, lmax_rho0, basis_rcut, basis_type, total_zeff_corr)
Get attributes of an atomic kind set.
Define the neighbor list data types and the corresponding functionality.
subroutine, public neighbor_list_iterator_create(iterator_set, nl, search, nthread)
Neighbor list iterator functions.
subroutine, public neighbor_list_iterator_release(iterator_set)
...
integer function, public neighbor_list_iterate(iterator_set, mepos)
...
subroutine, public get_iterator_info(iterator_set, mepos, ikind, jkind, nkind, ilist, nlist, inode, nnode, iatom, jatom, r, cell)
...
Simplified Tamm Dancoff approach (sTDA).
Simplified Tamm Dancoff approach (sTDA).
subroutine, public get_lowdin_mo_coefficients(qs_env, sub_env, work)
Calculate Lowdin MO coefficients.
subroutine, public get_lowdin_x(shalf, xvec, xt)
Calculate Lowdin transformed Davidson trial vector X shalf (dbcsr), xvec, xt (fm) are defined in the ...
subroutine, public setup_gamma(qs_env, stda_env, sub_env, gamma_matrix, ndim)
Calculate sTDA exchange-type contributions.
subroutine, public stda_init_matrices(qs_env, stda_kernel, sub_env, work, tddfpt_control)
Calculate sTDA matrices.
subroutine, public stda_calculate_kernel(qs_env, stda_control, stda_env, sub_env, work, is_rks_triplets, X, res)
...Calculate the sTDA kernel contribution by contracting the Lowdin MO coefficients – transition char...
parameters that control an scf iteration
All kind of helpful little routines.
pure integer function, dimension(2), public get_limit(m, n, me)
divide m entries into n parts, return size of part me