201#include "./base/base_uses.f90"
207 CHARACTER(len=*),
PARAMETER,
PRIVATE :: moduleN =
'qs_scf_post_gpw'
240 CHARACTER(6),
OPTIONAL :: wf_type
241 LOGICAL,
OPTIONAL :: do_mp2
243 CHARACTER(len=*),
PARAMETER :: routinen =
'scf_post_calculation_gpw'
245 INTEGER :: handle, homo, ispin, min_lumos, n_rep, &
246 nchk_nmoloc, nhomo, nlumo, nlumo_stm, &
247 nlumos, nmo, nspins, output_unit, &
249 INTEGER,
DIMENSION(:, :, :),
POINTER :: marked_states
250 LOGICAL :: check_write, compute_lumos, do_homo, do_kpoints,
do_mixed, do_mo_cubes, do_stm, &
251 do_wannier_cubes, has_homo, has_lumo, loc_explicit, loc_print_explicit, my_do_mp2, &
252 my_localized_wfn, p_loc, p_loc_homo, p_loc_lumo, p_loc_mixed
254 REAL(kind=
dp) :: gap, homo_lumo(2, 2), total_zeff_corr
255 REAL(kind=
dp),
DIMENSION(:),
POINTER :: mo_eigenvalues
258 TYPE(
cp_1d_r_p_type),
DIMENSION(:),
POINTER :: mixed_evals, occupied_evals, &
259 unoccupied_evals, unoccupied_evals_stm
260 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:) :: mixed_orbs, occupied_orbs
261 TYPE(
cp_fm_type),
ALLOCATABLE,
DIMENSION(:), &
262 TARGET :: homo_localized, lumo_localized, &
264 TYPE(
cp_fm_type),
DIMENSION(:),
POINTER :: lumo_ptr, mo_loc_history, &
265 unoccupied_orbs, unoccupied_orbs_stm
268 TYPE(
dbcsr_p_type),
DIMENSION(:),
POINTER :: ks_rmpv, matrix_p_mp2, matrix_s, &
270 TYPE(
dbcsr_p_type),
DIMENSION(:, :),
POINTER :: kinetic_m, rho_ao
282 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
290 localize_section, print_key, &
293 CALL timeset(routinen, handle)
300 IF (
PRESENT(do_mp2)) my_do_mp2 = do_mp2
301 IF (
PRESENT(wf_type))
THEN
302 IF (output_unit > 0)
THEN
303 WRITE (unit=output_unit, fmt=
'(/,(T1,A))') repeat(
"-", 40)
304 WRITE (unit=output_unit, fmt=
'(/,(T3,A,T19,A,T25,A))')
"Properties from ", wf_type,
" density"
305 WRITE (unit=output_unit, fmt=
'(/,(T1,A))') repeat(
"-", 40)
312 my_localized_wfn = .false.
313 NULLIFY (admm_env, dft_control, pw_env, auxbas_pw_pool, pw_pools, mos, rho, &
314 mo_coeff, ks_rmpv, matrix_s, qs_loc_env_homo, qs_loc_env_lumo, scf_control, &
315 unoccupied_orbs, mo_eigenvalues, unoccupied_evals, &
316 unoccupied_evals_stm, molecule_set, mo_derivs, &
317 subsys, particles, input, print_key, kinetic_m, marked_states, &
318 mixed_evals, qs_loc_env_mixed)
319 NULLIFY (lumo_ptr, rho_ao)
326 p_loc_mixed = .false.
328 cpassert(
ASSOCIATED(scf_env))
329 cpassert(
ASSOCIATED(qs_env))
332 dft_control=dft_control, &
333 molecule_set=molecule_set, &
334 scf_control=scf_control, &
335 do_kpoints=do_kpoints, &
340 particle_set=particle_set, &
341 atomic_kind_set=atomic_kind_set, &
342 qs_kind_set=qs_kind_set)
349 CALL get_qs_env(qs_env, matrix_p_mp2=matrix_p_mp2)
350 DO ispin = 1, dft_control%nspins
351 CALL dbcsr_add(rho_ao(ispin, 1)%matrix, matrix_p_mp2(ispin)%matrix, 1.0_dp, 1.0_dp)
356 CALL update_hartree_with_mp2(rho, qs_env)
359 CALL write_available_results(qs_env, scf_env)
363 "DFT%PRINT%KINETIC_ENERGY") /= 0)
THEN
365 cpassert(
ASSOCIATED(kinetic_m))
366 cpassert(
ASSOCIATED(kinetic_m(1, 1)%matrix))
370 IF (unit_nr > 0)
THEN
371 WRITE (unit_nr,
'(T3,A,T55,F25.14)')
"Electronic kinetic energy:", e_kin
374 "DFT%PRINT%KINETIC_ENERGY")
378 CALL qs_scf_post_charges(input, logger, qs_env)
391 IF (loc_print_explicit)
THEN
411 IF (loc_explicit)
THEN
421 p_loc_mixed = .false.
425 IF (n_rep == 0 .AND. p_loc_lumo)
THEN
426 CALL cp_abort(__location__,
"No LIST_UNOCCUPIED was specified, "// &
427 "therefore localization of unoccupied states will be skipped!")
440 IF (loc_print_explicit)
THEN
444 do_wannier_cubes = .false.
450 IF (((do_mo_cubes .OR. do_wannier_cubes) .AND. (nlumo /= 0 .OR. nhomo /= 0)) .OR. p_loc)
THEN
451 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool, &
453 CALL auxbas_pw_pool%create_pw(wf_r)
454 CALL auxbas_pw_pool%create_pw(wf_g)
457 IF (dft_control%restricted)
THEN
461 nspins = dft_control%nspins
464 IF (dft_control%restricted .AND. (do_mo_cubes .OR. p_loc_homo))
THEN
465 CALL cp_abort(__location__,
"Unclear how we define MOs / localization in the restricted case ... ")
470 cpwarn_if(do_mo_cubes,
"Print MO cubes not implemented for k-point calculations")
475 IF ((do_mo_cubes .AND. nhomo /= 0) .OR. do_stm)
THEN
477 IF (dft_control%do_admm)
THEN
479 CALL make_mo_eig(mos, nspins, ks_rmpv, scf_control, mo_derivs, admm_env=admm_env)
481 IF (dft_control%hairy_probes)
THEN
482 scf_control%smear%do_smear = .false.
483 CALL make_mo_eig(mos, dft_control%nspins, ks_rmpv, scf_control, mo_derivs, &
485 probe=dft_control%probe)
487 CALL make_mo_eig(mos, dft_control%nspins, ks_rmpv, scf_control, mo_derivs)
490 DO ispin = 1, dft_control%nspins
491 CALL get_mo_set(mo_set=mos(ispin), eigenvalues=mo_eigenvalues, homo=homo)
492 homo_lumo(ispin, 1) = mo_eigenvalues(homo)
496 IF (do_mo_cubes .AND. nhomo /= 0)
THEN
499 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff, &
500 eigenvalues=mo_eigenvalues, homo=homo, nmo=nmo)
501 CALL qs_scf_post_occ_cubes(input, dft_section, dft_control, logger, qs_env, &
502 mo_coeff, wf_g, wf_r, particles, homo, ispin)
513 cpwarn(
"Localization not implemented for k-point calculations!")
514 ELSEIF (dft_control%restricted &
517 cpabort(
"ROKS works only with LOCALIZE METHOD NONE or JACOBI")
519 ALLOCATE (occupied_orbs(dft_control%nspins))
520 ALLOCATE (occupied_evals(dft_control%nspins))
521 ALLOCATE (homo_localized(dft_control%nspins))
522 DO ispin = 1, dft_control%nspins
523 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff, &
524 eigenvalues=mo_eigenvalues)
525 occupied_orbs(ispin) = mo_coeff
526 occupied_evals(ispin)%array => mo_eigenvalues
527 CALL cp_fm_create(homo_localized(ispin), occupied_orbs(ispin)%matrix_struct)
528 CALL cp_fm_to_fm(occupied_orbs(ispin), homo_localized(ispin))
531 CALL get_qs_env(qs_env, mo_loc_history=mo_loc_history)
534 ALLOCATE (qs_loc_env_homo)
537 CALL qs_loc_init(qs_env, qs_loc_env_homo, localize_section, homo_localized, do_homo, &
538 do_mo_cubes, mo_loc_history=mo_loc_history)
540 wf_r, wf_g, particles, occupied_orbs, occupied_evals, marked_states)
543 IF (qs_loc_env_homo%localized_wfn_control%use_history)
THEN
545 CALL set_qs_env(qs_env, mo_loc_history=mo_loc_history)
550 homo_localized, do_homo)
552 DEALLOCATE (occupied_orbs)
553 DEALLOCATE (occupied_evals)
555 IF (qs_loc_env_homo%do_localize)
THEN
556 CALL loc_dipole(input, dft_control, qs_loc_env_homo, logger, qs_env)
563 IF (do_mo_cubes .OR. p_loc_lumo)
THEN
565 cpwarn(
"Localization and MO related output not implemented for k-point calculations!")
568 compute_lumos = do_mo_cubes .AND. nlumo .NE. 0
569 compute_lumos = compute_lumos .OR. p_loc_lumo
571 DO ispin = 1, dft_control%nspins
572 CALL get_mo_set(mo_set=mos(ispin), homo=homo, nmo=nmo)
573 compute_lumos = compute_lumos .AND. homo == nmo
576 IF (do_mo_cubes .AND. .NOT. compute_lumos)
THEN
579 DO ispin = 1, dft_control%nspins
581 CALL get_mo_set(mo_set=mos(ispin), homo=homo, nmo=nmo, eigenvalues=mo_eigenvalues)
582 IF (nlumo > nmo - homo)
THEN
585 IF (nlumo .EQ. -1)
THEN
588 IF (output_unit > 0)
WRITE (output_unit, *)
" "
589 IF (output_unit > 0)
WRITE (output_unit, *)
" Lowest eigenvalues of the unoccupied subspace spin ", ispin
590 IF (output_unit > 0)
WRITE (output_unit, *)
"---------------------------------------------"
591 IF (output_unit > 0)
WRITE (output_unit,
'(4(1X,1F16.8))') mo_eigenvalues(homo + 1:homo + nlumo)
594 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff)
595 CALL qs_scf_post_unocc_cubes(input, dft_section, dft_control, logger, qs_env, &
596 mo_coeff, wf_g, wf_r, particles, nlumo, homo, ispin, lumo=homo + 1)
602 IF (compute_lumos)
THEN
605 IF (nlumo == 0) check_write = .false.
608 ALLOCATE (qs_loc_env_lumo)
611 min_lumos = max(maxval(qs_loc_env_lumo%localized_wfn_control%loc_states(:, :)), nlumo)
614 ALLOCATE (unoccupied_orbs(dft_control%nspins))
615 ALLOCATE (unoccupied_evals(dft_control%nspins))
616 CALL make_lumo_gpw(qs_env, scf_env, unoccupied_orbs, unoccupied_evals, min_lumos, nlumos)
617 lumo_ptr => unoccupied_orbs
618 DO ispin = 1, dft_control%nspins
620 homo_lumo(ispin, 2) = unoccupied_evals(ispin)%array(1)
622 IF (check_write)
THEN
623 IF (p_loc_lumo .AND. nlumo .NE. -1) nlumos = min(nlumo, nlumos)
625 CALL qs_scf_post_unocc_cubes(input, dft_section, dft_control, logger, qs_env, &
626 unoccupied_orbs(ispin), wf_g, wf_r, particles, nlumos, homo, ispin)
631 ALLOCATE (lumo_localized(dft_control%nspins))
632 DO ispin = 1, dft_control%nspins
633 CALL cp_fm_create(lumo_localized(ispin), unoccupied_orbs(ispin)%matrix_struct)
634 CALL cp_fm_to_fm(unoccupied_orbs(ispin), lumo_localized(ispin))
636 CALL qs_loc_init(qs_env, qs_loc_env_lumo, localize_section, lumo_localized, do_homo, do_mo_cubes, &
637 evals=unoccupied_evals)
638 CALL qs_loc_env_init(qs_loc_env_lumo, qs_loc_env_lumo%localized_wfn_control, qs_env, &
639 loc_coeff=unoccupied_orbs)
641 lumo_localized, wf_r, wf_g, particles, &
642 unoccupied_orbs, unoccupied_evals, marked_states)
643 CALL loc_write_restart(qs_loc_env_lumo, loc_print_section, mos, homo_localized, do_homo, &
644 evals=unoccupied_evals)
645 lumo_ptr => lumo_localized
649 IF (has_homo .AND. has_lumo)
THEN
650 IF (output_unit > 0)
WRITE (output_unit, *)
" "
651 DO ispin = 1, dft_control%nspins
652 IF (.NOT. scf_control%smear%do_smear)
THEN
653 gap = homo_lumo(ispin, 2) - homo_lumo(ispin, 1)
654 IF (output_unit > 0)
WRITE (output_unit,
'(T2,A,F12.6)') &
655 "HOMO - LUMO gap [eV] :", gap*
evolt
661 IF (p_loc_mixed)
THEN
663 cpwarn(
"Localization not implemented for k-point calculations!")
664 ELSEIF (dft_control%restricted)
THEN
665 IF (output_unit > 0)
WRITE (output_unit, *) &
666 " Unclear how we define MOs / localization in the restricted case... skipping"
669 ALLOCATE (mixed_orbs(dft_control%nspins))
670 ALLOCATE (mixed_evals(dft_control%nspins))
671 ALLOCATE (mixed_localized(dft_control%nspins))
672 DO ispin = 1, dft_control%nspins
673 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff, &
674 eigenvalues=mo_eigenvalues)
675 mixed_orbs(ispin) = mo_coeff
676 mixed_evals(ispin)%array => mo_eigenvalues
677 CALL cp_fm_create(mixed_localized(ispin), mixed_orbs(ispin)%matrix_struct)
678 CALL cp_fm_to_fm(mixed_orbs(ispin), mixed_localized(ispin))
681 CALL get_qs_env(qs_env, mo_loc_history=mo_loc_history)
684 total_zeff_corr = scf_env%sum_zeff_corr
685 ALLOCATE (qs_loc_env_mixed)
688 CALL qs_loc_init(qs_env, qs_loc_env_mixed, localize_section, mixed_localized, do_homo, &
689 do_mo_cubes, mo_loc_history=mo_loc_history, tot_zeff_corr=total_zeff_corr, &
692 DO ispin = 1, dft_control%nspins
693 CALL cp_fm_get_info(mixed_localized(ispin), ncol_global=nchk_nmoloc)
697 wf_r, wf_g, particles, mixed_orbs, mixed_evals, marked_states)
700 IF (qs_loc_env_mixed%localized_wfn_control%use_history)
THEN
702 CALL set_qs_env(qs_env, mo_loc_history=mo_loc_history)
709 DEALLOCATE (mixed_orbs)
710 DEALLOCATE (mixed_evals)
720 IF (((do_mo_cubes .OR. do_wannier_cubes) .AND. (nlumo /= 0 .OR. nhomo /= 0)) .OR. p_loc)
THEN
721 CALL auxbas_pw_pool%give_back_pw(wf_r)
722 CALL auxbas_pw_pool%give_back_pw(wf_g)
726 IF (.NOT. do_kpoints)
THEN
729 DEALLOCATE (qs_loc_env_homo)
733 DEALLOCATE (qs_loc_env_lumo)
735 IF (p_loc_mixed)
THEN
737 DEALLOCATE (qs_loc_env_mixed)
745 CALL get_qs_env(qs_env, matrix_s=matrix_s, para_env=para_env)
746 CALL wfn_mix(mos, particle_set, dft_section, qs_kind_set, para_env, &
747 output_unit, unoccupied_orbs=lumo_ptr, scf_env=scf_env, &
748 matrix_s=matrix_s, marked_states=marked_states)
752 IF (
ASSOCIATED(marked_states))
THEN
753 DEALLOCATE (marked_states)
757 IF (.NOT. do_kpoints)
THEN
758 IF (compute_lumos)
THEN
759 DO ispin = 1, dft_control%nspins
760 DEALLOCATE (unoccupied_evals(ispin)%array)
763 DEALLOCATE (unoccupied_evals)
764 DEALLOCATE (unoccupied_orbs)
771 cpwarn(
"STM not implemented for k-point calculations!")
773 NULLIFY (unoccupied_orbs_stm, unoccupied_evals_stm)
774 IF (nlumo_stm > 0)
THEN
775 ALLOCATE (unoccupied_orbs_stm(dft_control%nspins))
776 ALLOCATE (unoccupied_evals_stm(dft_control%nspins))
777 CALL make_lumo_gpw(qs_env, scf_env, unoccupied_orbs_stm, unoccupied_evals_stm, &
781 CALL th_stm_image(qs_env, stm_section, particles, unoccupied_orbs_stm, &
782 unoccupied_evals_stm)
784 IF (nlumo_stm > 0)
THEN
785 DO ispin = 1, dft_control%nspins
786 DEALLOCATE (unoccupied_evals_stm(ispin)%array)
788 DEALLOCATE (unoccupied_evals_stm)
795 CALL qs_scf_post_xray(input, dft_section, logger, qs_env, output_unit)
798 CALL qs_scf_post_efg(input, logger, qs_env)
801 CALL qs_scf_post_et(input, qs_env, dft_control)
804 CALL qs_scf_post_epr(input, logger, qs_env)
807 CALL qs_scf_post_molopt(input, logger, qs_env)
810 CALL qs_scf_post_elf(input, logger, qs_env)
817 DO ispin = 1, dft_control%nspins
818 CALL dbcsr_add(rho_ao(ispin, 1)%matrix, matrix_p_mp2(ispin)%matrix, 1.0_dp, -1.0_dp)
824 CALL timestop(handle)
837 SUBROUTINE make_lumo_gpw(qs_env, scf_env, unoccupied_orbs, unoccupied_evals, nlumo, nlumos)
841 TYPE(
cp_fm_type),
DIMENSION(:),
INTENT(INOUT) :: unoccupied_orbs
843 INTEGER,
INTENT(IN) :: nlumo
844 INTEGER,
INTENT(OUT) :: nlumos
846 CHARACTER(len=*),
PARAMETER :: routinen =
'make_lumo_gpw'
848 INTEGER :: handle, homo, ispin, n, nao, nmo, &
855 TYPE(
dbcsr_p_type),
DIMENSION(:),
POINTER :: ks_rmpv, matrix_s
862 CALL timeset(routinen, handle)
864 NULLIFY (mos, ks_rmpv, scf_control, dft_control, admm_env, para_env, blacs_env)
868 scf_control=scf_control, &
869 dft_control=dft_control, &
878 DO ispin = 1, dft_control%nspins
879 NULLIFY (unoccupied_evals(ispin)%array)
881 IF (output_unit > 0)
WRITE (output_unit, *)
" "
882 IF (output_unit > 0)
WRITE (output_unit, *)
" Lowest Eigenvalues of the unoccupied subspace spin ", ispin
883 IF (output_unit > 0)
WRITE (output_unit, fmt=
'(1X,A)')
"-----------------------------------------------------"
884 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff, homo=homo, nao=nao, nmo=nmo)
886 nlumos = max(1, min(nlumo, nao - nmo))
887 IF (nlumo == -1) nlumos = nao - nmo
888 ALLOCATE (unoccupied_evals(ispin)%array(nlumos))
890 nrow_global=n, ncol_global=nlumos)
891 CALL cp_fm_create(unoccupied_orbs(ispin), fm_struct_tmp, name=
"lumos")
896 NULLIFY (local_preconditioner)
897 IF (
ASSOCIATED(scf_env%ot_preconditioner))
THEN
898 local_preconditioner => scf_env%ot_preconditioner(1)%preconditioner
901 NULLIFY (local_preconditioner)
906 IF (dft_control%do_admm)
THEN
910 CALL ot_eigensolver(matrix_h=ks_rmpv(ispin)%matrix, matrix_s=matrix_s(1)%matrix, &
911 matrix_c_fm=unoccupied_orbs(ispin), &
912 matrix_orthogonal_space_fm=mo_coeff, &
913 eps_gradient=scf_control%eps_lumos, &
915 iter_max=scf_control%max_iter_lumos, &
916 size_ortho_space=nmo)
919 unoccupied_evals(ispin)%array, scr=output_unit, &
920 ionode=output_unit > 0)
923 IF (dft_control%do_admm)
THEN
929 CALL timestop(handle)
938 SUBROUTINE qs_scf_post_charges(input, logger, qs_env)
943 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_charges'
945 INTEGER :: handle, print_level, unit_nr
946 LOGICAL :: do_kpoints, print_it
949 CALL timeset(routinen, handle)
951 CALL get_qs_env(qs_env=qs_env, do_kpoints=do_kpoints)
959 log_filename=.false.)
962 IF (print_it) print_level = 2
964 IF (print_it) print_level = 3
966 cpwarn(
"Lowdin charges not implemented for k-point calculations!")
979 unit_nr =
cp_print_key_unit_nr(logger, input,
"PROPERTIES%FIT_CHARGE", extension=
".Fitcharge", &
980 log_filename=.false.)
982 CALL get_ddapc(qs_env, .false., density_fit_section, iwc=unit_nr)
986 CALL timestop(handle)
988 END SUBROUTINE qs_scf_post_charges
1004 SUBROUTINE qs_scf_post_occ_cubes(input, dft_section, dft_control, logger, qs_env, &
1005 mo_coeff, wf_g, wf_r, particles, homo, ispin)
1014 INTEGER,
INTENT(IN) :: homo, ispin
1016 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_occ_cubes'
1018 CHARACTER(LEN=default_path_length) :: filename, my_pos_cube, title
1019 INTEGER :: handle, i, ir, ivector, n_rep, nhomo, &
1021 INTEGER,
DIMENSION(:),
POINTER ::
list, list_index
1022 LOGICAL :: append_cube, mpi_io
1027 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1029 CALL timeset(routinen, handle)
1031 NULLIFY (list_index)
1037 my_pos_cube =
"REWIND"
1038 IF (append_cube)
THEN
1039 my_pos_cube =
"APPEND"
1048 IF (
ASSOCIATED(
list))
THEN
1050 DO i = 1,
SIZE(
list)
1051 list_index(i + nlist) =
list(i)
1053 nlist = nlist +
SIZE(
list)
1058 IF (nhomo == -1) nhomo = homo
1059 nlist = homo - max(1, homo - nhomo + 1) + 1
1060 ALLOCATE (list_index(nlist))
1062 list_index(i) = max(1, homo - nhomo + 1) + i - 1
1066 ivector = list_index(i)
1068 atomic_kind_set=atomic_kind_set, &
1069 qs_kind_set=qs_kind_set, &
1071 particle_set=particle_set, &
1074 cell, dft_control, particle_set, pw_env)
1075 WRITE (filename,
'(a4,I5.5,a1,I1.1)')
"WFN_", ivector,
"_", ispin
1078 middle_name=trim(filename), file_position=my_pos_cube, log_filename=.false., &
1080 WRITE (title, *)
"WAVEFUNCTION ", ivector,
" spin ", ispin,
" i.e. HOMO - ", ivector - homo
1081 CALL cp_pw_to_cube(wf_r, unit_nr, title, particles=particles, &
1085 IF (
ASSOCIATED(list_index))
DEALLOCATE (list_index)
1088 CALL timestop(handle)
1090 END SUBROUTINE qs_scf_post_occ_cubes
1108 SUBROUTINE qs_scf_post_unocc_cubes(input, dft_section, dft_control, logger, qs_env, &
1109 unoccupied_orbs, wf_g, wf_r, particles, nlumos, homo, ispin, lumo)
1115 TYPE(
cp_fm_type),
INTENT(IN) :: unoccupied_orbs
1119 INTEGER,
INTENT(IN) :: nlumos, homo, ispin
1120 INTEGER,
INTENT(IN),
OPTIONAL :: lumo
1122 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_unocc_cubes'
1124 CHARACTER(LEN=default_path_length) :: filename, my_pos_cube, title
1125 INTEGER :: handle, ifirst, index_mo, ivector, &
1127 LOGICAL :: append_cube, mpi_io
1132 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1134 CALL timeset(routinen, handle)
1138 NULLIFY (qs_kind_set, particle_set, pw_env, cell)
1140 my_pos_cube =
"REWIND"
1141 IF (append_cube)
THEN
1142 my_pos_cube =
"APPEND"
1145 IF (
PRESENT(lumo)) ifirst = lumo
1146 DO ivector = ifirst, ifirst + nlumos - 1
1148 atomic_kind_set=atomic_kind_set, &
1149 qs_kind_set=qs_kind_set, &
1151 particle_set=particle_set, &
1154 qs_kind_set, cell, dft_control, particle_set, pw_env)
1156 IF (ifirst == 1)
THEN
1157 index_mo = homo + ivector
1161 WRITE (filename,
'(a4,I5.5,a1,I1.1)')
"WFN_", index_mo,
"_", ispin
1165 middle_name=trim(filename), file_position=my_pos_cube, log_filename=.false., &
1167 WRITE (title, *)
"WAVEFUNCTION ", index_mo,
" spin ", ispin,
" i.e. LUMO + ", ifirst + ivector - 2
1168 CALL cp_pw_to_cube(wf_r, unit_nr, title, particles=particles, &
1174 CALL timestop(handle)
1176 END SUBROUTINE qs_scf_post_unocc_cubes
1189 INTEGER,
INTENT(IN) :: output_unit
1191 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_moments'
1193 CHARACTER(LEN=default_path_length) :: filename
1194 INTEGER :: handle, maxmom, reference, unit_nr
1195 LOGICAL :: com_nl, do_kpoints, magnetic, periodic, &
1196 second_ref_point, vel_reprs
1197 REAL(kind=
dp),
DIMENSION(:),
POINTER :: ref_point
1200 CALL timeset(routinen, handle)
1203 subsection_name=
"DFT%PRINT%MOMENTS")
1208 keyword_name=
"DFT%PRINT%MOMENTS%MAX_MOMENT")
1210 keyword_name=
"DFT%PRINT%MOMENTS%PERIODIC")
1212 keyword_name=
"DFT%PRINT%MOMENTS%REFERENCE")
1214 keyword_name=
"DFT%PRINT%MOMENTS%MAGNETIC")
1216 keyword_name=
"DFT%PRINT%MOMENTS%VEL_REPRS")
1218 keyword_name=
"DFT%PRINT%MOMENTS%COM_NL")
1220 keyword_name=
"DFT%PRINT%MOMENTS%SECOND_REFERENCE_POINT")
1225 print_key_path=
"DFT%PRINT%MOMENTS", extension=
".dat", &
1226 middle_name=
"moments", log_filename=.false.)
1228 IF (output_unit > 0)
THEN
1229 IF (unit_nr /= output_unit)
THEN
1230 INQUIRE (unit=unit_nr, name=filename)
1231 WRITE (unit=output_unit, fmt=
"(/,T2,A,2(/,T3,A),/)") &
1232 "MOMENTS",
"The electric/magnetic moments are written to file:", &
1235 WRITE (unit=output_unit, fmt=
"(/,T2,A)")
"ELECTRIC/MAGNETIC MOMENTS"
1239 CALL get_qs_env(qs_env, do_kpoints=do_kpoints)
1241 IF (do_kpoints)
THEN
1242 cpwarn(
"Moments not implemented for k-point calculations!")
1247 CALL qs_moment_locop(qs_env, magnetic, maxmom, reference, ref_point, unit_nr, vel_reprs, com_nl)
1252 basis_section=input, print_key_path=
"DFT%PRINT%MOMENTS")
1254 IF (second_ref_point)
THEN
1256 keyword_name=
"DFT%PRINT%MOMENTS%REFERENCE_2")
1261 print_key_path=
"DFT%PRINT%MOMENTS", extension=
".dat", &
1262 middle_name=
"moments_refpoint_2", log_filename=.false.)
1264 IF (output_unit > 0)
THEN
1265 IF (unit_nr /= output_unit)
THEN
1266 INQUIRE (unit=unit_nr, name=filename)
1267 WRITE (unit=output_unit, fmt=
"(/,T2,A,2(/,T3,A),/)") &
1268 "MOMENTS",
"The electric/magnetic moments for the second reference point are written to file:", &
1271 WRITE (unit=output_unit, fmt=
"(/,T2,A)")
"ELECTRIC/MAGNETIC MOMENTS"
1274 IF (do_kpoints)
THEN
1275 cpwarn(
"Moments not implemented for k-point calculations!")
1280 CALL qs_moment_locop(qs_env, magnetic, maxmom, reference, ref_point, unit_nr, vel_reprs, com_nl)
1284 basis_section=input, print_key_path=
"DFT%PRINT%MOMENTS")
1289 CALL timestop(handle)
1301 SUBROUTINE qs_scf_post_xray(input, dft_section, logger, qs_env, output_unit)
1306 INTEGER,
INTENT(IN) :: output_unit
1308 CHARACTER(LEN=*),
PARAMETER :: routinen =
'qs_scf_post_xray'
1310 CHARACTER(LEN=default_path_length) :: filename
1311 INTEGER :: handle, unit_nr
1312 REAL(kind=
dp) :: q_max
1315 CALL timeset(routinen, handle)
1318 subsection_name=
"DFT%PRINT%XRAY_DIFFRACTION_SPECTRUM")
1322 keyword_name=
"PRINT%XRAY_DIFFRACTION_SPECTRUM%Q_MAX")
1324 basis_section=input, &
1325 print_key_path=
"DFT%PRINT%XRAY_DIFFRACTION_SPECTRUM", &
1327 middle_name=
"xrd", &
1328 log_filename=.false.)
1329 IF (output_unit > 0)
THEN
1330 INQUIRE (unit=unit_nr, name=filename)
1331 WRITE (unit=output_unit, fmt=
"(/,/,T2,A)") &
1332 "X-RAY DIFFRACTION SPECTRUM"
1333 IF (unit_nr /= output_unit)
THEN
1334 WRITE (unit=output_unit, fmt=
"(/,T3,A,/,/,T3,A,/)") &
1335 "The coherent X-ray diffraction spectrum is written to the file:", &
1340 unit_number=unit_nr, &
1344 basis_section=input, &
1345 print_key_path=
"DFT%PRINT%XRAY_DIFFRACTION_SPECTRUM")
1348 CALL timestop(handle)
1350 END SUBROUTINE qs_scf_post_xray
1358 SUBROUTINE qs_scf_post_efg(input, logger, qs_env)
1363 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_efg'
1368 CALL timeset(routinen, handle)
1371 subsection_name=
"DFT%PRINT%ELECTRIC_FIELD_GRADIENT")
1377 CALL timestop(handle)
1379 END SUBROUTINE qs_scf_post_efg
1387 SUBROUTINE qs_scf_post_et(input, qs_env, dft_control)
1392 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_et'
1394 INTEGER :: handle, ispin
1396 TYPE(
cp_fm_type),
DIMENSION(:),
POINTER :: my_mos
1399 CALL timeset(routinen, handle)
1405 IF (qs_env%et_coupling%first_run)
THEN
1407 ALLOCATE (my_mos(dft_control%nspins))
1408 ALLOCATE (qs_env%et_coupling%et_mo_coeff(dft_control%nspins))
1409 DO ispin = 1, dft_control%nspins
1411 matrix_struct=qs_env%mos(ispin)%mo_coeff%matrix_struct, &
1412 name=
"FIRST_RUN_COEFF"//trim(adjustl(
cp_to_string(ispin)))//
"MATRIX")
1421 CALL timestop(handle)
1423 END SUBROUTINE qs_scf_post_et
1434 SUBROUTINE qs_scf_post_elf(input, logger, qs_env)
1439 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_elf'
1441 CHARACTER(LEN=default_path_length) :: filename, mpi_filename, my_pos_cube, &
1443 INTEGER :: handle, ispin, output_unit, unit_nr
1444 LOGICAL :: append_cube, gapw, mpi_io
1445 REAL(
dp) :: rho_cutoff
1455 CALL timeset(routinen, handle)
1462 NULLIFY (dft_control, pw_env, auxbas_pw_pool, pw_pools, particles, subsys)
1463 CALL get_qs_env(qs_env, dft_control=dft_control, pw_env=pw_env, subsys=subsys)
1466 gapw = dft_control%qs_control%gapw
1467 IF (.NOT. gapw)
THEN
1469 ALLOCATE (elf_r(dft_control%nspins))
1470 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool, &
1472 DO ispin = 1, dft_control%nspins
1473 CALL auxbas_pw_pool%create_pw(elf_r(ispin))
1477 IF (output_unit > 0)
THEN
1478 WRITE (unit=output_unit, fmt=
"(/,T15,A,/)") &
1479 " ----- ELF is computed on the real space grid -----"
1486 my_pos_cube =
"REWIND"
1487 IF (append_cube)
THEN
1488 my_pos_cube =
"APPEND"
1491 DO ispin = 1, dft_control%nspins
1492 WRITE (filename,
'(a5,I1.1)')
"ELF_S", ispin
1493 WRITE (title, *)
"ELF spin ", ispin
1496 middle_name=trim(filename), file_position=my_pos_cube, log_filename=.false., &
1497 mpi_io=mpi_io, fout=mpi_filename)
1498 IF (output_unit > 0)
THEN
1499 IF (.NOT. mpi_io)
THEN
1500 INQUIRE (unit=unit_nr, name=filename)
1502 filename = mpi_filename
1504 WRITE (unit=output_unit, fmt=
"(/,T2,A,/,/,T2,A)") &
1505 "ELF is written in cube file format to the file:", &
1509 CALL cp_pw_to_cube(elf_r(ispin), unit_nr, title, particles=particles, &
1513 CALL auxbas_pw_pool%give_back_pw(elf_r(ispin))
1521 cpwarn(
"ELF not implemented for GAPW calculations!")
1526 CALL timestop(handle)
1528 END SUBROUTINE qs_scf_post_elf
1540 SUBROUTINE qs_scf_post_molopt(input, logger, qs_env)
1545 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_molopt'
1547 INTEGER :: handle, nao, unit_nr
1548 REAL(kind=
dp) :: s_cond_number
1549 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: eigenvalues
1558 CALL timeset(routinen, handle)
1561 subsection_name=
"DFT%PRINT%BASIS_MOLOPT_QUANTITIES")
1565 CALL get_qs_env(qs_env, energy=energy, matrix_s=matrix_s, mos=mos)
1568 CALL get_mo_set(mo_set=mos(1), mo_coeff=mo_coeff, nao=nao)
1570 nrow_global=nao, ncol_global=nao, &
1571 template_fmstruct=mo_coeff%matrix_struct)
1572 CALL cp_fm_create(fm_s, matrix_struct=ao_ao_fmstruct, &
1574 CALL cp_fm_create(fm_work, matrix_struct=ao_ao_fmstruct, &
1577 ALLOCATE (eigenvalues(nao))
1585 s_cond_number = maxval(abs(eigenvalues))/max(minval(abs(eigenvalues)), epsilon(0.0_dp))
1588 extension=
".molopt")
1590 IF (unit_nr > 0)
THEN
1593 WRITE (unit_nr,
'(T2,A28,2A25)')
"",
"Tot. Ener.",
"S Cond. Numb."
1594 WRITE (unit_nr,
'(T2,A28,2E25.17)')
"BASIS_MOLOPT_QUANTITIES", energy%total, s_cond_number
1598 "DFT%PRINT%BASIS_MOLOPT_QUANTITIES")
1602 CALL timestop(handle)
1604 END SUBROUTINE qs_scf_post_molopt
1612 SUBROUTINE qs_scf_post_epr(input, logger, qs_env)
1617 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_epr'
1622 CALL timeset(routinen, handle)
1625 subsection_name=
"DFT%PRINT%HYPERFINE_COUPLING_TENSOR")
1631 CALL timestop(handle)
1633 END SUBROUTINE qs_scf_post_epr
1642 SUBROUTINE write_available_results(qs_env, scf_env)
1646 CHARACTER(len=*),
PARAMETER :: routinen =
'write_available_results'
1650 CALL timeset(routinen, handle)
1658 CALL timestop(handle)
1660 END SUBROUTINE write_available_results
1673 CHARACTER(len=*),
PARAMETER :: routinen =
'write_mo_dependent_results'
1675 INTEGER :: handle, homo, ispin, nmo, output_unit
1676 LOGICAL :: all_equal, do_kpoints, explicit
1677 REAL(kind=
dp) :: maxocc, s_square, s_square_ideal, &
1678 total_abs_spin_dens, total_spin_dens
1679 REAL(kind=
dp),
DIMENSION(:),
POINTER :: mo_eigenvalues, occupation_numbers
1685 TYPE(
dbcsr_p_type),
DIMENSION(:),
POINTER :: ks_rmpv, matrix_s
1698 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1707 CALL timeset(routinen, handle)
1709 NULLIFY (cell, dft_control, pw_env, auxbas_pw_pool, pw_pools, mo_coeff, &
1710 mo_coeff_deriv, mo_eigenvalues, mos, atomic_kind_set, qs_kind_set, &
1711 particle_set, rho, ks_rmpv, matrix_s, scf_control, dft_section, &
1712 molecule_set, input, particles, subsys, rho_r)
1717 cpassert(
ASSOCIATED(qs_env))
1719 dft_control=dft_control, &
1720 molecule_set=molecule_set, &
1721 atomic_kind_set=atomic_kind_set, &
1722 particle_set=particle_set, &
1723 qs_kind_set=qs_kind_set, &
1724 admm_env=admm_env, &
1725 scf_control=scf_control, &
1734 CALL get_qs_env(qs_env, do_kpoints=do_kpoints)
1738 IF (.NOT. qs_env%run_rtp)
THEN
1745 IF (.NOT. do_kpoints)
THEN
1746 CALL get_qs_env(qs_env, mos=mos, matrix_ks=ks_rmpv)
1752 dft_section,
"PRINT%CHARGEMOL"), &
1761 IF (do_kpoints)
THEN
1772 IF (do_kpoints)
THEN
1773 cpwarn(
"Projected density of states (pDOS) is not implemented for k points")
1778 DO ispin = 1, dft_control%nspins
1780 IF (dft_control%do_admm)
THEN
1783 IF (
PRESENT(scf_env))
THEN
1785 CALL get_mo_set(mo_set=mos(ispin), mo_coeff=mo_coeff, &
1786 eigenvalues=mo_eigenvalues)
1787 IF (
ASSOCIATED(qs_env%mo_derivs))
THEN
1788 mo_coeff_deriv => qs_env%mo_derivs(ispin)%matrix
1790 mo_coeff_deriv => null()
1793 do_rotation=.true., &
1794 co_rotate_dbcsr=mo_coeff_deriv)
1798 IF (dft_control%nspins == 2)
THEN
1800 qs_kind_set, particle_set, qs_env, dft_section, ispin=ispin)
1803 qs_kind_set, particle_set, qs_env, dft_section)
1806 IF (dft_control%do_admm)
THEN
1815 IF (dft_control%nspins == 2)
THEN
1817 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env)
1818 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool, &
1820 CALL auxbas_pw_pool%create_pw(wf_r)
1822 CALL pw_axpy(rho_r(2), wf_r, alpha=-1._dp)
1824 IF (output_unit > 0)
WRITE (unit=output_unit, fmt=
'(/,(T3,A,T61,F20.10))') &
1825 "Integrated spin density: ", total_spin_dens
1827 IF (output_unit > 0)
WRITE (unit=output_unit, fmt=
'((T3,A,T61,F20.10))') &
1828 "Integrated absolute spin density: ", total_abs_spin_dens
1829 CALL auxbas_pw_pool%give_back_pw(wf_r)
1835 IF (do_kpoints)
THEN
1836 cpwarn(
"Spin contamination estimate not implemented for k-points.")
1839 DO ispin = 1, dft_control%nspins
1841 occupation_numbers=occupation_numbers, &
1846 all_equal = all_equal .AND. &
1847 (all(occupation_numbers(1:homo) == maxocc) .AND. &
1848 all(occupation_numbers(homo + 1:nmo) == 0.0_dp))
1851 IF (.NOT. all_equal)
THEN
1852 IF (output_unit > 0)
WRITE (unit=output_unit, fmt=
"(T3,A)") &
1853 "WARNING: S**2 computation does not yet treat fractional occupied orbitals"
1856 matrix_s=matrix_s, &
1859 s_square_ideal=s_square_ideal)
1860 IF (output_unit > 0)
WRITE (unit=output_unit, fmt=
'(T3,A,T51,2F15.6)') &
1861 "Ideal and single determinant S**2 : ", s_square_ideal, s_square
1862 energy%s_square = s_square
1867 CALL timestop(handle)
1879 CHARACTER(len=*),
PARAMETER :: routinen =
'write_mo_free_results'
1880 CHARACTER(len=1),
DIMENSION(3),
PARAMETER :: cdir = (/
"x",
"y",
"z"/)
1882 CHARACTER(LEN=2) :: element_symbol
1883 CHARACTER(LEN=default_path_length) :: filename, mpi_filename, my_pos_cube, &
1885 CHARACTER(LEN=default_string_length) :: name, print_density
1886 INTEGER :: after, handle, i, iat, id, ikind, img, iso, ispin, iw, l, n_rep_hf, natom, nd(3), &
1887 ngto, niso, nkind, np, nr, output_unit, print_level, should_print_bqb, should_print_voro, &
1888 unit_nr, unit_nr_voro
1889 LOGICAL :: append_cube, append_voro, do_hfx, do_kpoints, mpi_io, omit_headers, print_it, &
1890 rho_r_valid, voro_print_txt, write_ks, write_xc, xrd_interface
1892 rho_total, rho_total_rspace, udvol, &
1894 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: bfun
1895 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :, :) :: aedens, ccdens, ppdens
1896 REAL(kind=
dp),
DIMENSION(3) :: dr
1897 REAL(kind=
dp),
DIMENSION(:),
POINTER :: my_q0
1903 TYPE(
dbcsr_p_type),
DIMENSION(:, :),
POINTER :: ks_rmpv, matrix_vxc, rho_ao
1911 TYPE(
pw_c1d_gs_type),
POINTER :: rho0_s_gs, rho_core, rhoz_cneo_s_gs
1918 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
1926 print_key, print_key_bqb, &
1927 print_key_voro, xc_section
1929 CALL timeset(routinen, handle)
1930 NULLIFY (cell, dft_control, pw_env, auxbas_pw_pool, pw_pools, hfx_section, &
1931 atomic_kind_set, qs_kind_set, particle_set, rho, ks_rmpv, rho_ao, rho_r, &
1932 dft_section, xc_section, input, particles, subsys, matrix_vxc, v_hartree_rspace, &
1938 cpassert(
ASSOCIATED(qs_env))
1940 atomic_kind_set=atomic_kind_set, &
1941 qs_kind_set=qs_kind_set, &
1942 particle_set=particle_set, &
1944 para_env=para_env, &
1945 dft_control=dft_control, &
1947 do_kpoints=do_kpoints, &
1957 "DFT%PRINT%TOT_DENSITY_CUBE"),
cp_p_file))
THEN
1958 NULLIFY (rho_core, rho0_s_gs, rhoz_cneo_s_gs)
1960 my_pos_cube =
"REWIND"
1961 IF (append_cube)
THEN
1962 my_pos_cube =
"APPEND"
1965 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env, rho_core=rho_core, &
1966 rho0_s_gs=rho0_s_gs, rhoz_cneo_s_gs=rhoz_cneo_s_gs)
1967 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool, &
1969 CALL auxbas_pw_pool%create_pw(wf_r)
1970 IF (dft_control%qs_control%gapw)
THEN
1971 IF (dft_control%qs_control%gapw_control%nopaw_as_gpw)
THEN
1972 CALL pw_axpy(rho_core, rho0_s_gs)
1973 IF (
ASSOCIATED(rhoz_cneo_s_gs))
THEN
1974 CALL pw_axpy(rhoz_cneo_s_gs, rho0_s_gs)
1977 CALL pw_axpy(rho_core, rho0_s_gs, -1.0_dp)
1978 IF (
ASSOCIATED(rhoz_cneo_s_gs))
THEN
1979 CALL pw_axpy(rhoz_cneo_s_gs, rho0_s_gs, -1.0_dp)
1982 IF (
ASSOCIATED(rhoz_cneo_s_gs))
THEN
1983 CALL pw_axpy(rhoz_cneo_s_gs, rho0_s_gs)
1986 IF (
ASSOCIATED(rhoz_cneo_s_gs))
THEN
1987 CALL pw_axpy(rhoz_cneo_s_gs, rho0_s_gs, -1.0_dp)
1993 DO ispin = 1, dft_control%nspins
1994 CALL pw_axpy(rho_r(ispin), wf_r)
1996 filename =
"TOTAL_DENSITY"
1999 extension=
".cube", middle_name=trim(filename), file_position=my_pos_cube, &
2000 log_filename=.false., mpi_io=mpi_io)
2002 particles=particles, &
2003 stride=
section_get_ivals(dft_section,
"PRINT%TOT_DENSITY_CUBE%STRIDE"), mpi_io=mpi_io)
2005 "DFT%PRINT%TOT_DENSITY_CUBE", mpi_io=mpi_io)
2006 CALL auxbas_pw_pool%give_back_pw(wf_r)
2011 "DFT%PRINT%E_DENSITY_CUBE"),
cp_p_file))
THEN
2013 keyword_name=
"PRINT%E_DENSITY_CUBE%DENSITY_INCLUDE", &
2014 c_val=print_density)
2015 print_density = trim(print_density)
2017 my_pos_cube =
"REWIND"
2018 IF (append_cube)
THEN
2019 my_pos_cube =
"APPEND"
2023 xrd_interface =
section_get_lval(input,
"DFT%PRINT%E_DENSITY_CUBE%XRD_INTERFACE")
2024 IF (xrd_interface)
THEN
2026 IF (dft_control%qs_control%gapw) print_density =
"SOFT_DENSITY"
2028 filename =
"ELECTRON_DENSITY"
2030 extension=
".xrd", middle_name=trim(filename), &
2031 file_position=my_pos_cube, log_filename=.false.)
2033 IF (output_unit > 0)
THEN
2034 INQUIRE (unit=unit_nr, name=filename)
2035 WRITE (unit=output_unit, fmt=
"(/,T2,A,/,/,T2,A)") &
2036 "The electron density (atomic part) is written to the file:", &
2041 nkind =
SIZE(atomic_kind_set)
2042 IF (unit_nr > 0)
THEN
2043 WRITE (unit_nr, *)
"Atomic (core) densities"
2044 WRITE (unit_nr, *)
"Unit cell"
2045 WRITE (unit_nr, fmt=
"(3F20.12)") cell%hmat(1, 1), cell%hmat(1, 2), cell%hmat(1, 3)
2046 WRITE (unit_nr, fmt=
"(3F20.12)") cell%hmat(2, 1), cell%hmat(2, 2), cell%hmat(2, 3)
2047 WRITE (unit_nr, fmt=
"(3F20.12)") cell%hmat(3, 1), cell%hmat(3, 2), cell%hmat(3, 3)
2048 WRITE (unit_nr, *)
"Atomic types"
2049 WRITE (unit_nr, *) nkind
2052 ALLOCATE (ppdens(ngto, 2, nkind), aedens(ngto, 2, nkind), ccdens(ngto, 2, nkind))
2054 atomic_kind => atomic_kind_set(ikind)
2055 qs_kind => qs_kind_set(ikind)
2056 CALL get_atomic_kind(atomic_kind, name=name, element_symbol=element_symbol)
2058 iunit=output_unit, confine=.true.)
2060 iunit=output_unit, allelectron=.true., confine=.true.)
2061 ccdens(:, 1, ikind) = aedens(:, 1, ikind)
2062 ccdens(:, 2, ikind) = 0._dp
2063 CALL project_function_a(ccdens(1:ngto, 2, ikind), ccdens(1:ngto, 1, ikind), &
2064 ppdens(1:ngto, 2, ikind), ppdens(1:ngto, 1, ikind), 0)
2065 ccdens(:, 2, ikind) = aedens(:, 2, ikind) - ccdens(:, 2, ikind)
2066 IF (unit_nr > 0)
THEN
2067 WRITE (unit_nr, fmt=
"(I6,A10,A20)") ikind, trim(element_symbol), trim(name)
2068 WRITE (unit_nr, fmt=
"(I6)") ngto
2069 WRITE (unit_nr, *)
" Total density"
2070 WRITE (unit_nr, fmt=
"(2G24.12)") (aedens(i, 1, ikind), aedens(i, 2, ikind), i=1, ngto)
2071 WRITE (unit_nr, *)
" Core density"
2072 WRITE (unit_nr, fmt=
"(2G24.12)") (ccdens(i, 1, ikind), ccdens(i, 2, ikind), i=1, ngto)
2074 NULLIFY (atomic_kind)
2077 IF (dft_control%qs_control%gapw)
THEN
2078 CALL get_qs_env(qs_env=qs_env, rho_atom_set=rho_atom_set)
2080 IF (unit_nr > 0)
THEN
2081 WRITE (unit_nr, *)
"Coordinates and GAPW density"
2083 np = particles%n_els
2085 CALL get_atomic_kind(particles%els(iat)%atomic_kind, kind_number=ikind)
2086 CALL get_qs_kind(qs_kind_set(ikind), grid_atom=grid_atom)
2087 rho_atom => rho_atom_set(iat)
2088 IF (
ASSOCIATED(rho_atom%rho_rad_h(1)%r_coef))
THEN
2089 nr =
SIZE(rho_atom%rho_rad_h(1)%r_coef, 1)
2090 niso =
SIZE(rho_atom%rho_rad_h(1)%r_coef, 2)
2095 CALL para_env%sum(nr)
2096 CALL para_env%sum(niso)
2098 ALLOCATE (bfun(nr, niso))
2100 DO ispin = 1, dft_control%nspins
2101 IF (
ASSOCIATED(rho_atom%rho_rad_h(1)%r_coef))
THEN
2102 bfun(:, :) = bfun + rho_atom%rho_rad_h(ispin)%r_coef - rho_atom%rho_rad_s(ispin)%r_coef
2105 CALL para_env%sum(bfun)
2106 ccdens(:, 1, ikind) = ppdens(:, 1, ikind)
2107 ccdens(:, 2, ikind) = 0._dp
2108 IF (unit_nr > 0)
THEN
2109 WRITE (unit_nr,
'(I10,I5,3f12.6)') iat, ikind, particles%els(iat)%r
2113 CALL project_function_b(ccdens(:, 2, ikind), ccdens(:, 1, ikind), bfun(:, iso), grid_atom, l)
2114 IF (unit_nr > 0)
THEN
2115 WRITE (unit_nr, fmt=
"(3I6)") iso, l, ngto
2116 WRITE (unit_nr, fmt=
"(2G24.12)") (ccdens(i, 1, ikind), ccdens(i, 2, ikind), i=1, ngto)
2122 IF (unit_nr > 0)
THEN
2123 WRITE (unit_nr, *)
"Coordinates"
2124 np = particles%n_els
2126 CALL get_atomic_kind(particles%els(iat)%atomic_kind, kind_number=ikind)
2127 WRITE (unit_nr,
'(I10,I5,3f12.6)') iat, ikind, particles%els(iat)%r
2132 DEALLOCATE (ppdens, aedens, ccdens)
2135 "DFT%PRINT%E_DENSITY_CUBE")
2138 IF (dft_control%qs_control%gapw .AND. print_density ==
"TOTAL_DENSITY")
THEN
2140 cpassert(.NOT. do_kpoints)
2145 auxbas_pw_pool=auxbas_pw_pool, &
2147 CALL auxbas_pw_pool%create_pw(pw=rho_elec_rspace)
2149 CALL auxbas_pw_pool%create_pw(pw=rho_elec_gspace)
2154 q_max = sqrt(sum((
pi/dr(:))**2))
2156 auxbas_pw_pool=auxbas_pw_pool, &
2157 rhotot_elec_gspace=rho_elec_gspace, &
2159 rho_hard=rho_hard, &
2161 rho_total = rho_hard + rho_soft
2166 CALL pw_scale(rho_elec_gspace, 1.0_dp/volume)
2168 CALL pw_transfer(rho_elec_gspace, rho_elec_rspace)
2170 filename =
"TOTAL_ELECTRON_DENSITY"
2173 extension=
".cube", middle_name=trim(filename), &
2174 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
2176 IF (output_unit > 0)
THEN
2177 IF (.NOT. mpi_io)
THEN
2178 INQUIRE (unit=unit_nr, name=filename)
2180 filename = mpi_filename
2182 WRITE (unit=output_unit, fmt=
"(/,T2,A,/,/,T2,A)") &
2183 "The total electron density is written in cube file format to the file:", &
2185 WRITE (unit=output_unit, fmt=
"(/,(T2,A,F20.10))") &
2186 "q(max) [1/Angstrom] :", q_max/
angstrom, &
2187 "Soft electronic charge (G-space) :", rho_soft, &
2188 "Hard electronic charge (G-space) :", rho_hard, &
2189 "Total electronic charge (G-space):", rho_total, &
2190 "Total electronic charge (R-space):", rho_total_rspace
2192 CALL cp_pw_to_cube(rho_elec_rspace, unit_nr,
"TOTAL ELECTRON DENSITY", &
2193 particles=particles, &
2194 stride=
section_get_ivals(dft_section,
"PRINT%E_DENSITY_CUBE%STRIDE"), mpi_io=mpi_io)
2196 "DFT%PRINT%E_DENSITY_CUBE", mpi_io=mpi_io)
2198 IF (dft_control%nspins > 1)
THEN
2202 auxbas_pw_pool=auxbas_pw_pool, &
2203 rhotot_elec_gspace=rho_elec_gspace, &
2205 rho_hard=rho_hard, &
2206 rho_soft=rho_soft, &
2208 rho_total = rho_hard + rho_soft
2212 CALL pw_scale(rho_elec_gspace, 1.0_dp/volume)
2214 CALL pw_transfer(rho_elec_gspace, rho_elec_rspace)
2216 filename =
"TOTAL_SPIN_DENSITY"
2219 extension=
".cube", middle_name=trim(filename), &
2220 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
2222 IF (output_unit > 0)
THEN
2223 IF (.NOT. mpi_io)
THEN
2224 INQUIRE (unit=unit_nr, name=filename)
2226 filename = mpi_filename
2228 WRITE (unit=output_unit, fmt=
"(/,T2,A,/,/,T2,A)") &
2229 "The total spin density is written in cube file format to the file:", &
2231 WRITE (unit=output_unit, fmt=
"(/,(T2,A,F20.10))") &
2232 "q(max) [1/Angstrom] :", q_max/
angstrom, &
2233 "Soft part of the spin density (G-space):", rho_soft, &
2234 "Hard part of the spin density (G-space):", rho_hard, &
2235 "Total spin density (G-space) :", rho_total, &
2236 "Total spin density (R-space) :", rho_total_rspace
2238 CALL cp_pw_to_cube(rho_elec_rspace, unit_nr,
"TOTAL SPIN DENSITY", &
2239 particles=particles, &
2240 stride=
section_get_ivals(dft_section,
"PRINT%E_DENSITY_CUBE%STRIDE"), mpi_io=mpi_io)
2242 "DFT%PRINT%E_DENSITY_CUBE", mpi_io=mpi_io)
2244 CALL auxbas_pw_pool%give_back_pw(rho_elec_gspace)
2245 CALL auxbas_pw_pool%give_back_pw(rho_elec_rspace)
2247 ELSE IF (print_density ==
"SOFT_DENSITY" .OR. .NOT. dft_control%qs_control%gapw)
THEN
2248 IF (dft_control%nspins > 1)
THEN
2252 auxbas_pw_pool=auxbas_pw_pool, &
2254 CALL auxbas_pw_pool%create_pw(pw=rho_elec_rspace)
2255 CALL pw_copy(rho_r(1), rho_elec_rspace)
2256 CALL pw_axpy(rho_r(2), rho_elec_rspace)
2257 filename =
"ELECTRON_DENSITY"
2260 extension=
".cube", middle_name=trim(filename), &
2261 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
2263 IF (output_unit > 0)
THEN
2264 IF (.NOT. mpi_io)
THEN
2265 INQUIRE (unit=unit_nr, name=filename)
2267 filename = mpi_filename
2269 WRITE (unit=output_unit, fmt=
"(/,T2,A,/,/,T2,A)") &
2270 "The sum of alpha and beta density is written in cube file format to the file:", &
2273 CALL cp_pw_to_cube(rho_elec_rspace, unit_nr,
"SUM OF ALPHA AND BETA DENSITY", &
2274 particles=particles, stride=
section_get_ivals(dft_section,
"PRINT%E_DENSITY_CUBE%STRIDE"), &
2277 "DFT%PRINT%E_DENSITY_CUBE", mpi_io=mpi_io)
2278 CALL pw_copy(rho_r(1), rho_elec_rspace)
2279 CALL pw_axpy(rho_r(2), rho_elec_rspace, alpha=-1.0_dp)
2280 filename =
"SPIN_DENSITY"
2283 extension=
".cube", middle_name=trim(filename), &
2284 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
2286 IF (output_unit > 0)
THEN
2287 IF (.NOT. mpi_io)
THEN
2288 INQUIRE (unit=unit_nr, name=filename)
2290 filename = mpi_filename
2292 WRITE (unit=output_unit, fmt=
"(/,T2,A,/,/,T2,A)") &
2293 "The spin density is written in cube file format to the file:", &
2296 CALL cp_pw_to_cube(rho_elec_rspace, unit_nr,
"SPIN DENSITY", &
2297 particles=particles, &
2298 stride=
section_get_ivals(dft_section,
"PRINT%E_DENSITY_CUBE%STRIDE"), mpi_io=mpi_io)
2300 "DFT%PRINT%E_DENSITY_CUBE", mpi_io=mpi_io)
2301 CALL auxbas_pw_pool%give_back_pw(rho_elec_rspace)
2303 filename =
"ELECTRON_DENSITY"
2306 extension=
".cube", middle_name=trim(filename), &
2307 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
2309 IF (output_unit > 0)
THEN
2310 IF (.NOT. mpi_io)
THEN
2311 INQUIRE (unit=unit_nr, name=filename)
2313 filename = mpi_filename
2315 WRITE (unit=output_unit, fmt=
"(/,T2,A,/,/,T2,A)") &
2316 "The electron density is written in cube file format to the file:", &
2320 particles=particles, &
2321 stride=
section_get_ivals(dft_section,
"PRINT%E_DENSITY_CUBE%STRIDE"), mpi_io=mpi_io)
2323 "DFT%PRINT%E_DENSITY_CUBE", mpi_io=mpi_io)
2326 ELSE IF (dft_control%qs_control%gapw .AND. print_density ==
"TOTAL_HARD_APPROX")
THEN
2327 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env, rho0_mpole=rho0_mpole, natom=natom)
2328 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool, pw_pools=pw_pools)
2329 CALL auxbas_pw_pool%create_pw(rho_elec_rspace)
2332 ALLOCATE (my_q0(natom))
2340 my_q0(iat) = sum(rho0_mpole%mp_rho(iat)%Q0(1:dft_control%nspins))*
norm_factor
2344 CALL calculate_rho_resp_all(rho_elec_rspace, coeff=my_q0, natom=natom, eta=rho0_mpole%zet0_h, qs_env=qs_env)
2348 DO ispin = 1, dft_control%nspins
2349 CALL pw_axpy(rho_r(ispin), rho_elec_rspace)
2353 rho_total_rspace = rho_soft + rho_hard
2355 filename =
"ELECTRON_DENSITY"
2358 extension=
".cube", middle_name=trim(filename), &
2359 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
2361 IF (output_unit > 0)
THEN
2362 IF (.NOT. mpi_io)
THEN
2363 INQUIRE (unit=unit_nr, name=filename)
2365 filename = mpi_filename
2367 WRITE (unit=output_unit, fmt=
"(/,T2,A,/,/,T2,A)") &
2368 "The electron density is written in cube file format to the file:", &
2370 WRITE (unit=output_unit, fmt=
"(/,(T2,A,F20.10))") &
2371 "Soft electronic charge (R-space) :", rho_soft, &
2372 "Hard electronic charge (R-space) :", rho_hard, &
2373 "Total electronic charge (R-space):", rho_total_rspace
2375 CALL cp_pw_to_cube(rho_elec_rspace, unit_nr,
"ELECTRON DENSITY", &
2376 particles=particles, stride=
section_get_ivals(dft_section,
"PRINT%E_DENSITY_CUBE%STRIDE"), &
2379 "DFT%PRINT%E_DENSITY_CUBE", mpi_io=mpi_io)
2382 IF (dft_control%nspins > 1)
THEN
2384 my_q0(iat) = (rho0_mpole%mp_rho(iat)%Q0(1) - rho0_mpole%mp_rho(iat)%Q0(2))*
norm_factor
2387 CALL calculate_rho_resp_all(rho_elec_rspace, coeff=my_q0, natom=natom, eta=rho0_mpole%zet0_h, qs_env=qs_env)
2390 CALL pw_axpy(rho_r(1), rho_elec_rspace)
2391 CALL pw_axpy(rho_r(2), rho_elec_rspace, alpha=-1.0_dp)
2395 rho_total_rspace = rho_soft + rho_hard
2397 filename =
"SPIN_DENSITY"
2400 extension=
".cube", middle_name=trim(filename), &
2401 file_position=my_pos_cube, log_filename=.false., mpi_io=mpi_io, &
2403 IF (output_unit > 0)
THEN
2404 IF (.NOT. mpi_io)
THEN
2405 INQUIRE (unit=unit_nr, name=filename)
2407 filename = mpi_filename
2409 WRITE (unit=output_unit, fmt=
"(/,T2,A,/,/,T2,A)") &
2410 "The spin density is written in cube file format to the file:", &
2412 WRITE (unit=output_unit, fmt=
"(/,(T2,A,F20.10))") &
2413 "Soft part of the spin density :", rho_soft, &
2414 "Hard part of the spin density :", rho_hard, &
2415 "Total spin density (R-space) :", rho_total_rspace
2417 CALL cp_pw_to_cube(rho_elec_rspace, unit_nr,
"SPIN DENSITY", &
2418 particles=particles, &
2419 stride=
section_get_ivals(dft_section,
"PRINT%E_DENSITY_CUBE%STRIDE"), mpi_io=mpi_io)
2421 "DFT%PRINT%E_DENSITY_CUBE", mpi_io=mpi_io)
2423 CALL auxbas_pw_pool%give_back_pw(rho_elec_rspace)
2429 dft_section,
"PRINT%ENERGY_WINDOWS"),
cp_p_file) .AND. .NOT. do_kpoints)
THEN
2435 "DFT%PRINT%V_HARTREE_CUBE"),
cp_p_file))
THEN
2439 v_hartree_rspace=v_hartree_rspace)
2440 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
2441 CALL auxbas_pw_pool%create_pw(aux_r)
2444 my_pos_cube =
"REWIND"
2445 IF (append_cube)
THEN
2446 my_pos_cube =
"APPEND"
2449 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env)
2452 extension=
".cube", middle_name=
"v_hartree", file_position=my_pos_cube, mpi_io=mpi_io)
2453 udvol = 1.0_dp/v_hartree_rspace%pw_grid%dvol
2455 CALL pw_copy(v_hartree_rspace, aux_r)
2458 CALL cp_pw_to_cube(aux_r, unit_nr,
"HARTREE POTENTIAL", particles=particles, &
2460 "PRINT%V_HARTREE_CUBE%STRIDE"), mpi_io=mpi_io)
2462 "DFT%PRINT%V_HARTREE_CUBE", mpi_io=mpi_io)
2464 CALL auxbas_pw_pool%give_back_pw(aux_r)
2469 "DFT%PRINT%EXTERNAL_POTENTIAL_CUBE"),
cp_p_file))
THEN
2470 IF (dft_control%apply_external_potential)
THEN
2471 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env, vee=vee)
2472 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
2473 CALL auxbas_pw_pool%create_pw(aux_r)
2475 append_cube =
section_get_lval(input,
"DFT%PRINT%EXTERNAL_POTENTIAL_CUBE%APPEND")
2476 my_pos_cube =
"REWIND"
2477 IF (append_cube)
THEN
2478 my_pos_cube =
"APPEND"
2483 extension=
".cube", middle_name=
"ext_pot", file_position=my_pos_cube, mpi_io=mpi_io)
2487 CALL cp_pw_to_cube(aux_r, unit_nr,
"EXTERNAL POTENTIAL", particles=particles, &
2489 "PRINT%EXTERNAL_POTENTIAL_CUBE%STRIDE"), mpi_io=mpi_io)
2491 "DFT%PRINT%EXTERNAL_POTENTIAL_CUBE", mpi_io=mpi_io)
2493 CALL auxbas_pw_pool%give_back_pw(aux_r)
2499 "DFT%PRINT%EFIELD_CUBE"),
cp_p_file))
THEN
2501 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env)
2502 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
2503 CALL auxbas_pw_pool%create_pw(aux_r)
2504 CALL auxbas_pw_pool%create_pw(aux_g)
2507 my_pos_cube =
"REWIND"
2508 IF (append_cube)
THEN
2509 my_pos_cube =
"APPEND"
2511 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env, &
2512 v_hartree_rspace=v_hartree_rspace)
2514 udvol = 1.0_dp/v_hartree_rspace%pw_grid%dvol
2518 extension=
".cube", middle_name=
"efield_"//cdir(id), file_position=my_pos_cube, &
2529 unit_nr,
"ELECTRIC FIELD", particles=particles, &
2531 "PRINT%EFIELD_CUBE%STRIDE"), mpi_io=mpi_io)
2533 "DFT%PRINT%EFIELD_CUBE", mpi_io=mpi_io)
2536 CALL auxbas_pw_pool%give_back_pw(aux_r)
2537 CALL auxbas_pw_pool%give_back_pw(aux_g)
2541 CALL qs_scf_post_local_energy(input, logger, qs_env)
2544 CALL qs_scf_post_local_stress(input, logger, qs_env)
2547 CALL qs_scf_post_ps_implicit(input, logger, qs_env)
2555 "DFT%PRINT%AO_MATRICES/DENSITY"),
cp_p_file))
THEN
2560 after = min(max(after, 1), 16)
2561 DO ispin = 1, dft_control%nspins
2562 DO img = 1, dft_control%nimages
2564 para_env, output_unit=iw, omit_headers=omit_headers)
2568 "DFT%PRINT%AO_MATRICES/DENSITY")
2573 "DFT%PRINT%AO_MATRICES/KOHN_SHAM_MATRIX"),
cp_p_file)
2575 "DFT%PRINT%AO_MATRICES/MATRIX_VXC"),
cp_p_file)
2577 IF (write_ks .OR. write_xc)
THEN
2578 IF (write_xc) qs_env%requires_matrix_vxc = .true.
2581 just_energy=.false.)
2582 IF (write_xc) qs_env%requires_matrix_vxc = .false.
2589 CALL get_qs_env(qs_env=qs_env, matrix_ks_kp=ks_rmpv)
2591 after = min(max(after, 1), 16)
2592 DO ispin = 1, dft_control%nspins
2593 DO img = 1, dft_control%nimages
2595 para_env, output_unit=iw, omit_headers=omit_headers)
2599 "DFT%PRINT%AO_MATRICES/KOHN_SHAM_MATRIX")
2604 IF (.NOT. dft_control%qs_control%pao)
THEN
2610 CALL write_adjacency_matrix(qs_env, input)
2614 CALL get_qs_env(qs_env=qs_env, matrix_vxc_kp=matrix_vxc)
2615 cpassert(
ASSOCIATED(matrix_vxc))
2619 after = min(max(after, 1), 16)
2620 DO ispin = 1, dft_control%nspins
2621 DO img = 1, dft_control%nimages
2623 para_env, output_unit=iw, omit_headers=omit_headers)
2627 "DFT%PRINT%AO_MATRICES/MATRIX_VXC")
2632 "DFT%PRINT%AO_MATRICES/COMMUTATOR_HR"),
cp_p_file))
THEN
2638 after = min(max(after, 1), 16)
2641 para_env, output_unit=iw, omit_headers=omit_headers)
2645 "DFT%PRINT%AO_MATRICES/COMMUTATOR_HR")
2651 unit_nr =
cp_print_key_unit_nr(logger, input,
"DFT%PRINT%MULLIKEN", extension=
".mulliken", log_filename=.false.)
2654 IF (print_it) print_level = 2
2656 IF (print_it) print_level = 3
2667 CALL qs_rho_get(rho, rho_r_valid=rho_r_valid)
2668 IF (rho_r_valid)
THEN
2669 unit_nr =
cp_print_key_unit_nr(logger, input,
"DFT%PRINT%HIRSHFELD", extension=
".hirshfeld", log_filename=.false.)
2670 CALL hirshfeld_charges(qs_env, print_key, unit_nr)
2678 unit_nr =
cp_print_key_unit_nr(logger, input,
"DFT%PRINT%EEQ_CHARGES", extension=
".eeq", log_filename=.false.)
2680 CALL eeq_print(qs_env, unit_nr, print_level, ext=.false.)
2688 should_print_voro = 1
2690 should_print_voro = 0
2693 should_print_bqb = 1
2695 should_print_bqb = 0
2697 IF ((should_print_voro /= 0) .OR. (should_print_bqb /= 0))
THEN
2702 CALL qs_rho_get(rho, rho_r_valid=rho_r_valid)
2703 IF (rho_r_valid)
THEN
2705 IF (dft_control%nspins > 1)
THEN
2709 auxbas_pw_pool=auxbas_pw_pool, &
2713 CALL auxbas_pw_pool%create_pw(pw=mb_rho)
2714 CALL pw_copy(rho_r(1), mb_rho)
2715 CALL pw_axpy(rho_r(2), mb_rho)
2722 IF (should_print_voro /= 0)
THEN
2724 IF (voro_print_txt)
THEN
2726 my_pos_voro =
"REWIND"
2727 IF (append_voro)
THEN
2728 my_pos_voro =
"APPEND"
2730 unit_nr_voro =
cp_print_key_unit_nr(logger, input,
"DFT%PRINT%VORONOI", extension=
".voronoi", &
2731 file_position=my_pos_voro, log_filename=.false.)
2739 CALL entry_voronoi_or_bqb(should_print_voro, should_print_bqb, print_key_voro, print_key_bqb, &
2740 unit_nr_voro, qs_env, mb_rho)
2742 IF (dft_control%nspins > 1)
THEN
2743 CALL auxbas_pw_pool%give_back_pw(mb_rho)
2747 IF (unit_nr_voro > 0)
THEN
2757 unit_nr =
cp_print_key_unit_nr(logger, input,
"DFT%PRINT%MAO_ANALYSIS", extension=
".mao", log_filename=.false.)
2765 unit_nr =
cp_print_key_unit_nr(logger, input,
"DFT%PRINT%MINBAS_ANALYSIS", extension=
".mao", log_filename=.false.)
2773 unit_nr =
cp_print_key_unit_nr(logger, input,
"DFT%PRINT%IAO_ANALYSIS", extension=
".iao", log_filename=.false.)
2775 IF (iao_env%do_iao)
THEN
2785 extension=
".mao", log_filename=.false.)
2796 IF (qs_env%x_data(i, 1)%do_hfx_ri)
CALL print_ri_hfx(qs_env%x_data(i, 1)%ri_data, qs_env)
2800 CALL timestop(handle)
2810 SUBROUTINE hirshfeld_charges(qs_env, input_section, unit_nr)
2813 INTEGER,
INTENT(IN) :: unit_nr
2815 INTEGER :: i, iat, ikind, natom, nkind, nspin, &
2816 radius_type, refc, shapef
2817 INTEGER,
DIMENSION(:),
POINTER :: atom_list
2818 LOGICAL :: do_radius, do_sc, paw_atom
2819 REAL(kind=
dp) :: zeff
2820 REAL(kind=
dp),
DIMENSION(:),
POINTER :: radii
2821 REAL(kind=
dp),
DIMENSION(:, :),
POINTER :: charges
2824 TYPE(
dbcsr_p_type),
DIMENSION(:, :),
POINTER :: matrix_p, matrix_s
2830 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
2834 NULLIFY (hirshfeld_env)
2838 CALL get_qs_env(qs_env, nkind=nkind, natom=natom)
2839 ALLOCATE (hirshfeld_env%charges(natom))
2848 IF (.NOT.
SIZE(radii) == nkind) &
2849 CALL cp_abort(__location__, &
2850 "Length of keyword HIRSHFELD\ATOMIC_RADII does not "// &
2851 "match number of atomic kinds in the input coordinate file.")
2856 iterative=do_sc, ref_charge=refc, &
2857 radius_type=radius_type)
2859 CALL get_qs_env(qs_env, qs_kind_set=qs_kind_set, atomic_kind_set=atomic_kind_set)
2865 nspin =
SIZE(matrix_p, 1)
2866 ALLOCATE (charges(natom, nspin))
2871 atomic_kind => atomic_kind_set(ikind)
2873 DO iat = 1,
SIZE(atom_list)
2875 hirshfeld_env%charges(i) = zeff
2879 CALL get_qs_env(qs_env, matrix_s_kp=matrix_s, para_env=para_env)
2882 hirshfeld_env%charges(iat) = sum(charges(iat, :))
2885 cpabort(
"Unknown type of reference charge for Hirshfeld partitioning.")
2889 IF (hirshfeld_env%iterative)
THEN
2896 CALL get_qs_env(qs_env, particle_set=particle_set, dft_control=dft_control)
2897 IF (dft_control%qs_control%gapw)
THEN
2899 CALL get_qs_env(qs_env, rho0_mpole=rho0_mpole)
2902 atomic_kind => particle_set(iat)%atomic_kind
2904 CALL get_qs_kind(qs_kind_set(ikind), paw_atom=paw_atom)
2906 charges(iat, 1:nspin) = charges(iat, 1:nspin) + mp_rho(iat)%q0(1:nspin)
2911 IF (unit_nr > 0)
THEN
2913 qs_kind_set, unit_nr)
2919 DEALLOCATE (charges)
2921 END SUBROUTINE hirshfeld_charges
2931 SUBROUTINE project_function_a(ca, a, cb, b, l)
2933 REAL(kind=
dp),
DIMENSION(:),
INTENT(OUT) :: ca
2934 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: a, cb, b
2935 INTEGER,
INTENT(IN) :: l
2938 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: ipiv
2939 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: smat, tmat, v
2942 ALLOCATE (smat(n, n), tmat(n, n), v(n, 1), ipiv(n))
2946 v(:, 1) = matmul(tmat, cb)
2947 CALL dgesv(n, 1, smat, n, ipiv, v, n, info)
2951 DEALLOCATE (smat, tmat, v, ipiv)
2953 END SUBROUTINE project_function_a
2963 SUBROUTINE project_function_b(ca, a, bfun, grid_atom, l)
2965 REAL(kind=
dp),
DIMENSION(:),
INTENT(OUT) :: ca
2966 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: a, bfun
2968 INTEGER,
INTENT(IN) :: l
2970 INTEGER :: i, info, n, nr
2971 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: ipiv
2972 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: afun
2973 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: smat, v
2977 ALLOCATE (smat(n, n), v(n, 1), ipiv(n), afun(nr))
2981 afun(:) = grid_atom%rad(:)**l*exp(-a(i)*grid_atom%rad2(:))
2982 v(i, 1) = sum(afun(:)*bfun(:)*grid_atom%wr(:))
2984 CALL dgesv(n, 1, smat, n, ipiv, v, n, info)
2988 DEALLOCATE (smat, v, ipiv, afun)
2990 END SUBROUTINE project_function_b
3001 SUBROUTINE qs_scf_post_local_energy(input, logger, qs_env)
3006 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_local_energy'
3008 CHARACTER(LEN=default_path_length) :: filename, my_pos_cube
3009 INTEGER :: handle, io_unit, natom, unit_nr
3010 LOGICAL :: append_cube, gapw, gapw_xc, mpi_io
3019 CALL timeset(routinen, handle)
3022 "DFT%PRINT%LOCAL_ENERGY_CUBE"),
cp_p_file))
THEN
3024 CALL get_qs_env(qs_env=qs_env, dft_control=dft_control, natom=natom)
3025 gapw = dft_control%qs_control%gapw
3026 gapw_xc = dft_control%qs_control%gapw_xc
3027 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env, subsys=subsys)
3029 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
3030 CALL auxbas_pw_pool%create_pw(eden)
3034 append_cube =
section_get_lval(input,
"DFT%PRINT%LOCAL_ENERGY_CUBE%APPEND")
3035 IF (append_cube)
THEN
3036 my_pos_cube =
"APPEND"
3038 my_pos_cube =
"REWIND"
3042 extension=
".cube", middle_name=
"local_energy", &
3043 file_position=my_pos_cube, mpi_io=mpi_io)
3045 unit_nr,
"LOCAL ENERGY", particles=particles, &
3047 "PRINT%LOCAL_ENERGY_CUBE%STRIDE"), mpi_io=mpi_io)
3048 IF (io_unit > 0)
THEN
3049 INQUIRE (unit=unit_nr, name=filename)
3050 IF (gapw .OR. gapw_xc)
THEN
3051 WRITE (unit=io_unit, fmt=
"(/,T3,A,A)") &
3052 "The soft part of the local energy is written to the file: ", trim(adjustl(filename))
3054 WRITE (unit=io_unit, fmt=
"(/,T3,A,A)") &
3055 "The local energy is written to the file: ", trim(adjustl(filename))
3059 "DFT%PRINT%LOCAL_ENERGY_CUBE", mpi_io=mpi_io)
3061 CALL auxbas_pw_pool%give_back_pw(eden)
3063 CALL timestop(handle)
3065 END SUBROUTINE qs_scf_post_local_energy
3076 SUBROUTINE qs_scf_post_local_stress(input, logger, qs_env)
3081 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_local_stress'
3083 CHARACTER(LEN=default_path_length) :: filename, my_pos_cube
3084 INTEGER :: handle, io_unit, natom, unit_nr
3085 LOGICAL :: append_cube, gapw, gapw_xc, mpi_io
3086 REAL(kind=
dp) :: beta
3095 CALL timeset(routinen, handle)
3098 "DFT%PRINT%LOCAL_STRESS_CUBE"),
cp_p_file))
THEN
3100 CALL get_qs_env(qs_env=qs_env, dft_control=dft_control, natom=natom)
3101 gapw = dft_control%qs_control%gapw
3102 gapw_xc = dft_control%qs_control%gapw_xc
3103 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env, subsys=subsys)
3105 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
3106 CALL auxbas_pw_pool%create_pw(stress)
3112 append_cube =
section_get_lval(input,
"DFT%PRINT%LOCAL_STRESS_CUBE%APPEND")
3113 IF (append_cube)
THEN
3114 my_pos_cube =
"APPEND"
3116 my_pos_cube =
"REWIND"
3120 extension=
".cube", middle_name=
"local_stress", &
3121 file_position=my_pos_cube, mpi_io=mpi_io)
3123 unit_nr,
"LOCAL STRESS", particles=particles, &
3125 "PRINT%LOCAL_STRESS_CUBE%STRIDE"), mpi_io=mpi_io)
3126 IF (io_unit > 0)
THEN
3127 INQUIRE (unit=unit_nr, name=filename)
3128 WRITE (unit=io_unit, fmt=
"(/,T3,A)")
"Write 1/3*Tr(sigma) to cube file"
3129 IF (gapw .OR. gapw_xc)
THEN
3130 WRITE (unit=io_unit, fmt=
"(T3,A,A)") &
3131 "The soft part of the local stress is written to the file: ", trim(adjustl(filename))
3133 WRITE (unit=io_unit, fmt=
"(T3,A,A)") &
3134 "The local stress is written to the file: ", trim(adjustl(filename))
3138 "DFT%PRINT%LOCAL_STRESS_CUBE", mpi_io=mpi_io)
3140 CALL auxbas_pw_pool%give_back_pw(stress)
3143 CALL timestop(handle)
3145 END SUBROUTINE qs_scf_post_local_stress
3156 SUBROUTINE qs_scf_post_ps_implicit(input, logger, qs_env)
3161 CHARACTER(len=*),
PARAMETER :: routinen =
'qs_scf_post_ps_implicit'
3163 CHARACTER(LEN=default_path_length) :: filename, my_pos_cube
3164 INTEGER :: boundary_condition, handle, i, j, &
3165 n_cstr, n_tiles, unit_nr
3166 LOGICAL :: append_cube, do_cstr_charge_cube, do_dielectric_cube, do_dirichlet_bc_cube, &
3167 has_dirichlet_bc, has_implicit_ps, mpi_io, tile_cubes
3177 CALL timeset(routinen, handle)
3179 NULLIFY (pw_env, auxbas_pw_pool, dft_section, particles)
3182 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env, subsys=subsys)
3184 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool)
3186 has_implicit_ps = .false.
3187 CALL get_qs_env(qs_env=qs_env, pw_env=pw_env)
3188 IF (pw_env%poisson_env%parameters%solver .EQ.
pw_poisson_implicit) has_implicit_ps = .true.
3192 "DFT%PRINT%IMPLICIT_PSOLVER%DIELECTRIC_CUBE"),
cp_p_file)
3193 IF (has_implicit_ps .AND. do_dielectric_cube)
THEN
3194 append_cube =
section_get_lval(input,
"DFT%PRINT%IMPLICIT_PSOLVER%DIELECTRIC_CUBE%APPEND")
3195 my_pos_cube =
"REWIND"
3196 IF (append_cube)
THEN
3197 my_pos_cube =
"APPEND"
3201 extension=
".cube", middle_name=
"DIELECTRIC_CONSTANT", file_position=my_pos_cube, &
3203 CALL pw_env_get(pw_env, poisson_env=poisson_env, auxbas_pw_pool=auxbas_pw_pool)
3204 CALL auxbas_pw_pool%create_pw(aux_r)
3206 boundary_condition = pw_env%poisson_env%parameters%ps_implicit_params%boundary_condition
3207 SELECT CASE (boundary_condition)
3209 CALL pw_copy(poisson_env%implicit_env%dielectric%eps, aux_r)
3211 CALL pw_shrink(pw_env%poisson_env%parameters%ps_implicit_params%neumann_directions, &
3212 pw_env%poisson_env%implicit_env%dct_env%dests_shrink, &
3213 pw_env%poisson_env%implicit_env%dct_env%srcs_shrink, &
3214 pw_env%poisson_env%implicit_env%dct_env%bounds_local_shftd, &
3215 poisson_env%implicit_env%dielectric%eps, aux_r)
3218 CALL cp_pw_to_cube(aux_r, unit_nr,
"DIELECTRIC CONSTANT", particles=particles, &
3219 stride=
section_get_ivals(dft_section,
"PRINT%IMPLICIT_PSOLVER%DIELECTRIC_CUBE%STRIDE"), &
3222 "DFT%PRINT%IMPLICIT_PSOLVER%DIELECTRIC_CUBE", mpi_io=mpi_io)
3224 CALL auxbas_pw_pool%give_back_pw(aux_r)
3229 "DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_CSTR_CHARGE_CUBE"),
cp_p_file)
3231 has_dirichlet_bc = .false.
3232 IF (has_implicit_ps)
THEN
3233 boundary_condition = pw_env%poisson_env%parameters%ps_implicit_params%boundary_condition
3235 has_dirichlet_bc = .true.
3239 IF (has_implicit_ps .AND. do_cstr_charge_cube .AND. has_dirichlet_bc)
THEN
3241 "DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_CSTR_CHARGE_CUBE%APPEND")
3242 my_pos_cube =
"REWIND"
3243 IF (append_cube)
THEN
3244 my_pos_cube =
"APPEND"
3248 "DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_CSTR_CHARGE_CUBE", &
3249 extension=
".cube", middle_name=
"dirichlet_cstr_charge", file_position=my_pos_cube, &
3251 CALL pw_env_get(pw_env, poisson_env=poisson_env, auxbas_pw_pool=auxbas_pw_pool)
3252 CALL auxbas_pw_pool%create_pw(aux_r)
3254 boundary_condition = pw_env%poisson_env%parameters%ps_implicit_params%boundary_condition
3255 SELECT CASE (boundary_condition)
3257 CALL pw_copy(poisson_env%implicit_env%cstr_charge, aux_r)
3259 CALL pw_shrink(pw_env%poisson_env%parameters%ps_implicit_params%neumann_directions, &
3260 pw_env%poisson_env%implicit_env%dct_env%dests_shrink, &
3261 pw_env%poisson_env%implicit_env%dct_env%srcs_shrink, &
3262 pw_env%poisson_env%implicit_env%dct_env%bounds_local_shftd, &
3263 poisson_env%implicit_env%cstr_charge, aux_r)
3266 CALL cp_pw_to_cube(aux_r, unit_nr,
"DIRICHLET CONSTRAINT CHARGE", particles=particles, &
3267 stride=
section_get_ivals(dft_section,
"PRINT%IMPLICIT_PSOLVER%DIRICHLET_CSTR_CHARGE_CUBE%STRIDE"), &
3270 "DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_CSTR_CHARGE_CUBE", mpi_io=mpi_io)
3272 CALL auxbas_pw_pool%give_back_pw(aux_r)
3277 "DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_BC_CUBE"),
cp_p_file)
3278 has_dirichlet_bc = .false.
3279 IF (has_implicit_ps)
THEN
3280 boundary_condition = pw_env%poisson_env%parameters%ps_implicit_params%boundary_condition
3282 has_dirichlet_bc = .true.
3286 IF (has_implicit_ps .AND. has_dirichlet_bc .AND. do_dirichlet_bc_cube)
THEN
3287 append_cube =
section_get_lval(input,
"DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_BC_CUBE%APPEND")
3288 my_pos_cube =
"REWIND"
3289 IF (append_cube)
THEN
3290 my_pos_cube =
"APPEND"
3292 tile_cubes =
section_get_lval(input,
"DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_BC_CUBE%TILE_CUBES")
3294 CALL pw_env_get(pw_env, poisson_env=poisson_env, auxbas_pw_pool=auxbas_pw_pool)
3295 CALL auxbas_pw_pool%create_pw(aux_r)
3298 IF (tile_cubes)
THEN
3300 n_cstr =
SIZE(poisson_env%implicit_env%contacts)
3302 n_tiles = poisson_env%implicit_env%contacts(j)%dirichlet_bc%n_tiles
3304 filename =
"dirichlet_cstr_"//trim(adjustl(
cp_to_string(j)))// &
3307 unit_nr =
cp_print_key_unit_nr(logger, input,
"DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_BC_CUBE", &
3308 extension=
".cube", middle_name=filename, file_position=my_pos_cube, &
3311 CALL pw_copy(poisson_env%implicit_env%contacts(j)%dirichlet_bc%tiles(i)%tile%tile_pw, aux_r)
3313 CALL cp_pw_to_cube(aux_r, unit_nr,
"DIRICHLET TYPE CONSTRAINT", particles=particles, &
3314 stride=
section_get_ivals(dft_section,
"PRINT%IMPLICIT_PSOLVER%DIRICHLET_BC_CUBE%STRIDE"), &
3317 "DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_BC_CUBE", mpi_io=mpi_io)
3322 NULLIFY (dirichlet_tile)
3323 ALLOCATE (dirichlet_tile)
3324 CALL auxbas_pw_pool%create_pw(dirichlet_tile)
3327 unit_nr =
cp_print_key_unit_nr(logger, input,
"DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_BC_CUBE", &
3328 extension=
".cube", middle_name=
"DIRICHLET_CSTR", file_position=my_pos_cube, &
3331 n_cstr =
SIZE(poisson_env%implicit_env%contacts)
3333 n_tiles = poisson_env%implicit_env%contacts(j)%dirichlet_bc%n_tiles
3335 CALL pw_copy(poisson_env%implicit_env%contacts(j)%dirichlet_bc%tiles(i)%tile%tile_pw, dirichlet_tile)
3336 CALL pw_axpy(dirichlet_tile, aux_r)
3340 CALL cp_pw_to_cube(aux_r, unit_nr,
"DIRICHLET TYPE CONSTRAINT", particles=particles, &
3341 stride=
section_get_ivals(dft_section,
"PRINT%IMPLICIT_PSOLVER%DIRICHLET_BC_CUBE%STRIDE"), &
3344 "DFT%PRINT%IMPLICIT_PSOLVER%DIRICHLET_BC_CUBE", mpi_io=mpi_io)
3345 CALL auxbas_pw_pool%give_back_pw(dirichlet_tile)
3346 DEALLOCATE (dirichlet_tile)
3349 CALL auxbas_pw_pool%give_back_pw(aux_r)
3352 CALL timestop(handle)
3354 END SUBROUTINE qs_scf_post_ps_implicit
3362 SUBROUTINE write_adjacency_matrix(qs_env, input)
3366 CHARACTER(len=*),
PARAMETER :: routinen =
'write_adjacency_matrix'
3368 INTEGER :: adjm_size, colind, handle, iatom, ikind, &
3369 ind, jatom, jkind, k, natom, nkind, &
3370 output_unit, rowind, unit_nr
3371 INTEGER,
ALLOCATABLE,
DIMENSION(:) :: interact_adjm
3372 LOGICAL :: do_adjm_write, do_symmetric
3378 DIMENSION(:),
POINTER :: nl_iterator
3381 TYPE(
qs_kind_type),
DIMENSION(:),
POINTER :: qs_kind_set
3384 CALL timeset(routinen, handle)
3386 NULLIFY (dft_section)
3395 IF (do_adjm_write)
THEN
3396 NULLIFY (qs_kind_set, nl_iterator)
3397 NULLIFY (basis_set_list_a, basis_set_list_b, basis_set_a, basis_set_b)
3399 CALL get_qs_env(qs_env, qs_kind_set=qs_kind_set, sab_orb=nl, natom=natom, para_env=para_env)
3401 nkind =
SIZE(qs_kind_set)
3402 cpassert(
SIZE(nl) .GT. 0)
3404 cpassert(do_symmetric)
3405 ALLOCATE (basis_set_list_a(nkind), basis_set_list_b(nkind))
3409 adjm_size = ((natom + 1)*natom)/2
3410 ALLOCATE (interact_adjm(4*adjm_size))
3413 NULLIFY (nl_iterator)
3417 ikind=ikind, jkind=jkind, &
3418 iatom=iatom, jatom=jatom)
3420 basis_set_a => basis_set_list_a(ikind)%gto_basis_set
3421 IF (.NOT.
ASSOCIATED(basis_set_a)) cycle
3422 basis_set_b => basis_set_list_b(jkind)%gto_basis_set
3423 IF (.NOT.
ASSOCIATED(basis_set_b)) cycle
3426 IF (iatom .LE. jatom)
THEN
3433 ikind = ikind + jkind
3434 jkind = ikind - jkind
3435 ikind = ikind - jkind
3439 ind = adjm_size - (natom - rowind + 1)*((natom - rowind + 1) + 1)/2 + colind - rowind + 1
3442 interact_adjm((ind - 1)*4 + 1) = rowind
3443 interact_adjm((ind - 1)*4 + 2) = colind
3444 interact_adjm((ind - 1)*4 + 3) = ikind
3445 interact_adjm((ind - 1)*4 + 4) = jkind
3448 CALL para_env%sum(interact_adjm)
3451 extension=
".adjmat", file_form=
"FORMATTED", &
3452 file_status=
"REPLACE")
3453 IF (unit_nr .GT. 0)
THEN
3454 WRITE (unit_nr,
"(1A,2X,1A,5X,1A,4X,A5,3X,A5)")
"#",
"iatom",
"jatom",
"ikind",
"jkind"
3455 DO k = 1, 4*adjm_size, 4
3457 IF (interact_adjm(k) .GT. 0 .AND. interact_adjm(k + 1) .GT. 0)
THEN
3458 WRITE (unit_nr,
"(I8,2X,I8,3X,I6,2X,I6)") interact_adjm(k:k + 3)
3466 DEALLOCATE (basis_set_list_a, basis_set_list_b)
3469 CALL timestop(handle)
3471 END SUBROUTINE write_adjacency_matrix
3479 SUBROUTINE update_hartree_with_mp2(rho, qs_env)
3483 LOGICAL :: use_virial
3493 NULLIFY (auxbas_pw_pool, pw_env, poisson_env, energy, rho_core, v_hartree_rspace, virial)
3494 CALL get_qs_env(qs_env, pw_env=pw_env, energy=energy, &
3495 rho_core=rho_core, virial=virial, &
3496 v_hartree_rspace=v_hartree_rspace)
3498 use_virial = virial%pv_availability .AND. (.NOT. virial%pv_numer)
3500 IF (.NOT. use_virial)
THEN
3502 CALL pw_env_get(pw_env, auxbas_pw_pool=auxbas_pw_pool, &
3503 poisson_env=poisson_env)
3504 CALL auxbas_pw_pool%create_pw(v_hartree_gspace)
3505 CALL auxbas_pw_pool%create_pw(rho_tot_gspace)
3509 v_hartree_gspace, rho_core=rho_core)
3511 CALL pw_transfer(v_hartree_gspace, v_hartree_rspace)
3512 CALL pw_scale(v_hartree_rspace, v_hartree_rspace%pw_grid%dvol)
3514 CALL auxbas_pw_pool%give_back_pw(v_hartree_gspace)
3515 CALL auxbas_pw_pool%give_back_pw(rho_tot_gspace)
3518 END SUBROUTINE update_hartree_with_mp2
static double norm_factor(double alpha, int L)
Types and set/get functions for auxiliary density matrix methods.
Contains methods used in the context of density fitting.
subroutine, public admm_uncorrect_for_eigenvalues(ispin, admm_env, ks_matrix)
...
subroutine, public admm_correct_for_eigenvalues(ispin, admm_env, ks_matrix)
...
subroutine, public sg_overlap(smat, l, pa, pb)
...
calculate the orbitals for a given atomic kind type
subroutine, public calculate_atomic_density(density, atomic_kind, qs_kind, ngto, iunit, optbasis, allelectron, confine)
...
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...
subroutine, public dbcsr_add(matrix_a, matrix_b, alpha_scalar, beta_scalar)
...
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)
...
Density Derived atomic point charges from a QM calculation (see Bloechl, J. Chem. Phys....
recursive subroutine, public get_ddapc(qs_env, calc_force, density_fit_section, density_type, qout1, qout2, out_radii, dq_out, ext_rho_tot_g, itype_of_density, iwc)
Computes the Density Derived Atomic Point Charges.
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_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)
...
the type I Discrete Cosine Transform (DCT-I)
subroutine, public pw_shrink(neumann_directions, dests_shrink, srcs_shrink, bounds_local_shftd, pw_in, pw_shrinked)
shrinks an evenly symmetric pw_r3d_rs_type data to a pw_r3d_rs_type data that is 8 times smaller (the...
Calculate Energy Decomposition analysis.
subroutine, public edmf_analysis(qs_env, input_section, unit_nr)
...
Calculation of charge equilibration method.
subroutine, public eeq_print(qs_env, iounit, print_level, ext)
...
Definition and initialisation of the et_coupling data type.
subroutine, public set_et_coupling_type(et_coupling, et_mo_coeff, rest_mat)
...
subroutine, public print_ri_hfx(ri_data, qs_env)
Print RI-HFX quantities, as required by the PRINT subsection.
Calculate Hirshfeld charges and related functions.
subroutine, public comp_hirshfeld_charges(qs_env, hirshfeld_env, charges)
...
subroutine, public create_shape_function(hirshfeld_env, qs_kind_set, atomic_kind_set, radius, radii_list)
creates kind specific shape functions for Hirshfeld charges
subroutine, public write_hirshfeld_charges(charges, hirshfeld_env, particle_set, qs_kind_set, unit_nr)
...
subroutine, public comp_hirshfeld_i_charges(qs_env, hirshfeld_env, charges, ounit)
...
subroutine, public save_hirshfeld_charges(charges, particle_set, qs_kind_set, qs_env)
saves the Hirshfeld charges to the results structure
The types needed for the calculation of Hirshfeld charges and related functions.
subroutine, public create_hirshfeld_type(hirshfeld_env)
...
subroutine, public set_hirshfeld_info(hirshfeld_env, shape_function_type, iterative, ref_charge, fnorm, radius_type, use_bohr)
Set values of a Hirshfeld env.
subroutine, public release_hirshfeld_type(hirshfeld_env)
...
Calculate intrinsic atomic orbitals and analyze wavefunctions.
subroutine, public iao_wfn_analysis(qs_env, iao_env, unit_nr, c_iao_coef, mos, bond_centers)
...
Calculate ntrinsic atomic orbitals and analyze wavefunctions.
subroutine, public iao_read_input(iao_env, iao_section, cell)
...
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 ...
Calculate MAO's and analyze wavefunctions.
subroutine, public mao_analysis(qs_env, input_section, unit_nr)
...
Definition of mathematical constants and functions.
real(kind=dp), parameter, public pi
Utility routines for the memory handling.
Interface to the message passing library MPI.
Calculate localized minimal basis and analyze wavefunctions.
subroutine, public minbas_analysis(qs_env, input_section, unit_nr)
...
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.
Define the data structure for the molecule information.
compute mulliken charges we (currently) define them as c_i = 1/2 [ (PS)_{ii} + (SP)_{ii} ]
Provides Cartesian and spherical orbital pointers and indices.
integer, dimension(:, :), allocatable, public indso
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 evolt
real(kind=dp), parameter, public angstrom
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...
subroutine, public mulliken_population_analysis(qs_env, output_unit, print_level)
Perform a Mulliken population analysis.
computes preconditioners, and implements methods to apply them currently used in qs_ot
Types containing essential information for running implicit (iterative) Poisson solver.
integer, parameter, public neumann_bc
integer, parameter, public mixed_bc
integer, parameter, public mixed_periodic_bc
integer, parameter, public periodic_bc
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
This module defines the grid data type and some basic operations on it.
subroutine, public get_pw_grid_info(pw_grid, id_nr, mode, vol, dvol, npts, ngpts, ngpts_cut, dr, cutoff, orthorhombic, gvectors, gsquare)
Access to information stored in the pw_grid_type.
subroutine, public pw_derive(pw, n)
Calculate the derivative of a plane wave vector.
functions related to the poisson solver on regular grids
integer, parameter, public pw_poisson_implicit
Manages a pool of grids (to be used for example as tmp objects), but can also be used to instantiate ...
Write wfx file, works as interface to chargemol and multiwfn.
subroutine, public write_wfx(qs_env, dft_section)
...
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
Calculation of commutator [H,r] matrices.
subroutine, public build_com_hr_matrix(qs_env, matrix_hr)
Calculation of the [H,r] commutators matrices over Cartesian Gaussian functions.
Calculation of the energies concerning the core charge distribution.
Calculation and writing of density of states.
subroutine, public calculate_dos(mos, dft_section)
Compute and write density of states.
subroutine, public calculate_dos_kp(qs_env, dft_section)
Compute and write density of states (kpoints)
Calculates electric field gradients H.M. Petrili, P.E. Blochl, P. Blaha, K. Schwarz,...
subroutine, public qs_efg_calc(qs_env)
...
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_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, 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.
subroutine, public set_qs_env(qs_env, super_cell, mos, qmmm, qmmm_periodic, ewald_env, ewald_pw, mpools, rho_external, external_vxc, mask, scf_control, rel_control, qs_charges, ks_env, ks_qmmm_env, wf_history, scf_env, active_space, input, oce, rho_atom_set, rho0_atom_set, rho0_mpole, run_rtp, rtp, rhoz_set, rhoz_tot, ecoul_1c, has_unit_metric, requires_mo_derivs, mo_derivs, mo_loc_history, efield, rhoz_cneo_set, linres_control, xas_env, cp_ddapc_env, cp_ddapc_ewald, outer_scf_history, outer_scf_ihistory, x_data, et_coupling, dftb_potential, se_taper, se_store_int_env, se_nddo_mpole, se_nonbond_env, admm_env, ls_scf_env, do_transport, transport_env, lri_env, lri_density, exstate_env, ec_env, dispersion_env, harris_env, gcp_env, mp2_env, bs_env, kg_env, force, kpoints, wanniercentres, almo_scf_env, gradient_history, variable_history, embed_pot, spin_embed_pot, polar_env, mos_last_converged, eeq, rhs, do_rixs, tb_tblite)
Set the QUICKSTEP environment.
Calculates hyperfine values.
subroutine, public qs_epr_hyp_calc(qs_env)
...
Some utility functions for the calculation of integrals.
subroutine, public basis_set_list_setup(basis_set_list, basis_type, qs_kind_set)
Set up an easy accessible list of the basis sets for all kinds.
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, floating, name, element_symbol, pao_basis_size, pao_model_file, pao_potentials, pao_descriptors, nelec)
Get attributes of an atomic kind.
routines that build the Kohn-Sham matrix (i.e calculate the coulomb and xc parts
subroutine, public qs_ks_update_qs_env(qs_env, calculate_forces, just_energy, print_active)
updates the Kohn Sham matrix of the given qs_env (facility method)
subroutine, public calc_rho_tot_gspace(rho_tot_gspace, qs_env, rho, skip_nuclear_density)
...
subroutine, public qs_ks_did_change(ks_env, s_mstruct_changed, rho_changed, potential_changed, full_reset)
tells that some of the things relevant to the ks calculation did change. has to be called when change...
subroutine, public loc_dipole(input, dft_control, qs_loc_env, logger, qs_env)
Computes and prints the Dipole (using localized charges)
subroutine, public get_localization_info(qs_env, qs_loc_env, loc_section, mo_local, wf_r, wf_g, particles, coeff, evals, marked_states)
Performs localization of the orbitals.
New version of the module for the localization of the molecular orbitals This should be able to use d...
subroutine, public qs_loc_env_release(qs_loc_env)
...
subroutine, public qs_loc_env_create(qs_loc_env)
...
Some utilities for the construction of the localization environment.
subroutine, public loc_write_restart(qs_loc_env, section, mo_array, coeff_localized, do_homo, evals, do_mixed)
...
subroutine, public qs_loc_env_init(qs_loc_env, localized_wfn_control, qs_env, myspin, do_localize, loc_coeff, mo_loc_history)
allocates the data, and initializes the operators
subroutine, public qs_loc_control_init(qs_loc_env, loc_section, do_homo, do_mixed, do_xas, nloc_xas, spin_xas)
initializes everything needed for localization of the HOMOs
subroutine, public retain_history(mo_loc_history, mo_loc)
copy old mos to new ones, allocating as necessary
subroutine, public qs_loc_init(qs_env, qs_loc_env, localize_section, mos_localized, do_homo, do_mo_cubes, mo_loc_history, evals, tot_zeff_corr, do_mixed)
initializes everything needed for localization of the molecular orbitals
Routines for calculating local energy and stress tensor.
subroutine, public qs_local_stress(qs_env, stress_tensor, beta)
Routine to calculate the local stress.
subroutine, public qs_local_energy(qs_env, energy_density)
Routine to calculate the local energy.
Definition and initialisation of the mo data type.
subroutine, public write_dm_binary_restart(mo_array, dft_section, tmpl_matrix)
calculates density matrix from mo set and writes the density matrix into a binary restart file
collects routines that perform operations directly related to MOs
subroutine, public make_mo_eig(mos, nspins, ks_rmpv, scf_control, mo_derivs, admm_env, hairy_probes, probe)
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.
Calculates the moment integrals <a|r^m|b> and <a|r x d/dr|b>
subroutine, public qs_moment_locop(qs_env, magnetic, nmoments, reference, ref_point, unit_number, vel_reprs, com_nl)
...
subroutine, public qs_moment_berry_phase(qs_env, magnetic, nmoments, reference, ref_point, unit_number)
...
Define the neighbor list data types and the corresponding functionality.
subroutine, public neighbor_list_iterator_create(iterator_set, nl, search, nthread)
Neighbor list iterator functions.
subroutine, public neighbor_list_iterator_release(iterator_set)
...
subroutine, public get_neighbor_list_set_p(neighbor_list_sets, nlist, symmetric)
Return the components of the first neighbor list set.
integer function, public neighbor_list_iterate(iterator_set, mepos)
...
subroutine, public get_iterator_info(iterator_set, mepos, ikind, jkind, nkind, ilist, nlist, inode, nnode, iatom, jatom, r, cell)
...
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.
provides a resp fit for gas phase systems
subroutine, public resp_fit(qs_env)
performs resp fit and generates RESP charges
subroutine, public get_rho0_mpole(rho0_mpole, g0_h, vg0_h, iat, ikind, lmax_0, l0_ikind, mp_gau_ikind, mp_rho, norm_g0l_h, qlm_gg, qlm_car, qlm_tot, zet0_h, igrid_zet0_s, rpgf0_h, rpgf0_s, max_rpgf0_s, rho0_s_rs, rho0_s_gs, rhoz_cneo_s_rs, rhoz_cneo_s_gs)
...
methods of the rho structure (defined in qs_rho_types)
subroutine, public qs_rho_update_rho(rho_struct, qs_env, rho_xc_external, local_rho_set, task_list_external, task_list_external_soft, pw_env_external, para_env_external)
updates rho_r and rho_g to the rhorho_ao. if use_kinetic_energy_density also computes tau_r and tau_g...
superstucture that hold various representations of the density and keeps track of which ones are vali...
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 GPW/GAPW.
subroutine, public make_lumo_gpw(qs_env, scf_env, unoccupied_orbs, unoccupied_evals, nlumo, nlumos)
Gets the lumos, and eigenvalues for the lumos.
subroutine, public write_mo_free_results(qs_env)
Write QS results always available (if switched on through the print_keys) Can be called from ls_scf.
subroutine, public qs_scf_post_moments(input, logger, qs_env, output_unit)
Computes and prints electric moments.
subroutine, public write_mo_dependent_results(qs_env, scf_env)
Write QS results available if MO's are present (if switched on through the print_keys) Writes only MO...
subroutine, public scf_post_calculation_gpw(qs_env, wf_type, do_mp2)
collects possible post - scf calculations and prints info / computes properties.
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)
...
Interface to Wannier90 code.
subroutine, public wannier90_interface(input, logger, qs_env)
...
Methods related to (\cal S)^2 (i.e. spin)
subroutine, public compute_s_square(mos, matrix_s, s_square, s_square_ideal, mo_derivs, strength)
Compute the expectation value <(\cal S)^2> of the single determinant defined by the spin up (alpha) a...
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...
routines for DFT+NEGF calculations (coupling with the quantum transport code OMEN)
subroutine, public qs_scf_post_transport(qs_env)
post scf calculations for transport
The module to read/write TREX IO files for interfacing CP2K with other programs.
subroutine, public write_trexio(qs_env, trexio_section, energy_derivative)
Write a trexio file.
Interface for Voronoi Integration and output of BQB files.
subroutine, public entry_voronoi_or_bqb(do_voro, do_bqb, input_voro, input_bqb, unit_voro, qs_env, rspace_pw)
Does a Voronoi integration of density or stores the density to compressed BQB format.
subroutine, public xray_diffraction_spectrum(qs_env, unit_number, q_max)
Calculate the coherent X-ray diffraction spectrum using the total electronic density in reciprocal sp...
subroutine, public calculate_rhotot_elec_gspace(qs_env, auxbas_pw_pool, rhotot_elec_gspace, q_max, rho_hard, rho_soft, fsign)
The total electronic density in reciprocal space (g-space) is calculated.
stores some data used in wavefunction fitting
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...
quantities needed for a Hirshfeld based partitioning of real space
Contains information about kpoints.
stores all the informations relevant to an mpi environment
represent a list of objects
contained for different pw related things
environment for the poisson solver
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.
contains all the info needed by quickstep to calculate the spread of a selected set of orbitals and i...
keeps the density in various representations, keeping track of which ones are valid.