34 use,
intrinsic :: iso_fortran_env
69 logical :: needs_vtau = .false.
71 real(real64),
public,
allocatable :: vhartree(:)
72 real(real64),
public,
allocatable :: vxc(:,:)
73 real(real64),
public,
allocatable :: vhxc(:,:)
76 real(real64),
allocatable :: vtau(:,:)
77 real(real64),
allocatable :: lapl_vtau(:,:)
79 type(accel_mem_t) :: vtau_accel
80 type(accel_mem_t) :: lapl_vtau_accel
82 type(derivatives_t),
pointer :: der => null()
117 real(real64),
public,
allocatable :: vhxc(:,:)
118 real(real64),
allocatable :: vtau(:,:)
119 real(real64),
allocatable :: lapl_vtau(:,:)
128 subroutine ks_potential_init(this, der, np, np_part, nspin, theory_level, needs_vtau)
129 class(ks_potential_t),
intent(inout) :: this
130 type(derivatives_t),
target,
intent(in) :: der
131 integer,
intent(in) :: np, np_part
132 integer,
intent(in) :: nspin
133 integer,
intent(in) :: theory_level
134 logical,
intent(in) :: needs_vtau
138 this%theory_level = theory_level
139 this%needs_vtau = needs_vtau
146 safe_allocate(this%vhxc(1:np, 1:nspin))
147 this%vhxc(1:np, 1:nspin) =
m_zero
151 safe_allocate(this%vhartree(1:np_part))
154 safe_allocate(this%vxc(1:np, 1:nspin))
158 safe_allocate(this%vtau(1:np_part, 1:nspin))
160 safe_allocate(this%lapl_vtau(1:np, 1:nspin))
181 safe_deallocate_a(this%vhxc)
182 safe_deallocate_a(this%vhartree)
183 safe_deallocate_a(this%vxc)
184 safe_deallocate_a(this%vtau)
185 safe_deallocate_a(this%lapl_vtau)
198 real(real64),
contiguous,
intent(in) :: vtau(:,:)
202 assert(this%needs_vtau)
215 integer :: offset, ispin
219 assert(this%needs_vtau)
221 do ispin = 1, this%nspin
227 do ispin = 1, this%nspin
228 call accel_write_buffer(this%vtau_accel, this%np, this%vtau(:, ispin), offset = offset)
229 call accel_write_buffer(this%lapl_vtau_accel, this%np, this%lapl_vtau(:, ispin), offset = offset)
240 real(real64),
contiguous,
intent(inout) :: pot(:,:)
241 integer,
optional,
intent(in) :: nspin
249 assert(
size(pot, dim=1) >= this%np)
250 assert(
size(pot, dim=2) >= nspin_)
264 class(
space_t),
intent(in) :: space
265 class(
mesh_t),
intent(in) :: mesh
266 integer,
intent(out) :: ierr
268 integer :: iunit, err, err2(2), isp
269 character(len=MAX_PATH_LEN) :: filename
270 character(len=100) :: lines(2)
282 message(1) =
"Debug: Writing Vhxc restart."
287 iunit = restart%open(
'vhxc')
288 lines(1) =
'# #spin #nspin filename'
290 call restart%write(iunit, lines, 2, err)
291 if (err /= 0) ierr = ierr + 1
294 do isp = 1, this%nspin
296 write(lines(1),
'(i8,a,i8,a)') isp,
' | ', this%nspin,
' | "'//trim(adjustl(filename))//
'"'
297 call restart%write(iunit, lines, 1, err)
298 if (err /= 0) err2(1) = err2(1) + 1
300 call restart%write_mesh_function(space, filename, mesh, this%vhxc(:,isp), err)
301 if (err /= 0) err2(2) = err2(2) + 1
304 if (err2(1) /= 0) ierr = ierr + 2
305 if (err2(2) /= 0) ierr = ierr + 4
308 call restart%write(iunit, lines, 1, err)
309 if (err /= 0) ierr = ierr + 4
312 if (this%needs_vtau)
then
313 lines(1) =
'# #spin #nspin filename'
315 call restart%write(iunit, lines, 2, err)
316 if (err /= 0) ierr = ierr + 8
319 do isp = 1, this%nspin
321 write(lines(1),
'(i8,a,i8,a)') isp,
' | ', this%nspin,
' | "'//trim(adjustl(filename))//
'"'
322 call restart%write(iunit, lines, 1, err)
323 if (err /= 0) err2(1) = err2(1) + 16
325 call restart%write_mesh_function(space, filename, mesh, this%vtau(:,isp), err)
326 if (err /= 0) err2(1) = err2(1) + 1
329 if (err2(1) /= 0) ierr = ierr + 32
330 if (err2(2) /= 0) ierr = ierr + 64
333 call restart%write(iunit, lines, 1, err)
334 if (err /= 0) ierr = ierr + 128
337 call restart%close(iunit)
340 message(1) =
"Debug: Writing Vhxc restart done."
353 class(
space_t),
intent(in) :: space
354 class(
mesh_t),
intent(in) :: mesh
355 integer,
intent(out) :: ierr
357 integer :: err, err2, isp
358 character(len=MAX_PATH_LEN) :: filename
371 message(1) =
"Debug: Reading Vhxc restart."
376 do isp = 1, this%nspin
379 call restart%read_mesh_function(space, filename, mesh, this%vhxc(:,isp), err)
380 if (err /= 0) err2 = err2 + 1
383 if (err2 /= 0) ierr = ierr + 1
387 if (this%needs_vtau)
then
388 do isp = 1, this%nspin
391 call restart%read_mesh_function(space, filename, mesh, this%vtau(:,isp), err)
392 if (err /= 0) err2 = err2 + 1
396 if (err2 /= 0) ierr = ierr + 2
400 message(1) =
"Debug: Reading Vhxc restart done."
411 integer,
optional,
intent(in) :: order
436 real(real64),
intent(in) :: current_time
437 real(real64),
intent(in) :: dt
452 integer,
intent(in) :: history
459 if (.not.
present(storage))
then
460 if (this%needs_vtau)
then
468 if (this%needs_vtau)
then
482 integer,
intent(in) :: history
488 if (this%needs_vtau)
then
502 integer,
intent(in) :: order
503 real(real64),
intent(in) :: current_time
504 real(real64),
intent(in) :: dt
505 real(real64),
intent(in) :: interpolation_time
511 if (this%needs_vtau)
then
513 this%vhxc, vtau = this%vtau)
565 integer(int64),
intent(in) :: how
566 character(len=*),
intent(in) :: dir
567 class(
space_t),
intent(in) :: space
568 class(
mesh_t),
intent(in) :: mesh
569 real(real64),
optional,
intent(in) :: pos(:,:)
570 type(
atom_t),
optional,
intent(in) :: atoms(:)
571 type(
mpi_grp_t),
optional,
intent(in) :: grp
573 character(len=MAX_PATH_LEN) :: fname
579 space, mesh, this%vhartree,
units_out%energy, err, pos=pos, atoms=atoms, grp = grp)
581 do is = 1, this%nspin
584 mesh, this%vxc(:, is),
units_out%energy, err, pos=pos, atoms=atoms, grp = grp)
586 if (this%needs_vtau)
then
589 mesh, this%vtau(:, is),
units_out%energy, err, pos=pos, atoms=atoms, grp = grp)
603 if (.not.
allocated(copy%vhxc))
then
604 safe_allocate(copy%vhxc(1:this%np, 1:this%nspin))
606 if (this%needs_vtau)
then
607 if (.not.
allocated(copy%vtau))
then
608 safe_allocate(copy%vtau(1:this%np, 1:this%nspin))
625 call lalg_copy(this%np, this%nspin, this%vhxc, copy%vhxc)
626 if (this%needs_vtau)
then
627 call lalg_copy(this%np, this%nspin, this%vtau, copy%vtau)
642 assert(
allocated(copy%vhxc))
643 call lalg_copy(this%np, this%nspin, copy%vhxc, this%vhxc)
644 if (this%needs_vtau)
then
645 assert(
allocated(copy%vtau))
646 call this%set_vtau(copy%vtau)
655 integer(int64),
intent(in) :: np
656 integer,
intent(in) :: nspin
657 integer(int64),
intent(in) :: pnp
675 safe_deallocate_a(this%vhxc)
676 safe_deallocate_a(this%vtau)
685 real(real64) function ks_potential_check_convergence(this, copy, mesh, rho, qtot) result(diff)
688 class(
mesh_t),
intent(in) :: mesh
689 real(real64),
intent(in) :: rho(:,:)
690 real(real64),
intent(in) :: qtot
692 real(real64),
allocatable :: diff_pot(:)
695 push_sub(ks_potential_check_convergence)
697 safe_allocate(diff_pot(1:this%np))
702 diff_pot(ip) = abs(copy%vhxc(ip, 1) - this%vhxc(ip, 1))*rho(ip, 1)
704 do is = 2, this%nspin
707 diff_pot(ip) = diff_pot(ip) + abs(copy%vhxc(ip, is) - this%vhxc(ip, is))*rho(ip, is)
713 safe_deallocate_a(diff_pot)
715 pop_sub(ks_potential_check_convergence)
721 type(potential_interpolation_t),
intent(inout) :: vksold
722 real(real64),
intent(in) :: times(:)
723 real(real64),
intent(in) :: current_time
727 assert(
size(times) == 3)
729 call interpolate(times, vksold%v_old(:, :, 1:3), current_time, vksold%v_old(:, :, 0))
730 if (this%needs_vtau)
then
731 call interpolate(times, vksold%vtau_old(:, :, 1:3), current_time, vksold%vtau_old(:, :, 0))
741 real(real64),
intent(in) :: dt
747 assert(not_in_openmp())
750 do ispin = 1, this%nspin
753 vold%vhxc(ip, ispin) = m_half*dt*(this%vhxc(ip, ispin) - vold%vhxc(ip, ispin))
756 if (this%needs_vtau)
then
759 vold%vtau(ip, ispin) = m_half*dt*(this%vtau(ip, ispin) - vold%vtau(ip, ispin))
770#include "complex.F90"
771#include "ks_potential_inc.F90"
775#include "ks_potential_inc.F90"
constant times a vector plus a vector
Copies a vector x, to a vector y.
subroutine, public accel_release_buffer(this, async)
pure logical function, public accel_is_enabled()
integer, parameter, public accel_mem_read_only
type(debug_t), save, public debug
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
subroutine, public dderivatives_lapl(der, ff, op_ff, ghost_update, set_bc, factor)
apply the Laplacian to a mesh function
real(real64), parameter, public m_zero
integer, parameter, public independent_particles
Theory level.
logical pure function, public not_in_openmp()
real(real64), parameter, public m_one
subroutine, public dio_function_output(how, dir, fname, namespace, space, mesh, ff, unit, ierr, pos, atoms, grp, root)
Top-level IO routine for functions defined on the mesh.
A module to handle KS potential, without the external potential.
subroutine ks_potential_set_interpolated_potentials(this, vksold, history)
Set the interpolated potentials to history.
subroutine zks_potential_current_mass_renormalization(this, gpsi, space_dim, ndim, ispin)
Nonlocal contribution of vtau for the current.
subroutine dks_potential_apply_lapl_vtau_psi(this, mesh, d, ispin, psib, vpsib)
Wrapper to hamiltonian_elec_base_local_sub to hide the data of lapl_vtau.
subroutine ks_potential_add_vhxc(this, pot, nspin)
Adds vHxc to the potential.
subroutine dks_potential_current_mass_renormalization(this, gpsi, space_dim, ndim, ispin)
Nonlocal contribution of vtau for the current.
subroutine ks_potential_load_vhxc(this, restart, space, mesh, ierr)
Loads the vhxc potentials.
subroutine, public vtau_set_vin(field, this)
subroutine ks_potential_get_interpolated_potentials(this, vksold, history, storage)
Get the interpolated potentials from history.
subroutine zks_potential_apply_vtau_psi(this, mesh, d, ispin, psib, vpsib)
Wrapper to hamiltonian_elec_base_local_sub to hide the data of vtau.
subroutine, public vtau_set_vout(field, this)
subroutine zks_potential_mult_vhxc(this, mf, ispin)
Multiply a mesh function by vHxc.
subroutine ks_potential_init(this, der, np, np_part, nspin, theory_level, needs_vtau)
Allocate the memory for the KS potentials.
subroutine ks_potential_interpolate_potentials(this, vksold, order, current_time, dt, interpolation_time)
Interpolate potentials to a new time.
subroutine ks_potential_update_vtau_buffer(this)
Update vtau GPU buffer.
subroutine ks_potential_run_zero_iter(this, vksold)
Run zero iter for the interpolation.
subroutine ks_potential_store_copy(this, copy)
Copy the potentials to a storage object.
subroutine ks_potential_mix_potentials(this, vold, dt)
Replace vold potentials by 0.5*dt(vold + vhxc)
subroutine ks_potential_perform_interpolation(this, vksold, times, current_time)
Perform a time interpolation of the potentials.
subroutine, public vtau_get_vnew(field, this)
subroutine ks_potential_init_interpolation(this, vksold, order)
Initialize the potential interpolation.
real(real64) function ks_potential_check_convergence(this, copy, mesh, rho, qtot)
Check the convergence of a vhxc for predictor-corrector.
subroutine ks_potential_restore_copy(this, copy)
Copy the potentials from a storage object.
subroutine ks_potential_storage_allocate(this, copy)
Copy the potentials to a storage object.
subroutine ks_potential_interpolation_new(this, vksold, current_time, dt)
New interpolation point for the interpolation.
subroutine ks_potential_end(this)
Releases the memory for the KS potentials.
subroutine dks_potential_mult_vhxc(this, mf, ispin)
Multiply a mesh function by vHxc.
subroutine, public xc_copied_potentials_end(this)
Finalizer for the copied potentials.
subroutine ks_potential_dump_vhxc(this, restart, space, mesh, ierr)
Dumps the vhxc potentials.
subroutine dks_potential_apply_vtau_psi(this, mesh, d, ispin, psib, vpsib)
Wrapper to hamiltonian_elec_base_local_sub to hide the data of vtau.
subroutine ks_potential_set_vtau(this, vtau)
Set vtau and update the corresponding GPU buffer.
subroutine xc_copied_potentials_copy_vhxc_to_buffer(this, np, nspin, pnp, buffer)
Copy the vhxc potential to a gpu buffer.
subroutine ks_potential_output_potentials(this, namespace, how, dir, space, mesh, pos, atoms, grp)
Outputs vh, vxc, and vtau potentials.
subroutine zks_potential_apply_lapl_vtau_psi(this, mesh, d, ispin, psib, vpsib)
Wrapper to hamiltonian_elec_base_local_sub to hide the data of lapl_vtau.
This module is intended to contain "only mathematical" functions and procedures.
This module defines various routines, operating on mesh functions.
This module defines the meshes, which are used in Octopus.
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
this module contains the low-level part of the output system
character(len=max_path_len) function, public get_filename_with_spin(output, nspin, spin_index)
Returns the filame as output, or output-spX is spin polarized.
subroutine, public potential_interpolation_interpolate(potential_interpolation, order, time, dt, t, vhxc, vtau)
subroutine, public potential_interpolation_set(potential_interpolation, np, nspin, i, vhxc, vtau)
subroutine, public potential_interpolation_new(potential_interpolation, np, nspin, time, dt, vhxc, vtau)
subroutine, public potential_interpolation_run_zero_iter(potential_interpolation, np, nspin, vhxc, vtau)
subroutine, public potential_interpolation_get(potential_interpolation, np, nspin, i, vhxc, vtau)
subroutine, public potential_interpolation_init(potential_interpolation, np, nspin, mgga_with_exc, order)
This module handles spin dimensions of the states and the k-point distribution.
type(type_t), public type_float
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
Describes mesh distribution to nodes.
Quantities used in mixing: Input, output and new potentials, and the residuals.
This is defined even when running serial.