44 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
153 subroutine td_init(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp)
154 type(td_t),
intent(inout) :: td
155 type(namespace_t),
intent(in) :: namespace
156 class(space_t),
intent(in) :: space
157 type(grid_t),
intent(in) :: gr
158 type(ions_t),
intent(inout) :: ions
159 type(states_elec_t),
intent(in) :: st
160 type(v_ks_t),
intent(in) :: ks
161 type(hamiltonian_elec_t),
intent(in) :: hm
162 type(partner_list_t),
intent(in) :: ext_partners
163 type(output_t),
intent(in) :: outp
166 real(real64) :: propagation_time
167 type(lasers_t),
pointer :: lasers
168 logical :: symmetrize
174 symmetrize = hm%kpoints%use_symmetries .or. st%symmetrize_density
177 if (td%ions_dyn%ions_move())
then
178 if (hm%kpoints%use_symmetries)
then
179 message(1) =
"KPoints symmetries cannot be used with moving ions."
180 message(2) =
"Please set KPointsSymmetries = no."
183 if (st%symmetrize_density)
then
184 message(1) =
"Symmetrization of the density cannot be used with moving ions."
185 message(2) =
"Please set SymmetrizeDensity = no."
207 write(
message(1),
'(a)')
'A positive value for TDTimeStep must be defined in the input file.'
215 call messages_write(
'You cannot set TDMaxSteps and TDPropagationTime at the same time')
244 if (propagation_time >
m_zero) default = nint(propagation_time/td%dt)
245 call parse_variable(namespace,
'TDMaxSteps', default, td%max_iter)
247 if (propagation_time <=
m_zero) propagation_time = td%dt*td%max_iter
252 if (td%max_iter < 1)
then
253 write(
message(1),
'(a,i6,a)')
"Input: '", td%max_iter,
"' is not a valid value for TDMaxSteps."
254 message(2) =
'(TDMaxSteps <= 1)'
265 call pes_init(td%pesv, namespace, space, gr, gr%box, st, outp%restart_write_interval, hm%kpoints, &
266 hm%abs_boundaries, ext_partners, td%max_iter, td%dt)
281 call parse_variable(namespace,
'TDDynamics', ehrenfest, td%dynamics)
284 if (td%dynamics .ne. ehrenfest)
then
285 if (.not. td%ions_dyn%is_active())
then
286 message(1) =
"TDDynamics=bo can only be used if MoveIons=yes or CellDynamics=yes"
307 call parse_variable(namespace,
'RecalculateGSDuringEvolution', .false., td%recalculate_gs)
308 if (hm%lda_u_level /=
dft_u_none .and. td%recalculate_gs)
then
329 call laser_write_info(lasers%lasers, dt=td%dt, max_iter=td%max_iter, namespace=namespace)
345 call parse_variable(namespace,
'TDEnergyUpdateIter', default, td%energy_update_iter)
347 if (gr%der%boundaries%spiralBC .and. hm%ep%reltype ==
spin_orbit)
then
348 message(1) =
"Generalized Bloch theorem cannot be used with spin-orbit coupling."
352 if (gr%der%boundaries%spiralBC)
then
353 if (any(abs(hm%kick%easy_axis(1:2)) >
m_epsilon))
then
354 message(1) =
"Generalized Bloch theorem cannot be used for an easy axis not along the z direction."
380 call parse_variable(namespace,
'TDFreezeOrbitals', 0, td%freeze_orbitals)
382 if (td%freeze_orbitals /= 0)
then
396 subroutine td_init_run(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, from_scratch)
397 type(
td_t),
intent(inout) :: td
400 type(
grid_t),
intent(inout) :: gr
401 type(
ions_t),
intent(inout) :: ions
403 type(
v_ks_t),
intent(inout) :: ks
406 type(
output_t),
intent(inout) :: outp
408 logical,
intent(inout) :: from_scratch
418 td%from_scratch = from_scratch
420 if (.not. td%from_scratch)
then
422 if (td%from_scratch)
then
423 message(1) =
"Unable to read time-dependent restart information: Starting from scratch"
428 if (td%iter >= td%max_iter)
then
429 message(1) =
"All requested iterations have already been done. Use FromScratch = yes if you want to redo them."
432 td%iter = td%iter + 1
433 if ((td%ions_dyn%is_active()) .and. td%recalculate_gs)
call restart_end(td%restart_load)
438 if (td%from_scratch)
then
442 call td_init_with_wavefunctions(td, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, outp, td%from_scratch)
449 type(
td_t),
intent(inout) :: td
452 type(
grid_t),
intent(inout) :: gr
453 type(
ions_t),
intent(inout) :: ions
456 class(
space_t),
intent(in) :: space
461 if (td%dynamics == ehrenfest)
then
467 call lda_u_init(hm%lda_u, namespace, space, hm%lda_u_level, gr, ions, st, mc, &
468 hm%kpoints, hm%phase%is_allocated())
475 call scf_init(td%scf, namespace, gr, ions, st, mc, hm, space)
483 type(
td_t),
intent(inout) :: td
485 type(
grid_t),
intent(inout) :: gr
487 type(
v_ks_t),
intent(inout) :: ks
490 class(
space_t),
intent(in) :: space
497 if(
associated(gfield))
then
504 call hm%update(gr, namespace, space, ext_partners, time = td%dt*td%iter)
514 type(
td_t),
intent(inout) :: td
522 if (td%dynamics ==
bo)
call scf_end(td%scf)
529 type(
td_t),
intent(inout) :: td
535 if (st%pack_states .and. hm%apply_packed())
call st%unpack()
542 if ((td%ions_dyn%is_active()).and. td%recalculate_gs)
call restart_end(td%restart_load)
548 subroutine td_run(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, from_scratch)
549 type(
td_t),
intent(inout) :: td
552 type(
grid_t),
intent(inout) :: gr
553 type(
ions_t),
intent(inout) :: ions
555 type(
v_ks_t),
intent(inout) :: ks
558 type(
output_t),
intent(inout) :: outp
560 logical,
intent(inout) :: from_scratch
563 integer :: iter, scsteps
564 real(real64) :: etime
572 propagation:
do iter = td%iter, td%max_iter
579 if (((iter-1)*td%dt <= hm%kick%time) .and. (iter*td%dt > hm%kick%time))
then
580 if (.not. hm%pcm%localf)
then
581 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints)
583 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints, pcm = hm%pcm)
585 call td_write_kick(outp, namespace, space, gr, hm%kick, ions, iter)
588 if (gr%der%boundaries%spiralBC) gr%der%boundaries%spiral = .
true.
593 select case (td%dynamics)
595 call propagator_elec_dt(ks, namespace, space, hm, gr, st, td%tr, iter*td%dt, td%dt, iter, td%ions_dyn, &
596 ions, ext_partners, mc, outp, td%write_handler, scsteps = scsteps, &
597 update_energy = (mod(iter, td%energy_update_iter) == 0) .or. (iter == td%max_iter))
599 call propagator_elec_dt_bo(td%scf, namespace, space, gr, ks, st, hm, ions, ext_partners, mc, outp, iter, &
600 td%dt, td%ions_dyn, scsteps)
613 if (td%pesv%calc_spm .or. td%pesv%calc_mask .or. td%pesv%calc_flux)
then
614 call pes_calc(td%pesv, namespace, space, gr, st, td%dt, iter, gr%der, hm%kpoints, ext_partners, stopping)
617 call td_write_iter(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
618 hm%kick, ks, td%dt, iter, mc, td%recalculate_gs)
621 call td_check_point(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, &
622 iter, scsteps, etime, stopping, from_scratch)
640 write(
message(1),
'(a7,1x,a14,a14,a10,a17)')
'Iter ',
'Time ',
'Energy ',
'SC Steps',
'Elapsed Time '
649 subroutine td_check_point(td, namespace, mc, gr, ions, st, ks, hm, ext_partners, outp, space, &
650 iter, scsteps, etime, stopping, from_scratch)
651 type(
td_t),
intent(inout) :: td
654 type(
grid_t),
intent(inout) :: gr
655 type(
ions_t),
intent(inout) :: ions
657 type(
v_ks_t),
intent(inout) :: ks
662 integer,
intent(in) :: iter
663 integer,
intent(in) :: scsteps
664 real(real64),
intent(inout) :: etime
665 logical,
intent(in) :: stopping
666 logical,
intent(inout) :: from_scratch
674 if (outp%anything_now(iter))
then
675 call td_write_output(namespace, space, gr, st, hm, ks, outp, ions, ext_partners, iter, td%dt)
678 if (mod(iter, outp%restart_write_interval) == 0 .or. iter == td%max_iter .or. stopping)
then
681 call td_dump(td, namespace, space, gr, st, hm, ks, ext_partners, iter, ierr)
683 message(1) =
"Unable to write time-dependent restart information."
687 call pes_output(td%pesv, namespace, space, gr, st, iter, outp, td%dt, ions)
689 if ((td%ions_dyn%is_active()) .and. td%recalculate_gs)
then
691 from_scratch = .false.
693 call electrons_ground_state_run(namespace, mc, gr, ions, ext_partners, st, ks, hm, outp, space, from_scratch)
695 call td_load(td%restart_load, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
697 message(1) =
"Unable to load TD states."
701 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
702 calc_eigenval=.
true., time = iter*td%dt, calc_energy=.
true.)
703 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = iter*td%dt, dt = td%dt)
704 assert(.not. td%ions_dyn%cell_relax())
715 type(
td_t),
intent(inout) :: td
717 type(
ions_t),
intent(inout) :: ions
719 integer,
intent(in) :: iter
720 integer,
intent(in) :: scsteps
721 real(real64),
intent(inout) :: etime
736 real(real64),
intent(inout) :: etime
746 subroutine td_init_with_wavefunctions(td, namespace, space, mc, gr, ions, ext_partners, st, ks, hm, outp, from_scratch)
747 type(
td_t),
intent(inout) :: td
751 type(
grid_t),
intent(inout) :: gr
752 type(
ions_t),
intent(inout) :: ions
755 type(
v_ks_t),
intent(inout) :: ks
757 type(
output_t),
intent(inout) :: outp
758 logical,
intent(in) :: from_scratch
762 real(real64) :: ndinitial(space%dim)
763 logical :: freeze_hxc, freeze_occ, freeze_u
764 type(
restart_t) :: restart, restart_frozen
771 if (gr%der%boundaries%spiralBC)
then
772 if ((td%iter-1)*td%dt > hm%kick%time)
then
773 gr%der%boundaries%spiral = .
true.
775 hm%vnl%spin => st%spin
776 hm%phase%spin => st%spin
781 if (from_scratch)
then
788 if (td%freeze_orbitals > 0)
then
789 if (from_scratch)
then
800 message(1) =
"Unable to read frozen restart information."
805 write(
message(1),
'(a,i4,a,i4,a)')
'Info: The lowest', td%freeze_orbitals, &
806 ' orbitals have been frozen.', st%nst,
' will be propagated.'
810 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
811 else if (td%freeze_orbitals < 0)
then
814 write(
message(1),
'(a)')
'Info: The single-active-electron approximation will be used.'
816 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
817 if (from_scratch)
then
828 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
841 write(
message(1),
'(a)')
'Info: Freezing Hartree and exchange-correlation potentials.'
844 if (.not. from_scratch)
then
847 call states_elec_load(restart_frozen, namespace, space, st, gr, hm%kpoints, ierr, label =
": gs")
852 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
855 call states_elec_load(restart_frozen, namespace, space, st, gr, hm%kpoints, ierr, iter=td%iter, label =
": td")
857 call hm%ks_pot%run_zero_iter(td%tr%vks_old)
865 x = minval(st%eigenval(st%st_start, :))
866 if (st%parallel_in_states)
then
867 call st%mpi_grp%bcast(x, 1, mpi_double_precision, 0)
869 call hm%update_span(gr%spacing(1:space%dim), x, namespace)
871 call states_elec_fermi(st, namespace, gr, compute_spin = .not. gr%der%boundaries%spiralBC)
882 call parse_variable(namespace,
'TDFreezeDFTUOccupations', .false., freeze_occ)
884 write(
message(1),
'(a)')
'Info: Freezing DFT+U occupation matrices that enters in the DFT+U potential.'
889 if (hm%lda_u_level /=
dft_u_none .and. .not. from_scratch)
then
891 call lda_u_load(restart_frozen, hm%lda_u, st, hm%energy%dft_u, ierr, occ_only = .
true.)
905 write(
message(1),
'(a)')
'Info: Freezing the effective U of DFT+U.'
910 if (hm%lda_u_level ==
dft_u_acbn0 .and. .not. from_scratch)
then
912 call lda_u_load(restart_frozen, hm%lda_u, st, hm%energy%dft_u, ierr, u_only = .
true.)
914 write(
message(1),
'(a)')
'Loaded GS effective U of DFT+U'
923 call td_write_init(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
924 ks, td%ions_dyn%is_active(), &
929 if(
associated(lasers))
then
931 ndinitial(1:space%dim)=
m_zero
940 call scissor_init(hm%scissor, namespace, space, st, gr, hm%d, hm%kpoints, hm%phase, td%scissor, mc)
943 if (td%iter == 0)
call td_run_zero_iter(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp, mc)
946 if(
associated(gfield))
then
948 if(ks%xc%kernel_lrc_alpha >
m_epsilon)
then
958 td%iter = td%iter + 1
961 if (td%ions_dyn%is_active() .and. td%recalculate_gs)
then
969 if (td%pesv%calc_spm .or. td%pesv%calc_mask .and. from_scratch)
then
973 if (st%pack_states .and. hm%apply_packed())
call st%pack()
980 type(
td_t),
intent(inout) :: td
983 type(
grid_t),
intent(inout) :: gr
984 type(
ions_t),
intent(inout) :: ions
987 type(
v_ks_t),
intent(inout) :: ks
989 type(
output_t),
intent(inout) :: outp
994 if (td%ions_dyn%ions_move())
then
995 if (td%iter > 0)
then
1002 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval=.
true., time = td%iter*td%dt)
1005 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = td%iter*td%dt, dt = td%dt)
1007 call ions%update_kinetic_energy()
1009 if (outp%what(option__output__forces) .or. td%write_handler%out(
out_separate_forces)%write)
then
1010 call forces_calculate(gr, namespace, ions, hm, ext_partners, st, ks, t = td%iter*td%dt, dt = td%dt)
1014 if (outp%what(option__output__stress) .or. td%ions_dyn%cell_relax())
then
1016 if (td%ions_dyn%cell_relax())
then
1017 call td%ions_dyn%update_stress(ions%space, st%stress_tensors%total, ions%latt%rlattice, ions%latt%rcell_volume)
1026 type(
td_t),
intent(inout) :: td
1028 class(
space_t),
intent(in) :: space
1030 type(
grid_t),
intent(inout) :: gr
1033 type(
v_ks_t),
intent(inout) :: ks
1035 logical,
intent(inout) :: from_scratch
1043 if (td%freeze_orbitals > 0)
then
1049 call td_load(restart, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
1053 from_scratch = .
true.
1062 type(
td_t),
intent(inout) :: td
1064 class(
space_t),
intent(in) :: space
1066 type(
grid_t),
intent(inout) :: gr
1069 type(
v_ks_t),
intent(inout) :: ks
1079 if (.not. st%only_userdef_istates)
then
1081 call states_elec_load(restart, namespace, space, st, gr, hm%kpoints, ierr, label =
": gs")
1084 message(1) =
'Unable to read ground-state wavefunctions.'
1103 subroutine td_run_zero_iter(td, namespace, space, gr, ions, st, ks, hm, ext_partners, outp, mc)
1104 type(
td_t),
intent(inout) :: td
1107 type(
grid_t),
intent(inout) :: gr
1108 type(
ions_t),
intent(inout) :: ions
1110 type(
v_ks_t),
intent(inout) :: ks
1118 call td_write_iter(td%write_handler, namespace, space, outp, gr, st, hm, ions, ext_partners, &
1119 hm%kick, ks, td%dt, 0, mc, td%recalculate_gs)
1123 if (abs(hm%kick%time) <=
m_epsilon)
then
1124 if (.not. hm%pcm%localf)
then
1125 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints)
1127 call kick_apply(space, gr, st, td%ions_dyn, ions, hm%kick, hm%psolver, hm%kpoints, pcm = hm%pcm)
1129 call td_write_kick(outp, namespace, space, gr, hm%kick, ions, 0)
1132 if (gr%der%boundaries%spiralBC)
then
1133 gr%der%boundaries%spiral = .
true.
1136 call hm%ks_pot%run_zero_iter(td%tr%vks_old)
1138 if (any(outp%output_interval > 0))
then
1140 call td_write_output(namespace, space, gr, st, hm, ks, outp, ions, ext_partners, 0)
1150 type(
td_t),
intent(in) :: td
1152 type(
ions_t),
intent(inout) :: ions
1154 integer :: iatom, iter, iunit
1158 iunit =
io_open(
'td.general/coordinates', namespace, action=
'read', status=
'old', die=.false.)
1159 if (iunit == -1)
then
1160 message(1) =
"Could not open file '"//trim(
io_workpath(
'td.general/coordinates', namespace))//
"'."
1161 message(2) =
"Starting simulation from initial geometry."
1168 do iter = 0, td%iter - 1
1171 read(iunit,
'(32x)', advance=
'no')
1173 do iatom = 1, ions%natoms
1174 read(iunit,
'(3es24.16)', advance=
'no') ions%pos(:, iatom)
1177 do iatom = 1, ions%natoms
1178 read(iunit,
'(3es24.16)', advance=
'no') ions%vel(:, iatom)
1181 do iatom = 1, ions%natoms
1182 read(iunit,
'(3es24.16)', advance=
'no') ions%tot_force(:, iatom)
1192 subroutine td_dump(td, namespace, space, gr, st, hm, ks, ext_partners, iter, ierr)
1193 type(
td_t),
intent(in) :: td
1195 class(
space_t),
intent(in) :: space
1199 type(
v_ks_t),
intent(in) :: ks
1201 integer,
intent(in) :: iter
1202 integer,
intent(out) :: ierr
1205 integer :: err, err2
1216 message(1) =
"Debug: Writing td restart."
1220 call states_elec_dump(td%restart_dump, space, st, gr, hm%kpoints, err, iter=iter)
1221 if (err /= 0) ierr = ierr + 1
1224 if (err /= 0) ierr = ierr + 1
1227 call lda_u_dump(td%restart_dump, namespace, hm%lda_u, st, gr, ierr)
1228 if (err /= 0) ierr = ierr + 1
1232 if (err2 /= 0) ierr = ierr + 2
1234 call pes_dump(td%pesv, namespace, td%restart_dump, st, gr, err)
1235 if (err /= 0) ierr = ierr + 4
1239 if(
associated(gfield))
then
1243 if (gr%der%boundaries%spiralBC)
then
1245 if (err /= 0) ierr = ierr + 8
1248 if (ks%has_photons)
then
1249 call mf_photons_dump(td%restart_dump, ks%pt_mx, gr, td%dt, ks%pt, err)
1250 if (err /= 0) ierr = ierr + 16
1253 if (ks%xc_photon /= 0)
then
1255 call ks%xc_photons%mf_dump(td%restart_dump, err)
1256 if (err /= 0) ierr = ierr + 32
1259 if (
allocated(st%frozen_rho))
then
1262 if (err /= 0) ierr = ierr + 64
1264 if (td%ions_dyn%ions_move() .or. td%ions_dyn%cell_relax())
then
1267 if (err /= 0) ierr = ierr + 128
1269 message(1) =
"Debug: Writing td restart done."
1276 subroutine td_load(restart, namespace, space, gr, st, hm, ext_partners, td, ks, ierr)
1279 class(
space_t),
intent(in) :: space
1280 type(
grid_t),
intent(in) :: gr
1284 type(
td_t),
intent(inout) :: td
1286 integer,
intent(out) :: ierr
1288 integer :: err, err2
1300 message(1) =
"Debug: Reading td restart."
1304 call states_elec_load(restart, namespace, space, st, gr, hm%kpoints, err, iter=td%iter, label =
": td")
1311 if (err2 /= 0) ierr = ierr + 2
1314 call lda_u_load(restart, hm%lda_u, st, hm%energy%dft_u, ierr)
1315 if (err /= 0) ierr = ierr + 1
1320 if (td%pesv%calc_spm .or. td%pesv%calc_mask .or. td%pesv%calc_flux)
then
1321 call pes_load(td%pesv, namespace, restart, st, err)
1322 if (err /= 0) ierr = ierr + 4
1327 if (
associated(gfield))
then
1332 call hm%update(gr, namespace, space, ext_partners, time = td%dt*td%iter)
1337 if (ks%has_photons)
then
1340 if (err /= 0) ierr = ierr + 16
1342 if (ks%xc_photon /= 0)
then
1343 call ks%xc_photons%mf_load(restart, space, err)
1345 if (err /= 0) ierr = ierr + 32
1347 if (gr%der%boundaries%spiralBC)
then
1354 if (td%ions_dyn%is_active())
then
1357 if (err /= 0) ierr = ierr + 64
1359 message(1) =
"Debug: Reading td restart done."
1366 subroutine td_load_frozen(namespace, restart, space, mesh, st, hm, ierr)
1370 class(
mesh_t),
intent(in) :: mesh
1373 integer,
intent(out) :: ierr
1385 message(1) =
"Debug: Reading td frozen restart."
1388 safe_allocate(st%frozen_rho(1:mesh%np, 1:st%d%nspin))
1390 safe_allocate(st%frozen_tau(1:mesh%np, 1:st%d%nspin))
1391 safe_allocate(st%frozen_gdens(1:mesh%np, 1:space%dim, 1:st%d%nspin))
1392 safe_allocate(st%frozen_ldens(1:mesh%np, 1:st%d%nspin))
1397 message(1) =
"Debug: Reading td frozen restart done."
1405 type(
td_t),
intent(in) :: td
1416 type(
td_t),
intent(inout) :: td
1417 logical,
intent(in) :: from_scratch
1421 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.
type(calc_mode_par_t), public calc_mode_par
Singleton instance of parallel calculation mode.
integer, parameter, public p_strategy_states
parallelization in states
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 electrons_ground_state_run(namespace, mc, gr, ions, ext_partners, st, ks, hm, outp, space, fromScratch)
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)
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)
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)
logical function mpi_grp_is_root(grp)
Is the current MPI process of grpcomm, root.
type(mpi_grp_t), public mpi_world
This module handles the communicators for the various parallelization strategies.
this module contains the low-level part of the output system
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
subroutine, public restart_init(restart, namespace, data_type, type, mc, ierr, mesh, dir, exact)
Initializes a restart object.
integer, parameter, public restart_type_dump
logical pure function, public restart_skip(restart)
Returns true if the restart information should neither be read nor written. This might happen because...
integer, parameter, public restart_td
integer, parameter, public restart_type_load
subroutine, public restart_end(restart)
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_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_dump(restart, space, st, mesh, kpoints, ierr, iter, lr, st_start_writing, verbose)
subroutine, public states_elec_transform(st, namespace, space, restart, mesh, kpoints, prefix)
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_run_init()
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_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
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.