49 use,
intrinsic :: iso_fortran_env
99 real(real64) :: shift_aux
100 type(derivatives_t),
pointer :: der_aux => null()
101 type(preconditioner_t) :: prec_aux
111 type(namespace_t),
intent(in) :: namespace
113 type(test_parameters_t) :: param
120 call param%init_from_file(namespace)
189 call parse_variable(namespace,
'TestMode', option__testmode__hartree, test_mode)
199 select case (test_mode)
200 case (option__testmode__hartree)
202 case (option__testmode__derivatives)
204 case (option__testmode__orthogonalization)
206 case (option__testmode__interpolation)
208 case (option__testmode__ion_interaction)
210 case (option__testmode__projector)
212 case (option__testmode__dft_u)
214 case (option__testmode__hamiltonian_apply)
216 case (option__testmode__density_calc)
218 case (option__testmode__exp_apply)
220 case (option__testmode__boundaries)
222 case (option__testmode__subspace_diag)
224 case (option__testmode__batch_ops)
226 case (option__testmode__clock)
228 case (option__testmode__linear_solver)
230 case (option__testmode__cgal)
232 case (option__testmode__dense_eigensolver)
234 case (option__testmode__grid_interpolation)
236 case (option__testmode__iihash)
238 case (option__testmode__sihash)
240 case (option__testmode__sphash)
242 case (option__testmode__mpiwrappers)
244 case (option__testmode__regridding)
246 case (option__testmode__helmholtz_decomposition)
248 case (option__testmode__vecpot_analytical)
250 case (option__testmode__current_density)
252 case (option__testmode__mixing_tests)
254 case (option__testmode__optimizers)
256 case (option__testmode__weighted_kmeans)
274 sys =>
electrons_t(namespace, generate_epot=.false.)
276 call poisson_test(sys%hm%psolver, sys%space, sys%gr, sys%ions%latt, namespace, param%repetitions)
277 safe_deallocate_p(sys)
294 sys =>
electrons_t(namespace, generate_epot=.false.)
297 call helmholtz%init(namespace, sys%gr, sys%mc, sys%space)
300 write(
message(1),
'(a)')
"Helmholtz decomposition: beginning Hertzian dipole test"
304 write(
message(1),
'(a)')
"Helmholtz decomposition: beginning Gaussian test"
306 call gaussian_test(helmholtz, sys%gr, sys%namespace, sys%space)
308 safe_deallocate_p(sys)
318 real(real64),
allocatable :: rho(:), x(:), center(:)
319 real(real64) :: rr, alpha, beta, res
322 real(real64),
parameter :: threshold = 1.e-7_real64
328 sys =>
electrons_t(namespace, generate_epot=.false.)
334 shift_aux = 0.25_real64
342 alpha =
m_four * sys%gr%spacing(1)
343 beta =
m_one / (alpha**sys%space%dim *
sqrt(
m_pi)**sys%space%dim)
345 safe_allocate(center(1:sys%space%dim))
348 safe_allocate(rho(1:sys%gr%np))
351 call mesh_r(sys%gr, ip, rr, origin = center(:))
352 rho(ip) = beta*
exp(-(rr/alpha)**2)
355 safe_allocate(x(1:sys%gr%np))
361 write(
message(1),
'(a,i6,a)')
"Info: CG converged with ", iter,
" iterations."
362 write(
message(2),
'(a,e14.6)')
"Info: The residue is ", res
363 write(
message(3),
'(a,e14.6)')
"Info: Norm solution CG ",
dmf_nrm2(sys%gr, x)
368 safe_deallocate_a(rho)
369 safe_deallocate_p(sys)
384 real(real64),
contiguous,
intent(in) :: x(:)
385 real(real64),
contiguous,
intent(out) :: Hx(:)
387 real(real64),
allocatable :: tmpx(:)
391 safe_allocate(tmpx(1:
mesh_aux%np_part))
396 safe_deallocate_a(tmpx)
411 complex(real64),
allocatable :: psi(:, :)
417 call messages_write(
'Info: Testing the nonlocal part of the pseudopotential with SOC')
422 sys =>
electrons_t(namespace, generate_epot=.false.)
431 call sys%st%group%psib(1, 1)%copy_to(epsib)
435 do itime = 1, param%repetitions
437 sys%hm%ep%natoms, 2, sys%st%group%psib(1, 1), epsib)
440 safe_allocate(psi(1:sys%gr%np, 1:sys%st%d%dim))
441 do itime = 1, epsib%nst
443 write(
message(1),
'(a,i1,3x, f12.6)')
"Norm state ", itime,
zmf_nrm2(sys%gr, 2, psi)
446 safe_deallocate_a(psi)
450 safe_deallocate_p(sys)
462 integer :: itime, ist
464 real(real64),
allocatable :: ddot(:,:,:), dweight(:,:)
465 complex(real64),
allocatable :: zdot(:,:,:), zweight(:,:)
478 sys =>
electrons_t(namespace, generate_epot=.false.)
483 if (sys%st%pack_states)
call sys%st%pack()
485 call sys%st%group%psib(1, 1)%copy_to(epsib2, copy_data = .
true.)
488 if (.not. sys%hm%phase%is_allocated())
then
489 call sys%st%group%psib(1, 1)%copy_to(epsib, copy_data = .
true.)
491 call sys%st%group%psib(1, 1)%copy_to(epsib)
492 call sys%hm%phase%apply_to(sys%gr, sys%gr%np, &
493 .false., epsib, src=sys%st%group%psib(1, 1))
494 epsib2%has_phase = .
true.
500 call dorbitalbasis_build(basis, sys%namespace, sys%ions, sys%gr, sys%st%d%kpt, sys%st%d%dim, &
501 sys%hm%phase%is_allocated(), .false., .false.)
502 safe_allocate(dweight(1:basis%orbsets(1)%norbs, 1:epsib%nst_linear))
503 safe_allocate(ddot(1:sys%st%d%dim, 1:basis%orbsets(1)%norbs, 1:epsib%nst))
505 call zorbitalbasis_build(basis, sys%namespace, sys%ions, sys%gr, sys%st%d%kpt, sys%st%d%dim, &
506 sys%hm%phase%is_allocated(), .false., .false.)
508 safe_allocate(zweight(1:basis%orbsets(1)%norbs, 1:epsib%nst_linear))
509 safe_allocate(zdot(1:sys%st%d%dim, 1:basis%orbsets(1)%norbs, 1:epsib%nst))
512 if (sys%hm%phase%is_allocated())
then
518 do itime = 1, param%repetitions
533 if (epsib%is_packed())
then
534 call epsib%do_unpack(force = .
true.)
537 do ist = 1, epsib%nst
539 write(
message(1),
'(a,i2,3x,e13.6)')
"Dotp state ", ist, ddot(1,1,ist)
541 write(
message(1),
'(a,i2,2(3x,e13.6))')
"Dotp state ", ist, zdot(1,1,ist)
549 safe_deallocate_a(dweight)
550 safe_deallocate_a(zweight)
551 safe_deallocate_a(ddot)
552 safe_deallocate_a(zdot)
558 safe_deallocate_p(sys)
570 integer :: itime, terms
589 call parse_variable(namespace,
'TestHamiltonianApply', option__testhamiltonianapply__term_all, terms)
590 if (terms == 0) terms = huge(1)
595 call messages_write(
'Info: Testing the application of the Hamiltonian')
600 sys =>
electrons_t(namespace, generate_epot=.false.)
607 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
610 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
612 call boundaries_set(sys%gr%der%boundaries, sys%gr, sys%st%group%psib(1, 1))
614 call sys%st%group%psib(1, 1)%copy_to(hpsib)
616 if (sys%hm%apply_packed())
then
617 call sys%st%group%psib(1, 1)%do_pack()
618 call hpsib%do_pack(copy = .false.)
621 do itime = 1, param%repetitions
631 if (hpsib%is_packed())
then
632 call hpsib%do_unpack(force = .
true.)
637 call hpsib%end(copy = .false.)
639 safe_deallocate_p(sys)
662 sys =>
electrons_t(namespace, generate_epot=.false.)
667 if (sys%st%pack_states)
call sys%st%pack()
669 do itime = 1, param%repetitions
673 write(
message(1),
'(a,3x, f12.6)')
"Norm density ",
dmf_nrm2(sys%gr, sys%st%rho(:,1))
677 safe_deallocate_p(sys)
700 sys =>
electrons_t(namespace, generate_epot=.false.)
705 if (sys%st%pack_states)
call sys%st%pack()
707 do itime = 1, param%repetitions
708 call boundaries_set(sys%gr%der%boundaries, sys%gr, sys%st%group%psib(1, 1))
714 safe_deallocate_p(sys)
738 sys =>
electrons_t(namespace, generate_epot=.false.)
745 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
748 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
752 if (sys%hm%apply_packed())
then
753 call sys%st%group%psib(1, 1)%do_pack()
756 do itime = 1, param%repetitions
757 call te%apply_batch(sys%namespace, sys%gr, sys%hm, sys%st%group%psib(1, 1), 1e-3_real64)
763 safe_deallocate_p(sys)
777 real(real64),
allocatable :: diff(:)
788 sys =>
electrons_t(namespace, generate_epot=.false.)
794 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
797 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
799 call sdiag%init(sys%namespace, sys%st)
801 safe_allocate(diff(1:sys%st%nst))
803 do itime = 1, param%repetitions
805 call dsubspace_diag(sdiag, sys%namespace, sys%gr, sys%st, sys%hm, 1, sys%st%eigenval(:, 1), diff)
807 call zsubspace_diag(sdiag, sys%namespace, sys%gr, sys%st, sys%hm, 1, sys%st%eigenval(:, 1), diff)
811 safe_deallocate_a(diff)
816 safe_deallocate_p(sys)
828 integer :: itime, ops, ops_default, ist, jst, nst
830 real(real64),
allocatable :: tmp(:)
831 real(real64),
allocatable :: ddotv(:)
832 complex(real64),
allocatable :: zdotv(:)
833 real(real64),
allocatable :: ddot(:,:)
834 complex(real64),
allocatable :: zdot(:,:)
859 option__testbatchops__ops_axpy + &
860 option__testbatchops__ops_scal + &
861 option__testbatchops__ops_nrm2 + &
862 option__testbatchops__ops_dotp_matrix + &
863 option__testbatchops__ops_dotp_self + &
864 option__testbatchops__ops_dotp_vector
875 sys =>
electrons_t(namespace, generate_epot=.false.)
880 if (sys%st%pack_states)
call sys%st%pack()
882 if (
bitand(ops, option__testbatchops__ops_axpy) /= 0)
then
883 message(1) =
'Info: Testing axpy'
886 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
887 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
889 do itime = 1, param%repetitions
890 call batch_axpy(sys%gr%np, 0.1_real64, xx, yy)
898 if (
bitand(ops, option__testbatchops__ops_scal) /= 0)
then
899 message(1) =
'Info: Testing scal'
902 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
903 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
905 do itime = 1, param%repetitions
914 if (
bitand(ops, option__testbatchops__ops_nrm2) /= 0)
then
915 message(1) =
'Info: Testing nrm2'
918 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
919 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
921 safe_allocate(tmp(1:xx%nst))
923 do itime = 1, param%repetitions
927 write(
message(1),
'(a,i1,3x,e23.16)')
"Nrm2 norm state ", itime, tmp(itime)
931 safe_deallocate_a(tmp)
937 if (
bitand(ops, option__testbatchops__ops_dotp_matrix) /= 0)
then
939 message(1) =
'Info: Testing dotp_matrix'
942 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
943 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
945 nst = sys%st%group%psib(1, 1)%nst
948 safe_allocate(ddot(1:nst, 1:nst))
949 do itime = 1, param%repetitions
955 write(
message(jst),
'(a,2i3,3x,e23.16)')
'Dotp_matrix states', ist, jst, ddot(ist,jst)
959 safe_deallocate_a(ddot)
961 safe_allocate(zdot(1:nst, 1:nst))
962 do itime = 1, param%repetitions
968 write(
message(jst),
'(a,2i3,3x,2(e23.16,1x))')
'Dotp_matrix states', ist, jst, zdot(ist,jst)
972 safe_deallocate_a(zdot)
979 if (
bitand(ops, option__testbatchops__ops_dotp_vector) /= 0)
then
981 message(1) =
'Info: Testing dotp_vector'
984 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
985 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
987 nst = sys%st%group%psib(1, 1)%nst
990 safe_allocate(ddotv(1:nst))
991 do itime = 1, param%repetitions
996 write(
message(ist),
'(a,i3,3x,e23.16)')
'Dotp_vector state', ist, ddotv(ist)
999 safe_deallocate_a(ddotv)
1001 safe_allocate(zdotv(1:nst))
1002 do itime = 1, param%repetitions
1007 write(
message(ist),
'(a,i3,3x,2(e23.16,1x))')
'Dotp_vector state', ist, zdotv(ist)
1010 safe_deallocate_a(zdotv)
1017 if (
bitand(ops, option__testbatchops__ops_dotp_self) /= 0)
then
1019 message(1) =
'Info: Testing dotp_self'
1022 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1024 nst = sys%st%group%psib(1, 1)%nst
1027 safe_allocate(ddot(1:nst, 1:nst))
1028 do itime = 1, param%repetitions
1034 write(
message(jst),
'(a,2i3,3x,e23.16)')
'Dotp_self states', ist, jst, ddot(ist,jst)
1038 safe_deallocate_a(ddot)
1040 safe_allocate(zdot(1:nst, 1:nst))
1041 do itime = 1, param%repetitions
1047 write(
message(jst),
'(a,2i3,3x,2(e23.16,1x))')
'Dotp_self states', ist, jst, zdot(ist,jst)
1051 safe_deallocate_a(zdot)
1058 safe_deallocate_p(sys)
1072 sys =>
electrons_t(namespace, generate_epot=.false.)
1073 call sys%init_parallelization(
mpi_world)
1075 message(1) =
'Info: Testing the finite-differences derivatives.'
1079 if (param%type == option__testtype__all .or. param%type == option__testtype__real)
then
1080 call dderivatives_test(sys%gr%der, sys%namespace, param%repetitions, param%min_blocksize, param%max_blocksize)
1083 if (param%type == option__testtype__all .or. param%type == option__testtype__complex)
then
1084 call zderivatives_test(sys%gr%der, sys%namespace, param%repetitions, param%min_blocksize, param%max_blocksize)
1087 safe_deallocate_p(sys)
1106 sys =>
electrons_t(namespace, generate_epot=.false.)
1107 call sys%init_parallelization(
mpi_world)
1109 message(1) =
'Info: Testing orthogonalization.'
1113 if (param%type == option__testtype__all .or. param%type == option__testtype__real)
then
1114 message(1) =
'Info: Real wave-functions.'
1116 do itime = 1, param%repetitions
1121 if (param%type == option__testtype__all .or. param%type == option__testtype__complex)
then
1122 message(1) =
'Info: Complex wave-functions.'
1124 do itime = 1, param%repetitions
1129 safe_deallocate_p(sys)
1144 sys =>
electrons_t(namespace, generate_epot=.false.)
1145 call sys%init_parallelization(
mpi_world)
1147 if (param%type == option__testtype__all .or. param%type == option__testtype__real)
then
1156 if (param%type == option__testtype__all .or. param%type == option__testtype__complex)
then
1158 call messages_write(
'Info: Testing complex interpolation routines')
1166 safe_deallocate_p(sys)
1181 sys =>
electrons_t(namespace, generate_epot=.false.)
1182 call sys%init_parallelization(
mpi_world)
1184 call ion_interaction_test(sys%space, sys%ions%latt, sys%ions%atom, sys%ions%natoms, sys%ions%pos, &
1185 sys%gr%box%bounding_box_l, namespace, sys%mc)
1187 safe_deallocate_p(sys)
1196 type(
grid_t),
intent(in) :: gr
1197 class(
batch_t),
intent(inout) :: psib
1198 character(*),
optional,
intent(in) :: string
1201 complex(real64),
allocatable :: zpsi(:, :)
1202 real(real64),
allocatable :: dpsi(:, :)
1204 character(80) :: string_
1211 safe_allocate(dpsi(1:gr%np, 1:st%d%dim))
1213 safe_allocate(zpsi(1:gr%np, 1:st%d%dim))
1216 do itime = 1, psib%nst
1219 write(
message(1),
'(a,i2,3x,e23.16)')
"Norm state "//trim(string_)//
" ", itime,
dmf_nrm2(gr, st%d%dim, dpsi)
1222 write(
message(1),
'(a,i2,3x,e23.16)')
"Norm state "//trim(string_)//
" ", itime,
zmf_nrm2(gr, st%d%dim, zpsi)
1228 safe_deallocate_a(dpsi)
1230 safe_deallocate_a(zpsi)
1246 write(
message(1),
'(a)')
" Operation Counter Time Global step"
1261 call clock%set(
clock_t(time_step=
m_four, initial_iteration=1))
1265 write(
message(1),
'(a)')
" Clock comparisons:"
1268 other_clock =
clock_t(time_step=
m_one, initial_iteration=5)
1280 character(len=*),
intent(in) :: operation
1282 write(
message(1),
'(a17,1x,i6,1x,f10.1,1x,i16)') operation, clock%counter(), clock%value(), clock%global_step()
1287 character(len=*),
intent(in) :: condition
1288 logical,
intent(in) :: result
1290 write(
message(1),
'(a10," = ",i1," (",l1,")")') condition, abs(transfer(result, 0)), result
1307 message(1) =
"cgal_polyhedron_point_inside"
1319 integer :: N, ii, jj, N_list(4), i_N
1320 real(real64),
allocatable :: matrix(:, :), eigenvectors(:, :), eigenvalues(:), test(:)
1321 real(real64),
allocatable :: differences(:)
1325 n_list = [15, 32, 100, 500]
1329 safe_allocate(matrix(1:n, 1:n))
1330 safe_allocate(eigenvectors(1:n, 1:n))
1331 safe_allocate(eigenvalues(1:n))
1332 safe_allocate(test(1:n))
1333 safe_allocate(differences(1:n))
1339 matrix(ii, jj) = ii * jj
1344 eigenvectors(1:n, 1:n) = matrix(1:n, 1:n)
1348 test(:) = matmul(matrix, eigenvectors(:, ii)) - eigenvalues(ii) * eigenvectors(:, ii)
1349 differences(ii) = sum(abs(test)) / sum(abs(eigenvectors(:, ii)))
1351 write(
message(1),
"(A, I3, A, E13.6)")
"Parallel solver - N: ", n, &
1352 ", average difference: ", sum(differences)/n
1356 eigenvectors(1:n, 1:n) = matrix(1:n, 1:n)
1360 test(:) = matmul(matrix, eigenvectors(:, ii)) - eigenvalues(ii) * eigenvectors(:, ii)
1361 differences(ii) = sum(abs(test)) / sum(abs(eigenvectors(:, ii)))
1363 write(
message(1),
"(A, I3, A, E13.6)")
"Serial solver - N: ", n, &
1364 ", average difference: ", sum(differences)/n
1367 safe_deallocate_a(matrix)
1368 safe_deallocate_a(eigenvectors)
1369 safe_deallocate_a(eigenvalues)
1370 safe_deallocate_a(test)
1371 safe_deallocate_a(differences)
1378 class(
batch_t),
intent(inout) :: psib
1381 real(real64),
allocatable :: dff(:)
1382 complex(real64),
allocatable :: zff(:)
1384 real(real64) :: da, db, dc
1385 complex(real64) :: za, zb, zc
1390 da =
m_one/mesh%box%bounding_box_l(1)
1396 za = da +
m_zi*0.01_real64
1397 zb = db*
exp(
m_zi*0.345_real64)
1398 zc = dc -
m_zi*50.0_real64
1400 safe_allocate(zff(1:mesh%np))
1401 do ist = 1, psib%nst_linear
1405 zff(ip) = zb*
exp(-za*sum(mesh%x(ip, :)**2)) + zc
1410 safe_deallocate_a(zff)
1412 safe_allocate(dff(1:mesh%np))
1413 do ist = 1, psib%nst_linear
1417 dff(ip) = db*
exp(-da*sum(mesh%x(ip, :)**2)) + dc
1422 safe_deallocate_a(dff)
1436 call sys%init_parallelization(
mpi_world)
1439 sys%gr%stencil, sys%mc, nlevels=3)
1445 safe_deallocate_p(sys)
1461 write(
message(1),*)
'hash[1] :', found,
value
1465 write(
message(1),*)
'hash[2] :', found,
value
1469 write(
message(1),*)
'hash[3] :', found,
value
1481 integer ::
value, sum
1490 write(
message(1),*)
'hash["one"]: ', found,
value
1494 write(
message(1),*)
'hash["two"]: ', found,
value
1498 write(
message(1),*)
'hash["three"]: ', found,
value
1505 do while (it%has_next())
1506 value = it%get_next()
1508 write(
message(1),
'(I3,A,I5)') counter,
': hash[...] = ',
value
1510 counter = counter + 1
1512 write(
message(1),*)
'counter = ', counter
1513 write(
message(2),*)
'sum = ', sum
1535 class(*),
pointer :: value
1537 integer :: count_clock, count_space
1539 safe_allocate(clock_2)
1553 write(
message(1),*)
'hash["one"]: ', found,
value%counter()
1556 write(
message(1),*)
'hash["one"]: ', found,
value%short_info()
1559 write(
message(1),*)
'wrong type. found = ', found
1566 write(
message(1),*)
'hash["two"]: ', found,
value%counter()
1569 write(
message(1),*)
'hash["two"]: ', found,
value%short_info()
1572 write(
message(1),*)
'wrong type. found = ',found
1576 safe_deallocate_a(clock_2)
1581 write(
message(1),*)
'hash["three"]: ', found,
value%counter()
1584 write(
message(1),*)
'hash["three"]: ', found,
value%short_info()
1587 write(
message(1),*)
'wrong type. found = ',found
1596 do while (it%has_next())
1597 value => it%get_next()
1600 count_clock = count_clock + 1
1602 count_space = count_space + 1
1606 write(
message(1), *)
'Count_clock = ', count_clock
1607 write(
message(2), *)
'Count_space = ', count_space
1620 real(real64),
allocatable :: ff_A(:), ff_A_reference(:), ff_B(:), ff_B_reference(:), diff_A(:), diff_B(:)
1621 real(real64) :: norm_ff, norm_diff
1630 call sysa%init_parallelization(
mpi_world)
1631 call sysb%init_parallelization(
mpi_world)
1634 safe_allocate(ff_a(1:sysa%gr%np))
1635 safe_allocate(ff_a_reference(1:sysa%gr%np))
1636 safe_allocate(diff_a(1:sysa%gr%np))
1637 safe_allocate(ff_b(1:sysb%gr%np))
1638 safe_allocate(ff_b_reference(1:sysb%gr%np))
1639 safe_allocate(diff_b(1:sysb%gr%np))
1641 do ip = 1, sysa%gr%np
1642 ff_a_reference(ip) =
values(sysa%gr%x(ip, :))
1644 do ip = 1, sysb%gr%np
1645 ff_b_reference(ip) =
values(sysb%gr%x(ip, :))
1649 regridding =>
regridding_t(sysb%gr, sysa%gr, sysa%space, sysa%namespace)
1650 call regridding%do_transfer(ff_b, ff_a_reference)
1651 safe_deallocate_p(regridding)
1654 do ip = 1, sysb%gr%np
1656 ff_b_reference(ip) =
m_zero
1659 diff_b(ip) = abs(ff_b_reference(ip) - ff_b(ip))
1662 norm_ff =
dmf_nrm2(sysb%gr, ff_b_reference)
1663 norm_diff =
dmf_nrm2(sysb%gr, diff_b)
1665 write(
message(1),
'(a, E14.6)')
"Forward: difference of reference to mapped function (rel.): ", &
1670 sysb%gr, ff_b_reference,
unit_one, ierr)
1674 sysa%gr, ff_a_reference,
unit_one, ierr)
1677 regridding =>
regridding_t(sysa%gr, sysb%gr, sysb%space, sysb%namespace)
1678 call regridding%do_transfer(ff_a, ff_b_reference)
1679 safe_deallocate_p(regridding)
1681 do ip = 1, sysa%gr%np
1683 ff_a_reference(ip) =
m_zero
1686 diff_a(ip) = abs(ff_a_reference(ip) - ff_a(ip))
1689 norm_ff =
dmf_nrm2(sysa%gr, ff_a_reference)
1690 norm_diff =
dmf_nrm2(sysa%gr, diff_a)
1692 write(
message(1),
'(a, E14.6)')
"Backward: difference of reference to mapped function (rel.): ", &
1697 sysa%gr, ff_a_reference,
unit_one, ierr)
1701 sysb%gr, ff_b_reference,
unit_one, ierr)
1703 safe_deallocate_a(ff_a)
1704 safe_deallocate_a(ff_a_reference)
1705 safe_deallocate_a(ff_b)
1706 safe_deallocate_a(ff_b_reference)
1707 safe_deallocate_a(diff_a)
1708 safe_deallocate_a(diff_b)
1709 safe_deallocate_p(sysa)
1710 safe_deallocate_p(sysb)
1716 real(real64) function values(xx)
1717 real(real64),
intent(in) :: xx(:)
1718 real(real64) :: xx0(1:size(xx, dim=1))
1719 real(real64),
parameter :: aa =
m_half
1720 real(real64),
parameter :: bb =
m_four
1724 values = bb *
exp(-aa*sum((xx-xx0)**2))
1734 type(namespace_t),
intent(in) :: namespace
1736 class(maxwell_t),
pointer :: maxwell_system
1738 real(real64),
allocatable :: magnetic_field(:,:)
1739 real(real64),
allocatable :: vector_potential_mag(:,:)
1740 real(real64),
allocatable :: vector_potential_analytical(:,:)
1741 real(real64),
allocatable :: delta(:,:)
1742 real(real64) :: exp_factor
1746 real(real64) :: sigma
1747 integer :: ip, j, ierr, nn
1748 integer(int64) :: out_how
1749 character(len=MAX_PATH_LEN) :: fname, fname2, fname3
1752 maxwell_system => maxwell_t(namespace)
1753 sigma = maxwell_system%gr%box%bounding_box_l(1)/10_real64
1754 call maxwell_system%init_parallelization(mpi_world)
1756 safe_allocate(magnetic_field(1:maxwell_system%gr%np_part, 1:3))
1757 safe_allocate(vector_potential_mag(1:maxwell_system%gr%np_part, 1:3))
1758 safe_allocate(vector_potential_analytical(1:maxwell_system%gr%np_part, 1:3))
1759 safe_allocate(delta(1:maxwell_system%gr%np, 1:3))
1772 call parse_variable(namespace,
'TestVectorPotentialType', option__testvectorpotentialtype__bounded, nn)
1775 case (option__testvectorpotentialtype__bounded)
1776 do ip = 1, maxwell_system%gr%np_part
1777 xx = maxwell_system%gr%x(ip, 1)
1778 yy = maxwell_system%gr%x(ip, 2)
1779 zz = maxwell_system%gr%x(ip, 3)
1780 exp_factor =
exp((-xx**2 - yy**2 - zz**2)*1/(2*sigma**2))
1781 magnetic_field(ip, 1) = exp_factor*yy*(1 - (-xx**2 + yy**2)/(3*sigma**2) - zz**2/(3*sigma**2))
1782 magnetic_field(ip, 2) = exp_factor * xx * (1 + (-xx**2 + yy**2)/(3*sigma**2) - zz**2/(3*sigma**2))
1783 magnetic_field(ip, 3) = exp_factor * 2 * xx * yy * zz * 1/(3*sigma**2)
1785 vector_potential_analytical(ip, 1) = m_third * xx * zz * exp_factor
1786 vector_potential_analytical(ip, 2) = - m_third * yy * zz * exp_factor
1787 vector_potential_analytical(ip, 3) = m_third * (-xx**2 + yy**2) * exp_factor
1789 case (option__testvectorpotentialtype__unbounded)
1790 do ip = 1, maxwell_system%gr%np_part
1791 magnetic_field(ip, 1) = maxwell_system%gr%x(ip, 2)
1792 magnetic_field(ip, 2) = maxwell_system%gr%x(ip, 1)
1793 magnetic_field(ip, 3) = m_zero
1795 vector_potential_analytical(ip, 1) = m_third * maxwell_system%gr%x(ip, 1) * maxwell_system%gr%x(ip, 3)
1796 vector_potential_analytical(ip, 2) = - m_third * maxwell_system%gr%x(ip, 2) * maxwell_system%gr%x(ip, 3)
1797 vector_potential_analytical(ip, 3) = - m_third * (maxwell_system%gr%x(ip, 1)**2 - maxwell_system%gr%x(ip, 2)**2)
1800 call maxwell_system%helmholtz%get_vector_potential(namespace, vector_potential_mag, magnetic_field)
1804 do ip = 1, maxwell_system%gr%np
1805 delta(ip,j) = vector_potential_analytical(ip, j) - vector_potential_mag(ip, j)
1810 write(message(j),*)
'j, norm2(delta)', j, norm2(delta(:,j))
1812 call messages_info(3)
1814 write(fname,
'(a)')
'deviation_from_analytical_formulation'
1815 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, maxwell_system%space, maxwell_system%gr, &
1816 delta, unit_one, ierr)
1817 write(fname2,
'(a)')
'vector_potential_analytical'
1818 call io_function_output_vector(out_how ,
'./' , trim(fname2), namespace, maxwell_system%space, maxwell_system%gr, &
1819 vector_potential_analytical, unit_one, ierr)
1820 write(fname3,
'(a)')
'vector_potential_mag'
1821 call io_function_output_vector(out_how ,
'./' , trim(fname3), namespace, maxwell_system%space, maxwell_system%gr, &
1822 vector_potential_mag, unit_one, ierr)
1824 safe_deallocate_a(magnetic_field)
1825 safe_deallocate_a(vector_potential_mag)
1826 safe_deallocate_a(vector_potential_analytical)
1827 safe_deallocate_a(delta)
1828 safe_deallocate_p(maxwell_system)
1834 type(multigrid_t),
intent(in) :: mgrid
1835 class(space_t),
intent(in) :: space
1837 real(real64),
allocatable :: guess0(:), res0(:), guess1(:)
1838 type(mesh_t),
pointer :: mesh0, mesh1
1839 real(real64) :: delta, xx(3,2), alpha, beta, rr
1840 integer :: nn, ip, ierr
1844 message(1) =
'Info: Testing the grid interpolation.'
1846 call messages_info(2)
1848 mesh0 => mgrid%level(0)%mesh
1849 mesh1 => mgrid%level(1)%mesh
1851 safe_allocate(guess0(1:mesh0%np_part))
1852 safe_allocate(res0(1:mesh0%np_part))
1853 safe_allocate(guess1(1:mesh1%np_part))
1855 alpha = m_four*mesh0%spacing(1)
1856 beta = m_one / (alpha**space%dim *
sqrt(m_pi)**space%dim)
1871 call mesh_r(mesh0, ip, rr, origin = xx(:, nn))
1872 guess0(ip) = guess0(ip) + (-1)**nn * beta*
exp(-(rr/alpha)**2)
1876 call dio_function_output (io_function_fill_how(
'AxisX'),
".",
"interpolation_target", global_namespace, &
1877 space, mesh0, guess0, unit_one, ierr)
1878 call dio_function_output (io_function_fill_how(
'AxisZ'),
".",
"interpolation_target", global_namespace, &
1879 space, mesh0, guess0, unit_one, ierr)
1880 call dio_function_output (io_function_fill_how(
'PlaneZ'),
".",
"interpolation_target", global_namespace, &
1881 space, mesh0, guess0, unit_one, ierr)
1888 call dmultigrid_fine2coarse(mgrid%level(1)%tt, mgrid%level(0)%der, mesh1, guess0, guess1, injection)
1890 call dmultigrid_coarse2fine(mgrid%level(1)%tt, mgrid%level(1)%der, mesh0, guess1, res0)
1892 call dio_function_output (io_function_fill_how(
'AxisX'),
".",
"interpolation_result", global_namespace, &
1893 space, mesh0, res0, unit_one, ierr)
1894 call dio_function_output (io_function_fill_how(
'AxisZ'),
".",
"interpolation_result", global_namespace, &
1895 space, mesh0, res0, unit_one, ierr)
1896 call dio_function_output (io_function_fill_how(
'PlaneZ'),
".",
"interpolation_result", global_namespace, &
1897 space, mesh0, res0, unit_one, ierr)
1899 delta = dmf_nrm2(mesh0, guess0(1:mesh0%np)-res0(1:mesh0%np))
1900 write(message(1),
'(a,e13.6)')
'Interpolation test (abs.) = ', delta
1906 call dmultigrid_fine2coarse(mgrid%level(1)%tt, mgrid%level(0)%der, mesh1, guess0, guess1, fullweight)
1908 call dmultigrid_coarse2fine(mgrid%level(1)%tt, mgrid%level(1)%der, mesh0, guess1, res0)
1910 call dio_function_output (io_function_fill_how(
'AxisX'),
".",
"restriction_result", global_namespace, &
1911 space, mesh0, res0, unit_one, ierr)
1912 call dio_function_output (io_function_fill_how(
'AxisZ'),
".",
"restriction_result", global_namespace, &
1913 space, mesh0, res0, unit_one, ierr)
1914 call dio_function_output (io_function_fill_how(
'PlaneZ'),
".",
"restriction_result", global_namespace, &
1915 space, mesh0, res0, unit_one, ierr)
1917 delta = dmf_nrm2(mesh0, guess0(1:mesh0%np)-res0(1:mesh0%np))
1918 write(message(2),
'(a,e13.6)')
'Restriction test (abs.) = ', delta
1919 call messages_info(2)
1921 safe_deallocate_a(guess0)
1922 safe_deallocate_a(res0)
1923 safe_deallocate_a(guess1)
1931 type(namespace_t),
intent(in) :: namespace
1932 type(electrons_t),
pointer :: sys
1934 type(current_t) :: current
1935 character(len=MAX_PATH_LEN) :: fname
1936 integer :: ierr, ip, idir
1937 integer(int64) :: out_how
1938 real(real64),
allocatable :: current_para_ref(:,:), current_dia_ref(:,:), current_mag_ref(:,:), delta(:)
1939 real(real64) :: xx(3), rr, a0, mag_curr, sin_thet, sin_phi, cos_phi, vec_pot_slope
1940 complex(real64) :: alpha
1942 sys => electrons_t(namespace, generate_epot=.false.)
1943 call sys%init_parallelization(mpi_world)
1945 alpha = (0.0_real64, 0.5_real64)
1947 vec_pot_slope = 0.4_real64
1949 call states_elec_allocate_wfns(sys%st, sys%gr, wfs_type = type_cmplx)
1952 call current_init(current, namespace)
1954 call hamiltonian_elec_epot_generate(sys%hm, sys%namespace, sys%space, sys%gr, sys%ions, sys%ext_partners, sys%st)
1956 safe_allocate(sys%hm%hm_base%vector_potential(1:3, 1:sys%gr%np))
1958 sys%hm%hm_base%vector_potential = m_zero
1959 do ip = 1, sys%gr%np
1960 xx = sys%gr%x(ip, 1:3)
1961 sys%hm%hm_base%vector_potential(2, ip) = vec_pot_slope * xx(1) / p_c
1964 call states_elec_allocate_current(sys%st, sys%space, sys%gr)
1965 call density_calc(sys%st, sys%gr, sys%st%rho)
1967 call current_calculate(current, namespace, sys%gr, sys%hm, sys%space, sys%st)
1969 safe_allocate(current_para_ref(1:sys%gr%np,1:3))
1970 safe_allocate(current_dia_ref(1:sys%gr%np,1:3))
1971 safe_allocate(current_mag_ref(1:sys%gr%np,1:3))
1972 safe_allocate(delta(1:sys%gr%np))
1975 current_para_ref(:,:) = m_zero
1976 do ip = 1, sys%gr%np
1977 call mesh_r(sys%gr, ip, rr)
1978 xx = sys%gr%x(ip, 1:3)
1979 if (rr > r_small)
then
1981 psi_1s(rr, a0) *
dr_psi_2s(rr, a0) ) * aimag(alpha) / (1 + abs(alpha)**2) * xx(1:3) / rr
1985 write(fname,
'(a)')
'current_para'
1986 out_how = io_function_fill_how(
"PlaneZ")
1987 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
1988 sys%st%current_para(:,:,1), unit_one, ierr)
1990 write(fname,
'(a)')
'current_para-ref'
1991 out_how = io_function_fill_how(
"PlaneZ")
1992 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
1993 current_para_ref(:,:), unit_one, ierr)
1997 delta(:) = current_para_ref(1:sys%gr%np, idir) - sys%st%current_para(1:sys%gr%np, idir, 1)
1998 write(message(idir),*)
'idir =',idir,
', norm2(delta paramagnetic)',norm2(delta)
2000 call messages_info(3)
2003 current_dia_ref(:,:) = m_zero
2004 do ip = 1, sys%gr%np
2005 call mesh_r(sys%gr, ip, rr)
2006 current_dia_ref(ip,1:3) = - sys%hm%hm_base%vector_potential(1:3,ip) *&
2010 write(fname,
'(a)')
'current_dia'
2011 out_how = io_function_fill_how(
"PlaneZ")
2012 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2013 sys%st%current_dia(:,:,1), unit_one, ierr)
2015 write(fname,
'(a)')
'current_dia-ref'
2016 out_how = io_function_fill_how(
"PlaneZ")
2017 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2018 current_dia_ref(:,:), unit_one, ierr)
2022 delta(:) = current_dia_ref(1:sys%gr%np, idir) - sys%st%current_dia(1:sys%gr%np, idir, 1)
2023 write(message(idir),*)
'idir =',idir,
', norm2(delta diamagnetic)',norm2(delta)
2025 call messages_info(3)
2028 call current_calculate_mag(sys%gr%der, sys%st)
2031 current_mag_ref(:,:) = m_zero
2032 do ip = 1, sys%gr%np
2033 call mesh_r(sys%gr, ip, rr)
2034 xx = sys%gr%x(ip, 1:3)
2035 if (norm2(xx(1:2)) > r_small .and. rr > r_small)
then
2036 sin_thet = norm2(xx(1:2)) / rr
2037 sin_phi = xx(2) / norm2(xx(1:2))
2038 cos_phi = xx(1) / norm2(xx(1:2))
2042 current_mag_ref(ip,1) = m_half * mag_curr * sin_thet * sin_phi / (1+abs(alpha)**2)
2043 current_mag_ref(ip,2) = -m_half * mag_curr * sin_thet * cos_phi / (1+abs(alpha)**2)
2047 write(fname,
'(a)')
'current_mag'
2048 out_how = io_function_fill_how(
"PlaneZ")
2049 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2050 sys%st%current_mag(:,:,1), unit_one, ierr)
2052 write(fname,
'(a)')
'current_mag-ref'
2053 out_how = io_function_fill_how(
"PlaneZ")
2054 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2055 current_mag_ref(:,:), unit_one, ierr)
2059 delta(:) = current_mag_ref(1:sys%gr%np, idir) - sys%st%current_mag(1:sys%gr%np, idir, 1)
2060 write(message(idir),*)
'idir =',idir,
', norm2(delta magnetization)',norm2(delta)
2062 call messages_info(3)
2064 safe_deallocate_a(current_para_ref)
2065 safe_deallocate_a(current_dia_ref)
2066 safe_deallocate_a(current_mag_ref)
2067 safe_deallocate_a(delta)
2068 safe_deallocate_p(sys)
2074 class(batch_t),
intent(inout) :: psib
2075 class(mesh_t),
intent(in) :: mesh
2076 type(namespace_t),
intent(in) :: namespace
2077 complex(real64),
intent(in) :: alpha
2078 real(real64),
intent(in) :: a0
2080 complex(real64),
allocatable :: zff(:)
2087 safe_allocate(zff(1:mesh%np))
2088 if (type_is_complex(psib%type()))
then
2090 call mesh_r(mesh, ip, rr)
2092 call batch_set_state(psib, 1, mesh%np, zff)
2094 safe_deallocate_a(zff)
2096 write(message(1),*)
"States should be complex for the linear combination of hydrogenic states to work"
2097 call messages_info(1, namespace=namespace)
2104 real(real64),
intent(in) :: a0, rr
2105 complex(real64),
intent(in) :: alpha
2111 real(real64) function psi_1s(rr, a0)
2112 real(real64),
intent(in) :: a0, rr
2118 real(real64) function psi_2s(rr, a0)
2119 real(real64),
intent(in) :: a0, rr
2121 psi_2s =
sqrt(m_two) * a0**(-m_three/m_two) * (m_one - rr/(m_two * a0)) *
exp(-rr/(m_two * a0)) &
2122 / (m_two *
sqrt(m_pi))
2125 real(real64) function dr_psi_1s(rr, a0)
2126 real(real64),
intent(in) :: a0, rr
2131 real(real64) function dr_psi_2s(rr, a0)
2132 real(real64),
intent(in) :: a0, rr
2135 a0**(-m_five/m_two) *
exp(-rr/(m_two * a0)) / (
sqrt(m_two) * m_two *
sqrt(m_pi))
batchified version of the BLAS axpy routine:
scale a batch by a constant or vector
There are several ways how to call batch_set_state and batch_get_state:
constant times a vector plus a vector
Copies a vector x, to a vector y.
scales a vector by a constant
Prints out to iunit a message in the form: ["InputVariable" = value] where "InputVariable" is given b...
double exp(double __x) __attribute__((__nothrow__
double sqrt(double __x) __attribute__((__nothrow__
This module implements batches of mesh functions.
This module implements common operations on batches of mesh functions.
subroutine, public batch_set_zero(this, np, async)
fill all mesh functions of the batch with zero
Module implementing boundary conditions in Octopus.
Module, implementing a factory for boxes.
This module handles the calculation mode.
integer, parameter, public p_strategy_kpoints
parallelization in k-points
integer, parameter, public p_strategy_domains
parallelization in domains
type(calc_mode_par_t), public calc_mode_par
Singleton instance of parallel calculation mode.
integer, parameter, public p_strategy_states
parallelization in states
subroutine, public cgal_polyhedron_init(cgal_poly, fname, verbose)
logical function, public cgal_polyhedron_point_inside(cgal_poly, xq, yq, zq)
subroutine, public cgal_polyhedron_end(cgal_poly)
This module implements a calculator for the density and defines related functions.
subroutine, public density_calc(st, gr, density, istin)
Computes the density from the orbitals in st.
This module calculates the derivatives (gradients, Laplacians, etc.) of a function.
subroutine, public dderivatives_test(this, namespace, repetitions, min_blocksize, max_blocksize)
unit test for derivatives
subroutine, public dderivatives_lapl(der, ff, op_ff, ghost_update, set_bc, factor)
apply the Laplacian to a mesh function
subroutine, public zderivatives_test(this, namespace, repetitions, min_blocksize, max_blocksize)
unit test for derivatives
integer, parameter, public spin_polarized
subroutine, public exponential_init(te, namespace, full_batch)
real(real64), parameter, public m_two
real(real64), parameter, public m_zero
real(real64), parameter, public m_four
real(real64), parameter, public m_pi
some mathematical constants
complex(real64), parameter, public m_zi
real(real64), parameter, public m_epsilon
real(real64), parameter, public m_half
real(real64), parameter, public m_one
This module implements the underlying real-space grid.
subroutine, public zhamiltonian_elec_apply_batch(hm, namespace, mesh, psib, hpsib, terms, set_bc)
subroutine, public hamiltonian_elec_epot_generate(this, namespace, space, gr, ions, ext_partners, st, time)
subroutine, public dhamiltonian_elec_apply_batch(hm, namespace, mesh, psib, hpsib, terms, set_bc)
The Helmholtz decomposition is intended to contain "only mathematical" functions and procedures to co...
Test suit for the Helmholtz decomposition module.
subroutine, public gaussian_test(helmholtz, sys_grid, namespace, space)
subroutine, public hertzian_dipole_test(helmholtz, sys_grid, namespace, space)
This module implements a simple hash table for non-negative integer keys and integer values.
subroutine, public iihash_end(h)
Free a hash table.
subroutine, public iihash_insert(h, key, val)
Insert a (key, val) pair into the hash table h.
integer function, public iihash_lookup(h, key, found)
Look up a value in the hash table h. If found is present, it indicates if key could be found in the t...
subroutine, public iihash_init(h)
Initialize a hash table h.
subroutine, public dio_function_output(how, dir, fname, namespace, space, mesh, ff, unit, ierr, pos, atoms, grp, root)
Top-level IO routine for functions defined on the mesh.
integer(int64) function, public io_function_fill_how(where)
Use this function to quickly plot functions for debugging purposes: call dio_function_output(io_funct...
subroutine, public ion_interaction_test(space, latt, atom, natoms, pos, lsize, namespace, mc)
This module defines functions over batches of mesh functions.
subroutine, public dmesh_batch_dotp_matrix(mesh, aa, bb, dot, reduce)
Calculate the overlap matrix of two batches.
subroutine, public dmesh_batch_dotp_self(mesh, aa, dot, reduce)
calculate the overlap matrix of a batch with itself
subroutine, public mesh_batch_nrm2(mesh, aa, nrm2, reduce)
Calculate the norms (norm2, not the square!) of a batch of mesh functions.
subroutine, public zmesh_batch_dotp_vector(mesh, aa, bb, dot, reduce, cproduct)
calculate the vector of dot-products of mesh functions between two batches
subroutine, public zmesh_batch_dotp_matrix(mesh, aa, bb, dot, reduce)
Calculate the overlap matrix of two batches.
subroutine, public zmesh_batch_normalize(mesh, psib, norm)
Normalize a batch.
subroutine, public zmesh_batch_dotp_self(mesh, aa, dot, reduce)
calculate the overlap matrix of a batch with itself
subroutine, public dmesh_batch_normalize(mesh, psib, norm)
Normalize a batch.
subroutine, public dmesh_batch_dotp_vector(mesh, aa, bb, dot, reduce, cproduct)
calculate the vector of dot-products of mesh functions between two batches
This module defines various routines, operating on mesh functions.
class(mesh_t), pointer, public mesh_aux
Globally-scoped pointer to the mesh instance.
real(real64) function, public dmf_dotp_aux(f1, f2)
dot product between two vectors (mesh functions)
subroutine, public mesh_init_mesh_aux(mesh)
Initialise a pointer to the grid/mesh, that is globally exposed, such that low level mesh operations ...
subroutine, public zmesh_interpolation_test(mesh)
subroutine, public dmesh_interpolation_test(mesh)
This module defines the meshes, which are used in Octopus.
pure subroutine, public mesh_r(mesh, ip, rr, origin, coords)
return the distance to the origin for a given grid point
subroutine, public messages_print_with_emphasis(msg, iunit, namespace)
character(len=512), private msg
subroutine, public messages_obsolete_variable(namespace, name, rep)
subroutine, public messages_new_line()
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_info(no_lines, iunit, debug_only, stress, all_nodes, namespace)
This modules takes care of testing optimizers using standard test functions.
subroutine, public test_optimizers(namespace)
Unit tests for different optimizers.
This module implements unit tests for the mixing methods.
subroutine, public mix_tests_run()
type(mpi_grp_t), public mpi_world
subroutine, public test_mpiwrappers
This module handles the communicators for the various parallelization strategies.
subroutine, public multigrid_end(mgrid)
subroutine, public multigrid_init(mgrid, namespace, space, mesh, der, stencil, mc, nlevels)
type(namespace_t), public global_namespace
subroutine, public orbitalbasis_end(this)
subroutine, public zorbitalbasis_build(this, namespace, ions, mesh, kpt, ndim, skip_s_orb, use_all_orb, verbose)
This routine is an interface for constructing the orbital basis.
subroutine, public dorbitalbasis_build(this, namespace, ions, mesh, kpt, ndim, skip_s_orb, use_all_orb, verbose)
This routine is an interface for constructing the orbital basis.
subroutine, public orbitalbasis_init(this, namespace, periodic_dim)
subroutine, public dorbitalset_get_coeff_batch(os, ndim, psib, dot)
subroutine, public dorbitalset_add_to_batch(os, ndim, psib, weight)
subroutine, public zorbitalset_add_to_batch(os, ndim, psib, weight)
subroutine, public orbitalset_update_phase(os, dim, kpt, kpoints, spin_polarized, vec_pot, vec_pot_var, kpt_max)
Build the phase correction to the global phase in case the orbital crosses the border of the simulato...
subroutine, public zorbitalset_get_coeff_batch(os, ndim, psib, dot)
subroutine, public poisson_test(this, space, mesh, latt, namespace, repetitions)
This routine checks the Hartree solver selected in the input file by calculating numerically and anal...
subroutine, public preconditioner_end(this)
subroutine, public preconditioner_init(this, namespace, gr, mc, space)
subroutine, public zproject_psi_batch(mesh, bnd, pj, npj, dim, psib, ppsib)
To optimize the application of the non-local operator in parallel, the projectors are applied in step...
Implementation details for regridding.
This module implements a simple hash table for string valued keys and integer values using the C++ ST...
subroutine, public sihash_insert(h, key, val)
Insert a (key, val) pair into the hash table h.
subroutine, public sihash_init(h)
Initialize a hash table h with size entries. Since we use separate chaining, the number of entries in...
integer function, public sihash_lookup(h, key, found)
Look up a value in the hash table h. If found is present, it indicates if key could be found in the t...
subroutine, public sihash_end(h)
Free a hash table.
This module is intended to contain "only mathematical" functions and procedures.
This module implements a simple hash table for string valued keys and integer values using the C++ ST...
subroutine, public sphash_init(h)
Initialize a hash table h with size entries. Since we use separate chaining, the number of entries in...
subroutine, public sphash_insert(h, key, val, clone)
Insert a (key, val) pair into the hash table h. If clone=.true., the object will be copied.
subroutine, public sphash_end(h)
Free a hash table.
class(*) function, pointer, public sphash_lookup(h, key, found)
Look up a value in the hash table h. If found is present, it indicates if key could be found in the t...
pure logical function, public states_are_real(st)
subroutine, public zstates_elec_calc_orth_test(st, namespace, mesh, kpoints)
subroutine, public dstates_elec_calc_orth_test(st, namespace, mesh, kpoints)
This module handles spin dimensions of the states and the k-point distribution.
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, public dsubspace_diag(this, namespace, mesh, st, hm, ik, eigenval, diff, nonortho)
Diagonalises the Hamiltonian in the subspace defined by the states.
subroutine, public zsubspace_diag(this, namespace, mesh, st, hm, ik, eigenval, diff, nonortho)
Diagonalises the Hamiltonian in the subspace defined by the states.
subroutine, public test_weighted_kmeans(namespace)
Test weighted kmeans algorithm for a finite system.
This module implements a unit-test like runmode for Octopus.
real(real64) function psi_2s(rr, a0)
subroutine test_helmholtz_decomposition(namespace)
subroutine test_hartree(param, namespace)
subroutine test_derivatives(param, namespace)
subroutine test_subspace_diagonalization(param, namespace)
subroutine, public test_run(namespace)
Components and integration test runner.
subroutine test_density_calc(param, namespace)
real(real64) function psi_1s(rr, a0)
subroutine test_current_density(namespace)
Here we test the different contributions to the total electronic current density.
subroutine test_batch_set_gaussian(psib, mesh)
subroutine test_regridding(namespace)
subroutine test_sphash(namespace)
subroutine test_hamiltonian(param, namespace)
subroutine test_dense_eigensolver()
subroutine test_interpolation(param, namespace)
subroutine multigrid_test_interpolation(mgrid, space)
subroutine test_ion_interaction(namespace)
subroutine test_boundaries(param, namespace)
subroutine test_orthogonalization(param, namespace)
real(real64) function dr_psi_2s(rr, a0)
subroutine test_batch_ops(param, namespace)
complex(real64) function lc_hydrogen_state(rr, alpha, a0)
subroutine test_projector(param, namespace)
subroutine test_dft_u(param, namespace)
subroutine test_prints_info_batch(st, gr, psib, string)
real(real64) function dr_psi_1s(rr, a0)
subroutine test_linear_solver(namespace)
subroutine test_grid_interpolation()
subroutine set_hydrogen_states(psib, mesh, namespace, alpha, a0)
subroutine test_exponential(param, namespace)
subroutine test_vecpot_analytical(namespace)
Here, analytical formulation for vector potential and B field are used. Ref: Sangita Sen and Erik I....
type(type_t), public type_cmplx
logical pure function, public type_is_complex(this)
This module defines the unit system, used for input and output.
type(unit_t), public unit_one
some special units required for particular quantities
subroutine, public v_ks_calc(ks, namespace, space, hm, st, ions, ext_partners, calc_eigenval, time, calc_energy, calc_current, force_semilocal)
Class defining batches of mesh functions.
class representing derivatives
Class describing the electron system.
Description of the grid, containing information on derivatives, stencil, and symmetries.
This class implements the iteration counter used by the multisystem algorithms. As any iteration coun...
Describes mesh distribution to nodes.
contains the information of the meshes and provides the transfer functions
The states_elec_t class contains all electronic wave functions.
batches of electronic states
subroutine write_clock(operation)
subroutine laplacian_op(x, hx)
Computes .
subroutine set_der_aux(der)
subroutine write_condition_result(condition, result)
real(real64) function values(xx)