42 use,
intrinsic :: iso_fortran_env
111 integer,
public,
parameter :: &
119 integer,
public :: max_iter
121 real(real64),
public :: lmm_r
124 logical :: conv_eigen_error
125 logical :: check_conv
128 logical :: calc_force
129 logical,
public :: calc_stress
130 logical :: calc_dipole
131 logical :: calc_polarization
132 logical :: calc_partial_charges
133 logical :: calc_orb_moments = .false.
136 type(mixfield_t),
pointer :: mixfield
137 type(eigensolver_t) :: eigens
139 logical :: forced_finish = .false.
140 type(lda_u_mixer_t) :: lda_u_mix
141 type(vtau_mixer_t) :: vtau_mix
142 type(berry_t) :: berry
145 type(restart_t),
public :: restart_load, restart_dump
147 type(criterion_list_t),
public :: criterion_list
148 real(real64) :: energy_in, energy_diff, abs_dens_diff, evsum_in, evsum_out, evsum_diff
151 logical :: converged_current, converged_last
152 integer :: verbosity_
154 real(real64),
allocatable :: rhoout(:,:), rhoin(:,:)
155 real(real64),
allocatable :: vhxc_old(:,:)
156 class(wfs_elec_t),
allocatable :: psioutb(:, :)
157 logical :: output_forces, calc_current, output_during_scf
158 logical :: finish = .false.
164 subroutine scf_init(scf, namespace, gr, ions, st, mc, hm, space)
165 type(scf_t),
intent(inout) :: scf
166 type(grid_t),
intent(in) :: gr
167 type(namespace_t),
intent(in) :: namespace
168 type(ions_t),
intent(in) :: ions
169 type(states_elec_t),
intent(in) :: st
170 type(multicomm_t),
intent(in) :: mc
171 type(hamiltonian_elec_t),
intent(inout) :: hm
172 class(space_t),
intent(in) :: space
175 integer :: mixdefault
176 type(type_t) :: mix_type
177 class(convergence_criterion_t),
pointer :: crit
178 type(criterion_iterator_t) :: iter
179 logical :: deactivate_oracle
202 if (
allocated(hm%vberry))
then
209 call iter%start(scf%criterion_list)
210 do while (iter%has_next())
211 crit => iter%get_next()
214 call crit%set_pointers(scf%energy_diff, scf%energy_in)
216 call crit%set_pointers(scf%abs_dens_diff, st%qtot)
218 call crit%set_pointers(scf%evsum_diff, scf%evsum_out)
225 if(.not. scf%check_conv .and. scf%max_iter < 0)
then
226 call messages_write(
"All convergence criteria are disabled. Octopus is cowardly refusing")
231 call messages_write(
"Please set one of the following variables to a positive value:")
234 call messages_write(
" | MaximumIter | ConvEnergy | ConvAbsDens | ConvRelDens |")
254 call parse_variable(namespace,
'ConvEigenError', .false., scf%conv_eigen_error)
256 if(scf%max_iter < 0) scf%max_iter = huge(scf%max_iter)
262 call eigensolver_init(scf%eigens, namespace, gr, st, hm, mc, space, deactivate_oracle)
264 if(scf%eigens%es_type /=
rs_evo)
then
288 mixdefault = option__mixfield__potential
291 call parse_variable(namespace,
'MixField', mixdefault, scf%mix_field)
295 if (scf%mix_field == option__mixfield__potential .and. hm%theory_level ==
independent_particles)
then
296 call messages_write(
'Input: Cannot mix the potential for non-interacting particles.')
300 if (scf%mix_field == option__mixfield__potential .and. hm%pcm%run_pcm)
then
301 call messages_write(
'Input: You have selected to mix the potential.', new_line = .
true.)
302 call messages_write(
' This might produce convergence problems for solvated systems.', new_line = .
true.)
307 if(scf%mix_field == option__mixfield__density &
310 call messages_write(
'Input: You have selected to mix the density with OEP or MGGA XC functionals.', new_line = .
true.)
311 call messages_write(
' This might produce convergence problems. Mix the potential instead.')
315 if(scf%mix_field == option__mixfield__states)
then
320 select case(scf%mix_field)
321 case (option__mixfield__potential, option__mixfield__density)
323 case(option__mixfield__states)
330 if (scf%mix_field /= option__mixfield__none)
then
331 call mix_init(scf%smix, namespace, space, gr%der, scf%mixdim1, st%d%nspin, func_type_ = mix_type)
335 if (scf%mix_field /= option__mixfield__states .and. scf%mix_field /= option__mixfield__none )
then
341 if(scf%mix_field == option__mixfield__potential)
then
347 scf%mix_field = option__mixfield__none
360 call parse_variable(namespace,
'SCFCalculateForces', .not. ions%only_user_def .and. .not. hm%ep%has_paw, &
363 if(scf%calc_force .and. gr%der%boundaries%spiralBC)
then
364 message(1) =
'Forces cannot be calculated when using spiral boundary conditions.'
365 write(
message(2),
'(a)')
'Please use SCFCalculateForces = no.'
368 if(scf%calc_force)
then
369 if (hm%ep%has_paw)
then
372 if (
allocated(hm%ep%b_field) .or.
allocated(hm%ep%a_static))
then
373 write(
message(1),
'(a)')
'The forces are currently not properly calculated if static'
374 write(
message(2),
'(a)')
'magnetic fields or static vector potentials are present.'
375 write(
message(3),
'(a)')
'Please use SCFCalculateForces = no.'
379 write(
message(1),
'(a)')
'The forces receive no contribution from the ZORA terms of the'
380 write(
message(2),
'(a)')
'Hamiltonian, and are therefore only approximate.'
394 call parse_variable(namespace,
'SCFCalculateStress', .false. , scf%calc_stress)
408 call parse_variable(namespace,
'SCFCalculateDipole', .not. space%is_periodic(), scf%calc_dipole)
409 if (
allocated(hm%vberry)) scf%calc_dipole = .
true.
423 call parse_variable(namespace,
'SCFCalculatePolarization', .false., scf%calc_polarization)
438 call parse_variable(namespace,
'SCFCalculateOrbitalMoments', .false. , scf%calc_orb_moments)
439 if((st%d%ispin /=
spinors .or. space%dim /= 3) .and. scf%calc_orb_moments)
then
440 message(1) =
"Orbital moments are only implemented for spinors and in 3D."
443 if (scf%calc_orb_moments .and. .not. (hm%ep%reltype ==
spin_orbit &
445 message(1) =
"Orbital moments are only available with SOC."
448 if(gr%use_curvilinear .and. scf%calc_orb_moments)
then
460 call parse_variable(namespace,
'SCFCalculatePartialCharges', .false., scf%calc_partial_charges)
461 if (scf%calc_partial_charges)
call messages_experimental(
'SCFCalculatePartialCharges', namespace=namespace)
463 rmin = ions%min_distance()
479 scf%forced_finish = .false.
487 type(
scf_t),
intent(inout) :: scf
496 if(scf%mix_field /= option__mixfield__none)
call mix_end(scf%smix)
498 nullify(scf%mixfield)
500 if (scf%mix_field /= option__mixfield__states .and. scf%mix_field /= option__mixfield__none)
then
505 call iter%start(scf%criterion_list)
506 do while (iter%has_next())
507 crit => iter%get_next()
508 safe_deallocate_p(crit)
517 type(
scf_t),
intent(inout) :: scf
523 if (scf%mix_field /= option__mixfield__states .and. scf%mix_field /= option__mixfield__none)
then
533 subroutine scf_load(scf, namespace, space, gr, ions, ext_partners, st, ks, hm, restart_load)
534 type(
scf_t),
intent(inout) :: scf
537 type(
grid_t),
intent(inout) :: gr
538 type(
ions_t),
intent(in) :: ions
541 type(
v_ks_t),
intent(inout) :: ks
543 type(
restart_t),
intent(in) :: restart_load
545 integer :: ierr, is, ip
553 message(1) =
'Unable to read density. Density will be calculated from states.'
556 if (
bitand(ks%xc_family, xc_family_oep) == 0)
then
557 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners)
560 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners)
567 call hm%ks_pot%load(restart_load, gr, ierr)
569 message(1) =
'Unable to read Vhxc. Vhxc will be calculated from states.'
572 call hm%update(gr, namespace, space, ext_partners)
573 if (
bitand(ks%xc_family, xc_family_oep) /= 0)
then
576 do is = 1, st%d%nspin
579 ks%oep%vxc(ip, is) = hm%ks_pot%vhxc(ip, is) - hm%ks_pot%vhartree(ip)
583 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners)
590 if (scf%mix_field == option__mixfield__density .or. scf%mix_field == option__mixfield__potential)
then
591 call mix_load(namespace, restart_load, scf%smix, gr, ierr)
593 message(1) =
"Unable to read mixing information. Mixing will start from scratch."
600 call lda_u_load(restart_load, hm%lda_u, st, hm%energy%dft_u, ierr)
602 message(1) =
"Unable to read DFT+U information. DFT+U data will be calculated from states."
622 subroutine scf_start(scf, namespace, gr, ions, st, ks, hm, outp, verbosity)
623 type(
scf_t),
intent(inout) :: scf
625 type(
grid_t),
intent(inout) :: gr
626 type(
ions_t),
intent(inout) :: ions
628 type(
v_ks_t),
intent(inout) :: ks
630 type(
output_t),
optional,
intent(in) :: outp
631 integer,
optional,
intent(in) :: verbosity
637 if(scf%forced_finish)
then
638 message(1) =
"Previous clean stop, not doing SCF and quitting."
642 if (.not. hm%is_hermitian())
then
643 message(1) =
"Trying to run a SCF calculation for a non-hermitian Hamiltonian. This is not supported."
649 scf%output_during_scf = .false.
650 scf%output_forces = .false.
651 scf%calc_current = .false.
653 if (
present(outp))
then
656 if (outp%what(option__output__stress))
then
657 scf%calc_stress = .
true.
660 scf%output_during_scf = outp%duringscf
663 if (outp%duringscf .and. outp%what(option__output__forces))
then
664 scf%output_forces = .
true.
668 safe_allocate(scf%rhoout(1:gr%np, 1:st%d%nspin))
669 safe_allocate(scf%rhoin (1:gr%np, 1:st%d%nspin))
671 call lalg_copy(gr%np, st%d%nspin, st%rho, scf%rhoin)
674 if (scf%calc_force .or. scf%output_forces)
then
676 safe_allocate(scf%vhxc_old(1:gr%np, 1:st%d%nspin))
677 call lalg_copy(gr%np, st%d%nspin, hm%ks_pot%vhxc, scf%vhxc_old)
681 select case(scf%mix_field)
682 case(option__mixfield__potential)
685 case(option__mixfield__density)
688 case(option__mixfield__states)
691 allocate(
wfs_elec_t::scf%psioutb (st%group%block_start:st%group%block_end, st%d%kpt%start:st%d%kpt%end))
693 do iqn = st%d%kpt%start, st%d%kpt%end
694 do ib = st%group%block_start, st%group%block_end
695 call st%group%psib(ib, iqn)%copy_to(scf%psioutb(ib, iqn))
703 if (scf%mix_field /= option__mixfield__states .and. scf%mix_field /= option__mixfield__none)
then
709 if ( scf%verbosity_ /= verb_no )
then
710 if(scf%max_iter > 0)
then
711 write(
message(1),
'(a)')
'Info: Starting SCF iteration.'
713 write(
message(1),
'(a)')
'Info: No SCF iterations will be done.'
720 scf%converged_current = .false.
730 character(len=*),
intent(in) :: dir
731 character(len=*),
intent(in) :: fname
734 character(len=12) :: label
735 if(st%system_grp%is_root())
then
737 iunit =
io_open(trim(dir) //
"/" // trim(fname), namespace, action=
'write')
738 write(iunit,
'(a)', advance =
'no')
'#iter energy '
739 label =
'energy_diff'
740 write(iunit,
'(1x,a)', advance =
'no') label
742 write(iunit,
'(1x,a)', advance =
'no') label
744 write(iunit,
'(1x,a)', advance =
'no') label
746 write(iunit,
'(1x,a)', advance =
'no') label
748 write(iunit,
'(1x,a)', advance =
'no') label
752 label =
'OEP norm2ss'
753 write(iunit,
'(1x,a)', advance =
'no') label
756 write(iunit,
'(a)')
''
766 subroutine scf_run(scf, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, outp, &
767 verbosity, iters_done, restart_dump)
768 type(
scf_t),
intent(inout) :: scf
772 type(
grid_t),
intent(inout) :: gr
773 type(
ions_t),
intent(inout) :: ions
776 type(
v_ks_t),
intent(inout) :: ks
778 type(
output_t),
optional,
intent(in) :: outp
779 integer,
optional,
intent(in) :: verbosity
780 integer,
optional,
intent(out) :: iters_done
781 type(
restart_t),
optional,
intent(in) :: restart_dump
788 call scf_start(scf, namespace, gr, ions, st, ks, hm, outp, verbosity)
791 do iter = 1, scf%max_iter
793 call scf_iter(scf, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, iter, outp, &
796 completed =
scf_iter_finish(scf, namespace, space, gr, ions, st, ks, hm, iter, outp, iters_done)
798 if(scf%forced_finish .or. completed)
then
803 if (.not.scf%forced_finish)
then
805 call scf_finish(scf, namespace, space, gr, ions, ext_partners, st, ks, hm, iter, outp)
812 subroutine scf_iter(scf, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, iter, outp, &
814 type(
scf_t),
intent(inout) :: scf
818 type(
grid_t),
intent(inout) :: gr
819 type(
ions_t),
intent(inout) :: ions
822 type(
v_ks_t),
intent(inout) :: ks
824 integer,
intent(in) :: iter
825 type(
output_t),
optional,
intent(in) :: outp
826 type(
restart_t),
optional,
intent(in) :: restart_dump
828 integer :: iqn, ib, ierr
831 logical :: is_crit_conv
832 real(real64) :: etime, itime
841 scf%eigens%converged = 0
844 call hm%update_span(gr%spacing(1:space%dim), minval(st%eigenval(:, :)), namespace)
850 call iterator%start(scf%criterion_list)
851 do while (iterator%has_next())
852 crit => iterator%get_next()
856 if (scf%calc_force .or. scf%output_forces)
then
858 scf%vhxc_old(1:gr%np, 1:st%d%nspin) = hm%ks_pot%vhxc(1:gr%np, 1:st%d%nspin)
863 if (
allocated(hm%vberry))
then
866 ks%frozen_hxc = .
true.
868 call berry_perform_internal_scf(scf%berry, namespace, space, scf%eigens, gr, st, hm, iter, ks, ions, ext_partners)
870 ks%frozen_hxc = .false.
872 scf%eigens%converged = 0
873 call scf%eigens%run(namespace, gr, st, hm, space, ext_partners, iter)
876 scf%matvec = scf%matvec + scf%eigens%matvec
883 call density_calc(st, gr, st%rho, ep = hm%ep, vnl = hm%aug_overlap, phase = hm%phase)
885 call lalg_copy(gr%np, st%d%nspin, st%rho, scf%rhoout)
887 select case (scf%mix_field)
888 case (option__mixfield__potential)
889 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_current=scf%output_during_scf)
892 case (option__mixfield__density)
894 case(option__mixfield__states)
895 do iqn = st%d%kpt%start, st%d%kpt%end
896 do ib = st%group%block_start, st%group%block_end
897 call st%group%psib(ib, iqn)%copy_data_to(gr%np, scf%psioutb(ib, iqn))
902 if (scf%mix_field /= option__mixfield__states .and. scf%mix_field /= option__mixfield__none)
then
909 if (
present(outp))
then
911 if (outp%duringscf .and. outp%what_now(option__output__forces, iter))
then
912 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, vhxc_old=scf%vhxc_old)
917 call iterator%start(scf%criterion_list)
918 do while (iterator%has_next())
919 crit => iterator%get_next()
924 scf%converged_last = scf%converged_current
926 scf%converged_current = scf%check_conv .and. &
927 (.not. scf%conv_eigen_error .or. all(scf%eigens%converged >= st%nst_conv))
929 call iterator%start(scf%criterion_list)
930 do while (iterator%has_next())
931 crit => iterator%get_next()
932 call crit%is_converged(is_crit_conv)
933 scf%converged_current = scf%converged_current .and. is_crit_conv
938 scf%finish = scf%converged_last .and. scf%converged_current
944 select case (scf%mix_field)
945 case (option__mixfield__density)
947 call mixing(namespace, scf%smix)
953 if (minval(st%rho(1:gr%np, 1:st%d%spin_channels)) < -1e-6_real64)
then
954 write(
message(1),*)
'Negative density after mixing. Minimum value = ', &
955 minval(st%rho(1:gr%np, 1:st%d%spin_channels))
959 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_current=scf%output_during_scf)
961 case (option__mixfield__potential)
963 call mixing(namespace, scf%smix)
969 case(option__mixfield__states)
970 do iqn = st%d%kpt%start, st%d%kpt%end
971 do ib = st%group%block_start, st%group%block_end
976 call density_calc(st, gr, st%rho, ep = hm%ep, vnl = hm%aug_overlap, phase = hm%phase)
977 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_current=scf%output_during_scf)
979 case (option__mixfield__none)
980 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_current=scf%output_during_scf)
986 if (scf%finish .and. st%modelmbparticles%nparticle > 0)
then
990 if (
present(outp) .and.
present(restart_dump))
then
994 .or. iter == scf%max_iter .or. scf%forced_finish) )
then
996 call states_elec_dump(restart_dump, space, st, gr, hm%kpoints, ierr, iter=iter)
998 message(1) =
'Unable to write states wavefunctions.'
1004 message(1) =
'Unable to write density.'
1009 call lda_u_dump(restart_dump, namespace, hm%lda_u, st, gr, ierr)
1011 message(1) =
'Unable to write DFT+U information.'
1016 select case (scf%mix_field)
1017 case (option__mixfield__density)
1018 call mix_dump(namespace, restart_dump, scf%smix, gr, ierr)
1020 message(1) =
'Unable to write mixing information.'
1023 case (option__mixfield__potential)
1024 call hm%ks_pot%dump(restart_dump, gr, ierr)
1026 message(1) =
'Unable to write Vhxc.'
1030 call mix_dump(namespace, restart_dump, scf%smix, gr, ierr)
1032 message(1) =
'Unable to write mixing information.'
1051 character(len=50) :: str
1052 real(real64) :: dipole(1:space%dim)
1058 write(str,
'(a,i5)')
'SCF CYCLE ITER #' ,iter
1062 ' rel_ev = ', scf%evsum_diff/(abs(scf%evsum_out)+1e-20)
1064 write(
message(2),
'(a,es15.2,2(a,es9.2))') &
1065 ' ediff = ', scf%energy_diff,
' abs_dens = ', scf%abs_dens_diff, &
1066 ' rel_dens = ', scf%abs_dens_diff/st%qtot
1068 write(
message(2),
'(a,es15.2,a,es9.2)') &
1069 ' ediff = ', scf%energy_diff,
' abs_dens = ', scf%abs_dens_diff
1073 write(
message(1),
'(a,i0)')
'Matrix vector products: ', scf%eigens%matvec
1074 write(
message(2),
'(a,i0)')
'Converged eigenvectors: ', sum(scf%eigens%converged(1:st%nik))
1078 if (
allocated(hm%vberry))
then
1080 call write_dipole(st, hm, space, dipole, namespace=namespace)
1093 write(
message(2),
'(a,i5,a,f14.2)')
'Elapsed time for SCF step ', iter,
':', etime
1104 write(
message(1),
'(a,i4,a,es15.8, a,es9.2, a, f7.1, a)') &
1107 ' : rel_dens', scf%abs_dens_diff/st%qtot, &
1108 ' : etime ', etime,
's'
1110 write(
message(1),
'(a,i4,a,es15.8, a, f7.1, a)') &
1113 ' : etime ', etime,
's'
1124 character(len=*),
intent(in) :: dir
1125 character(len=*),
intent(in) :: fname
1129 if(st%system_grp%is_root())
then
1131 iunit =
io_open(trim(dir) //
"/" // trim(fname), namespace, action=
'write', position=
'append')
1133 call iterator%start(scf%criterion_list)
1134 do while (iterator%has_next())
1135 crit => iterator%get_next()
1140 write(iunit,
'(2es13.5)', advance =
'no') crit%val_abs, crit%val_rel
1143 write(iunit,
'(es13.5)', advance =
'no') crit%val_rel
1151 write(iunit,
'(es13.5)', advance =
'no') ks%oep%norm2ss
1154 write(iunit,
'(a)')
''
1161 logical function scf_iter_finish(scf, namespace, space, gr, ions, st, ks, hm, iter, outp, &
1162 iters_done)
result(completed)
1163 type(
scf_t),
intent(inout) :: scf
1166 type(
grid_t),
intent(inout) :: gr
1167 type(
ions_t),
intent(inout) :: ions
1169 type(
v_ks_t),
intent(inout) :: ks
1171 integer,
intent(in) :: iter
1172 type(
output_t),
optional,
intent(in) :: outp
1173 integer,
optional,
intent(out) :: iters_done
1175 character(len=MAX_PATH_LEN) :: dirname
1176 integer(int64) :: what_i
1183 if(
present(iters_done)) iters_done = iter
1185 write(
message(1),
'(a, i4, a)')
'Info: SCF converged in ', iter,
' iterations'
1193 if (
present(outp))
then
1194 if (any(outp%what) .and. outp%duringscf)
then
1195 do what_i = lbound(outp%what, 1), ubound(outp%what, 1)
1196 if (outp%what_now(what_i, iter))
then
1197 write(dirname,
'(a,a,i4.4)') trim(outp%iter_dir),
"scf.", iter
1198 call output_all(outp, namespace, space, dirname, gr, ions, iter, st, hm, ks)
1199 call output_modelmb(outp, namespace, space, dirname, gr, ions, iter, st)
1207 call lalg_copy(gr%np, st%d%nspin, st%rho, scf%rhoin)
1210 if (scf%mix_field /= option__mixfield__none)
then
1211 if (scf%smix%ns_restart > 0)
then
1212 if (
mix_scheme(scf%smix) /= option__mixingscheme__broyden_adaptive .and. &
1213 mod(iter, scf%smix%ns_restart) == 0)
then
1214 message(1) =
"Info: restarting mixing."
1221 select case(scf%mix_field)
1222 case(option__mixfield__potential)
1225 case (option__mixfield__density)
1230 if (scf%mix_field /= option__mixfield__states .and. scf%mix_field /= option__mixfield__none)
then
1241 subroutine scf_finish(scf, namespace, space, gr, ions, ext_partners, st, ks, hm, iter, outp)
1242 type(
scf_t),
intent(inout) :: scf
1245 type(
grid_t),
intent(inout) :: gr
1246 type(
ions_t),
intent(inout) :: ions
1249 type(
v_ks_t),
intent(inout) :: ks
1251 integer,
intent(in) :: iter
1252 type(
output_t),
optional,
intent(in) :: outp
1263 if ((scf%max_iter > 0 .and. scf%mix_field == option__mixfield__potential) .or. scf%calc_current)
then
1264 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
1265 calc_current=scf%calc_current)
1268 select case(scf%mix_field)
1269 case(option__mixfield__states)
1271 do iqn = st%d%kpt%start, st%d%kpt%end
1272 do ib = st%group%block_start, st%group%block_end
1273 call scf%psioutb(ib, iqn)%end()
1278 deallocate(scf%psioutb)
1281 safe_deallocate_a(scf%rhoout)
1282 safe_deallocate_a(scf%rhoin)
1284 if (scf%max_iter > 0 .and. any(scf%eigens%converged < st%nst))
then
1285 write(
message(1),
'(a)')
'Some of the states are not fully converged!'
1286 if (all(scf%eigens%converged >= st%nst_conv))
then
1287 write(
message(2),
'(a)')
'But all requested states to converge are converged.'
1291 write(
message(2),
'(a)')
'With the Chebyshev filtering eigensolver, it usually helps to'
1292 write(
message(3),
'(a)')
'increase ExtraStates and set ExtraStatesToConverge to the number'
1293 write(
message(4),
'(a)')
'of states to be converged.'
1301 if (.not.scf%finish)
then
1302 write(
message(1),
'(a,i4,a)')
'SCF *not* converged after ', iter - 1,
' iterations.'
1304 write(
message(2),
'(a)')
'With the Chebyshev filtering eigensolver, it usually helps to'
1305 write(
message(3),
'(a)')
'increase ExtraStates to improve convergence.'
1312 write(
message(1),
'(a,i10)')
'Info: Number of matrix-vector products: ', scf%matvec
1315 if (scf%calc_force)
then
1316 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, vhxc_old=scf%vhxc_old)
1319 if (scf%calc_stress)
call stress_calculate(namespace, gr, hm, st, ions, ks, ext_partners)
1322 if (scf%mix_field == option__mixfield__potential)
then
1327 if(
present(outp))
then
1334 if (space%is_periodic() .and.
kpoints_number(hm%kpoints) > 1)
then
1337 ions, gr, hm%kpoints, hm%phase, vec_pot = hm%hm_base%uniform_vector_potential, &
1338 vec_pot_var = hm%hm_base%vector_potential)
1342 if (ks%vdw%vdw_correction == option__vdwcorrection__vdw_ts)
then
1346 safe_deallocate_a(scf%vhxc_old)
1354 character(len=*),
intent(in) :: dir, fname
1357 real(real64) :: dipole(1:space%dim)
1358 real(real64) :: ex_virial
1362 if(st%system_grp%is_root())
then
1364 iunit =
io_open(trim(dir) //
"/" // trim(fname), namespace, action=
'write')
1370 if (space%is_periodic())
then
1371 call hm%kpoints%write_info(iunit=iunit)
1380 write(iunit,
'(1x)')
1384 write(iunit,
'(a, i4, a)')
'SCF converged in ', iter,
' iterations'
1386 write(iunit,
'(a)')
'SCF *not* converged!'
1388 write(iunit,
'(1x)')
1390 if(any(scf%eigens%converged < st%nst))
then
1391 write(iunit,
'(a)')
'Some of the states are not fully converged!'
1392 if (all(scf%eigens%converged >= st%nst_conv))
then
1393 write(iunit,
'(a)')
'But all requested states to converge are converged.'
1398 write(iunit,
'(1x)')
1400 if (space%is_periodic())
then
1402 write(iunit,
'(1x)')
1412 if(st%system_grp%is_root())
write(iunit,
'(1x)')
1415 calc_orb_moments=scf%calc_orb_moments)
1416 if (st%system_grp%is_root())
write(iunit,
'(1x)')
1419 if(st%d%ispin ==
spinors .and. space%dim == 3 .and. &
1422 if(st%system_grp%is_root())
write(iunit,
'(1x)')
1428 if(st%system_grp%is_root())
write(iunit,
'(1x)')
1431 if(scf%calc_dipole)
then
1436 if (scf%calc_polarization)
then
1438 if (st%system_grp%is_root())
write(iunit,
'(1x)')
1443 hm%xc%functional(
func_c,1)%family == xc_family_none .and. st%d%ispin /=
spinors &
1444 .and. .not. space%is_periodic())
then
1447 if (st%system_grp%is_root())
then
1451 write(iunit,
'(1x)')
1455 if(st%system_grp%is_root())
then
1456 if(scf%max_iter > 0)
then
1457 write(iunit,
'(a)')
'Convergence:'
1458 call iterator%start(scf%criterion_list)
1459 do while (iterator%has_next())
1460 crit => iterator%get_next()
1461 call crit%write_info(iunit)
1469 call ks%v_ks_photons%write_info(iunit)
1474 if (scf%calc_stress)
then
1475 call output_stress(iunit, space%periodic_dim, st%stress_tensors, st%system_grp, all_terms=.false.)
1476 call output_pressure(iunit, space%periodic_dim, st%stress_tensors%total)
1481 if(scf%calc_partial_charges)
then
1485 if(st%system_grp%is_root())
then
1516 real(real64) :: mem_tmp
1520 if(
conf%report_memory)
then
1522 call mpi_world%allreduce(mem, mem_tmp, 1, mpi_double_precision, mpi_sum)
1524 write(
message(1),
'(a,f14.2)')
'Memory usage [Mbytes] :', mem
1534 type(
scf_t),
intent(inout) :: scf
1540 select type (criterion)
1542 scf%energy_in = hm%energy%total
1557 type(
scf_t),
intent(inout) :: scf
1560 type(
grid_t),
intent(in) :: gr
1561 real(real64),
contiguous,
intent(in) :: rhoout(:,:), rhoin(:,:)
1565 real(real64),
allocatable :: tmp(:)
1569 select type (criterion)
1571 scf%energy_diff = abs(hm%energy%total - scf%energy_in)
1574 scf%abs_dens_diff =
m_zero
1575 safe_allocate(tmp(1:gr%np))
1576 do is = 1, st%d%nspin
1577 tmp(:) = abs(rhoin(1:gr%np, is) - rhoout(1:gr%np, is))
1578 scf%abs_dens_diff = scf%abs_dens_diff +
dmf_integrate(gr, tmp)
1580 safe_deallocate_a(tmp)
1584 scf%evsum_diff = abs(scf%evsum_out - scf%evsum_in)
1585 scf%evsum_in = scf%evsum_out
1595 subroutine write_dipole(st, hm, space, dipole, iunit, namespace)
1599 real(real64),
contiguous,
intent(in) :: dipole(:)
1600 integer,
optional,
intent(in) :: iunit
1601 type(
namespace_t),
optional,
intent(in) :: namespace
1605 if(st%system_grp%is_root())
then
1606 call output_dipole(dipole, space%dim, iunit=iunit, namespace=namespace)
1608 if (space%is_periodic())
then
1609 message(1) =
"Defined only up to quantum of polarization (e * lattice vector)."
1610 message(2) =
"Single-point Berry's phase method only accurate for large supercells."
1613 if (hm%kpoints%full%npoints > 1)
then
1615 "WARNING: Single-point Berry's phase method for dipole should not be used when there is more than one k-point."
1616 message(2) =
"Instead, finite differences on k-points (not yet implemented) are needed."
1621 message(1) =
"Single-point Berry's phase dipole calculation not correct without integer occupations."
1634 type(
scf_t),
intent(inout) :: scf
1635 logical,
intent(in) :: known_lower_bound
1637 call scf%eigens%set_lower_bound_is_known(known_lower_bound)
Copies a vector x, to a vector y.
This module implements common operations on batches of mesh functions.
Berry-phase routines for periodic dipoles, static polarization, and the finite-field electric enthalp...
subroutine, public berry_perform_internal_scf(this, namespace, space, eigensolver, gr, st, hm, iter, ks, ions, ext_partners)
Inner self-consistency loop for a static electric field in periodic systems.
subroutine, public berry_write_polarization(namespace, space, mesh, st, ions, kpoints, iunit)
Compute and write the static modern-theory polarization after SCF.
subroutine, public berry_init(this, namespace)
subroutine, public calc_dipole(dipole, space, mesh, st, ions)
Calculate the total dipole used by the finite-field Berry machinery.
subroutine, public criteria_factory_init(list, namespace, check_conv)
This module implements a calculator for the density and defines related functions.
subroutine, public density_calc(st, gr, density, istin, ep, vnl, phase)
Computes the density from the orbitals in st.
subroutine, public states_elec_sync_buff_density(st, mesh)
Synchronize the GPU density buffer with the host density strho.
integer, parameter, public rs_evo
subroutine, public eigensolver_init(eigens, namespace, gr, st, hm, mc, space, deactivate_oracle)
integer, parameter, public rs_chebyshev
subroutine, public eigensolver_end(eigens)
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,...
subroutine, public energy_calc_virial_ex(der, vxc, st, ex)
subroutine, public energy_calc_eigenvalues(namespace, hm, der, st)
integer, parameter, public spin_orbit
integer, parameter, public scalar_relativistic_zora
integer, parameter, public fully_relativistic_zora
subroutine, public forces_write_info(iunit, ions, dir, namespace)
subroutine, public forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, vhxc_old, t, dt)
real(real64), parameter, public m_zero
integer, parameter, public hartree_fock
integer, parameter, public independent_particles
Theory level.
integer, parameter, public generalized_kohn_sham_dft
real(real64), parameter, public lmm_r_single_atom
Default local magnetic moments sphere radius for an isolated system.
integer, parameter, public kohn_sham_dft
real(real64), parameter, public m_epsilon
type(conf_t), public conf
Global instance of Octopus configuration.
character(len= *), parameter, public static_dir
real(real64), parameter, public m_half
real(real64), parameter, public m_one
This module implements the underlying real-space grid.
subroutine, public grid_write_info(gr, iunit, namespace)
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.
subroutine, public io_close(iunit, grp)
subroutine, public io_debug_on_the_fly(namespace)
check if debug mode should be enabled or disabled on the fly
subroutine, public io_mkdir(fname, namespace, parents)
integer function, public io_open(file, namespace, action, status, form, position, die, recl, grp)
integer, parameter, public kpoints_path
integer pure function, public kpoints_number(this)
A module to handle KS potential, without the external potential.
subroutine, public lda_u_dump(restart, namespace, this, st, mesh, ierr)
subroutine, public lda_u_write_u(this, iunit, namespace)
subroutine, public lda_u_load(restart, this, st, dftu_energy, ierr, occ_only, u_only)
subroutine, public lda_u_write_v(this, iunit, namespace)
subroutine, public lda_u_mixer_set_vin(this, mixer)
subroutine, public lda_u_mixer_init(this, mixer, st)
subroutine, public lda_u_mixer_clear(mixer, smix)
subroutine, public lda_u_mixer_init_auxmixer(this, namespace, mixer, smix, st)
subroutine, public lda_u_mixer_get_vnew(this, mixer, st)
subroutine, public lda_u_mixer_set_vout(this, mixer)
subroutine, public lda_u_mixer_end(mixer, smix)
integer, parameter, public dft_u_none
subroutine, public lda_u_update_occ_matrices(this, namespace, mesh, st, phase, energy, aug_overlap)
integer, parameter, public dft_u_acbn0
System information (time, memory, sysname)
subroutine, public compute_and_write_magnetic_moments(gr, st, phase, ep, ions, lmm_r, calc_orb_moments, iunit, namespace)
Computes and prints the global and local magnetic moments.
subroutine, public write_total_xc_torque(iunit, mesh, vxc, st)
This module is intended to contain "only mathematical" functions and procedures.
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)
integer pure function, public mix_scheme(this)
real(real64) pure function, public mix_coefficient(this)
subroutine, public mixing(namespace, smix)
Main entry-point to SCF mixer.
subroutine, public mix_get_field(this, mixfield)
subroutine, public mix_dump(namespace, restart, smix, mesh, ierr)
subroutine, public mix_init(smix, namespace, space, der, d1, d2, def_, func_type_, prefix_)
Initialise mix_t instance.
subroutine, public mix_load(namespace, restart, smix, mesh, ierr)
subroutine, public mix_end(smix)
subroutine, public mix_clear(smix)
subroutine, public modelmb_sym_all_states(space, mesh, st)
type(mpi_grp_t), public mpi_world
This module handles the communicators for the various parallelization strategies.
this module contains the low-level part of the output system
subroutine, public output_modelmb(outp, namespace, space, dir, gr, ions, iter, st)
this module contains the output system
logical function, public output_needs_current(outp, states_are_real)
subroutine, public output_all(outp, namespace, space, dir, gr, ions, iter, st, hm, ks)
subroutine, public partial_charges_compute_and_print_charges(mesh, st, ions, iunit)
Computes and write partial charges to a file.
/* To use the profiling module, call profiling_in and profiling_out with the label of the region as a...
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 restart_flag_mix
integer, parameter, public restart_flag_rho
logical function, public clean_stop(mpi_grp)
returns true if a file named stop exists
integer, parameter, public restart_flag_vhxc
subroutine, public scf_finish(scf, namespace, space, gr, ions, ext_partners, st, ks, hm, iter, outp)
subroutine, public scf_set_lower_bound_is_known(scf, known_lower_bound)
Set the flag lower_bound_is_known.
subroutine, public scf_load(scf, namespace, space, gr, ions, ext_partners, st, ks, hm, restart_load)
Loading of restarting data of the SCF cycle.
subroutine write_dipole(st, hm, space, dipole, iunit, namespace)
subroutine scf_update_initial_quantity(scf, hm, criterion)
Update the quantity at the begining of a SCF cycle.
subroutine scf_update_diff_quantity(scf, hm, st, gr, rhoout, rhoin, criterion)
Update the quantity at the begining of a SCF cycle.
subroutine, public scf_state_info(namespace, st)
subroutine, public scf_print_mem_use(namespace)
subroutine, public scf_mix_clear(scf)
subroutine, public scf_start(scf, namespace, gr, ions, st, ks, hm, outp, verbosity)
Preparation of the SCF cycle.
integer, parameter, public verb_full
integer, parameter, public verb_compact
subroutine, public scf_init(scf, namespace, gr, ions, st, mc, hm, space)
subroutine, public scf_end(scf)
subroutine, public scf_run(scf, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, outp, verbosity, iters_done, restart_dump)
Legacy version of the SCF code.
subroutine, public scf_iter(scf, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, iter, outp, restart_dump)
logical function, public scf_iter_finish(scf, namespace, space, gr, ions, st, ks, hm, iter, outp, iters_done)
logical pure function, public smear_is_semiconducting(this)
pure logical function, public states_are_real(st)
This module defines routines to write information about states.
subroutine, public states_elec_write_eigenvalues(nst, st, space, kpoints, error, st_start, compact, iunit, namespace)
write the eigenvalues for some states to a file.
subroutine, public states_elec_write_gaps(iunit, st, space)
calculate gaps and write to a file.
subroutine, public states_elec_write_bandstructure(dir, namespace, nst, st, ions, mesh, kpoints, phase, vec_pot, vec_pot_var)
calculate and write the bandstructure
subroutine, public states_elec_fermi(st, namespace, mesh, compute_spin)
calculate the Fermi level for the states in this object
real(real64) function, public states_elec_eigenvalues_sum(st, alt_eig)
function to calculate the eigenvalues sum using occupations as weights
This module handles reading and writing restart information for the states_elec_t.
subroutine, public states_elec_dump(restart, space, st, mesh, kpoints, ierr, iter, lr, verbose)
subroutine, public states_elec_load_rho(restart, st, mesh, ierr)
subroutine, public states_elec_dump_rho(restart, st, mesh, ierr, iter)
This module implements the calculation of the stress tensor.
subroutine, public output_stress(iunit, space_dim, stress_tensors, mpi_grp, all_terms)
subroutine, public output_pressure(iunit, space_dim, total_stress_tensor)
subroutine, public stress_calculate(namespace, gr, hm, st, ions, ks, ext_partners)
This computes the total stress on the lattice.
subroutine, public symmetries_write_info(this, space, iunit, namespace)
type(type_t), parameter, public type_float
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
character(len=20) pure function, public units_abbrev(this)
This module defines the unit system, used for input and output.
type(unit_system_t), public units_out
type(unit_system_t), public units_inp
the units systems for reading and writing
This module is intended to contain simple general-purpose utility functions and procedures.
subroutine, public output_dipole(dipole, ndim, iunit, namespace)
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(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval, time, calc_energy, calc_current, force_semilocal)
Tkatchenko-Scheffler pairwise method for van der Waals (vdW, dispersion) interactions.
subroutine, public vdw_ts_write_c6ab(this, ions, dir, fname, namespace)
subroutine, public vtau_mixer_end(mixer, smix)
subroutine, public vtau_mixer_init_auxmixer(namespace, mixer, smix, hm, np, nspin)
subroutine, public vtau_mixer_set_vout(mixer, hm)
subroutine, public vtau_mixer_get_vnew(mixer, hm)
subroutine, public vtau_mixer_clear(mixer, smix)
subroutine, public vtau_mixer_set_vin(mixer, hm)
This module provides a simple timer class which can be used to trigger the writing of a restart file ...
logical function, public walltimer_alarm(comm, print)
indicate whether time is up
logical function, public restart_walltime_period_alarm(comm)
integer, parameter, public xc_family_nc_mgga
integer, parameter, public func_c
integer, parameter, public oep_level_full
subroutine scf_write_static(dir, fname)
subroutine create_convergence_file(dir, fname)
subroutine scf_write_iter(namespace)
subroutine write_convergence_file(dir, fname)
Extension of space that contains the knowledge of the spin dimension.
Description of the grid, containing information on derivatives, stencil, and symmetries.
Stores all communicators and groups.
some variables used for the SCF cycle
abstract class for states
The states_elec_t class contains all electronic wave functions.
batches of electronic states