72 subroutine td_etrs(ks, namespace, space, hm, ext_partners, gr, st, tr, time, dt, &
74 type(v_ks_t),
intent(inout) :: ks
75 type(namespace_t),
intent(in) :: namespace
76 type(electron_space_t),
intent(in) :: space
77 type(hamiltonian_elec_t),
intent(inout) :: hm
78 type(partner_list_t),
intent(in) :: ext_partners
79 type(grid_t),
intent(inout) :: gr
80 type(states_elec_t),
intent(inout) :: st
81 type(propagator_base_t),
intent(inout) :: tr
82 real(real64),
intent(in) :: time
83 real(real64),
intent(in) :: dt
84 type(ion_dynamics_t),
intent(inout) :: ions_dyn
85 type(ions_t),
intent(inout) :: ions
86 type(multicomm_t),
intent(inout) :: mc
88 type(xc_copied_potentials_t) :: vhxc_t1, vhxc_t2
89 type(gauge_field_t),
pointer :: gfield
95 call hm%ks_pot%store_potentials(vhxc_t1)
99 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
100 calc_current = .false., calc_energy = .false., calc_eigenval = .false.)
102 call hm%ks_pot%store_potentials(vhxc_t2)
103 call hm%ks_pot%restore_potentials(vhxc_t1)
104 call hm%update(gr, namespace, space, ext_partners, time = time - dt)
116 ext_partners, mc, time, dt)
119 if(
associated(gfield))
then
123 call hm%ks_pot%restore_potentials(vhxc_t2)
135 subroutine td_etrs_sc(ks, namespace, space, hm, ext_partners, gr, st, tr, time, dt, &
136 ions_dyn, ions, mc, sctol, scsteps)
137 type(v_ks_t),
intent(inout) :: ks
138 type(namespace_t),
intent(in) :: namespace
139 type(electron_space_t),
intent(in) :: space
140 type(hamiltonian_elec_t),
intent(inout) :: hm
141 type(partner_list_t),
intent(in) :: ext_partners
142 type(grid_t),
intent(inout) :: gr
143 type(states_elec_t),
intent(inout) :: st
144 type(propagator_base_t),
intent(inout) :: tr
145 real(real64),
intent(in) :: time
146 real(real64),
intent(in) :: dt
147 type(ion_dynamics_t),
intent(inout) :: ions_dyn
148 type(ions_t),
intent(inout) :: ions
149 type(multicomm_t),
intent(inout) :: mc
150 real(real64),
intent(in) :: sctol
151 integer,
optional,
intent(out) :: scsteps
154 integer :: ik, ib, iter
155 class(wfs_elec_t),
allocatable :: psi2(:, :)
157 integer,
parameter :: niter = 10
158 type(gauge_field_t),
pointer :: gfield
159 type(xc_copied_potentials_t) :: vhxc_t1, vhxc_t2
165 call hm%ks_pot%store_potentials(vhxc_t1)
174 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
175 calc_current = .false., calc_energy = .false., calc_eigenval = .false.)
178 call hm%ks_pot%store_potentials(vhxc_t2)
179 call hm%ks_pot%restore_potentials(vhxc_t1)
187 ext_partners, mc, time, dt)
190 if(
associated(gfield))
then
194 call hm%ks_pot%restore_potentials(vhxc_t2)
198 safe_allocate_type_array(
wfs_elec_t, psi2, (st%group%block_start:st%group%block_end, st%d%kpt%start:st%d%kpt%end))
201 do ik = st%d%kpt%start, st%d%kpt%end
202 do ib = st%group%block_start, st%group%block_end
203 call st%group%psib(ib, ik)%copy_to(psi2(ib, ik), copy_data=.
true.)
209 call hm%ks_pot%store_potentials(vhxc_t2)
213 call v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, &
214 time = time, calc_current = .false., calc_energy = .false., calc_eigenval = .false.)
218 diff = hm%ks_pot%check_convergence(vhxc_t2, gr, st%rho, st%qtot)
226 if (diff <= sctol)
exit
228 if (iter /= niter)
then
230 do ik = st%d%kpt%start, st%d%kpt%end
231 do ib = st%group%block_start, st%group%block_end
232 call psi2(ib, ik)%copy_data_to(gr%np, st%group%psib(ib, ik))
247 if (
present(scsteps)) scsteps = iter
249 do ik = st%d%kpt%start, st%d%kpt%end
250 do ib = st%group%block_start, st%group%block_end
251 call psi2(ib, ik)%end()
255 safe_deallocate_a(psi2)
262 subroutine td_aetrs(namespace, space, hm, gr, st, tr, time, dt, ions_dyn, ions, ext_partners, mc)
266 type(
grid_t),
intent(inout) :: gr
269 real(real64),
intent(in) :: time
270 real(real64),
intent(in) :: dt
272 type(
ions_t),
intent(inout) :: ions
288 ions, ext_partners, mc, time, dt)
292 if(
associated(gfield))
then
307 subroutine td_caetrs(ks, namespace, space, hm, ext_partners, gr, st, tr, time, dt, &
309 type(
v_ks_t),
intent(inout) :: ks
314 type(
grid_t),
intent(inout) :: gr
317 real(real64),
intent(in) :: time
318 real(real64),
intent(in) :: dt
320 type(
ions_t),
intent(inout) :: ions
323 integer :: ik, ispin, ip, ist, ib
325 complex(real64) :: phase
327 integer(int64) :: pnp, wgsize, dim2, dim3
335 call hm%ks_pot%get_interpolated_potentials(tr%vks_old, 2, storage=vold)
337 call hm%ks_pot%restore_potentials(vold)
341 call v_ks_calc_start(ks, namespace, space, hm, st, ions, ions%latt, ext_partners, &
342 time = time - dt, calc_energy = .false., calc_current = .false.)
347 call v_ks_calc_finish(ks, hm, namespace, space, ions%latt, st, ext_partners)
349 call hm%ks_pot%set_interpolated_potentials(tr%vks_old, 1)
351 call hm%ks_pot%perform_interpolation(tr%vks_old, (/time - dt, time -
m_two*dt, time -
m_three*dt/), time)
354 call hm%ks_pot%mix_potentials(vold, dt)
363 call vold%copy_vhxc_to_buffer(int(gr%np, int64), st%d%nspin, pnp, phase_buff)
371 ions, ext_partners, mc, time, dt)
374 if(
associated(gfield))
then
383 do ik = st%d%kpt%start, st%d%kpt%end
384 ispin = st%d%get_spin_index(ik)
386 do ib = st%group%block_start, st%group%block_end
387 if (hm%apply_packed())
then
388 call st%group%psib(ib, ik)%do_pack()
393 select case (st%group%psib(ib, ik)%status())
396 vv = vold%vhxc(ip, ispin)
397 phase = cmplx(
cos(vv), -
sin(vv), real64)
398 do ist = 1, st%group%psib(ib, ik)%nst_linear
399 st%group%psib(ib, ik)%zff_linear(ip, ist) = st%group%psib(ib, ik)%zff_linear(ip, ist)*phase
404 vv = vold%vhxc(ip, ispin)
405 phase = cmplx(
cos(vv), -
sin(vv), real64)
406 do ist = 1, st%group%psib(ib, ik)%nst_linear
407 st%group%psib(ib, ik)%zff_pack(ist, ip) = st%group%psib(ib, ik)%zff_pack(ist, ip)*phase
421 (/st%group%psib(ib, ik)%pack_size(1), wgsize, 1_int64/))
426 call hm%phase%set_phase_corr(gr, st%group%psib(ib, ik))
428 call tr%te%apply_batch(namespace, gr, hm, st%group%psib(ib, ik),
m_half*dt, &
429 inh_psib = hm%inh_st%group%psib(ib, ik))
431 call tr%te%apply_batch(namespace, gr, hm, st%group%psib(ib, ik),
m_half*dt)
433 call hm%phase%unset_phase_corr(gr, st%group%psib(ib, ik))
437 if (hm%apply_packed())
then
438 call st%group%psib(ib, ik)%do_unpack()
double sin(double __x) __attribute__((__nothrow__
double cos(double __x) __attribute__((__nothrow__
integer pure function, public accel_max_size_per_dim(dim)
subroutine, public accel_release_buffer(this)
type(accel_kernel_t), target, save, public kernel_phase
pure logical function, public accel_is_enabled()
integer, parameter, public accel_mem_read_only
integer pure function, public accel_max_workgroup_size()
This module implements batches of mesh functions.
integer, parameter, public batch_not_packed
functions are stored in CPU memory, unpacked order
integer, parameter, public batch_device_packed
functions are stored in device memory in packed order
integer, parameter, public batch_packed
functions are stored in CPU memory, in transposed (packed) order
This module implements a calculator for the density and defines related functions.
subroutine, public density_calc_end(this, allreduce, symmetrize)
Finalize the density calculation.
subroutine, public density_calc_accumulate(this, psib, async)
Accumulate weighted orbital densities for a batch psib.
subroutine, public density_calc_init(this, st, gr, density)
initialize the density calculator
type(gauge_field_t) function, pointer, public list_get_gauge_field(partners)
real(real64), parameter, public m_two
real(real64), parameter, public m_half
real(real64), parameter, public m_three
This module implements the underlying real-space grid.
pure logical function, public hamiltonian_elec_inh_term(hm)
This module defines classes and functions for interaction partners.
A module to handle KS potential, without the external potential.
integer, parameter, public independent_particles
subroutine, public lda_u_write_u(this, iunit, namespace)
subroutine, public lda_u_write_v(this, iunit, namespace)
integer, parameter, public dft_u_none
subroutine, public lda_u_update_occ_matrices(this, namespace, mesh, st, hm_base, phase, energy)
This module is intended to contain "only mathematical" functions and procedures.
This module defines various routines, operating on mesh functions.
subroutine, public messages_not_implemented(feature, namespace)
subroutine, public messages_new_line()
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
This module handles the communicators for the various parallelization strategies.
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 propagation_ops_elec_propagate_gauge_field(wo, gfield, dt, time, save_gf)
subroutine, public propagation_ops_elec_update_hamiltonian(namespace, space, st, mesh, hm, ext_partners, time)
subroutine, public propagation_ops_elec_exp_apply(te, namespace, st, mesh, hm, dt)
subroutine, public propagation_ops_elec_interpolate_get(hm, mesh, vks_old)
subroutine, public propagation_ops_elec_move_ions(wo, gr, hm, st, namespace, space, ions_dyn, ions, ext_partners, mc, time, dt, save_pos)
subroutine, public propagation_ops_elec_fuse_density_exp_apply(te, namespace, st, gr, hm, dt, dt2, vmagnus)
subroutine, public td_aetrs(namespace, space, hm, gr, st, tr, time, dt, ions_dyn, ions, ext_partners, mc)
Propagator with approximate enforced time-reversal symmetry.
subroutine, public td_etrs_sc(ks, namespace, space, hm, ext_partners, gr, st, tr, time, dt, ions_dyn, ions, mc, sctol, scsteps)
Propagator with enforced time-reversal symmetry and self-consistency.
subroutine, public td_etrs(ks, namespace, space, hm, ext_partners, gr, st, tr, time, dt, ions_dyn, ions, mc)
Propagator with enforced time-reversal symmetry.
subroutine, public td_caetrs(ks, namespace, space, hm, ext_partners, gr, st, tr, time, dt, ions_dyn, ions, mc)
Propagator with approximate enforced time-reversal symmetry.
This module handles spin dimensions of the states and the k-point distribution.
type(type_t), public type_float
subroutine, public v_ks_calc_finish(ks, hm, namespace, space, latt, st, ext_partners, force_semilocal)
subroutine, public v_ks_calc_start(ks, namespace, space, hm, st, ions, latt, ext_partners, time, calc_energy, calc_current, force_semilocal)
This routine starts the calculation of the Kohn-Sham potential. The routine v_ks_calc_finish must be ...
subroutine, public v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval, time, calc_energy, calc_current, force_semilocal)
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.
Stores all communicators and groups.
The states_elec_t class contains all electronic wave functions.
batches of electronic states