45 use,
intrinsic :: iso_fortran_env
108 integer,
parameter,
public :: &
114 type(propagator_base_t),
public :: tr
115 type(scf_t),
public :: scf
116 type(ion_dynamics_t),
public :: ions_dyn
117 real(real64),
public :: dt
118 integer,
public :: max_iter
119 integer,
public :: iter
120 logical,
public :: recalculate_gs
122 type(pes_t),
public :: pesv
124 integer,
public :: dynamics
125 integer,
public :: energy_update_iter
126 real(real64) :: scissor
128 logical :: freeze_occ
130 integer :: freeze_orbitals
132 logical :: from_scratch = .false.
134 type(td_write_t),
public :: write_handler
135 type(restart_t) :: restart_load
136 type(restart_t) :: restart_dump
144 subroutine td_init(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp)
145 type(td_t),
intent(inout) :: td
146 type(namespace_t),
intent(in) :: namespace
147 class(space_t),
intent(in) :: space
148 type(grid_t),
intent(in) :: gr
149 type(ions_t),
intent(inout) :: ions
150 type(states_elec_t),
intent(in) :: st
151 type(v_ks_t),
intent(in) :: ks
152 type(hamiltonian_elec_t),
intent(in) :: hm
153 type(partner_list_t),
intent(in) :: ext_partners
154 type(output_t),
intent(in) :: outp
157 real(real64) :: propagation_time
158 type(lasers_t),
pointer :: lasers
159 logical :: symmetrize
165 symmetrize = hm%kpoints%use_symmetries .or. st%symmetrize_density
168 if (td%ions_dyn%ions_move())
then
169 if (hm%kpoints%use_symmetries)
then
170 message(1) =
"KPoints symmetries cannot be used with moving ions."
171 message(2) =
"Please set KPointsSymmetries = no."
174 if (st%symmetrize_density)
then
175 message(1) =
"Symmetrization of the density cannot be used with moving ions."
176 message(2) =
"Please set SymmetrizeDensity = no."
198 write(
message(1),
'(a)')
'A positive value for TDTimeStep must be defined in the input file.'
206 call messages_write(
'You cannot set TDMaxSteps and TDPropagationTime at the same time')
235 if (propagation_time >
m_zero) default = nint(propagation_time/td%dt)
236 call parse_variable(namespace,
'TDMaxSteps', default, td%max_iter)
238 if (propagation_time <=
m_zero) propagation_time = td%dt*td%max_iter
243 if (td%max_iter < 1)
then
244 write(
message(1),
'(a,i6,a)')
"Input: '", td%max_iter,
"' is not a valid value for TDMaxSteps."
245 message(2) =
'(TDMaxSteps <= 1)'
256 call pes_init(td%pesv, namespace, space, gr, gr%box, st, outp%restart_write_interval, hm%kpoints, &
257 hm%abs_boundaries, ext_partners, td%max_iter, td%dt)
272 call parse_variable(namespace,
'TDDynamics', ehrenfest, td%dynamics)
275 if (td%dynamics .ne. ehrenfest)
then
276 if (.not. td%ions_dyn%is_active())
then
277 message(1) =
"TDDynamics=bo can only be used if MoveIons=yes or CellDynamics=yes"
298 call parse_variable(namespace,
'RecalculateGSDuringEvolution', .false., td%recalculate_gs)
299 if (hm%lda_u_level /=
dft_u_none .and. td%recalculate_gs)
then
318 if (
associated(lasers) .and.
mpi_world%is_root())
then
320 call laser_write_info(lasers%lasers, dt=td%dt, max_iter=td%max_iter, namespace=namespace)
336 call parse_variable(namespace,
'TDEnergyUpdateIter', default, td%energy_update_iter)
338 if (gr%der%boundaries%spiralBC .and. hm%ep%reltype ==
spin_orbit)
then
339 message(1) =
"Generalized Bloch theorem cannot be used with spin-orbit coupling."
343 if (gr%der%boundaries%spiralBC)
then
344 if (any(abs(hm%kick%easy_axis(1:2)) >
m_epsilon))
then
345 message(1) =
"Generalized Bloch theorem cannot be used for an easy axis not along the z direction."
371 call parse_variable(namespace,
'TDFreezeOrbitals', 0, td%freeze_orbitals)
373 if (td%freeze_orbitals /= 0)
then
405 if (td%dmp%calculation_mode /= option__tddmpropagation__no_propagation)
then
407 call td%dmp%init(namespace, st)
416 subroutine td_init_run(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, from_scratch)
417 type(
td_t),
intent(inout) :: td
420 type(
grid_t),
intent(inout) :: gr
421 type(
ions_t),
intent(inout) :: ions
423 type(
v_ks_t),
intent(inout) :: ks
426 type(
output_t),
intent(inout) :: outp
428 logical,
intent(inout) :: from_scratch
438 td%from_scratch = from_scratch
440 if (.not. td%from_scratch)
then
442 if (td%from_scratch)
then
443 message(1) =
"Unable to read time-dependent restart information: Starting from scratch"
448 if (td%iter >= td%max_iter)
then
449 message(1) =
"All requested iterations have already been done. Use FromScratch = yes if you want to redo them."
452 td%iter = td%iter + 1
453 if ((td%ions_dyn%is_active()) .and. td%recalculate_gs)
call td%restart_load%end()
458 if (td%from_scratch)
then
462 call td_init_with_wavefunctions(td, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, outp, td%from_scratch)
464 if (td%dmp%calculation_mode /= option__tddmpropagation__no_propagation)
then
473 type(
td_t),
intent(inout) :: td
476 type(
grid_t),
intent(inout) :: gr
477 type(
ions_t),
intent(inout) :: ions
480 class(
space_t),
intent(in) :: space
485 if (td%dynamics == ehrenfest)
then
491 call lda_u_init(hm%lda_u, namespace, space, hm%lda_u_level, gr, ions, st, mc, hm%kpoints)
498 call scf_init(td%scf, namespace, gr, ions, st, mc, hm, space)
506 type(
td_t),
intent(inout) :: td
508 type(
grid_t),
intent(inout) :: gr
510 type(
v_ks_t),
intent(inout) :: ks
513 class(
space_t),
intent(in) :: space
520 if(
associated(gfield))
then
527 call hm%update(gr, namespace, space, ext_partners, time = td%dt*td%iter)
537 type(
td_t),
intent(inout) :: td
545 if (td%dmp%calculation_mode /= option__tddmpropagation__no_propagation)
then
549 if (td%dynamics ==
bo)
call scf_end(td%scf)
556 type(
td_t),
intent(inout) :: td
562 if (st%pack_states .and. hm%apply_packed())
call st%unpack()
564 call td%restart_dump%end()
569 if ((td%ions_dyn%is_active()).and. td%recalculate_gs)
call td%restart_load%end()
575 subroutine td_run(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, from_scratch)
576 type(
td_t),
intent(inout) :: td
579 type(
grid_t),
intent(inout) :: gr
580 type(
ions_t),
intent(inout) :: ions
582 type(
v_ks_t),
intent(inout) :: ks
585 type(
output_t),
intent(inout) :: outp
587 logical,
intent(inout) :: from_scratch
590 integer :: iter, scsteps
591 real(real64) :: etime
592 real(real64) :: wall_time, simulation_time, speed_fs_per_day
593 character(len=20) :: fmt
601 propagation:
do iter = td%iter, td%max_iter
608 if (((iter-1)*td%dt <= hm%kick%time) .and. (iter*td%dt > hm%kick%time))
then
609 if (.not. hm%pcm%localf)
then
610 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints)
612 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints, pcm = hm%pcm)
614 call td_write_kick(outp, namespace, space, gr, hm%kick, ions, iter)
617 if (gr%der%boundaries%spiralBC) gr%der%boundaries%spiral = .
true.
622 select case (td%dynamics)
624 call propagator_elec_dt(ks, namespace, space, hm, gr, st, td%tr, iter*td%dt, td%dt, iter, td%ions_dyn, &
625 ions, ext_partners, mc, outp, td%write_handler, scsteps = scsteps, &
626 update_energy = (mod(iter, td%energy_update_iter) == 0) .or. (iter == td%max_iter))
628 call propagator_elec_dt_bo(td%scf, namespace, space, gr, ks, st, hm, ions, ext_partners, mc, iter, &
629 td%dt, td%ions_dyn, scsteps)
632 if (td%dmp%calculation_mode /= option__tddmpropagation__no_propagation)
then
633 call dm_propagation_run(td%dmp, namespace, space, gr, ions, st, mc, hm, ks, iter, td%dt, ext_partners, &
634 update_energy = (mod(iter, td%energy_update_iter) == 0) .or. (iter == td%max_iter))
647 if (td%pesv%calc_spm .or. td%pesv%calc_mask .or. td%pesv%calc_flux)
then
648 call pes_calc(td%pesv, namespace, space, gr, st, td%dt, iter, gr%der, hm%kpoints, ext_partners, stopping)
651 call td_write_iter(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
652 hm%kick, ks, td%dt, iter, mc, td%recalculate_gs)
655 call td_check_point(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, &
656 iter, scsteps, etime, stopping, from_scratch)
668 simulation_time = td%dt * (iter - td%iter + 1)
670 if (speed_fs_per_day > 1e4 .or. speed_fs_per_day < 1e-3)
then
675 write(
message(1),
'(a,'//trim(fmt)//
',a)')
'Propagation speed: ', speed_fs_per_day,
' fs/day'
687 write(
message(1),
'(a7,1x,a14,a14,a10,a17)')
'Iter ',
'Time ',
'Energy ',
'SC Steps',
'Elapsed Time '
696 subroutine td_check_point(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, &
697 iter, scsteps, etime, stopping, from_scratch)
698 type(
td_t),
intent(inout) :: td
701 type(
grid_t),
intent(inout) :: gr
702 type(
ions_t),
intent(inout) :: ions
704 type(
v_ks_t),
intent(inout) :: ks
709 integer,
intent(in) :: iter
710 integer,
intent(in) :: scsteps
711 real(real64),
intent(inout) :: etime
712 logical,
intent(in) :: stopping
713 logical,
intent(inout) :: from_scratch
721 if (outp%anything_now(iter))
then
722 call td_write_output(namespace, space, gr, st, hm, ks, outp, ions, ext_partners, iter, td%dt)
725 if (mod(iter, outp%restart_write_interval) == 0 .or. iter == td%max_iter .or. stopping)
then
728 call td_dump(td, namespace, space, gr, st, hm, ks, ext_partners, iter, ierr)
730 message(1) =
"Unable to write time-dependent restart information."
734 call pes_output(td%pesv, namespace, space, gr, st, iter, outp, td%dt, ions)
736 if ((td%ions_dyn%is_active()) .and. td%recalculate_gs)
then
738 from_scratch = .false.
740 call electrons_ground_state_run(namespace, mc, gr, ions, ext_partners, st, ks, hm, outp, space, from_scratch)
742 call td_load(td%restart_load, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
744 message(1) =
"Unable to load TD states."
748 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
749 calc_eigenval=.
true., time = iter*td%dt, calc_energy=.
true.)
750 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = iter*td%dt, dt = td%dt)
751 assert(.not. td%ions_dyn%cell_relax())
762 type(
td_t),
intent(inout) :: td
764 type(
ions_t),
intent(inout) :: ions
766 integer,
intent(in) :: iter
767 integer,
intent(in) :: scsteps
768 real(real64),
intent(inout) :: etime
783 real(real64),
intent(inout) :: etime
793 subroutine td_init_with_wavefunctions(td, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, outp, from_scratch)
794 type(
td_t),
intent(inout) :: td
798 type(
grid_t),
intent(inout) :: gr
799 type(
ions_t),
intent(inout) :: ions
802 type(
v_ks_t),
intent(inout) :: ks
804 type(
output_t),
intent(inout) :: outp
805 logical,
intent(in) :: from_scratch
809 real(real64) :: ndinitial(space%dim)
810 logical :: freeze_hxc, freeze_occ, freeze_u
811 type(
restart_t) :: restart, restart_frozen
818 if (gr%der%boundaries%spiralBC)
then
819 if ((td%iter-1)*td%dt > hm%kick%time)
then
820 gr%der%boundaries%spiral = .
true.
822 hm%vnl%spin => st%spin
823 hm%phase%spin => st%spin
828 if (from_scratch)
then
835 if (td%freeze_orbitals > 0)
then
836 if (from_scratch)
then
847 message(1) =
"Unable to read frozen restart information."
852 write(
message(1),
'(a,i4,a,i4,a)')
'Info: The lowest', td%freeze_orbitals, &
853 ' orbitals have been frozen.', st%nst,
' will be propagated.'
857 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
858 else if (td%freeze_orbitals < 0)
then
861 write(
message(1),
'(a)')
'Info: The single-active-electron approximation will be used.'
863 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
864 if (from_scratch)
then
875 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
886 call parse_variable(namespace,
'TDFreezeHXC', .false., freeze_hxc)
888 write(
message(1),
'(a)')
'Info: Freezing Hartree and exchange-correlation potentials.'
891 if (.not. from_scratch)
then
894 call states_elec_load(restart_frozen, namespace, space, st, gr, hm%kpoints, ierr, label =
": gs")
896 call restart_frozen%end()
899 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
902 call states_elec_load(restart_frozen, namespace, space, st, gr, hm%kpoints, ierr, iter=td%iter, label =
": td")
903 call restart_frozen%end()
904 call hm%ks_pot%run_zero_iter(td%tr%vks_old)
912 x = minval(st%eigenval(st%st_start, :))
913 if (st%parallel_in_states)
then
914 call st%mpi_grp%bcast(x, 1, mpi_double_precision, 0)
916 call hm%update_span(gr%spacing(1:space%dim), x, namespace)
918 call states_elec_fermi(st, namespace, gr, compute_spin = .not. gr%der%boundaries%spiralBC)
929 call parse_variable(namespace,
'TDFreezeDFTUOccupations', .false., freeze_occ)
931 write(
message(1),
'(a)')
'Info: Freezing DFT+U occupation matrices that enters in the DFT+U potential.'
936 if (hm%lda_u_level /=
dft_u_none .and. .not. from_scratch)
then
938 call lda_u_load(restart_frozen, hm%lda_u, st, hm%energy%dft_u, ierr, occ_only = .
true.)
939 call restart_frozen%end()
952 write(
message(1),
'(a)')
'Info: Freezing the effective U of DFT+U.'
957 if (hm%lda_u_level ==
dft_u_acbn0 .and. .not. from_scratch)
then
959 call lda_u_load(restart_frozen, hm%lda_u, st, hm%energy%dft_u, ierr, u_only = .
true.)
960 call restart_frozen%end()
961 write(
message(1),
'(a)')
'Loaded GS effective U of DFT+U'
970 call td_write_init(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
971 ks, td%ions_dyn%is_active(), &
976 if(
associated(lasers))
then
978 ndinitial(1:space%dim)=
m_zero
987 call scissor_init(hm%scissor, namespace, space, st, gr, hm%kpoints, hm%phase, td%scissor, mc)
990 if (td%iter == 0)
call td_run_zero_iter(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp, mc)
993 if(
associated(gfield))
then
996 if (abs(ks%xc%lrc%alpha) >
m_epsilon)
then
1003 td%iter = td%iter + 1
1006 if (td%ions_dyn%is_active() .and. td%recalculate_gs)
then
1014 if (td%pesv%calc_spm .or. td%pesv%calc_mask .and. from_scratch)
then
1018 if (st%pack_states .and. hm%apply_packed())
call st%pack()
1025 type(
td_t),
intent(inout) :: td
1028 type(
grid_t),
intent(inout) :: gr
1029 type(
ions_t),
intent(inout) :: ions
1032 type(
v_ks_t),
intent(inout) :: ks
1034 type(
output_t),
intent(inout) :: outp
1039 if (td%ions_dyn%ions_move())
then
1040 if (td%iter > 0)
then
1047 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
1050 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = td%iter*td%dt, dt = td%dt)
1052 call ions%update_kinetic_energy()
1054 if (outp%what(option__output__forces) .or. td%write_handler%out(
out_separate_forces)%write)
then
1055 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = td%iter*td%dt, dt = td%dt)
1059 if (outp%what(option__output__stress) .or. td%ions_dyn%cell_relax())
then
1061 if (td%ions_dyn%cell_relax())
then
1062 call td%ions_dyn%update_stress(ions%space, st%stress_tensors%total, ions%latt%rlattice, ions%latt%rcell_volume)
1071 type(
td_t),
intent(inout) :: td
1073 class(
space_t),
intent(in) :: space
1075 type(
grid_t),
intent(inout) :: gr
1078 type(
v_ks_t),
intent(inout) :: ks
1080 logical,
intent(inout) :: from_scratch
1088 if (td%freeze_orbitals > 0)
then
1094 call td_load(restart, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
1098 from_scratch = .
true.
1107 type(
td_t),
intent(inout) :: td
1109 class(
space_t),
intent(in) :: space
1111 type(
grid_t),
intent(inout) :: gr
1114 type(
v_ks_t),
intent(inout) :: ks
1124 if (.not. st%only_userdef_istates)
then
1126 call states_elec_load(restart, namespace, space, st, gr, hm%kpoints, ierr, label =
": gs")
1129 message(1) =
'Unable to read ground-state wavefunctions.'
1148 subroutine td_run_zero_iter(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp, mc)
1149 type(
td_t),
intent(inout) :: td
1152 type(
grid_t),
intent(inout) :: gr
1153 type(
ions_t),
intent(inout) :: ions
1155 type(
v_ks_t),
intent(inout) :: ks
1163 call td_write_iter(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
1164 hm%kick, ks, td%dt, 0, mc, td%recalculate_gs)
1168 if (abs(hm%kick%time) <=
m_epsilon)
then
1169 if (.not. hm%pcm%localf)
then
1170 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints)
1172 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints, pcm = hm%pcm)
1174 call td_write_kick(outp, namespace, space, gr, hm%kick, ions, 0)
1177 if (gr%der%boundaries%spiralBC)
then
1178 gr%der%boundaries%spiral = .
true.
1181 call hm%ks_pot%run_zero_iter(td%tr%vks_old)
1183 if (any(outp%output_interval > 0))
then
1185 call td_write_output(namespace, space, gr, st, hm, ks, outp, ions, ext_partners, 0)
1195 type(
td_t),
intent(in) :: td
1197 type(
ions_t),
intent(inout) :: ions
1199 integer :: iatom, iter, iunit
1203 iunit =
io_open(
'td.general/coordinates', namespace, action=
'read', status=
'old', die=.false.)
1204 if (iunit == -1)
then
1205 message(1) =
"Could not open file '"//trim(
io_workpath(
'td.general/coordinates', namespace))//
"'."
1206 message(2) =
"Starting simulation from initial geometry."
1213 do iter = 0, td%iter - 1
1216 read(iunit,
'(32x)', advance=
'no')
1218 do iatom = 1, ions%natoms
1219 read(iunit,
'(3es24.16)', advance=
'no') ions%pos(:, iatom)
1222 do iatom = 1, ions%natoms
1223 read(iunit,
'(3es24.16)', advance=
'no') ions%vel(:, iatom)
1226 do iatom = 1, ions%natoms
1227 read(iunit,
'(3es24.16)', advance=
'no') ions%tot_force(:, iatom)
1237 subroutine td_dump(td, namespace, space, gr, st, hm, ks, ext_partners, iter, ierr)
1238 type(
td_t),
intent(in) :: td
1240 class(
space_t),
intent(in) :: space
1241 type(
grid_t),
intent(in) :: gr
1244 type(
v_ks_t),
intent(in) :: ks
1246 integer,
intent(in) :: iter
1247 integer,
intent(out) :: ierr
1250 integer :: err, err2
1256 if (td%restart_dump%skip())
then
1261 message(1) =
"Debug: Writing td restart."
1265 call states_elec_dump(td%restart_dump, space, st, gr, hm%kpoints, err, iter=iter)
1266 if (err /= 0) ierr = ierr + 1
1269 if (err /= 0) ierr = ierr + 1
1272 call lda_u_dump(td%restart_dump, namespace, hm%lda_u, st, gr, ierr)
1273 if (err /= 0) ierr = ierr + 1
1277 if (err2 /= 0) ierr = ierr + 2
1279 call pes_dump(td%pesv, namespace, td%restart_dump, st, gr, err)
1280 if (err /= 0) ierr = ierr + 4
1284 if(
associated(gfield))
then
1288 if (gr%der%boundaries%spiralBC)
then
1290 if (err /= 0) ierr = ierr + 8
1293 if (ks%has_photons)
then
1294 call mf_photons_dump(td%restart_dump, ks%pt_mx, gr, td%dt, ks%pt, err)
1295 if (err /= 0) ierr = ierr + 16
1298 if (ks%xc_photon /= 0)
then
1300 call ks%xc_photons%mf_dump(td%restart_dump, err)
1301 if (err /= 0) ierr = ierr + 32
1304 if (
allocated(st%frozen_rho))
then
1307 if (err /= 0) ierr = ierr + 64
1309 if (td%ions_dyn%ions_move() .or. td%ions_dyn%cell_relax())
then
1312 if (err /= 0) ierr = ierr + 128
1314 message(1) =
"Debug: Writing td restart done."
1321 subroutine td_load(restart, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
1324 class(
space_t),
intent(in) :: space
1325 type(
grid_t),
intent(in) :: gr
1329 type(
td_t),
intent(inout) :: td
1330 type(
v_ks_t),
intent(inout) :: ks
1331 integer,
intent(out) :: ierr
1333 integer :: err, err2
1339 if (restart%skip())
then
1345 message(1) =
"Debug: Reading td restart."
1349 call states_elec_load(restart, namespace, space, st, gr, hm%kpoints, err, iter=td%iter, label =
": td")
1356 if (err2 /= 0) ierr = ierr + 2
1359 call lda_u_load(restart, hm%lda_u, st, hm%energy%dft_u, ierr)
1360 if (err /= 0) ierr = ierr + 1
1365 if (td%pesv%calc_spm .or. td%pesv%calc_mask .or. td%pesv%calc_flux)
then
1366 call pes_load(td%pesv, namespace, restart, st, err)
1367 if (err /= 0) ierr = ierr + 4
1372 if (
associated(gfield))
then
1377 call hm%update(gr, namespace, space, ext_partners, time = td%dt*td%iter)
1382 if (ks%has_photons)
then
1385 if (err /= 0) ierr = ierr + 16
1387 if (ks%xc_photon /= 0)
then
1388 call ks%xc_photons%mf_load(restart, space, err)
1390 if (err /= 0) ierr = ierr + 32
1392 if (gr%der%boundaries%spiralBC)
then
1399 if (td%ions_dyn%is_active())
then
1402 if (err /= 0) ierr = ierr + 64
1404 message(1) =
"Debug: Reading td restart done."
1410 subroutine td_load_frozen(namespace, restart, space, mesh, st, hm, ierr)
1413 class(
space_t),
intent(in) :: space
1414 class(
mesh_t),
intent(in) :: mesh
1417 integer,
intent(out) :: ierr
1423 if (restart%skip())
then
1429 message(1) =
"Debug: Reading td frozen restart."
1432 safe_allocate(st%frozen_rho(1:mesh%np, 1:st%d%nspin))
1434 safe_allocate(st%frozen_tau(1:mesh%np, 1:st%d%nspin))
1435 safe_allocate(st%frozen_gdens(1:mesh%np, 1:space%dim, 1:st%d%nspin))
1436 safe_allocate(st%frozen_ldens(1:mesh%np, 1:st%d%nspin))
1441 message(1) =
"Debug: Reading td frozen restart done."
1449 type(
td_t),
intent(in) :: td
1460 type(
td_t),
intent(inout) :: td
1461 logical,
intent(in) :: from_scratch
1465 td%from_scratch = from_scratch
Define which routines can be seen from the outside.
Prints out to iunit a message in the form: ["InputVariable" = value] where "InputVariable" is given b...
integer, parameter, public mask_absorbing
Module implementing boundary conditions in Octopus.
This module handles the calculation mode.
This module implements a calculator for the density and defines related functions.
subroutine, public states_elec_freeze_adjust_qtot(st)
subroutine, public states_elec_freeze_redistribute_states(st, namespace, mesh, mc, nn)
subroutine, public states_elec_freeze_orbitals(st, namespace, space, gr, mc, kpoints, n, family_is_mgga)
Calculate partial density for frozen orbitals.
subroutine, public density_calc(st, gr, density, istin)
Computes the density from the orbitals in st.
subroutine, public dm_propagation_init_run(adiabatic_st, namespace, space, gr, st, hm, mc)
Initialise the adiabatic states prior to running TB propagation.
subroutine, public dm_propagation_run(dmp, namespace, space, gr, ions, st, mc, hm, ks, iter, dt, ext_partners, update_energy)
Apply dissipation to a TD run via the Linblad formalism.
A set of subroutines for performing the parts of a ground state calculation with an electrons system....
subroutine, public electrons_ground_state_run(namespace, mc, gr, ions, ext_partners, st, ks, hm, outp, space, fromScratch)
Run a ground state calculation for a system of electrons.
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,...
integer, parameter, public spin_orbit
logical function, public list_has_gauge_field(partners)
type(gauge_field_t) function, pointer, public list_get_gauge_field(partners)
type(lasers_t) function, pointer, public list_get_lasers(partners)
subroutine, public forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, vhxc_old, t, dt)
subroutine, public gauge_field_load(restart, gfield, ierr)
subroutine, public gauge_field_get_force(this, gr, spin_channels, current, lrc)
subroutine, public gauge_field_dump(restart, gfield, ierr)
logical pure function, public gauge_field_is_propagated(this)
logical pure function, public gauge_field_is_used(this)
subroutine, public gauge_field_init_vec_pot(this, qtot)
real(real64), parameter, public m_zero
real(real64), parameter, public m_epsilon
real(real64), parameter, public m_one
This module implements the underlying real-space grid.
subroutine, public zvmask(mesh, hm, st)
subroutine, public hamiltonian_elec_epot_generate(this, namespace, space, gr, ions, ext_partners, st, time)
subroutine, public dvmask(mesh, hm, st)
This module defines classes and functions for interaction partners.
subroutine, public io_close(iunit, grp)
subroutine, public io_skip_header(iunit)
character(len=max_path_len) function, public io_workpath(path, namespace)
construct path name from given name and namespace
subroutine, public io_debug_on_the_fly(namespace)
check if debug mode should be enabled or disabled on the fly
integer function, public io_open(file, namespace, action, status, form, position, die, recl, grp)
subroutine, public ion_dynamics_dump(this, restart, ierr)
subroutine, public ion_dynamics_propagate(this, ions, time, dt, namespace)
Interface for the ion/cell dynamics.
subroutine, public ion_dynamics_load(this, restart, ierr)
subroutine, public ion_dynamics_init(this, namespace, ions, symmetrize, symm)
subroutine, public ion_dynamics_end(this)
logical pure function, public ion_dynamics_drive_ions(this)
Is the ion dynamics activated or not.
subroutine, public kick_apply(space, mesh, st, ions_dyn, ions, kick, psolver, kpoints, pcm)
Applies the delta-function electric field where k = kick%delta_strength.
subroutine, public lasers_set_nondipole_parameters(this, ndfield, nd_integration_time)
Set parameters for nondipole SFA calculation.
logical function, public lasers_with_nondipole_field(lasers)
Check if a nondipole SFA correction should be computed for the given laser.
subroutine, public laser_write_info(lasers, namespace, dt, max_iter, iunit)
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)
integer, parameter, public dft_u_none
subroutine, public lda_u_init(this, namespace, space, level, gr, ions, st, mc, kpoints)
subroutine, public lda_u_freeze_occ(this)
subroutine, public lda_u_freeze_u(this)
subroutine, public lda_u_end(this)
subroutine, public lda_u_update_occ_matrices(this, namespace, mesh, st, phase, energy)
integer, parameter, public dft_u_acbn0
This module implements fully polymorphic linked lists, and some specializations thereof.
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)
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)
type(mpi_grp_t), public mpi_world
This module handles the communicators for the various parallelization strategies.
type(namespace_t), public global_namespace
this module contains the low-level part of the output system
this module contains the output system
logical function, public parse_is_defined(namespace, name)
subroutine, public pes_calc(pes, namespace, space, mesh, st, dt, iter, der, kpoints, ext_partners, stopping)
subroutine, public pes_init(pes, namespace, space, mesh, box, st, save_iter, kpoints, abs_boundaries, ext_partners, max_iter, dt)
subroutine, public pes_output(pes, namespace, space, gr, st, iter, outp, dt, ions)
subroutine, public pes_init_write(pes, mesh, st, namespace)
subroutine, public pes_end(pes)
subroutine, public pes_load(pes, namespace, restart, st, ierr)
subroutine, public pes_dump(pes, namespace, restart, st, mesh, ierr)
subroutine, public mf_photons_load(restart, this, gr, ierr)
subroutine, public mf_photons_dump(restart, this, gr, dt, pt_mode, ierr)
subroutine, public potential_interpolation_load(potential_interpolation, namespace, restart, mesh, nspin, err2)
subroutine, public potential_interpolation_dump(potential_interpolation, restart, mesh, nspin, err2)
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.
subroutine, public propagator_elec_dt_bo(scf, namespace, space, gr, ks, st, hm, ions, ext_partners, mc, iter, dt, ions_dyn, scsteps)
subroutine, public propagator_elec_init(gr, namespace, st, tr, ks_pot, have_fields, family_is_mgga_with_exc, relax_cell)
subroutine, public propagator_elec_dt(ks, namespace, space, hm, gr, st, tr, time, dt, nt, ions_dyn, ions, ext_partners, mc, outp, write_handler, scsteps, update_energy, qcchi)
Propagates st from time - dt to t. If dt<0, it propagates backwards from t+|dt| to t.
subroutine, public propagator_elec_end(tr)
This module implements the basic propagator framework.
logical function, public clean_stop(comm)
returns true if a file named stop exists
integer, parameter, public restart_gs
integer, parameter, public restart_type_dump
integer, parameter, public restart_td
integer, parameter, public restart_type_load
subroutine, public scf_init(scf, namespace, gr, ions, st, mc, hm, space)
subroutine, public scf_end(scf)
subroutine, public scissor_init(this, namespace, space, st, mesh, kpoints, phase, gap, mc)
pure logical function, public states_are_real(st)
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_deallocate_wfns(st)
Deallocates the KS wavefunctions defined within a states_elec_t structure.
subroutine, public states_elec_allocate_wfns(st, mesh, wfs_type, skip, packed)
Allocates the KS wavefunctions defined within a states_elec_t structure.
This module handles reading and writing restart information for the states_elec_t.
subroutine, public states_elec_read_user_def_orbitals(mesh, namespace, space, st)
the routine reads formulas for user-defined wavefunctions from the input file and fills the respectiv...
subroutine, public states_elec_load_frozen(restart, space, st, mesh, ierr)
subroutine, public states_elec_transform(st, namespace, space, restart, mesh, kpoints, prefix)
subroutine, public states_elec_dump(restart, space, st, mesh, kpoints, ierr, iter, lr, verbose)
subroutine, public states_elec_load(restart, namespace, space, st, mesh, kpoints, ierr, iter, lr, lowest_missing, label, verbose, skip)
returns in ierr: <0 => Fatal error, or nothing read =0 => read all wavefunctions >0 => could only rea...
subroutine, public states_elec_load_spin(restart, st, ierr)
returns in ierr: <0 => Fatal error, or nothing read =0 => read all wavefunctions >0 => could only rea...
subroutine, public states_elec_dump_frozen(restart, space, st, mesh, ierr)
subroutine, public states_elec_dump_rho(restart, st, mesh, ierr, iter)
subroutine, public states_elec_dump_spin(restart, st, ierr)
This module implements the calculation of the stress tensor.
subroutine, public stress_calculate(namespace, gr, hm, st, ions, ks, ext_partners)
This computes the total stress on the lattice.
subroutine, public td_check_point(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, iter, scsteps, etime, stopping, from_scratch)
subroutine, public td_end(td)
subroutine, public td_load_restart_from_gs(td, namespace, space, mc, gr, ext_partners, st, ks, hm)
subroutine td_print_message(td, namespace, ions, hm, iter, scsteps, etime)
subroutine, public td_end_run(td, st, hm)
subroutine, public td_init(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp)
subroutine, public td_allocate_wavefunctions(td, namespace, mc, gr, ions, st, hm, space)
logical function, public td_get_from_scratch(td)
subroutine td_load_frozen(namespace, restart, space, mesh, st, hm, ierr)
subroutine td_print_header(namespace)
integer, parameter, public bo
subroutine td_load(restart, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
subroutine, public td_set_from_scratch(td, from_scratch)
subroutine, public td_dump(td, namespace, space, gr, st, hm, ks, ext_partners, iter, ierr)
subroutine td_read_coordinates(td, namespace, ions)
reads the pos and vel from coordinates file
subroutine, public td_run(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, from_scratch)
subroutine td_run_zero_iter(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp, mc)
subroutine, public td_init_gaugefield(td, namespace, gr, st, ks, hm, ext_partners, space)
subroutine td_update_elapsed_time(etime)
subroutine, public td_init_with_wavefunctions(td, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, outp, from_scratch)
subroutine, public td_load_restart_from_td(td, namespace, space, mc, gr, ext_partners, st, ks, hm, from_scratch)
subroutine td_init_ions_and_forces(td, namespace, space, gr, ions, ext_partners, st, ks, hm, outp)
subroutine, public td_init_run(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, from_scratch)
subroutine, public td_write_output(namespace, space, gr, st, hm, ks, outp, ions, ext_partners, iter, dt)
subroutine, public td_write_data(writ)
subroutine, public td_write_kick(outp, namespace, space, mesh, kick, ions, iter)
subroutine, public td_write_end(writ)
subroutine, public td_write_iter(writ, namespace, space, outp, gr, st, hm, ions, ext_partners, kick, ks, dt, iter, mc, recalculate_gs)
subroutine, public td_write_init(writ, namespace, space, outp, gr, st, hm, ions, ext_partners, ks, ions_move, with_gauge_field, kick, iter, max_iter, dt, mc)
Initialize files to write when prograting in time.
integer, parameter, public out_separate_forces
type(type_t), public type_cmplx
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
This module defines the unit system, used for input and output.
type(unit_t), public unit_femtosecond
Time in femtoseconds.
type(unit_system_t), public units_out
type(unit_system_t), public units_inp
the units systems for reading and writing
subroutine, public v_ks_freeze_hxc(ks)
subroutine, public v_ks_calculate_current(this, calc_cur)
subroutine, public v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval, time, calc_energy, calc_current, force_semilocal)
This module provices 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
real(real64) function, public walltimer_get_start_time()
Return the walltimer start time.
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.
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.
Stores all communicators and groups.
The states_elec_t class contains all electronic wave functions.