49 USE dbcsr_api,
ONLY: dbcsr_p_type,&
140#include "./base/base_uses.f90"
146 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'qs_scf_post_tb'
166 CHARACTER(LEN=*) :: tb_type
167 LOGICAL,
INTENT(IN) :: no_mos
169 CHARACTER(len=*),
PARAMETER :: routinen =
'scf_post_calculation_tb'
171 CHARACTER(LEN=6) :: ana
172 CHARACTER(LEN=default_string_length) :: aname
173 INTEGER :: after, handle, homo, iat, iatom, ikind, &
174 img, ispin, iw, nat, natom, nkind, &
175 nlumo_stm, nlumos, nspins, &
177 LOGICAL :: do_cube, do_kpoints, explicit, has_homo, &
178 omit_headers, print_it, rebuild
179 REAL(kind=
dp) :: zeff
180 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: mcharge
181 REAL(kind=
dp),
DIMENSION(2, 2) :: homo_lumo
182 REAL(kind=
dp),
DIMENSION(:),
POINTER :: mo_eigenvalues
183 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: charges
185 TYPE(
cp_1d_r_p_type),
DIMENSION(:),
POINTER :: unoccupied_evals_stm
186 TYPE(
cp_fm_type),
DIMENSION(:),
POINTER :: unoccupied_orbs_stm
189 TYPE(dbcsr_p_type),
DIMENSION(:),
POINTER :: ks_rmpv, mo_derivs
190 TYPE(dbcsr_p_type),
DIMENSION(:, :),
POINTER :: matrix_ks, matrix_p, matrix_s
191 TYPE(dbcsr_type),
POINTER :: mo_coeff_deriv
199 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
205 print_section, sprint_section, &
209 CALL timeset(routinen, handle)
213 cpassert(
ASSOCIATED(qs_env))
214 NULLIFY (dft_control, rho, para_env, matrix_s, matrix_p)
215 CALL get_qs_env(qs_env, scf_env=scf_env, atomic_kind_set=atomic_kind_set, qs_kind_set=qs_kind_set, &
216 dft_control=dft_control, rho=rho, natom=natom, para_env=para_env, &
217 particle_set=particle_set, do_kpoints=do_kpoints, matrix_s_kp=matrix_s)
218 nspins = dft_control%nspins
221 ALLOCATE (charges(natom, nspins), mcharge(natom))
225 nkind =
SIZE(atomic_kind_set)
228 SELECT CASE (trim(tb_type))
230 CALL get_qs_kind(qs_kind_set(ikind), dftb_parameter=dftb_kind)
233 CALL get_qs_kind(qs_kind_set(ikind), xtb_parameter=xtb_kind)
236 cpabort(
"unknown TB type")
239 iat = atomic_kind_set(ikind)%atom_list(iatom)
240 mcharge(iat) = zeff - sum(charges(iat, 1:nspins))
251 extension=
".mulliken", log_filename=.false.)
252 IF (unit_nr > 0)
THEN
253 WRITE (unit=unit_nr, fmt=
"(/,/,T2,A)")
"MULLIKEN POPULATION ANALYSIS"
254 IF (nspins == 1)
THEN
255 WRITE (unit=unit_nr, fmt=
"(/,T2,A,T70,A)") &
256 " # Atom Element Kind Atomic population",
" Net charge"
260 SELECT CASE (tb_type)
262 CALL get_qs_kind(qs_kind_set(ikind), dftb_parameter=dftb_kind)
265 CALL get_qs_kind(qs_kind_set(ikind), xtb_parameter=xtb_kind)
268 cpabort(
"unknown TB type")
270 ana = adjustr(trim(adjustl(aname)))
272 iat = atomic_kind_set(ikind)%atom_list(iatom)
273 WRITE (unit=unit_nr, &
274 fmt=
"(T2,I7,5X,A6,I6,T39,F12.6,T69,F12.6)") &
275 iat, adjustl(ana), ikind, charges(iat, 1), mcharge(iat)
278 WRITE (unit=unit_nr, &
279 fmt=
"(T2,A,T39,F12.6,T69,F12.6,/)") &
280 "# Total charge", sum(charges(:, 1)), sum(mcharge(:))
282 WRITE (unit=unit_nr, fmt=
"(/,T2,A)") &
283 "# Atom Element Kind Atomic population (alpha,beta) Net charge Spin moment"
287 SELECT CASE (tb_type)
289 CALL get_qs_kind(qs_kind_set(ikind), dftb_parameter=dftb_kind)
292 CALL get_qs_kind(qs_kind_set(ikind), xtb_parameter=xtb_kind)
295 cpabort(
"unknown TB type")
297 ana = adjustr(trim(adjustl(aname)))
299 iat = atomic_kind_set(ikind)%atom_list(iatom)
300 WRITE (unit=unit_nr, &
301 fmt=
"(T2,I6,3X,A6,I6,T29,4(1X,F12.6))") &
302 iat, adjustl(ana), ikind, charges(iat, 1:2), mcharge(iat), &
303 charges(iat, 1) - charges(iat, 2)
306 WRITE (unit=unit_nr, &
307 fmt=
"(T2,A,T29,4(1X,F12.6),/)") &
308 "# Total charge and spin", sum(charges(:, 1)), sum(charges(:, 2)), sum(mcharge(:))
318 SELECT CASE (tb_type)
320 cpwarn(
"Lowdin population analysis not implemented for DFTB method.")
323 log_filename=.false.)
326 IF (print_it) print_level = 2
328 IF (print_it) print_level = 3
330 cpwarn(
"Lowdin charges not implemented for k-point calculations!")
336 cpabort(
"unknown TB type")
345 cpwarn(
"Hirshfeld charges not available for TB methods.")
354 cpwarn(
"MAO analysis not available for TB methods.")
363 cpwarn(
"ED analysis not available for TB methods.")
371 extension=
".data", middle_name=
"tb_dipole", log_filename=.false.)
373 CALL tb_dipole(qs_env, moments_section, unit_nr, mcharge)
377 DEALLOCATE (charges, mcharge)
380 IF (.NOT. no_mos)
THEN
384 IF (.NOT. do_kpoints)
THEN
385 SELECT CASE (tb_type)
392 cpabort(
"Unknown TB type")
399 IF (.NOT. no_mos)
THEN
402 IF (explicit .AND. .NOT. qs_env%run_rtp)
CALL wfn_mix_tb(qs_env, dft_section, scf_env)
405 IF (.NOT. no_mos)
THEN
409 CALL get_qs_env(qs_env=qs_env, kpoints=kpoints)
419 IF (.NOT. no_mos)
THEN
423 cpwarn(
"Projected density of states not implemented for k-points.")
425 CALL get_qs_env(qs_env, mos=mos, matrix_ks=ks_rmpv)
426 DO ispin = 1, dft_control%nspins
428 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff, &
429 eigenvalues=mo_eigenvalues)
430 IF (
ASSOCIATED(qs_env%mo_derivs))
THEN
431 mo_coeff_deriv => qs_env%mo_derivs(ispin)%matrix
433 mo_coeff_deriv => null()
436 do_rotation=.true., &
437 co_rotate_dbcsr=mo_coeff_deriv)
440 IF (dft_control%nspins == 2)
THEN
442 qs_kind_set, particle_set, qs_env, dft_section, ispin=ispin)
445 qs_kind_set, particle_set, qs_env, dft_section)
453 SELECT CASE (tb_type)
461 cpabort(
"unknown TB type")
469 cpwarn(
"Energy Windows not implemented for k-points.")
472 CALL rebuild_pw_env(qs_env)
478 cpwarn(
"Energy Windows not implemented for TB methods.")
487 CALL rebuild_pw_env(qs_env)
490 CALL print_e_density(qs_env, print_key)
492 cpwarn(
"Electronic density cube file not implemented for TB methods.")
501 CALL rebuild_pw_env(qs_env)
504 CALL print_density_cubes(qs_env, print_key, total_density=.true.)
506 cpwarn(
"Total density cube file not implemented for TB methods.")
515 CALL rebuild_pw_env(qs_env)
518 CALL print_density_cubes(qs_env, print_key, v_hartree=.true.)
520 cpwarn(
"Hartree potential cube file not implemented for TB methods.")
529 CALL rebuild_pw_env(qs_env)
532 CALL print_density_cubes(qs_env, print_key, efield=.true.)
534 cpwarn(
"Efield cube file not implemented for TB methods.")
543 CALL rebuild_pw_env(qs_env)
546 CALL print_elf(qs_env, print_key)
548 cpwarn(
"ELF not implemented for TB methods.")
553 IF (.NOT. no_mos)
THEN
558 CALL rebuild_pw_env(qs_env)
561 CALL print_mo_cubes(qs_env, print_key)
563 cpwarn(
"Printing of MO cube files not implemented for TB methods.")
569 IF (.NOT. no_mos)
THEN
574 CALL rebuild_pw_env(qs_env)
578 cpwarn(
"STM not implemented for k-point calculations!")
581 cpassert(.NOT. dft_control%restricted)
582 CALL get_qs_env(qs_env, mos=mos, mo_derivs=mo_derivs, &
583 scf_control=scf_control, matrix_ks=ks_rmpv)
584 CALL make_mo_eig(mos, dft_control%nspins, ks_rmpv, scf_control, mo_derivs)
585 DO ispin = 1, dft_control%nspins
586 CALL get_mo_set(mo_set=mos(ispin), eigenvalues=mo_eigenvalues, homo=homo)
587 homo_lumo(ispin, 1) = mo_eigenvalues(homo)
590 NULLIFY (unoccupied_orbs_stm, unoccupied_evals_stm)
591 IF (nlumo_stm > 0)
THEN
592 ALLOCATE (unoccupied_orbs_stm(dft_control%nspins))
593 ALLOCATE (unoccupied_evals_stm(dft_control%nspins))
594 CALL make_lumo_tb(qs_env, scf_env, unoccupied_orbs_stm, unoccupied_evals_stm, &
600 CALL th_stm_image(qs_env, print_key, particles, unoccupied_orbs_stm, &
601 unoccupied_evals_stm)
603 IF (nlumo_stm > 0)
THEN
604 DO ispin = 1, dft_control%nspins
605 DEALLOCATE (unoccupied_evals_stm(ispin)%array)
607 DEALLOCATE (unoccupied_evals_stm)
616 CALL get_qs_env(qs_env, matrix_ks_kp=matrix_ks)
623 after = min(max(after, 1), 16)
624 DO ispin = 1, dft_control%nspins
625 DO img = 1,
SIZE(matrix_p, 2)
627 para_env, output_unit=iw, omit_headers=omit_headers)
635 "AO_MATRICES/KOHN_SHAM_MATRIX"),
cp_p_file))
THEN
639 after = min(max(after, 1), 16)
640 DO ispin = 1, dft_control%nspins
641 DO img = 1,
SIZE(matrix_ks, 2)
643 output_unit=iw, omit_headers=omit_headers)
656 cpwarn(
"XC potential cube file not available for TB methods.")
665 cpwarn(
"Electric field gradient not implemented for TB methods.")
674 cpwarn(
"Kinetic energy not available for TB methods.")
683 cpwarn(
"Xray diffraction spectrum not implemented for TB methods.")
692 cpwarn(
"Hyperfine Coupling not implemented for TB methods.")
701 cpwarn(
"DFT+U method not implemented for TB methods.")
708 CALL timestop(handle)
719 SUBROUTINE tb_dipole(qs_env, input, unit_nr, charges)
723 INTEGER,
INTENT(in) :: unit_nr
724 REAL(kind=
dp),
DIMENSION(:),
INTENT(in) :: charges
726 CHARACTER(LEN=default_string_length) :: description, dipole_type
727 COMPLEX(KIND=dp) :: dzeta, dzphase(3), zeta, zphase(3)
728 COMPLEX(KIND=dp),
DIMENSION(3) :: dggamma, ggamma
729 INTEGER :: i, iat, ikind, j, nat, reference
731 REAL(kind=
dp) :: charge_tot, ci(3), dci(3), dipole(3), dipole_deriv(3), drcc(3), dria(3), &
732 dtheta, gvec(3), q, rcc(3), ria(3), theta, tmp(3), via(3)
733 REAL(kind=
dp),
DIMENSION(:),
POINTER :: ref_point
739 NULLIFY (atomic_kind_set, cell, results)
740 CALL get_qs_env(qs_env, atomic_kind_set=atomic_kind_set, &
741 particle_set=particle_set, cell=cell, results=results)
746 description =
'[DIPOLE]'
750 CALL get_reference_point(rcc, drcc, qs_env=qs_env, reference=reference, ref_point=ref_point)
753 dipole_deriv = 0.0_dp
756 dipole_type =
"periodic (Berry phase)"
759 charge_tot = sum(charges)
760 ria =
twopi*matmul(cell%h_inv, rcc)
761 zphase = cmplx(cos(ria), sin(ria),
dp)**charge_tot
763 dria =
twopi*matmul(cell%h_inv, drcc)
764 dzphase = charge_tot*cmplx(-sin(ria), cos(ria),
dp)**(charge_tot - 1.0_dp)*dria
766 ggamma = cmplx(1.0_dp, 0.0_dp, kind=
dp)
767 dggamma = cmplx(0.0_dp, 0.0_dp, kind=
dp)
768 DO ikind = 1,
SIZE(atomic_kind_set)
771 iat = atomic_kind_set(ikind)%atom_list(i)
772 ria = particle_set(iat)%r(:)
774 via = particle_set(iat)%v(:)
777 gvec =
twopi*cell%h_inv(j, :)
778 theta = sum(ria(:)*gvec(:))
779 dtheta = sum(via(:)*gvec(:))
780 zeta = cmplx(cos(theta), sin(theta), kind=
dp)**(-q)
781 dzeta = -q*cmplx(-sin(theta), cos(theta), kind=
dp)**(-q - 1.0_dp)*dtheta
782 dggamma(j) = dggamma(j)*zeta + ggamma(j)*dzeta
783 ggamma(j) = ggamma(j)*zeta
787 dggamma = dggamma*zphase + ggamma*dzphase
788 ggamma = ggamma*zphase
789 IF (all(real(ggamma, kind=
dp) /= 0.0_dp))
THEN
790 tmp = aimag(ggamma)/real(ggamma, kind=
dp)
792 dci = -(1.0_dp/(1.0_dp + tmp**2))* &
793 (aimag(dggamma)*real(ggamma, kind=
dp) - aimag(ggamma)*real(dggamma, kind=
dp))/(real(ggamma, kind=
dp))**2
794 dipole = matmul(cell%hmat, ci)/
twopi
795 dipole_deriv = matmul(cell%hmat, dci)/
twopi
798 dipole_type =
"non-periodic"
799 DO i = 1,
SIZE(particle_set)
801 ria = particle_set(i)%r(:)
803 dipole = dipole + q*(ria - rcc)
804 dipole_deriv(:) = dipole_deriv(:) + q*(particle_set(i)%v(:) - drcc)
808 CALL put_results(results=results, description=description, &
810 IF (unit_nr > 0)
THEN
811 WRITE (unit_nr,
'(/,T2,A,T31,A50)') &
812 'TB_DIPOLE| Dipole type', adjustr(trim(dipole_type))
813 WRITE (unit_nr,
"(T2,A,T33,3F16.8)")
"TB_DIPOLE| Reference Point [Bohr]", rcc
814 WRITE (unit_nr,
'(T2,A,T30,3(1X,F16.8))') &
815 'TB_DIPOLE| Moment [a.u.]', dipole(1:3)
816 WRITE (unit_nr,
'(T2,A,T30,3(1X,F16.8))') &
817 'TB_DIPOLE| Moment [Debye]', dipole(1:3)*
debye
818 WRITE (unit_nr,
'(T2,A,T30,3(1X,F16.8))') &
819 'TB_DIPOLE| Derivative [a.u.]', dipole_deriv(1:3)
822 END SUBROUTINE tb_dipole
833 SUBROUTINE wfn_mix_tb(qs_env, dft_section, scf_env)
839 INTEGER :: ispin, nao, nmo, output_unit
840 REAL(
dp),
DIMENSION(:),
POINTER :: mo_eigenvalues
843 TYPE(
cp_fm_type) :: ks_tmp, mo_tmp, s_tmp, work
844 TYPE(
cp_fm_type),
DIMENSION(:),
POINTER :: lumos
847 TYPE(dbcsr_p_type),
DIMENSION(:),
POINTER :: matrix_ks, matrix_s
851 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
855 CALL get_qs_env(qs_env=qs_env, matrix_s=matrix_s, matrix_ks=matrix_ks, &
856 particle_set=particle_set, atomic_kind_set=atomic_kind_set, &
857 qs_kind_set=qs_kind_set, mos=mos, para_env=para_env)
861 CALL get_mo_set(mos(1), mo_coeff=mo_coeff, nao=nao)
864 template_fmstruct=mo_coeff%matrix_struct)
869 ALLOCATE (lumos(
SIZE(mos)))
874 DO ispin = 1,
SIZE(mos)
875 CALL get_mo_set(mos(ispin), mo_coeff=mo_coeff, eigenvalues=mo_eigenvalues, nmo=nmo)
876 CALL cp_fm_struct_create(fmstruct=ao_lumo_struct, nrow_global=nao, ncol_global=nao - nmo, &
877 template_fmstruct=mo_coeff%matrix_struct)
879 CALL cp_fm_create(lumos(ispin), matrix_struct=ao_lumo_struct)
891 CALL wfn_mix(mos, particle_set, dft_section, qs_kind_set, para_env, output_unit, &
892 unoccupied_orbs=lumos, scf_env=scf_env, matrix_s=matrix_s)
901 END SUBROUTINE wfn_mix_tb
912 SUBROUTINE make_lumo_tb(qs_env, scf_env, unoccupied_orbs, unoccupied_evals, nlumo, nlumos)
916 TYPE(
cp_fm_type),
DIMENSION(:),
POINTER :: unoccupied_orbs
917 TYPE(
cp_1d_r_p_type),
DIMENSION(:),
INTENT(INOUT) :: unoccupied_evals
919 INTEGER,
INTENT(OUT) :: nlumos
921 INTEGER :: homo, iounit, ispin, n, nao, nmo
926 TYPE(dbcsr_p_type),
DIMENSION(:),
POINTER :: ks_rmpv, matrix_s
933 NULLIFY (mos, ks_rmpv, scf_control, dft_control, para_env, blacs_env)
937 scf_control=scf_control, &
938 dft_control=dft_control, &
946 DO ispin = 1, dft_control%nspins
947 NULLIFY (unoccupied_evals(ispin)%array)
949 IF (iounit > 0)
WRITE (iounit, *)
" "
950 IF (iounit > 0)
WRITE (iounit, *)
" Lowest Eigenvalues of the unoccupied subspace spin ", ispin
951 IF (iounit > 0)
WRITE (iounit, fmt=
'(1X,A)')
"-----------------------------------------------------"
952 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff, homo=homo, nao=nao, nmo=nmo)
954 nlumos = max(1, min(nlumo, nao - nmo))
955 IF (nlumo == -1) nlumos = nao - nmo
956 ALLOCATE (unoccupied_evals(ispin)%array(nlumos))
958 nrow_global=n, ncol_global=nlumos)
959 CALL cp_fm_create(unoccupied_orbs(ispin), fm_struct_tmp, name=
"lumos")
964 NULLIFY (local_preconditioner)
965 IF (
ASSOCIATED(scf_env%ot_preconditioner))
THEN
966 local_preconditioner => scf_env%ot_preconditioner(1)%preconditioner
969 NULLIFY (local_preconditioner)
973 CALL ot_eigensolver(matrix_h=ks_rmpv(ispin)%matrix, matrix_s=matrix_s(1)%matrix, &
974 matrix_c_fm=unoccupied_orbs(ispin), &
975 matrix_orthogonal_space_fm=mo_coeff, &
976 eps_gradient=scf_control%eps_lumos, &
978 iter_max=scf_control%max_iter_lumos, &
979 size_ortho_space=nmo)
982 unoccupied_evals(ispin)%array, scr=iounit, &
993 SUBROUTINE rebuild_pw_env(qs_env)
997 LOGICAL :: skip_load_balance_distributed
1005 CALL get_qs_env(qs_env, ks_env=ks_env, dft_control=dft_control, pw_env=new_pw_env)
1006 IF (.NOT.
ASSOCIATED(new_pw_env))
THEN
1011 CALL get_qs_env(qs_env, pw_env=new_pw_env, dft_control=dft_control, cell=cell)
1013 new_pw_env%cell_hmat = cell%hmat
1018 IF (.NOT.
ASSOCIATED(task_list))
THEN
1022 skip_load_balance_distributed = dft_control%qs_control%skip_load_balance_distributed
1024 reorder_rs_grid_ranks=.true., soft_valid=.false., &
1025 skip_load_balance_distributed=skip_load_balance_distributed)
1027 CALL qs_rho_rebuild(rho, qs_env=qs_env, rebuild_ao=.false., rebuild_grids=.true.)
1029 END SUBROUTINE rebuild_pw_env
1036 SUBROUTINE print_e_density(qs_env, cube_section)
1041 CHARACTER(LEN=default_path_length) :: filename, mpi_filename, my_pos_cube
1042 INTEGER :: iounit, ispin, unit_nr
1043 LOGICAL :: append_cube, mpi_io
1044 REAL(kind=
dp),
DIMENSION(:),
POINTER :: tot_rho_r
1046 TYPE(dbcsr_p_type),
DIMENSION(:),
POINTER :: rho_ao
1047 TYPE(dbcsr_p_type),
DIMENSION(:, :),
POINTER :: rho_ao_kp
1059 CALL get_qs_env(qs_env, dft_control=dft_control)
1062 my_pos_cube =
"REWIND"
1063 IF (append_cube) my_pos_cube =
"APPEND"
1069 CALL get_qs_env(qs_env, ks_env=ks_env, rho=rho)
1070 NULLIFY (rho_r, rho_g, tot_rho_r)
1072 rho_r=rho_r, rho_g=rho_g, tot_rho_r=tot_rho_r)
1073 DO ispin = 1, dft_control%nspins
1074 rho_ao => rho_ao_kp(ispin, :)
1077 rho_gspace=rho_g(ispin), &
1078 total_rho=tot_rho_r(ispin), &
1081 CALL qs_rho_set(rho, rho_r_valid=.true., rho_g_valid=.true.)
1086 IF (dft_control%nspins > 1)
THEN
1087 IF (iounit > 0)
THEN
1088 WRITE (unit=iounit, fmt=
"(/,T2,A,T51,2F15.6)") &
1089 "Integrated alpha and beta electronic density:", tot_rho_r(1:2)
1091 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env)
1092 CALL pw_env_get(pw_env=pw_env, auxbas_pw_pool=auxbas_pw_pool, pw_pools=pw_pools)
1095 CALL auxbas_pw_pool%create_pw(pw=rho_elec_rspace)
1096 CALL pw_copy(rho_r(1), rho_elec_rspace)
1097 CALL pw_axpy(rho_r(2), rho_elec_rspace)
1098 filename =
"ELECTRON_DENSITY"
1101 extension=
".cube", middle_name=trim(filename), &
1102 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
1104 IF (iounit > 0)
THEN
1105 IF (.NOT. mpi_io)
THEN
1106 INQUIRE (unit=unit_nr, name=filename)
1108 filename = mpi_filename
1110 WRITE (unit=iounit, fmt=
"(T2,A,/,T2,A79)") &
1111 "The sum of alpha and beta density is written in cube file format to the file:", adjustr(trim(filename))
1113 CALL cp_pw_to_cube(rho_elec_rspace, unit_nr,
"SUM OF ALPHA AND BETA DENSITY", &
1117 CALL pw_copy(rho_r(1), rho_elec_rspace)
1118 CALL pw_axpy(rho_r(2), rho_elec_rspace, alpha=-1.0_dp)
1119 filename =
"SPIN_DENSITY"
1122 extension=
".cube", middle_name=trim(filename), &
1123 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
1125 IF (iounit > 0)
THEN
1126 IF (.NOT. mpi_io)
THEN
1127 INQUIRE (unit=unit_nr, name=filename)
1129 filename = mpi_filename
1131 WRITE (unit=iounit, fmt=
"(T2,A,/,T2,A79)") &
1132 "The spin density is written in cube file format to the file:", adjustr(trim(filename))
1134 CALL cp_pw_to_cube(rho_elec_rspace, unit_nr,
"SPIN DENSITY", &
1135 particles=particles, &
1138 CALL auxbas_pw_pool%give_back_pw(rho_elec_rspace)
1141 IF (iounit > 0)
THEN
1142 WRITE (unit=iounit, fmt=
"(/,T2,A,T66,F15.6)") &
1143 "Integrated electronic density:", tot_rho_r(1)
1145 filename =
"ELECTRON_DENSITY"
1148 extension=
".cube", middle_name=trim(filename), &
1149 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
1151 IF (iounit > 0)
THEN
1152 IF (.NOT. mpi_io)
THEN
1153 INQUIRE (unit=unit_nr, name=filename)
1155 filename = mpi_filename
1157 WRITE (unit=iounit, fmt=
"(T2,A,/,T2,A79)") &
1158 "The electron density is written in cube file format to the file:", adjustr(trim(filename))
1161 particles=particles, &
1166 END SUBROUTINE print_e_density
1175 SUBROUTINE print_density_cubes(qs_env, cube_section, total_density, v_hartree, efield)
1177 TYPE(qs_environment_type),
POINTER :: qs_env
1178 TYPE(section_vals_type),
POINTER :: cube_section
1179 LOGICAL,
INTENT(IN),
OPTIONAL :: total_density, v_hartree, efield
1181 CHARACTER(len=1),
DIMENSION(3),
PARAMETER :: cdir = (/
"x",
"y",
"z"/)
1183 CHARACTER(LEN=default_path_length) :: filename, mpi_filename, my_pos_cube
1184 INTEGER :: id, iounit, ispin, nd(3), unit_nr
1185 LOGICAL :: append_cube, mpi_io, my_efield, &
1186 my_total_density, my_v_hartree
1187 REAL(kind=dp) :: total_rho_core_rspace, udvol
1188 REAL(kind=dp),
DIMENSION(:),
POINTER :: tot_rho_r
1189 TYPE(cell_type),
POINTER :: cell
1190 TYPE(cp_logger_type),
POINTER :: logger
1191 TYPE(dbcsr_p_type),
DIMENSION(:),
POINTER :: rho_ao
1192 TYPE(dbcsr_p_type),
DIMENSION(:, :),
POINTER :: rho_ao_kp
1193 TYPE(dft_control_type),
POINTER :: dft_control
1194 TYPE(particle_list_type),
POINTER :: particles
1195 TYPE(pw_c1d_gs_type) :: rho_core
1196 TYPE(pw_c1d_gs_type),
DIMENSION(:),
POINTER :: rho_g
1197 TYPE(pw_env_type),
POINTER :: pw_env
1198 TYPE(pw_poisson_parameter_type) :: poisson_params
1199 TYPE(pw_pool_p_type),
DIMENSION(:),
POINTER :: pw_pools
1200 TYPE(pw_pool_type),
POINTER :: auxbas_pw_pool
1201 TYPE(pw_r3d_rs_type) :: rho_tot_rspace
1202 TYPE(pw_r3d_rs_type),
DIMENSION(:),
POINTER :: rho_r
1203 TYPE(qs_ks_env_type),
POINTER :: ks_env
1204 TYPE(qs_rho_type),
POINTER :: rho
1205 TYPE(qs_subsys_type),
POINTER :: subsys
1207 CALL get_qs_env(qs_env, cell=cell, dft_control=dft_control)
1209 append_cube = section_get_lval(cube_section,
"APPEND")
1210 my_pos_cube =
"REWIND"
1211 IF (append_cube) my_pos_cube =
"APPEND"
1213 IF (
PRESENT(total_density))
THEN
1214 my_total_density = total_density
1216 my_total_density = .false.
1218 IF (
PRESENT(v_hartree))
THEN
1219 my_v_hartree = v_hartree
1221 my_v_hartree = .false.
1223 IF (
PRESENT(efield))
THEN
1229 logger => cp_get_default_logger()
1230 iounit = cp_logger_get_default_io_unit(logger)
1233 CALL get_qs_env(qs_env, ks_env=ks_env, rho=rho)
1234 NULLIFY (rho_r, rho_g, tot_rho_r)
1235 CALL qs_rho_get(rho, rho_ao_kp=rho_ao_kp, &
1236 rho_r=rho_r, rho_g=rho_g, tot_rho_r=tot_rho_r)
1237 DO ispin = 1, dft_control%nspins
1238 rho_ao => rho_ao_kp(ispin, :)
1239 CALL calculate_rho_elec(matrix_p_kp=rho_ao, &
1241 rho_gspace=rho_g(ispin), &
1242 total_rho=tot_rho_r(ispin), &
1245 CALL qs_rho_set(rho, rho_r_valid=.true., rho_g_valid=.true.)
1247 CALL get_qs_env(qs_env, subsys=subsys)
1248 CALL qs_subsys_get(subsys, particles=particles)
1250 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env)
1251 CALL pw_env_get(pw_env=pw_env, auxbas_pw_pool=auxbas_pw_pool, pw_pools=pw_pools)
1252 CALL auxbas_pw_pool%create_pw(pw=rho_core)
1253 CALL calculate_rho_core(rho_core, total_rho_core_rspace, qs_env)
1255 IF (iounit > 0)
THEN
1256 WRITE (unit=iounit, fmt=
"(/,T2,A,T66,F15.6)") &
1257 "Integrated electronic density:", sum(tot_rho_r(:))
1258 WRITE (unit=iounit, fmt=
"(T2,A,T66,F15.6)") &
1259 "Integrated core density:", total_rho_core_rspace
1262 CALL auxbas_pw_pool%create_pw(pw=rho_tot_rspace)
1263 CALL pw_transfer(rho_core, rho_tot_rspace)
1264 DO ispin = 1, dft_control%nspins
1265 CALL pw_axpy(rho_r(ispin), rho_tot_rspace)
1268 IF (my_total_density)
THEN
1269 filename =
"TOTAL_DENSITY"
1271 unit_nr = cp_print_key_unit_nr(logger, cube_section,
'', &
1272 extension=
".cube", middle_name=trim(filename), file_position=my_pos_cube, &
1273 log_filename=.false., mpi_io=mpi_io, fout=mpi_filename)
1274 IF (iounit > 0)
THEN
1275 IF (.NOT. mpi_io)
THEN
1276 INQUIRE (unit=unit_nr, name=filename)
1278 filename = mpi_filename
1280 WRITE (unit=iounit, fmt=
"(T2,A,/,T2,A79)") &
1281 "The total density is written in cube file format to the file:", adjustr(trim(filename))
1283 CALL cp_pw_to_cube(rho_tot_rspace, unit_nr,
"TOTAL DENSITY", &
1284 particles=particles, &
1285 stride=section_get_ivals(cube_section,
"STRIDE"), mpi_io=mpi_io)
1286 CALL cp_print_key_finished_output(unit_nr, logger, cube_section,
'', mpi_io=mpi_io)
1288 IF (my_v_hartree .OR. my_efield)
THEN
1290 TYPE(pw_c1d_gs_type) :: rho_tot_gspace
1291 CALL auxbas_pw_pool%create_pw(pw=rho_tot_gspace)
1292 CALL pw_transfer(rho_tot_rspace, rho_tot_gspace)
1293 poisson_params%solver = pw_poisson_analytic
1294 poisson_params%periodic = cell%perd
1295 poisson_params%ewald_type = do_ewald_none
1297 TYPE(greens_fn_type) :: green_fft
1298 TYPE(pw_grid_type),
POINTER :: pwdummy
1300 CALL pw_green_create(green_fft, poisson_params, cell%hmat, auxbas_pw_pool, pwdummy, pwdummy)
1301 rho_tot_gspace%array(:) = rho_tot_gspace%array(:)*green_fft%influence_fn%array(:)
1302 CALL pw_green_release(green_fft, auxbas_pw_pool)
1304 IF (my_v_hartree)
THEN
1306 TYPE(pw_r3d_rs_type) :: vhartree
1307 CALL auxbas_pw_pool%create_pw(pw=vhartree)
1308 CALL pw_transfer(rho_tot_gspace, vhartree)
1309 filename =
"V_HARTREE"
1311 unit_nr = cp_print_key_unit_nr(logger, cube_section,
'', &
1312 extension=
".cube", middle_name=trim(filename), file_position=my_pos_cube, &
1313 log_filename=.false., mpi_io=mpi_io, fout=mpi_filename)
1314 IF (iounit > 0)
THEN
1315 IF (.NOT. mpi_io)
THEN
1316 INQUIRE (unit=unit_nr, name=filename)
1318 filename = mpi_filename
1320 WRITE (unit=iounit, fmt=
"(T2,A,/,T2,A79)") &
1321 "The Hartree potential is written in cube file format to the file:", adjustr(trim(filename))
1323 CALL cp_pw_to_cube(vhartree, unit_nr,
"Hartree Potential", &
1324 particles=particles, &
1325 stride=section_get_ivals(cube_section,
"STRIDE"), mpi_io=mpi_io)
1326 CALL cp_print_key_finished_output(unit_nr, logger, cube_section,
'', mpi_io=mpi_io)
1327 CALL auxbas_pw_pool%give_back_pw(vhartree)
1332 TYPE(pw_c1d_gs_type) :: vhartree
1333 CALL auxbas_pw_pool%create_pw(pw=vhartree)
1334 udvol = 1.0_dp/rho_tot_rspace%pw_grid%dvol
1336 CALL pw_transfer(rho_tot_gspace, vhartree)
1339 CALL pw_derive(vhartree, nd)
1340 CALL pw_transfer(vhartree, rho_tot_rspace)
1341 CALL pw_scale(rho_tot_rspace, udvol)
1343 filename =
"EFIELD_"//cdir(id)
1345 unit_nr = cp_print_key_unit_nr(logger, cube_section,
'', &
1346 extension=
".cube", middle_name=trim(filename), file_position=my_pos_cube, &
1347 log_filename=.false., mpi_io=mpi_io, fout=mpi_filename)
1348 IF (iounit > 0)
THEN
1349 IF (.NOT. mpi_io)
THEN
1350 INQUIRE (unit=unit_nr, name=filename)
1352 filename = mpi_filename
1354 WRITE (unit=iounit, fmt=
"(T2,A,/,T2,A79)") &
1355 "The Efield is written in cube file format to the file:", adjustr(trim(filename))
1357 CALL cp_pw_to_cube(rho_tot_rspace, unit_nr,
"EFIELD "//cdir(id), &
1358 particles=particles, &
1359 stride=section_get_ivals(cube_section,
"STRIDE"), mpi_io=mpi_io)
1360 CALL cp_print_key_finished_output(unit_nr, logger, cube_section,
'', mpi_io=mpi_io)
1362 CALL auxbas_pw_pool%give_back_pw(vhartree)
1365 CALL auxbas_pw_pool%give_back_pw(rho_tot_gspace)
1369 CALL auxbas_pw_pool%give_back_pw(rho_tot_rspace)
1370 CALL auxbas_pw_pool%give_back_pw(rho_core)
1372 END SUBROUTINE print_density_cubes
1379 SUBROUTINE print_elf(qs_env, elf_section)
1381 TYPE(qs_environment_type),
POINTER :: qs_env
1382 TYPE(section_vals_type),
POINTER :: elf_section
1384 CHARACTER(LEN=default_path_length) :: filename, mpi_filename, my_pos_cube, &
1386 INTEGER :: iounit, ispin, unit_nr
1387 LOGICAL :: append_cube, mpi_io
1388 REAL(kind=dp) :: rho_cutoff
1389 REAL(kind=dp),
DIMENSION(:),
POINTER :: tot_rho_r
1390 TYPE(cp_logger_type),
POINTER :: logger
1391 TYPE(dbcsr_p_type),
DIMENSION(:),
POINTER :: rho_ao
1392 TYPE(dbcsr_p_type),
DIMENSION(:, :),
POINTER :: rho_ao_kp
1393 TYPE(dft_control_type),
POINTER :: dft_control
1394 TYPE(particle_list_type),
POINTER :: particles
1395 TYPE(pw_c1d_gs_type),
DIMENSION(:),
POINTER :: rho_g
1396 TYPE(pw_env_type),
POINTER :: pw_env
1397 TYPE(pw_pool_p_type),
DIMENSION(:),
POINTER :: pw_pools
1398 TYPE(pw_pool_type),
POINTER :: auxbas_pw_pool
1399 TYPE(pw_r3d_rs_type),
ALLOCATABLE,
DIMENSION(:) :: elf_r
1400 TYPE(pw_r3d_rs_type),
DIMENSION(:),
POINTER :: rho_r
1401 TYPE(qs_ks_env_type),
POINTER :: ks_env
1402 TYPE(qs_rho_type),
POINTER :: rho
1403 TYPE(qs_subsys_type),
POINTER :: subsys
1405 logger => cp_get_default_logger()
1406 iounit = cp_logger_get_default_io_unit(logger)
1409 CALL get_qs_env(qs_env, dft_control=dft_control, ks_env=ks_env, rho=rho)
1410 NULLIFY (rho_r, rho_g, tot_rho_r)
1411 CALL qs_rho_get(rho, rho_ao_kp=rho_ao_kp, &
1412 rho_r=rho_r, rho_g=rho_g, tot_rho_r=tot_rho_r)
1413 DO ispin = 1, dft_control%nspins
1414 rho_ao => rho_ao_kp(ispin, :)
1415 CALL calculate_rho_elec(matrix_p_kp=rho_ao, &
1417 rho_gspace=rho_g(ispin), &
1418 total_rho=tot_rho_r(ispin), &
1421 CALL qs_rho_set(rho, rho_r_valid=.true., rho_g_valid=.true.)
1423 CALL get_qs_env(qs_env, subsys=subsys)
1424 CALL qs_subsys_get(subsys, particles=particles)
1426 ALLOCATE (elf_r(dft_control%nspins))
1427 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env)
1428 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool, pw_pools=pw_pools)
1429 DO ispin = 1, dft_control%nspins
1430 CALL auxbas_pw_pool%create_pw(elf_r(ispin))
1431 CALL pw_zero(elf_r(ispin))
1434 IF (iounit > 0)
THEN
1435 WRITE (unit=iounit, fmt=
"(/,T2,A)") &
1436 "ELF is computed on the real space grid -----"
1438 rho_cutoff = section_get_rval(elf_section,
"density_cutoff")
1439 CALL qs_elf_calc(qs_env, elf_r, rho_cutoff)
1442 append_cube = section_get_lval(elf_section,
"APPEND")
1443 my_pos_cube =
"REWIND"
1444 IF (append_cube) my_pos_cube =
"APPEND"
1445 DO ispin = 1, dft_control%nspins
1446 WRITE (filename,
'(a5,I1.1)')
"ELF_S", ispin
1447 WRITE (title, *)
"ELF spin ", ispin
1449 unit_nr = cp_print_key_unit_nr(logger, elf_section,
'', extension=
".cube", &
1450 middle_name=trim(filename), file_position=my_pos_cube, &
1451 log_filename=.false., mpi_io=mpi_io, fout=mpi_filename)
1452 IF (iounit > 0)
THEN
1453 IF (.NOT. mpi_io)
THEN
1454 INQUIRE (unit=unit_nr, name=filename)
1456 filename = mpi_filename
1458 WRITE (unit=iounit, fmt=
"(T2,A,/,T2,A79)") &
1459 "ELF is written in cube file format to the file:", adjustr(trim(filename))
1462 CALL cp_pw_to_cube(elf_r(ispin), unit_nr, title, particles=particles, &
1463 stride=section_get_ivals(elf_section,
"STRIDE"), mpi_io=mpi_io)
1464 CALL cp_print_key_finished_output(unit_nr, logger, elf_section,
'', mpi_io=mpi_io)
1466 CALL auxbas_pw_pool%give_back_pw(elf_r(ispin))
1471 END SUBROUTINE print_elf
1477 SUBROUTINE print_mo_cubes(qs_env, cube_section)
1479 TYPE(qs_environment_type),
POINTER :: qs_env
1480 TYPE(section_vals_type),
POINTER :: cube_section
1482 CHARACTER(LEN=default_path_length) :: filename, my_pos_cube, title
1483 INTEGER :: homo, i, ifirst, ilast, iounit, ir, &
1484 ispin, ivector, n_rep, nhomo, nlist, &
1485 nlumo, nmo, shomo, unit_nr
1486 INTEGER,
DIMENSION(:),
POINTER ::
list, list_index
1487 LOGICAL :: append_cube, mpi_io, write_cube
1488 REAL(kind=dp) :: homo_lumo(2, 2)
1489 REAL(kind=dp),
DIMENSION(:),
POINTER :: mo_eigenvalues
1490 TYPE(atomic_kind_type),
DIMENSION(:),
POINTER :: atomic_kind_set
1491 TYPE(cell_type),
POINTER :: cell
1492 TYPE(cp_fm_type),
POINTER :: mo_coeff
1493 TYPE(cp_logger_type),
POINTER :: logger
1494 TYPE(dbcsr_p_type),
DIMENSION(:),
POINTER :: ks_rmpv, mo_derivs
1495 TYPE(dft_control_type),
POINTER :: dft_control
1496 TYPE(mo_set_type),
DIMENSION(:),
POINTER :: mos
1497 TYPE(particle_list_type),
POINTER :: particles
1498 TYPE(particle_type),
DIMENSION(:),
POINTER :: particle_set
1499 TYPE(pw_c1d_gs_type) :: wf_g
1500 TYPE(pw_env_type),
POINTER :: pw_env
1501 TYPE(pw_pool_p_type),
DIMENSION(:),
POINTER :: pw_pools
1502 TYPE(pw_pool_type),
POINTER :: auxbas_pw_pool
1503 TYPE(pw_r3d_rs_type) :: wf_r
1504 TYPE(qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1505 TYPE(qs_subsys_type),
POINTER :: subsys
1506 TYPE(scf_control_type),
POINTER :: scf_control
1508 logger => cp_get_default_logger()
1509 iounit = cp_logger_get_default_io_unit(logger)
1511 CALL get_qs_env(qs_env, mos=mos, matrix_ks=ks_rmpv, scf_control=scf_control)
1512 CALL get_qs_env(qs_env, dft_control=dft_control, mo_derivs=mo_derivs)
1513 CALL make_mo_eig(mos, dft_control%nspins, ks_rmpv, scf_control, mo_derivs)
1514 NULLIFY (mo_eigenvalues)
1516 DO ispin = 1, dft_control%nspins
1517 CALL get_mo_set(mo_set=mos(ispin), eigenvalues=mo_eigenvalues, homo=shomo)
1518 homo_lumo(ispin, 1) = mo_eigenvalues(shomo)
1519 homo = max(homo, shomo)
1521 write_cube = section_get_lval(cube_section,
"WRITE_CUBE")
1522 nlumo = section_get_ival(cube_section,
"NLUMO")
1523 nhomo = section_get_ival(cube_section,
"NHOMO")
1524 NULLIFY (list_index)
1525 CALL section_vals_val_get(cube_section,
"HOMO_LIST", n_rep_val=n_rep)
1530 CALL section_vals_val_get(cube_section,
"HOMO_LIST", i_rep_val=ir, i_vals=
list)
1531 IF (
ASSOCIATED(
list))
THEN
1532 CALL reallocate(list_index, 1, nlist +
SIZE(
list))
1533 DO i = 1,
SIZE(
list)
1534 list_index(i + nlist) =
list(i)
1536 nlist = nlist +
SIZE(
list)
1539 nhomo = maxval(list_index)
1541 IF (nhomo == -1) nhomo = homo
1542 nlist = homo - max(1, homo - nhomo + 1) + 1
1543 ALLOCATE (list_index(nlist))
1545 list_index(i) = max(1, homo - nhomo + 1) + i - 1
1549 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env)
1550 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool, pw_pools=pw_pools)
1551 CALL auxbas_pw_pool%create_pw(wf_r)
1552 CALL auxbas_pw_pool%create_pw(wf_g)
1554 CALL get_qs_env(qs_env, subsys=subsys)
1555 CALL qs_subsys_get(subsys, particles=particles)
1557 append_cube = section_get_lval(cube_section,
"APPEND")
1558 my_pos_cube =
"REWIND"
1559 IF (append_cube)
THEN
1560 my_pos_cube =
"APPEND"
1563 CALL get_qs_env(qs_env=qs_env, &
1564 atomic_kind_set=atomic_kind_set, &
1565 qs_kind_set=qs_kind_set, &
1567 particle_set=particle_set)
1569 IF (nhomo >= 0)
THEN
1570 DO ispin = 1, dft_control%nspins
1572 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff, &
1573 eigenvalues=mo_eigenvalues, homo=homo, nmo=nmo)
1574 IF (write_cube)
THEN
1576 ivector = list_index(i)
1577 IF (ivector > homo) cycle
1578 CALL calculate_wavefunction(mo_coeff, ivector, wf_r, wf_g, atomic_kind_set, qs_kind_set, &
1579 cell, dft_control, particle_set, pw_env)
1580 WRITE (filename,
'(a4,I5.5,a1,I1.1)')
"WFN_", ivector,
"_", ispin
1582 unit_nr = cp_print_key_unit_nr(logger, cube_section,
'', extension=
".cube", &
1583 middle_name=trim(filename), file_position=my_pos_cube, &
1584 log_filename=.false., mpi_io=mpi_io)
1585 WRITE (title, *)
"WAVEFUNCTION ", ivector,
" spin ", ispin,
" i.e. HOMO - ", ivector - homo
1586 CALL cp_pw_to_cube(wf_r, unit_nr, title, particles=particles, &
1587 stride=section_get_ivals(cube_section,
"STRIDE"), mpi_io=mpi_io)
1588 CALL cp_print_key_finished_output(unit_nr, logger, cube_section,
'', mpi_io=mpi_io)
1594 IF (nlumo /= 0)
THEN
1595 DO ispin = 1, dft_control%nspins
1597 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff, &
1598 eigenvalues=mo_eigenvalues, homo=homo, nmo=nmo)
1599 IF (write_cube)
THEN
1601 IF (nlumo == -1)
THEN
1604 ilast = ifirst + nlumo - 1
1605 ilast = min(nmo, ilast)
1607 DO ivector = ifirst, ilast
1608 CALL calculate_wavefunction(mo_coeff, ivector, wf_r, wf_g, atomic_kind_set, &
1609 qs_kind_set, cell, dft_control, particle_set, pw_env)
1610 WRITE (filename,
'(a4,I5.5,a1,I1.1)')
"WFN_", ivector,
"_", ispin
1612 unit_nr = cp_print_key_unit_nr(logger, cube_section,
'', extension=
".cube", &
1613 middle_name=trim(filename), file_position=my_pos_cube, &
1614 log_filename=.false., mpi_io=mpi_io)
1615 WRITE (title, *)
"WAVEFUNCTION ", ivector,
" spin ", ispin,
" i.e. LUMO + ", ivector - ifirst
1616 CALL cp_pw_to_cube(wf_r, unit_nr, title, particles=particles, &
1617 stride=section_get_ivals(cube_section,
"STRIDE"), mpi_io=mpi_io)
1618 CALL cp_print_key_finished_output(unit_nr, logger, cube_section,
'', mpi_io=mpi_io)
1624 CALL auxbas_pw_pool%give_back_pw(wf_g)
1625 CALL auxbas_pw_pool%give_back_pw(wf_r)
1626 IF (
ASSOCIATED(list_index))
DEALLOCATE (list_index)
1628 END SUBROUTINE print_mo_cubes
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.
Handles all functions related to the CELL.
various utilities that regard array of different kinds: output, allocation,... maybe it is not a good...
methods related to the blacs parallel environment
Defines control structures, which contain the parameters and the settings for the DFT-based calculati...
DBCSR operations in CP2K.
subroutine, public copy_dbcsr_to_fm(matrix, fm)
Copy a DBCSR matrix to a BLACS matrix.
subroutine, public cp_dbcsr_write_sparse_matrix(sparse_matrix, before, after, qs_env, para_env, first_row, last_row, first_col, last_col, scale, output_unit, omit_headers)
...
various cholesky decomposition related routines
subroutine, public cp_fm_cholesky_decompose(matrix, n, info_out)
used to replace a symmetric positive def. matrix M with its cholesky decomposition U: M = U^T * U,...
subroutine, public cp_fm_cholesky_reduce(matrix, matrixb, itype)
reduce a matrix pencil A,B to normal form B has to be cholesky decomposed with cp_fm_cholesky_decompo...
subroutine, public cp_fm_cholesky_restore(matrix, neig, matrixb, matrixout, op, pos, transa)
...
used for collecting some of the diagonalization schemes available for cp_fm_type. cp_fm_power also mo...
subroutine, public choose_eigv_solver(matrix, eigenvectors, eigenvalues, info)
Choose the Eigensolver depending on which library is available ELPA seems to be unstable for small sy...
represent the structure of a full matrix
subroutine, public cp_fm_struct_create(fmstruct, para_env, context, nrow_global, ncol_global, nrow_block, ncol_block, descriptor, first_p_pos, local_leading_dimension, template_fmstruct, square_blocks, force_block)
allocates and initializes a full matrix structure
subroutine, public cp_fm_struct_release(fmstruct)
releases a full matrix structure
represent a full matrix distributed on many processors
subroutine, public cp_fm_get_info(matrix, name, nrow_global, ncol_global, nrow_block, ncol_block, nrow_local, ncol_local, row_indices, col_indices, local_data, context, nrow_locals, ncol_locals, matrix_struct, para_env)
returns all kind of information about the full matrix
subroutine, public cp_fm_to_fm_submat(msource, mtarget, nrow, ncol, s_firstrow, s_firstcol, t_firstrow, t_firstcol)
copy just a part ot the matrix
subroutine, public cp_fm_init_random(matrix, ncol, start_col)
fills a matrix with random numbers
subroutine, public cp_fm_create(matrix, matrix_struct, name, use_sp)
creates a new full matrix with the given structure
various routines to log and control the output. The idea is that decisions about where to log should ...
integer function, public cp_logger_get_default_io_unit(logger)
returns the unit nr for the ionode (-1 on all other processors) skips as well checks if the procs cal...
type(cp_logger_type) function, pointer, public cp_get_default_logger()
returns the default logger
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,...
integer, parameter, public cp_p_file
integer function, public cp_print_key_should_output(iteration_info, basis_section, print_key_path, used_print_key, first_time)
returns what should be done with the given property if btest(res,cp_p_store) then the property should...
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)
...
set of type/routines to handle the storage of results in force_envs
subroutine, public cp_results_erase(results, description, nval)
erase a part of result_list
set of type/routines to handle the storage of results in force_envs
Defines the basic variable types.
integer, parameter, public dp
integer, parameter, public default_string_length
integer, parameter, public default_path_length
Types and basic routines needed for a kpoint calculation.
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.
subroutine, public m_flush(lunit)
flushes units if the &GLOBAL flag is set accordingly
Definition of mathematical constants and functions.
real(kind=dp), parameter, public twopi
Utility routines for the memory handling.
Interface to the message passing library MPI.
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.
Calculates the moment integrals <a|r^m|b>
subroutine, public get_reference_point(rpoint, drpoint, qs_env, fist_env, reference, ref_point, ifirst, ilast)
...
compute mulliken charges we (currently) define them as c_i = 1/2 [ (PS)_{ii} + (SP)_{ii} ]
represent a simple array based list of the given type
Define the data structure for the particle information.
Definition of physical constants:
real(kind=dp), parameter, public debye
Provide various population analyses and print the requested output information.
subroutine, public lowdin_population_analysis(qs_env, output_unit, print_level)
Perform a Lowdin population analysis based on a symmetric orthogonalisation of the density matrix usi...
computes preconditioners, and implements methods to apply them currently used in qs_ot
methods of pw_env that have dependence on qs_env
subroutine, public pw_env_rebuild(pw_env, qs_env, external_para_env)
rebuilds the pw_env data (necessary if cell or cutoffs change)
subroutine, public pw_env_create(pw_env)
creates a pw_env, if qs_env is given calls pw_env_rebuild
container for various plainwaves related things
subroutine, public pw_env_release(pw_env, para_env)
releases the given pw_env (see doc/ReferenceCounting.html)
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
subroutine, public pw_derive(pw, n)
Calculate the derivative of a plane wave vector.
functions related to the poisson solver on regular grids
subroutine, public pw_green_create(green, poisson_params, cell_hmat, pw_pool, mt_super_ref_pw_grid, dct_pw_grid)
Allocates and sets up the green functions for the fft based poisson solvers.
subroutine, public pw_green_release(gftype, pw_pool)
destroys the type (deallocates data)
integer, parameter, public do_ewald_none
integer, parameter, public pw_poisson_analytic
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_rho_elec(matrix_p, matrix_p_kp, rho, rho_gspace, total_rho, ks_env, soft_valid, compute_tau, compute_grad, basis_type, der_type, idir, task_list_external, pw_env_external)
computes the density corresponding to a given density matrix on the grid
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, external_vector)
maps a given wavefunction on the grid
Definition of the DFTB parameter types.
Working with the DFTB parameter types.
subroutine, public get_dftb_atom_param(dftb_parameter, name, typ, defined, z, zeff, natorb, lmax, skself, occupation, eta, energy, cutoff, xi, di, rcdisp, dudq)
...
Calculation and writing of density of states.
subroutine, public calculate_dos_kp(kpoints, qs_env, dft_section)
Compute and write density of states (kpoints)
subroutine, public calculate_dos(mos, dft_section)
Compute and write density of states.
Does all kind of post scf calculations for GPW/GAPW.
subroutine, public qs_elf_calc(qs_env, elf_r, rho_cutoff)
...
Does all kind of post scf calculations for GPW/GAPW.
subroutine, public energy_windows(qs_env)
...
subroutine, public get_qs_env(qs_env, atomic_kind_set, qs_kind_set, cell, super_cell, cell_ref, use_ref_cell, kpoints, dft_control, mos, sab_orb, sab_all, qmmm, qmmm_periodic, sac_ae, sac_ppl, sac_lri, sap_ppnl, sab_vdw, sab_scp, sap_oce, sab_lrc, sab_se, sab_xtbe, sab_tbe, sab_core, sab_xb, sab_xtb_nonbond, sab_almo, sab_kp, sab_kp_nosym, particle_set, energy, force, matrix_h, matrix_h_im, matrix_ks, matrix_ks_im, matrix_vxc, run_rtp, rtp, matrix_h_kp, matrix_h_im_kp, matrix_ks_kp, matrix_ks_im_kp, matrix_vxc_kp, kinetic_kp, matrix_s_kp, matrix_w_kp, matrix_s_ri_aux_kp, matrix_s, matrix_s_ri_aux, matrix_w, matrix_p_mp2, matrix_p_mp2_admm, rho, rho_xc, pw_env, ewald_env, ewald_pw, active_space, mpools, input, para_env, blacs_env, scf_control, rel_control, kinetic, qs_charges, vppl, rho_core, rho_nlcc, rho_nlcc_g, ks_env, ks_qmmm_env, wf_history, scf_env, local_particles, local_molecules, distribution_2d, dbcsr_dist, molecule_kind_set, molecule_set, subsys, cp_subsys, oce, local_rho_set, rho_atom_set, task_list, task_list_soft, rho0_atom_set, rho0_mpole, rhoz_set, ecoul_1c, rho0_s_rs, rho0_s_gs, do_kpoints, has_unit_metric, requires_mo_derivs, mo_derivs, mo_loc_history, nkind, natom, nelectron_total, nelectron_spin, efield, neighbor_list_id, linres_control, xas_env, virial, cp_ddapc_env, cp_ddapc_ewald, outer_scf_history, outer_scf_ihistory, x_data, et_coupling, dftb_potential, results, se_taper, se_store_int_env, se_nddo_mpole, se_nonbond_env, admm_env, lri_env, lri_density, exstate_env, ec_env, dispersion_env, gcp_env, vee, rho_external, external_vxc, mask, mp2_env, bs_env, kg_env, wanniercentres, atprop, ls_scf_env, do_transport, transport_env, v_hartree_rspace, s_mstruct_changed, rho_changed, potential_changed, forces_up_to_date, mscfg_env, almo_scf_env, gradient_history, variable_history, embed_pot, spin_embed_pot, polar_env, mos_last_converged, rhs)
Get the QUICKSTEP environment.
Define the quickstep kind type and their sub types.
subroutine, public get_qs_kind(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, 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_r3d_rs_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_potentials, pao_descriptors, nelec)
Get attributes of an atomic kind.
subroutine, public set_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, vppl, rho_core, rho_nlcc, rho_nlcc_g, vee, neighbor_list_id, kpoints, 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_nonbond, sab_vdw, sab_scp, sab_almo, sab_kp, sab_kp_nosym, task_list, task_list_soft, subsys, dft_control, dbcsr_dist, distribution_2d, pw_env, para_env, blacs_env)
...
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_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)
...
collects routines that perform operations directly related to MOs
subroutine, public make_mo_eig(mos, nspins, ks_rmpv, scf_control, mo_derivs, admm_env)
Calculate KS eigenvalues starting from OF MOS.
Set occupation of molecular orbitals.
Definition and initialisation of the mo data type.
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.
an eigen-space solver for the generalised symmetric eigenvalue problem for sparse matrices,...
subroutine, public ot_eigensolver(matrix_h, matrix_s, matrix_orthogonal_space_fm, matrix_c_fm, preconditioner, eps_gradient, iter_max, size_ortho_space, silent, ot_settings)
...
Calculation and writing of projected density of states The DOS is computed per angular momentum and p...
subroutine, public calculate_projected_dos(mo_set, atomic_kind_set, qs_kind_set, particle_set, qs_env, dft_section, ispin, xas_mittle, external_matrix_shalf)
Compute and write projected density of states.
methods of the rho structure (defined in qs_rho_types)
subroutine, public qs_rho_rebuild(rho, qs_env, rebuild_ao, rebuild_grids, admm, pw_env_external)
rebuilds rho (if necessary allocating and initializing it)
superstucture that hold various representations of the density and keeps track of which ones are vali...
subroutine, public qs_rho_set(rho_struct, rho_ao, rho_ao_im, rho_ao_kp, rho_ao_im_kp, rho_r, drho_r, rho_g, drho_g, tau_r, tau_g, rho_r_valid, drho_r_valid, rho_g_valid, drho_g_valid, tau_r_valid, tau_g_valid, tot_rho_r, tot_rho_g, rho_r_sccs, soft_valid, complex_rho_ao)
...
subroutine, public qs_rho_get(rho_struct, rho_ao, rho_ao_im, rho_ao_kp, rho_ao_im_kp, rho_r, drho_r, rho_g, drho_g, tau_r, tau_g, rho_r_valid, drho_r_valid, rho_g_valid, drho_g_valid, tau_r_valid, tau_g_valid, tot_rho_r, tot_rho_g, rho_r_sccs, soft_valid, complex_rho_ao)
returns info about the density described by this object. If some representation is not available an e...
Functions to print the KS and S matrix in the CSR format to file.
subroutine, public write_s_matrix_csr(qs_env, input)
writing the overlap matrix in csr format into a file
subroutine, public write_ks_matrix_csr(qs_env, input)
writing the KS matrix in csr format into a file
subroutine, public qs_scf_write_mos(qs_env, scf_env, final_mos)
Write the MO eigenvector, eigenvalues, and occupation numbers to the output unit.
Does all kind of post scf calculations for DFTB.
subroutine, public scf_post_calculation_tb(qs_env, tb_type, no_mos)
collects possible post - scf calculations and prints info / computes properties.
subroutine, public make_lumo_tb(qs_env, scf_env, unoccupied_orbs, unoccupied_evals, nlumo, nlumos)
Gets the lumos, and eigenvalues for the lumos.
module that contains the definitions of the scf types
integer, parameter, public ot_method_nr
Does all kind of post scf calculations for GPW/GAPW.
subroutine, public wfn_mix(mos, particle_set, dft_section, qs_kind_set, para_env, output_unit, unoccupied_orbs, scf_env, matrix_s, marked_states, for_rtp)
writes a new 'mixed' set of mos to restart file, without touching the current MOs
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)
...
parameters that control an scf iteration
Calculation of STM image as post processing of an electronic structure calculation,...
subroutine, public th_stm_image(qs_env, stm_section, particles, unoccupied_orbs, unoccupied_evals)
Driver for the calculation of STM image, as post processing of a ground-state electronic structure ca...
generate the tasks lists used by collocate and integrate routines
subroutine, public generate_qs_task_list(ks_env, task_list, reorder_rs_grid_ranks, skip_load_balance_distributed, soft_valid, basis_type, pw_env_external, sab_orb_external)
...
subroutine, public allocate_task_list(task_list)
allocates and initialised the components of the task_list_type
Definition of the xTB parameter types.
subroutine, public get_xtb_atom_param(xtb_parameter, symbol, aname, typ, defined, z, zeff, natorb, lmax, nao, lao, rcut, rcov, kx, eta, xgamma, alpha, zneff, nshell, nval, lval, kpoly, kappa, hen, zeta, occupation, electronegativity, chmax)
...
Provides all information about an atomic kind.
Type defining parameters related to the simulation cell.
represent a pointer to a 1d array
represent a blacs multidimensional parallel environment (for the mpi corrispective see cp_paratypes/m...
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...
contains arbitrary information which need to be stored
Contains information about kpoints.
stores all the informations relevant to an mpi environment
represent a list of objects
contained for different pw related things
contains all the informations needed by the fft based poisson solvers
parameters for the poisson solver independet of input_section
to create arrays of pools
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 ...
keeps the density in various representations, keeping track of which ones are valid.