119#include "./base/base_uses.f90"
124 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'iao_analysis'
129 MODULE PROCEDURE iao_calculate_dmat_diag, &
130 iao_calculate_dmat_full
149 INTEGER,
INTENT(IN) :: unit_nr
150 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:), &
151 OPTIONAL :: c_iao_coef
152 TYPE(
mo_set_type),
DIMENSION(:),
OPTIONAL,
POINTER :: mos
153 REAL(kind=
dp),
DIMENSION(:, :, :),
OPTIONAL :: bond_centers
155 CHARACTER(len=*),
PARAMETER :: routinen =
'iao_wfn_analysis'
157 CHARACTER(LEN=2) :: element_symbol
158 CHARACTER(LEN=default_string_length) :: bname
159 INTEGER :: handle, i, iatom, ikind, isgf, ispin, &
160 nao, natom, nimages, nkind, no, norb, &
161 nref, ns, nsgf, nspin, nvec, nx, order
162 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: first_sgf, last_sgf, nsgfat
163 INTEGER,
DIMENSION(2) :: nocc
164 LOGICAL :: cubes_iao, cubes_ibo, molden_iao, &
165 molden_ibo, uniform_occupation
166 REAL(kind=
dp) :: fin, fout, t1, t2, trace, zval
167 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: fdiag
168 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: mcharge
169 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: moments
170 REAL(kind=
dp),
DIMENSION(:),
POINTER :: occupation_numbers
175 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:) :: c_loc_orb, ciao, cloc, cvec, iao_coef
176 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:, :) :: zij_atom
178 TYPE(
dbcsr_p_type),
DIMENSION(:),
POINTER :: sref, sro, sxo
179 TYPE(
dbcsr_p_type),
DIMENSION(:, :),
POINTER :: matrix_s
186 TYPE(
mo_set_type),
ALLOCATABLE,
DIMENSION(:) :: mo_iao, mo_loc
189 POINTER :: sro_list, srr_list, sxo_list
191 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
195 ibo_cc_section, ibo_cubes_section, &
199 cpassert(iao_env%do_iao)
202 CALL get_qs_env(qs_env, dft_control=dft_control)
203 nspin = dft_control%nspins
204 nimages = dft_control%nimages
205 IF (nimages > 1)
THEN
206 IF (unit_nr > 0)
THEN
207 WRITE (unit=unit_nr, fmt=
"(T2,A)") &
208 "K-Points: Intrinsic Atomic Orbitals Analysis not available."
211 IF (nimages > 1)
RETURN
213 CALL timeset(routinen, handle)
215 IF (unit_nr > 0)
THEN
216 WRITE (unit_nr,
'(/,T2,A)')
'!-----------------------------------------------------------------------------!'
217 WRITE (unit=unit_nr, fmt=
"(T24,A)")
"INTRINSIC ATOMIC ORBITALS ANALYSIS"
218 WRITE (unit=unit_nr, fmt=
"(T13,A)")
"G. Knizia, J. Chem. Theory Comput. 9, 4834-4843 (2013)"
219 WRITE (unit_nr,
'(T2,A)')
'!-----------------------------------------------------------------------------!'
224 iao_molden_section => iao_env%iao_molden_section
225 iao_cubes_section => iao_env%iao_cubes_section
226 ibo_molden_section => iao_env%ibo_molden_section
227 ibo_cubes_section => iao_env%ibo_cubes_section
228 ibo_cc_section => iao_env%ibo_cc_section
232 IF (
ASSOCIATED(iao_molden_section))
THEN
236 IF (
ASSOCIATED(iao_cubes_section))
THEN
240 IF (
ASSOCIATED(ibo_molden_section))
THEN
244 IF (
ASSOCIATED(ibo_cubes_section))
THEN
253 smat => matrix_s(1, 1)%matrix
255 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
256 nkind =
SIZE(qs_kind_set)
257 ALLOCATE (ref_basis_set_list(nkind), orb_basis_set_list(nkind))
259 qs_kind => qs_kind_set(ikind)
260 NULLIFY (ref_basis_set_list(ikind)%gto_basis_set)
261 NULLIFY (orb_basis_set_list(ikind)%gto_basis_set)
262 NULLIFY (refbasis, orbbasis)
263 CALL get_qs_kind(qs_kind=qs_kind, basis_set=orbbasis, basis_type=
"ORB")
264 IF (
ASSOCIATED(orbbasis)) orb_basis_set_list(ikind)%gto_basis_set => orbbasis
265 CALL get_qs_kind(qs_kind=qs_kind, basis_set=refbasis, basis_type=
"MIN")
266 IF (
ASSOCIATED(refbasis)) ref_basis_set_list(ikind)%gto_basis_set => refbasis
270 NULLIFY (srr_list, sro_list)
278 ref_basis_set_list, ref_basis_set_list, srr_list)
280 ref_basis_set_list, orb_basis_set_list, sro_list)
282 IF (
PRESENT(mos))
THEN
288 CALL dbcsr_get_info(sro(1)%matrix, nfullrows_total=nref, nfullcols_total=nao)
292 CALL cp_fm_struct_create(fm_struct, context=mo_coeff%matrix_struct%context, nrow_global=nref, &
293 ncol_global=nao, para_env=mo_coeff%matrix_struct%para_env)
297 CALL cp_fm_struct_create(fm_struct, context=mo_coeff%matrix_struct%context, nrow_global=nao, &
298 ncol_global=nref, para_env=mo_coeff%matrix_struct%para_env)
302 CALL iao_projectors(smat, sref(1)%matrix, sro(1)%matrix, p_orb_ref, p_ref_orb, iao_env%eps_svd)
307 CALL get_mo_set(my_mos(ispin), mo_coeff=mo_coeff, nmo=norb, uniform_occupation=uniform_occupation, &
308 occupation_numbers=occupation_numbers)
309 IF (uniform_occupation)
THEN
314 IF (occupation_numbers(i) > iao_env%eps_occ)
THEN
324 ALLOCATE (iao_coef(nspin), cvec(nspin))
326 CALL get_mo_set(my_mos(ispin), mo_coeff=mo_coeff)
330 CALL cp_fm_struct_create(fm_struct, ncol_global=nvec, template_fmstruct=mo_coeff%matrix_struct)
336 CALL cp_fm_struct_create(fm_struct, ncol_global=nref, template_fmstruct=mo_coeff%matrix_struct)
340 CALL intrinsic_ao_calc(smat, p_orb_ref, p_ref_orb, cvec(ispin), iao_coef(ispin))
344 IF (iao_env%do_charges)
THEN
346 ALLOCATE (ciao(nspin))
348 CALL get_mo_set(my_mos(ispin), mo_coeff=mo_coeff, nao=nao, nmo=norb)
351 CALL cp_fm_struct_create(fm_struct, nrow_global=nref, template_fmstruct=mo_coeff%matrix_struct)
356 CALL parallel_gemm(
'T',
'N', nref, norb, nao, 1.0_dp, iao_coef(ispin), smo, 0.0_dp, ciao(ispin))
361 IF (unit_nr > 0)
THEN
362 WRITE (unit_nr,
'(/,T2,A)')
'Intrinsic AO Population Analysis '
364 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set, natom=natom)
365 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set)
366 ALLOCATE (mcharge(natom, nspin))
370 uniform_occupation=uniform_occupation, &
371 occupation_numbers=occupation_numbers)
378 IF (unit_nr > 0)
THEN
379 WRITE (unit_nr,
'(T2,A,I2,T66,F15.4)')
'Number of Electrons: Trace(Piao) Spin ', ispin, trace
384 CALL print_atomic_charges(particle_set, qs_kind_set, unit_nr,
"Intrinsic Atomic Orbital Charges", &
385 electronic_charges=mcharge)
398 DEALLOCATE (orb_basis_set_list)
400 IF (iao_env%do_oce)
THEN
402 IF (unit_nr > 0)
THEN
403 WRITE (unit_nr,
'(T2,A)')
"IAO One-Center Expansion: OCE Basis Set"
405 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
406 nkind =
SIZE(qs_kind_set)
407 ALLOCATE (oce_basis_set_list(nkind), orb_basis_set_list(nkind))
409 qs_kind => qs_kind_set(ikind)
410 NULLIFY (orb_basis_set_list(ikind)%gto_basis_set)
412 CALL get_qs_kind(qs_kind=qs_kind, basis_set=orbbasis, basis_type=
"ORB")
413 IF (
ASSOCIATED(orbbasis)) orb_basis_set_list(ikind)%gto_basis_set => orbbasis
416 orbbasis => orb_basis_set_list(ikind)%gto_basis_set
417 cpassert(
ASSOCIATED(orbbasis))
419 CALL create_oce_basis(ocebasis, orbbasis, iao_env%lmax_oce, iao_env%nbas_oce)
422 oce_basis_set_list(ikind)%gto_basis_set => ocebasis
423 IF (unit_nr > 0)
THEN
424 qs_kind => qs_kind_set(ikind)
425 CALL get_qs_kind(qs_kind, zeff=zval, element_symbol=element_symbol)
427 WRITE (unit_nr,
'(T2,A,A,T14,A,I4,T40,A,A30)')
"Kind: ", element_symbol,
"NBasFun: ", nsgf, &
428 "OCE Basis: ", adjustl(trim(bname))
431 IF (unit_nr > 0)
WRITE (unit_nr, *)
433 ALLOCATE (smat_kind(nkind))
435 ocebasis => oce_basis_set_list(ikind)%gto_basis_set
437 ALLOCATE (smat_kind(ikind)%array(nsgf, nsgf))
439 CALL oce_overlap_matrix(smat_kind, oce_basis_set_list)
441 NULLIFY (sxo, sxo_list)
445 oce_basis_set_list, orb_basis_set_list, sxo_list)
449 ALLOCATE (oce_atom(natom, nspin))
450 CALL iao_oce_expansion(qs_env, oce_basis_set_list, smat_kind, sxo, iao_coef, oce_atom, unit_nr)
453 ocebasis => oce_basis_set_list(ikind)%gto_basis_set
456 DEALLOCATE (oce_basis_set_list, orb_basis_set_list)
461 DEALLOCATE (smat_kind(ikind)%array)
463 DEALLOCATE (smat_kind)
466 DEALLOCATE (oce_atom(iatom, ispin)%array)
469 DEALLOCATE (oce_atom)
474 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
475 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set)
476 IF (unit_nr > 0)
THEN
477 WRITE (unit_nr,
'(T2,A)')
' Write IAO in MOLDEN Format'
479 ALLOCATE (mo_iao(nspin))
482 CALL allocate_mo_set(mo_iao(ispin), nao, nref, nref, 0.0_dp, 1.0_dp, 0.0_dp)
483 CALL init_mo_set(mo_iao(ispin), fm_ref=iao_coef(ispin), name=
"iao_set")
484 CALL cp_fm_to_fm(iao_coef(ispin), mo_iao(ispin)%mo_coeff)
486 mo_iao(ispin)%occupation_numbers = 1.0_dp
489 CALL write_mos_molden(mo_iao, qs_kind_set, particle_set, iao_molden_section)
496 IF (unit_nr > 0)
THEN
497 WRITE (unit_nr,
'(T2,A)')
' Write IAO as CUBE Files'
500 CALL print_iao_cubes(qs_env, iao_cubes_section, iao_coef, ref_basis_set_list)
504 IF (iao_env%do_bondorbitals)
THEN
505 IF (unit_nr > 0)
THEN
506 WRITE (unit_nr,
'(/,T2,A)')
'Intrinsic Bond Orbital Generation'
509 ALLOCATE (ciao(nspin))
511 CALL get_mo_set(my_mos(ispin), mo_coeff=mo_coeff, nao=nao, nmo=norb)
514 CALL cp_fm_struct_create(fm_struct, nrow_global=nref, template_fmstruct=mo_coeff%matrix_struct)
519 CALL parallel_gemm(
'T',
'N', nref, norb, nao, 1.0_dp, iao_coef(ispin), smo, 0.0_dp, ciao(ispin))
525 ALLOCATE (cloc(nspin), c_loc_orb(nspin))
529 template_fmstruct=ciao(ispin)%matrix_struct)
532 CALL cp_fm_to_fm(ciao(ispin), cloc(ispin), ncol=nocc(ispin))
535 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set, natom=natom)
536 ALLOCATE (first_sgf(natom), last_sgf(natom), nsgfat(natom))
537 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set)
538 CALL get_particle_set(particle_set, qs_kind_set, first_sgf=first_sgf, last_sgf=last_sgf, &
539 nsgf=nsgfat, basis=ref_basis_set_list)
542 cpabort(
"IAO localization operator NYA")
545 cpabort(
"IAO energy weight localization NYA")
551 ALLOCATE (zij_atom(natom, 1), fdiag(nvec))
554 template_fmstruct=cloc(ispin)%matrix_struct)
557 isgf = first_sgf(iatom)
558 CALL parallel_gemm(
'T',
'N', nvec, nvec, nsgfat(iatom), 1.0_dp, cloc(ispin), cloc(ispin), &
559 0.0_dp, zij_atom(iatom, 1), &
560 a_first_col=1, a_first_row=isgf, b_first_col=1, b_first_row=isgf)
569 fin = fin + sum(fdiag**order)
571 fin = fin**(1._dp/order)
576 isgf = first_sgf(iatom)
577 CALL parallel_gemm(
'T',
'N', nvec, nvec, nsgfat(iatom), 1.0_dp, cloc(ispin), cloc(ispin), &
578 0.0_dp, zij_atom(iatom, 1), &
579 a_first_col=1, a_first_row=isgf, b_first_col=1, b_first_row=isgf)
584 fout = fout + sum(fdiag**order)
586 fout = fout**(1._dp/order)
589 IF (unit_nr > 0)
THEN
590 WRITE (unit_nr,
'(T2,A,F14.8,A,F14.8,A,F8.2)') &
591 'SCDM pre-localization: fin=', fin,
" fout=", fout,
" Time=", t2 - t1
594 CALL pm_localization(zij_atom, cloc(ispin), order, 1.e-12_dp, unit_nr)
600 template_fmstruct=cloc(ispin)%matrix_struct)
603 CALL parallel_gemm(
'N',
'N', nao, nvec, nref, 1.0_dp, iao_coef(ispin), cloc(ispin), &
604 0.0_dp, c_loc_orb(ispin))
607 DEALLOCATE (first_sgf, last_sgf, nsgfat)
610 IF (iao_env%do_center)
THEN
611 IF (unit_nr > 0)
THEN
612 WRITE (unit_nr,
'(T2,A)')
' Calculate Localized Orbital Centers and Spread'
613 IF (iao_env%pos_periodic)
THEN
614 WRITE (unit_nr,
'(T2,A)')
' Use Berry Phase Position Operator'
616 WRITE (unit_nr,
'(T2,A)')
' Use Local Position Operator'
621 ALLOCATE (moments(5, nvec, nspin))
623 IF (iao_env%pos_periodic)
THEN
624 CALL center_spread_berry(qs_env, c_loc_orb, moments)
626 CALL center_spread_loc(qs_env, c_loc_orb, moments)
629 IF (
ASSOCIATED(ibo_cc_section))
THEN
633 IF (
PRESENT(bond_centers))
THEN
634 nx =
SIZE(bond_centers, 1)
635 no =
SIZE(bond_centers, 2)
636 ns =
SIZE(bond_centers, 3)
638 cpassert(ns == nspin)
641 bond_centers(1:nx, 1:nvec, 1:ns) = moments(1:nx, 1:nvec, 1:ns)
647 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
648 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set)
649 IF (unit_nr > 0)
THEN
650 WRITE (unit_nr,
'(T2,A)')
' Write IBO in MOLDEN Format'
652 ALLOCATE (mo_loc(nspin))
656 CALL allocate_mo_set(mo_loc(ispin), nao, nvec, nvec, 0.0_dp, 1.0_dp, 0.0_dp)
657 CALL init_mo_set(mo_loc(ispin), fm_ref=c_loc_orb(ispin), name=
"ibo_orb")
658 CALL cp_fm_to_fm(c_loc_orb(ispin), mo_loc(ispin)%mo_coeff)
660 mo_loc(ispin)%occupation_numbers = 1.0_dp
663 CALL write_mos_molden(mo_loc, qs_kind_set, particle_set, ibo_molden_section)
671 IF (unit_nr > 0)
THEN
672 WRITE (unit_nr,
'(T2,A)')
' Write IBO on CUBE files'
675 CALL print_ibo_cubes(qs_env, ibo_cubes_section, c_loc_orb)
678 IF (
PRESENT(mos) .AND.
ALLOCATED(c_loc_orb))
THEN
681 CALL get_mo_set(mos(ispin), mo_coeff=mo_coeff)
683 CALL cp_fm_to_fm(c_loc_orb(ispin), mo_coeff, ncol=nvec)
688 DEALLOCATE (ref_basis_set_list)
690 IF (
PRESENT(c_iao_coef))
THEN
692 ALLOCATE (c_iao_coef(nspin))
694 CALL cp_fm_create(c_iao_coef(ispin), iao_coef(ispin)%matrix_struct)
695 CALL cp_fm_to_fm(iao_coef(ispin), c_iao_coef(ispin))
700 IF (unit_nr > 0)
THEN
701 WRITE (unit_nr,
'(T2,A)') &
702 '!----------------------------END OF IAO ANALYSIS------------------------------!'
705 CALL timestop(handle)
718 SUBROUTINE iao_projectors(smat, sref, s_r_o, p_o_r, p_r_o, eps_svd)
719 TYPE(
dbcsr_type),
INTENT(INOUT) :: smat, sref, s_r_o
720 TYPE(
cp_fm_type),
INTENT(INOUT) :: p_o_r, p_r_o
721 REAL(kind=
dp),
INTENT(IN) :: eps_svd
723 CHARACTER(len=*),
PARAMETER :: routinen =
'iao_projectors'
725 INTEGER :: handle, norb, nref
729 CALL timeset(routinen, handle)
737 template_fmstruct=p_r_o%matrix_struct)
743 CALL parallel_gemm(
'N',
'T', norb, nref, norb, 1.0_dp, fm_inv, fm_sro, 0.0_dp, p_o_r)
749 template_fmstruct=p_r_o%matrix_struct)
755 CALL parallel_gemm(
'N',
'N', nref, norb, nref, 1.0_dp, fm_inv, fm_sro, 0.0_dp, p_r_o)
761 CALL timestop(handle)
763 END SUBROUTINE iao_projectors
773 SUBROUTINE intrinsic_ao_calc(smat, p_o_r, p_r_o, cvec, avec)
775 TYPE(
cp_fm_type),
INTENT(INOUT) :: p_o_r, p_r_o, cvec, avec
777 CHARACTER(len=*),
PARAMETER :: routinen =
'intrinsic_ao_calc'
779 INTEGER :: handle, nao, norb, nref
783 CALL timeset(routinen, handle)
792 template_fmstruct=cvec%matrix_struct)
796 CALL parallel_gemm(
'N',
'N', nref, norb, nao, 1.0_dp, p_r_o, cvec, 0.0_dp, pc)
798 CALL parallel_gemm(
'N',
'N', nao, norb, nref, 1.0_dp, p_o_r, pc, 0.0_dp, ctvec)
807 template_fmstruct=cvec%matrix_struct)
811 CALL parallel_gemm(
'T',
'N', norb, nref, nao, 1.0_dp, sct, p_o_r, 0.0_dp, pc)
814 template_fmstruct=cvec%matrix_struct)
817 CALL parallel_gemm(
'N',
'N', nao, nref, norb, 1.0_dp, ctvec, pc, 0.0_dp, vec1)
819 CALL parallel_gemm(
'T',
'N', norb, nref, nao, 1.0_dp, sc, vec1, 0.0_dp, pc)
820 CALL parallel_gemm(
'N',
'N', nao, nref, norb, 1.0_dp, cvec, pc, 0.0_dp, avec)
822 CALL cp_fm_geadd(1.0_dp,
'N', p_o_r, -1.0_dp, vec1)
826 CALL parallel_gemm(
'T',
'N', norb, nref, nao, 1.0_dp, sc, vec1, 0.0_dp, pc)
827 CALL parallel_gemm(
'N',
'N', nao, nref, norb, -1.0_dp, cvec, pc, 1.0_dp, avec)
838 CALL timestop(handle)
840 END SUBROUTINE intrinsic_ao_calc
849 SUBROUTINE iao_calculate_dmat_diag(cvec, density_matrix, occupation, uniform_occupation)
853 REAL(KIND=
dp),
DIMENSION(:),
INTENT(IN) :: occupation
854 LOGICAL,
INTENT(IN) :: uniform_occupation
856 CHARACTER(len=*),
PARAMETER :: routineN =
'iao_calculate_dmat_diag'
858 INTEGER :: handle, ncol
859 REAL(KIND=
dp) :: alpha
862 CALL timeset(routinen, handle)
867 IF (.NOT. uniform_occupation)
THEN
873 matrix_v=cvec, matrix_g=fm_tmp, &
874 ncol=ncol, alpha=alpha)
877 alpha = occupation(1)
879 matrix_v=cvec, ncol=ncol, alpha=alpha)
882 CALL timestop(handle)
884 END SUBROUTINE iao_calculate_dmat_diag
893 SUBROUTINE iao_calculate_dmat_full(cvec, density_matrix, weight, occmat)
897 REAL(KIND=
dp),
DIMENSION(:),
INTENT(IN) :: weight
900 CHARACTER(len=*),
PARAMETER :: routinen =
'iao_calculate_dmat_full'
902 INTEGER :: handle, ic, jc, ncol
903 REAL(kind=
dp) :: alpha
907 CALL timeset(routinen, handle)
912 template_fmstruct=cvec%matrix_struct)
919 CALL cp_fm_to_fm(cvec, fm1, ncol=1, source_start=ic, target_start=1)
921 CALL cp_fm_to_fm(cvec, fm2, ncol=1, source_start=jc, target_start=1)
923 alpha = weight(ic)*alpha
925 alpha=alpha, symmetry_mode=1)
931 CALL timestop(handle)
933 END SUBROUTINE iao_calculate_dmat_full
942 REAL(kind=
dp),
DIMENSION(:) :: charges
944 INTEGER :: i, iblock_col, iblock_row
945 REAL(kind=
dp) :: trace
946 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: p_block
956 cpassert(iblock_row == iblock_col)
958 DO i = 1,
SIZE(p_block, 1)
959 trace = trace + p_block(i, i)
961 charges(iblock_row) = trace
966 CALL group%sum(charges)
977 SUBROUTINE print_iao_cubes(qs_env, print_section, iao_coef, basis_set_list)
980 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: iao_coef
983 CHARACTER(LEN=default_path_length) :: filename, title
984 INTEGER :: i, i_rep, ispin, ivec, iw, j, n_rep, &
985 nat, natom, norb, nspins, nstart
986 INTEGER,
DIMENSION(:),
POINTER :: atom_list, blk_sizes, first_bas, stride
998 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1005 CALL get_qs_env(qs_env=qs_env, atomic_kind_set=atomic_kind_set, qs_kind_set=qs_kind_set, &
1006 subsys=subsys, cell=cell, particle_set=particle_set, pw_env=pw_env, dft_control=dft_control)
1010 ALLOCATE (blk_sizes(natom), first_bas(0:natom))
1011 CALL get_particle_set(particle_set, qs_kind_set, nsgf=blk_sizes, basis=basis_set_list)
1014 first_bas(i) = first_bas(i - 1) + blk_sizes(i)
1017 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
1018 CALL auxbas_pw_pool%create_pw(wf_r)
1019 CALL auxbas_pw_pool%create_pw(wf_g)
1021 nspins =
SIZE(iao_coef)
1022 nstart = min(1, n_rep)
1024 DO ispin = 1, nspins
1025 DO i_rep = nstart, n_rep
1027 IF (i_rep == 0)
THEN
1031 nat =
SIZE(atom_list)
1034 IF (i_rep == 0)
THEN
1039 cpassert(j >= 1 .AND. j <= natom)
1040 DO ivec = first_bas(j - 1) + 1, first_bas(j)
1041 WRITE (filename,
'(a4,I5.5,a1,I1.1)')
"IAO_", ivec,
"_", ispin
1042 WRITE (title, *)
"Intrinsic Atomic Orbitals ", ivec,
" atom ", j,
" spin ", ispin
1045 middle_name=trim(filename), file_position=
"REWIND", log_filename=.false., &
1048 cell, dft_control, particle_set, pw_env)
1049 CALL cp_pw_to_cube(wf_r, iw, title, particles=particles, stride=stride, mpi_io=mpi_io)
1055 DEALLOCATE (blk_sizes, first_bas)
1056 CALL auxbas_pw_pool%give_back_pw(wf_r)
1057 CALL auxbas_pw_pool%give_back_pw(wf_g)
1059 END SUBROUTINE print_iao_cubes
1067 SUBROUTINE print_ibo_cubes(qs_env, print_section, ibo_coef)
1070 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: ibo_coef
1072 CHARACTER(LEN=default_path_length) :: filename, title
1073 INTEGER :: i, i_rep, ispin, iw, j, n_rep, norb, &
1074 nspins, nstart, nstate
1075 INTEGER,
DIMENSION(:),
POINTER :: state_list, stride
1087 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1090 cpassert(
ASSOCIATED(print_section))
1096 CALL get_qs_env(qs_env=qs_env, atomic_kind_set=atomic_kind_set, qs_kind_set=qs_kind_set, &
1097 subsys=subsys, cell=cell, particle_set=particle_set, pw_env=pw_env, dft_control=dft_control)
1100 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
1101 CALL auxbas_pw_pool%create_pw(wf_r)
1102 CALL auxbas_pw_pool%create_pw(wf_g)
1104 nspins =
SIZE(ibo_coef)
1105 nstart = min(1, n_rep)
1107 DO ispin = 1, nspins
1108 DO i_rep = nstart, n_rep
1110 IF (i_rep == 0)
THEN
1114 nstate =
SIZE(state_list)
1117 IF (i_rep == 0)
THEN
1122 cpassert(j >= 1 .AND. j <= norb)
1123 WRITE (filename,
'(a4,I5.5,a1,I1.1)')
"IBO_", j,
"_", ispin
1124 WRITE (title, *)
"Intrinsic Atomic Orbitals ", j,
" spin ", ispin
1127 middle_name=trim(filename), file_position=
"REWIND", log_filename=.false., &
1130 cell, dft_control, particle_set, pw_env)
1131 CALL cp_pw_to_cube(wf_r, iw, title, particles=particles, stride=stride, mpi_io=mpi_io)
1137 CALL auxbas_pw_pool%give_back_pw(wf_r)
1138 CALL auxbas_pw_pool%give_back_pw(wf_g)
1140 END SUBROUTINE print_ibo_cubes
1150 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: moments
1151 INTEGER,
DIMENSION(:),
INTENT(IN) :: nocc
1153 INTEGER,
INTENT(IN),
OPTIONAL :: iounit
1155 CHARACTER(LEN=default_path_length) :: filename
1156 INTEGER :: is, ispin, iw, nspin
1160 nspin =
SIZE(moments, 3)
1162 IF (
PRESENT(print_section))
THEN
1163 WRITE (filename,
'(A18,I1.1)')
"IBO_CENTERS_SPREAD"
1165 middle_name=trim(filename), file_position=
"REWIND", log_filename=.false.)
1166 ELSEIF (
PRESENT(iounit))
THEN
1173 WRITE (iw,
"(T2,A,i1)")
"Intrinsic Bond Orbitals: Centers and Spread for Spin ", ispin
1174 WRITE (iw,
"(A7,T30,A6,T68,A7)")
"State",
"Center",
"Spreads"
1175 DO is = 1, nocc(ispin)
1176 WRITE (iw,
"(i7,3F15.8,8X,2F10.5)") is, moments(:, is, ispin)
1180 IF (
PRESENT(print_section))
THEN
1192 SUBROUTINE center_spread_loc(qs_env, c_loc_orb, moments)
1194 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: c_loc_orb
1195 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: moments
1197 CHARACTER(len=*),
PARAMETER :: routinen =
'center_spread_loc'
1198 INTEGER,
DIMENSION(6),
PARAMETER ::
list = (/1, 2, 3, 4, 7, 9/)
1200 INTEGER :: handle, i, iop, iorb, ispin, nao, norb, &
1202 REAL(kind=
dp) :: xmii
1203 REAL(kind=
dp),
DIMENSION(3) :: rpoint
1208 TYPE(
dbcsr_p_type),
DIMENSION(:, :),
POINTER :: matrix_s
1211 CALL timeset(routinen, handle)
1213 CALL get_qs_env(qs_env=qs_env, matrix_s_kp=matrix_s)
1214 smat => matrix_s(1, 1)%matrix
1216 nspin =
SIZE(c_loc_orb)
1219 ALLOCATE (dipmat(9))
1221 ALLOCATE (dipmat(i)%matrix)
1223 CALL dbcsr_set(dipmat(i)%matrix, 0.0_dp)
1229 CALL cp_fm_get_info(c_loc_orb(ispin), nrow_global=nao, ncol_global=norb)
1230 CALL cp_fm_create(ocvec, c_loc_orb(ispin)%matrix_struct)
1233 template_fmstruct=c_loc_orb(ispin)%matrix_struct)
1238 omat => dipmat(iop)%matrix
1240 CALL parallel_gemm(
'T',
'N', norb, norb, nao, 1.0_dp, c_loc_orb(ispin), ocvec, &
1245 moments(iop, iorb, ispin) = moments(iop, iorb, ispin) + xmii
1246 moments(4, iorb, ispin) = moments(4, iorb, ispin) - xmii**2
1248 moments(4, iorb, ispin) = moments(4, iorb, ispin) + xmii
1258 DEALLOCATE (dipmat(i)%matrix)
1265 moments(1:3, iorb, ispin) =
pbc(moments(1:3, iorb, ispin), cell)
1269 CALL timestop(handle)
1271 END SUBROUTINE center_spread_loc
1279 SUBROUTINE center_spread_berry(qs_env, c_loc_orb, moments)
1281 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: c_loc_orb
1282 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: moments
1284 CHARACTER(len=*),
PARAMETER :: routinen =
'center_spread_berry'
1286 COMPLEX(KIND=dp) :: z
1287 INTEGER :: dim_op, handle, i, idir, ispin, istate, &
1288 j, jdir, nao, norb, nspin
1289 REAL(
dp),
DIMENSION(3) :: c, cpbc
1290 REAL(
dp),
DIMENSION(6) :: weights
1291 REAL(kind=
dp) :: imagpart, realpart, spread_i, spread_ii
1295 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:, :) :: zij
1297 TYPE(
dbcsr_p_type),
DIMENSION(:, :),
POINTER :: op_sm_set
1299 CALL timeset(routinen, handle)
1301 CALL get_qs_env(qs_env=qs_env, matrix_s=matrix_s, cell=cell)
1303 IF (cell%orthorhombic)
THEN
1308 ALLOCATE (op_sm_set(2, dim_op))
1311 NULLIFY (op_sm_set(j, i)%matrix)
1312 ALLOCATE (op_sm_set(j, i)%matrix)
1313 CALL dbcsr_copy(op_sm_set(j, i)%matrix, matrix_s(1)%matrix)
1314 CALL dbcsr_set(op_sm_set(j, i)%matrix, 0.0_dp)
1321 nspin =
SIZE(c_loc_orb, 1)
1323 CALL cp_fm_get_info(c_loc_orb(ispin), nrow_global=nao, ncol_global=norb)
1324 CALL cp_fm_create(opvec, c_loc_orb(ispin)%matrix_struct)
1327 template_fmstruct=c_loc_orb(ispin)%matrix_struct)
1328 ALLOCATE (zij(2, dim_op))
1336 CALL parallel_gemm(
"T",
"N", norb, norb, nao, 1.0_dp, c_loc_orb(ispin), opvec, 0.0_dp, zij(j, i))
1350 z = cmplx(realpart, imagpart,
dp)
1351 spread_i = spread_i - weights(jdir)* &
1352 log(realpart*realpart + imagpart*imagpart)/
twopi/
twopi
1353 spread_ii = spread_ii + weights(jdir)* &
1354 (1.0_dp - (realpart*realpart + imagpart*imagpart))/
twopi/
twopi
1357 c(idir) = c(idir) + &
1358 (cell%hmat(idir, jdir)/
twopi)*aimag(log(z))
1363 moments(1:3, istate, ispin) = cpbc(1:3)
1364 moments(4, istate, ispin) = spread_i
1365 moments(5, istate, ispin) = spread_ii
1375 DEALLOCATE (op_sm_set(j, i)%matrix)
1378 DEALLOCATE (op_sm_set)
1380 CALL timestop(handle)
1382 END SUBROUTINE center_spread_berry
1394 SUBROUTINE iao_oce_expansion(qs_env, oce_basis_set_list, smat_kind, sxo, iao_coef, oce_atom, unit_nr)
1401 INTEGER,
INTENT(IN) :: unit_nr
1403 CHARACTER(len=*),
PARAMETER :: routinen =
'iao_oce_expansion'
1405 INTEGER :: handle, i, i1, i2, iao, iatom, ikind, &
1406 iset, ishell, ispin, l, m, maxl, n, &
1407 natom, nkind, noce, ns, nset, nsgf, &
1409 INTEGER,
DIMENSION(:),
POINTER :: iao_blk_sizes, nshell, oce_blk_sizes, &
1411 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgf, last_sgf, lval
1413 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: ev, vector
1414 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: amat, bmat, filter, oce_comp, prol, vec
1415 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: ablock
1422 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1425 CALL timeset(routinen, handle)
1428 CALL dbcsr_get_info(sxo(1)%matrix, row_blk_size=oce_blk_sizes, col_blk_size=orb_blk_sizes, &
1429 distribution=dbcsr_dist)
1430 CALL get_qs_env(qs_env=qs_env, ks_env=ks_env, natom=natom)
1431 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set, qs_kind_set=qs_kind_set)
1432 ALLOCATE (iao_blk_sizes(natom))
1434 CALL get_atomic_kind(particle_set(iatom)%atomic_kind, kind_number=ikind)
1435 CALL get_qs_kind(qs_kind_set(ikind), nsgf=ns, basis_type=
"MIN")
1436 iao_blk_sizes(iatom) = ns
1439 CALL dbcsr_create(iao_vec, name=
"IAO_VEC", dist=dbcsr_dist, &
1440 matrix_type=dbcsr_type_no_symmetry, row_blk_size=orb_blk_sizes, &
1441 col_blk_size=iao_blk_sizes)
1442 CALL dbcsr_create(sx_vec, name=
"SX_VEC", dist=dbcsr_dist, &
1443 matrix_type=dbcsr_type_no_symmetry, row_blk_size=oce_blk_sizes, &
1444 col_blk_size=iao_blk_sizes)
1447 nkind =
SIZE(smat_kind)
1448 ALLOCATE (sinv_kind(nkind))
1450 noce =
SIZE(smat_kind(ikind)%array, 1)
1451 ALLOCATE (sinv_kind(ikind)%array(noce, noce))
1452 sinv_kind(ikind)%array = smat_kind(ikind)%array
1457 nspin =
SIZE(iao_coef, 1)
1458 ALLOCATE (oce_comp(natom, nspin))
1462 CALL dbcsr_multiply(
"N",
"N", 1.0_dp, sxo(1)%matrix, iao_vec, 0.0_dp, sx_vec, &
1463 retain_sparsity=.true.)
1465 CALL get_atomic_kind(particle_set(iatom)%atomic_kind, kind_number=ikind)
1467 row=iatom, col=iatom, block=ablock, found=found)
1471 ablock = matmul(sinv_kind(ikind)%array, ablock)
1472 ALLOCATE (amat(n, m), bmat(m, m), ev(m), vec(m, m))
1473 amat(1:n, 1:m) = matmul(smat_kind(ikind)%array(1:n, 1:n), ablock(1:n, 1:m))
1474 bmat(1:m, 1:m) = matmul(transpose(ablock(1:n, 1:m)), amat(1:n, 1:m))
1475 CALL jacobi(bmat, ev, vec)
1476 oce_comp(iatom, ispin) = sum(ev(1:m))/real(m, kind=
dp)
1478 ev(i) = 1._dp/sqrt(ev(i))
1479 bmat(1:m, i) = vec(1:m, i)*ev(i)
1481 bmat(1:m, 1:m) = matmul(bmat(1:m, 1:m), transpose(vec(1:m, 1:m)))
1482 ablock(1:n, 1:m) = matmul(ablock(1:n, 1:m), bmat(1:m, 1:m))
1483 DEALLOCATE (amat, bmat, ev, vec)
1488 CALL get_atomic_kind(particle_set(iatom)%atomic_kind, kind_number=ikind)
1490 row=iatom, col=iatom, block=ablock, found=found)
1494 ALLOCATE (oce_atom(iatom, ispin)%array(n, m))
1495 oce_atom(iatom, ispin)%array = ablock
1499 CALL group%sum(oce_comp)
1500 IF (unit_nr > 0)
THEN
1502 WRITE (unit_nr,
"(T4,A,I6,T30,A,2F12.4)")
"Atom:", iatom,
" Completeness: ", oce_comp(iatom, 1:nspin)
1503 CALL get_atomic_kind(particle_set(iatom)%atomic_kind, kind_number=ikind)
1504 oce_basis => oce_basis_set_list(ikind)%gto_basis_set
1505 CALL get_gto_basis_set(oce_basis, nset=nset, nshell=nshell, nsgf=nsgf, maxl=maxl, &
1506 l=lval, first_sgf=first_sgf, last_sgf=last_sgf)
1507 ALLOCATE (filter(nsgf, 0:maxl), vector(nsgf), prol(0:maxl, nspin))
1510 DO ishell = 1, nshell(iset)
1511 l = lval(ishell, iset)
1512 i1 = first_sgf(ishell, iset)
1513 i2 = last_sgf(ishell, iset)
1514 filter(i1:i2, l) = 1.0_dp
1518 n =
SIZE(oce_atom(iatom, 1)%array, 1)
1519 m =
SIZE(oce_atom(iatom, 1)%array, 2)
1525 vector(1:n) = oce_atom(iatom, ispin)%array(1:n, iao)*filter(1:n, l)
1526 prol(l, ispin) = sum(matmul(smat_kind(ikind)%array(1:n, 1:n), vector(1:n))*vector(1:n))
1529 WRITE (unit_nr,
"(T4,I3,T15,A,T39,(6F7.4))") iao,
" l-contributions:", (sum(prol(l, :)), l=0, maxl)
1531 DEALLOCATE (filter, vector, prol)
1536 DEALLOCATE (oce_comp)
1538 DEALLOCATE (sinv_kind(ikind)%array)
1540 DEALLOCATE (sinv_kind)
1541 DEALLOCATE (iao_blk_sizes)
1545 CALL timestop(handle)
1547 END SUBROUTINE iao_oce_expansion
1554 SUBROUTINE oce_overlap_matrix(smat_kind, basis_set_list)
1558 CHARACTER(len=*),
PARAMETER :: routinen =
'oce_overlap_matrix'
1560 INTEGER :: handle, ikind, iset, jset, ldsab, m1, &
1561 m2, n1, n2, ncoa, ncob, nkind, nseta, &
1563 INTEGER,
DIMENSION(:),
POINTER :: la_max, la_min, npgfa, nsgfa
1564 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgfa
1565 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: oint, owork
1566 REAL(kind=
dp),
DIMENSION(3) :: rab
1567 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: rpgfa, scon_a, smat, zeta
1570 CALL timeset(routinen, handle)
1574 nkind =
SIZE(smat_kind)
1577 basis_set => basis_set_list(ikind)%gto_basis_set
1578 cpassert(
ASSOCIATED(basis_set))
1580 ldsab = max(m1, m2, ldsab)
1583 ALLOCATE (oint(ldsab, ldsab), owork(ldsab, ldsab))
1586 basis_set => basis_set_list(ikind)%gto_basis_set
1587 cpassert(
ASSOCIATED(basis_set))
1588 smat => smat_kind(ikind)%array
1591 first_sgfa => basis_set%first_sgf
1592 la_max => basis_set%lmax
1593 la_min => basis_set%lmin
1594 npgfa => basis_set%npgf
1595 nseta = basis_set%nset
1596 nsgfa => basis_set%nsgf_set
1597 rpgfa => basis_set%pgf_radius
1598 scon_a => basis_set%scon
1599 zeta => basis_set%zet
1603 ncoa = npgfa(iset)*
ncoset(la_max(iset))
1604 n1 = npgfa(iset)*(
ncoset(la_max(iset)) -
ncoset(la_min(iset) - 1))
1605 sgfa = first_sgfa(1, iset)
1609 ncob = npgfa(jset)*
ncoset(la_max(jset))
1610 n2 = npgfa(jset)*(
ncoset(la_max(jset)) -
ncoset(la_min(jset) - 1))
1611 sgfb = first_sgfa(1, jset)
1614 CALL overlap_ab(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
1615 la_max(jset), la_min(jset), npgfa(jset), rpgfa(:, jset), zeta(:, jset), &
1616 rab, sab=oint(:, :))
1618 CALL contraction(oint(:, :), owork, ca=scon_a(:, sgfa:), na=n1, ma=nsgfa(iset), &
1619 cb=scon_a(:, sgfb:), nb=n2, mb=nsgfa(jset), fscale=1.0_dp, trans=.false.)
1620 CALL block_add(
"IN", owork, nsgfa(iset), nsgfa(jset), smat, &
1621 sgfa, sgfb, trans=.false.)
1627 DEALLOCATE (oint, owork)
1629 CALL timestop(handle)
1631 END SUBROUTINE oce_overlap_matrix
1645 SUBROUTINE pm_localization(zij_fm_set, vectors, order, accuracy, unit_nr)
1647 TYPE(
cp_fm_type),
DIMENSION(:, :),
INTENT(IN) :: zij_fm_set
1649 INTEGER,
INTENT(IN) :: order
1650 REAL(kind=
dp),
INTENT(IN) :: accuracy
1651 INTEGER,
INTENT(IN) :: unit_nr
1653 INTEGER,
PARAMETER :: max_sweeps = 250
1655 INTEGER :: iatom, istate, jstate, natom, nstate, &
1657 REAL(kind=
dp) :: aij, bij, ct, ftarget, mii, mij, mjj, &
1658 st, t1, t2, theta, tolerance, tt
1659 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: fdiag
1662 CALL cp_fm_create(rmat, zij_fm_set(1, 1)%matrix_struct)
1666 ALLOCATE (fdiag(nstate))
1667 tolerance = 1.0e10_dp
1669 natom =
SIZE(zij_fm_set, 1)
1670 IF (unit_nr > 0)
THEN
1671 WRITE (unit_nr,
'(A,T30,A,T45,A,T63,A,T77,A)') &
1672 " Jacobi Localization ",
"Sweep",
"Functional",
"Gradient",
"Time"
1675 DO sweeps = 1, max_sweeps
1678 DO istate = 1, nstate
1679 DO jstate = istate + 1, nstate
1686 IF (order == 2)
THEN
1687 aij = aij + 4._dp*mij**2 - (mii - mjj)**2
1688 bij = bij + 4._dp*mij*(mii - mjj)
1689 ELSEIF (order == 4)
THEN
1690 aij = aij - mii**4 - mjj**4 + 6._dp*(mii**2 + mjj**2)*mij**2 + &
1691 mii**3*mjj + mii*mjj**3
1692 bij = bij + 4._dp*mij*(mii**3 - mjj**3)
1697 IF ((aij**2 + bij**2) < 1.e-10_dp) cycle
1698 tolerance = tolerance + bij**2
1699 theta = 0.25_dp*atan2(bij, -aij)
1706 CALL cp_fm_rot_cols(zij_fm_set(iatom, 1), istate, jstate, ct, st)
1707 CALL cp_fm_rot_rows(zij_fm_set(iatom, 1), istate, jstate, ct, st)
1714 ftarget = ftarget + sum(fdiag**order)
1716 ftarget = ftarget**(1._dp/order)
1717 tolerance = sqrt(tolerance)
1720 IF (unit_nr > 0)
THEN
1721 WRITE (unit_nr,
'(T31,I4,T39,F16.8,T55,G16.8,T71,F10.2)') sweeps, ftarget, tolerance, tt
1723 IF (tolerance < accuracy)
EXIT
1730 END SUBROUTINE pm_localization
Set of routines to: Contract integrals over primitive Gaussians Decontract (density) matrices Trace m...
Calculation of the overlap integrals over Cartesian Gaussian-type functions.
subroutine, public overlap_ab(la_max, la_min, npgfa, rpgfa, zeta, lb_max, lb_min, npgfb, rpgfb, zetb, rab, sab, dab, ddab)
Calculation of the two-center overlap integrals [a|b] over Cartesian Gaussian-type functions....
simple routine to print charges for all atomic charge methods (currently mulliken,...
subroutine, public print_atomic_charges(particle_set, qs_kind_set, scr, title, electronic_charges, atomic_charges)
generates a unified output format for atomic charges
Define the atomic kind types and their sub types.
subroutine, public get_atomic_kind(atomic_kind, fist_potential, element_symbol, name, mass, kind_number, natom, atom_list, rcov, rvdw, z, qeff, apol, cpol, mm_radius, shell, shell_active, damping)
Get attributes of an atomic kind.
Automatic generation of auxiliary basis sets of different kind.
subroutine, public create_oce_basis(oce_basis, orb_basis, lmax_oce, nbas_oce)
...
subroutine, public get_gto_basis_set(gto_basis_set, name, aliases, norm_type, kind_radius, ncgf, nset, nsgf, cgf_symbol, sgf_symbol, norm_cgf, set_radius, lmax, lmin, lx, ly, lz, m, ncgf_set, npgf, nsgf_set, nshell, cphi, pgf_radius, sphi, scon, zet, first_cgf, first_sgf, l, last_cgf, last_sgf, n, gcc, maxco, maxl, maxpgf, maxsgf_set, maxshell, maxso, nco_sum, npgf_sum, nshell_sum, maxder, short_kind_radius, npgf_seg_sum)
...
subroutine, public deallocate_gto_basis_set(gto_basis_set)
...
subroutine, public init_orb_basis_set(gto_basis_set)
Initialise a Gaussian-type orbital (GTO) basis set data set.
collects all references to literature in CP2K as new algorithms / method are included from literature...
integer, save, public knizia2013
Handles all functions related to the CELL.
various utilities that regard array of different kinds: output, allocation,... maybe it is not a good...
Defines control structures, which contain the parameters and the settings for the DFT-based calculati...
subroutine, public dbcsr_iterator_next_block(iterator, row, column, block, block_number_argument_has_been_removed, row_size, col_size, row_offset, col_offset)
...
logical function, public dbcsr_iterator_blocks_left(iterator)
...
subroutine, public dbcsr_iterator_stop(iterator)
...
subroutine, public dbcsr_copy(matrix_b, matrix_a, name, keep_sparsity, keep_imaginary)
...
subroutine, public dbcsr_get_block_p(matrix, row, col, block, found, row_size, col_size)
...
subroutine, public dbcsr_multiply(transa, transb, alpha, matrix_a, matrix_b, beta, matrix_c, first_row, last_row, first_column, last_column, first_k, last_k, retain_sparsity, filter_eps, flop)
...
subroutine, public dbcsr_replicate_all(matrix)
...
subroutine, public dbcsr_get_info(matrix, nblkrows_total, nblkcols_total, nfullrows_total, nfullcols_total, nblkrows_local, nblkcols_local, nfullrows_local, nfullcols_local, my_prow, my_pcol, local_rows, local_cols, proc_row_dist, proc_col_dist, row_blk_size, col_blk_size, row_blk_offset, col_blk_offset, distribution, name, matrix_type, group)
...
subroutine, public dbcsr_iterator_start(iterator, matrix, shared, dynamic, dynamic_byrows)
...
subroutine, public dbcsr_set(matrix, alpha)
...
subroutine, public dbcsr_release(matrix)
...
subroutine, public dbcsr_trace(matrix, trace)
Computes the trace of the given matrix, also known as the sum of its diagonal elements.
subroutine, public dbcsr_reserve_diag_blocks(matrix)
Reserves all diagonal blocks.
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_rot_rows(matrix, irow, jrow, cs, sn)
Applies a planar rotation defined by cs and sn to the i'th and j'th rows.
subroutine, public cp_fm_column_scale(matrixa, scaling)
scales column i of matrix a with scaling(i)
subroutine, public cp_fm_rot_cols(matrix, icol, jcol, cs, sn)
Applies a planar rotation defined by cs and sn to the i'th and j'th columnns.
subroutine, public cp_fm_geadd(alpha, trans, matrix_a, beta, matrix_b)
interface to BLACS geadd: matrix_b = beta*matrix_b + alpha*opt(matrix_a) where opt(matrix_a) can be e...
subroutine, public cp_fm_invert(matrix_a, matrix_inverse, det_a, eps_svd, eigval)
Inverts a cp_fm_type matrix, optionally returning the determinant of the input matrix.
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_diag(matrix, diag)
returns the diagonal elements of a fm
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_get_element(matrix, irow_global, icol_global, alpha, local)
returns an element of a fm this value is valid on every cpu using this call is expensive
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 ...
type(cp_logger_type) function, pointer, public cp_get_default_logger()
returns the default logger
routines to handle the output, The idea is to remove the decision of wheter to output and what to out...
integer function, public cp_print_key_unit_nr(logger, basis_section, print_key_path, extension, middle_name, local, log_filename, ignore_should_output, file_form, file_position, file_action, file_status, do_backup, on_file, is_new_file, mpi_io, fout)
...
subroutine, public cp_print_key_finished_output(unit_nr, logger, basis_section, print_key_path, local, ignore_should_output, on_file, mpi_io)
should be called after you finish working with a unit obtained with cp_print_key_unit_nr,...
A wrapper around pw_to_cube() which accepts particle_list_type.
subroutine, public cp_pw_to_cube(pw, unit_nr, title, particles, stride, zero_tails, silent, mpi_io)
...
Calculate intrinsic atomic orbitals and analyze wavefunctions.
subroutine, public iao_wfn_analysis(qs_env, iao_env, unit_nr, c_iao_coef, mos, bond_centers)
...
subroutine, public print_center_spread(moments, nocc, print_section, iounit)
prints charge center and spreads for all orbitals
subroutine, public iao_charges(p_matrix, charges)
compute the atomic charges (orthogonal basis)
Calculate ntrinsic atomic orbitals and analyze wavefunctions.
Defines the basic variable types.
integer, parameter, public dp
integer, parameter, public default_string_length
integer, parameter, public default_path_length
An array-based list which grows on demand. When the internal array is full, a new array of twice the ...
Machine interface based on Fortran 2003 and POSIX.
real(kind=dp) function, public m_walltime()
returns time from a real-time clock, protected against rolling early/easily
Definition of mathematical constants and functions.
real(kind=dp), parameter, public twopi
Collection of simple mathematical functions and subroutines.
subroutine, public jacobi(a, d, v)
Jacobi matrix diagonalization. The eigenvalues are returned in vector d and the eigenvectors are retu...
subroutine, public invmat_symm(a, potrf, uplo)
returns inverse of real symmetric, positive definite matrix
Interface to the message passing library MPI.
generate or use from input minimal basis set
subroutine, public create_minbas_set(qs_env, unit_nr, basis_type, primitive)
...
Functions handling the MOLDEN format. Split from mode_selective.
subroutine, public write_mos_molden(mos, qs_kind_set, particle_set, print_section)
Write out the MOs in molden format for visualisation.
Provides Cartesian and spherical orbital pointers and indices.
integer, dimension(:), allocatable, public ncoset
basic linear algebra operations for full matrixes
represent a simple array based list of the given type
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.
container for various plainwaves related things
subroutine, public pw_env_get(pw_env, pw_pools, cube_info, gridlevel_info, auxbas_pw_pool, auxbas_grid, auxbas_rs_desc, auxbas_rs_grid, rs_descs, rs_grids, xc_pw_pool, vdw_pw_pool, poisson_env, interp_section)
returns the various attributes of the pw env
Manages a pool of grids (to be used for example as tmp objects), but can also be used to instantiate ...
Calculate the plane wave density by collocating the primitive Gaussian functions (pgf).
subroutine, public calculate_wavefunction(mo_vectors, ivector, rho, rho_gspace, atomic_kind_set, qs_kind_set, cell, dft_control, particle_set, pw_env, basis_type)
maps a given wavefunction on the grid
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_pp, 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, harris_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, eeq, rhs)
Get the QUICKSTEP environment.
Calculate the interaction radii for the operator matrix calculation.
subroutine, public init_interaction_radii_orb_basis(orb_basis_set, eps_pgf_orb, eps_pgf_short)
...
Define the quickstep kind type and their sub types.
subroutine, public get_qs_kind(qs_kind, basis_set, basis_type, ncgf, nsgf, all_potential, tnadd_potential, gth_potential, sgp_potential, upf_potential, se_parameter, dftb_parameter, xtb_parameter, dftb3_param, zatom, zeff, elec_conf, mao, lmax_dftb, alpha_core_charge, ccore_charge, core_charge, core_charge_radius, paw_proj_set, paw_atom, hard_radius, hard0_radius, max_rad_local, covalent_radius, vdw_radius, gpw_type_forced, harmonics, max_iso_not0, max_s_harm, grid_atom, ngrid_ang, ngrid_rad, lmax_rho0, dft_plus_u_atom, l_of_dft_plus_u, n_of_dft_plus_u, u_minus_j, u_of_dft_plus_u, j_of_dft_plus_u, alpha_of_dft_plus_u, beta_of_dft_plus_u, j0_of_dft_plus_u, occupation_of_dft_plus_u, dispersion, bs_occupation, magnetization, no_optimize, addel, laddel, naddel, orbitals, max_scf, eps_scf, smear, u_ramping, u_minus_j_target, eps_u_ramping, init_u_ramping_each_scf, reltmat, ghost, floating, name, element_symbol, pao_basis_size, pao_model_file, pao_potentials, pao_descriptors, nelec)
Get attributes of an atomic kind.
subroutine, public get_ks_env(ks_env, v_hartree_rspace, s_mstruct_changed, rho_changed, potential_changed, forces_up_to_date, complex_ks, matrix_h, matrix_h_im, matrix_ks, matrix_ks_im, matrix_vxc, kinetic, matrix_s, matrix_s_ri_aux, matrix_w, matrix_p_mp2, matrix_p_mp2_admm, matrix_h_kp, matrix_h_im_kp, matrix_ks_kp, matrix_vxc_kp, kinetic_kp, matrix_s_kp, matrix_w_kp, matrix_s_ri_aux_kp, matrix_ks_im_kp, rho, rho_xc, vppl, rho_core, rho_nlcc, rho_nlcc_g, vee, neighbor_list_id, sab_orb, sab_all, sac_ae, sac_ppl, sac_lri, sap_ppnl, sap_oce, sab_lrc, sab_se, sab_xtbe, sab_tbe, sab_core, sab_xb, sab_xtb_pp, sab_xtb_nonbond, sab_vdw, sab_scp, sab_almo, sab_kp, sab_kp_nosym, task_list, task_list_soft, kpoints, do_kpoints, atomic_kind_set, qs_kind_set, cell, cell_ref, use_ref_cell, particle_set, energy, force, local_particles, local_molecules, molecule_kind_set, molecule_set, subsys, cp_subsys, virial, results, atprop, nkind, natom, dft_control, dbcsr_dist, distribution_2d, pw_env, para_env, blacs_env, nelectron_total, nelectron_spin)
...
Some utilities for the construction of the localization environment.
subroutine, public compute_berry_operator(qs_env, cell, op_sm_set, dim_op)
Computes the Berry operator for periodic systems used to define the spread of the MOS Here the matrix...
Localization methods such as 2x2 Jacobi rotations Steepest Decents Conjugate Gradient.
subroutine, public rotate_orbitals(rmat, vectors)
...
subroutine, public initialize_weights(cell, weights)
...
subroutine, public scdm_qrfact(vectors)
...
collects routines that perform operations directly related to MOs
subroutine, public make_basis_lowdin(vmatrix, ncol, matrix_s)
return a set of S orthonormal vectors (C^T S C == 1) where a Loedwin transformation is applied to kee...
Definition and initialisation of the mo data type.
subroutine, public set_mo_set(mo_set, maxocc, homo, lfomo, nao, nelectron, n_el_f, nmo, eigenvalues, occupation_numbers, uniform_occupation, kts, mu, flexible_electron_count)
Set the components of a MO set data structure.
subroutine, public allocate_mo_set(mo_set, nao, nmo, nelectron, n_el_f, maxocc, flexible_electron_count)
Allocates a mo set and partially initializes it (nao,nmo,nelectron, and flexible_electron_count are v...
subroutine, public deallocate_mo_set(mo_set)
Deallocate a wavefunction data structure.
subroutine, public get_mo_set(mo_set, maxocc, homo, lfomo, nao, nelectron, n_el_f, nmo, eigenvalues, occupation_numbers, mo_coeff, mo_coeff_b, uniform_occupation, kts, mu, flexible_electron_count)
Get the components of a MO set data structure.
subroutine, public init_mo_set(mo_set, fm_pool, fm_ref, fm_struct, name)
initializes an allocated mo_set. eigenvalues, mo_coeff, occupation_numbers are valid only after this ...
Calculates the moment integrals <a|r^m|b> and <a|r x d/dr|b>
subroutine, public build_local_moment_matrix(qs_env, moments, nmoments, ref_point, ref_points, basis_type)
...
Define the neighbor list data types and the corresponding functionality.
subroutine, public release_neighbor_list_sets(nlists)
releases an array of neighbor_list_sets
Generate the atomic neighbor lists.
subroutine, public setup_neighbor_list(ab_list, basis_set_a, basis_set_b, qs_env, mic, symmetric, molecular, operator_type)
Build a neighborlist.
Calculation of overlap matrix, its derivatives and forces.
subroutine, public build_overlap_matrix_simple(ks_env, matrix_s, basis_set_list_a, basis_set_list_b, sab_nl)
Calculation of the overlap matrix over Cartesian Gaussian functions.
types that represent a quickstep subsys
subroutine, public qs_subsys_get(subsys, atomic_kinds, atomic_kind_set, particles, particle_set, local_particles, molecules, molecule_set, molecule_kinds, molecule_kind_set, local_molecules, para_env, colvar_p, shell_particles, core_particles, gci, multipoles, natom, nparticle, ncore, nshell, nkind, atprop, virial, results, cell, cell_ref, use_ref_cell, energy, force, qs_kind_set, cp_subsys, nelectron_total, nelectron_spin)
...
Provides all information about an atomic kind.
Type defining parameters related to the simulation cell.
represent a pointer to a 2d array
keeps the information about the structure of a full matrix
type of a logger, at the moment it contains just a print level starting at which level it should be l...
represent a list of objects
contained for different pw related things
Manages a pool of grids (to be used for example as tmp objects), but can also be used to instantiate ...
Provides all information about a quickstep kind.
calculation environment to calculate the ks matrix, holds all the needed vars. assumes that the core ...