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
600 propagation:
do iter = td%iter, td%max_iter
607 if (((iter-1)*td%dt <= hm%kick%time) .and. (iter*td%dt > hm%kick%time))
then
608 if (.not. hm%pcm%localf)
then
609 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints)
611 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints, pcm = hm%pcm)
613 call td_write_kick(outp, namespace, space, gr, hm%kick, ions, iter)
616 if (gr%der%boundaries%spiralBC) gr%der%boundaries%spiral = .
true.
621 select case (td%dynamics)
623 call propagator_elec_dt(ks, namespace, space, hm, gr, st, td%tr, iter*td%dt, td%dt, iter, td%ions_dyn, &
624 ions, ext_partners, mc, outp, td%write_handler, scsteps = scsteps, &
625 update_energy = (mod(iter, td%energy_update_iter) == 0) .or. (iter == td%max_iter))
627 call propagator_elec_dt_bo(td%scf, namespace, space, gr, ks, st, hm, ions, ext_partners, mc, iter, &
628 td%dt, td%ions_dyn, scsteps)
631 if (td%dmp%calculation_mode /= option__tddmpropagation__no_propagation)
then
632 call dm_propagation_run(td%dmp, namespace, space, gr, ions, st, mc, hm, ks, iter, td%dt, ext_partners, &
633 update_energy = (mod(iter, td%energy_update_iter) == 0) .or. (iter == td%max_iter))
646 if (td%pesv%calc_spm .or. td%pesv%calc_mask .or. td%pesv%calc_flux)
then
647 call pes_calc(td%pesv, namespace, space, gr, st, td%dt, iter, gr%der, hm%kpoints, ext_partners, stopping)
650 call td_write_iter(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
651 hm%kick, ks, td%dt, iter, mc, td%recalculate_gs)
654 call td_check_point(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, &
655 iter, scsteps, etime, stopping, from_scratch)
667 simulation_time = td%dt * (iter - td%iter + 1)
669 write(
message(1),
'(a,f10.3,a)')
'Propagation speed: ', speed_fs_per_day,
' fs/day'
681 write(
message(1),
'(a7,1x,a14,a14,a10,a17)')
'Iter ',
'Time ',
'Energy ',
'SC Steps',
'Elapsed Time '
690 subroutine td_check_point(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, &
691 iter, scsteps, etime, stopping, from_scratch)
692 type(
td_t),
intent(inout) :: td
695 type(
grid_t),
intent(inout) :: gr
696 type(
ions_t),
intent(inout) :: ions
698 type(
v_ks_t),
intent(inout) :: ks
703 integer,
intent(in) :: iter
704 integer,
intent(in) :: scsteps
705 real(real64),
intent(inout) :: etime
706 logical,
intent(in) :: stopping
707 logical,
intent(inout) :: from_scratch
715 if (outp%anything_now(iter))
then
716 call td_write_output(namespace, space, gr, st, hm, ks, outp, ions, ext_partners, iter, td%dt)
719 if (mod(iter, outp%restart_write_interval) == 0 .or. iter == td%max_iter .or. stopping)
then
722 call td_dump(td, namespace, space, gr, st, hm, ks, ext_partners, iter, ierr)
724 message(1) =
"Unable to write time-dependent restart information."
728 call pes_output(td%pesv, namespace, space, gr, st, iter, outp, td%dt, ions)
730 if ((td%ions_dyn%is_active()) .and. td%recalculate_gs)
then
732 from_scratch = .false.
734 call electrons_ground_state_run(namespace, mc, gr, ions, ext_partners, st, ks, hm, outp, space, from_scratch)
736 call td_load(td%restart_load, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
738 message(1) =
"Unable to load TD states."
742 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
743 calc_eigenval=.
true., time = iter*td%dt, calc_energy=.
true.)
744 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = iter*td%dt, dt = td%dt)
745 assert(.not. td%ions_dyn%cell_relax())
756 type(
td_t),
intent(inout) :: td
758 type(
ions_t),
intent(inout) :: ions
760 integer,
intent(in) :: iter
761 integer,
intent(in) :: scsteps
762 real(real64),
intent(inout) :: etime
777 real(real64),
intent(inout) :: etime
787 subroutine td_init_with_wavefunctions(td, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, outp, from_scratch)
788 type(
td_t),
intent(inout) :: td
792 type(
grid_t),
intent(inout) :: gr
793 type(
ions_t),
intent(inout) :: ions
796 type(
v_ks_t),
intent(inout) :: ks
798 type(
output_t),
intent(inout) :: outp
799 logical,
intent(in) :: from_scratch
803 real(real64) :: ndinitial(space%dim)
804 logical :: freeze_hxc, freeze_occ, freeze_u
805 type(
restart_t) :: restart, restart_frozen
812 if (gr%der%boundaries%spiralBC)
then
813 if ((td%iter-1)*td%dt > hm%kick%time)
then
814 gr%der%boundaries%spiral = .
true.
816 hm%vnl%spin => st%spin
817 hm%phase%spin => st%spin
822 if (from_scratch)
then
829 if (td%freeze_orbitals > 0)
then
830 if (from_scratch)
then
841 message(1) =
"Unable to read frozen restart information."
846 write(
message(1),
'(a,i4,a,i4,a)')
'Info: The lowest', td%freeze_orbitals, &
847 ' orbitals have been frozen.', st%nst,
' will be propagated.'
851 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
852 else if (td%freeze_orbitals < 0)
then
855 write(
message(1),
'(a)')
'Info: The single-active-electron approximation will be used.'
857 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
858 if (from_scratch)
then
869 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
880 call parse_variable(namespace,
'TDFreezeHXC', .false., freeze_hxc)
882 write(
message(1),
'(a)')
'Info: Freezing Hartree and exchange-correlation potentials.'
885 if (.not. from_scratch)
then
888 call states_elec_load(restart_frozen, namespace, space, st, gr, hm%kpoints, ierr, label =
": gs")
890 call restart_frozen%end()
893 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
896 call states_elec_load(restart_frozen, namespace, space, st, gr, hm%kpoints, ierr, iter=td%iter, label =
": td")
897 call restart_frozen%end()
898 call hm%ks_pot%run_zero_iter(td%tr%vks_old)
906 x = minval(st%eigenval(st%st_start, :))
907 if (st%parallel_in_states)
then
908 call st%mpi_grp%bcast(x, 1, mpi_double_precision, 0)
910 call hm%update_span(gr%spacing(1:space%dim), x, namespace)
912 call states_elec_fermi(st, namespace, gr, compute_spin = .not. gr%der%boundaries%spiralBC)
923 call parse_variable(namespace,
'TDFreezeDFTUOccupations', .false., freeze_occ)
925 write(
message(1),
'(a)')
'Info: Freezing DFT+U occupation matrices that enters in the DFT+U potential.'
930 if (hm%lda_u_level /=
dft_u_none .and. .not. from_scratch)
then
932 call lda_u_load(restart_frozen, hm%lda_u, st, hm%energy%dft_u, ierr, occ_only = .
true.)
933 call restart_frozen%end()
946 write(
message(1),
'(a)')
'Info: Freezing the effective U of DFT+U.'
951 if (hm%lda_u_level ==
dft_u_acbn0 .and. .not. from_scratch)
then
953 call lda_u_load(restart_frozen, hm%lda_u, st, hm%energy%dft_u, ierr, u_only = .
true.)
954 call restart_frozen%end()
955 write(
message(1),
'(a)')
'Loaded GS effective U of DFT+U'
964 call td_write_init(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
965 ks, td%ions_dyn%is_active(), &
970 if(
associated(lasers))
then
972 ndinitial(1:space%dim)=
m_zero
981 call scissor_init(hm%scissor, namespace, space, st, gr, hm%kpoints, hm%phase, td%scissor, mc)
984 if (td%iter == 0)
call td_run_zero_iter(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp, mc)
987 if(
associated(gfield))
then
989 if(abs(ks%xc%kernel_lrc_alpha) >
m_epsilon)
then
991 ks%xc%kernel_lrc_alpha, ks%xc%kernel_proca_a_zero, ks%xc%kernel_proca_a_one)
1000 td%iter = td%iter + 1
1003 if (td%ions_dyn%is_active() .and. td%recalculate_gs)
then
1011 if (td%pesv%calc_spm .or. td%pesv%calc_mask .and. from_scratch)
then
1015 if (st%pack_states .and. hm%apply_packed())
call st%pack()
1022 type(
td_t),
intent(inout) :: td
1025 type(
grid_t),
intent(inout) :: gr
1026 type(
ions_t),
intent(inout) :: ions
1029 type(
v_ks_t),
intent(inout) :: ks
1031 type(
output_t),
intent(inout) :: outp
1036 if (td%ions_dyn%ions_move())
then
1037 if (td%iter > 0)
then
1044 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
1047 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = td%iter*td%dt, dt = td%dt)
1049 call ions%update_kinetic_energy()
1051 if (outp%what(option__output__forces) .or. td%write_handler%out(
out_separate_forces)%write)
then
1052 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = td%iter*td%dt, dt = td%dt)
1056 if (outp%what(option__output__stress) .or. td%ions_dyn%cell_relax())
then
1058 if (td%ions_dyn%cell_relax())
then
1059 call td%ions_dyn%update_stress(ions%space, st%stress_tensors%total, ions%latt%rlattice, ions%latt%rcell_volume)
1068 type(
td_t),
intent(inout) :: td
1070 class(
space_t),
intent(in) :: space
1072 type(
grid_t),
intent(inout) :: gr
1075 type(
v_ks_t),
intent(inout) :: ks
1077 logical,
intent(inout) :: from_scratch
1085 if (td%freeze_orbitals > 0)
then
1091 call td_load(restart, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
1095 from_scratch = .
true.
1104 type(
td_t),
intent(inout) :: td
1106 class(
space_t),
intent(in) :: space
1108 type(
grid_t),
intent(inout) :: gr
1111 type(
v_ks_t),
intent(inout) :: ks
1121 if (.not. st%only_userdef_istates)
then
1123 call states_elec_load(restart, namespace, space, st, gr, hm%kpoints, ierr, label =
": gs")
1126 message(1) =
'Unable to read ground-state wavefunctions.'
1145 subroutine td_run_zero_iter(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp, mc)
1146 type(
td_t),
intent(inout) :: td
1149 type(
grid_t),
intent(inout) :: gr
1150 type(
ions_t),
intent(inout) :: ions
1152 type(
v_ks_t),
intent(inout) :: ks
1160 call td_write_iter(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
1161 hm%kick, ks, td%dt, 0, mc, td%recalculate_gs)
1165 if (abs(hm%kick%time) <=
m_epsilon)
then
1166 if (.not. hm%pcm%localf)
then
1167 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints)
1169 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints, pcm = hm%pcm)
1171 call td_write_kick(outp, namespace, space, gr, hm%kick, ions, 0)
1174 if (gr%der%boundaries%spiralBC)
then
1175 gr%der%boundaries%spiral = .
true.
1178 call hm%ks_pot%run_zero_iter(td%tr%vks_old)
1180 if (any(outp%output_interval > 0))
then
1182 call td_write_output(namespace, space, gr, st, hm, ks, outp, ions, ext_partners, 0)
1192 type(
td_t),
intent(in) :: td
1194 type(
ions_t),
intent(inout) :: ions
1196 integer :: iatom, iter, iunit
1200 iunit =
io_open(
'td.general/coordinates', namespace, action=
'read', status=
'old', die=.false.)
1201 if (iunit == -1)
then
1202 message(1) =
"Could not open file '"//trim(
io_workpath(
'td.general/coordinates', namespace))//
"'."
1203 message(2) =
"Starting simulation from initial geometry."
1210 do iter = 0, td%iter - 1
1213 read(iunit,
'(32x)', advance=
'no')
1215 do iatom = 1, ions%natoms
1216 read(iunit,
'(3es24.16)', advance=
'no') ions%pos(:, iatom)
1219 do iatom = 1, ions%natoms
1220 read(iunit,
'(3es24.16)', advance=
'no') ions%vel(:, iatom)
1223 do iatom = 1, ions%natoms
1224 read(iunit,
'(3es24.16)', advance=
'no') ions%tot_force(:, iatom)
1234 subroutine td_dump(td, namespace, space, gr, st, hm, ks, ext_partners, iter, ierr)
1235 type(
td_t),
intent(in) :: td
1237 class(
space_t),
intent(in) :: space
1238 type(
grid_t),
intent(in) :: gr
1241 type(
v_ks_t),
intent(in) :: ks
1243 integer,
intent(in) :: iter
1244 integer,
intent(out) :: ierr
1247 integer :: err, err2
1253 if (td%restart_dump%skip())
then
1258 message(1) =
"Debug: Writing td restart."
1262 call states_elec_dump(td%restart_dump, space, st, gr, hm%kpoints, err, iter=iter)
1263 if (err /= 0) ierr = ierr + 1
1266 if (err /= 0) ierr = ierr + 1
1269 call lda_u_dump(td%restart_dump, namespace, hm%lda_u, st, gr, ierr)
1270 if (err /= 0) ierr = ierr + 1
1274 if (err2 /= 0) ierr = ierr + 2
1276 call pes_dump(td%pesv, namespace, td%restart_dump, st, gr, err)
1277 if (err /= 0) ierr = ierr + 4
1281 if(
associated(gfield))
then
1285 if (gr%der%boundaries%spiralBC)
then
1287 if (err /= 0) ierr = ierr + 8
1290 if (ks%has_photons)
then
1291 call mf_photons_dump(td%restart_dump, ks%pt_mx, gr, td%dt, ks%pt, err)
1292 if (err /= 0) ierr = ierr + 16
1295 if (ks%xc_photon /= 0)
then
1297 call ks%xc_photons%mf_dump(td%restart_dump, err)
1298 if (err /= 0) ierr = ierr + 32
1301 if (
allocated(st%frozen_rho))
then
1304 if (err /= 0) ierr = ierr + 64
1306 if (td%ions_dyn%ions_move() .or. td%ions_dyn%cell_relax())
then
1309 if (err /= 0) ierr = ierr + 128
1311 message(1) =
"Debug: Writing td restart done."
1318 subroutine td_load(restart, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
1321 class(
space_t),
intent(in) :: space
1322 type(
grid_t),
intent(in) :: gr
1326 type(
td_t),
intent(inout) :: td
1327 type(
v_ks_t),
intent(inout) :: ks
1328 integer,
intent(out) :: ierr
1330 integer :: err, err2
1336 if (restart%skip())
then
1342 message(1) =
"Debug: Reading td restart."
1346 call states_elec_load(restart, namespace, space, st, gr, hm%kpoints, err, iter=td%iter, label =
": td")
1353 if (err2 /= 0) ierr = ierr + 2
1356 call lda_u_load(restart, hm%lda_u, st, hm%energy%dft_u, ierr)
1357 if (err /= 0) ierr = ierr + 1
1362 if (td%pesv%calc_spm .or. td%pesv%calc_mask .or. td%pesv%calc_flux)
then
1363 call pes_load(td%pesv, namespace, restart, st, err)
1364 if (err /= 0) ierr = ierr + 4
1369 if (
associated(gfield))
then
1374 call hm%update(gr, namespace, space, ext_partners, time = td%dt*td%iter)
1379 if (ks%has_photons)
then
1382 if (err /= 0) ierr = ierr + 16
1384 if (ks%xc_photon /= 0)
then
1385 call ks%xc_photons%mf_load(restart, space, err)
1387 if (err /= 0) ierr = ierr + 32
1389 if (gr%der%boundaries%spiralBC)
then
1396 if (td%ions_dyn%is_active())
then
1399 if (err /= 0) ierr = ierr + 64
1401 message(1) =
"Debug: Reading td restart done."
1407 subroutine td_load_frozen(namespace, restart, space, mesh, st, hm, ierr)
1410 class(
space_t),
intent(in) :: space
1411 class(
mesh_t),
intent(in) :: mesh
1414 integer,
intent(out) :: ierr
1420 if (restart%skip())
then
1426 message(1) =
"Debug: Reading td frozen restart."
1429 safe_allocate(st%frozen_rho(1:mesh%np, 1:st%d%nspin))
1431 safe_allocate(st%frozen_tau(1:mesh%np, 1:st%d%nspin))
1432 safe_allocate(st%frozen_gdens(1:mesh%np, 1:space%dim, 1:st%d%nspin))
1433 safe_allocate(st%frozen_ldens(1:mesh%np, 1:st%d%nspin))
1438 message(1) =
"Debug: Reading td frozen restart done."
1446 type(
td_t),
intent(in) :: td
1457 type(
td_t),
intent(inout) :: td
1458 logical,
intent(in) :: from_scratch
1462 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_alpha, proca_a_zero, proca_a_one)
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, space, restart, mesh, nspin, err2)
subroutine, public potential_interpolation_dump(potential_interpolation, space, 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, space, 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.