54 use,
intrinsic :: iso_fortran_env
106 real(real64) :: shift_aux
107 type(derivatives_t),
pointer :: der_aux => null()
108 type(preconditioner_t) :: prec_aux
118 type(namespace_t),
intent(in) :: namespace
120 type(test_parameters_t) :: param
127 call param%init_from_file(namespace)
207 call parse_variable(namespace,
'TestMode', option__testmode__hartree, test_mode)
217 select case (test_mode)
218 case (option__testmode__hartree)
220 case (option__testmode__derivatives)
222 case (option__testmode__orthogonalization)
224 case (option__testmode__interpolation)
226 case (option__testmode__ion_interaction)
228 case (option__testmode__projector)
230 case (option__testmode__dft_u)
232 case (option__testmode__hamiltonian_apply)
234 case (option__testmode__density_calc)
236 case (option__testmode__exp_apply)
238 case (option__testmode__boundaries)
240 case (option__testmode__subspace_diag)
242 case (option__testmode__batch_ops)
244 case (option__testmode__clock)
246 case (option__testmode__linear_solver)
248 case (option__testmode__cgal)
250 case (option__testmode__dense_eigensolver)
252 case (option__testmode__grid_interpolation)
254 case (option__testmode__iihash)
256 case (option__testmode__sihash)
258 case (option__testmode__sphash)
260 case (option__testmode__mpiwrappers)
262 case (option__testmode__regridding)
264 case (option__testmode__helmholtz_decomposition)
266 case (option__testmode__vecpot_analytical)
268 case (option__testmode__current_density)
270 case (option__testmode__mixing_tests)
272 case (option__testmode__optimizers)
274 case (option__testmode__weighted_kmeans)
276 case (option__testmode__csv_input)
278 case (option__testmode__composition_chebyshev)
280 case (option__testmode__lalg_adv)
282 case (option__testmode__isdf_serial)
284 case (option__testmode__isdf)
302 sys =>
electrons_t(namespace, generate_epot=.false.)
304 call poisson_test(sys%hm%psolver, sys%space, sys%gr, sys%ions%latt, namespace, param%repetitions)
305 safe_deallocate_p(sys)
322 sys =>
electrons_t(namespace, generate_epot=.false.)
325 call helmholtz%init(namespace, sys%gr, sys%mc, sys%space)
328 write(
message(1),
'(a)')
"Helmholtz decomposition: beginning Hertzian dipole test"
332 write(
message(1),
'(a)')
"Helmholtz decomposition: beginning Gaussian test"
334 call gaussian_test(helmholtz, sys%gr, sys%namespace, sys%space)
336 safe_deallocate_p(sys)
346 real(real64),
allocatable :: rho(:), x(:),
center(:)
347 real(real64) :: rr, alpha, beta, res
350 real(real64),
parameter :: threshold = 1.e-7_real64
356 sys =>
electrons_t(namespace, generate_epot=.false.)
362 shift_aux = 0.25_real64
370 alpha =
m_four * sys%gr%spacing(1)
371 beta =
m_one / (alpha**sys%space%dim *
sqrt(
m_pi)**sys%space%dim)
373 safe_allocate(
center(1:sys%space%dim))
376 safe_allocate(rho(1:sys%gr%np))
380 rho(ip) = beta*
exp(-(rr/alpha)**2)
383 safe_allocate(x(1:sys%gr%np))
389 write(
message(1),
'(a,i6,a)')
"Info: CG converged with ", iter,
" iterations."
390 write(
message(2),
'(a,e14.6)')
"Info: The residue is ", res
391 write(
message(3),
'(a,e14.6)')
"Info: Norm solution CG ",
dmf_nrm2(sys%gr, x)
396 safe_deallocate_a(rho)
397 safe_deallocate_p(sys)
412 real(real64),
contiguous,
intent(in) :: x(:)
413 real(real64),
contiguous,
intent(out) :: Hx(:)
415 real(real64),
allocatable :: tmpx(:)
419 safe_allocate(tmpx(1:
mesh_aux%np_part))
424 safe_deallocate_a(tmpx)
439 complex(real64),
allocatable :: psi(:, :)
445 call messages_write(
'Info: Testing the nonlocal part of the pseudopotential with SOC')
450 sys =>
electrons_t(namespace, generate_epot=.false.)
459 call sys%st%group%psib(1, 1)%copy_to(epsib)
463 do itime = 1, param%repetitions
465 sys%hm%ep%natoms, 2, sys%st%group%psib(1, 1), epsib)
468 safe_allocate(psi(1:sys%gr%np, 1:sys%st%d%dim))
469 do itime = 1, epsib%nst
471 write(
message(1),
'(a,i1,3x, f12.6)')
"Norm state ", itime,
zmf_nrm2(sys%gr, 2, psi)
474 safe_deallocate_a(psi)
478 safe_deallocate_p(sys)
490 integer :: itime, ist
492 real(real64),
allocatable :: ddot(:,:,:), dweight(:,:)
493 complex(real64),
allocatable :: zdot(:,:,:), zweight(:,:)
506 sys =>
electrons_t(namespace, generate_epot=.false.)
511 if (sys%st%pack_states)
call sys%st%pack()
513 call sys%st%group%psib(1, 1)%copy_to(epsib2, copy_data = .
true.)
516 if (.not. sys%hm%phase%is_allocated())
then
517 call sys%st%group%psib(1, 1)%copy_to(epsib, copy_data = .
true.)
519 call sys%st%group%psib(1, 1)%copy_to(epsib)
520 call sys%hm%phase%apply_to(sys%gr, sys%gr%np, &
521 .false., epsib, src=sys%st%group%psib(1, 1))
522 epsib2%has_phase = .
true.
528 call dorbitalbasis_build(basis, sys%namespace, sys%ions, sys%gr, sys%st%d%kpt, sys%st%d%dim, &
529 sys%hm%phase%is_allocated(), .false., .false.)
530 safe_allocate(dweight(1:basis%orbsets(1)%norbs, 1:epsib%nst_linear))
531 safe_allocate(ddot(1:sys%st%d%dim, 1:basis%orbsets(1)%norbs, 1:epsib%nst))
533 call zorbitalbasis_build(basis, sys%namespace, sys%ions, sys%gr, sys%st%d%kpt, sys%st%d%dim, &
534 sys%hm%phase%is_allocated(), .false., .false.)
536 safe_allocate(zweight(1:basis%orbsets(1)%norbs, 1:epsib%nst_linear))
537 safe_allocate(zdot(1:sys%st%d%dim, 1:basis%orbsets(1)%norbs, 1:epsib%nst))
540 if (sys%hm%phase%is_allocated())
then
546 do itime = 1, param%repetitions
561 if (epsib%is_packed())
then
562 call epsib%do_unpack(force = .
true.)
565 do ist = 1, epsib%nst
567 write(
message(1),
'(a,i2,3x,e13.6)')
"Dotp state ", ist, ddot(1,1,ist)
569 write(
message(1),
'(a,i2,2(3x,e13.6))')
"Dotp state ", ist, zdot(1,1,ist)
577 safe_deallocate_a(dweight)
578 safe_deallocate_a(zweight)
579 safe_deallocate_a(ddot)
580 safe_deallocate_a(zdot)
586 safe_deallocate_p(sys)
598 integer :: itime, terms
617 call parse_variable(namespace,
'TestHamiltonianApply', option__testhamiltonianapply__term_all, terms)
618 if (terms == 0) terms = huge(1)
623 call messages_write(
'Info: Testing the application of the Hamiltonian')
628 sys =>
electrons_t(namespace, generate_epot=.false.)
635 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
638 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
640 call boundaries_set(sys%gr%der%boundaries, sys%gr, sys%st%group%psib(1, 1))
642 call sys%st%group%psib(1, 1)%copy_to(hpsib)
644 if (sys%hm%apply_packed())
then
645 call sys%st%group%psib(1, 1)%do_pack()
646 call hpsib%do_pack(copy = .false.)
649 do itime = 1, param%repetitions
659 if (hpsib%is_packed())
then
660 call hpsib%do_unpack(force = .
true.)
665 call hpsib%end(copy = .false.)
667 safe_deallocate_p(sys)
690 sys =>
electrons_t(namespace, generate_epot=.false.)
695 if (sys%st%pack_states)
call sys%st%pack()
697 do itime = 1, param%repetitions
701 write(
message(1),
'(a,3x, f12.6)')
"Norm density ",
dmf_nrm2(sys%gr, sys%st%rho(:,1))
705 safe_deallocate_p(sys)
728 sys =>
electrons_t(namespace, generate_epot=.false.)
733 if (sys%st%pack_states)
call sys%st%pack()
735 do itime = 1, param%repetitions
736 call boundaries_set(sys%gr%der%boundaries, sys%gr, sys%st%group%psib(1, 1))
742 safe_deallocate_p(sys)
756 integer,
allocatable :: degree(:)
764 call messages_write(
'Info: Testing Chebyshev filtering and its composition rule')
769 sys =>
electrons_t(namespace, generate_epot=.false.)
774 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
777 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
780 safe_allocate(degree(1:sys%st%group%nblocks))
790 call parse_variable(namespace,
'TestCompositionOrder', 2, degree_n)
802 call dchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
804 call zchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
808 call messages_write(
'Info: Result after calling 2n-th order filtering')
814 call sys%st%group%psib(1, 1)%copy_to(psib, copy_data=.
true.)
817 call dchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
818 call dchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
820 call zchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
821 call zchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
832 safe_deallocate_a(degree)
833 safe_deallocate_p(bounds)
837 safe_deallocate_p(sys)
862 sys =>
electrons_t(namespace, generate_epot=.false.)
869 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
872 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
876 if (sys%hm%apply_packed())
then
877 call sys%st%group%psib(1, 1)%do_pack()
880 do itime = 1, param%repetitions
881 call te%apply_batch(sys%namespace, sys%gr, sys%hm, sys%st%group%psib(1, 1), 1e-3_real64)
887 safe_deallocate_p(sys)
901 real(real64),
allocatable :: diff(:)
912 sys =>
electrons_t(namespace, generate_epot=.false.)
918 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
921 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
923 call sdiag%init(sys%namespace, sys%st)
925 safe_allocate(diff(1:sys%st%nst))
927 do itime = 1, param%repetitions
929 call dsubspace_diag(sdiag, sys%namespace, sys%gr, sys%st, sys%hm, 1, sys%st%eigenval(:, 1), diff)
931 call zsubspace_diag(sdiag, sys%namespace, sys%gr, sys%st, sys%hm, 1, sys%st%eigenval(:, 1), diff)
935 safe_deallocate_a(diff)
940 safe_deallocate_p(sys)
952 integer :: itime, ops, ops_default, ist, jst, nst
954 real(real64),
allocatable :: tmp(:)
955 real(real64),
allocatable :: ddotv(:)
956 complex(real64),
allocatable :: zdotv(:)
957 real(real64),
allocatable :: ddot(:,:), df(:,:), dweight(:), dpoints(:,:,:)
958 complex(real64),
allocatable :: zdot(:,:), zf(:,:), zweight(:), zpoints(:,:,:)
959 integer :: sp, block_size, size
988 option__testbatchops__ops_axpy + &
989 option__testbatchops__ops_scal + &
990 option__testbatchops__ops_nrm2 + &
991 option__testbatchops__ops_dotp_matrix + &
992 option__testbatchops__ops_dotp_self + &
993 option__testbatchops__ops_dotp_vector + &
994 option__testbatchops__ops_ax_function_py + &
995 option__testbatchops__ops_get_points
1006 sys =>
electrons_t(namespace, generate_epot=.false.)
1007 call sys%init_parallelization(
mpi_world)
1011 if (sys%st%pack_states)
call sys%st%pack()
1013 if (
bitand(ops, option__testbatchops__ops_axpy) /= 0)
then
1014 message(1) =
'Info: Testing axpy'
1017 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1018 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1020 do itime = 1, param%repetitions
1021 call batch_axpy(sys%gr%np, 0.1_real64, xx, yy)
1029 if (
bitand(ops, option__testbatchops__ops_scal) /= 0)
then
1030 message(1) =
'Info: Testing scal'
1033 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1034 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1036 do itime = 1, param%repetitions
1045 if (
bitand(ops, option__testbatchops__ops_nrm2) /= 0)
then
1046 message(1) =
'Info: Testing nrm2'
1049 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1050 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1052 safe_allocate(tmp(1:xx%nst))
1054 do itime = 1, param%repetitions
1057 do itime = 1, xx%nst
1058 write(
message(1),
'(a,i1,3x,e23.16)')
"Nrm2 norm state ", itime, tmp(itime)
1062 safe_deallocate_a(tmp)
1068 if (
bitand(ops, option__testbatchops__ops_dotp_matrix) /= 0)
then
1070 message(1) =
'Info: Testing dotp_matrix'
1073 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1074 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1076 nst = sys%st%group%psib(1, 1)%nst
1079 safe_allocate(ddot(1:nst, 1:nst))
1080 do itime = 1, param%repetitions
1086 write(
message(jst),
'(a,2i3,3x,e23.16)')
'Dotp_matrix states', ist, jst, ddot(ist,jst)
1090 safe_deallocate_a(ddot)
1092 safe_allocate(zdot(1:nst, 1:nst))
1093 do itime = 1, param%repetitions
1099 write(
message(jst),
'(a,2i3,3x,2(e23.16,1x))')
'Dotp_matrix states', ist, jst, zdot(ist,jst)
1103 safe_deallocate_a(zdot)
1110 if (
bitand(ops, option__testbatchops__ops_dotp_vector) /= 0)
then
1112 message(1) =
'Info: Testing dotp_vector'
1115 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1116 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1118 nst = sys%st%group%psib(1, 1)%nst
1121 safe_allocate(ddotv(1:nst))
1122 do itime = 1, param%repetitions
1127 write(
message(ist),
'(a,i3,3x,e23.16)')
'Dotp_vector state', ist, ddotv(ist)
1130 safe_deallocate_a(ddotv)
1132 safe_allocate(zdotv(1:nst))
1133 do itime = 1, param%repetitions
1138 write(
message(ist),
'(a,i3,3x,2(e23.16,1x))')
'Dotp_vector state', ist, zdotv(ist)
1141 safe_deallocate_a(zdotv)
1148 if (
bitand(ops, option__testbatchops__ops_dotp_self) /= 0)
then
1150 message(1) =
'Info: Testing dotp_self'
1153 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1155 nst = sys%st%group%psib(1, 1)%nst
1158 safe_allocate(ddot(1:nst, 1:nst))
1159 do itime = 1, param%repetitions
1165 write(
message(jst),
'(a,2i3,3x,e23.16)')
'Dotp_self states', ist, jst, ddot(ist,jst)
1169 safe_deallocate_a(ddot)
1171 safe_allocate(zdot(1:nst, 1:nst))
1172 do itime = 1, param%repetitions
1178 write(
message(jst),
'(a,2i3,3x,2(e23.16,1x))')
'Dotp_self states', ist, jst, zdot(ist,jst)
1182 safe_deallocate_a(zdot)
1188 if (
bitand(ops, option__testbatchops__ops_ax_function_py) /= 0)
then
1189 message(1) =
'Info: Testing ax_function_py'
1192 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1195 safe_allocate(df(sys%gr%np, sys%st%d%dim))
1196 safe_allocate(dweight(1:sys%st%group%psib(1, 1)%nst_linear))
1197 dweight = 0.1_real64
1200 do itime = 1, param%repetitions
1203 safe_deallocate_a(df)
1204 safe_deallocate_a(dweight)
1206 safe_allocate(zf(sys%gr%np, sys%st%d%dim))
1207 safe_allocate(zweight(1:sys%st%group%psib(1, 1)%nst_linear))
1208 zweight = cmplx(0.1_real64,
m_zero, real64)
1211 do itime = 1, param%repetitions
1214 safe_deallocate_a(zf)
1221 if (
bitand(ops, option__testbatchops__ops_get_points) /= 0)
then
1226 call sys%st%group%psib(1, 1)%copy_to(yy)
1232 safe_allocate(dpoints(1:sys%st%nst, 1:sys%st%d%dim, 1:block_size))
1234 do itime = 1, param%repetitions
1235 do sp = 1, sys%gr%np, block_size
1236 size = min(block_size, sys%gr%np - sp + 1)
1241 safe_deallocate_a(dpoints)
1247 safe_allocate(zpoints(1:sys%st%nst, 1:sys%st%d%dim, 1:block_size))
1249 do itime = 1, param%repetitions
1250 do sp = 1, sys%gr%np, block_size
1251 size = min(block_size, sys%gr%np - sp + 1)
1256 safe_deallocate_a(dpoints)
1267 safe_deallocate_p(sys)
1281 sys =>
electrons_t(namespace, generate_epot=.false.)
1282 call sys%init_parallelization(
mpi_world)
1284 message(1) =
'Info: Testing the finite-differences derivatives.'
1288 if (param%type == option__testtype__all .or. param%type == option__testtype__real)
then
1289 call dderivatives_test(sys%gr%der, sys%namespace, param%repetitions, param%min_blocksize, param%max_blocksize)
1292 if (param%type == option__testtype__all .or. param%type == option__testtype__complex)
then
1293 call zderivatives_test(sys%gr%der, sys%namespace, param%repetitions, param%min_blocksize, param%max_blocksize)
1296 safe_deallocate_p(sys)
1315 sys =>
electrons_t(namespace, generate_epot=.false.)
1316 call sys%init_parallelization(
mpi_world)
1318 message(1) =
'Info: Testing orthogonalization.'
1322 if (param%type == option__testtype__all .or. param%type == option__testtype__real)
then
1323 message(1) =
'Info: Real wave-functions.'
1325 do itime = 1, param%repetitions
1330 if (param%type == option__testtype__all .or. param%type == option__testtype__complex)
then
1331 message(1) =
'Info: Complex wave-functions.'
1333 do itime = 1, param%repetitions
1338 safe_deallocate_p(sys)
1353 sys =>
electrons_t(namespace, generate_epot=.false.)
1354 call sys%init_parallelization(
mpi_world)
1356 if (param%type == option__testtype__all .or. param%type == option__testtype__real)
then
1365 if (param%type == option__testtype__all .or. param%type == option__testtype__complex)
then
1367 call messages_write(
'Info: Testing complex interpolation routines')
1375 safe_deallocate_p(sys)
1390 sys =>
electrons_t(namespace, generate_epot=.false.)
1391 call sys%init_parallelization(
mpi_world)
1393 call ion_interaction_test(sys%space, sys%ions%latt, sys%ions%atom, sys%ions%natoms, sys%ions%pos, &
1394 sys%gr%box%bounding_box_l, namespace, sys%mc)
1396 safe_deallocate_p(sys)
1405 type(
grid_t),
intent(in) :: gr
1406 class(
batch_t),
intent(inout) :: psib
1407 character(*),
optional,
intent(in) :: string
1410 complex(real64),
allocatable :: zpsi(:, :)
1411 real(real64),
allocatable :: dpsi(:, :)
1413 character(80) :: string_
1420 safe_allocate(dpsi(1:gr%np, 1:st%d%dim))
1422 safe_allocate(zpsi(1:gr%np, 1:st%d%dim))
1425 do itime = 1, psib%nst
1428 write(
message(1),
'(a,i2,3x,e23.16)')
"Norm state "//trim(string_)//
" ", itime,
dmf_nrm2(gr, st%d%dim, dpsi)
1431 write(
message(1),
'(a,i2,3x,e23.16)')
"Norm state "//trim(string_)//
" ", itime,
zmf_nrm2(gr, st%d%dim, zpsi)
1437 safe_deallocate_a(dpsi)
1439 safe_deallocate_a(zpsi)
1455 write(
message(1),
'(a)')
" Operation Counter Time Global step"
1470 call clock%set(
clock_t(time_step=
m_four, initial_iteration=1))
1474 write(
message(1),
'(a)')
" Clock comparisons:"
1477 other_clock =
clock_t(time_step=
m_one, initial_iteration=5)
1489 character(len=*),
intent(in) :: operation
1491 write(
message(1),
'(a17,1x,i6,1x,f10.1,1x,i16)') operation, clock%counter(), clock%value(), clock%global_step()
1496 character(len=*),
intent(in) :: condition
1497 logical,
intent(in) :: result
1499 write(
message(1),
'(a10," = ",i1," (",l1,")")') condition, abs(transfer(result, 0)), result
1516 message(1) =
"cgal_polyhedron_point_inside"
1528 integer :: N, ii, jj, N_list(4), i_N
1529 real(real64),
allocatable :: matrix(:, :), eigenvectors(:, :), eigenvalues(:), test(:)
1530 real(real64),
allocatable :: differences(:)
1534 n_list = [15, 32, 100, 500]
1538 safe_allocate(matrix(1:n, 1:n))
1539 safe_allocate(eigenvectors(1:n, 1:n))
1540 safe_allocate(eigenvalues(1:n))
1541 safe_allocate(test(1:n))
1542 safe_allocate(differences(1:n))
1548 matrix(ii, jj) = ii * jj
1553 eigenvectors(1:n, 1:n) = matrix(1:n, 1:n)
1557 test(:) = matmul(matrix, eigenvectors(:, ii)) - eigenvalues(ii) * eigenvectors(:, ii)
1558 differences(ii) = sum(abs(test)) / sum(abs(eigenvectors(:, ii)))
1560 write(
message(1),
"(A, I3, A, E13.6)")
"Parallel solver - N: ", n, &
1561 ", average difference: ", sum(differences)/n
1565 eigenvectors(1:n, 1:n) = matrix(1:n, 1:n)
1569 test(:) = matmul(matrix, eigenvectors(:, ii)) - eigenvalues(ii) * eigenvectors(:, ii)
1570 differences(ii) = sum(abs(test)) / sum(abs(eigenvectors(:, ii)))
1572 write(
message(1),
"(A, I3, A, E13.6)")
"Serial solver - N: ", n, &
1573 ", average difference: ", sum(differences)/n
1576 safe_deallocate_a(matrix)
1577 safe_deallocate_a(eigenvectors)
1578 safe_deallocate_a(eigenvalues)
1579 safe_deallocate_a(test)
1580 safe_deallocate_a(differences)
1587 class(
batch_t),
intent(inout) :: psib
1590 real(real64),
allocatable :: dff(:)
1591 complex(real64),
allocatable :: zff(:)
1593 real(real64) :: da, db, dc
1594 complex(real64) :: za, zb, zc
1599 da =
m_one/mesh%box%bounding_box_l(1)
1605 za = da +
m_zi*0.01_real64
1606 zb = db*
exp(
m_zi*0.345_real64)
1607 zc = dc -
m_zi*50.0_real64
1609 safe_allocate(zff(1:mesh%np))
1610 do ist = 1, psib%nst_linear
1614 zff(ip) = zb*
exp(-za*sum(mesh%x(ip, :)**2)) + zc
1619 safe_deallocate_a(zff)
1621 safe_allocate(dff(1:mesh%np))
1622 do ist = 1, psib%nst_linear
1626 dff(ip) = db*
exp(-da*sum(mesh%x(ip, :)**2)) + dc
1631 safe_deallocate_a(dff)
1645 call sys%init_parallelization(
mpi_world)
1648 sys%gr%stencil, sys%mc, nlevels=3)
1654 safe_deallocate_p(sys)
1670 write(
message(1),*)
'hash[1] :', found,
value
1674 write(
message(1),*)
'hash[2] :', found,
value
1678 write(
message(1),*)
'hash[3] :', found,
value
1690 integer ::
value, sum
1699 write(
message(1),*)
'hash["one"]: ', found,
value
1703 write(
message(1),*)
'hash["two"]: ', found,
value
1707 write(
message(1),*)
'hash["three"]: ', found,
value
1714 do while (it%has_next())
1715 value = it%get_next()
1717 write(
message(1),
'(I3,A,I5)') counter,
': hash[...] = ',
value
1719 counter = counter + 1
1721 write(
message(1),*)
'counter = ', counter
1722 write(
message(2),*)
'sum = ', sum
1744 class(*),
pointer :: value
1746 integer :: count_clock, count_space
1748 safe_allocate(clock_2)
1762 write(
message(1),*)
'hash["one"]: ', found,
value%counter()
1765 write(
message(1),*)
'hash["one"]: ', found,
value%short_info()
1768 write(
message(1),*)
'wrong type. found = ', found
1775 write(
message(1),*)
'hash["two"]: ', found,
value%counter()
1778 write(
message(1),*)
'hash["two"]: ', found,
value%short_info()
1781 write(
message(1),*)
'wrong type. found = ',found
1785 safe_deallocate_a(clock_2)
1790 write(
message(1),*)
'hash["three"]: ', found,
value%counter()
1793 write(
message(1),*)
'hash["three"]: ', found,
value%short_info()
1796 write(
message(1),*)
'wrong type. found = ',found
1805 do while (it%has_next())
1806 value => it%get_next()
1809 count_clock = count_clock + 1
1811 count_space = count_space + 1
1815 write(
message(1), *)
'Count_clock = ', count_clock
1816 write(
message(2), *)
'Count_space = ', count_space
1829 real(real64),
allocatable :: ff_A(:), ff_A_reference(:), ff_B(:), ff_B_reference(:), diff_A(:), diff_B(:)
1830 real(real64) :: norm_ff, norm_diff
1839 call sysa%init_parallelization(
mpi_world)
1840 call sysb%init_parallelization(
mpi_world)
1843 safe_allocate(ff_a(1:sysa%gr%np))
1844 safe_allocate(ff_a_reference(1:sysa%gr%np))
1845 safe_allocate(diff_a(1:sysa%gr%np))
1846 safe_allocate(ff_b(1:sysb%gr%np))
1847 safe_allocate(ff_b_reference(1:sysb%gr%np))
1848 safe_allocate(diff_b(1:sysb%gr%np))
1850 do ip = 1, sysa%gr%np
1851 ff_a_reference(ip) =
values(sysa%gr%x(ip, :))
1853 do ip = 1, sysb%gr%np
1854 ff_b_reference(ip) =
values(sysb%gr%x(ip, :))
1858 regridding =>
regridding_t(sysb%gr, sysa%gr, sysa%space, sysa%namespace)
1859 call regridding%do_transfer(ff_b, ff_a_reference)
1860 safe_deallocate_p(regridding)
1863 do ip = 1, sysb%gr%np
1865 ff_b_reference(ip) =
m_zero
1868 diff_b(ip) = abs(ff_b_reference(ip) - ff_b(ip))
1871 norm_ff =
dmf_nrm2(sysb%gr, ff_b_reference)
1872 norm_diff =
dmf_nrm2(sysb%gr, diff_b)
1874 write(
message(1),
'(a, E14.6)')
"Forward: difference of reference to mapped function (rel.): ", &
1879 sysb%gr, ff_b_reference,
unit_one, ierr)
1883 sysa%gr, ff_a_reference,
unit_one, ierr)
1886 regridding =>
regridding_t(sysa%gr, sysb%gr, sysb%space, sysb%namespace)
1887 call regridding%do_transfer(ff_a, ff_b_reference)
1888 safe_deallocate_p(regridding)
1890 do ip = 1, sysa%gr%np
1892 ff_a_reference(ip) =
m_zero
1895 diff_a(ip) = abs(ff_a_reference(ip) - ff_a(ip))
1898 norm_ff =
dmf_nrm2(sysa%gr, ff_a_reference)
1899 norm_diff =
dmf_nrm2(sysa%gr, diff_a)
1901 write(
message(1),
'(a, E14.6)')
"Backward: difference of reference to mapped function (rel.): ", &
1906 sysa%gr, ff_a_reference,
unit_one, ierr)
1910 sysb%gr, ff_b_reference,
unit_one, ierr)
1912 safe_deallocate_a(ff_a)
1913 safe_deallocate_a(ff_a_reference)
1914 safe_deallocate_a(ff_b)
1915 safe_deallocate_a(ff_b_reference)
1916 safe_deallocate_a(diff_a)
1917 safe_deallocate_a(diff_b)
1918 safe_deallocate_p(sysa)
1919 safe_deallocate_p(sysb)
1925 real(real64) function values(xx)
1926 real(real64),
intent(in) :: xx(:)
1927 real(real64) :: xx0(1:size(xx, dim=1))
1928 real(real64),
parameter :: aa =
m_half
1929 real(real64),
parameter :: bb =
m_four
1933 values = bb *
exp(-aa*sum((xx-xx0)**2))
1943 type(namespace_t),
intent(in) :: namespace
1945 class(maxwell_t),
pointer :: maxwell_system
1947 real(real64),
allocatable :: magnetic_field(:,:)
1948 real(real64),
allocatable :: vector_potential_mag(:,:)
1949 real(real64),
allocatable :: vector_potential_analytical(:,:)
1950 real(real64),
allocatable :: delta(:,:)
1951 real(real64) :: exp_factor
1955 real(real64) :: sigma
1956 integer :: ip, j, ierr, nn
1957 integer(int64) :: out_how
1958 character(len=MAX_PATH_LEN) :: fname, fname2, fname3
1961 maxwell_system => maxwell_t(namespace)
1962 sigma = maxwell_system%gr%box%bounding_box_l(1)/10_real64
1963 call maxwell_system%init_parallelization(mpi_world)
1965 safe_allocate(magnetic_field(1:maxwell_system%gr%np_part, 1:3))
1966 safe_allocate(vector_potential_mag(1:maxwell_system%gr%np_part, 1:3))
1967 safe_allocate(vector_potential_analytical(1:maxwell_system%gr%np_part, 1:3))
1968 safe_allocate(delta(1:maxwell_system%gr%np, 1:3))
1981 call parse_variable(namespace,
'TestVectorPotentialType', option__testvectorpotentialtype__bounded, nn)
1984 case (option__testvectorpotentialtype__bounded)
1985 do ip = 1, maxwell_system%gr%np_part
1986 xx = maxwell_system%gr%x(ip, 1)
1987 yy = maxwell_system%gr%x(ip, 2)
1988 zz = maxwell_system%gr%x(ip, 3)
1989 exp_factor =
exp((-xx**2 - yy**2 - zz**2)*1/(2*sigma**2))
1990 magnetic_field(ip, 1) = exp_factor*yy*(1 - (-xx**2 + yy**2)/(3*sigma**2) - zz**2/(3*sigma**2))
1991 magnetic_field(ip, 2) = exp_factor * xx * (1 + (-xx**2 + yy**2)/(3*sigma**2) - zz**2/(3*sigma**2))
1992 magnetic_field(ip, 3) = exp_factor * 2 * xx * yy * zz * 1/(3*sigma**2)
1994 vector_potential_analytical(ip, 1) = m_third * xx * zz * exp_factor
1995 vector_potential_analytical(ip, 2) = - m_third * yy * zz * exp_factor
1996 vector_potential_analytical(ip, 3) = m_third * (-xx**2 + yy**2) * exp_factor
1998 case (option__testvectorpotentialtype__unbounded)
2000 do ip = 1, maxwell_system%gr%np_part
2001 magnetic_field(ip, 1) = maxwell_system%gr%x(ip, 2)
2002 magnetic_field(ip, 2) = maxwell_system%gr%x(ip, 1)
2003 magnetic_field(ip, 3) = m_zero
2005 vector_potential_analytical(ip, 1) = m_third * maxwell_system%gr%x(ip, 1) * maxwell_system%gr%x(ip, 3)
2006 vector_potential_analytical(ip, 2) = - m_third * maxwell_system%gr%x(ip, 2) * maxwell_system%gr%x(ip, 3)
2007 vector_potential_analytical(ip, 3) = - m_third * (maxwell_system%gr%x(ip, 1)**2 - maxwell_system%gr%x(ip, 2)**2)
2010 call maxwell_system%helmholtz%get_vector_potential(namespace, vector_potential_mag, magnetic_field)
2014 do ip = 1, maxwell_system%gr%np
2015 delta(ip,j) = vector_potential_analytical(ip, j) - vector_potential_mag(ip, j)
2020 write(message(j),*)
'j, norm2(delta)', j, norm2(delta(:,j))
2022 call messages_info(3)
2024 write(fname,
'(a)')
'deviation_from_analytical_formulation'
2025 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, maxwell_system%space, maxwell_system%gr, &
2026 delta, unit_one, ierr)
2027 write(fname2,
'(a)')
'vector_potential_analytical'
2028 call io_function_output_vector(out_how ,
'./' , trim(fname2), namespace, maxwell_system%space, maxwell_system%gr, &
2029 vector_potential_analytical, unit_one, ierr)
2030 write(fname3,
'(a)')
'vector_potential_mag'
2031 call io_function_output_vector(out_how ,
'./' , trim(fname3), namespace, maxwell_system%space, maxwell_system%gr, &
2032 vector_potential_mag, unit_one, ierr)
2034 safe_deallocate_a(magnetic_field)
2035 safe_deallocate_a(vector_potential_mag)
2036 safe_deallocate_a(vector_potential_analytical)
2037 safe_deallocate_a(delta)
2038 safe_deallocate_p(maxwell_system)
2044 type(multigrid_t),
intent(in) :: mgrid
2045 class(space_t),
intent(in) :: space
2047 real(real64),
allocatable :: guess0(:), res0(:), guess1(:)
2048 type(mesh_t),
pointer :: mesh0, mesh1
2049 real(real64) :: delta, xx(3,2), alpha, beta, rr
2050 integer :: nn, ip, ierr
2054 message(1) =
'Info: Testing the grid interpolation.'
2056 call messages_info(2)
2058 mesh0 => mgrid%level(0)%mesh
2059 mesh1 => mgrid%level(1)%mesh
2061 safe_allocate(guess0(1:mesh0%np_part))
2062 safe_allocate(res0(1:mesh0%np_part))
2063 safe_allocate(guess1(1:mesh1%np_part))
2065 alpha = m_four*mesh0%spacing(1)
2066 beta = m_one / (alpha**space%dim *
sqrt(m_pi)**space%dim)
2081 call mesh_r(mesh0, ip, rr, origin = xx(:, nn))
2082 guess0(ip) = guess0(ip) + (-1)**nn * beta*
exp(-(rr/alpha)**2)
2086 call dio_function_output (io_function_fill_how(
'AxisX'),
".",
"interpolation_target", global_namespace, &
2087 space, mesh0, guess0, unit_one, ierr)
2088 call dio_function_output (io_function_fill_how(
'AxisZ'),
".",
"interpolation_target", global_namespace, &
2089 space, mesh0, guess0, unit_one, ierr)
2090 call dio_function_output (io_function_fill_how(
'PlaneZ'),
".",
"interpolation_target", global_namespace, &
2091 space, mesh0, guess0, unit_one, ierr)
2098 call dmultigrid_fine2coarse(mgrid%level(1)%tt, mgrid%level(0)%der, mesh1, guess0, guess1, injection)
2100 call dmultigrid_coarse2fine(mgrid%level(1)%tt, mgrid%level(1)%der, mesh0, guess1, res0)
2102 call dio_function_output (io_function_fill_how(
'AxisX'),
".",
"interpolation_result", global_namespace, &
2103 space, mesh0, res0, unit_one, ierr)
2104 call dio_function_output (io_function_fill_how(
'AxisZ'),
".",
"interpolation_result", global_namespace, &
2105 space, mesh0, res0, unit_one, ierr)
2106 call dio_function_output (io_function_fill_how(
'PlaneZ'),
".",
"interpolation_result", global_namespace, &
2107 space, mesh0, res0, unit_one, ierr)
2109 delta = dmf_nrm2(mesh0, guess0(1:mesh0%np)-res0(1:mesh0%np))
2110 write(message(1),
'(a,e13.6)')
'Interpolation test (abs.) = ', delta
2116 call dmultigrid_fine2coarse(mgrid%level(1)%tt, mgrid%level(0)%der, mesh1, guess0, guess1, fullweight)
2118 call dmultigrid_coarse2fine(mgrid%level(1)%tt, mgrid%level(1)%der, mesh0, guess1, res0)
2120 call dio_function_output (io_function_fill_how(
'AxisX'),
".",
"restriction_result", global_namespace, &
2121 space, mesh0, res0, unit_one, ierr)
2122 call dio_function_output (io_function_fill_how(
'AxisZ'),
".",
"restriction_result", global_namespace, &
2123 space, mesh0, res0, unit_one, ierr)
2124 call dio_function_output (io_function_fill_how(
'PlaneZ'),
".",
"restriction_result", global_namespace, &
2125 space, mesh0, res0, unit_one, ierr)
2127 delta = dmf_nrm2(mesh0, guess0(1:mesh0%np)-res0(1:mesh0%np))
2128 write(message(2),
'(a,e13.6)')
'Restriction test (abs.) = ', delta
2129 call messages_info(2)
2131 safe_deallocate_a(guess0)
2132 safe_deallocate_a(res0)
2133 safe_deallocate_a(guess1)
2141 type(namespace_t),
intent(in) :: namespace
2142 type(electrons_t),
pointer :: sys
2144 type(current_t) :: current
2145 character(len=MAX_PATH_LEN) :: fname
2146 integer :: ierr, ip, idir
2147 integer(int64) :: out_how
2148 real(real64),
allocatable :: current_para_ref(:,:), current_dia_ref(:,:), current_mag_ref(:,:), delta(:)
2149 real(real64) :: xx(3), rr, a0, mag_curr, sin_thet, sin_phi, cos_phi, vec_pot_slope
2150 complex(real64) :: alpha
2152 sys => electrons_t(namespace, generate_epot=.false.)
2153 call sys%init_parallelization(mpi_world)
2155 alpha = (0.0_real64, 0.5_real64)
2157 vec_pot_slope = 0.4_real64
2159 call states_elec_allocate_wfns(sys%st, sys%gr, wfs_type = type_cmplx)
2162 call current_init(current, namespace)
2164 call hamiltonian_elec_epot_generate(sys%hm, sys%namespace, sys%space, sys%gr, sys%ions, sys%ext_partners, sys%st)
2166 safe_allocate(sys%hm%hm_base%vector_potential(1:3, 1:sys%gr%np))
2168 sys%hm%hm_base%vector_potential = m_zero
2169 do ip = 1, sys%gr%np
2170 xx = sys%gr%x(ip, 1:3)
2171 sys%hm%hm_base%vector_potential(2, ip) = vec_pot_slope * xx(1) / p_c
2174 call states_elec_allocate_current(sys%st, sys%space, sys%gr)
2175 call density_calc(sys%st, sys%gr, sys%st%rho)
2177 call current_calculate(current, namespace, sys%gr, sys%hm, sys%space, sys%st)
2179 safe_allocate(current_para_ref(1:sys%gr%np,1:3))
2180 safe_allocate(current_dia_ref(1:sys%gr%np,1:3))
2181 safe_allocate(current_mag_ref(1:sys%gr%np,1:3))
2182 safe_allocate(delta(1:sys%gr%np))
2185 current_para_ref(:,:) = m_zero
2186 do ip = 1, sys%gr%np
2187 call mesh_r(sys%gr, ip, rr)
2188 xx = sys%gr%x(ip, 1:3)
2189 if (rr > r_small)
then
2191 psi_1s(rr, a0) *
dr_psi_2s(rr, a0) ) * aimag(alpha) / (1 + abs(alpha)**2) * xx(1:3) / rr
2195 write(fname,
'(a)')
'current_para'
2196 out_how = io_function_fill_how(
"PlaneZ")
2197 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2198 sys%st%current_para(:,:,1), unit_one, ierr)
2200 write(fname,
'(a)')
'current_para-ref'
2201 out_how = io_function_fill_how(
"PlaneZ")
2202 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2203 current_para_ref(:,:), unit_one, ierr)
2207 delta(:) = current_para_ref(1:sys%gr%np, idir) - sys%st%current_para(1:sys%gr%np, idir, 1)
2208 write(message(idir),*)
'idir =',idir,
', norm2(delta paramagnetic)',norm2(delta)
2210 call messages_info(3)
2213 current_dia_ref(:,:) = m_zero
2214 do ip = 1, sys%gr%np
2215 call mesh_r(sys%gr, ip, rr)
2216 current_dia_ref(ip,1:3) = - sys%hm%hm_base%vector_potential(1:3,ip) *&
2220 write(fname,
'(a)')
'current_dia'
2221 out_how = io_function_fill_how(
"PlaneZ")
2222 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2223 sys%st%current_dia(:,:,1), unit_one, ierr)
2225 write(fname,
'(a)')
'current_dia-ref'
2226 out_how = io_function_fill_how(
"PlaneZ")
2227 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2228 current_dia_ref(:,:), unit_one, ierr)
2232 delta(:) = current_dia_ref(1:sys%gr%np, idir) - sys%st%current_dia(1:sys%gr%np, idir, 1)
2233 write(message(idir),*)
'idir =',idir,
', norm2(delta diamagnetic)',norm2(delta)
2235 call messages_info(3)
2238 call current_calculate_mag(sys%gr%der, sys%st)
2241 current_mag_ref(:,:) = m_zero
2242 do ip = 1, sys%gr%np
2243 call mesh_r(sys%gr, ip, rr)
2244 xx = sys%gr%x(ip, 1:3)
2245 if (norm2(xx(1:2)) > r_small .and. rr > r_small)
then
2246 sin_thet = norm2(xx(1:2)) / rr
2247 sin_phi = xx(2) / norm2(xx(1:2))
2248 cos_phi = xx(1) / norm2(xx(1:2))
2252 current_mag_ref(ip,1) = m_half * mag_curr * sin_thet * sin_phi / (1+abs(alpha)**2)
2253 current_mag_ref(ip,2) = -m_half * mag_curr * sin_thet * cos_phi / (1+abs(alpha)**2)
2257 write(fname,
'(a)')
'current_mag'
2258 out_how = io_function_fill_how(
"PlaneZ")
2259 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2260 sys%st%current_mag(:,:,1), unit_one, ierr)
2262 write(fname,
'(a)')
'current_mag-ref'
2263 out_how = io_function_fill_how(
"PlaneZ")
2264 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2265 current_mag_ref(:,:), unit_one, ierr)
2269 delta(:) = current_mag_ref(1:sys%gr%np, idir) - sys%st%current_mag(1:sys%gr%np, idir, 1)
2270 write(message(idir),*)
'idir =',idir,
', norm2(delta magnetization)',norm2(delta)
2272 call messages_info(3)
2274 safe_deallocate_a(current_para_ref)
2275 safe_deallocate_a(current_dia_ref)
2276 safe_deallocate_a(current_mag_ref)
2277 safe_deallocate_a(delta)
2278 safe_deallocate_p(sys)
2284 class(batch_t),
intent(inout) :: psib
2285 class(mesh_t),
intent(in) :: mesh
2286 type(namespace_t),
intent(in) :: namespace
2287 complex(real64),
intent(in) :: alpha
2288 real(real64),
intent(in) :: a0
2290 complex(real64),
allocatable :: zff(:)
2297 safe_allocate(zff(1:mesh%np))
2298 if (type_is_complex(psib%type()))
then
2300 call mesh_r(mesh, ip, rr)
2302 call batch_set_state(psib, 1, mesh%np, zff)
2304 safe_deallocate_a(zff)
2306 write(message(1),*)
"States should be complex for the linear combination of hydrogenic states to work"
2307 call messages_info(1, namespace=namespace)
2314 real(real64),
intent(in) :: a0, rr
2315 complex(real64),
intent(in) :: alpha
2321 real(real64) function psi_1s(rr, a0)
2322 real(real64),
intent(in) :: a0, rr
2328 real(real64) function psi_2s(rr, a0)
2329 real(real64),
intent(in) :: a0, rr
2331 psi_2s =
sqrt(m_two) * a0**(-m_three/m_two) * (m_one - rr/(m_two * a0)) *
exp(-rr/(m_two * a0)) &
2332 / (m_two *
sqrt(m_pi))
2335 real(real64) function dr_psi_1s(rr, a0)
2336 real(real64),
intent(in) :: a0, rr
2341 real(real64) function dr_psi_2s(rr, a0)
2342 real(real64),
intent(in) :: a0, rr
2345 a0**(-m_five/m_two) *
exp(-rr/(m_two * a0)) / (
sqrt(m_two) * m_two *
sqrt(m_pi))
2350 type(namespace_t),
intent(in) :: namespace
2353 integer(int64) :: i, j, k
2354 integer(int64) :: dims(3)
2355 character(len=MAX_PATH_LEN) :: fname
2357 real(real64),
allocatable :: ff(:)
2367 call parse_variable(namespace,
'TestCSVFileName',
"", fname)
2369 message(1) =
"Attempting to probe "//trim(fname)
2370 call messages_info(1, namespace=namespace)
2372 call io_csv_get_info(fname, dims, ierr)
2374 message(1) =
"Probing successful."
2375 write(message(2),
'("found dimensions: ",3I20)') dims
2376 call messages_info(2, namespace=namespace)
2378 write(message(1),
'("Probing failed. ierr = ",I5)') ierr
2379 call messages_fatal(1, namespace=namespace)
2382 safe_allocate(ff(1:dims(1)*dims(2)*dims(3)))
2384 message(1) =
"Attempting to read "//trim(fname)
2385 call messages_info(1, namespace=namespace)
2387 call dread_csv(fname, dims(1)*dims(2)*dims(3), ff, ierr)
2389 message(1) =
"Reading successful."
2390 call messages_info(1, namespace=namespace)
2392 do k=1, min(4_int64, dims(3))
2393 do j=1, min(4_int64, dims(2))
2394 write(message(j),
'("data ",2I5, 1X, 4F8.2)') k, j, &
2395 (ff(i + dims(1)*(j-1) + dims(1)* dims(2)*(k-1)), i=1, min(4_int64, dims(1)))
2397 write(message(int(j, int32)),
'("")')
2398 call messages_info(int(j, int32), namespace=namespace)
2402 message(1) =
"Reading failed."
2403 call messages_fatal(1, namespace=namespace)
2406 safe_deallocate_a(ff)
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__
pure logical function, public accel_is_enabled()
This module implements batches of mesh functions.
This module implements common operations on batches of mesh functions.
subroutine, public dbatch_ax_function_py(np, aa, psi, yy)
This routine performs a set of axpy operations adding the same function psi to all functions of a bat...
subroutine, public batch_set_zero(this, np, async)
fill all mesh functions of the batch with zero
subroutine, public zbatch_ax_function_py(np, aa, psi, yy)
This routine performs a set of axpy operations adding the same function psi to all functions of a bat...
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)
pure real(real64) function center(this)
Center of the filter interval.
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
subroutine, public zchebyshev_filter(namespace, mesh, st, hm, degree, bounds, ik, normalize)
Chebyshev Filter.
subroutine, public dchebyshev_filter(namespace, mesh, st, hm, degree, bounds, ik, normalize)
Chebyshev Filter.
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)
type(hardware_t), public cpu_hardware
Global instance of CPU hardware specification.
integer, parameter, public sizeof_real64
Number of bytes to store a variable of type real(real64)
integer, parameter, public sizeof_complex64
Number of bytes to store a variable of type complex(real64)
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 modules takes care of testing some linear algebra routines.
subroutine, public test_exponential_matrix(namespace)
Unit tests for the exponential of a matrix.
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_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 dorbitalset_get_coeff_batch(os, ndim, psib, dot, reduce)
subroutine, public zorbitalset_get_coeff_batch(os, ndim, psib, dot, reduce)
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.
Integration tests for ISDF.
subroutine, public test_isdf(namespace, serial)
Set up an electron system, compute some optimal centroid positions, and use these to build a set of I...
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)
subroutine test_composition_chebyshev(namespace)
Test the composition rule for Chebyshev polynomials.
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_csv_input(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.
Overload default constructor.
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)