48 use,
intrinsic :: iso_fortran_env
144 type(space_t),
private :: space
145 type(states_elec_dim_t) :: d
146 type(hamiltonian_elec_base_t) :: hm_base
147 type(phase_t) :: phase
148 type(energy_t),
allocatable :: energy
149 type(absorbing_boundaries_t) :: abs_boundaries
150 type(ks_potential_t) :: ks_pot
151 real(real64),
allocatable :: vberry(:,:)
153 type(derivatives_t),
pointer,
private :: der
155 type(nonlocal_pseudopotential_t) :: vnl
156 type(nonlocal_pseudopotential_t) :: aug_overlap
157 type(nonlocal_pseudopotential_t) :: aug_inverse_overlap
159 type(ions_t),
pointer :: ions
160 logical,
private :: owns_ions = .false.
161 logical,
private :: is_copy_snapshot = .false.
162 real(real64) :: exx_coef
164 class(poisson_t),
allocatable :: psolver
167 logical :: self_induced_magnetic
168 real(real64),
allocatable :: a_ind(:, :)
169 real(real64),
allocatable :: b_ind(:, :)
171 integer :: theory_level
172 type(xc_t),
pointer :: xc
173 type(xc_photons_t),
pointer :: xc_photons
175 class(epot_t),
allocatable :: ep
176 class(pcm_t),
allocatable :: pcm
179 logical,
private :: adjoint
182 real(real64),
private :: mass
185 logical,
private :: inh_term
186 class(states_elec_t),
allocatable :: inh_st
190 type(oct_exchange_t) :: oct_exchange
192 class(scissor_t),
allocatable :: scissor
194 real(real64) :: current_time
195 logical,
private :: is_applied_packed
198 class(lda_u_t),
allocatable :: lda_u
199 integer :: lda_u_level
201 logical,
public :: time_zero
203 class(exchange_operator_t),
allocatable,
public :: exxop
205 type(kpoints_t),
pointer,
public :: kpoints => null()
207 type(partner_list_t) :: external_potentials
208 real(real64),
allocatable,
public :: v_ext_pot(:)
209 real(real64),
allocatable,
public :: v_static(:)
211 type(ion_electron_local_potential_t) :: v_ie_loc
214 type(magnetic_constrain_t) :: magnetic_constrain
234 integer,
public,
parameter :: &
242 subroutine hamiltonian_elec_init(hm, namespace, space, gr, ions, ext_partners, st, theory_level, xc, &
243 mc, kpoints, need_exchange, xc_photons)
246 class(
space_t),
intent(in) :: space
247 type(
grid_t),
target,
intent(inout) :: gr
248 type(
ions_t),
target,
intent(inout) :: ions
251 integer,
intent(in) :: theory_level
252 type(
xc_t),
target,
intent(in) :: xc
255 logical,
optional,
intent(in) :: need_exchange
256 type(
xc_photons_t),
optional,
target,
intent(in) :: xc_photons
259 logical :: need_exchange_
260 real(real64) :: rashba_coupling
265 safe_allocate(hm%lda_u)
266 safe_allocate(hm%exxop)
267 safe_allocate(hm%psolver)
268 safe_allocate(hm%scissor)
269 safe_allocate(hm%inh_st)
271 safe_allocate(hm%pcm)
272 safe_allocate(hm%lda_u%basis)
277 hm%theory_level = theory_level
280 hm%kpoints => kpoints
306 if (space%dim /= 2)
then
307 write(
message(1),
'(a)')
'Rashba spin-orbit coupling can only be used for two-dimensional systems.'
313 call hm%hm_base%init(hm%d%nspin, hm%mass, rashba_coupling)
315 call hm%aug_overlap%init()
316 call hm%aug_inverse_overlap%init()
318 assert(
associated(gr%der%lapl))
319 hm%hm_base%kinetic => gr%der%lapl
321 safe_allocate(hm%energy)
326 hm%owns_ions = .false.
327 hm%is_copy_snapshot = .false.
330 if(
present(xc_photons))
then
331 hm%xc_photons => xc_photons
333 hm%xc_photons => null()
342 call poisson_init(hm%psolver, namespace, space, gr%der, mc, gr%stencil, st%qtot)
345 call epot_init(hm%ep, namespace, gr, hm%ions, hm%psolver, hm%d%ispin, hm%xc%family, hm%kpoints)
346 st%requires_generalized_overlap = hm%ep%requires_generalized_overlap
351 if (hm%ep%requires_generalized_overlap)
then
352 if (gr%use_curvilinear)
then
374 call parse_variable(namespace,
'USPPSaveMemory', .false., hm%vnl%uspp_save_memory)
375 hm%aug_overlap%uspp_save_memory = hm%vnl%uspp_save_memory
376 hm%aug_inverse_overlap%uspp_save_memory = hm%vnl%uspp_save_memory
378 call kick_init(hm%kick, namespace, space, hm%kpoints, hm%d%ispin)
380 hm%zora =>
zora_t(namespace, hm%der, hm%d, hm%ep, hm%mass)
383 call hm%v_ie_loc%init(gr, hm%psolver, hm%ions, namespace)
385 call hm%nlcc%init(gr, hm%ions, hm%ep%dgrid)
386 safe_allocate(st%rho_core(1:gr%np))
419 call parse_variable(namespace,
'CalculateSelfInducedMagneticField', .false., hm%self_induced_magnetic)
420 if (hm%self_induced_magnetic)
then
421 safe_allocate(hm%a_ind(1:gr%np_part, 1:space%dim))
422 safe_allocate(hm%b_ind(1:gr%np_part, 1:space%dim))
430 hm%inh_term = .false.
435 call hm%phase%init(gr, hm%d%kpt, hm%kpoints, st%d, space)
455 call lda_u_init(hm%lda_u, namespace, space, hm%lda_u_level, gr, ions, st, mc, hm%kpoints)
464 if(hm%lda_u_level /=
dft_u_none .and. hm%phase%is_allocated())
then
479 call parse_variable(namespace,
'HamiltonianApplyPacked', .
true., hm%is_applied_packed)
481 if (hm%theory_level ==
hartree_fock .and. st%parallel_in_states)
then
486 .and. st%parallel_in_states)
then
505 if (hm%xc%compute_exchange(hm%theory_level) .or. need_exchange_)
then
510 else if (
bitand(hm%xc%family, xc_family_oep) /= 0 .or. hm%theory_level ==
rdmft)
then
512 hm%kpoints, hm%xc%cam)
513 if (hm%theory_level ==
rdmft) hm%exxop%useACE = .false.
522 if (gr%use_curvilinear)
then
524 hm%is_applied_packed = .false.
525 call messages_write(
'Cannot use GPUs as curvilinear coordinates are used.')
528 call messages_write(
'Cannot use GPUs as curvilinear coordinates are used.', new_line = .
true.)
529 call messages_write(
'Calculation will not be continued. To force execution, set AllowCPUonly = yes.')
559 if (
associated(hm%xc_photons))
then
560 if (hm%xc_photons%wants_to_renormalize_mass())
then
562 call hm%set_mass(namespace, hm%xc_photons%get_renormalized_mass())
566 if (hm%xc%compute_exchange(hm%theory_level) .or. need_exchange_)
call hm%exxop%write_info(namespace)
576 class(*),
pointer :: potential
581 safe_allocate(hm%v_ext_pot(1:gr%np))
582 hm%v_ext_pot(1:gr%np) =
m_zero
584 call iter%start(hm%external_potentials)
585 do while (iter%has_next())
586 potential => iter%get_next()
587 select type (potential)
590 call potential%allocate_memory(gr)
591 call potential%calculate(namespace, gr, hm%psolver)
594 select case (potential%type)
600 message(1) =
"Cannot use static magnetic field with real wavefunctions"
604 if (.not.
allocated(hm%ep%b_field))
then
605 safe_allocate(hm%ep%b_field(1:3))
606 hm%ep%b_field(1:3) =
m_zero
608 hm%ep%b_field(1:3) = hm%ep%b_field(1:3) + potential%b_field(1:3)
610 if (.not.
allocated(hm%ep%a_static))
then
611 safe_allocate(hm%ep%a_static(1:gr%np, 1:space%dim))
612 hm%ep%a_static(1:gr%np, 1:space%dim) =
m_zero
614 call lalg_axpy(gr%np, space%dim,
m_one, potential%a_static, hm%ep%a_static)
617 if (.not.
allocated(hm%ep%e_field))
then
618 safe_allocate(hm%ep%e_field(1:space%dim))
619 hm%ep%e_field(1:space%dim) =
m_zero
621 hm%ep%e_field(1:space%dim) = hm%ep%e_field(1:space%dim) + potential%e_field(1:space%dim)
624 if (space%periodic_dim < space%dim)
then
625 if (.not.
allocated(hm%v_static))
then
626 safe_allocate(hm%v_static(1:gr%np))
627 hm%v_static(1:gr%np) =
m_zero
629 if (.not.
allocated(hm%ep%v_ext))
then
630 safe_allocate(hm%ep%v_ext(1:gr%np_part))
631 hm%ep%v_ext(1:gr%np_part) =
m_zero
637 if (hm%kpoints%use_symmetries)
then
641 message(1) =
"The StaticElectricField breaks (at least) one of the symmetries used to reduce the k-points."
642 message(2) =
"Set SymmetryBreakDir equal to StaticElectricField."
649 call potential%deallocate_memory()
662 class(*),
pointer :: potential
666 call iter%start(hm%external_potentials)
667 do while (iter%has_next())
668 potential => iter%get_next()
669 select type (potential)
673 message(1) =
"Applying StaticElectricField in a periodic direction is only accurate for large supercells."
674 message(2) =
"Single-point Berry phase is not appropriate when k-point sampling is needed."
690 logical :: external_potentials_present
691 logical :: kick_present
695 if (
allocated(hm%ep%e_field) .and. space%is_periodic() .and. .not.
list_has_gauge_field(ext_partners))
then
698 if (any(abs(hm%ep%e_field(1:space%periodic_dim)) >
m_epsilon))
then
699 safe_allocate(hm%vberry(1:gr%np, 1:hm%d%nspin))
710 call pcm_init(hm%pcm, namespace, space, ions, gr, st%qtot, st%val_charge, external_potentials_present, kick_present)
711 if (hm%pcm%run_pcm)
then
734 if (hm%is_copy_snapshot)
then
737 if (
allocated(hm%lda_u))
then
738 safe_deallocate_a(hm%lda_u%basis)
740 safe_deallocate_a(hm%lda_u)
741 safe_deallocate_a(hm%exxop)
742 safe_deallocate_a(hm%psolver)
743 safe_deallocate_a(hm%scissor)
744 safe_deallocate_a(hm%inh_st)
745 safe_deallocate_a(hm%ep)
746 safe_deallocate_a(hm%pcm)
751 call hm%hm_base%end()
753 call hm%aug_overlap%end()
754 call hm%aug_inverse_overlap%end()
759 safe_deallocate_a(hm%vberry)
760 safe_deallocate_a(hm%a_ind)
761 safe_deallocate_a(hm%b_ind)
762 safe_deallocate_a(hm%v_ext_pot)
764 safe_deallocate_p(hm%zora)
772 if (hm%owns_ions .and.
associated(hm%ions))
then
775 if (
allocated(hm%ions%species))
then
776 safe_deallocate_a(hm%ions%species)
779 safe_deallocate_p(hm%ions)
780 hm%owns_ions = .false.
783 hm%owns_ions = .false.
795 safe_deallocate_a(hm%energy)
797 if (hm%pcm%run_pcm)
call pcm_end(hm%pcm)
799 call hm%v_ie_loc%end()
802 call iter%start(hm%external_potentials)
803 do while (iter%has_next())
804 potential => iter%get_next()
805 safe_deallocate_p(potential)
807 call hm%external_potentials%empty()
808 safe_deallocate_a(hm%v_static)
814 hm%is_copy_snapshot = .false.
816 if (
allocated(hm%lda_u))
then
817 safe_deallocate_a(hm%lda_u%basis)
819 safe_deallocate_a(hm%lda_u)
820 safe_deallocate_a(hm%exxop)
821 safe_deallocate_a(hm%psolver)
822 safe_deallocate_a(hm%scissor)
823 safe_deallocate_a(hm%inh_st)
824 safe_deallocate_a(hm%ep)
825 safe_deallocate_a(hm%pcm)
842 if (hm%owns_ions .and.
associated(hm%ions))
then
843 if (
allocated(hm%ions%species))
then
844 safe_deallocate_a(hm%ions%species)
847 safe_deallocate_p(hm%ions)
848 hm%owns_ions = .false.
851 hm%owns_ions = .false.
854 if (
associated(hm%zora))
then
855 safe_deallocate_p(hm%zora)
858 call iter%start(hm%external_potentials)
859 do while (iter%has_next())
860 potential => iter%get_next()
861 safe_deallocate_p(potential)
863 call hm%external_potentials%empty()
865 call hm%hm_base%end()
869 call hm%aug_overlap%end()
870 call hm%aug_inverse_overlap%end()
873 hm%is_copy_snapshot = .false.
889 type(
ions_t),
pointer :: ions_out
890 type(
zora_t),
pointer :: zora_out
894 class(*),
pointer :: ptr
896 logical :: runtime_initialized
901 runtime_initialized =
associated(hm_in%kpoints)
903 call iter%start(hm_in%external_potentials)
904 do while (iter%has_next())
905 ptr => iter%get_next()
908 call external_potentials_in%add(ptr)
910 call external_potentials_out%add(ext_pot)
915 call hm_in%external_potentials%empty()
918 hm_out%is_copy_snapshot = .
true.
925 if (
accel_is_enabled() .and. runtime_initialized .and.
associated(hm_out%der))
then
934 call hm_out%external_potentials%empty()
935 call iter%start(external_potentials_out)
936 do while (iter%has_next())
937 ptr => iter%get_next()
940 call hm_out%external_potentials%add(ptr)
945 call iter%start(external_potentials_in)
946 do while (iter%has_next())
947 ptr => iter%get_next()
950 call hm_in%external_potentials%add(ptr)
955 call external_potentials_out%empty()
956 call external_potentials_in%empty()
958 if (runtime_initialized)
then
962 if (
allocated(hm_in%energy))
then
963 if (.not.
allocated(hm_out%energy)) safe_allocate(hm_out%energy)
966 safe_deallocate_a(hm_out%energy)
973 if (
associated(hm_in%ions))
then
974 safe_allocate(ions_out)
975 ions_out = hm_in%ions
976 hm_out%ions => ions_out
977 hm_out%owns_ions = .
true.
978 call hm_out%v_ie_loc%bind(hm_out%psolver, hm_out%ions)
979 call hm_out%nlcc%bind(hm_out%ions)
982 hm_out%owns_ions = .false.
983 nullify(hm_out%v_ie_loc%atoms_dist)
984 nullify(hm_out%v_ie_loc%atom)
985 nullify(hm_out%v_ie_loc%pos)
986 nullify(hm_out%nlcc%atoms_dist)
987 nullify(hm_out%nlcc%atom)
988 nullify(hm_out%nlcc%pos)
991 if (hm_out%lda_u_level /=
dft_u_none .and.
associated(hm_out%ions))
then
998 if (
associated(hm_in%zora))
then
999 allocate(zora_out, source=hm_in%zora)
1000 hm_out%zora => zora_out
1002 nullify(hm_out%zora)
1014 logical :: runtime_initialized
1018 runtime_initialized =
associated(hm_in%kpoints)
1019 if (.not. runtime_initialized)
then
1028 if (
associated(hm_in%xc))
then
1029 if (hm_in%xc%compute_exchange(hm_in%theory_level))
then
1042 if (hm_in%pcm%run_pcm)
then
1066 integer,
intent(in) :: terms
1087 real(real64),
intent(in) :: delta(:)
1088 real(real64),
intent(in) :: emin
1091 real(real64) :: emax
1099 hm%spectral_middle_point = (emax + emin) /
m_two
1100 hm%spectral_half_span = (emax - emin) /
m_two
1123 hm%inh_term = .
true.
1135 if (hm%inh_term)
then
1137 hm%inh_term = .false.
1149 if (.not. hm%adjoint)
then
1152 hm%abs_boundaries%mf = -hm%abs_boundaries%mf
1166 if (hm%adjoint)
then
1167 hm%adjoint = .false.
1169 hm%abs_boundaries%mf = -hm%abs_boundaries%mf
1181 class(
mesh_t),
intent(in) :: mesh
1183 class(
space_t),
intent(in) :: space
1185 real(real64),
optional,
intent(in) :: time
1187 integer :: ispin, ip, idir, iatom, ilaser
1188 real(real64) :: aa(space%dim), time_
1189 real(real64),
allocatable :: vp(:,:)
1192 real(real64) :: am(space%dim)
1197 this%current_time =
m_zero
1198 if (
present(time)) this%current_time = time
1203 call this%hm_base%clear(mesh%np)
1210 if (
present(time) .or. this%time_zero)
then
1213 if(
associated(lasers))
then
1214 do ilaser = 1, lasers%no_lasers
1215 select case (
laser_kind(lasers%lasers(ilaser)))
1217 do ispin = 1, this%d%spin_channels
1219 this%hm_base%potential(:, ispin), time_)
1225 safe_allocate(vp(1:mesh%np, 1:space%dim))
1226 vp(1:mesh%np, 1:space%dim) =
m_zero
1230 do idir = 1, space%dim
1231 this%hm_base%vector_potential(idir, ip) = this%hm_base%vector_potential(idir, ip) + vp(ip, idir)/
p_c
1235 call laser_field(lasers%lasers(ilaser), this%hm_base%uniform_magnetic_field(1:space%dim), time_)
1236 safe_deallocate_a(vp)
1241 call laser_field(lasers%lasers(ilaser), aa, time_)
1242 this%hm_base%uniform_vector_potential(1:space%dim) = this%hm_base%uniform_vector_potential(1:space%dim) - aa/
p_c
1247 assert(
allocated(this%hm_base%uniform_vector_potential))
1249 this%hm_base%uniform_vector_potential(1:space%dim) = this%hm_base%uniform_vector_potential(1:space%dim) - am/
p_c
1255 if (
associated(gfield))
then
1258 this%hm_base%uniform_vector_potential(1:space%dim) = this%hm_base%uniform_vector_potential(1:space%dim) - aa/
p_c
1262 if (
allocated(this%ep%e_field) .and.
associated(gfield))
then
1263 this%hm_base%uniform_vector_potential(1:space%periodic_dim) = &
1264 this%hm_base%uniform_vector_potential(1:space%periodic_dim) - time_*this%ep%e_field(1:space%periodic_dim)
1268 if (
associated(this%xc_photons))
then
1269 if(this%xc_photons%lpfmf .and.
allocated(this%xc_photons%mf_vector_potential))
then
1272 this%hm_base%uniform_vector_potential(1:space%dim) = &
1273 this%hm_base%uniform_vector_potential(1:space%dim) - this%xc_photons%mf_vector_potential(1:space%dim)/
p_c
1280 if (
allocated(this%ep%a_static))
then
1285 do idir = 1, space%dim
1286 this%hm_base%vector_potential(idir, ip) = this%hm_base%vector_potential(idir, ip) + this%ep%a_static(ip, idir)
1295 call this%hm_base%accel_copy_pot(mesh)
1298 if (
allocated(this%ep%b_field))
then
1301 this%hm_base%uniform_magnetic_field(idir) = this%hm_base%uniform_magnetic_field(idir) + this%ep%b_field(idir)
1306 call this%hm_base%update_magnetic_terms(mesh, this%ep%gyromagnetic_ratio, this%d%ispin)
1311 if (this%mxll%test_equad)
then
1330 if ((.not. this%kpoints%gamma_only()) .or.
allocated(this%hm_base%uniform_vector_potential))
then
1334 do iatom = 1, this%ep%natoms
1335 call projector_init_phases(this%ep%proj(iatom), space%dim, this%d, this%der%boundaries, this%kpoints, &
1336 vec_pot = this%hm_base%uniform_vector_potential, vec_pot_var = this%hm_base%vector_potential)
1342 if (
allocated(this%hm_base%uniform_vector_potential))
then
1344 call this%phase%update(mesh, this%d%kpt, this%kpoints, this%d, space, this%hm_base%uniform_vector_potential)
1349 vec_pot = this%hm_base%uniform_vector_potential, vec_pot_var = this%hm_base%vector_potential)
1354 if (this%ep%requires_generalized_overlap)
then
1358 if (this%aug_inverse_overlap%ovlp_inv%use_global_coupling)
then
1359 if (.not. this%aug_inverse_overlap%ovlp_inv%coupling_built .or. this%phase%is_allocated())
then
1360 call this%aug_inverse_overlap%ovlp_inv%build(this%aug_inverse_overlap%projector_matrices, &
1361 this%aug_inverse_overlap%projector_phases, mesh, this%d%kpt%start, this%d%kpt%end)
1380 class(
mesh_t),
intent(in) :: mesh
1381 logical,
optional,
intent(in) :: accumulate
1383 integer :: ispin, ip
1390 do ispin = 1, this%d%nspin
1393 this%hm_base%potential(ip, ispin) =
m_zero
1403 do ispin = 1, this%d%nspin
1404 if (ispin <= 2)
then
1408 this%hm_base%potential(ip, ispin) = this%hm_base%potential(ip, ispin) + this%ep%vpsl(ip) + this%v_ext_pot(ip)
1412 if (this%pcm%run_pcm)
then
1413 if (this%pcm%solute)
then
1416 this%hm_base%potential(ip, ispin) = this%hm_base%potential(ip, ispin) + &
1417 this%pcm%v_e_rs(ip) + this%pcm%v_n_rs(ip)
1421 if (this%pcm%localf)
then
1424 this%hm_base%potential(ip, ispin) = this%hm_base%potential(ip, ispin) + &
1425 this%pcm%v_ext_rs(ip)
1435 this%hm_base%Impotential(ip, ispin) = this%hm_base%Impotential(ip, ispin) + this%abs_boundaries%mf(ip)
1450 call this%zora%update(this%der, this%hm_base%potential)
1454 do ispin = 1, this%d%nspin
1456 if (
allocated(this%hm_base%zeeman_pot))
then
1459 this%hm_base%potential(ip, ispin) = this%hm_base%potential(ip, ispin) + this%hm_base%zeeman_pot(ip, ispin)
1465 if (this%mxll%test_equad)
then
1468 this%hm_base%potential(ip, ispin) = this%hm_base%potential(ip, ispin) + this%mxll%e_quadrupole_pot(ip)
1477 call this%ks_pot%add_vhxc(this%hm_base%potential)
1479 call this%hm_base%accel_copy_pot(mesh)
1483 if (this%ep%requires_generalized_overlap)
then
1488 if (this%ep%has_paw .and. this%vnl%nprojector_matrices > 0)
then
1489 if (.not.
allocated(this%aug_overlap%onsite_density_matrix))
then
1490 message(1) =
"Internal error: the PAW one-center density matrix is not allocated,"
1491 message(2) =
"the one-center contributions to the Hamiltonian cannot be computed."
1495 onsite_density_matrix = this%aug_overlap%onsite_density_matrix)
1509 type(
grid_t),
intent(in) :: gr
1510 type(
ions_t),
target,
intent(inout) :: ions
1513 real(real64),
optional,
intent(in) :: time
1518 call epot_generate(this%ep, namespace, gr, this%ions, this%d)
1519 st%requires_generalized_overlap = this%ep%requires_generalized_overlap
1524 if (
allocated(this%ep%e_field) .and. space%periodic_dim < space%dim)
then
1530 this%v_ie_loc%atoms_dist => ions%atoms_dist
1531 this%v_ie_loc%atom => ions%atom
1532 call this%v_ie_loc%calculate()
1535 call lalg_axpy(gr%np,
m_one, this%v_ie_loc%potential(:,1), this%ep%vpsl)
1539 if (this%ep%nlcc)
then
1540 call this%nlcc%end()
1541 call this%nlcc%init(gr, ions, this%ep%dgrid)
1542 call this%nlcc%calculate()
1543 call lalg_copy(gr%np, this%nlcc%density(:,1), st%rho_core)
1546 call this%vnl%build(space, gr, this%ep, this%d%ispin)
1547 if (this%ep%requires_generalized_overlap)
then
1548 call this%aug_overlap%build(space, gr, this%ep, this%d%ispin, overlap_operator = .
true.)
1549 call this%aug_inverse_overlap%build(space, gr, this%ep, this%d%ispin, inverse_overlap_operator = .
true.)
1552 if (this%ep%has_paw)
then
1556 call this%aug_overlap%end()
1557 call this%aug_inverse_overlap%end()
1563 if (this%ep%non_local .and. .not. this%vnl%apply_projector_matrices)
then
1565 call messages_write(
'Relativistic pseudopotentials have not been fully implemented for GPUs.')
1568 call messages_write(
'Relativistic pseudopotentials have not been fully implemented for GPUs.',&
1570 call messages_write(
'Calculation will not be continued. To force execution, set AllowCPUonly = yes.')
1577 if (this%pcm%run_pcm)
then
1580 if (this%pcm%solute)
then
1587 if (this%pcm%localf .and.
allocated(this%v_static))
then
1588 call pcm_calc_pot_rs(this%pcm, gr, this%psolver, v_ext = this%ep%v_ext(1:gr%np_part))
1593 call lda_u_update_basis(this%lda_u, space, gr, ions, st, this%psolver, namespace, this%kpoints, &
1594 this%phase%is_allocated(), this%aug_overlap)
1604 time = this%current_time
1612 apply = this%is_applied_packed
1620 type(namespace_t),
intent(in) :: namespace
1621 class(space_t),
intent(in) :: space
1622 type(lattice_vectors_t),
intent(in) :: latt
1623 class(species_t),
intent(in) :: species
1624 real(real64),
intent(in) :: pos(1:space%dim)
1625 integer,
intent(in) :: ia
1626 class(mesh_t),
intent(in) :: mesh
1627 complex(real64),
contiguous,
intent(in) :: psi(:,:)
1628 complex(real64),
contiguous,
intent(out) :: vpsi(:,:)
1631 real(real64),
allocatable :: vlocal(:)
1634 safe_allocate(vlocal(1:mesh%np_part))
1636 call epot_local_potential(hm%ep, namespace, space, latt, mesh, species, pos, ia, vlocal)
1639 do idim = 1, hm%d%dim
1642 vpsi(ip, idim) = vlocal(ip) * psi(ip, idim)
1647 safe_deallocate_a(vlocal)
1658 class(space_t),
intent(in) :: space
1659 class(mesh_t),
intent(in) :: mesh
1660 type(partner_list_t),
intent(in) :: ext_partners
1661 real(real64),
intent(in) :: time(1:2)
1662 real(real64),
intent(in) :: mu(1:2)
1664 integer :: ispin, ip, idir, iatom, ilaser, itime
1665 real(real64) :: aa(space%dim), bb(space%dim), time_
1666 real(real64),
allocatable :: vp(:,:)
1667 real(real64),
allocatable :: velectric(:)
1668 type(lasers_t),
pointer :: lasers
1669 type(gauge_field_t),
pointer :: gfield
1672 call profiling_in(
"HAMILTONIAN_ELEC_UPDATE_EXT_POT")
1674 this%current_time = m_zero
1675 this%current_time = time(1)
1678 call this%hm_base%clear(mesh%np)
1681 call this%hm_base%allocate_field(mesh, field_potential, &
1682 complex_potential = this%abs_boundaries%abtype == imaginary_absorbing)
1687 lasers => list_get_lasers(ext_partners)
1688 if(
associated(lasers))
then
1689 do ilaser = 1, lasers%no_lasers
1690 select case (laser_kind(lasers%lasers(ilaser)))
1691 case (e_field_scalar_potential, e_field_electric)
1692 safe_allocate(velectric(1:mesh%np))
1693 do ispin = 1, this%d%spin_channels
1695 call laser_potential(lasers%lasers(ilaser), mesh, velectric, time_)
1698 this%hm_base%potential(ip, ispin) = this%hm_base%potential(ip, ispin) + mu(itime) * velectric(ip)
1701 safe_deallocate_a(velectric)
1702 case (e_field_magnetic)
1703 call this%hm_base%allocate_field(mesh, field_vector_potential + field_uniform_magnetic_field, .false.)
1705 safe_allocate(vp(1:mesh%np, 1:space%dim))
1706 vp(1:mesh%np, 1:space%dim) = m_zero
1707 call laser_vector_potential(lasers%lasers(ilaser), mesh, vp, time_)
1708 do idir = 1, space%dim
1711 this%hm_base%vector_potential(idir, ip) = this%hm_base%vector_potential(idir, ip) &
1712 + mu(itime) * vp(ip, idir)/p_c
1717 call laser_field(lasers%lasers(ilaser), bb(1:space%dim), time_)
1718 this%hm_base%uniform_magnetic_field = this%hm_base%uniform_magnetic_field &
1720 safe_deallocate_a(vp)
1721 case (e_field_vector_potential)
1722 call this%hm_base%allocate_field(mesh, field_uniform_vector_potential, .false.)
1725 call laser_field(lasers%lasers(ilaser), aa, time_)
1726 this%hm_base%uniform_vector_potential(1:space%dim) = this%hm_base%uniform_vector_potential(1:space%dim) &
1727 - mu(itime) * aa/p_c
1733 gfield => list_get_gauge_field(ext_partners)
1734 if (
associated(gfield))
then
1735 call this%hm_base%allocate_field(mesh, field_uniform_vector_potential, .false.)
1736 call gauge_field_get_vec_pot(gfield, aa)
1737 this%hm_base%uniform_vector_potential(1:space%dim) = this%hm_base%uniform_vector_potential(1:space%dim) - aa/p_c
1744 if (
allocated(this%ep%e_field) .and.
associated(gfield))
then
1745 this%hm_base%uniform_vector_potential(1:space%periodic_dim) = &
1746 this%hm_base%uniform_vector_potential(1:space%periodic_dim) - time_*this%ep%e_field(1:space%periodic_dim)
1752 if (
allocated(this%ep%a_static))
then
1753 call this%hm_base%allocate_field(mesh, field_vector_potential, .false.)
1757 do idir = 1, space%dim
1758 this%hm_base%vector_potential(idir, ip) = this%hm_base%vector_potential(idir, ip) + this%ep%a_static(ip, idir)
1764 call this%hm_base%accel_copy_pot(mesh)
1767 if (
allocated(this%ep%b_field))
then
1768 call this%hm_base%allocate_field(mesh, field_uniform_magnetic_field, .false.)
1770 this%hm_base%uniform_magnetic_field(idir) = this%hm_base%uniform_magnetic_field(idir) + this%ep%b_field(idir)
1774 call this%hm_base%update_magnetic_terms(mesh, this%ep%gyromagnetic_ratio, this%d%ispin)
1780 call profiling_out(
"HAMILTONIAN_ELEC_UPDATE_EXT_POT")
1789 if ((.not. this%kpoints%gamma_only()) .or.
allocated(this%hm_base%uniform_vector_potential))
then
1791 call profiling_in(
'UPDATE_PHASES')
1793 do iatom = 1, this%ep%natoms
1794 call projector_init_phases(this%ep%proj(iatom), space%dim, this%d, this%der%boundaries, this%kpoints, &
1795 vec_pot = this%hm_base%uniform_vector_potential, vec_pot_var = this%hm_base%vector_potential)
1798 call profiling_out(
'UPDATE_PHASES')
1801 if (
allocated(this%hm_base%uniform_vector_potential))
then
1802 call this%phase%update(mesh, this%d%kpt, this%kpoints, this%d, space, this%hm_base%uniform_vector_potential)
1806 if (this%ep%requires_generalized_overlap)
then
1810 if (this%aug_inverse_overlap%ovlp_inv%use_global_coupling)
then
1811 if (.not. this%aug_inverse_overlap%ovlp_inv%coupling_built .or. this%phase%is_allocated())
then
1812 call this%aug_inverse_overlap%ovlp_inv%build(this%aug_inverse_overlap%projector_matrices, &
1813 this%aug_inverse_overlap%projector_phases, mesh, this%d%kpt%start, this%d%kpt%end)
1831 type(nonlocal_pseudopotential_t),
intent(inout) :: nlpp
1832 logical,
optional,
intent(in) :: async
1834 integer :: ik, imat, nmat, max_npoints, offset, iphase, nphase, ip, iatom
1838 if (this%phase%is_allocated() .and.
allocated(nlpp%projector_matrices))
then
1840 max_npoints = nlpp%max_npoints
1841 nmat = nlpp%nprojector_matrices
1844 if (this%der%boundaries%spiralBC) nphase = 3
1846 if (.not.
allocated(nlpp%projector_phases))
then
1847 safe_allocate(nlpp%projector_phases(1:max_npoints, 1:nphase, nmat, this%d%kpt%start:this%d%kpt%end))
1848 if (accel_is_enabled())
then
1849 call accel_create_buffer(nlpp%buff_projector_phases, accel_mem_read_only, &
1850 type_cmplx, nlpp%total_points*nphase*this%d%kpt%nlocal())
1853 nlpp%nphase = nphase
1858 do ik = this%d%kpt%start, this%d%kpt%end
1859 do imat = 1, nlpp%nprojector_matrices
1860 iatom = nlpp%projector_to_atom(imat)
1861 do iphase = 1, nphase
1863 do ip = 1, nlpp%projector_matrices(imat)%npoints
1864 nlpp%projector_phases(ip, iphase, imat, ik) = this%ep%proj(iatom)%phase(ip, iphase, ik)
1867 if (accel_is_enabled() .and. nlpp%projector_matrices(imat)%npoints > 0)
then
1868 call accel_write_buffer(nlpp%buff_projector_phases, &
1869 nlpp%projector_matrices(imat)%npoints, nlpp%projector_phases(1:, iphase, imat, ik), &
1870 offset = offset, async=optional_default(async, .false.))
1872 offset = offset + nlpp%projector_matrices(imat)%npoints
1884 logical,
intent(in) :: states_are_real
1888 if (hm%self_induced_magnetic)
then
1889 if (.not. states_are_real)
then
1892 message(1) =
'No current density for real states since it is identically zero.'
1893 call messages_warning(1)
1902 type(namespace_t),
intent(in) :: namespace
1903 type(grid_t),
intent(in) :: gr
1904 type(states_elec_t),
intent(inout) :: st
1905 type(states_elec_t),
intent(inout) :: hst
1907 integer :: ik, ib, ist
1908 complex(real64),
allocatable :: psi(:, :)
1909 complex(real64),
allocatable :: psiall(:, :, :, :)
1913 do ik = st%d%kpt%start, st%d%kpt%end
1914 do ib = st%group%block_start, st%group%block_end
1919 if (oct_exchange_enabled(hm%oct_exchange))
then
1921 safe_allocate(psiall(gr%np_part, 1:hst%d%dim, st%st_start:st%st_end, st%d%kpt%start:st%d%kpt%end))
1923 call states_elec_get_state(st, gr, psiall)
1925 call oct_exchange_prepare(hm%oct_exchange, gr, psiall, hm%xc, hm%psolver, namespace)
1927 safe_deallocate_a(psiall)
1929 safe_allocate(psi(gr%np_part, 1:hst%d%dim))
1933 call states_elec_get_state(hst, gr, ist, ik, psi)
1934 call oct_exchange_operator(hm%oct_exchange, namespace, gr, psi, ist, ik)
1935 call states_elec_set_state(hst, gr, ist, ik, psi)
1939 safe_deallocate_a(psi)
1961 type(namespace_t),
intent(in) :: namespace
1962 real(real64),
intent(in) :: mass
1966 if (parse_is_defined(namespace,
'ParticleMass'))
then
1967 message(1) =
'Attempting to redefine a non-unit electron mass'
1968 call messages_fatal(1)
1979 class(mesh_t),
intent(in) :: mesh
1980 real(real64),
contiguous,
intent(out) :: diag(:,:)
1981 integer,
intent(in) :: ik
1983 integer :: idim, ip, ispin
1985 real(real64),
allocatable :: ldiag(:)
1989 safe_allocate(ldiag(1:mesh%np))
1993 call derivatives_lapl_diag(hm%der, ldiag)
1996 do idim = 1, hm%d%dim
1999 diag(ip, idim) = -m_half/hm%mass*ldiag(ip)
2004 select case (hm%d%ispin)
2006 case (unpolarized, spin_polarized)
2007 ispin = hm%d%get_spin_index(ik)
2010 diag(ip, 1) = diag(ip, 1) + hm%ep%vpsl(ip)
2016 diag(ip, 1) = diag(ip, 1) + hm%ep%vpsl(ip)
2017 diag(ip, 2) = diag(ip, 2) + hm%ep%vpsl(ip)
2022 call hm%ks_pot%add_vhxc(diag)
2031#include "hamiltonian_elec_inc.F90"
2034#include "complex.F90"
2035#include "hamiltonian_elec_inc.F90"
subroutine build_external_potentials()
subroutine external_potentials_checks()
subroutine build_interactions()
constant times a vector plus a vector
Copies a vector x, to a vector y.
integer, parameter, public imaginary_absorbing
subroutine, public absorbing_boundaries_end(this)
subroutine, public absorbing_boundaries_init(this, namespace, space, gr)
pure logical function, public accel_allow_cpu_only()
subroutine, public accel_finish()
pure logical function, public accel_is_enabled()
This module implements batches of mesh functions.
This module implements common operations on batches of mesh functions.
Module implementing boundary conditions in Octopus.
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
real(real64) function, public derivatives_lapl_get_max_eigenvalue(this)
Get maximum eigenvalue of discrete Laplacian. For the star and star_general stencils,...
subroutine, public energy_copy(ein, eout)
subroutine, public epot_bind_poisson_solver(ep, psolver)
Bind the Poisson solver if the potential manages a density. The Poisson solver pointer is aliased whe...
logical function, public epot_have_external_potentials(ep)
integer, parameter, public scalar_relativistic_zora
subroutine, public epot_end(ep)
integer, parameter, public fully_relativistic_zora
subroutine, public epot_init(ep, namespace, gr, ions, psolver, ispin, xc_family, kpoints)
subroutine, public epot_generate(ep, namespace, mesh, ions, st_d)
subroutine, public exchange_operator_init(this, namespace, space, st, der, mc, stencil, kpoints, cam)
subroutine, public exchange_operator_end(this)
logical function, public list_has_gauge_field(partners)
type(gauge_field_t) function, pointer, public list_get_gauge_field(partners)
logical function, public list_has_lasers(partners)
type(lasers_t) function, pointer, public list_get_lasers(partners)
integer, parameter, public external_pot_from_file
potential, defined in a file
subroutine, public load_external_potentials(external_potentials, namespace)
integer, parameter, public external_pot_charge_density
user-defined function for charge density
integer, parameter, public external_pot_usdef
user-defined function for local potential
integer, parameter, public external_pot_static_efield
Static electric field.
integer, parameter, public external_pot_static_bfield
Static magnetic field.
subroutine, public external_potential_clone(pot_out, pot_in)
Deep-clone an external potential instance.
subroutine, public gauge_field_get_vec_pot(this, vec_pot)
real(real64), parameter, public m_two
real(real64), parameter, public m_zero
integer, parameter, public rdmft
integer, parameter, public hartree_fock
integer, parameter, public independent_particles
Theory level.
integer, parameter, public generalized_kohn_sham_dft
integer, parameter, public kohn_sham_dft
real(real64), parameter, public m_epsilon
real(real64), parameter, public p_c
Electron gyromagnetic ratio, see Phys. Rev. Lett. 130, 071801 (2023)
real(real64), parameter, public m_one
This module implements the underlying real-space grid.
This module defines an abstract class for Hamiltonians.
integer, parameter, public field_uniform_magnetic_field
integer, parameter, public field_uniform_vector_potential
integer, parameter, public field_vector_potential
integer, parameter, public term_mgga
subroutine, public hamiltonian_elec_base_accel_rebuild(this, mesh)
Rebuild accelerator buffers after an intrinsic copy.
integer, parameter, public field_potential
subroutine, public zhamiltonian_elec_apply_overlap_single(hm, namespace, mesh, psi, spsi, ist, ik, set_bc, set_phase, inverse)
Apply the overlap S (or its inverse) to a single state (wrapper around the batch routine).
subroutine, public dhamiltonian_elec_apply_sinvh_batch(hm, namespace, mesh, psib, hspsib, terms, set_bc, set_phase)
Apply the operator A = S^{-1} H to a batch (for ultrasoft/PAW).
subroutine, public zhamiltonian_elec_apply_overlap_batch(hm, namespace, mesh, psib, spsib, set_bc, inverse, set_phase)
Apply the generalized ultrasoft overlap operator S (or its inverse) to a batch.
pure logical function, public hamiltonian_elec_apply_packed(this)
subroutine, public hamiltonian_elec_set_inh(hm, st)
subroutine, public zvmask(mesh, hm, st)
subroutine, public dhamiltonian_elec_apply_batch(hm, namespace, mesh, psib, hpsib, terms, set_bc, set_phase, spsib)
subroutine, public hamiltonian_elec_adjoint(hm)
subroutine, public hamiltonian_elec_end(hm)
subroutine, public zhamiltonian_elec_apply_single(hm, namespace, mesh, psi, hpsi, ist, ik, terms, set_bc, set_phase)
pure logical function hamiltonian_elec_needs_mgga_term(hm, terms)
logical function, public hamiltonian_elec_has_kick(hm)
integer, parameter, public length
subroutine hamiltonian_elec_build_projector_phases(this, nlpp, async)
Build the projector phases for a given nonlocal-pseudopotential set.
logical function hamiltonian_elec_hermitian(hm)
subroutine, public dhamiltonian_elec_apply_single(hm, namespace, mesh, psi, hpsi, ist, ik, terms, set_bc, set_phase)
subroutine, public hamiltonian_elec_epot_generate(this, namespace, space, gr, ions, ext_partners, st, time)
real(real64) function, public hamiltonian_elec_get_time(this)
subroutine, public zhamiltonian_elec_apply_batch(hm, namespace, mesh, psib, hpsib, terms, set_bc, set_phase, spsib)
subroutine, public hamiltonian_elec_copy(hm_out, hm_in)
Deep-copy a hamiltonian_elec_t snapshot.
subroutine, public zhamiltonian_elec_apply_sinvh_single(hm, namespace, mesh, psi, hspsi, ist, ik, terms, set_bc, set_phase)
Apply A = S^{-1} H to a single state (wrapper around the batch routine).
subroutine, public dhamiltonian_elec_apply_sinvh_single(hm, namespace, mesh, psi, hspsi, ist, ik, terms, set_bc, set_phase)
Apply A = S^{-1} H to a single state (wrapper around the batch routine).
subroutine, public dhamiltonian_elec_apply_overlap_batch(hm, namespace, mesh, psib, spsib, set_bc, inverse, set_phase)
Apply the generalized ultrasoft overlap operator S (or its inverse) to a batch.
subroutine, public dvmask(mesh, hm, st)
logical function, public hamiltonian_elec_needs_current(hm, states_are_real)
subroutine, public hamiltonian_elec_remove_inh(hm)
subroutine, public dhamiltonian_elec_apply_overlap_single(hm, namespace, mesh, psi, spsi, ist, ik, set_bc, set_phase, inverse)
Apply the overlap S (or its inverse) to a single state (wrapper around the batch routine).
subroutine, public zhamiltonian_elec_apply_atom(hm, namespace, space, latt, species, pos, ia, mesh, psi, vpsi)
subroutine hamiltonian_elec_release_copy_owned(hm)
Release owned pointer targets created by hamiltonian_elec_copy.
subroutine, public zhamiltonian_elec_apply_all(hm, namespace, gr, st, hst)
subroutine, public zhamiltonian_elec_apply_sinvh_batch(hm, namespace, mesh, psib, hspsib, terms, set_bc, set_phase)
Apply the operator A = S^{-1} H to a batch (for ultrasoft/PAW).
subroutine, public hamiltonian_elec_diagonal(hm, mesh, diag, ik)
subroutine, public hamiltonian_elec_update_pot(this, mesh, accumulate)
Update the KS potential of the electronic Hamiltonian.
integer, parameter, public velocity
subroutine hamiltonian_elec_update(this, mesh, namespace, space, ext_partners, time)
(re-)build the Hamiltonian for the next application:
subroutine hamiltonian_elec_copy_guard_supported(hm_in)
Hard-fail guard matrix for unsupported hamiltonian snapshots.
subroutine hamiltonian_elec_span(hm, delta, emin, namespace)
subroutine, public hamiltonian_elec_init(hm, namespace, space, gr, ions, ext_partners, st, theory_level, xc, mc, kpoints, need_exchange, xc_photons)
subroutine dhamiltonian_elec_apply(hm, namespace, mesh, psib, hpsib, terms, set_bc)
pure logical function, public hamiltonian_elec_inh_term(hm)
subroutine hamiltonian_elec_set_mass(this, namespace, mass)
set the effective electron mass, checking whether it was previously redefined.
subroutine, public hamiltonian_elec_update_with_ext_pot(this, mesh, space, ext_partners, time, mu)
This is an extension of "hamiltonian_elec_update_pot" to be used by the CFM4 propagator....
subroutine, public hamiltonian_elec_not_adjoint(hm)
subroutine, public zhamiltonian_elec_external(this, mesh, psib, vpsib)
subroutine zhamiltonian_elec_apply(hm, namespace, mesh, psib, hpsib, terms, set_bc)
This module defines classes and functions for interaction partners.
subroutine, public kick_copy(kick_out, kick_in)
integer, parameter, public kick_magnon_mode
subroutine, public kick_end(kick)
subroutine, public kick_init(kick, namespace, space, kpoints, nspin)
pure integer function, public kick_get_type(kick)
A module to handle KS potential, without the external potential.
subroutine, public ks_potential_accel_rebuild(this)
Rebuild accelerator buffers after an intrinsic copy.
subroutine, public laser_vector_potential(laser, mesh, aa, time)
subroutine, public lasers_nondipole_laser_field_step(this, field, time)
Retrieves the NDSFA vector_potential correction. The nondipole field is obtained for consecutive time...
logical function, public lasers_with_nondipole_field(lasers)
Check if a nondipole SFA correction should be computed for the given laser.
integer, parameter, public e_field_electric
integer, parameter, public e_field_vector_potential
subroutine, public laser_potential(laser, mesh, pot, time)
integer, parameter, public e_field_scalar_potential
integer pure elemental function, public laser_kind(laser)
subroutine, public laser_field(laser, field, time)
Retrieves the value of either the electric or the magnetic field. If the laser is given by a scalar p...
integer, parameter, public e_field_magnetic
integer, parameter, public dft_u_none
subroutine, public lda_u_init(this, namespace, space, level, gr, ions, st, mc, kpoints)
subroutine, public lda_u_accel_rebuild(this, kpt)
Rebuild DFT+U accelerator buffers after intrinsic assignment.
subroutine, public lda_u_rebind_after_copy(this, ions)
Rebind non-owning pointers after intrinsic assignment of lda_u_t.
subroutine, public lda_u_build_phase_correction(this, space, std, boundaries, namespace, kpoints, vec_pot, vec_pot_var)
Build the phase correction to the global phase for all orbitals.
subroutine, public lda_u_end(this)
subroutine, public lda_u_update_basis(this, space, gr, ions, st, psolver, namespace, kpoints, has_phase, aug_overlap)
This module implements fully polymorphic linked lists, and some specializations thereof.
This modules implements the routines for doing constrain DFT for noncollinear magnetism.
subroutine, public magnetic_constrain_copy(this_out, this_in)
Deep-copy magnetic constrain data.
subroutine, public magnetic_constrain_end(this)
Releases memory of the magnetic constrain.
subroutine, public magnetic_constrain_init(this, namespace, mesh, std, natoms, min_dist)
Initilializes the magnetic_constrain_t object.
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.
subroutine, public messages_not_implemented(feature, namespace)
subroutine, public messages_warning(no_lines, all_nodes, namespace)
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_experimental(name, namespace)
This module handles the communicators for the various parallelization strategies.
subroutine, public mxll_coupling_init(this, d, gr, namespace, mass)
Parse variables and initialize Maxwell coupling.
subroutine, public set_electric_quadrupole_pot(this, mesh)
Computes the electric quadrupole potential where .
subroutine, public mxll_coupling_end(this)
Finalize and deallocate Maxwell coupling arrays.
subroutine, public mxll_coupling_calc(this, hm_base, mesh, d, space)
Add the Maxwell coupling to the electronic Hamiltonian.
subroutine, public mxll_coupling_copy(this_out, this_in, der_target)
Deep-copy Maxwell-electron coupling data and rebind derivatives.
subroutine, public nonlocal_pseudopotential_accel_rebuild(this, space, mesh)
Rebuild accelerator buffers after an intrinsic copy.
subroutine, public nonlocal_pseudopotential_rebind_projectors(this, epot)
Rebind projector matrix pointers (map, position) to a target epot.
subroutine, public nonlocal_pseudopotential_update_dij(this, mesh, epot, veff, add_bare, onsite_density_matrix)
Screen the ultrasoft nonlocal coupling matrix D_ij with the local potential.
subroutine, public nonlocal_pseudopotential_build_paw_symm(this, epot, space, gr, ions)
Build the crystal-symmetry data used to symmetrize the PAW one-center density matrix.
logical function, public oct_exchange_enabled(this)
subroutine, public oct_exchange_remove(this)
this module contains the low-level part of the output system
Some general things and nomenclature:
logical function, public parse_is_defined(namespace, name)
subroutine, public pcm_calc_pot_rs(pcm, mesh, psolver, ions, v_h, v_ext, kick, time_present, kick_time)
subroutine, public pcm_end(pcm)
subroutine, public pcm_init(pcm, namespace, space, ions, grid, qtot, val_charge, external_potentials_present, kick_present)
Initializes the PCM calculation: reads the VdW molecular cavity and generates the PCM response matrix...
subroutine, public phase_accel_rebuild(phase, mesh, kpt)
Rebuild phase accelerator buffers after an intrinsic copy.
subroutine, public poisson_init(this, namespace, space, der, mc, stencil, qtot, label, solver, verbose, force_serial, force_cmplx, fft_library, fft_batch_size, single_precision)
subroutine, public poisson_end(this)
/* To use the profiling module, call profiling_in and profiling_out with the label of the region as a...
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 projector_init_phases(this, dim, std, bnd, kpoints, vec_pot, vec_pot_var)
subroutine, public scissor_end(this)
subroutine, public states_set_complex(st)
pure logical function, public states_are_real(st)
This module handles spin dimensions of the states and the k-point distribution.
subroutine, public states_elec_dim_copy(dout, din)
subroutine, public states_elec_dim_end(dim)
subroutine, public states_elec_end(st)
finalize the states_elec_t object
subroutine, public states_elec_copy(stout, stin, exclude_wfns, exclude_eigenval, special, dest_type, copy_data)
make a (selective) copy of a states_elec_t object
This module provides routines for communicating states when using states parallelization.
integer pure function, public symmetries_identity_index(this)
integer pure function, public symmetries_number(this)
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_inp
the units systems for reading and writing
type(xc_cam_t), parameter, public cam_exact_exchange
Use only Hartree Fock exact exchange.
integer, parameter, public xc_oep_x_slater
Slater approximation to the exact exchange.
integer, parameter, public func_x
logical pure function, public family_is_mgga_with_exc(xcs)
Is the xc function part of the mGGA family with an energy functional.
logical pure function, public family_is_hybrid(xcs)
Returns true if the functional is an hybrid functional.
This module implements the "photon-free" electron-photon exchange-correlation functional.
This module implements the ZORA terms for the Hamoiltonian.
Extension of space that contains the knowledge of the spin dimension.
Description of the grid, containing information on derivatives, stencil, and symmetries.
The abstract Hamiltonian class defines a skeleton for specific implementations.
abstract class for general interaction partners
iterator for the list of partners
Describes mesh distribution to nodes.
Stores all communicators and groups.
The states_elec_t class contains all electronic wave functions.
This class described the 'photon-exchange' electron-photon xc functionals, based on QEDFT.
This class is responsible for calculating and applying the ZORA.