38 use,
intrinsic :: iso_fortran_env
106 logical :: calculating
107 logical :: time_present
109 real(real64),
allocatable :: density(:, :)
110 logical :: total_density_alloc
111 real(real64),
pointer,
contiguous :: total_density(:)
112 type(energy_t),
allocatable :: energy
114 type(states_elec_t),
pointer :: hf_st
119 real(real64),
allocatable :: vxc(:, :)
120 real(real64),
allocatable :: vtau(:, :)
121 real(real64),
allocatable :: axc(:, :, :)
122 real(real64),
allocatable :: a_ind(:, :)
123 real(real64),
allocatable :: b_ind(:, :)
124 logical :: calc_energy
129 integer,
public :: theory_level = -1
130 logical,
public :: frozen_hxc = .false.
132 integer,
public :: xc_family = 0
133 integer,
public :: xc_flags = 0
134 integer,
public :: xc_photon = 0
135 type(xc_t),
public :: xc
136 type(xc_photons_t),
public :: xc_photons
137 type(xc_oep_t),
public :: oep
138 type(xc_oep_photon_t),
public :: oep_photon
139 type(xc_ks_inversion_t),
public :: ks_inversion
140 type(xc_sic_t),
public :: sic
141 type(xc_vdw_t),
public :: vdw
142 type(grid_t),
pointer,
public :: gr
143 type(v_ks_calc_t) :: calc
144 logical :: calculate_current = .false.
145 type(current_t) :: current_calculator
146 logical :: include_td_field = .false.
147 logical,
public :: has_photons = .false.
148 logical :: xc_photon_include_hartree = .
true.
150 real(real64),
public :: stress_xc_gga(3, 3)
151 type(photon_mode_t),
pointer,
public :: pt => null()
152 type(mf_t),
public :: pt_mx
158 subroutine v_ks_init(ks, namespace, gr, st, ions, mc, space, kpoints)
159 type(v_ks_t),
intent(inout) :: ks
160 type(namespace_t),
intent(in) :: namespace
161 type(grid_t),
target,
intent(inout) :: gr
162 type(states_elec_t),
intent(in) :: st
163 type(ions_t),
intent(inout) :: ions
164 type(multicomm_t),
intent(in) :: mc
165 class(space_t),
intent(in) :: space
166 type(kpoints_t),
intent(in) :: kpoints
168 integer :: x_id, c_id, xk_id, ck_id, default, val
169 logical :: parsed_theory_level, using_hartree_fock
170 integer :: pseudo_x_functional, pseudo_c_functional
213 ks%xc_family = xc_family_none
219 parsed_theory_level = .false.
226 parsed_theory_level = .
true.
240 call messages_write(
'Info: the XCFunctional has been selected to match the pseudopotentials', new_line = .
true.)
255 call messages_write(
'The XCFunctional that you selected does not match the one used', new_line = .
true.)
304 call parse_variable(namespace,
'XCPhotonFunctional', option__xcphotonfunctional__none, ks%xc_photon)
314 call parse_variable(namespace,
'XCPhotonIncludeHartree', .
true., ks%xc_photon_include_hartree)
316 if (.not. ks%xc_photon_include_hartree)
then
327 using_hartree_fock = (ks%theory_level ==
hartree_fock) &
329 call xc_init(ks%xc, namespace, space%dim, space%periodic_dim, st%qtot, &
330 x_id, c_id, xk_id, ck_id,
hartree_fock = using_hartree_fock, ispin=st%d%ispin)
332 ks%xc_family = ks%xc%family
333 ks%xc_flags = ks%xc%flags
335 if (.not. parsed_theory_level)
then
344 call parse_variable(namespace,
'TheoryLevel', default, ks%theory_level)
356 ks%xc_family = ior(ks%xc_family, xc_family_oep)
366 ks%sic%amaldi_factor =
m_one
368 select case (ks%theory_level)
373 if (space%periodic_dim == space%dim)
then
376 if (kpoints%full%npoints > 1)
then
381 if (kpoints%full%npoints > 1)
then
396 if (
bitand(ks%xc_family, xc_family_lda + xc_family_gga) /= 0)
then
397 call xc_sic_init(ks%sic, namespace, gr, st, mc, space)
400 if (
bitand(ks%xc_family, xc_family_oep) /= 0)
then
401 select case (ks%xc%functional(
func_x,1)%id)
403 if (kpoints%reduced%npoints > 1)
then
408 if (kpoints%reduced%npoints > 1)
then
413 if((.not. ks%has_photons) .or. (ks%xc_photon /= 0))
then
414 if(oep_type == -1)
then
417 call xc_oep_init(ks%oep, namespace, gr, st, mc, space, oep_type)
431 message(1) =
"SICCorrection can only be used with Kohn-Sham DFT"
435 if (st%d%ispin ==
spinors)
then
436 if (
bitand(ks%xc_family, xc_family_mgga + xc_family_hyb_mgga) /= 0)
then
441 ks%frozen_hxc = .false.
446 ks%calc%calculating = .false.
451 call ks%vdw%init(namespace, space, gr, ks%xc, ions, x_id, c_id)
452 if (ks%vdw%vdw_correction /= option__vdwcorrection__none .and. ks%theory_level ==
rdmft)
then
453 message(1) =
"VDWCorrection and RDMFT are not compatible"
456 if (ks%vdw%vdw_correction /= option__vdwcorrection__none .and. ks%theory_level ==
independent_particles)
then
457 message(1) =
"VDWCorrection and independent particles are not compatible"
461 if (ks%xc_photon /= 0)
then
463 call ks%xc_photons%init(namespace, ks%xc_photon , space, gr, st)
475 integer,
intent(out) :: x_functional
476 integer,
intent(out) :: c_functional
478 integer :: xf, cf, ispecies
479 logical :: warned_inconsistent
484 warned_inconsistent = .false.
485 do ispecies = 1, ions%nspecies
486 select type(spec=>ions%species(ispecies)%s)
488 xf = spec%x_functional()
489 cf = spec%c_functional()
492 call messages_write(
"Unknown XC functional for species '"//trim(ions%species(ispecies)%s%get_label())//
"'")
500 if (xf /= x_functional .and. .not. warned_inconsistent)
then
501 call messages_write(
'Inconsistent XC functional detected between species')
503 warned_inconsistent = .
true.
510 if (cf /= c_functional .and. .not. warned_inconsistent)
then
511 call messages_write(
'Inconsistent XC functional detected between species')
513 warned_inconsistent = .
true.
533 type(
v_ks_t),
intent(inout) :: ks
539 select case (ks%theory_level)
544 if (
bitand(ks%xc_family, xc_family_oep) /= 0)
then
554 if (ks%xc_photon /= 0)
then
555 call ks%xc_photons%end()
565 type(
v_ks_t),
intent(in) :: ks
566 integer,
optional,
intent(in) :: iunit
567 type(
namespace_t),
optional,
intent(in) :: namespace
574 select case (ks%theory_level)
599 subroutine v_ks_h_setup(namespace, space, gr, ions, ext_partners, st, ks, hm, calc_eigenval, calc_current)
602 type(
grid_t),
intent(in) :: gr
603 type(
ions_t),
intent(in) :: ions
606 type(
v_ks_t),
intent(inout) :: ks
608 logical,
optional,
intent(in) :: calc_eigenval
609 logical,
optional,
intent(in) :: calc_current
611 integer,
allocatable :: ind(:)
613 real(real64),
allocatable :: copy_occ(:)
614 logical :: calc_eigenval_
615 logical :: calc_current_
623 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
624 calc_eigenval = calc_eigenval_, calc_current = calc_current_)
626 if (st%restart_reorder_occs .and. .not. st%fromScratch)
then
627 message(1) =
"Reordering occupations for restart."
630 safe_allocate(ind(1:st%nst))
631 safe_allocate(copy_occ(1:st%nst))
634 call sort(st%eigenval(:, ik), ind)
635 copy_occ(1:st%nst) = st%occ(1:st%nst, ik)
637 st%occ(ist, ik) = copy_occ(ind(ist))
641 safe_deallocate_a(ind)
642 safe_deallocate_a(copy_occ)
652 subroutine v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
653 calc_eigenval, time, calc_energy, calc_current, force_semilocal)
654 type(
v_ks_t),
intent(inout) :: ks
661 logical,
optional,
intent(in) :: calc_eigenval
662 real(real64),
optional,
intent(in) :: time
663 logical,
optional,
intent(in) :: calc_energy
664 logical,
optional,
intent(in) :: calc_current
665 logical,
optional,
intent(in) :: force_semilocal
667 logical :: calc_current_
672 .and. ks%calculate_current &
676 if (calc_current_)
then
681 call v_ks_calc_start(ks, namespace, space, hm, st, ions, hm%kpoints%latt, ext_partners, time, &
682 calc_energy, force_semilocal=force_semilocal)
684 ext_partners, force_semilocal=force_semilocal)
695 call lalg_axpy(ks%gr%np, st%d%nspin,
m_one, hm%magnetic_constrain%pot, hm%ks_pot%vhxc)
707 subroutine v_ks_calc_start(ks, namespace, space, hm, st, ions, latt, ext_partners, time, &
708 calc_energy, force_semilocal)
709 type(
v_ks_t),
target,
intent(inout) :: ks
711 class(
space_t),
intent(in) :: space
714 type(
ions_t),
intent(in) :: ions
717 real(real64),
optional,
intent(in) :: time
718 logical,
optional,
intent(in) :: calc_energy
719 logical,
optional,
intent(in) :: force_semilocal
725 assert(.not. ks%calc%calculating)
726 ks%calc%calculating = .
true.
728 write(
message(1),
'(a)')
'Debug: Calculating Kohn-Sham potential.'
731 ks%calc%time_present =
present(time)
737 if (ks%frozen_hxc)
then
743 allocate(ks%calc%energy)
749 nullify(ks%calc%total_density)
759 if (ks%theory_level /=
hartree .and. ks%theory_level /=
rdmft)
call v_a_xc(hm, force_semilocal)
761 ks%calc%total_density_alloc = .false.
768 nullify(ks%calc%hf_st)
773 if (st%parallel_in_states)
then
775 call messages_write(
'State parallelization of Hartree-Fock exchange is not supported')
777 call messages_write(
'when running with OpenCL/CUDA. Please use domain parallelization')
779 call messages_write(
"or disable acceleration using 'DisableAccel = yes'.")
784 if (hm%exxop%useACE)
then
787 safe_allocate(ks%calc%hf_st)
796 if (hm%self_induced_magnetic)
then
797 safe_allocate(ks%calc%a_ind(1:ks%gr%np_part, 1:space%dim))
798 safe_allocate(ks%calc%b_ind(1:ks%gr%np_part, 1:space%dim))
799 call magnetic_induced(namespace, ks%gr, st, hm%psolver, hm%kpoints, ks%calc%a_ind, ks%calc%b_ind)
802 if ((ks%has_photons) .and. (ks%calc%time_present) .and. (ks%xc_photon == 0) )
then
803 call mf_calc(ks%pt_mx, ks%gr, st, ions, ks%pt, time)
821 safe_allocate(ks%calc%density(1:ks%gr%np, 1:st%d%nspin))
826 call lalg_scal(ks%gr%np, st%d%nspin, ks%sic%amaldi_factor, ks%calc%density)
829 nullify(ks%calc%total_density)
830 if (
allocated(st%rho_core) .or. hm%d%spin_channels > 1)
then
831 ks%calc%total_density_alloc = .
true.
833 safe_allocate(ks%calc%total_density(1:ks%gr%np))
836 ks%calc%total_density(ip) = sum(ks%calc%density(ip, 1:hm%d%spin_channels))
840 if (
allocated(st%rho_core))
then
841 call lalg_axpy(ks%gr%np, -ks%sic%amaldi_factor, st%rho_core, ks%calc%total_density)
844 ks%calc%total_density_alloc = .false.
845 ks%calc%total_density => ks%calc%density(:, 1)
852 subroutine v_a_xc(hm, force_semilocal)
854 logical,
optional,
intent(in) :: force_semilocal
861 ks%calc%energy%exchange =
m_zero
862 ks%calc%energy%correlation =
m_zero
863 ks%calc%energy%xc_j =
m_zero
864 ks%calc%energy%vdw =
m_zero
866 allocate(ks%calc%vxc(1:ks%gr%np, 1:st%d%nspin))
870 safe_allocate(ks%calc%vtau(1:ks%gr%np, 1:st%d%nspin))
875 if (ks%calc%calc_energy)
then
877 call xc_get_vxc(ks%gr, ks%xc, st, hm%kpoints, hm%psolver, namespace, space, ks%calc%density, st%d%ispin, &
878 latt%rcell_volume, ks%calc%vxc, ex = ks%calc%energy%exchange, ec = ks%calc%energy%correlation, &
879 deltaxc = ks%calc%energy%delta_xc, vtau = ks%calc%vtau, force_orbitalfree=force_semilocal)
881 call xc_get_vxc(ks%gr, ks%xc, st, hm%kpoints, hm%psolver, namespace, space, ks%calc%density, st%d%ispin, &
882 latt%rcell_volume, ks%calc%vxc, ex = ks%calc%energy%exchange, ec = ks%calc%energy%correlation, &
883 deltaxc = ks%calc%energy%delta_xc, stress_xc=ks%stress_xc_gga, force_orbitalfree=force_semilocal)
887 call xc_get_vxc(ks%gr, ks%xc, st, hm%kpoints, hm%psolver, namespace, space, ks%calc%density, &
888 st%d%ispin, latt%rcell_volume, ks%calc%vxc, vtau = ks%calc%vtau, force_orbitalfree=force_semilocal)
890 call xc_get_vxc(ks%gr, ks%xc, st, hm%kpoints, hm%psolver, namespace, space, ks%calc%density, &
891 st%d%ispin, latt%rcell_volume, ks%calc%vxc, stress_xc=ks%stress_xc_gga, force_orbitalfree=force_semilocal)
897 if (st%d%ispin /=
spinors)
then
898 message(1) =
"Noncollinear functionals can only be used with spinor wavefunctions."
903 message(1) =
"Cannot perform LCAO for noncollinear MGGAs."
904 message(2) =
"Please perform a LDA calculation first."
908 if (ks%calc%calc_energy)
then
910 call xc_get_nc_vxc(ks%gr, ks%xc, st, hm%kpoints, space, namespace, ks%calc%density, ks%calc%vxc, &
911 vtau = ks%calc%vtau, ex = ks%calc%energy%exchange, ec = ks%calc%energy%correlation)
913 call xc_get_nc_vxc(ks%gr, ks%xc, st, hm%kpoints, space, namespace, ks%calc%density, ks%calc%vxc, &
914 ex = ks%calc%energy%exchange, ec = ks%calc%energy%correlation)
918 call xc_get_nc_vxc(ks%gr, ks%xc, st, hm%kpoints, space, namespace, ks%calc%density, &
919 ks%calc%vxc, vtau = ks%calc%vtau)
921 call xc_get_nc_vxc(ks%gr, ks%xc, st, hm%kpoints, space, namespace, ks%calc%density, ks%calc%vxc)
926 call ks%vdw%calc(namespace, space, latt, ions%atom, ions%natoms, ions%pos, &
927 ks%gr, st, ks%calc%energy%vdw, ks%calc%vxc)
940 if (ks%calc%calc_energy)
then
941 call xc_sic_calc_adsic(ks%sic, namespace, space, ks%gr, st, hm, ks%xc, ks%calc%density, &
942 ks%calc%vxc, ex = ks%calc%energy%exchange, ec = ks%calc%energy%correlation)
944 call xc_sic_calc_adsic(ks%sic, namespace, space, ks%gr, st, hm, ks%xc, ks%calc%density, &
956 call x_slater_calc(namespace, ks%gr, space, hm%exxop, st, hm%kpoints, ks%calc%energy%exchange, &
959 call x_fbe_calc(ks%xc%functional(
func_x,1)%id, namespace, hm%psolver, ks%gr, st, space, &
960 ks%calc%energy%exchange, vxc = ks%calc%vxc)
964 call fbe_c_lda_sl(namespace, hm%psolver, ks%gr, st, space, &
965 ks%calc%energy%correlation, vxc = ks%calc%vxc)
973 call xc_ks_inversion_calc(ks%ks_inversion, namespace, space, ks%gr, hm, ext_partners, st, vxc = ks%calc%vxc, &
978 if (ks%xc_photon /= 0)
then
980 call ks%xc_photons%v_ks(namespace, ks%calc%total_density, ks%gr, space, hm%psolver, hm%ep, st)
983 do ispin = 1, hm%d%spin_channels
984 call lalg_axpy(ks%gr%np,
m_one, ks%xc_photons%vpx(1:ks%gr%np), ks%calc%vxc(1:ks%gr%np, ispin) )
988 ks%calc%energy%photon_exchange = ks%xc_photons%ex
993 if (ks%calc%calc_energy)
then
1006 subroutine v_ks_calc_finish(ks, hm, namespace, space, latt, st, ext_partners, force_semilocal)
1007 type(
v_ks_t),
target,
intent(inout) :: ks
1010 class(
space_t),
intent(in) :: space
1014 logical,
optional,
intent(in) :: force_semilocal
1016 integer :: ip, ispin
1019 real(real64) :: exx_energy
1020 real(real64) :: factor
1024 assert(ks%calc%calculating)
1025 ks%calc%calculating = .false.
1027 if (ks%frozen_hxc)
then
1033 safe_deallocate_a(hm%energy)
1034 call move_alloc(ks%calc%energy, hm%energy)
1036 if (hm%self_induced_magnetic)
then
1037 hm%a_ind(1:ks%gr%np, 1:space%dim) = ks%calc%a_ind(1:ks%gr%np, 1:space%dim)
1038 hm%b_ind(1:ks%gr%np, 1:space%dim) = ks%calc%b_ind(1:ks%gr%np, 1:space%dim)
1040 safe_deallocate_a(ks%calc%a_ind)
1041 safe_deallocate_a(ks%calc%b_ind)
1044 if (
allocated(hm%v_static))
then
1045 hm%energy%intnvstatic =
dmf_dotp(ks%gr, ks%calc%total_density, hm%v_static)
1047 hm%energy%intnvstatic =
m_zero
1053 hm%energy%intnvxc =
m_zero
1054 hm%energy%hartree =
m_zero
1055 hm%energy%exchange =
m_zero
1056 hm%energy%exchange_hf =
m_zero
1057 hm%energy%correlation =
m_zero
1060 hm%energy%hartree =
m_zero
1061 call v_ks_hartree(namespace, ks, space, hm, ext_partners)
1067 call dxc_oep_calc(ks%sic%oep, namespace, ks%xc, ks%gr, hm, st, space, &
1068 latt%rcell_volume, hm%energy%exchange, hm%energy%correlation, vxc = ks%calc%vxc)
1070 call zxc_oep_calc(ks%sic%oep, namespace, ks%xc, ks%gr, hm, st, space, &
1071 latt%rcell_volume, hm%energy%exchange, hm%energy%correlation, vxc = ks%calc%vxc)
1080 call dxc_oep_calc(ks%oep, namespace, ks%xc, ks%gr, hm, st, space, &
1081 latt%rcell_volume, hm%energy%exchange, hm%energy%correlation, vxc = ks%calc%vxc)
1083 call zxc_oep_calc(ks%oep, namespace, ks%xc, ks%gr, hm, st, space, &
1084 latt%rcell_volume, hm%energy%exchange, hm%energy%correlation, vxc = ks%calc%vxc)
1093 hm, st, space, hm%energy%exchange, hm%energy%correlation, vxc = ks%calc%vxc)
1096 hm, st, space, hm%energy%exchange, hm%energy%correlation, vxc = ks%calc%vxc)
1098 hm%energy%photon_exchange = ks%oep_photon%pt%ex
1102 if (ks%calc%calc_energy)
then
1104 hm%energy%intnvxc =
m_zero
1107 do ispin = 1, hm%d%nspin
1108 if (ispin <= 2)
then
1113 hm%energy%intnvxc = hm%energy%intnvxc + &
1114 factor*
dmf_dotp(ks%gr, st%rho(:, ispin), ks%calc%vxc(:, ispin), reduce = .false.)
1116 call ks%gr%allreduce(hm%energy%intnvxc)
1121 if (ks%theory_level /=
hartree .and. ks%theory_level /=
rdmft)
then
1123 safe_deallocate_a(hm%ks_pot%vxc)
1124 call move_alloc(ks%calc%vxc, hm%ks_pot%vxc)
1127 call hm%ks_pot%set_vtau(ks%calc%vtau)
1128 safe_deallocate_a(ks%calc%vtau)
1134 hm%energy%intnvxc = hm%energy%intnvxc &
1137 hm%energy%intnvxc = hm%energy%intnvxc &
1147 if (.not. ks%xc_photon_include_hartree)
then
1148 hm%energy%hartree =
m_zero
1149 hm%ks_pot%vhartree =
m_zero
1155 hm%ks_pot%vhxc(ip, 1) = hm%ks_pot%vxc(ip, 1) + hm%ks_pot%vhartree(ip)
1157 if (
allocated(hm%vberry))
then
1159 hm%ks_pot%vhxc(ip, 1) = hm%ks_pot%vhxc(ip, 1) + hm%vberry(ip, 1)
1165 hm%ks_pot%vhxc(ip, 2) = hm%ks_pot%vxc(ip, 2) + hm%ks_pot%vhartree(ip)
1167 if (
allocated(hm%vberry))
then
1169 hm%ks_pot%vhxc(ip, 2) = hm%ks_pot%vhxc(ip, 2) + hm%vberry(ip, 2)
1174 if (hm%d%ispin ==
spinors)
then
1177 hm%ks_pot%vhxc(ip, ispin) = hm%ks_pot%vxc(ip, ispin)
1183 hm%energy%exchange_hf =
m_zero
1185 .or. ks%theory_level ==
rdmft &
1189 if (.not. hm%exxop%useACE)
then
1191 if (
associated(hm%exxop%st))
then
1194 safe_deallocate_p(hm%exxop%st)
1205 select case (ks%theory_level)
1219 if (hm%exxop%useACE)
then
1223 if (hm%exxop%with_isdf)
then
1226 call hm%exxop%isdf%get_interpolation_points(namespace, space, ks%gr, st%rho(1:ks%gr%np, 1))
1228 ks%calc%hf_st, xst, hm%kpoints)
1231 ks%calc%hf_st, xst, hm%kpoints)
1237 ks%calc%hf_st, xst, hm%kpoints)
1239 if (hm%phase%is_allocated())
then
1246 exx_energy = exx_energy + hm%exxop%singul%energy
1250 select case (ks%theory_level)
1253 hm%energy%exchange_hf = hm%energy%exchange_hf + exx_energy
1256 hm%energy%exchange_hf = hm%energy%exchange_hf + exx_energy
1274 if (ks%has_photons .and. (ks%xc_photon == 0))
then
1275 if (
associated(ks%pt_mx%vmf))
then
1276 forall(ip = 1:ks%gr%np) hm%ks_pot%vhxc(ip, 1) = hm%ks_pot%vhxc(ip, 1) + ks%pt_mx%vmf(ip)
1278 forall(ip = 1:ks%gr%np) hm%ks_pot%vhxc(ip, 2) = hm%ks_pot%vhxc(ip, 2) + ks%pt_mx%vmf(ip)
1281 hm%ep%photon_forces(1:space%dim) = ks%pt_mx%fmf(1:space%dim)
1284 if (ks%vdw%vdw_correction /= option__vdwcorrection__none)
then
1285 assert(
allocated(ks%vdw%forces))
1286 hm%ep%vdw_forces(:, :) = ks%vdw%forces(:, :)
1287 hm%ep%vdw_stress = ks%vdw%stress
1288 safe_deallocate_a(ks%vdw%forces)
1290 hm%ep%vdw_forces = 0.0_real64
1293 if (ks%calc%time_present .or. hm%time_zero)
then
1294 call hm%update(ks%gr, namespace, space, ext_partners, time = ks%calc%time)
1300 safe_deallocate_a(ks%calc%density)
1301 if (ks%calc%total_density_alloc)
then
1302 safe_deallocate_p(ks%calc%total_density)
1304 nullify(ks%calc%total_density)
1318 class(
space_t),
intent(in ) :: space
1319 class(
mesh_t),
intent(in ) :: gr
1325 if (exxop%isdf%use_serial)
then
1327 hf_st, xst, kpoints)
1329 call isdf_parallel_ace_compute_potentials(exxop, namespace, space, gr, &
1330 hf_st, xst, kpoints)
1341 subroutine v_ks_hartree(namespace, ks, space, hm, ext_partners)
1343 type(
v_ks_t),
intent(inout) :: ks
1344 class(
space_t),
intent(in) :: space
1352 call dpoisson_solve(hm%psolver, namespace, hm%ks_pot%vhartree, ks%calc%total_density, reset=.false.)
1358 if (ks%calc%calc_energy)
then
1360 hm%energy%hartree =
m_half*
dmf_dotp(ks%gr, ks%calc%total_density, hm%ks_pot%vhartree)
1364 if(ks%calc%time_present)
then
1367 ks%calc%total_density, hm%energy%pcm_corr, kick=hm%kick, time=ks%calc%time)
1370 ks%calc%total_density, hm%energy%pcm_corr, time=ks%calc%time)
1375 ks%calc%total_density, hm%energy%pcm_corr, kick=hm%kick)
1378 ks%calc%total_density, hm%energy%pcm_corr)
1389 type(
v_ks_t),
intent(inout) :: ks
1393 ks%frozen_hxc = .
true.
1400 type(
v_ks_t),
intent(inout) :: this
1401 logical,
intent(in) :: calc_cur
1405 this%calculate_current = calc_cur
1412 type(
v_ks_t),
intent(inout) :: ks
1416 real(real64),
intent(out) :: int_dft_u
constant times a vector plus a vector
scales a vector by a constant
This is the common interface to a sorting routine. It performs the shell algorithm,...
pure logical function, public accel_is_enabled()
subroutine, public current_calculate(this, namespace, gr, hm, space, st)
Compute total electronic current density.
subroutine, public current_init(this, namespace)
This module implements a calculator for the density and defines related functions.
subroutine, public states_elec_total_density(st, mesh, total_rho)
This routine calculates the total electronic density.
subroutine, public density_calc(st, gr, density, istin)
Computes the density from the orbitals in st.
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
integer, parameter, public unpolarized
Parameters...
integer, parameter, public spinors
subroutine, public energy_calc_total(namespace, space, hm, gr, st, ext_partners, iunit, full)
This subroutine calculates the total energy of the system. Basically, it adds up the KS eigenvalues,...
real(real64) function, public zenergy_calc_electronic(namespace, hm, der, st, terms)
real(real64) function, public denergy_calc_electronic(namespace, hm, der, st, terms)
subroutine, public energy_calc_eigenvalues(namespace, hm, der, st)
subroutine, public energy_copy(ein, eout)
subroutine, public dexchange_operator_ace(this, namespace, mesh, st, xst, phase)
subroutine, public zexchange_operator_compute_potentials(this, namespace, space, gr, st, xst, kpoints, F_out)
subroutine, public exchange_operator_reinit(this, cam, st)
subroutine, public dexchange_operator_compute_potentials(this, namespace, space, gr, st, xst, kpoints, F_out)
subroutine, public zexchange_operator_ace(this, namespace, mesh, st, xst, phase)
real(real64) function, public dexchange_operator_compute_ex(mesh, st, xst)
Compute the exact exchange energy.
real(real64) function, public zexchange_operator_compute_ex(mesh, st, xst)
Compute the exact exchange energy.
real(real64), parameter, public m_two
real(real64), parameter, public m_zero
integer, parameter, public rdmft
integer, parameter, public hartree_fock
integer, parameter, public independent_particles
Theory level.
integer, parameter, public generalized_kohn_sham_dft
integer, parameter, public kohn_sham_dft
real(real64), parameter, public m_epsilon
real(real64), parameter, public m_half
real(real64), parameter, public m_one
integer, parameter, public hartree
This module implements the underlying real-space grid.
integer, parameter, public term_mgga
integer, parameter, public term_dft_u
logical function, public hamiltonian_elec_has_kick(hm)
logical function, public hamiltonian_elec_needs_current(hm, states_are_real)
subroutine, public hamiltonian_elec_update_pot(this, mesh, accumulate)
Update the KS potential of the electronic Hamiltonian.
This module defines classes and functions for interaction partners.
Interoperable Separable Density Fitting (ISDF) molecular implementation.
subroutine, public isdf_ace_compute_potentials(exxop, namespace, space, mesh, st, Vx_on_st, kpoints)
ISDF wrapper computing interpolation points and vectors, which are used to build the potential used ...
Serial prototype for benchmarking and validating ISDF implementation.
subroutine, public isdf_serial_ace_compute_potentials(exxop, namespace, space, mesh, st, Vx_on_st, kpoints)
ISDF wrapper computing interpolation points and vectors, which are used to build the potential used ...
A module to handle KS potential, without the external potential.
integer, parameter, public dft_u_none
This modules implements the routines for doing constrain DFT for noncollinear magnetism.
integer, parameter, public constrain_none
subroutine, public magnetic_constrain_update(this, mesh, std, space, latt, pos, rho)
Recomputes the magnetic contraining potential.
subroutine, public magnetic_induced(namespace, gr, st, psolver, kpoints, a_ind, b_ind)
This subroutine receives as input a current, and produces as an output the vector potential that it i...
This module defines various routines, operating on mesh functions.
This module defines the meshes, which are used in Octopus.
subroutine, public messages_print_with_emphasis(msg, iunit, namespace)
subroutine, public messages_not_implemented(feature, namespace)
character(len=512), private msg
subroutine, public messages_warning(no_lines, all_nodes, namespace)
subroutine, public messages_obsolete_variable(namespace, name, rep)
subroutine, public messages_new_line()
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
subroutine, public messages_input_error(namespace, var, details, row, column)
subroutine, public messages_experimental(name, namespace)
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
This module handles the communicators for the various parallelization strategies.
logical function, public parse_is_defined(namespace, name)
subroutine, public pcm_hartree_potential(pcm, space, mesh, psolver, ext_partners, vhartree, density, pcm_corr, kick, time)
PCM reaction field due to the electronic density.
subroutine, public mf_calc(this, gr, st, ions, pt_mode, time)
subroutine, public dpoisson_solve_start(this, rho)
subroutine, public dpoisson_solve(this, namespace, pot, rho, all_nodes, kernel, reset)
Calculates the Poisson equation. Given the density returns the corresponding potential.
subroutine, public dpoisson_solve_finish(this, pot)
logical pure function, public poisson_is_async(this)
subroutine, public profiling_out(label)
Increment out counter and sum up difference between entry and exit time.
subroutine, public profiling_in(label, exclude)
Increment in counter and save entry time.
integer, parameter, public pseudo_exchange_unknown
integer, parameter, public pseudo_correlation_unknown
integer, parameter, public pseudo_correlation_any
integer, parameter, public pseudo_exchange_any
This module is intended to contain "only mathematical" functions and procedures.
integer, parameter, private libxc_c_index
pure logical function, public states_are_complex(st)
pure logical function, public states_are_real(st)
This module handles spin dimensions of the states and the k-point distribution.
subroutine, public states_elec_fermi(st, namespace, mesh, compute_spin)
calculate the Fermi level for the states in this object
subroutine, public states_elec_end(st)
finalize the states_elec_t object
subroutine, public states_elec_copy(stout, stin, exclude_wfns, exclude_eigenval, special)
make a (selective) copy of a states_elec_t object
subroutine, public states_elec_allocate_current(st, space, mesh)
This module provides routines for communicating states when using states parallelization.
subroutine, public states_elec_parallel_remote_access_stop(this)
stop remote memory access for states on other processors
subroutine, public states_elec_parallel_remote_access_start(this)
start remote memory access for states on other processors
subroutine v_ks_hartree(namespace, ks, space, hm, ext_partners)
Hartree contribution to the KS potential. This function is designed to be used by v_ks_calc_finish an...
subroutine, public v_ks_calc_finish(ks, hm, namespace, space, latt, st, ext_partners, force_semilocal)
subroutine, public v_ks_freeze_hxc(ks)
subroutine, public v_ks_end(ks)
subroutine, public v_ks_calculate_current(this, calc_cur)
subroutine, public v_ks_write_info(ks, iunit, namespace)
subroutine, public v_ks_update_dftu_energy(ks, namespace, hm, st, int_dft_u)
Update the value of <\psi | V_U | \psi>, where V_U is the DFT+U potential.
subroutine, public v_ks_calc_start(ks, namespace, space, hm, st, ions, latt, ext_partners, time, calc_energy, force_semilocal)
This routine starts the calculation of the Kohn-Sham potential. The routine v_ks_calc_finish must be ...
subroutine, public v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval, time, calc_energy, calc_current, force_semilocal)
subroutine, public v_ks_h_setup(namespace, space, gr, ions, ext_partners, st, ks, hm, calc_eigenval, calc_current)
subroutine, public v_ks_init(ks, namespace, gr, st, ions, mc, space, kpoints)
subroutine, public x_slater_calc(namespace, gr, space, exxop, st, kpoints, ex, vxc)
Interface to X(slater_calc)
type(xc_cam_t), parameter, public cam_null
All CAM parameters set to zero.
type(xc_cam_t), parameter, public cam_exact_exchange
Use only Hartree Fock exact exchange.
subroutine, public x_fbe_calc(id, namespace, psolver, gr, st, space, ex, vxc)
Interface to X(x_fbe_calc) Two possible run modes possible: adiabatic and Sturm-Liouville....
subroutine, public fbe_c_lda_sl(namespace, psolver, gr, st, space, ec, vxc)
Sturm-Liouville version of the FBE local-density correlation functional.
integer, parameter, public xc_family_ks_inversion
declaring 'family' constants for 'functionals' not handled by libxc careful not to use a value define...
integer function, public xc_get_default_functional(dim, pseudo_x_functional, pseudo_c_functional)
Returns the default functional given the one parsed from the pseudopotentials and the space dimension...
integer, parameter, public xc_family_nc_mgga
integer, parameter, public xc_oep_x
Exact exchange.
integer, parameter, public xc_lda_c_fbe_sl
LDA correlation based ib the force-balance equation - Sturm-Liouville version.
integer, parameter, public xc_family_nc_lda
integer, parameter, public xc_oep_x_fbe_sl
Exchange approximation based on the force balance equation - Sturn-Liouville version.
integer, parameter, public xc_oep_x_fbe
Exchange approximation based on the force balance equation.
integer, parameter, public xc_oep_x_slater
Slater approximation to the exact exchange.
integer, parameter, public func_c
integer, parameter, public func_x
subroutine, public xc_ks_inversion_end(ks_inv)
subroutine, public xc_ks_inversion_write_info(ks_inversion, iunit, namespace)
subroutine, public xc_ks_inversion_init(ks_inv, namespace, gr, ions, st, xc, mc, space, kpoints)
subroutine, public xc_ks_inversion_calc(ks_inversion, namespace, space, gr, hm, ext_partners, st, vxc, time)
subroutine, public xc_write_info(xcs, iunit, namespace)
subroutine, public xc_init(xcs, namespace, ndim, periodic_dim, nel, x_id, c_id, xk_id, ck_id, hartree_fock, ispin)
pure logical function, public family_is_mgga(family, only_collinear)
Is the xc function part of the mGGA family.
logical pure function, public family_is_mgga_with_exc(xcs)
Is the xc function part of the mGGA family with an energy functional.
subroutine, public xc_end(xcs)
subroutine, public xc_get_vxc(gr, xcs, st, kpoints, psolver, namespace, space, rho, ispin, rcell_volume, vxc, ex, ec, deltaxc, vtau, ex_density, ec_density, stress_xc, force_orbitalfree)
logical pure function, public family_is_hybrid(xcs)
Returns true if the functional is an hybrid functional.
subroutine, public xc_get_nc_vxc(gr, xcs, st, kpoints, space, namespace, rho, vxc, ex, ec, vtau, ex_density, ec_density)
This routines is similar to xc_get_vxc but for noncollinear functionals, which are not implemented in...
integer, parameter, public oep_type_mgga
integer, parameter, public oep_level_none
the OEP levels
subroutine, public xc_oep_end(oep)
subroutine, public zxc_oep_calc(oep, namespace, xcs, gr, hm, st, space, rcell_volume, ex, ec, vxc)
This file handles the evaluation of the OEP potential, in the KLI or full OEP as described in S....
subroutine, public dxc_oep_calc(oep, namespace, xcs, gr, hm, st, space, rcell_volume, ex, ec, vxc)
This file handles the evaluation of the OEP potential, in the KLI or full OEP as described in S....
subroutine, public xc_oep_write_info(oep, iunit, namespace)
integer, parameter, public oep_type_exx
The different types of OEP that we can work with.
subroutine, public xc_oep_init(oep, namespace, gr, st, mc, space, oep_type)
subroutine, public zxc_oep_photon_calc(oep, namespace, xcs, gr, hm, st, space, ex, ec, vxc)
This file handles the evaluation of the OEP potential, in the KLI or full OEP as described in S....
subroutine, public dxc_oep_photon_calc(oep, namespace, xcs, gr, hm, st, space, ex, ec, vxc)
This file handles the evaluation of the OEP potential, in the KLI or full OEP as described in S....
This module implements the "photon-free" electron-photon exchange-correlation functional.
integer, parameter, public sic_none
no self-interaction correction
subroutine, public xc_sic_write_info(sic, iunit, namespace)
integer, parameter, public sic_adsic
Averaged density SIC.
subroutine, public xc_sic_init(sic, namespace, gr, st, mc, space)
initialize the SIC object
subroutine, public xc_sic_end(sic)
finalize the SIC and, if needed, the included OEP
integer, parameter, public sic_pz_oep
Perdew-Zunger SIC (OEP way)
integer, parameter, public sic_amaldi
Amaldi correction term.
subroutine, public xc_sic_calc_adsic(sic, namespace, space, gr, st, hm, xc, density, vxc, ex, ec)
Computes the ADSIC potential and energy.
A module that takes care of xc contribution from vdW interactions.
Extension of space that contains the knowledge of the spin dimension.
Description of the grid, containing information on derivatives, stencil, and symmetries.
Describes mesh distribution to nodes.
The states_elec_t class contains all electronic wave functions.
subroutine get_functional_from_pseudos(x_functional, c_functional)
Tries to find out the functional from the pseudopotential.
subroutine v_a_xc(hm, force_semilocal)
subroutine calculate_density()