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, &
492 hm%kpoints, hm%phase%is_allocated())
499 call scf_init(td%scf, namespace, gr, ions, st, mc, hm, space)
507 type(
td_t),
intent(inout) :: td
509 type(
grid_t),
intent(inout) :: gr
514 class(
space_t),
intent(in) :: space
521 if(
associated(gfield))
then
528 call hm%update(gr, namespace, space, ext_partners, time = td%dt*td%iter)
538 type(
td_t),
intent(inout) :: td
546 if (td%dmp%calculation_mode /= option__tddmpropagation__no_propagation)
then
550 if (td%dynamics ==
bo)
call scf_end(td%scf)
557 type(
td_t),
intent(inout) :: td
563 if (st%pack_states .and. hm%apply_packed())
call st%unpack()
565 call td%restart_dump%end()
570 if ((td%ions_dyn%is_active()).and. td%recalculate_gs)
call td%restart_load%end()
576 subroutine td_run(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, from_scratch)
577 type(
td_t),
intent(inout) :: td
580 type(
grid_t),
intent(inout) :: gr
581 type(
ions_t),
intent(inout) :: ions
583 type(
v_ks_t),
intent(inout) :: ks
586 type(
output_t),
intent(inout) :: outp
588 logical,
intent(inout) :: from_scratch
591 integer :: iter, scsteps
592 real(real64) :: etime
593 real(real64) :: wall_time, simulation_time, speed_fs_per_day
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, outp, 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 write(
message(1),
'(a,f10.3,a)')
'Propagation speed: ', speed_fs_per_day,
' fs/day'
682 write(
message(1),
'(a7,1x,a14,a14,a10,a17)')
'Iter ',
'Time ',
'Energy ',
'SC Steps',
'Elapsed Time '
691 subroutine td_check_point(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, &
692 iter, scsteps, etime, stopping, from_scratch)
693 type(
td_t),
intent(inout) :: td
696 type(
grid_t),
intent(inout) :: gr
697 type(
ions_t),
intent(inout) :: ions
699 type(
v_ks_t),
intent(inout) :: ks
704 integer,
intent(in) :: iter
705 integer,
intent(in) :: scsteps
706 real(real64),
intent(inout) :: etime
707 logical,
intent(in) :: stopping
708 logical,
intent(inout) :: from_scratch
716 if (outp%anything_now(iter))
then
717 call td_write_output(namespace, space, gr, st, hm, ks, outp, ions, ext_partners, iter, td%dt)
720 if (mod(iter, outp%restart_write_interval) == 0 .or. iter == td%max_iter .or. stopping)
then
723 call td_dump(td, namespace, space, gr, st, hm, ks, ext_partners, iter, ierr)
725 message(1) =
"Unable to write time-dependent restart information."
729 call pes_output(td%pesv, namespace, space, gr, st, iter, outp, td%dt, ions)
731 if ((td%ions_dyn%is_active()) .and. td%recalculate_gs)
then
733 from_scratch = .false.
735 call electrons_ground_state_run(namespace, mc, gr, ions, ext_partners, st, ks, hm, outp, space, from_scratch)
737 call td_load(td%restart_load, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
739 message(1) =
"Unable to load TD states."
743 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
744 calc_eigenval=.
true., time = iter*td%dt, calc_energy=.
true.)
745 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = iter*td%dt, dt = td%dt)
746 assert(.not. td%ions_dyn%cell_relax())
757 type(
td_t),
intent(inout) :: td
759 type(
ions_t),
intent(inout) :: ions
761 integer,
intent(in) :: iter
762 integer,
intent(in) :: scsteps
763 real(real64),
intent(inout) :: etime
778 real(real64),
intent(inout) :: etime
788 subroutine td_init_with_wavefunctions(td, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, outp, from_scratch)
789 type(
td_t),
intent(inout) :: td
793 type(
grid_t),
intent(inout) :: gr
794 type(
ions_t),
intent(inout) :: ions
797 type(
v_ks_t),
intent(inout) :: ks
799 type(
output_t),
intent(inout) :: outp
800 logical,
intent(in) :: from_scratch
804 real(real64) :: ndinitial(space%dim)
805 logical :: freeze_hxc, freeze_occ, freeze_u
806 type(
restart_t) :: restart, restart_frozen
813 if (gr%der%boundaries%spiralBC)
then
814 if ((td%iter-1)*td%dt > hm%kick%time)
then
815 gr%der%boundaries%spiral = .
true.
817 hm%vnl%spin => st%spin
818 hm%phase%spin => st%spin
823 if (from_scratch)
then
830 if (td%freeze_orbitals > 0)
then
831 if (from_scratch)
then
842 message(1) =
"Unable to read frozen restart information."
847 write(
message(1),
'(a,i4,a,i4,a)')
'Info: The lowest', td%freeze_orbitals, &
848 ' orbitals have been frozen.', st%nst,
' will be propagated.'
852 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
853 else if (td%freeze_orbitals < 0)
then
856 write(
message(1),
'(a)')
'Info: The single-active-electron approximation will be used.'
858 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
859 if (from_scratch)
then
870 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
881 call parse_variable(namespace,
'TDFreezeHXC', .false., freeze_hxc)
883 write(
message(1),
'(a)')
'Info: Freezing Hartree and exchange-correlation potentials.'
886 if (.not. from_scratch)
then
889 call states_elec_load(restart_frozen, namespace, space, st, gr, hm%kpoints, ierr, label =
": gs")
891 call restart_frozen%end()
894 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
897 call states_elec_load(restart_frozen, namespace, space, st, gr, hm%kpoints, ierr, iter=td%iter, label =
": td")
898 call restart_frozen%end()
899 call hm%ks_pot%run_zero_iter(td%tr%vks_old)
907 x = minval(st%eigenval(st%st_start, :))
908 if (st%parallel_in_states)
then
909 call st%mpi_grp%bcast(x, 1, mpi_double_precision, 0)
911 call hm%update_span(gr%spacing(1:space%dim), x, namespace)
913 call states_elec_fermi(st, namespace, gr, compute_spin = .not. gr%der%boundaries%spiralBC)
924 call parse_variable(namespace,
'TDFreezeDFTUOccupations', .false., freeze_occ)
926 write(
message(1),
'(a)')
'Info: Freezing DFT+U occupation matrices that enters in the DFT+U potential.'
931 if (hm%lda_u_level /=
dft_u_none .and. .not. from_scratch)
then
933 call lda_u_load(restart_frozen, hm%lda_u, st, hm%energy%dft_u, ierr, occ_only = .
true.)
934 call restart_frozen%end()
947 write(
message(1),
'(a)')
'Info: Freezing the effective U of DFT+U.'
952 if (hm%lda_u_level ==
dft_u_acbn0 .and. .not. from_scratch)
then
954 call lda_u_load(restart_frozen, hm%lda_u, st, hm%energy%dft_u, ierr, u_only = .
true.)
955 call restart_frozen%end()
956 write(
message(1),
'(a)')
'Loaded GS effective U of DFT+U'
965 call td_write_init(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
966 ks, td%ions_dyn%is_active(), &
971 if(
associated(lasers))
then
973 ndinitial(1:space%dim)=
m_zero
982 call scissor_init(hm%scissor, namespace, space, st, gr, hm%d, hm%kpoints, hm%phase, td%scissor, mc)
985 if (td%iter == 0)
call td_run_zero_iter(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp, mc)
988 if(
associated(gfield))
then
990 if(abs(ks%xc%kernel_lrc_alpha) >
m_epsilon)
then
992 ks%xc%kernel_lrc_alpha, ks%xc%kernel_proca_a_zero, ks%xc%kernel_proca_a_one)
1001 td%iter = td%iter + 1
1004 if (td%ions_dyn%is_active() .and. td%recalculate_gs)
then
1012 if (td%pesv%calc_spm .or. td%pesv%calc_mask .and. from_scratch)
then
1016 if (st%pack_states .and. hm%apply_packed())
call st%pack()
1023 type(
td_t),
intent(inout) :: td
1026 type(
grid_t),
intent(inout) :: gr
1027 type(
ions_t),
intent(inout) :: ions
1030 type(
v_ks_t),
intent(inout) :: ks
1032 type(
output_t),
intent(inout) :: outp
1037 if (td%ions_dyn%ions_move())
then
1038 if (td%iter > 0)
then
1045 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
1048 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = td%iter*td%dt, dt = td%dt)
1050 call ions%update_kinetic_energy()
1052 if (outp%what(option__output__forces) .or. td%write_handler%out(
out_separate_forces)%write)
then
1053 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = td%iter*td%dt, dt = td%dt)
1057 if (outp%what(option__output__stress) .or. td%ions_dyn%cell_relax())
then
1059 if (td%ions_dyn%cell_relax())
then
1060 call td%ions_dyn%update_stress(ions%space, st%stress_tensors%total, ions%latt%rlattice, ions%latt%rcell_volume)
1069 type(
td_t),
intent(inout) :: td
1071 class(
space_t),
intent(in) :: space
1073 type(
grid_t),
intent(inout) :: gr
1076 type(
v_ks_t),
intent(inout) :: ks
1078 logical,
intent(inout) :: from_scratch
1086 if (td%freeze_orbitals > 0)
then
1092 call td_load(restart, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
1096 from_scratch = .
true.
1105 type(
td_t),
intent(inout) :: td
1107 class(
space_t),
intent(in) :: space
1109 type(
grid_t),
intent(inout) :: gr
1112 type(
v_ks_t),
intent(inout) :: ks
1122 if (.not. st%only_userdef_istates)
then
1124 call states_elec_load(restart, namespace, space, st, gr, hm%kpoints, ierr, label =
": gs")
1127 message(1) =
'Unable to read ground-state wavefunctions.'
1146 subroutine td_run_zero_iter(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp, mc)
1147 type(
td_t),
intent(inout) :: td
1150 type(
grid_t),
intent(inout) :: gr
1151 type(
ions_t),
intent(inout) :: ions
1153 type(
v_ks_t),
intent(inout) :: ks
1161 call td_write_iter(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
1162 hm%kick, ks, td%dt, 0, mc, td%recalculate_gs)
1166 if (abs(hm%kick%time) <=
m_epsilon)
then
1167 if (.not. hm%pcm%localf)
then
1168 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints)
1170 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints, pcm = hm%pcm)
1172 call td_write_kick(outp, namespace, space, gr, hm%kick, ions, 0)
1175 if (gr%der%boundaries%spiralBC)
then
1176 gr%der%boundaries%spiral = .
true.
1179 call hm%ks_pot%run_zero_iter(td%tr%vks_old)
1181 if (any(outp%output_interval > 0))
then
1183 call td_write_output(namespace, space, gr, st, hm, ks, outp, ions, ext_partners, 0)
1193 type(
td_t),
intent(in) :: td
1195 type(
ions_t),
intent(inout) :: ions
1197 integer :: iatom, iter, iunit
1201 iunit =
io_open(
'td.general/coordinates', namespace, action=
'read', status=
'old', die=.false.)
1202 if (iunit == -1)
then
1203 message(1) =
"Could not open file '"//trim(
io_workpath(
'td.general/coordinates', namespace))//
"'."
1204 message(2) =
"Starting simulation from initial geometry."
1211 do iter = 0, td%iter - 1
1214 read(iunit,
'(32x)', advance=
'no')
1216 do iatom = 1, ions%natoms
1217 read(iunit,
'(3es24.16)', advance=
'no') ions%pos(:, iatom)
1220 do iatom = 1, ions%natoms
1221 read(iunit,
'(3es24.16)', advance=
'no') ions%vel(:, iatom)
1224 do iatom = 1, ions%natoms
1225 read(iunit,
'(3es24.16)', advance=
'no') ions%tot_force(:, iatom)
1235 subroutine td_dump(td, namespace, space, gr, st, hm, ks, ext_partners, iter, ierr)
1236 type(
td_t),
intent(in) :: td
1238 class(
space_t),
intent(in) :: space
1239 type(
grid_t),
intent(in) :: gr
1242 type(
v_ks_t),
intent(in) :: ks
1244 integer,
intent(in) :: iter
1245 integer,
intent(out) :: ierr
1248 integer :: err, err2
1254 if (td%restart_dump%skip())
then
1259 message(1) =
"Debug: Writing td restart."
1263 call states_elec_dump(td%restart_dump, space, st, gr, hm%kpoints, err, iter=iter)
1264 if (err /= 0) ierr = ierr + 1
1267 if (err /= 0) ierr = ierr + 1
1270 call lda_u_dump(td%restart_dump, namespace, hm%lda_u, st, gr, ierr)
1271 if (err /= 0) ierr = ierr + 1
1275 if (err2 /= 0) ierr = ierr + 2
1277 call pes_dump(td%pesv, namespace, td%restart_dump, st, gr, err)
1278 if (err /= 0) ierr = ierr + 4
1282 if(
associated(gfield))
then
1286 if (gr%der%boundaries%spiralBC)
then
1288 if (err /= 0) ierr = ierr + 8
1291 if (ks%has_photons)
then
1292 call mf_photons_dump(td%restart_dump, ks%pt_mx, gr, td%dt, ks%pt, err)
1293 if (err /= 0) ierr = ierr + 16
1296 if (ks%xc_photon /= 0)
then
1298 call ks%xc_photons%mf_dump(td%restart_dump, err)
1299 if (err /= 0) ierr = ierr + 32
1302 if (
allocated(st%frozen_rho))
then
1305 if (err /= 0) ierr = ierr + 64
1307 if (td%ions_dyn%ions_move() .or. td%ions_dyn%cell_relax())
then
1310 if (err /= 0) ierr = ierr + 128
1312 message(1) =
"Debug: Writing td restart done."
1319 subroutine td_load(restart, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
1322 class(
space_t),
intent(in) :: space
1323 type(
grid_t),
intent(in) :: gr
1327 type(
td_t),
intent(inout) :: td
1328 type(
v_ks_t),
intent(inout) :: ks
1329 integer,
intent(out) :: ierr
1331 integer :: err, err2
1337 if (restart%skip())
then
1343 message(1) =
"Debug: Reading td restart."
1347 call states_elec_load(restart, namespace, space, st, gr, hm%kpoints, err, iter=td%iter, label =
": td")
1354 if (err2 /= 0) ierr = ierr + 2
1357 call lda_u_load(restart, hm%lda_u, st, hm%energy%dft_u, ierr)
1358 if (err /= 0) ierr = ierr + 1
1363 if (td%pesv%calc_spm .or. td%pesv%calc_mask .or. td%pesv%calc_flux)
then
1364 call pes_load(td%pesv, namespace, restart, st, err)
1365 if (err /= 0) ierr = ierr + 4
1370 if (
associated(gfield))
then
1375 call hm%update(gr, namespace, space, ext_partners, time = td%dt*td%iter)
1380 if (ks%has_photons)
then
1383 if (err /= 0) ierr = ierr + 16
1385 if (ks%xc_photon /= 0)
then
1386 call ks%xc_photons%mf_load(restart, space, err)
1388 if (err /= 0) ierr = ierr + 32
1390 if (gr%der%boundaries%spiralBC)
then
1397 if (td%ions_dyn%is_active())
then
1400 if (err /= 0) ierr = ierr + 64
1402 message(1) =
"Debug: Reading td restart done."
1408 subroutine td_load_frozen(namespace, restart, space, mesh, st, hm, ierr)
1411 class(
space_t),
intent(in) :: space
1412 class(
mesh_t),
intent(in) :: mesh
1415 integer,
intent(out) :: ierr
1421 if (restart%skip())
then
1427 message(1) =
"Debug: Reading td frozen restart."
1430 safe_allocate(st%frozen_rho(1:mesh%np, 1:st%d%nspin))
1432 safe_allocate(st%frozen_tau(1:mesh%np, 1:st%d%nspin))
1433 safe_allocate(st%frozen_gdens(1:mesh%np, 1:space%dim, 1:st%d%nspin))
1434 safe_allocate(st%frozen_ldens(1:mesh%np, 1:st%d%nspin))
1439 message(1) =
"Debug: Reading td frozen restart done."
1447 type(
td_t),
intent(in) :: td
1458 type(
td_t),
intent(inout) :: td
1459 logical,
intent(in) :: from_scratch
1463 td%from_scratch = from_scratch
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_freeze_occ(this)
subroutine, public lda_u_freeze_u(this)
subroutine, public lda_u_end(this)
subroutine, public lda_u_init(this, namespace, space, level, gr, ions, st, mc, kpoints, has_phase)
integer, parameter, public dft_u_acbn0
subroutine, public lda_u_update_occ_matrices(this, namespace, mesh, st, hm_base, phase, energy)
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, outp, 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, d, 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.