121#include "./base/base_uses.f90"
126 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'iao_analysis'
131 MODULE PROCEDURE iao_calculate_dmat_diag, &
132 iao_calculate_dmat_full
151 INTEGER,
INTENT(IN) :: unit_nr
152 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:), &
153 OPTIONAL :: c_iao_coef
154 TYPE(
mo_set_type),
DIMENSION(:),
OPTIONAL,
POINTER :: mos
155 REAL(kind=
dp),
DIMENSION(:, :, :),
OPTIONAL :: bond_centers
157 CHARACTER(len=*),
PARAMETER :: routinen =
'iao_wfn_analysis'
159 CHARACTER(LEN=2) :: element_symbol
160 CHARACTER(LEN=default_string_length) :: bname
161 INTEGER :: handle, i, iatom, ikind, isgf, ispin, &
162 nao, natom, nimages, nkind, no, norb, &
163 nref, ns, nsgf, nspin, nvec, nx, order
164 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: first_sgf, last_sgf, nsgfat
165 INTEGER,
DIMENSION(2) :: nocc
166 LOGICAL :: cubes_iao, cubes_ibo, molden_iao, &
167 molden_ibo, uniform_occupation
168 REAL(kind=
dp) :: fin, fout, t1, t2, trace, zval
169 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: fdiag
170 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: mcharge
171 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: moments
172 REAL(kind=
dp),
DIMENSION(:),
POINTER :: occupation_numbers
178 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:) :: c_loc_orb, ciao, cloc, cvec, iao_coef
179 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:, :) :: zij_atom
181 TYPE(
dbcsr_p_type),
DIMENSION(:),
POINTER :: sref, sro, sxo
182 TYPE(
dbcsr_p_type),
DIMENSION(:, :),
POINTER :: matrix_s
189 TYPE(
mo_set_type),
ALLOCATABLE,
DIMENSION(:) :: mo_iao, mo_loc
192 POINTER :: sro_list, srr_list, sxo_list
194 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
198 ibo_cc_section, ibo_cubes_section, &
202 cpassert(iao_env%do_iao)
205 NULLIFY (particle_set)
206 CALL get_qs_env(qs_env, dft_control=dft_control, particle_set=particle_set)
207 nspin = dft_control%nspins
208 nimages = dft_control%nimages
209 IF (nimages > 1)
THEN
210 IF (unit_nr > 0)
THEN
211 WRITE (unit=unit_nr, fmt=
"(T2,A)") &
212 "K-Points: Intrinsic Atomic Orbitals Analysis not available."
215 IF (nimages > 1)
RETURN
217 CALL timeset(routinen, handle)
219 IF (unit_nr > 0)
THEN
220 WRITE (unit_nr,
'(/,T2,A)')
'!-----------------------------------------------------------------------------!'
221 WRITE (unit=unit_nr, fmt=
"(T24,A)")
"INTRINSIC ATOMIC ORBITALS ANALYSIS"
222 WRITE (unit=unit_nr, fmt=
"(T13,A)")
"G. Knizia, J. Chem. Theory Comput. 9, 4834-4843 (2013)"
223 WRITE (unit_nr,
'(T2,A)')
'!-----------------------------------------------------------------------------!'
228 iao_molden_section => iao_env%iao_molden_section
229 iao_cubes_section => iao_env%iao_cubes_section
230 ibo_molden_section => iao_env%ibo_molden_section
231 ibo_cubes_section => iao_env%ibo_cubes_section
232 ibo_cc_section => iao_env%ibo_cc_section
236 IF (
ASSOCIATED(iao_molden_section))
THEN
240 IF (
ASSOCIATED(iao_cubes_section))
THEN
244 IF (
ASSOCIATED(ibo_molden_section))
THEN
248 IF (
ASSOCIATED(ibo_cubes_section))
THEN
257 smat => matrix_s(1, 1)%matrix
259 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
260 nkind =
SIZE(qs_kind_set)
261 ALLOCATE (ref_basis_set_list(nkind), orb_basis_set_list(nkind))
263 qs_kind => qs_kind_set(ikind)
264 NULLIFY (ref_basis_set_list(ikind)%gto_basis_set)
265 NULLIFY (orb_basis_set_list(ikind)%gto_basis_set)
266 NULLIFY (refbasis, orbbasis)
267 CALL get_qs_kind(qs_kind=qs_kind, basis_set=orbbasis, basis_type=
"ORB")
268 IF (
ASSOCIATED(orbbasis)) orb_basis_set_list(ikind)%gto_basis_set => orbbasis
269 CALL get_qs_kind(qs_kind=qs_kind, basis_set=refbasis, basis_type=
"MIN")
270 IF (
ASSOCIATED(refbasis)) ref_basis_set_list(ikind)%gto_basis_set => refbasis
274 NULLIFY (srr_list, sro_list)
282 ref_basis_set_list, ref_basis_set_list, srr_list)
284 ref_basis_set_list, orb_basis_set_list, sro_list)
286 IF (
PRESENT(mos))
THEN
295 IF (
PRESENT(mos))
THEN
301 CALL dbcsr_get_info(sro(1)%matrix, nfullrows_total=nref, nfullcols_total=nao)
305 CALL cp_fm_struct_create(fm_struct, context=mo_coeff%matrix_struct%context, nrow_global=nref, &
306 ncol_global=nao, para_env=mo_coeff%matrix_struct%para_env)
310 CALL cp_fm_struct_create(fm_struct, context=mo_coeff%matrix_struct%context, nrow_global=nao, &
311 ncol_global=nref, para_env=mo_coeff%matrix_struct%para_env)
315 CALL iao_projectors(smat, sref(1)%matrix, sro(1)%matrix, p_orb_ref, p_ref_orb, iao_env%eps_svd)
320 CALL get_mo_set(my_mos(ispin), mo_coeff=mo_coeff, nmo=norb, uniform_occupation=uniform_occupation, &
321 occupation_numbers=occupation_numbers)
322 IF (uniform_occupation)
THEN
327 IF (occupation_numbers(i) > iao_env%eps_occ)
THEN
337 ALLOCATE (iao_coef(nspin), cvec(nspin))
339 CALL get_mo_set(my_mos(ispin), mo_coeff=mo_coeff)
343 CALL cp_fm_struct_create(fm_struct, ncol_global=nvec, template_fmstruct=mo_coeff%matrix_struct)
349 CALL cp_fm_struct_create(fm_struct, ncol_global=nref, template_fmstruct=mo_coeff%matrix_struct)
353 CALL intrinsic_ao_calc(smat, p_orb_ref, p_ref_orb, cvec(ispin), iao_coef(ispin))
357 IF (iao_env%do_charges)
THEN
359 ALLOCATE (ciao(nspin))
361 CALL get_mo_set(my_mos(ispin), mo_coeff=mo_coeff, nao=nao, nmo=norb)
364 CALL cp_fm_struct_create(fm_struct, nrow_global=nref, template_fmstruct=mo_coeff%matrix_struct)
369 CALL parallel_gemm(
'T',
'N', nref, norb, nao, 1.0_dp, iao_coef(ispin), smo, 0.0_dp, ciao(ispin))
374 IF (unit_nr > 0)
THEN
375 WRITE (unit_nr,
'(/,T2,A)')
'Intrinsic AO Population Analysis '
377 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set, natom=natom)
378 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set)
379 ALLOCATE (mcharge(natom, nspin))
383 uniform_occupation=uniform_occupation, &
384 occupation_numbers=occupation_numbers)
391 IF (unit_nr > 0)
THEN
392 WRITE (unit_nr,
'(T2,A,I2,T66,F15.4)')
'Number of Electrons: Trace(Piao) Spin ', ispin, trace
397 CALL print_atomic_charges(particle_set, qs_kind_set, unit_nr,
"Intrinsic Atomic Orbital Charges", &
398 electronic_charges=mcharge)
411 DEALLOCATE (orb_basis_set_list)
413 IF (iao_env%do_oce)
THEN
415 IF (unit_nr > 0)
THEN
416 WRITE (unit_nr,
'(T2,A)')
"IAO One-Center Expansion: OCE Basis Set"
418 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
419 nkind =
SIZE(qs_kind_set)
420 ALLOCATE (oce_basis_set_list(nkind), orb_basis_set_list(nkind))
422 qs_kind => qs_kind_set(ikind)
423 NULLIFY (orb_basis_set_list(ikind)%gto_basis_set)
425 CALL get_qs_kind(qs_kind=qs_kind, basis_set=orbbasis, basis_type=
"ORB")
426 IF (
ASSOCIATED(orbbasis)) orb_basis_set_list(ikind)%gto_basis_set => orbbasis
429 orbbasis => orb_basis_set_list(ikind)%gto_basis_set
430 cpassert(
ASSOCIATED(orbbasis))
432 CALL create_oce_basis(ocebasis, orbbasis, iao_env%lmax_oce, iao_env%nbas_oce)
435 oce_basis_set_list(ikind)%gto_basis_set => ocebasis
436 IF (unit_nr > 0)
THEN
437 qs_kind => qs_kind_set(ikind)
438 CALL get_qs_kind(qs_kind, zeff=zval, element_symbol=element_symbol)
440 WRITE (unit_nr,
'(T2,A,A,T14,A,I4,T40,A,A30)')
"Kind: ", element_symbol,
"NBasFun: ", nsgf, &
441 "OCE Basis: ", adjustl(trim(bname))
444 IF (unit_nr > 0)
WRITE (unit_nr, *)
446 ALLOCATE (smat_kind(nkind))
448 ocebasis => oce_basis_set_list(ikind)%gto_basis_set
450 ALLOCATE (smat_kind(ikind)%array(nsgf, nsgf))
452 CALL oce_overlap_matrix(smat_kind, oce_basis_set_list)
454 NULLIFY (sxo, sxo_list)
458 oce_basis_set_list, orb_basis_set_list, sxo_list)
462 ALLOCATE (oce_atom(natom, nspin))
463 CALL iao_oce_expansion(qs_env, oce_basis_set_list, smat_kind, sxo, iao_coef, oce_atom, unit_nr)
466 ocebasis => oce_basis_set_list(ikind)%gto_basis_set
469 DEALLOCATE (oce_basis_set_list, orb_basis_set_list)
474 DEALLOCATE (smat_kind(ikind)%array)
476 DEALLOCATE (smat_kind)
479 DEALLOCATE (oce_atom(iatom, ispin)%array)
482 DEALLOCATE (oce_atom)
487 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
489 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set)
490 IF (unit_nr > 0)
THEN
491 WRITE (unit_nr,
'(T2,A)')
' Write IAO in MOLDEN Format'
493 ALLOCATE (mo_iao(nspin))
496 CALL allocate_mo_set(mo_iao(ispin), nao, nref, nref, 0.0_dp, 1.0_dp, 0.0_dp)
497 CALL init_mo_set(mo_iao(ispin), fm_ref=iao_coef(ispin), name=
"iao_set")
498 CALL cp_fm_to_fm(iao_coef(ispin), mo_iao(ispin)%mo_coeff)
500 mo_iao(ispin)%occupation_numbers = 1.0_dp
503 CALL write_mos_molden(mo_iao, qs_kind_set, particle_set, iao_molden_section, cell=cell, qs_env=qs_env)
510 IF (unit_nr > 0)
THEN
511 WRITE (unit_nr,
'(T2,A)')
' Write IAO as CUBE Files'
514 CALL print_iao_cubes(qs_env, iao_cubes_section, iao_coef, ref_basis_set_list)
518 IF (iao_env%do_bondorbitals)
THEN
519 IF (unit_nr > 0)
THEN
520 WRITE (unit_nr,
'(/,T2,A)')
'Intrinsic Bond Orbital Generation'
523 ALLOCATE (ciao(nspin))
525 CALL get_mo_set(my_mos(ispin), mo_coeff=mo_coeff, nao=nao, nmo=norb)
528 CALL cp_fm_struct_create(fm_struct, nrow_global=nref, template_fmstruct=mo_coeff%matrix_struct)
533 CALL parallel_gemm(
'T',
'N', nref, norb, nao, 1.0_dp, iao_coef(ispin), smo, 0.0_dp, ciao(ispin))
539 ALLOCATE (cloc(nspin), c_loc_orb(nspin))
543 template_fmstruct=ciao(ispin)%matrix_struct)
546 CALL cp_fm_to_fm(ciao(ispin), cloc(ispin), ncol=nocc(ispin))
549 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set, natom=natom)
550 ALLOCATE (first_sgf(natom), last_sgf(natom), nsgfat(natom))
551 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set)
552 CALL get_particle_set(particle_set, qs_kind_set, first_sgf=first_sgf, last_sgf=last_sgf, &
553 nsgf=nsgfat, basis=ref_basis_set_list)
556 cpabort(
"IAO localization operator NYA")
559 cpabort(
"IAO energy weight localization NYA")
565 ALLOCATE (zij_atom(natom, 1), fdiag(nvec))
568 template_fmstruct=cloc(ispin)%matrix_struct)
571 isgf = first_sgf(iatom)
572 CALL parallel_gemm(
'T',
'N', nvec, nvec, nsgfat(iatom), 1.0_dp, cloc(ispin), cloc(ispin), &
573 0.0_dp, zij_atom(iatom, 1), &
574 a_first_col=1, a_first_row=isgf, b_first_col=1, b_first_row=isgf)
583 fin = fin + sum(fdiag**order)
585 fin = fin**(1._dp/order)
590 isgf = first_sgf(iatom)
591 CALL parallel_gemm(
'T',
'N', nvec, nvec, nsgfat(iatom), 1.0_dp, cloc(ispin), cloc(ispin), &
592 0.0_dp, zij_atom(iatom, 1), &
593 a_first_col=1, a_first_row=isgf, b_first_col=1, b_first_row=isgf)
598 fout = fout + sum(fdiag**order)
600 fout = fout**(1._dp/order)
603 IF (unit_nr > 0)
THEN
604 WRITE (unit_nr,
'(T2,A,F14.8,A,F14.8,A,F8.2)') &
605 'SCDM pre-localization: fin=', fin,
" fout=", fout,
" Time=", t2 - t1
608 CALL pm_localization(zij_atom, cloc(ispin), order, 1.e-12_dp, unit_nr)
614 template_fmstruct=cloc(ispin)%matrix_struct)
617 CALL parallel_gemm(
'N',
'N', nao, nvec, nref, 1.0_dp, iao_coef(ispin), cloc(ispin), &
618 0.0_dp, c_loc_orb(ispin))
621 DEALLOCATE (first_sgf, last_sgf, nsgfat)
624 IF (iao_env%do_center)
THEN
625 IF (unit_nr > 0)
THEN
626 WRITE (unit_nr,
'(T2,A)')
' Calculate Localized Orbital Centers and Spread'
627 IF (iao_env%pos_periodic)
THEN
628 WRITE (unit_nr,
'(T2,A)')
' Use Berry Phase Position Operator'
630 WRITE (unit_nr,
'(T2,A)')
' Use Local Position Operator'
635 ALLOCATE (moments(5, nvec, nspin))
637 IF (iao_env%pos_periodic)
THEN
638 CALL center_spread_berry(qs_env, c_loc_orb, moments)
640 CALL center_spread_loc(qs_env, c_loc_orb, moments)
643 IF (
ASSOCIATED(ibo_cc_section))
THEN
649 IF (
PRESENT(bond_centers))
THEN
650 nx =
SIZE(bond_centers, 1)
651 no =
SIZE(bond_centers, 2)
652 ns =
SIZE(bond_centers, 3)
654 cpassert(ns == nspin)
657 bond_centers(1:nx, 1:nvec, 1:ns) = moments(1:nx, 1:nvec, 1:ns)
663 CALL get_qs_env(qs_env=qs_env, qs_kind_set=qs_kind_set)
664 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set)
665 IF (unit_nr > 0)
THEN
666 WRITE (unit_nr,
'(T2,A)')
' Write IBO in MOLDEN Format'
668 ALLOCATE (mo_loc(nspin))
672 CALL allocate_mo_set(mo_loc(ispin), nao, nvec, nvec, 0.0_dp, 1.0_dp, 0.0_dp)
673 CALL init_mo_set(mo_loc(ispin), fm_ref=c_loc_orb(ispin), name=
"ibo_orb")
674 CALL cp_fm_to_fm(c_loc_orb(ispin), mo_loc(ispin)%mo_coeff)
676 mo_loc(ispin)%occupation_numbers = 1.0_dp
679 CALL write_mos_molden(mo_loc, qs_kind_set, particle_set, ibo_molden_section, cell=cell, qs_env=qs_env)
687 IF (unit_nr > 0)
THEN
688 WRITE (unit_nr,
'(T2,A)')
' Write IBO on CUBE files'
691 CALL print_ibo_cubes(qs_env, ibo_cubes_section, c_loc_orb)
694 IF (
PRESENT(mos) .AND.
ALLOCATED(c_loc_orb))
THEN
697 CALL get_mo_set(mos(ispin), mo_coeff=mo_coeff)
699 CALL cp_fm_to_fm(c_loc_orb(ispin), mo_coeff, ncol=nvec)
704 DEALLOCATE (ref_basis_set_list)
706 IF (
PRESENT(c_iao_coef))
THEN
708 ALLOCATE (c_iao_coef(nspin))
710 CALL cp_fm_create(c_iao_coef(ispin), iao_coef(ispin)%matrix_struct)
711 CALL cp_fm_to_fm(iao_coef(ispin), c_iao_coef(ispin))
716 IF (unit_nr > 0)
THEN
717 WRITE (unit_nr,
'(T2,A)') &
718 '!----------------------------END OF IAO ANALYSIS------------------------------!'
721 CALL timestop(handle)
734 SUBROUTINE iao_projectors(smat, sref, s_r_o, p_o_r, p_r_o, eps_svd)
735 TYPE(
dbcsr_type),
INTENT(INOUT) :: smat, sref, s_r_o
736 TYPE(
cp_fm_type),
INTENT(INOUT) :: p_o_r, p_r_o
737 REAL(kind=
dp),
INTENT(IN) :: eps_svd
739 CHARACTER(len=*),
PARAMETER :: routinen =
'iao_projectors'
741 INTEGER :: handle, norb, nref
745 CALL timeset(routinen, handle)
753 template_fmstruct=p_r_o%matrix_struct)
759 CALL parallel_gemm(
'N',
'T', norb, nref, norb, 1.0_dp, fm_inv, fm_sro, 0.0_dp, p_o_r)
765 template_fmstruct=p_r_o%matrix_struct)
771 CALL parallel_gemm(
'N',
'N', nref, norb, nref, 1.0_dp, fm_inv, fm_sro, 0.0_dp, p_r_o)
777 CALL timestop(handle)
779 END SUBROUTINE iao_projectors
789 SUBROUTINE intrinsic_ao_calc(smat, p_o_r, p_r_o, cvec, avec)
791 TYPE(
cp_fm_type),
INTENT(INOUT) :: p_o_r, p_r_o, cvec, avec
793 CHARACTER(len=*),
PARAMETER :: routinen =
'intrinsic_ao_calc'
795 INTEGER :: handle, nao, norb, nref
799 CALL timeset(routinen, handle)
808 template_fmstruct=cvec%matrix_struct)
812 CALL parallel_gemm(
'N',
'N', nref, norb, nao, 1.0_dp, p_r_o, cvec, 0.0_dp, pc)
814 CALL parallel_gemm(
'N',
'N', nao, norb, nref, 1.0_dp, p_o_r, pc, 0.0_dp, ctvec)
823 template_fmstruct=cvec%matrix_struct)
827 CALL parallel_gemm(
'T',
'N', norb, nref, nao, 1.0_dp, sct, p_o_r, 0.0_dp, pc)
830 template_fmstruct=cvec%matrix_struct)
833 CALL parallel_gemm(
'N',
'N', nao, nref, norb, 1.0_dp, ctvec, pc, 0.0_dp, vec1)
835 CALL parallel_gemm(
'T',
'N', norb, nref, nao, 1.0_dp, sc, vec1, 0.0_dp, pc)
836 CALL parallel_gemm(
'N',
'N', nao, nref, norb, 1.0_dp, cvec, pc, 0.0_dp, avec)
838 CALL cp_fm_geadd(1.0_dp,
'N', p_o_r, -1.0_dp, vec1)
842 CALL parallel_gemm(
'T',
'N', norb, nref, nao, 1.0_dp, sc, vec1, 0.0_dp, pc)
843 CALL parallel_gemm(
'N',
'N', nao, nref, norb, -1.0_dp, cvec, pc, 1.0_dp, avec)
854 CALL timestop(handle)
856 END SUBROUTINE intrinsic_ao_calc
865 SUBROUTINE iao_calculate_dmat_diag(cvec, density_matrix, occupation, uniform_occupation)
869 REAL(KIND=
dp),
DIMENSION(:),
INTENT(IN) :: occupation
870 LOGICAL,
INTENT(IN) :: uniform_occupation
872 CHARACTER(len=*),
PARAMETER :: routineN =
'iao_calculate_dmat_diag'
874 INTEGER :: handle, ncol
875 REAL(KIND=
dp) :: alpha
878 CALL timeset(routinen, handle)
883 IF (.NOT. uniform_occupation)
THEN
889 matrix_v=cvec, matrix_g=fm_tmp, &
890 ncol=ncol, alpha=alpha)
893 alpha = occupation(1)
895 matrix_v=cvec, ncol=ncol, alpha=alpha)
898 CALL timestop(handle)
900 END SUBROUTINE iao_calculate_dmat_diag
909 SUBROUTINE iao_calculate_dmat_full(cvec, density_matrix, weight, occmat)
913 REAL(KIND=
dp),
DIMENSION(:),
INTENT(IN) :: weight
916 CHARACTER(len=*),
PARAMETER :: routinen =
'iao_calculate_dmat_full'
918 INTEGER :: handle, ic, jc, ncol
919 REAL(kind=
dp) :: alpha
923 CALL timeset(routinen, handle)
928 template_fmstruct=cvec%matrix_struct)
935 CALL cp_fm_to_fm(cvec, fm1, ncol=1, source_start=ic, target_start=1)
937 CALL cp_fm_to_fm(cvec, fm2, ncol=1, source_start=jc, target_start=1)
939 alpha = weight(ic)*alpha
941 alpha=alpha, symmetry_mode=1)
947 CALL timestop(handle)
949 END SUBROUTINE iao_calculate_dmat_full
958 REAL(kind=
dp),
DIMENSION(:) :: charges
960 INTEGER :: i, iblock_col, iblock_row
961 REAL(kind=
dp) :: trace
962 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: p_block
972 cpassert(iblock_row == iblock_col)
974 DO i = 1,
SIZE(p_block, 1)
975 trace = trace + p_block(i, i)
977 charges(iblock_row) = trace
982 CALL group%sum(charges)
993 SUBROUTINE print_iao_cubes(qs_env, print_section, iao_coef, basis_set_list)
996 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: iao_coef
999 CHARACTER(LEN=default_path_length) :: filename, title
1000 INTEGER :: i, i_rep, ispin, ivec, iw, j, n_rep, &
1001 nat, natom, norb, nspins, nstart
1002 INTEGER,
DIMENSION(:),
POINTER :: atom_list, blk_sizes, first_bas, stride
1014 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1021 CALL get_qs_env(qs_env=qs_env, atomic_kind_set=atomic_kind_set, qs_kind_set=qs_kind_set, &
1022 subsys=subsys, cell=cell, particle_set=particle_set, pw_env=pw_env, dft_control=dft_control)
1026 ALLOCATE (blk_sizes(natom), first_bas(0:natom))
1027 CALL get_particle_set(particle_set, qs_kind_set, nsgf=blk_sizes, basis=basis_set_list)
1030 first_bas(i) = first_bas(i - 1) + blk_sizes(i)
1033 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
1034 CALL auxbas_pw_pool%create_pw(wf_r)
1035 CALL auxbas_pw_pool%create_pw(wf_g)
1037 nspins =
SIZE(iao_coef)
1038 nstart = min(1, n_rep)
1040 DO ispin = 1, nspins
1041 DO i_rep = nstart, n_rep
1043 IF (i_rep == 0)
THEN
1047 nat =
SIZE(atom_list)
1050 IF (i_rep == 0)
THEN
1055 cpassert(j >= 1 .AND. j <= natom)
1056 DO ivec = first_bas(j - 1) + 1, first_bas(j)
1057 WRITE (filename,
'(a4,I5.5,a1,I1.1)')
"IAO_", ivec,
"_", ispin
1058 WRITE (title, *)
"Intrinsic Atomic Orbitals ", ivec,
" atom ", j,
" spin ", ispin
1061 middle_name=trim(filename), file_position=
"REWIND", log_filename=.false., &
1064 cell, dft_control, particle_set, pw_env)
1065 CALL cp_pw_to_cube(wf_r, iw, title, particles=particles, stride=stride, mpi_io=mpi_io)
1071 DEALLOCATE (blk_sizes, first_bas)
1072 CALL auxbas_pw_pool%give_back_pw(wf_r)
1073 CALL auxbas_pw_pool%give_back_pw(wf_g)
1075 END SUBROUTINE print_iao_cubes
1083 SUBROUTINE print_ibo_cubes(qs_env, print_section, ibo_coef)
1086 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: ibo_coef
1088 CHARACTER(LEN=default_path_length) :: filename, title
1089 INTEGER :: i, i_rep, ispin, iw, j, n_rep, norb, &
1090 nspins, nstart, nstate
1091 INTEGER,
DIMENSION(:),
POINTER :: state_list, stride
1103 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1106 cpassert(
ASSOCIATED(print_section))
1112 CALL get_qs_env(qs_env=qs_env, atomic_kind_set=atomic_kind_set, qs_kind_set=qs_kind_set, &
1113 subsys=subsys, cell=cell, particle_set=particle_set, pw_env=pw_env, dft_control=dft_control)
1116 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
1117 CALL auxbas_pw_pool%create_pw(wf_r)
1118 CALL auxbas_pw_pool%create_pw(wf_g)
1120 nspins =
SIZE(ibo_coef)
1121 nstart = min(1, n_rep)
1123 DO ispin = 1, nspins
1124 DO i_rep = nstart, n_rep
1126 IF (i_rep == 0)
THEN
1130 nstate =
SIZE(state_list)
1133 IF (i_rep == 0)
THEN
1138 cpassert(j >= 1 .AND. j <= norb)
1139 WRITE (filename,
'(a4,I5.5,a1,I1.1)')
"IBO_", j,
"_", ispin
1140 WRITE (title, *)
"Intrinsic Atomic Orbitals ", j,
" spin ", ispin
1143 middle_name=trim(filename), file_position=
"REWIND", log_filename=.false., &
1146 cell, dft_control, particle_set, pw_env)
1147 CALL cp_pw_to_cube(wf_r, iw, title, particles=particles, stride=stride, mpi_io=mpi_io)
1153 CALL auxbas_pw_pool%give_back_pw(wf_r)
1154 CALL auxbas_pw_pool%give_back_pw(wf_g)
1156 END SUBROUTINE print_ibo_cubes
1166 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(IN) :: moments
1167 INTEGER,
DIMENSION(:),
INTENT(IN) :: nocc
1169 INTEGER,
INTENT(IN),
OPTIONAL :: iounit
1171 CHARACTER(LEN=default_path_length) :: filename
1172 INTEGER :: is, ispin, iw, nspin
1176 nspin =
SIZE(moments, 3)
1178 IF (
PRESENT(print_section))
THEN
1179 WRITE (filename,
'(A18,I1.1)')
"IBO_CENTERS_SPREAD"
1181 middle_name=trim(filename), file_position=
"REWIND", log_filename=.false.)
1182 ELSEIF (
PRESENT(iounit))
THEN
1189 WRITE (iw,
"(T2,A,i1)")
"Intrinsic Bond Orbitals: Centers and Spread for Spin ", ispin
1190 WRITE (iw,
"(A7,T30,A6,T68,A7)")
"State",
"Center",
"Spreads"
1191 DO is = 1, nocc(ispin)
1192 WRITE (iw,
"(i7,3F15.8,8X,2F10.5)") is, moments(:, is, ispin)
1196 IF (
PRESENT(print_section))
THEN
1208 SUBROUTINE center_spread_loc(qs_env, c_loc_orb, moments)
1210 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: c_loc_orb
1211 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: moments
1213 CHARACTER(len=*),
PARAMETER :: routinen =
'center_spread_loc'
1214 INTEGER,
DIMENSION(6),
PARAMETER ::
list = [1, 2, 3, 4, 7, 9]
1216 INTEGER :: handle, i, iop, iorb, ispin, nao, norb, &
1218 REAL(kind=
dp) :: xmii
1219 REAL(kind=
dp),
DIMENSION(3) :: rpoint
1224 TYPE(
dbcsr_p_type),
DIMENSION(:, :),
POINTER :: matrix_s
1227 CALL timeset(routinen, handle)
1229 CALL get_qs_env(qs_env=qs_env, matrix_s_kp=matrix_s)
1230 smat => matrix_s(1, 1)%matrix
1232 nspin =
SIZE(c_loc_orb)
1235 ALLOCATE (dipmat(9))
1237 ALLOCATE (dipmat(i)%matrix)
1239 CALL dbcsr_set(dipmat(i)%matrix, 0.0_dp)
1245 CALL cp_fm_get_info(c_loc_orb(ispin), nrow_global=nao, ncol_global=norb)
1246 CALL cp_fm_create(ocvec, c_loc_orb(ispin)%matrix_struct)
1249 template_fmstruct=c_loc_orb(ispin)%matrix_struct)
1254 omat => dipmat(iop)%matrix
1256 CALL parallel_gemm(
'T',
'N', norb, norb, nao, 1.0_dp, c_loc_orb(ispin), ocvec, &
1261 moments(iop, iorb, ispin) = moments(iop, iorb, ispin) + xmii
1262 moments(4, iorb, ispin) = moments(4, iorb, ispin) - xmii**2
1264 moments(4, iorb, ispin) = moments(4, iorb, ispin) + xmii
1274 DEALLOCATE (dipmat(i)%matrix)
1281 moments(1:3, iorb, ispin) =
pbc(moments(1:3, iorb, ispin), cell)
1285 CALL timestop(handle)
1287 END SUBROUTINE center_spread_loc
1295 SUBROUTINE center_spread_berry(qs_env, c_loc_orb, moments)
1297 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(IN) :: c_loc_orb
1298 REAL(kind=
dp),
DIMENSION(:, :, :),
INTENT(INOUT) :: moments
1300 CHARACTER(len=*),
PARAMETER :: routinen =
'center_spread_berry'
1302 COMPLEX(KIND=dp) :: z
1303 INTEGER :: dim_op, handle, i, idir, ispin, istate, &
1304 j, jdir, nao, norb, nspin
1305 REAL(
dp),
DIMENSION(3) :: c, cpbc
1306 REAL(
dp),
DIMENSION(6) :: weights
1307 REAL(kind=
dp) :: imagpart, realpart, spread_i, spread_ii
1311 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:, :) :: zij
1313 TYPE(
dbcsr_p_type),
DIMENSION(:, :),
POINTER :: op_sm_set
1315 CALL timeset(routinen, handle)
1317 CALL get_qs_env(qs_env=qs_env, matrix_s=matrix_s, cell=cell)
1319 IF (cell%orthorhombic)
THEN
1324 ALLOCATE (op_sm_set(2, dim_op))
1327 NULLIFY (op_sm_set(j, i)%matrix)
1328 ALLOCATE (op_sm_set(j, i)%matrix)
1329 CALL dbcsr_copy(op_sm_set(j, i)%matrix, matrix_s(1)%matrix)
1330 CALL dbcsr_set(op_sm_set(j, i)%matrix, 0.0_dp)
1337 nspin =
SIZE(c_loc_orb, 1)
1339 CALL cp_fm_get_info(c_loc_orb(ispin), nrow_global=nao, ncol_global=norb)
1340 CALL cp_fm_create(opvec, c_loc_orb(ispin)%matrix_struct)
1343 template_fmstruct=c_loc_orb(ispin)%matrix_struct)
1344 ALLOCATE (zij(2, dim_op))
1352 CALL parallel_gemm(
"T",
"N", norb, norb, nao, 1.0_dp, c_loc_orb(ispin), opvec, 0.0_dp, zij(j, i))
1366 z = cmplx(realpart, imagpart,
dp)
1367 spread_i = spread_i - weights(jdir)* &
1368 log(realpart*realpart + imagpart*imagpart)/
twopi/
twopi
1369 spread_ii = spread_ii + weights(jdir)* &
1370 (1.0_dp - (realpart*realpart + imagpart*imagpart))/
twopi/
twopi
1373 c(idir) = c(idir) + &
1374 (cell%hmat(idir, jdir)/
twopi)*aimag(log(z))
1379 moments(1:3, istate, ispin) = cpbc(1:3)
1380 moments(4, istate, ispin) = spread_i
1381 moments(5, istate, ispin) = spread_ii
1391 DEALLOCATE (op_sm_set(j, i)%matrix)
1394 DEALLOCATE (op_sm_set)
1396 CALL timestop(handle)
1398 END SUBROUTINE center_spread_berry
1410 SUBROUTINE iao_oce_expansion(qs_env, oce_basis_set_list, smat_kind, sxo, iao_coef, oce_atom, unit_nr)
1417 INTEGER,
INTENT(IN) :: unit_nr
1419 CHARACTER(len=*),
PARAMETER :: routinen =
'iao_oce_expansion'
1421 INTEGER :: handle, i, i1, i2, iao, iatom, ikind, &
1422 iset, ishell, ispin, l, m, maxl, n, &
1423 natom, nkind, noce, ns, nset, nsgf, &
1425 INTEGER,
DIMENSION(:),
POINTER :: iao_blk_sizes, nshell, oce_blk_sizes, &
1427 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgf, last_sgf, lval
1429 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: ev, vector
1430 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: amat, bmat, filter, oce_comp, prol, vec
1431 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: ablock
1438 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1441 CALL timeset(routinen, handle)
1444 CALL dbcsr_get_info(sxo(1)%matrix, row_blk_size=oce_blk_sizes, col_blk_size=orb_blk_sizes, &
1445 distribution=dbcsr_dist)
1446 CALL get_qs_env(qs_env=qs_env, ks_env=ks_env, natom=natom)
1447 CALL get_ks_env(ks_env=ks_env, particle_set=particle_set, qs_kind_set=qs_kind_set)
1448 ALLOCATE (iao_blk_sizes(natom))
1450 CALL get_atomic_kind(particle_set(iatom)%atomic_kind, kind_number=ikind)
1451 CALL get_qs_kind(qs_kind_set(ikind), nsgf=ns, basis_type=
"MIN")
1452 iao_blk_sizes(iatom) = ns
1455 CALL dbcsr_create(iao_vec, name=
"IAO_VEC", dist=dbcsr_dist, &
1456 matrix_type=dbcsr_type_no_symmetry, row_blk_size=orb_blk_sizes, &
1457 col_blk_size=iao_blk_sizes)
1458 CALL dbcsr_create(sx_vec, name=
"SX_VEC", dist=dbcsr_dist, &
1459 matrix_type=dbcsr_type_no_symmetry, row_blk_size=oce_blk_sizes, &
1460 col_blk_size=iao_blk_sizes)
1463 nkind =
SIZE(smat_kind)
1464 ALLOCATE (sinv_kind(nkind))
1466 noce =
SIZE(smat_kind(ikind)%array, 1)
1467 ALLOCATE (sinv_kind(ikind)%array(noce, noce))
1468 sinv_kind(ikind)%array = smat_kind(ikind)%array
1473 nspin =
SIZE(iao_coef, 1)
1474 ALLOCATE (oce_comp(natom, nspin))
1478 CALL dbcsr_multiply(
"N",
"N", 1.0_dp, sxo(1)%matrix, iao_vec, 0.0_dp, sx_vec, &
1479 retain_sparsity=.true.)
1481 CALL get_atomic_kind(particle_set(iatom)%atomic_kind, kind_number=ikind)
1483 row=iatom, col=iatom, block=ablock, found=found)
1487 ablock = matmul(sinv_kind(ikind)%array, ablock)
1488 ALLOCATE (amat(n, m), bmat(m, m), ev(m), vec(m, m))
1489 amat(1:n, 1:m) = matmul(smat_kind(ikind)%array(1:n, 1:n), ablock(1:n, 1:m))
1490 bmat(1:m, 1:m) = matmul(transpose(ablock(1:n, 1:m)), amat(1:n, 1:m))
1491 CALL jacobi(bmat, ev, vec)
1492 oce_comp(iatom, ispin) = sum(ev(1:m))/real(m, kind=
dp)
1494 ev(i) = 1._dp/sqrt(ev(i))
1495 bmat(1:m, i) = vec(1:m, i)*ev(i)
1497 bmat(1:m, 1:m) = matmul(bmat(1:m, 1:m), transpose(vec(1:m, 1:m)))
1498 ablock(1:n, 1:m) = matmul(ablock(1:n, 1:m), bmat(1:m, 1:m))
1499 DEALLOCATE (amat, bmat, ev, vec)
1504 CALL get_atomic_kind(particle_set(iatom)%atomic_kind, kind_number=ikind)
1506 row=iatom, col=iatom, block=ablock, found=found)
1510 ALLOCATE (oce_atom(iatom, ispin)%array(n, m))
1511 oce_atom(iatom, ispin)%array = ablock
1515 CALL group%sum(oce_comp)
1516 IF (unit_nr > 0)
THEN
1518 WRITE (unit_nr,
"(T4,A,I6,T30,A,2F12.4)")
"Atom:", iatom,
" Completeness: ", oce_comp(iatom, 1:nspin)
1519 CALL get_atomic_kind(particle_set(iatom)%atomic_kind, kind_number=ikind)
1520 oce_basis => oce_basis_set_list(ikind)%gto_basis_set
1521 CALL get_gto_basis_set(oce_basis, nset=nset, nshell=nshell, nsgf=nsgf, maxl=maxl, &
1522 l=lval, first_sgf=first_sgf, last_sgf=last_sgf)
1523 ALLOCATE (filter(nsgf, 0:maxl), vector(nsgf), prol(0:maxl, nspin))
1526 DO ishell = 1, nshell(iset)
1527 l = lval(ishell, iset)
1528 i1 = first_sgf(ishell, iset)
1529 i2 = last_sgf(ishell, iset)
1530 filter(i1:i2, l) = 1.0_dp
1534 n =
SIZE(oce_atom(iatom, 1)%array, 1)
1535 m =
SIZE(oce_atom(iatom, 1)%array, 2)
1541 vector(1:n) = oce_atom(iatom, ispin)%array(1:n, iao)*filter(1:n, l)
1542 prol(l, ispin) = sum(matmul(smat_kind(ikind)%array(1:n, 1:n), vector(1:n))*vector(1:n))
1545 WRITE (unit_nr,
"(T4,I3,T15,A,T39,(6F7.4))") iao,
" l-contributions:", (sum(prol(l, :)), l=0, maxl)
1547 DEALLOCATE (filter, vector, prol)
1552 DEALLOCATE (oce_comp)
1554 DEALLOCATE (sinv_kind(ikind)%array)
1556 DEALLOCATE (sinv_kind)
1557 DEALLOCATE (iao_blk_sizes)
1561 CALL timestop(handle)
1563 END SUBROUTINE iao_oce_expansion
1570 SUBROUTINE oce_overlap_matrix(smat_kind, basis_set_list)
1574 CHARACTER(len=*),
PARAMETER :: routinen =
'oce_overlap_matrix'
1576 INTEGER :: handle, ikind, iset, jset, ldsab, m1, &
1577 m2, n1, n2, ncoa, ncob, nkind, nseta, &
1579 INTEGER,
DIMENSION(:),
POINTER :: la_max, la_min, npgfa, nsgfa
1580 INTEGER,
DIMENSION(:, :),
POINTER :: first_sgfa
1581 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: oint, owork
1582 REAL(kind=
dp),
DIMENSION(3) :: rab
1583 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: rpgfa, scon_a, smat, zeta
1586 CALL timeset(routinen, handle)
1590 nkind =
SIZE(smat_kind)
1593 basis_set => basis_set_list(ikind)%gto_basis_set
1594 cpassert(
ASSOCIATED(basis_set))
1596 ldsab = max(m1, m2, ldsab)
1599 ALLOCATE (oint(ldsab, ldsab), owork(ldsab, ldsab))
1602 basis_set => basis_set_list(ikind)%gto_basis_set
1603 cpassert(
ASSOCIATED(basis_set))
1604 smat => smat_kind(ikind)%array
1607 first_sgfa => basis_set%first_sgf
1608 la_max => basis_set%lmax
1609 la_min => basis_set%lmin
1610 npgfa => basis_set%npgf
1611 nseta = basis_set%nset
1612 nsgfa => basis_set%nsgf_set
1613 rpgfa => basis_set%pgf_radius
1614 scon_a => basis_set%scon
1615 zeta => basis_set%zet
1619 ncoa = npgfa(iset)*
ncoset(la_max(iset))
1620 n1 = npgfa(iset)*(
ncoset(la_max(iset)) -
ncoset(la_min(iset) - 1))
1621 sgfa = first_sgfa(1, iset)
1625 ncob = npgfa(jset)*
ncoset(la_max(jset))
1626 n2 = npgfa(jset)*(
ncoset(la_max(jset)) -
ncoset(la_min(jset) - 1))
1627 sgfb = first_sgfa(1, jset)
1630 CALL overlap_ab(la_max(iset), la_min(iset), npgfa(iset), rpgfa(:, iset), zeta(:, iset), &
1631 la_max(jset), la_min(jset), npgfa(jset), rpgfa(:, jset), zeta(:, jset), &
1632 rab, sab=oint(:, :))
1634 CALL contraction(oint(:, :), owork, ca=scon_a(:, sgfa:), na=n1, ma=nsgfa(iset), &
1635 cb=scon_a(:, sgfb:), nb=n2, mb=nsgfa(jset), fscale=1.0_dp, trans=.false.)
1636 CALL block_add(
"IN", owork, nsgfa(iset), nsgfa(jset), smat, &
1637 sgfa, sgfb, trans=.false.)
1643 DEALLOCATE (oint, owork)
1645 CALL timestop(handle)
1647 END SUBROUTINE oce_overlap_matrix
1661 SUBROUTINE pm_localization(zij_fm_set, vectors, order, accuracy, unit_nr)
1663 TYPE(
cp_fm_type),
DIMENSION(:, :),
INTENT(IN) :: zij_fm_set
1665 INTEGER,
INTENT(IN) :: order
1666 REAL(kind=
dp),
INTENT(IN) :: accuracy
1667 INTEGER,
INTENT(IN) :: unit_nr
1669 INTEGER,
PARAMETER :: max_sweeps = 250
1671 INTEGER :: iatom, istate, jstate, natom, nstate, &
1673 REAL(kind=
dp) :: aij, bij, ct, ftarget, mii, mij, mjj, &
1674 st, t1, t2, theta, tolerance, tt
1675 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: fdiag
1678 CALL cp_fm_create(rmat, zij_fm_set(1, 1)%matrix_struct)
1682 ALLOCATE (fdiag(nstate))
1683 tolerance = 1.0e10_dp
1685 natom =
SIZE(zij_fm_set, 1)
1686 IF (unit_nr > 0)
THEN
1687 WRITE (unit_nr,
'(A,T30,A,T45,A,T63,A,T77,A)') &
1688 " Jacobi Localization ",
"Sweep",
"Functional",
"Gradient",
"Time"
1691 DO sweeps = 1, max_sweeps
1694 DO istate = 1, nstate
1695 DO jstate = istate + 1, nstate
1702 IF (order == 2)
THEN
1703 aij = aij + 4._dp*mij**2 - (mii - mjj)**2
1704 bij = bij + 4._dp*mij*(mii - mjj)
1705 ELSEIF (order == 4)
THEN
1706 aij = aij - mii**4 - mjj**4 + 6._dp*(mii**2 + mjj**2)*mij**2 + &
1707 mii**3*mjj + mii*mjj**3
1708 bij = bij + 4._dp*mij*(mii**3 - mjj**3)
1713 IF ((aij**2 + bij**2) < 1.e-10_dp) cycle
1714 tolerance = tolerance + bij**2
1715 theta = 0.25_dp*atan2(bij, -aij)
1722 CALL cp_fm_rot_cols(zij_fm_set(iatom, 1), istate, jstate, ct, st)
1723 CALL cp_fm_rot_rows(zij_fm_set(iatom, 1), istate, jstate, ct, st)
1730 ftarget = ftarget + sum(fdiag**order)
1732 ftarget = ftarget**(1._dp/order)
1733 tolerance = sqrt(tolerance)
1736 IF (unit_nr > 0)
THEN
1737 WRITE (unit_nr,
'(T31,I4,T39,F16.8,T55,G16.8,T71,F10.2)') sweeps, ftarget, tolerance, tt
1739 IF (tolerance < accuracy)
EXIT
1746 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, ccon)
...
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...
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_next_block(iterator, row, column, block, block_number_argument_has_been_removed, row_size, col_size, row_offset, col_offset, transposed)
...
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, nrow, ncol, set_zero)
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, zeff, stride, max_file_size_mb, 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.
subroutine, public organise_printout_for_rose(qs_env, orb_basis_set_list)
Prints fragmented overlap matrices for interface with ROSE.
subroutine, public print_fragment_association(qs_env, moments, unit_nr)
Associates IBO centers to fragments.
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, cell, unoccupied_orbs, unoccupied_evals, qs_env, calc_energies)
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, ncgf)
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, mimic, 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, sab_cneo, 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, xcint_weights, 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, rhoz_cneo_set, ecoul_1c, rho0_s_rs, rho0_s_gs, rhoz_cneo_s_rs, rhoz_cneo_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, do_rixs, tb_tblite)
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, cneo_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, monovalent, 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, exc_accint, 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, xcint_weights, 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, sab_cneo, 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 init_mo_set(mo_set, fm_pool, fm_ref, fm_struct, name, counter)
initializes an allocated mo_set. eigenvalues, mo_coeff, occupation_numbers are valid only after this ...
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.
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, lcart)
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 ...