37 use,
intrinsic :: iso_fortran_env
109 real(real64) :: total(3,3) =
m_zero
110 real(real64) :: kinetic(3,3) =
m_zero
111 real(real64) :: Hartree(3,3) =
m_zero
112 real(real64) :: xc(3,3) =
m_zero
113 real(real64) :: xc_nlcc(3,3) =
m_zero
114 real(real64) :: ps_local(3,3) =
m_zero
115 real(real64) :: ps_nl(3,3) =
m_zero
116 real(real64) :: ps_aug(3,3) =
m_zero
117 real(real64) :: ion_ion(3,3) =
m_zero
118 real(real64) :: vdw(3,3) =
m_zero
119 real(real64) :: hubbard(3,3) =
m_zero
121 real(real64) :: kinetic_sumrule =
m_zero
122 real(real64) :: hartree_sumrule =
m_zero
137 type(states_elec_dim_t) :: d
140 logical :: only_userdef_istates
141 logical :: requires_generalized_overlap = .false.
143 type(states_elec_group_t) :: group
144 integer :: block_size
148 logical :: pack_states
154 character(len=1024),
allocatable :: user_def_states(:,:,:)
160 real(real64),
allocatable :: rho(:,:)
161 real(real64),
allocatable :: rho_core(:)
164 type(accel_mem_t) :: buff_density
166 real(real64),
allocatable :: current(:, :, :)
167 real(real64),
allocatable :: current_para(:, :, :)
168 real(real64),
allocatable :: current_dia(:, :, :)
169 real(real64),
allocatable :: current_mag(:, :, :)
170 real(real64),
allocatable :: current_kpt(:,:,:)
175 real(real64),
allocatable :: frozen_rho(:, :)
176 real(real64),
allocatable :: frozen_tau(:, :)
177 real(real64),
allocatable :: frozen_gdens(:,:,:)
178 real(real64),
allocatable :: frozen_ldens(:,:)
180 logical :: uniform_occ
182 real(real64),
allocatable :: eigenval(:,:)
184 logical :: restart_fixed_occ
185 logical :: restart_reorder_occs
186 real(real64),
allocatable :: occ(:,:)
187 real(real64),
allocatable :: kweights(:)
190 logical :: fixed_spins
192 real(real64),
allocatable :: spin(:, :, :)
195 real(real64) :: val_charge
199 logical :: fromscratch
207 type(mpi_grp_t) :: mpi_grp
208 type(mpi_grp_t) :: dom_st_mpi_grp
215 logical :: scalapack_compatible
216 logical :: parallel_in_states = .false.
220 integer :: st_start, st_end
221 integer,
allocatable :: node(:)
224 integer,
allocatable :: st_kpt_task(:,:)
227 logical :: symmetrize_density
228 integer :: randomization
229 integer :: orth_method = 0
231 real(real64) :: gpu_states_mem
243 integer,
public,
parameter :: &
277 st%requires_generalized_overlap = .false.
288 real(real64),
intent(in) :: valence_charge
290 integer,
optional,
intent(in) :: calc_mode_id
292 real(real64) :: excess_charge, nempty_percent
293 integer :: nempty, ntot, default
294 integer :: nempty_conv, nempty_conv_default
295 logical :: force, adapt_for_chebyshev
296 real(real64),
parameter :: tol = 1e-13_real64
298 integer,
parameter :: rs_chebyshev = 12
299 integer(int64),
parameter :: chebyshev_compatible_modes(3) = &
300 [option__calculationmode__gs, option__calculationmode__go, option__calculationmode__unocc]
304 st%fromScratch = .
true.
309 st%d%ispin = space%ispin
314 if (st%d%ispin /=
unpolarized .and. kpoints%use_time_reversal)
then
315 message(1) =
"Time reversal symmetry is only implemented for unpolarized spins."
316 message(2) =
"Use KPointsUseTimeReversal = no."
348 write(
message(1),
'(a,i5,a)')
"Input: '", ntot,
"' is not a valid value for TotalStates."
370 write(
message(1),
'(a,i5,a)')
"Input: '", nempty,
"' is not a valid value for ExtraStates."
371 message(2) =
'(0 <= ExtraStates)'
375 if (ntot > 0 .and. nempty > 0)
then
376 message(1) =
'You cannot set TotalStates and ExtraStates at the same time.'
391 if (nempty_percent < 0)
then
392 write(
message(1),
'(a,f8.6,a)')
"Input: '", nempty_percent, &
393 "' should be a percentage value x (where x is parts in hundred) larger or equal 0"
397 if (nempty > 0 .and. nempty_percent > 0)
then
398 message(1) =
'You cannot set ExtraStates and ExtraStatesInPercent at the same time.'
403 adapt_for_chebyshev = .false.
404 if (
present(calc_mode_id))
then
405 if (any(calc_mode_id == chebyshev_compatible_modes))
then
408 if (es == rs_chebyshev)
then
410 adapt_for_chebyshev = .
true.
414 if (adapt_for_chebyshev)
then
417 message(1) =
'Chebyshev filtering eigensolver detected. Setting ExtraStatesInPercent = 15'
425 st%val_charge = valence_charge
427 st%qtot = -(st%val_charge + excess_charge)
430 write(
message(1),
'(a,f12.6,a)')
'Total charge = ', st%qtot,
' < 0'
431 message(2) =
'Check Species and ExcessCharge.'
435 select case (st%d%ispin)
438 st%nst = nint(st%qtot/2)
439 if (st%nst*2 - st%qtot < -tol) st%nst = st%nst + 1
441 st%d%spin_channels = 1
444 st%nst = nint(st%qtot/2)
445 if (st%nst*2 - st%qtot < -tol) st%nst = st%nst + 1
447 st%d%spin_channels = 2
450 st%nst = nint(st%qtot)
451 if (st%nst - st%qtot < -tol) st%nst = st%nst + 1
453 st%d%spin_channels = 2
456 if (nempty_percent > 0)
then
457 nempty = ceiling(nempty_percent * st%nst / 100)
477 nempty_conv_default = nempty
478 if (adapt_for_chebyshev)
then
480 nempty_conv_default = min(int(0.8*nempty), nempty - 1)
482 call parse_variable(namespace,
'ExtraStatesToConverge', nempty_conv_default, nempty_conv)
483 if (nempty_conv < 0)
then
484 write(
message(1),
'(a,i5,a)')
"Input: '", nempty_conv,
"' is not a valid value for ExtraStatesToConverge."
485 message(2) =
'(0 <= ExtraStatesToConverge)'
489 if (nempty_conv > nempty)
then
491 message(1) =
'You cannot set ExtraStatesToConverge to a higher value than ExtraStates.'
492 message(2) =
'Capping ExtraStatesToConverge to ExtraStates.'
497 if (ntot < st%nst)
then
498 message(1) =
'TotalStates is smaller than the number of states required by the system.'
505 st%nst_conv = st%nst + nempty_conv
506 st%nst = st%nst + nempty
507 if (st%nst == 0)
then
508 message(1) =
"Cannot run with number of states = zero."
526 default =
accel%warp_size
535 call parse_variable(namespace,
'StatesBlockSize', default, st%block_size)
536 if (st%block_size < 1)
then
537 call messages_write(
"The variable 'StatesBlockSize' must be greater than 0.")
541 st%block_size = min(st%block_size, st%nst)
542 conf%target_states_block_size = st%block_size
544 safe_allocate(st%eigenval(1:st%nst, 1:st%nik))
545 st%eigenval = huge(st%eigenval)
549 if (.not. kpoints%gamma_only())
then
562 call parse_variable(namespace,
'OnlyUserDefinedInitialStates', .false., st%only_userdef_istates)
565 safe_allocate(st%occ (1:st%nst, 1:st%nik))
570 safe_allocate(st%user_def_states(1:st%d%dim, 1:st%nst, 1:st%nik))
572 st%user_def_states(1:st%d%dim, 1:st%nst, 1:st%nik) =
'undefined'
575 if (st%d%ispin ==
spinors)
then
576 safe_allocate(st%spin(1:3, 1:st%nst, 1:st%nik))
603 if (st%smear%photodop)
then
604 if (nempty == 0)
then
605 write(
message(1),
'(a,i5,a)')
"PhotoDoping requires to specify ExtraStates."
606 message(2) =
'(0 == ExtraStates)'
614 safe_allocate(st%node(1:st%nst))
615 st%node(1:st%nst) = 0
618 st%parallel_in_states = .false.
632 call parse_variable(namespace,
'SymmetrizeDensity', kpoints%use_symmetries, st%symmetrize_density)
662 integer,
intent(out) :: nik
663 integer,
intent(out) :: dim
664 integer,
intent(out) :: nst
665 integer,
intent(out) :: ierr
667 character(len=256) :: lines(3)
668 character(len=20) :: char
675 iunit = restart%open(
'states')
676 call restart%read(iunit, lines, 3, ierr)
678 read(lines(1), *) char, nst
679 read(lines(2), *) char, dim
680 read(lines(3), *) char, nik
682 call restart%close(iunit)
700 real(real64),
intent(in) :: excess_charge
703 integer :: ik, ist, ispin, nspin, ncols, nrows, el_per_state, icol, start_pos, spin_n
705 real(real64) :: rr, charge
706 logical :: integral_occs, unoccupied_states
707 real(real64),
allocatable :: read_occs(:, :)
708 real(real64) :: charge_in_block
723 call parse_variable(namespace,
'RestartFixedOccupations', .
true., st%restart_fixed_occ)
794 integral_occs = .
true.
796 occ_fix:
if (
parse_block(namespace,
'Occupations', blk) == 0)
then
798 st%fixed_occ = .
true.
801 if (ncols > st%nst)
then
806 if (nrows /= st%nik)
then
807 call messages_input_error(namespace,
"Occupations",
"Wrong number of rows in block Occupations.")
810 do ik = 1, st%nik - 1
813 "All rows in block Occupations must have the same number of columns.")
824 safe_allocate(read_occs(1:ncols, 1:st%nik))
830 charge_in_block = charge_in_block + read_occs(icol, ik) * st%kweights(ik)
835 select case (st%d%ispin)
844 start_pos = nint((st%qtot - charge_in_block)/spin_n)
846 if (start_pos + ncols > st%nst)
then
847 message(1) =
"To balance charge, the first column in block Occupations is taken to refer to state"
848 write(
message(2),
'(a,i6,a)')
"number ", start_pos,
" but there are too many columns for the number of states."
849 write(
message(3),
'(a,i6,a)')
"Solution: set ExtraStates = ", start_pos + ncols - st%nst
854 do ist = 1, start_pos
855 st%occ(ist, ik) = el_per_state
860 do ist = start_pos + 1, start_pos + ncols
861 st%occ(ist, ik) = read_occs(ist - start_pos, ik)
862 integral_occs = integral_occs .and. &
863 abs((st%occ(ist, ik) - el_per_state) * st%occ(ist, ik)) <=
m_epsilon
868 do ist = start_pos + ncols + 1, st%nst
875 safe_deallocate_a(read_occs)
878 st%fixed_occ = .false.
879 integral_occs = .false.
886 st%qtot = -(st%val_charge + excess_charge)
889 if (st%d%nspin == 2) nspin = 2
891 do ik = 1, st%nik, nspin
894 do ispin = ik, ik + nspin - 1
895 st%occ(ist, ispin) = min(rr, -(st%val_charge + excess_charge) - charge)
896 charge = charge + st%occ(ist, ispin)
915 if (st%fixed_occ)
then
916 call parse_variable(namespace,
'RestartReorderOccs', .false., st%restart_reorder_occs)
918 st%restart_reorder_occs = .false.
921 call smear_init(st%smear, namespace, st%d%ispin, st%fixed_occ, integral_occs, kpoints)
923 unoccupied_states = (st%d%ispin /=
spinors .and. st%nst*2 > st%qtot) .or. (st%d%ispin ==
spinors .and. st%nst > st%qtot)
926 if (.not. unoccupied_states)
then
927 call messages_write(
'Smearing needs unoccupied states (via ExtraStates or TotalStates) to be useful.')
935 charge = charge + sum(st%occ(ist, 1:st%nik) * st%kweights(1:st%nik))
937 if (abs(charge - st%qtot) > 1e-6_real64)
then
938 message(1) =
"Initial occupations do not integrate to total charge."
939 write(
message(2),
'(6x,f12.6,a,f12.6)') charge,
' != ', st%qtot
961 integer :: i, j, nrows
966 st%fixed_spins = .false.
967 if (st%d%ispin /=
spinors)
then
1006 spin_fix:
if (
parse_block(namespace,
'InitialSpins', blk) == 0)
then
1008 if (nrows < st%nst)
then
1009 message(1) =
"Please specify one row for each state in InitialSpins, also for extra states."
1019 st%fixed_spins = .
true.
1021 st%spin(:, :, i) = st%spin(:, :, 1)
1034 class(
mesh_t),
intent(in) :: mesh
1035 type(
type_t),
optional,
intent(in) :: wfs_type
1036 logical,
contiguous,
optional,
intent(in) :: skip(:)
1037 logical,
optional,
intent(in) :: packed
1041 if (
present(wfs_type))
then
1043 st%wfs_type = wfs_type
1071 type(
mesh_t),
intent(in) :: mesh
1072 logical,
optional,
intent(in) :: verbose
1073 logical,
contiguous,
optional,
intent(in) :: skip(:)
1074 logical,
optional,
intent(in) :: packed
1076 integer :: ib, iqn, ist, istmin, istmax
1077 logical :: same_node, verbose_, packed_
1078 integer,
allocatable :: bstart(:), bend(:)
1082 safe_allocate(bstart(1:st%nst))
1083 safe_allocate(bend(1:st%nst))
1084 safe_allocate(st%group%iblock(1:st%nst))
1093 if (
present(skip))
then
1095 if (.not. skip(ist))
then
1103 if (
present(skip))
then
1104 do ist = st%nst, istmin, -1
1105 if (.not. skip(ist))
then
1112 if (
present(skip) .and. verbose_)
then
1122 st%group%nblocks = 0
1124 do ist = istmin, istmax
1127 st%group%iblock(ist) = st%group%nblocks + 1
1130 if (st%parallel_in_states .and. ist /= istmax)
then
1133 same_node = (st%node(ist + 1) == st%node(ist))
1136 if (ib == st%block_size .or. ist == istmax .or. .not. same_node)
then
1138 st%group%nblocks = st%group%nblocks + 1
1139 bend(st%group%nblocks) = ist
1140 if (ist /= istmax) bstart(st%group%nblocks + 1) = ist + 1
1144 safe_allocate(st%group%psib(1:st%group%nblocks, st%d%kpt%start:st%d%kpt%end))
1146 safe_allocate(st%group%block_is_local(1:st%group%nblocks, 1:st%nik))
1147 st%group%block_is_local = .false.
1148 st%group%block_start = -1
1149 st%group%block_end = -2
1151 do ib = 1, st%group%nblocks
1152 if (bstart(ib) >= st%st_start .and. bend(ib) <= st%st_end)
then
1153 if (st%group%block_start == -1) st%group%block_start = ib
1154 st%group%block_end = ib
1155 do iqn = st%d%kpt%start, st%d%kpt%end
1156 st%group%block_is_local(ib, iqn) = .
true.
1159 call dwfs_elec_init(st%group%psib(ib, iqn), st%d%dim, bstart(ib), bend(ib), mesh%np_part, iqn, &
1160 special=.
true., packed=packed_)
1162 call zwfs_elec_init(st%group%psib(ib, iqn), st%d%dim, bstart(ib), bend(ib), mesh%np_part, iqn, &
1163 special=.
true., packed=packed_)
1170 safe_allocate(st%group%block_range(1:st%group%nblocks, 1:2))
1171 safe_allocate(st%group%block_size(1:st%group%nblocks))
1173 st%group%block_range(1:st%group%nblocks, 1) = bstart(1:st%group%nblocks)
1174 st%group%block_range(1:st%group%nblocks, 2) = bend(1:st%group%nblocks)
1175 st%group%block_size(1:st%group%nblocks) = bend(1:st%group%nblocks) - bstart(1:st%group%nblocks) + 1
1177 st%group%block_initialized = .
true.
1179 safe_allocate(st%group%block_node(1:st%group%nblocks, 1:st%nik))
1180 st%group%block_node = 0
1182 assert(
allocated(st%node))
1183 assert(all(st%node >= 0) .and. all(st%node < st%mpi_grp%size))
1185 do iqn = st%d%kpt%start, st%d%kpt%end
1186 do ib = st%group%block_start, st%group%block_end
1187 st%group%block_node(ib, iqn) = st%st_kpt_mpi_grp%rank
1196 do ib = 1, st%group%nblocks
1202 if (st%group%block_size(ib) > 0)
then
1232 safe_deallocate_a(bstart)
1233 safe_deallocate_a(bend)
1258 type(
grid_t),
intent(in) :: gr
1260 real(real64) :: fsize
1264 safe_allocate(st%rho(1:gr%np_part, 1:st%d%nspin))
1267 fsize = gr%np_part*8.0_real64*st%block_size
1279 class(
space_t),
intent(in) :: space
1280 class(
mesh_t),
intent(in) :: mesh
1284 if (.not.
allocated(st%current))
then
1285 safe_allocate(st%current(1:mesh%np_part, 1:space%dim, 1:st%d%nspin))
1289 if (.not.
allocated(st%current_para))
then
1290 safe_allocate(st%current_para(1:mesh%np_part, 1:space%dim, 1:st%d%nspin))
1294 if (.not.
allocated(st%current_dia))
then
1295 safe_allocate(st%current_dia(1:mesh%np_part, 1:space%dim, 1:st%d%nspin))
1299 if (.not.
allocated(st%current_mag))
then
1300 safe_allocate(st%current_mag(1:mesh%np_part, 1:space%dim, 1:st%d%nspin))
1304 if (.not.
allocated(st%current_kpt))
then
1305 safe_allocate(st%current_kpt(1:mesh%np,1:space%dim,st%d%kpt%start:st%d%kpt%end))
1384 default = option__statesorthogonalization__cholesky_serial
1385#ifdef HAVE_SCALAPACK
1387 default = option__statesorthogonalization__cholesky_parallel
1391 call parse_variable(namespace,
'StatesOrthogonalization', default, st%orth_method)
1412 call parse_variable(namespace,
'StatesDeviceMemory', -512.0_real64, st%gpu_states_mem)
1422 subroutine states_elec_copy(stout, stin, exclude_wfns, exclude_eigenval, special, dest_type, copy_data)
1425 logical,
optional,
intent(in) :: exclude_wfns
1426 logical,
optional,
intent(in) :: exclude_eigenval
1427 logical,
optional,
intent(in) :: special
1428 type(
type_t),
optional,
intent(in) :: dest_type
1430 logical,
optional,
intent(in) :: copy_data
1434 logical :: exclude_wfns_
1443 safe_allocate_source_a(stout%kweights, stin%kweights)
1444 stout%nik = stin%nik
1448 stout%wfs_type = stin%wfs_type
1449 if (
present(dest_type))
then
1450 stout%wfs_type = dest_type
1452 stout%nst = stin%nst
1453 stout%block_size = stin%block_size
1454 stout%orth_method = stin%orth_method
1456 stout%gpu_states_mem = stin%gpu_states_mem
1457 stout%pack_states = stin%pack_states
1459 stout%only_userdef_istates = stin%only_userdef_istates
1460 stout%requires_generalized_overlap = stin%requires_generalized_overlap
1462 if (.not. exclude_wfns_)
then
1463 safe_allocate_source_a(stout%rho, stin%rho)
1466 stout%uniform_occ = stin%uniform_occ
1469 safe_allocate_source_a(stout%eigenval, stin%eigenval)
1470 safe_allocate_source_a(stout%occ, stin%occ)
1471 safe_allocate_source_a(stout%spin, stin%spin)
1476 stout%group%nblocks = stin%group%nblocks
1478 safe_allocate_source_a(stout%user_def_states, stin%user_def_states)
1480 safe_allocate_source_a(stout%current, stin%current)
1481 safe_allocate_source_a(stout%current_kpt, stin%current_kpt)
1482 safe_allocate_source_a(stout%rho_core, stin%rho_core)
1483 safe_allocate_source_a(stout%frozen_rho, stin%frozen_rho)
1484 safe_allocate_source_a(stout%frozen_tau, stin%frozen_tau)
1485 safe_allocate_source_a(stout%frozen_gdens, stin%frozen_gdens)
1486 safe_allocate_source_a(stout%frozen_ldens, stin%frozen_ldens)
1488 stout%fixed_occ = stin%fixed_occ
1489 stout%restart_fixed_occ = stin%restart_fixed_occ
1491 stout%fixed_spins = stin%fixed_spins
1493 stout%qtot = stin%qtot
1494 stout%val_charge = stin%val_charge
1498 stout%parallel_in_states = stin%parallel_in_states
1501 call mpi_grp_copy(stout%dom_st_kpt_mpi_grp, stin%dom_st_kpt_mpi_grp)
1502 call mpi_grp_copy(stout%st_kpt_mpi_grp, stin%st_kpt_mpi_grp)
1503 call mpi_grp_copy(stout%dom_st_mpi_grp, stin%dom_st_mpi_grp)
1504 safe_allocate_source_a(stout%node, stin%node)
1505 safe_allocate_source_a(stout%st_kpt_task, stin%st_kpt_task)
1507#ifdef HAVE_SCALAPACK
1513 stout%scalapack_compatible = stin%scalapack_compatible
1515 stout%lnst = stin%lnst
1516 stout%st_start = stin%st_start
1517 stout%st_end = stin%st_end
1521 stout%symmetrize_density = stin%symmetrize_density
1524 copy_data=copy_data, special=special, dest_type=dest_type)
1526 stout%packed = stin%packed
1528 stout%randomization = stin%randomization
1549 safe_deallocate_a(st%user_def_states)
1551 safe_deallocate_a(st%rho)
1552 safe_deallocate_a(st%eigenval)
1554 safe_deallocate_a(st%current)
1555 safe_deallocate_a(st%current_para)
1556 safe_deallocate_a(st%current_dia)
1557 safe_deallocate_a(st%current_mag)
1558 safe_deallocate_a(st%current_kpt)
1559 safe_deallocate_a(st%rho_core)
1560 safe_deallocate_a(st%frozen_rho)
1561 safe_deallocate_a(st%frozen_tau)
1562 safe_deallocate_a(st%frozen_gdens)
1563 safe_deallocate_a(st%frozen_ldens)
1564 safe_deallocate_a(st%occ)
1565 safe_deallocate_a(st%spin)
1566 safe_deallocate_a(st%kweights)
1569#ifdef HAVE_SCALAPACK
1575 safe_deallocate_a(st%node)
1576 safe_deallocate_a(st%st_kpt_task)
1578 if (st%parallel_in_states)
then
1579 safe_deallocate_a(st%ap%schedule)
1593 class(
mesh_t),
intent(in) :: mesh
1595 integer,
optional,
intent(in) :: ist_start_
1596 integer,
optional,
intent(in) :: ist_end_
1597 integer,
optional,
intent(in) :: ikpt_start_
1598 integer,
optional,
intent(in) :: ikpt_end_
1599 logical,
optional,
intent(in) :: normalized
1602 integer :: ist, ik, id, ist_start, ist_end, jst, ikpt_start, ikpt_end
1603 complex(real64) :: alpha, beta, zdotp_tmp
1604 real(real64),
allocatable :: dpsi(:, :)
1605 complex(real64),
allocatable :: zpsi(:, :), zpsi2(:)
1606 integer :: ikpoint, ip
1609 logical :: normalized_
1620 safe_allocate(dpsi(1:mesh%np, 1:st%d%dim))
1622 safe_allocate(zpsi(1:mesh%np, 1:st%d%dim))
1625 select case (st%d%ispin)
1628 do ik = ikpt_start, ikpt_end
1629 ikpoint = st%d%get_kpoint_index(ik)
1630 do ist = ist_start, ist_end
1634 pre_shift = mesh%pv%xlocal-1, &
1635 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1636 normalized = normalized)
1638 if(mesh%parallel_in_domains)
then
1644 call dmf_random(mesh, dpsi(:, 1), normalized = normalized)
1649 zpsi(ip,1) = cmplx(dpsi(ip,1),
m_zero, real64)
1658 pre_shift = mesh%pv%xlocal-1, &
1659 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1660 normalized = normalized)
1662 if(mesh%parallel_in_domains)
then
1668 call zmf_random(mesh, zpsi(:, 1), normalized = normalized)
1680 if (st%fixed_spins)
then
1682 do ik = ikpt_start, ikpt_end
1683 ikpoint = st%d%get_kpoint_index(ik)
1684 do ist = ist_start, ist_end
1688 pre_shift = mesh%pv%xlocal-1, &
1689 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1690 normalized = normalized)
1692 if(mesh%parallel_in_domains)
then
1698 call dmf_random(mesh, dpsi(:, 1), normalized = normalized)
1702 zpsi(ip,1) = cmplx(dpsi(ip,1),
m_zero, real64)
1708 pre_shift = mesh%pv%xlocal-1, &
1709 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1710 normalized = normalized)
1712 if(mesh%parallel_in_domains)
then
1718 call zmf_random(mesh, zpsi(:, 1), normalized = normalized)
1731 safe_allocate(zpsi2(1:mesh%np))
1732 do jst = ist_start, ist - 1
1734 zdotp_tmp =
zmf_dotp(mesh, zpsi(:, 1), zpsi2)
1735 call lalg_axpy(mesh%np, -zdotp_tmp, zpsi2, zpsi(:, 1))
1737 safe_deallocate_a(zpsi2)
1740 zpsi(1:mesh%np, 2) = zpsi(1:mesh%np, 1)
1745 beta = cmplx(st%spin(1, ist, ik) / abs(alpha), st%spin(2, ist, ik) / abs(alpha), real64)
1747 call lalg_scal(mesh%np, alpha, zpsi(:, 1))
1748 call lalg_scal(mesh%np, beta, zpsi(:, 2))
1753 do ik = ikpt_start, ikpt_end
1754 do ist = ist_start, ist_end
1758 pre_shift = mesh%pv%xlocal-1, &
1759 post_shift = mesh%pv%np_global - mesh%pv%xlocal - mesh%np + 1, &
1760 normalized = .false.)
1762 if(mesh%parallel_in_domains)
then
1768 call zmf_random(mesh, zpsi(:, id), normalized = .false.)
1784 safe_deallocate_a(dpsi)
1785 safe_deallocate_a(zpsi)
1796 class(
mesh_t),
intent(in) :: mesh
1797 logical,
optional,
intent(in) :: compute_spin
1801 real(real64) :: charge
1802 complex(real64),
allocatable :: zpsi(:, :)
1807 st%nik, st%nst, st%kweights)
1814 charge = charge + sum(st%occ(ist, 1:st%nik) * st%kweights(1:st%nik))
1816 if (abs(charge-st%qtot) > 1e-6_real64)
then
1817 message(1) =
'Occupations do not integrate to total charge.'
1818 write(
message(2),
'(6x,f12.8,a,f12.8)') charge,
' != ', st%qtot
1821 message(1) =
"There don't seem to be any electrons at all!"
1831 safe_allocate(zpsi(1:mesh%np, st%d%dim))
1832 do ik = st%d%kpt%start, st%d%kpt%end
1833 do ist = st%st_start, st%st_end
1835 st%spin(1:3, ist, ik) =
state_spin(mesh, zpsi)
1838 safe_deallocate_a(zpsi)
1840 if (st%parallel_in_states .or. st%d%kpt%parallel)
then
1855 real(real64),
optional,
intent(in) :: alt_eig(st%st_start:, st%d%kpt%start:)
1864 do ik = st%d%kpt%start, st%d%kpt%end
1865 if (
present(alt_eig))
then
1866 tot = tot + st%kweights(ik) * sum(st%occ(st%st_start:st%st_end, ik) * &
1867 alt_eig(st%st_start:st%st_end, ik))
1869 tot = tot + st%kweights(ik) * sum(st%occ(st%st_start:st%st_end, ik) * &
1870 st%eigenval(st%st_start:st%st_end, ik))
1874 if (st%parallel_in_states .or. st%d%kpt%parallel)
call comm_allreduce(st%st_kpt_mpi_grp, tot)
1886 logical :: default_scalapack_compatible
1897 st%parallel_in_states = .false.
1901 call mpi_grp_init(st%dom_st_kpt_mpi_grp, mc%dom_st_kpt_comm)
1905 default_scalapack_compatible =
calc_mode_par%scalapack_compat() .and. .not. st%d%kpt%parallel
1919 call parse_variable(namespace,
'ScaLAPACKCompatible', default_scalapack_compatible, st%scalapack_compatible)
1921#ifdef HAVE_SCALAPACK
1922 if (default_scalapack_compatible .neqv. st%scalapack_compatible)
then
1923 call messages_experimental(
'Setting ScaLAPACKCompatible to other than default', namespace=namespace)
1926 if (st%scalapack_compatible)
then
1933 st%scalapack_compatible = .false.
1939 call multicomm_create_all_pairs(st%mpi_grp, st%ap)
1942 if (st%nst < st%mpi_grp%size)
then
1943 message(1) =
"Have more processors than necessary"
1944 write(
message(2),
'(i4,a,i4,a)') st%mpi_grp%size,
" processors and ", st%nst,
" states."
1948 call distributed_init(st%dist, st%nst, st%mpi_grp%comm,
"states", scalapack_compat = st%scalapack_compatible)
1950 st%parallel_in_states = st%dist%parallel
1953 st%st_start = st%dist%start
1954 st%st_end = st%dist%end
1955 st%lnst = st%dist%nlocal()
1956 st%node(1:st%nst) = st%dist%process(1:st%nst)
1973 kinetic_energy_density, paramagnetic_current, density_gradient, density_laplacian, &
1974 gi_kinetic_energy_density, st_end)
1975 type(
grid_t),
intent(in) :: gr
1978 logical,
intent(in) :: nlcc
1979 real(real64),
contiguous,
optional,
target,
intent(out) :: kinetic_energy_density(:,:)
1980 real(real64),
contiguous,
optional,
target,
intent(out) :: paramagnetic_current(:,:,:)
1981 real(real64),
contiguous,
optional,
intent(out) :: density_gradient(:,:,:)
1982 real(real64),
contiguous,
optional,
intent(out) :: density_laplacian(:,:)
1983 real(real64),
contiguous,
optional,
intent(out) :: gi_kinetic_energy_density(:,:)
1984 integer,
optional,
intent(in) :: st_end
1986 real(real64),
pointer,
contiguous :: jp(:, :, :)
1987 real(real64),
pointer,
contiguous :: tau(:, :)
1988 complex(real64),
allocatable :: wf_psi(:,:), gwf_psi(:,:,:), wf_psi_conj(:,:), lwf_psi(:,:)
1989 real(real64),
allocatable :: abs_wf_psi(:,:), abs_gwf_psi(:,:)
1990 complex(real64),
allocatable :: psi_gpsi(:,:)
1991 complex(real64) :: c_tmp
1992 integer :: is, ik, ist, i_dim, st_dim, ii, st_end_
1993 real(real64) :: ww, kpoint(gr%der%dim)
1994 logical :: something_to_do
2002 something_to_do =
present(kinetic_energy_density) .or.
present(gi_kinetic_energy_density) .or. &
2003 present(paramagnetic_current) .or.
present(density_gradient) .or.
present(density_laplacian)
2004 assert(something_to_do)
2006 safe_allocate( wf_psi(1:gr%np_part, 1:st%d%dim))
2007 safe_allocate( wf_psi_conj(1:gr%np_part, 1:st%d%dim))
2008 safe_allocate(gwf_psi(1:gr%np, 1:gr%der%dim, 1:st%d%dim))
2009 safe_allocate(abs_wf_psi(1:gr%np, 1:st%d%dim))
2010 safe_allocate(abs_gwf_psi(1:gr%np, 1:st%d%dim))
2011 safe_allocate(psi_gpsi(1:gr%np, 1:st%d%dim))
2012 if (
present(density_laplacian))
then
2013 safe_allocate(lwf_psi(1:gr%np, 1:st%d%dim))
2017 if (
present(kinetic_energy_density)) tau => kinetic_energy_density
2020 if (
present(paramagnetic_current)) jp => paramagnetic_current
2024 if (
present(gi_kinetic_energy_density))
then
2026 safe_allocate(jp(1:gr%np, 1:gr%der%dim, 1:st%d%nspin))
2028 if (.not.
present(kinetic_energy_density))
then
2029 safe_allocate(tau(1:gr%np, 1:st%d%nspin))
2033 if (
associated(tau)) tau =
m_zero
2034 if (
associated(jp)) jp =
m_zero
2035 if (
present(density_gradient)) density_gradient(:,:,:) =
m_zero
2036 if (
present(density_laplacian)) density_laplacian(:,:) =
m_zero
2037 if (
present(gi_kinetic_energy_density)) gi_kinetic_energy_density =
m_zero
2039 do ik = st%d%kpt%start, st%d%kpt%end
2041 kpoint(1:gr%der%dim) = kpoints%get_point(st%d%get_kpoint_index(ik))
2042 is = st%d%get_spin_index(ik)
2044 do ist = st%st_start, st_end_
2045 ww = st%kweights(ik)*st%occ(ist, ik)
2051 do st_dim = 1, st%d%dim
2056 do st_dim = 1, st%d%dim
2057 call zderivatives_grad(gr%der, wf_psi(:,st_dim), gwf_psi(:,:,st_dim), set_bc = .false.)
2061 if (
present(density_laplacian))
then
2062 do st_dim = 1, st%d%dim
2063 call zderivatives_lapl(gr%der, wf_psi(:,st_dim), lwf_psi(:,st_dim), ghost_update = .false., set_bc = .false.)
2068 wf_psi_conj(1:gr%np, 1:st%d%dim) = conjg(wf_psi(1:gr%np,1:st%d%dim))
2070 do st_dim = 1, st%d%dim
2072 abs_wf_psi(ii, st_dim) = real(wf_psi_conj(ii, st_dim) * wf_psi(ii, st_dim), real64)
2077 if (
present(density_laplacian))
then
2080 density_laplacian(ii, is) = density_laplacian(ii, is) + &
2081 ww *
m_two*real(wf_psi_conj(ii, 1) * lwf_psi(ii, 1), real64)
2084 if (st%d%ispin ==
spinors)
then
2087 density_laplacian(ii, 2) = density_laplacian(ii, 2) + &
2088 ww *
m_two*real(wf_psi_conj(ii, 2) * lwf_psi(ii, 2), real64)
2093 c_tmp = ww*(lwf_psi(ii, 1) * wf_psi_conj(ii, 2) + wf_psi(ii, 1) * conjg(lwf_psi(ii, 2)))
2094 density_laplacian(ii, 3) = density_laplacian(ii, 3) + real(c_tmp, real64)
2095 density_laplacian(ii, 4) = density_laplacian(ii, 4) + aimag(c_tmp)
2100 if (
associated(tau))
then
2101 call lalg_axpy(gr%np, ww * sum(kpoint(1:gr%der%dim)**2), abs_wf_psi(:, 1), tau(:, is))
2102 if (st%d%ispin ==
spinors)
then
2103 call lalg_axpy(gr%np, ww * sum(kpoint(1:gr%der%dim)**2), abs_wf_psi(:, 2), tau(:, 2))
2107 c_tmp = ww * sum(kpoint(1:gr%der%dim)**2) * wf_psi(ii, 1) * wf_psi_conj(ii, 2)
2108 tau(ii, 3) = tau(ii, 3) + real(c_tmp, real64)
2109 tau(ii, 4) = tau(ii, 4) + aimag(c_tmp)
2114 do i_dim = 1, gr%der%dim
2118 do st_dim = 1, st%d%dim
2121 psi_gpsi(ii, st_dim) = wf_psi_conj(ii, st_dim) * gwf_psi(ii, i_dim, st_dim)
2124 do st_dim = 1, st%d%dim
2127 abs_gwf_psi(ii, st_dim) = real(conjg(gwf_psi(ii, i_dim, st_dim)) &
2128 * gwf_psi(ii, i_dim, st_dim), real64)
2133 if (
present(density_gradient))
then
2136 density_gradient(ii, i_dim, is) = density_gradient(ii, i_dim, is) &
2137 + ww *
m_two * real(psi_gpsi(ii, 1), real64)
2140 if (st%d%ispin ==
spinors)
then
2143 density_gradient(ii, i_dim, 2) = density_gradient(ii, i_dim, 2) &
2144 + ww *
m_two*real(psi_gpsi(ii, 2), real64)
2149 c_tmp = ww * (gwf_psi(ii, i_dim, 1) * wf_psi_conj(ii, 2) + wf_psi(ii, 1) * conjg(gwf_psi(ii, i_dim, 2)))
2150 density_gradient(ii, i_dim, 3) = density_gradient(ii, i_dim, 3) + real(c_tmp, real64)
2151 density_gradient(ii, i_dim, 4) = density_gradient(ii, i_dim, 4) + aimag(c_tmp)
2156 if (
present(density_laplacian))
then
2157 call lalg_axpy(gr%np, ww*
m_two, abs_gwf_psi(:,1), density_laplacian(:,is))
2158 if (st%d%ispin ==
spinors)
then
2159 call lalg_axpy(gr%np, ww*
m_two, abs_gwf_psi(:,2), density_laplacian(:,2))
2162 c_tmp =
m_two * ww * gwf_psi(ii, i_dim, 1) * conjg(gwf_psi(ii, i_dim, 2))
2163 density_laplacian(ii, 3) = density_laplacian(ii, 3) + real(c_tmp, real64)
2164 density_laplacian(ii, 4) = density_laplacian(ii, 4) + aimag(c_tmp)
2172 if (
associated(jp))
then
2176 jp(ii, i_dim, is) = jp(ii, i_dim, is) + &
2177 ww*(aimag(psi_gpsi(ii, 1)) - abs_wf_psi(ii, 1)*kpoint(i_dim))
2180 if (st%d%ispin ==
spinors)
then
2183 jp(ii, i_dim, 2) = jp(ii, i_dim, 2) + &
2184 ww*( aimag(psi_gpsi(ii, 2)) - abs_wf_psi(ii, 2)*kpoint(i_dim))
2189 c_tmp = -ww*
m_half*
m_zi*(gwf_psi(ii, i_dim, 1)*wf_psi_conj(ii, 2) - wf_psi(ii, 1)*conjg(gwf_psi(ii, i_dim, 2)) &
2190 -
m_two *
m_zi*wf_psi(ii, 1)*wf_psi_conj(ii, 2)*kpoint(i_dim))
2191 jp(ii, i_dim, 3) = jp(ii, i_dim, 3) + real(c_tmp, real64)
2192 jp(ii, i_dim, 4) = jp(ii, i_dim, 4) + aimag(c_tmp)
2201 if (
associated(tau))
then
2204 tau(ii, is) = tau(ii, is) + ww*(abs_gwf_psi(ii,1) &
2205 -
m_two*aimag(psi_gpsi(ii, 1))*kpoint(i_dim))
2208 if (st%d%ispin ==
spinors)
then
2211 tau(ii, 2) = tau(ii, 2) + ww*(abs_gwf_psi(ii, 2) &
2212 -
m_two*aimag(psi_gpsi(ii, 2))*kpoint(i_dim))
2217 c_tmp = ww * ( gwf_psi(ii, i_dim, 1)*conjg(gwf_psi(ii, i_dim, 2)) &
2218 +
m_zi * (gwf_psi(ii,i_dim,1)*wf_psi_conj(ii, 2) &
2219 - wf_psi(ii, 1)*conjg(gwf_psi(ii,i_dim,2)))*kpoint(i_dim))
2220 tau(ii, 3) = tau(ii, 3) + real(c_tmp, real64)
2221 tau(ii, 4) = tau(ii, 4) + aimag(c_tmp)
2231 safe_deallocate_a(wf_psi_conj)
2232 safe_deallocate_a(abs_wf_psi)
2233 safe_deallocate_a(abs_gwf_psi)
2234 safe_deallocate_a(psi_gpsi)
2236 if (.not.
present(gi_kinetic_energy_density))
then
2237 if (.not.
present(paramagnetic_current))
then
2238 safe_deallocate_p(jp)
2240 if (.not.
present(kinetic_energy_density))
then
2241 safe_deallocate_p(tau)
2245 if (st%parallel_in_states .or. st%d%kpt%parallel)
call reduce_all(st%st_kpt_mpi_grp)
2250 if (st%symmetrize_density)
then
2251 do is = 1, st%d%nspin
2252 if (
associated(tau))
then
2256 if (
present(density_laplacian))
then
2260 if (
associated(jp))
then
2264 if (
present(density_gradient))
then
2271 if (
allocated(st%rho_core) .and. nlcc .and. (
present(density_laplacian) .or.
present(density_gradient)))
then
2273 wf_psi(ii, 1) = st%rho_core(ii)/st%d%spin_channels
2278 if (
present(density_gradient))
then
2281 do is = 1, st%d%spin_channels
2283 do i_dim = 1, gr%der%dim
2285 density_gradient(ii, i_dim, is) = density_gradient(ii, i_dim, is) + &
2286 real(gwf_psi(ii, i_dim, 1), real64)
2294 if (
present(density_laplacian))
then
2298 do is = 1, st%d%spin_channels
2301 density_laplacian(ii, is) = density_laplacian(ii, is) + real(lwf_psi(ii, 1))
2310 if (
allocated(st%frozen_tau) .and. .not.
present(st_end) .and.
associated(tau))
then
2313 if (
allocated(st%frozen_gdens) .and. .not.
present(st_end) .and.
present(density_gradient))
then
2314 do is = 1, st%d%nspin
2315 call lalg_axpy(gr%np, gr%der%dim,
m_one, st%frozen_gdens(:,:,is), density_gradient(:,:,is))
2318 if (
allocated(st%frozen_ldens) .and. .not.
present(st_end) .and.
present(density_laplacian))
then
2319 call lalg_axpy(gr%np, st%d%nspin,
m_one, st%frozen_ldens, density_laplacian)
2322 safe_deallocate_a(wf_psi)
2323 safe_deallocate_a(gwf_psi)
2324 safe_deallocate_a(lwf_psi)
2328 if (
present(gi_kinetic_energy_density))
then
2329 do is = 1, st%d%nspin
2330 assert(
associated(tau))
2331 gi_kinetic_energy_density(1:gr%np, is) = tau(1:gr%np, is)
2334 assert(
associated(jp))
2335 if (st%d%ispin /=
spinors)
then
2336 do is = 1, st%d%nspin
2339 if (st%rho(ii, is) < 1.0e-7_real64) cycle
2340 gi_kinetic_energy_density(ii, is) = &
2341 gi_kinetic_energy_density(ii, is) - sum(jp(ii,1:gr%der%dim, is)**2)/st%rho(ii, is)
2347 gi_kinetic_energy_density(ii, 1) = gi_kinetic_energy_density(ii, 1) &
2348 - sum(jp(ii,1:gr%der%dim, 1)**2)/(safe_tol(st%rho(ii, 1),
m_epsilon))
2349 gi_kinetic_energy_density(ii, 2) = gi_kinetic_energy_density(ii, 2) &
2350 - sum(jp(ii,1:gr%der%dim, 2)**2)/(safe_tol(st%rho(ii, 2),
m_epsilon))
2351 gi_kinetic_energy_density(ii, 3) = &
2352 gi_kinetic_energy_density(ii, 3) - sum(jp(ii,1:gr%der%dim, 3)**2 + jp(ii,1:gr%der%dim, 4)**2) &
2353 /(safe_tol((st%rho(ii, 3)**2 + st%rho(ii, 4)**2),
m_epsilon))*st%rho(ii, 3)
2354 gi_kinetic_energy_density(ii, 4) = &
2355 gi_kinetic_energy_density(ii, 4) + sum(jp(ii,1:gr%der%dim, 3)**2 + jp(ii,1:gr%der%dim, 4)**2) &
2356 /(safe_tol((st%rho(ii, 3)**2 + st%rho(ii, 4)**2),
m_epsilon))*st%rho(ii, 4)
2362 if (.not.
present(kinetic_energy_density))
then
2363 safe_deallocate_p(tau)
2365 if (.not.
present(paramagnetic_current))
then
2366 safe_deallocate_p(jp)
2381 if (
associated(tau))
call comm_allreduce(grp, tau, dim = (/gr%np, st%d%nspin/))
2383 if (
present(density_laplacian))
call comm_allreduce(grp, density_laplacian, dim = (/gr%np, st%d%nspin/))
2385 do is = 1, st%d%nspin
2386 if (
associated(jp))
call comm_allreduce(grp, jp(:, :, is), dim = (/gr%np, gr%der%dim/))
2388 if (
present(density_gradient))
then
2389 call comm_allreduce(grp, density_gradient(:, :, is), dim = (/gr%np, gr%der%dim/))
2403 type(
mesh_t),
intent(in) :: mesh
2404 complex(real64),
contiguous,
intent(in) :: f1(:, :)
2405 real(real64) :: spin(1:3)
2407 complex(real64) :: z
2411 z =
zmf_dotp(mesh, f1(:, 1) , f1(:, 2))
2413 spin(1) =
m_two*real(z, real64)
2414 spin(2) =
m_two*aimag(z)
2426 integer,
intent(in) :: ist
2440 integer,
intent(in) :: ist
2441 integer,
intent(in) :: ik
2446 ik >= st%d%kpt%start .and. ik <= st%d%kpt%end
2456 class(
mesh_t),
intent(in) :: mesh
2462 memory = memory + real(storage_size(0.0_real64)/8, real64) * &
2463 real(mesh%np_part_global, real64) *st%d%dim *
real(st%nst, real64) *st%d%kpt%nglobal()
2473 logical,
optional,
intent(in) :: copy
2476 integer(int64) :: max_mem, mem
2488 if (accel_is_enabled())
then
2489 max_mem = accel_global_memory_size()
2491 if (st%gpu_states_mem > m_one)
then
2492 max_mem = int(st%gpu_states_mem, int64)*(1024_8)**2
2493 else if (st%gpu_states_mem < 0.0_real64)
then
2494 max_mem = max_mem + int(st%gpu_states_mem, int64)*(1024_8)**2
2496 max_mem = int(st%gpu_states_mem*real(max_mem, real64) , int64)
2499 max_mem = huge(max_mem)
2503 qnloop:
do iqn = st%d%kpt%start, st%d%kpt%end
2504 do ib = st%group%block_start, st%group%block_end
2506 mem = mem + st%group%psib(ib, iqn)%pack_total_size()
2508 if (mem > max_mem)
then
2509 call messages_write(
'Not enough device memory to store all states simultaneously.', new_line = .
true.)
2510 call messages_write(
'Only ')
2511 call messages_write(ib - st%group%block_start)
2512 call messages_write(
' of ')
2513 call messages_write(st%group%block_end - st%group%block_start + 1)
2514 call messages_write(
' blocks will be stored in device memory.', new_line = .
true.)
2515 call messages_warning()
2519 call st%group%psib(ib, iqn)%do_pack(copy)
2531 logical,
optional,
intent(in) :: copy
2540 do iqn = st%d%kpt%start, st%d%kpt%end
2541 do ib = st%group%block_start, st%group%block_end
2542 if (st%group%psib(ib, iqn)%is_packed())
call st%group%psib(ib, iqn)%do_unpack(copy)
2555 type(namespace_t),
intent(in) :: namespace
2559 call messages_print_with_emphasis(msg=
"States", namespace=namespace)
2561 write(message(1),
'(a,f12.3)')
'Total electronic charge = ', st%qtot
2562 write(message(2),
'(a,i8)')
'Number of states = ', st%nst
2563 write(message(3),
'(a,i8)')
'States block-size = ', st%block_size
2564 call messages_info(3, namespace=namespace)
2566 call messages_print_with_emphasis(namespace=namespace)
2579 do iqn = st%d%kpt%start, st%d%kpt%end
2580 do ib = st%group%block_start, st%group%block_end
2581 call batch_set_zero(st%group%psib(ib, iqn))
2591 integer pure function states_elec_block_min(st, ib) result(range)
2593 integer,
intent(in) :: ib
2595 range = st%group%block_range(ib, 1)
2601 integer pure function states_elec_block_max(st, ib) result(range)
2603 integer,
intent(in) :: ib
2605 range = st%group%block_range(ib, 2)
2611 integer pure function states_elec_block_size(st, ib) result(size)
2613 integer,
intent(in) :: ib
2615 size = st%group%block_size(ib)
2621 logical pure function states_elec_all_states_gpu_packed(st) result(all_packed)
2627 do ik = st%d%kpt%start, st%d%kpt%end
2628 do ib = st%group%block_start, st%group%block_end
2629 if (st%group%psib(ib, ik)%status() /= batch_device_packed)
then
2630 all_packed = .false.
2653 subroutine occupied_states(st, namespace, ik, n_filled, n_partially_filled, n_half_filled, &
2654 filled, partially_filled, half_filled)
2656 type(namespace_t),
intent(in) :: namespace
2657 integer,
intent(in) :: ik
2658 integer,
intent(out) :: n_filled, n_partially_filled, n_half_filled
2659 integer,
optional,
intent(out) :: filled(:), partially_filled(:), half_filled(:)
2665 if (
present(filled)) filled(:) = 0
2666 if (
present(partially_filled)) partially_filled(:) = 0
2667 if (
present(half_filled)) half_filled(:) = 0
2669 n_partially_filled = 0
2672 select case (st%d%ispin)
2675 if (abs(st%occ(ist, ik) - m_two) < m_min_occ)
then
2676 n_filled = n_filled + 1
2677 if (
present(filled)) filled(n_filled) = ist
2678 else if (abs(st%occ(ist, ik) - m_one) < m_min_occ)
then
2679 n_half_filled = n_half_filled + 1
2680 if (
present(half_filled)) half_filled(n_half_filled) = ist
2681 else if (st%occ(ist, ik) > m_min_occ)
then
2682 n_partially_filled = n_partially_filled + 1
2683 if (
present(partially_filled)) partially_filled(n_partially_filled) = ist
2684 else if (abs(st%occ(ist, ik)) > m_min_occ)
then
2685 write(message(1),*)
'Internal error in occupied_states: Illegal occupation value ', st%occ(ist, ik)
2686 call messages_fatal(1, namespace=namespace)
2689 case (spin_polarized, spinors)
2691 if (abs(st%occ(ist, ik)-m_one) < m_min_occ)
then
2692 n_filled = n_filled + 1
2693 if (
present(filled)) filled(n_filled) = ist
2694 else if (st%occ(ist, ik) > m_min_occ)
then
2695 n_partially_filled = n_partially_filled + 1
2696 if (
present(partially_filled)) partially_filled(n_partially_filled) = ist
2697 else if (abs(st%occ(ist, ik)) > m_min_occ)
then
2698 write(message(1),*)
'Internal error in occupied_states: Illegal occupation value ', st%occ(ist, ik)
2699 call messages_fatal(1, namespace=namespace)
2711 type(multicomm_t),
intent(in) :: mc
2714 call distributed_init(this%d%kpt, this%nik, mc%group_comm(p_strategy_kpoints),
"k-points")
2729 if (.not.
allocated(st%st_kpt_task))
then
2730 safe_allocate(st%st_kpt_task(0:st%st_kpt_mpi_grp%size-1, 1:4))
2733 st%st_kpt_task(0:st%st_kpt_mpi_grp%size-1, :) = 0
2734 st%st_kpt_task(st%st_kpt_mpi_grp%rank, :) = [st%st_start, st%st_end, st%d%kpt%start, st%d%kpt%end]
2736 if (st%parallel_in_states .or. st%d%kpt%parallel)
then
2737 call comm_allreduce(st%st_kpt_mpi_grp, st%st_kpt_task)
2748 type(kpoints_t),
intent(in) :: kpoints
2749 type(namespace_t),
intent(in) :: namespace
2752 type(states_elec_dim_t),
pointer :: dd
2759 st%nik = kpoints_number(kpoints)
2761 if (dd%ispin == spin_polarized) st%nik = 2*st%nik
2763 safe_allocate(st%kweights(1:st%nik))
2766 ik = dd%get_kpoint_index(iq)
2767 st%kweights(iq) = kpoints%get_weight(ik)
2779 call io_mkdir(
'debug/', namespace)
2780 iunit = io_open(
'debug/kpoints', namespace, action =
'write')
2781 call kpoints%write_info(iunit=iunit, absolute_coordinates = .
true.)
2782 call io_close(iunit)
2796 class(mesh_t),
intent(in) :: gr
2797 real(real64) :: dipole(1:gr%box%dim)
2800 real(real64) :: e_dip(1:gr%box%dim, this%d%spin_channels)
2804 do ispin = 1, this%d%spin_channels
2805 call dmf_dipole(gr, this%rho(:, ispin), e_dip(:, ispin))
2808 dipole(:) = sum(e_dip(:, 1:this%d%spin_channels), 2)
2816#include "states_elec_inc.F90"
2819#include "complex.F90"
2820#include "states_elec_inc.F90"
initialize a batch with existing memory
constant times a vector plus a vector
scales a vector by a constant
Prints out to iunit a message in the form: ["InputVariable" = value] where "InputVariable" is given b...
subroutine, public accel_free_buffer(this, async)
pure logical function, public accel_is_enabled()
type(accel_t), public accel
This module implements batches of mesh functions.
This module implements common operations on batches of mesh functions.
This module provides the BLACS processor grid.
subroutine, public blacs_proc_grid_init(this, mpi_grp, procdim)
Initializes a blacs context from an MPI communicator with topological information.
subroutine, public blacs_proc_grid_end(this)
subroutine, public blacs_proc_grid_copy(cin, cout)
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 calculates the derivatives (gradients, Laplacians, etc.) of a function.
subroutine, public zderivatives_grad(der, ff, op_ff, ghost_update, set_bc, to_cartesian)
apply the gradient to a mesh function
subroutine, public zderivatives_lapl(der, ff, op_ff, ghost_update, set_bc, factor)
apply the Laplacian to a mesh function
subroutine, public distributed_end(this)
subroutine, public distributed_init(this, total, comm, tag, scalapack_compat)
Distribute N instances across M processes of communicator comm
subroutine, public distributed_copy(in, out)
Create a copy of a distributed instance.
subroutine, public distributed_init_serial(this, total)
Serial initialization of a distributed instance. The calling process is assigned all total instances,...
integer, parameter, public unpolarized
Parameters...
integer, parameter, public spinors
integer, parameter, public spin_polarized
real(real64), parameter, public m_two
real(real64), parameter, public m_zero
real(real64), parameter, public m_fourth
complex(real64), parameter, public m_zi
real(real64), parameter, public m_epsilon
type(conf_t), public conf
Global instance of Octopus configuration.
real(real64), parameter, public m_half
real(real64), parameter, public m_one
This module implements the underlying real-space grid.
subroutine, public dgrid_symmetrize_vector_field(gr, field, suppress_warning)
subroutine, public dgrid_symmetrize_scalar_field(gr, field, suppress_warning)
logical pure function, public kpoints_point_is_gamma(this, ik)
System information (time, memory, sysname)
This module is intended to contain "only mathematical" functions and procedures.
integer pure function, public pad_pow2(size)
create array size, which is padded to powers of 2
This module defines functions over batches of mesh functions.
subroutine, public zmesh_batch_exchange_points(mesh, aa, forward_map, backward_map)
This functions exchanges points of a mesh according to a certain map. Two possible maps can be given....
subroutine, public dmesh_batch_exchange_points(mesh, aa, forward_map, backward_map)
This functions exchanges points of a mesh according to a certain map. Two possible maps can be given....
This module defines various routines, operating on mesh functions.
subroutine, public zmf_random(mesh, ff, pre_shift, post_shift, seed, normalized)
This subroutine fills a function with random values.
subroutine, public dmf_random(mesh, ff, pre_shift, post_shift, seed, normalized)
This subroutine fills a function with random values.
subroutine, public zmf_normalize(mesh, dim, psi, norm)
Normalize a mesh function psi.
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)
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)
general module for modelmb particles
subroutine, public modelmb_particles_end(this)
subroutine, public modelmb_particles_init(this, namespace, space, nst)
==============================================================
subroutine, public modelmb_particles_copy(modelmb_out, modelmb_in)
subroutine mpi_grp_copy(mpi_grp_out, mpi_grp_in)
MPI_THREAD_FUNNELED allows for calls to MPI from an OMP region if the thread is the team master.
type(mpi_comm), parameter, public mpi_comm_undefined
used to indicate a communicator has not been initialized
subroutine mpi_grp_init(grp, comm)
Initialize MPI group instance.
This module handles the communicators for the various parallelization strategies.
logical pure function, public multicomm_strategy_is_parallel(mc, level)
subroutine, public multicomm_all_pairs_copy(apout, apin)
logical pure function, public multicomm_have_slaves(this)
logical function, public parse_is_defined(namespace, name)
integer function, public parse_block(namespace, name, blk, check_varinfo_)
/* 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 smear_find_fermi_energy(this, namespace, eigenvalues, occupations, qtot, nik, nst, kweights)
subroutine, public smear_fill_occupations(this, eigenvalues, occupations, kweights, nik, nst)
subroutine, public smear_copy(to, from)
integer, parameter, public smear_fixed_occ
subroutine, public smear_init(this, namespace, ispin, fixed_occ, integral_occs, kpoints)
logical pure function, public smear_is_semiconducting(this)
subroutine, public states_set_complex(st)
pure logical function, public states_are_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)
This module handles groups of electronic batches and their parallel distribution.
subroutine, public states_elec_group_copy(d, group_in, group_out, copy_data, special, dest_type)
make a copy of a group
subroutine, public states_elec_group_end(this, d)
finalize the local blocks of wave functions and release local arrays
real(real64) function, public states_elec_wfns_memory(st, mesh)
return the memory usage of a states_elec_t object
integer pure function, public states_elec_block_max(st, ib)
return index of last state in block ib
subroutine zstates_elec_generate_random_vector(mesh, st, vector, normalized, reset_seed)
Generate a random vector.
subroutine, public states_elec_null(st)
subroutine, public states_elec_distribute_nodes(st, namespace, mc)
Distribute states over the processes for states parallelization.
subroutine, public states_elec_fermi(st, namespace, mesh, compute_spin)
calculate the Fermi level for the states in this object
logical function, public state_kpt_is_local(st, ist, ik)
check whether a given state (ist, ik) is on the local node
subroutine, public states_elec_calc_quantities(gr, st, kpoints, nlcc, kinetic_energy_density, paramagnetic_current, density_gradient, density_laplacian, gi_kinetic_energy_density, st_end)
calculated selected quantities
real(real64) function, dimension(1:gr%box%dim) states_elec_calculate_dipole(this, gr)
calculate the expectation value of the dipole moment of electrons
subroutine, public states_elec_densities_init(st, gr)
subroutine, public states_elec_end(st)
finalize the states_elec_t object
subroutine zstates_elec_get_state1(st, mesh, idim, ist, iqn, psi)
Write one component (dim) of a wave function into a state_elec_t object.
subroutine, public states_elec_deallocate_wfns(st)
Deallocates the KS wavefunctions defined within a states_elec_t structure.
subroutine, public states_elec_allocate_wfns(st, mesh, wfs_type, skip, packed)
Allocates the KS wavefunctions defined within a states_elec_t structure.
subroutine zstates_elec_get_points1(st, start_point, end_point, iqn, psi)
Returns the value of all the states for given k-point in the range of points [start_point:end_point].
subroutine states_elec_read_initial_occs(st, namespace, excess_charge, kpoints)
Reads from the input file the initial occupations, if the block "Occupations" is present....
subroutine zstates_elec_set_state1(st, mesh, idim, ist, iqn, psi)
get one dimension of local wave function for given k-point and states index from a states_elec_t obje...
real(real64) function, public states_elec_eigenvalues_sum(st, alt_eig)
function to calculate the eigenvalues sum using occupations as weights
integer, parameter, public par_independent
Method used to generate random states.
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
subroutine dstates_elec_generate_random_vector(mesh, st, vector, normalized, reset_seed)
Generate a random vector.
subroutine, public occupied_states(st, namespace, ik, n_filled, n_partially_filled, n_half_filled, filled, partially_filled, half_filled)
return information about occupied orbitals in many-body state
subroutine dstates_elec_get_state2(st, mesh, ist, iqn, psi)
Write a wave function into a state_elec_t object.
subroutine zstates_elec_set_state2(st, mesh, ist, iqn, psi)
get local wave function for given k-point and states index from a states_elec_t object
subroutine zstates_elec_get_state2(st, mesh, ist, iqn, psi)
Write a wave function into a state_elec_t object.
subroutine dstates_elec_get_points1(st, start_point, end_point, iqn, psi)
Returns the value of all the states for given k-point in the range of points [start_point:end_point].
integer pure function, public states_elec_block_size(st, ib)
return number of states in block ib
subroutine, public kpoints_distribute(this, mc)
distribute k-points over the nodes in the corresponding communicator
integer, parameter, public par_dependent
subroutine states_elec_pack(st, copy)
pack the batches in this states object
subroutine, public states_elec_choose_kpoints(st, kpoints, namespace)
double up k-points for SPIN_POLARIZED calculations
subroutine zstates_elec_get_state3(st, mesh, iqn, psi)
get local wave functions for given k-point from a states_elec_t object
logical function, public state_is_local(st, ist)
check whether a given state (ist) is on the local node
subroutine dstates_elec_set_state1(st, mesh, idim, ist, iqn, psi)
get one dimension of local wave function for given k-point and states index from a states_elec_t obje...
subroutine, public states_elec_exec_init(st, namespace, mc)
Further initializations.
subroutine dstates_elec_set_state4(st, mesh, psi)
set all local wave functions in a states_elec_t object
subroutine dstates_elec_set_state3(st, mesh, iqn, psi)
set local wave functions for given k-point in a states_elec_t object
subroutine states_elec_write_info(st, namespace)
write information about the states object
subroutine states_elec_init_block(st, mesh, verbose, skip, packed)
Initializes the data components in st that describe how the states are distributed in blocks:
real(real64) function, dimension(1:3) state_spin(mesh, f1)
calculate the spin vector for a spinor wave function f1
logical pure function, public states_elec_all_states_gpu_packed(st)
return boolean indicating whether all states are packed on the GPU
subroutine states_elec_kpoints_distribution(st)
Assign the start and end indices for states and kpoints, for "st_kpt_mpi_grp" communicator.
subroutine zstates_elec_get_state4(st, mesh, psi)
get all local wave functions from a states_elec_t object
subroutine, public states_elec_init(st, namespace, space, valence_charge, kpoints, calc_mode_id)
Initialize a new states_elec_t object.
subroutine, public states_elec_generate_random(st, mesh, kpoints, ist_start_, ist_end_, ikpt_start_, ikpt_end_, normalized)
randomize states
subroutine dstates_elec_get_state1(st, mesh, idim, ist, iqn, psi)
Write one component (dim) of a wave function into a state_elec_t object.
subroutine dstates_elec_set_state2(st, mesh, ist, iqn, psi)
get local wave function for given k-point and states index from a states_elec_t object
subroutine zstates_elec_set_state4(st, mesh, psi)
set all local wave functions in a states_elec_t object
subroutine states_elec_read_initial_spins(st, namespace)
Reads, if present, the "InitialSpins" block.
subroutine dstates_elec_get_state3(st, mesh, iqn, psi)
get local wave functions for given k-point from a states_elec_t object
subroutine dstates_elec_get_points2(st, start_point, end_point, psi)
Returns the value of all the states in the range of points [start_point:end_point].
integer pure function, public states_elec_block_min(st, ib)
return index of first state in block ib
subroutine states_elec_unpack(st, copy)
unpack the batches in this states object
subroutine, public states_elec_look(restart, nik, dim, nst, ierr)
Reads the 'states' file in the restart directory, and finds out the nik, dim, and nst contained in it...
subroutine dstates_elec_get_state4(st, mesh, psi)
get all local wave functions from a states_elec_t object
subroutine, public states_elec_allocate_current(st, space, mesh)
subroutine, public states_elec_set_zero(st)
Explicitly set all wave functions in the states to zero.
subroutine zstates_elec_set_state3(st, mesh, iqn, psi)
set local wave functions for given k-point in a states_elec_t object
subroutine zstates_elec_get_points2(st, start_point, end_point, psi)
Returns the value of all the states in the range of points [start_point:end_point].
type(type_t), parameter, public type_cmplx
type(type_t), parameter, 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_t), public unit_megabytes
For large amounts of data (natural code units are bytes)
subroutine, public zwfs_elec_init(this, dim, st_start, st_end, np, ik, special, packed)
initialize an empty wfs_elec_t object
subroutine, public dwfs_elec_init(this, dim, st_start, st_end, np, ik, special, packed)
initialize an empty wfs_elec_t object
subroutine reduce_all(grp)
subroutine print_kpoints_debug
Class defining batches of mesh functions.
Distribution of N instances over mpi_grpsize processes, for the local rank mpi_grprank....
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.
==============================================================
This is defined even when running serial.
An all-pairs communication schedule for a given group.
Stores all communicators and groups.
abstract class for states
The states_elec_t class contains all electronic wave functions.