54 use,
intrinsic :: iso_fortran_env
105 real(real64) :: shift_aux
106 type(derivatives_t),
pointer :: der_aux => null()
107 type(preconditioner_t) :: prec_aux
117 type(namespace_t),
intent(in) :: namespace
119 type(test_parameters_t) :: param
126 call param%init_from_file(namespace)
201 call parse_variable(namespace,
'TestMode', option__testmode__hartree, test_mode)
211 select case (test_mode)
212 case (option__testmode__hartree)
214 case (option__testmode__derivatives)
216 case (option__testmode__orthogonalization)
218 case (option__testmode__interpolation)
220 case (option__testmode__ion_interaction)
222 case (option__testmode__projector)
224 case (option__testmode__dft_u)
226 case (option__testmode__hamiltonian_apply)
228 case (option__testmode__density_calc)
230 case (option__testmode__exp_apply)
232 case (option__testmode__boundaries)
234 case (option__testmode__subspace_diag)
236 case (option__testmode__batch_ops)
238 case (option__testmode__clock)
240 case (option__testmode__linear_solver)
242 case (option__testmode__cgal)
244 case (option__testmode__dense_eigensolver)
246 case (option__testmode__grid_interpolation)
248 case (option__testmode__iihash)
250 case (option__testmode__sihash)
252 case (option__testmode__sphash)
254 case (option__testmode__mpiwrappers)
256 case (option__testmode__regridding)
258 case (option__testmode__helmholtz_decomposition)
260 case (option__testmode__vecpot_analytical)
262 case (option__testmode__current_density)
264 case (option__testmode__mixing_tests)
266 case (option__testmode__optimizers)
268 case (option__testmode__weighted_kmeans)
270 case (option__testmode__csv_input)
272 case (option__testmode__composition_chebyshev)
274 case (option__testmode__lalg_adv)
292 sys =>
electrons_t(namespace, generate_epot=.false.)
294 call poisson_test(sys%hm%psolver, sys%space, sys%gr, sys%ions%latt, namespace, param%repetitions)
295 safe_deallocate_p(sys)
312 sys =>
electrons_t(namespace, generate_epot=.false.)
315 call helmholtz%init(namespace, sys%gr, sys%mc, sys%space)
318 write(
message(1),
'(a)')
"Helmholtz decomposition: beginning Hertzian dipole test"
322 write(
message(1),
'(a)')
"Helmholtz decomposition: beginning Gaussian test"
324 call gaussian_test(helmholtz, sys%gr, sys%namespace, sys%space)
326 safe_deallocate_p(sys)
336 real(real64),
allocatable :: rho(:), x(:),
center(:)
337 real(real64) :: rr, alpha, beta, res
340 real(real64),
parameter :: threshold = 1.e-7_real64
346 sys =>
electrons_t(namespace, generate_epot=.false.)
352 shift_aux = 0.25_real64
360 alpha =
m_four * sys%gr%spacing(1)
361 beta =
m_one / (alpha**sys%space%dim *
sqrt(
m_pi)**sys%space%dim)
363 safe_allocate(
center(1:sys%space%dim))
366 safe_allocate(rho(1:sys%gr%np))
370 rho(ip) = beta*
exp(-(rr/alpha)**2)
373 safe_allocate(x(1:sys%gr%np))
379 write(
message(1),
'(a,i6,a)')
"Info: CG converged with ", iter,
" iterations."
380 write(
message(2),
'(a,e14.6)')
"Info: The residue is ", res
381 write(
message(3),
'(a,e14.6)')
"Info: Norm solution CG ",
dmf_nrm2(sys%gr, x)
386 safe_deallocate_a(rho)
387 safe_deallocate_p(sys)
402 real(real64),
contiguous,
intent(in) :: x(:)
403 real(real64),
contiguous,
intent(out) :: Hx(:)
405 real(real64),
allocatable :: tmpx(:)
409 safe_allocate(tmpx(1:
mesh_aux%np_part))
414 safe_deallocate_a(tmpx)
429 complex(real64),
allocatable :: psi(:, :)
435 call messages_write(
'Info: Testing the nonlocal part of the pseudopotential with SOC')
440 sys =>
electrons_t(namespace, generate_epot=.false.)
449 call sys%st%group%psib(1, 1)%copy_to(epsib)
453 do itime = 1, param%repetitions
455 sys%hm%ep%natoms, 2, sys%st%group%psib(1, 1), epsib)
458 safe_allocate(psi(1:sys%gr%np, 1:sys%st%d%dim))
459 do itime = 1, epsib%nst
461 write(
message(1),
'(a,i1,3x, f12.6)')
"Norm state ", itime,
zmf_nrm2(sys%gr, 2, psi)
464 safe_deallocate_a(psi)
468 safe_deallocate_p(sys)
480 integer :: itime, ist
482 real(real64),
allocatable :: ddot(:,:,:), dweight(:,:)
483 complex(real64),
allocatable :: zdot(:,:,:), zweight(:,:)
496 sys =>
electrons_t(namespace, generate_epot=.false.)
501 if (sys%st%pack_states)
call sys%st%pack()
503 call sys%st%group%psib(1, 1)%copy_to(epsib2, copy_data = .
true.)
506 if (.not. sys%hm%phase%is_allocated())
then
507 call sys%st%group%psib(1, 1)%copy_to(epsib, copy_data = .
true.)
509 call sys%st%group%psib(1, 1)%copy_to(epsib)
510 call sys%hm%phase%apply_to(sys%gr, sys%gr%np, &
511 .false., epsib, src=sys%st%group%psib(1, 1))
512 epsib2%has_phase = .
true.
518 call dorbitalbasis_build(basis, sys%namespace, sys%ions, sys%gr, sys%st%d%kpt, sys%st%d%dim, &
519 sys%hm%phase%is_allocated(), .false., .false.)
520 safe_allocate(dweight(1:basis%orbsets(1)%norbs, 1:epsib%nst_linear))
521 safe_allocate(ddot(1:sys%st%d%dim, 1:basis%orbsets(1)%norbs, 1:epsib%nst))
523 call zorbitalbasis_build(basis, sys%namespace, sys%ions, sys%gr, sys%st%d%kpt, sys%st%d%dim, &
524 sys%hm%phase%is_allocated(), .false., .false.)
526 safe_allocate(zweight(1:basis%orbsets(1)%norbs, 1:epsib%nst_linear))
527 safe_allocate(zdot(1:sys%st%d%dim, 1:basis%orbsets(1)%norbs, 1:epsib%nst))
530 if (sys%hm%phase%is_allocated())
then
536 do itime = 1, param%repetitions
551 if (epsib%is_packed())
then
552 call epsib%do_unpack(force = .
true.)
555 do ist = 1, epsib%nst
557 write(
message(1),
'(a,i2,3x,e13.6)')
"Dotp state ", ist, ddot(1,1,ist)
559 write(
message(1),
'(a,i2,2(3x,e13.6))')
"Dotp state ", ist, zdot(1,1,ist)
567 safe_deallocate_a(dweight)
568 safe_deallocate_a(zweight)
569 safe_deallocate_a(ddot)
570 safe_deallocate_a(zdot)
576 safe_deallocate_p(sys)
588 integer :: itime, terms
607 call parse_variable(namespace,
'TestHamiltonianApply', option__testhamiltonianapply__term_all, terms)
608 if (terms == 0) terms = huge(1)
613 call messages_write(
'Info: Testing the application of the Hamiltonian')
618 sys =>
electrons_t(namespace, generate_epot=.false.)
625 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
628 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
630 call boundaries_set(sys%gr%der%boundaries, sys%gr, sys%st%group%psib(1, 1))
632 call sys%st%group%psib(1, 1)%copy_to(hpsib)
634 if (sys%hm%apply_packed())
then
635 call sys%st%group%psib(1, 1)%do_pack()
636 call hpsib%do_pack(copy = .false.)
639 do itime = 1, param%repetitions
649 if (hpsib%is_packed())
then
650 call hpsib%do_unpack(force = .
true.)
655 call hpsib%end(copy = .false.)
657 safe_deallocate_p(sys)
680 sys =>
electrons_t(namespace, generate_epot=.false.)
685 if (sys%st%pack_states)
call sys%st%pack()
687 do itime = 1, param%repetitions
691 write(
message(1),
'(a,3x, f12.6)')
"Norm density ",
dmf_nrm2(sys%gr, sys%st%rho(:,1))
695 safe_deallocate_p(sys)
718 sys =>
electrons_t(namespace, generate_epot=.false.)
723 if (sys%st%pack_states)
call sys%st%pack()
725 do itime = 1, param%repetitions
726 call boundaries_set(sys%gr%der%boundaries, sys%gr, sys%st%group%psib(1, 1))
732 safe_deallocate_p(sys)
746 integer,
allocatable :: degree(:)
754 call messages_write(
'Info: Testing Chebyshev filtering and its composition rule')
759 sys =>
electrons_t(namespace, generate_epot=.false.)
764 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
767 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
770 safe_allocate(degree(1:sys%st%group%nblocks))
780 call parse_variable(namespace,
'TestCompositionOrder', 2, degree_n)
792 call dchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
794 call zchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
798 call messages_write(
'Info: Result after calling 2n-th order filtering')
804 call sys%st%group%psib(1, 1)%copy_to(psib, copy_data=.
true.)
807 call dchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
808 call dchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
810 call zchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
811 call zchebyshev_filter(namespace, sys%gr, sys%st, sys%hm, degree, bounds, 1, normalize=.false.)
822 safe_deallocate_a(degree)
823 safe_deallocate_p(bounds)
827 safe_deallocate_p(sys)
852 sys =>
electrons_t(namespace, generate_epot=.false.)
859 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
862 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
866 if (sys%hm%apply_packed())
then
867 call sys%st%group%psib(1, 1)%do_pack()
870 do itime = 1, param%repetitions
871 call te%apply_batch(sys%namespace, sys%gr, sys%hm, sys%st%group%psib(1, 1), 1e-3_real64)
877 safe_deallocate_p(sys)
891 real(real64),
allocatable :: diff(:)
902 sys =>
electrons_t(namespace, generate_epot=.false.)
908 if (sys%st%pack_states .and. sys%hm%apply_packed())
call sys%st%pack()
911 call v_ks_calc(sys%ks, sys%namespace, sys%space, sys%hm, sys%st, sys%ions, sys%ext_partners)
913 call sdiag%init(sys%namespace, sys%st)
915 safe_allocate(diff(1:sys%st%nst))
917 do itime = 1, param%repetitions
919 call dsubspace_diag(sdiag, sys%namespace, sys%gr, sys%st, sys%hm, 1, sys%st%eigenval(:, 1), diff)
921 call zsubspace_diag(sdiag, sys%namespace, sys%gr, sys%st, sys%hm, 1, sys%st%eigenval(:, 1), diff)
925 safe_deallocate_a(diff)
930 safe_deallocate_p(sys)
942 integer :: itime, ops, ops_default, ist, jst, nst
944 real(real64),
allocatable :: tmp(:)
945 real(real64),
allocatable :: ddotv(:)
946 complex(real64),
allocatable :: zdotv(:)
947 real(real64),
allocatable :: ddot(:,:), df(:,:), dweight(:), dpoints(:,:,:)
948 complex(real64),
allocatable :: zdot(:,:), zf(:,:), zweight(:), zpoints(:,:,:)
949 integer :: sp, block_size, size
978 option__testbatchops__ops_axpy + &
979 option__testbatchops__ops_scal + &
980 option__testbatchops__ops_nrm2 + &
981 option__testbatchops__ops_dotp_matrix + &
982 option__testbatchops__ops_dotp_self + &
983 option__testbatchops__ops_dotp_vector + &
984 option__testbatchops__ops_ax_function_py + &
985 option__testbatchops__ops_get_points
996 sys =>
electrons_t(namespace, generate_epot=.false.)
1001 if (sys%st%pack_states)
call sys%st%pack()
1003 if (
bitand(ops, option__testbatchops__ops_axpy) /= 0)
then
1004 message(1) =
'Info: Testing axpy'
1007 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1008 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1010 do itime = 1, param%repetitions
1011 call batch_axpy(sys%gr%np, 0.1_real64, xx, yy)
1019 if (
bitand(ops, option__testbatchops__ops_scal) /= 0)
then
1020 message(1) =
'Info: Testing scal'
1023 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1024 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1026 do itime = 1, param%repetitions
1035 if (
bitand(ops, option__testbatchops__ops_nrm2) /= 0)
then
1036 message(1) =
'Info: Testing nrm2'
1039 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1040 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1042 safe_allocate(tmp(1:xx%nst))
1044 do itime = 1, param%repetitions
1047 do itime = 1, xx%nst
1048 write(
message(1),
'(a,i1,3x,e23.16)')
"Nrm2 norm state ", itime, tmp(itime)
1052 safe_deallocate_a(tmp)
1058 if (
bitand(ops, option__testbatchops__ops_dotp_matrix) /= 0)
then
1060 message(1) =
'Info: Testing dotp_matrix'
1063 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1064 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1066 nst = sys%st%group%psib(1, 1)%nst
1069 safe_allocate(ddot(1:nst, 1:nst))
1070 do itime = 1, param%repetitions
1076 write(
message(jst),
'(a,2i3,3x,e23.16)')
'Dotp_matrix states', ist, jst, ddot(ist,jst)
1080 safe_deallocate_a(ddot)
1082 safe_allocate(zdot(1:nst, 1:nst))
1083 do itime = 1, param%repetitions
1089 write(
message(jst),
'(a,2i3,3x,2(e23.16,1x))')
'Dotp_matrix states', ist, jst, zdot(ist,jst)
1093 safe_deallocate_a(zdot)
1100 if (
bitand(ops, option__testbatchops__ops_dotp_vector) /= 0)
then
1102 message(1) =
'Info: Testing dotp_vector'
1105 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1106 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1108 nst = sys%st%group%psib(1, 1)%nst
1111 safe_allocate(ddotv(1:nst))
1112 do itime = 1, param%repetitions
1117 write(
message(ist),
'(a,i3,3x,e23.16)')
'Dotp_vector state', ist, ddotv(ist)
1120 safe_deallocate_a(ddotv)
1122 safe_allocate(zdotv(1:nst))
1123 do itime = 1, param%repetitions
1128 write(
message(ist),
'(a,i3,3x,2(e23.16,1x))')
'Dotp_vector state', ist, zdotv(ist)
1131 safe_deallocate_a(zdotv)
1138 if (
bitand(ops, option__testbatchops__ops_dotp_self) /= 0)
then
1140 message(1) =
'Info: Testing dotp_self'
1143 call sys%st%group%psib(1, 1)%copy_to(xx, copy_data = .
true.)
1145 nst = sys%st%group%psib(1, 1)%nst
1148 safe_allocate(ddot(1:nst, 1:nst))
1149 do itime = 1, param%repetitions
1155 write(
message(jst),
'(a,2i3,3x,e23.16)')
'Dotp_self states', ist, jst, ddot(ist,jst)
1159 safe_deallocate_a(ddot)
1161 safe_allocate(zdot(1:nst, 1:nst))
1162 do itime = 1, param%repetitions
1168 write(
message(jst),
'(a,2i3,3x,2(e23.16,1x))')
'Dotp_self states', ist, jst, zdot(ist,jst)
1172 safe_deallocate_a(zdot)
1178 if (
bitand(ops, option__testbatchops__ops_ax_function_py) /= 0)
then
1179 message(1) =
'Info: Testing ax_function_py'
1182 call sys%st%group%psib(1, 1)%copy_to(yy, copy_data = .
true.)
1185 safe_allocate(df(sys%gr%np, sys%st%d%dim))
1186 safe_allocate(dweight(1:sys%st%group%psib(1, 1)%nst_linear))
1187 dweight = 0.1_real64
1190 do itime = 1, param%repetitions
1193 safe_deallocate_a(df)
1194 safe_deallocate_a(dweight)
1196 safe_allocate(zf(sys%gr%np, sys%st%d%dim))
1197 safe_allocate(zweight(1:sys%st%group%psib(1, 1)%nst_linear))
1198 zweight = cmplx(0.1_real64,
m_zero, real64)
1201 do itime = 1, param%repetitions
1204 safe_deallocate_a(zf)
1211 if (
bitand(ops, option__testbatchops__ops_get_points) /= 0)
then
1216 call sys%st%group%psib(1, 1)%copy_to(yy)
1222 safe_allocate(dpoints(1:sys%st%nst, 1:sys%st%d%dim, 1:block_size))
1224 do itime = 1, param%repetitions
1225 do sp = 1, sys%gr%np, block_size
1226 size = min(block_size, sys%gr%np - sp + 1)
1231 safe_deallocate_a(dpoints)
1237 safe_allocate(zpoints(1:sys%st%nst, 1:sys%st%d%dim, 1:block_size))
1239 do itime = 1, param%repetitions
1240 do sp = 1, sys%gr%np, block_size
1241 size = min(block_size, sys%gr%np - sp + 1)
1246 safe_deallocate_a(dpoints)
1257 safe_deallocate_p(sys)
1271 sys =>
electrons_t(namespace, generate_epot=.false.)
1272 call sys%init_parallelization(
mpi_world)
1274 message(1) =
'Info: Testing the finite-differences derivatives.'
1278 if (param%type == option__testtype__all .or. param%type == option__testtype__real)
then
1279 call dderivatives_test(sys%gr%der, sys%namespace, param%repetitions, param%min_blocksize, param%max_blocksize)
1282 if (param%type == option__testtype__all .or. param%type == option__testtype__complex)
then
1283 call zderivatives_test(sys%gr%der, sys%namespace, param%repetitions, param%min_blocksize, param%max_blocksize)
1286 safe_deallocate_p(sys)
1305 sys =>
electrons_t(namespace, generate_epot=.false.)
1306 call sys%init_parallelization(
mpi_world)
1308 message(1) =
'Info: Testing orthogonalization.'
1312 if (param%type == option__testtype__all .or. param%type == option__testtype__real)
then
1313 message(1) =
'Info: Real wave-functions.'
1315 do itime = 1, param%repetitions
1320 if (param%type == option__testtype__all .or. param%type == option__testtype__complex)
then
1321 message(1) =
'Info: Complex wave-functions.'
1323 do itime = 1, param%repetitions
1328 safe_deallocate_p(sys)
1343 sys =>
electrons_t(namespace, generate_epot=.false.)
1344 call sys%init_parallelization(
mpi_world)
1346 if (param%type == option__testtype__all .or. param%type == option__testtype__real)
then
1355 if (param%type == option__testtype__all .or. param%type == option__testtype__complex)
then
1357 call messages_write(
'Info: Testing complex interpolation routines')
1365 safe_deallocate_p(sys)
1380 sys =>
electrons_t(namespace, generate_epot=.false.)
1381 call sys%init_parallelization(
mpi_world)
1383 call ion_interaction_test(sys%space, sys%ions%latt, sys%ions%atom, sys%ions%natoms, sys%ions%pos, &
1384 sys%gr%box%bounding_box_l, namespace, sys%mc)
1386 safe_deallocate_p(sys)
1395 type(
grid_t),
intent(in) :: gr
1396 class(
batch_t),
intent(inout) :: psib
1397 character(*),
optional,
intent(in) :: string
1400 complex(real64),
allocatable :: zpsi(:, :)
1401 real(real64),
allocatable :: dpsi(:, :)
1403 character(80) :: string_
1410 safe_allocate(dpsi(1:gr%np, 1:st%d%dim))
1412 safe_allocate(zpsi(1:gr%np, 1:st%d%dim))
1415 do itime = 1, psib%nst
1418 write(
message(1),
'(a,i2,3x,e23.16)')
"Norm state "//trim(string_)//
" ", itime,
dmf_nrm2(gr, st%d%dim, dpsi)
1421 write(
message(1),
'(a,i2,3x,e23.16)')
"Norm state "//trim(string_)//
" ", itime,
zmf_nrm2(gr, st%d%dim, zpsi)
1427 safe_deallocate_a(dpsi)
1429 safe_deallocate_a(zpsi)
1445 write(
message(1),
'(a)')
" Operation Counter Time Global step"
1460 call clock%set(
clock_t(time_step=
m_four, initial_iteration=1))
1464 write(
message(1),
'(a)')
" Clock comparisons:"
1467 other_clock =
clock_t(time_step=
m_one, initial_iteration=5)
1479 character(len=*),
intent(in) :: operation
1481 write(
message(1),
'(a17,1x,i6,1x,f10.1,1x,i16)') operation, clock%counter(), clock%value(), clock%global_step()
1486 character(len=*),
intent(in) :: condition
1487 logical,
intent(in) :: result
1489 write(
message(1),
'(a10," = ",i1," (",l1,")")') condition, abs(transfer(result, 0)), result
1506 message(1) =
"cgal_polyhedron_point_inside"
1518 integer :: N, ii, jj, N_list(4), i_N
1519 real(real64),
allocatable :: matrix(:, :), eigenvectors(:, :), eigenvalues(:), test(:)
1520 real(real64),
allocatable :: differences(:)
1524 n_list = [15, 32, 100, 500]
1528 safe_allocate(matrix(1:n, 1:n))
1529 safe_allocate(eigenvectors(1:n, 1:n))
1530 safe_allocate(eigenvalues(1:n))
1531 safe_allocate(test(1:n))
1532 safe_allocate(differences(1:n))
1538 matrix(ii, jj) = ii * jj
1543 eigenvectors(1:n, 1:n) = matrix(1:n, 1:n)
1547 test(:) = matmul(matrix, eigenvectors(:, ii)) - eigenvalues(ii) * eigenvectors(:, ii)
1548 differences(ii) = sum(abs(test)) / sum(abs(eigenvectors(:, ii)))
1550 write(
message(1),
"(A, I3, A, E13.6)")
"Parallel solver - N: ", n, &
1551 ", average difference: ", sum(differences)/n
1555 eigenvectors(1:n, 1:n) = matrix(1:n, 1:n)
1559 test(:) = matmul(matrix, eigenvectors(:, ii)) - eigenvalues(ii) * eigenvectors(:, ii)
1560 differences(ii) = sum(abs(test)) / sum(abs(eigenvectors(:, ii)))
1562 write(
message(1),
"(A, I3, A, E13.6)")
"Serial solver - N: ", n, &
1563 ", average difference: ", sum(differences)/n
1566 safe_deallocate_a(matrix)
1567 safe_deallocate_a(eigenvectors)
1568 safe_deallocate_a(eigenvalues)
1569 safe_deallocate_a(test)
1570 safe_deallocate_a(differences)
1577 class(
batch_t),
intent(inout) :: psib
1580 real(real64),
allocatable :: dff(:)
1581 complex(real64),
allocatable :: zff(:)
1583 real(real64) :: da, db, dc
1584 complex(real64) :: za, zb, zc
1589 da =
m_one/mesh%box%bounding_box_l(1)
1595 za = da +
m_zi*0.01_real64
1596 zb = db*
exp(
m_zi*0.345_real64)
1597 zc = dc -
m_zi*50.0_real64
1599 safe_allocate(zff(1:mesh%np))
1600 do ist = 1, psib%nst_linear
1604 zff(ip) = zb*
exp(-za*sum(mesh%x(ip, :)**2)) + zc
1609 safe_deallocate_a(zff)
1611 safe_allocate(dff(1:mesh%np))
1612 do ist = 1, psib%nst_linear
1616 dff(ip) = db*
exp(-da*sum(mesh%x(ip, :)**2)) + dc
1621 safe_deallocate_a(dff)
1635 call sys%init_parallelization(
mpi_world)
1638 sys%gr%stencil, sys%mc, nlevels=3)
1644 safe_deallocate_p(sys)
1660 write(
message(1),*)
'hash[1] :', found,
value
1664 write(
message(1),*)
'hash[2] :', found,
value
1668 write(
message(1),*)
'hash[3] :', found,
value
1680 integer ::
value, sum
1689 write(
message(1),*)
'hash["one"]: ', found,
value
1693 write(
message(1),*)
'hash["two"]: ', found,
value
1697 write(
message(1),*)
'hash["three"]: ', found,
value
1704 do while (it%has_next())
1705 value = it%get_next()
1707 write(
message(1),
'(I3,A,I5)') counter,
': hash[...] = ',
value
1709 counter = counter + 1
1711 write(
message(1),*)
'counter = ', counter
1712 write(
message(2),*)
'sum = ', sum
1734 class(*),
pointer :: value
1736 integer :: count_clock, count_space
1738 safe_allocate(clock_2)
1752 write(
message(1),*)
'hash["one"]: ', found,
value%counter()
1755 write(
message(1),*)
'hash["one"]: ', found,
value%short_info()
1758 write(
message(1),*)
'wrong type. found = ', found
1765 write(
message(1),*)
'hash["two"]: ', found,
value%counter()
1768 write(
message(1),*)
'hash["two"]: ', found,
value%short_info()
1771 write(
message(1),*)
'wrong type. found = ',found
1775 safe_deallocate_a(clock_2)
1780 write(
message(1),*)
'hash["three"]: ', found,
value%counter()
1783 write(
message(1),*)
'hash["three"]: ', found,
value%short_info()
1786 write(
message(1),*)
'wrong type. found = ',found
1795 do while (it%has_next())
1796 value => it%get_next()
1799 count_clock = count_clock + 1
1801 count_space = count_space + 1
1805 write(
message(1), *)
'Count_clock = ', count_clock
1806 write(
message(2), *)
'Count_space = ', count_space
1819 real(real64),
allocatable :: ff_A(:), ff_A_reference(:), ff_B(:), ff_B_reference(:), diff_A(:), diff_B(:)
1820 real(real64) :: norm_ff, norm_diff
1829 call sysa%init_parallelization(
mpi_world)
1830 call sysb%init_parallelization(
mpi_world)
1833 safe_allocate(ff_a(1:sysa%gr%np))
1834 safe_allocate(ff_a_reference(1:sysa%gr%np))
1835 safe_allocate(diff_a(1:sysa%gr%np))
1836 safe_allocate(ff_b(1:sysb%gr%np))
1837 safe_allocate(ff_b_reference(1:sysb%gr%np))
1838 safe_allocate(diff_b(1:sysb%gr%np))
1840 do ip = 1, sysa%gr%np
1841 ff_a_reference(ip) =
values(sysa%gr%x(ip, :))
1843 do ip = 1, sysb%gr%np
1844 ff_b_reference(ip) =
values(sysb%gr%x(ip, :))
1848 regridding =>
regridding_t(sysb%gr, sysa%gr, sysa%space, sysa%namespace)
1849 call regridding%do_transfer(ff_b, ff_a_reference)
1850 safe_deallocate_p(regridding)
1853 do ip = 1, sysb%gr%np
1855 ff_b_reference(ip) =
m_zero
1858 diff_b(ip) = abs(ff_b_reference(ip) - ff_b(ip))
1861 norm_ff =
dmf_nrm2(sysb%gr, ff_b_reference)
1862 norm_diff =
dmf_nrm2(sysb%gr, diff_b)
1864 write(
message(1),
'(a, E14.6)')
"Forward: difference of reference to mapped function (rel.): ", &
1869 sysb%gr, ff_b_reference,
unit_one, ierr)
1873 sysa%gr, ff_a_reference,
unit_one, ierr)
1876 regridding =>
regridding_t(sysa%gr, sysb%gr, sysb%space, sysb%namespace)
1877 call regridding%do_transfer(ff_a, ff_b_reference)
1878 safe_deallocate_p(regridding)
1880 do ip = 1, sysa%gr%np
1882 ff_a_reference(ip) =
m_zero
1885 diff_a(ip) = abs(ff_a_reference(ip) - ff_a(ip))
1888 norm_ff =
dmf_nrm2(sysa%gr, ff_a_reference)
1889 norm_diff =
dmf_nrm2(sysa%gr, diff_a)
1891 write(
message(1),
'(a, E14.6)')
"Backward: difference of reference to mapped function (rel.): ", &
1896 sysa%gr, ff_a_reference,
unit_one, ierr)
1900 sysb%gr, ff_b_reference,
unit_one, ierr)
1902 safe_deallocate_a(ff_a)
1903 safe_deallocate_a(ff_a_reference)
1904 safe_deallocate_a(ff_b)
1905 safe_deallocate_a(ff_b_reference)
1906 safe_deallocate_a(diff_a)
1907 safe_deallocate_a(diff_b)
1908 safe_deallocate_p(sysa)
1909 safe_deallocate_p(sysb)
1915 real(real64) function values(xx)
1916 real(real64),
intent(in) :: xx(:)
1917 real(real64) :: xx0(1:size(xx, dim=1))
1918 real(real64),
parameter :: aa =
m_half
1919 real(real64),
parameter :: bb =
m_four
1923 values = bb *
exp(-aa*sum((xx-xx0)**2))
1933 type(namespace_t),
intent(in) :: namespace
1935 class(maxwell_t),
pointer :: maxwell_system
1937 real(real64),
allocatable :: magnetic_field(:,:)
1938 real(real64),
allocatable :: vector_potential_mag(:,:)
1939 real(real64),
allocatable :: vector_potential_analytical(:,:)
1940 real(real64),
allocatable :: delta(:,:)
1941 real(real64) :: exp_factor
1945 real(real64) :: sigma
1946 integer :: ip, j, ierr, nn
1947 integer(int64) :: out_how
1948 character(len=MAX_PATH_LEN) :: fname, fname2, fname3
1951 maxwell_system => maxwell_t(namespace)
1952 sigma = maxwell_system%gr%box%bounding_box_l(1)/10_real64
1953 call maxwell_system%init_parallelization(mpi_world)
1955 safe_allocate(magnetic_field(1:maxwell_system%gr%np_part, 1:3))
1956 safe_allocate(vector_potential_mag(1:maxwell_system%gr%np_part, 1:3))
1957 safe_allocate(vector_potential_analytical(1:maxwell_system%gr%np_part, 1:3))
1958 safe_allocate(delta(1:maxwell_system%gr%np, 1:3))
1971 call parse_variable(namespace,
'TestVectorPotentialType', option__testvectorpotentialtype__bounded, nn)
1974 case (option__testvectorpotentialtype__bounded)
1975 do ip = 1, maxwell_system%gr%np_part
1976 xx = maxwell_system%gr%x(ip, 1)
1977 yy = maxwell_system%gr%x(ip, 2)
1978 zz = maxwell_system%gr%x(ip, 3)
1979 exp_factor =
exp((-xx**2 - yy**2 - zz**2)*1/(2*sigma**2))
1980 magnetic_field(ip, 1) = exp_factor*yy*(1 - (-xx**2 + yy**2)/(3*sigma**2) - zz**2/(3*sigma**2))
1981 magnetic_field(ip, 2) = exp_factor * xx * (1 + (-xx**2 + yy**2)/(3*sigma**2) - zz**2/(3*sigma**2))
1982 magnetic_field(ip, 3) = exp_factor * 2 * xx * yy * zz * 1/(3*sigma**2)
1984 vector_potential_analytical(ip, 1) = m_third * xx * zz * exp_factor
1985 vector_potential_analytical(ip, 2) = - m_third * yy * zz * exp_factor
1986 vector_potential_analytical(ip, 3) = m_third * (-xx**2 + yy**2) * exp_factor
1988 case (option__testvectorpotentialtype__unbounded)
1990 do ip = 1, maxwell_system%gr%np_part
1991 magnetic_field(ip, 1) = maxwell_system%gr%x(ip, 2)
1992 magnetic_field(ip, 2) = maxwell_system%gr%x(ip, 1)
1993 magnetic_field(ip, 3) = m_zero
1995 vector_potential_analytical(ip, 1) = m_third * maxwell_system%gr%x(ip, 1) * maxwell_system%gr%x(ip, 3)
1996 vector_potential_analytical(ip, 2) = - m_third * maxwell_system%gr%x(ip, 2) * maxwell_system%gr%x(ip, 3)
1997 vector_potential_analytical(ip, 3) = - m_third * (maxwell_system%gr%x(ip, 1)**2 - maxwell_system%gr%x(ip, 2)**2)
2000 call maxwell_system%helmholtz%get_vector_potential(namespace, vector_potential_mag, magnetic_field)
2004 do ip = 1, maxwell_system%gr%np
2005 delta(ip,j) = vector_potential_analytical(ip, j) - vector_potential_mag(ip, j)
2010 write(message(j),*)
'j, norm2(delta)', j, norm2(delta(:,j))
2012 call messages_info(3)
2014 write(fname,
'(a)')
'deviation_from_analytical_formulation'
2015 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, maxwell_system%space, maxwell_system%gr, &
2016 delta, unit_one, ierr)
2017 write(fname2,
'(a)')
'vector_potential_analytical'
2018 call io_function_output_vector(out_how ,
'./' , trim(fname2), namespace, maxwell_system%space, maxwell_system%gr, &
2019 vector_potential_analytical, unit_one, ierr)
2020 write(fname3,
'(a)')
'vector_potential_mag'
2021 call io_function_output_vector(out_how ,
'./' , trim(fname3), namespace, maxwell_system%space, maxwell_system%gr, &
2022 vector_potential_mag, unit_one, ierr)
2024 safe_deallocate_a(magnetic_field)
2025 safe_deallocate_a(vector_potential_mag)
2026 safe_deallocate_a(vector_potential_analytical)
2027 safe_deallocate_a(delta)
2028 safe_deallocate_p(maxwell_system)
2034 type(multigrid_t),
intent(in) :: mgrid
2035 class(space_t),
intent(in) :: space
2037 real(real64),
allocatable :: guess0(:), res0(:), guess1(:)
2038 type(mesh_t),
pointer :: mesh0, mesh1
2039 real(real64) :: delta, xx(3,2), alpha, beta, rr
2040 integer :: nn, ip, ierr
2044 message(1) =
'Info: Testing the grid interpolation.'
2046 call messages_info(2)
2048 mesh0 => mgrid%level(0)%mesh
2049 mesh1 => mgrid%level(1)%mesh
2051 safe_allocate(guess0(1:mesh0%np_part))
2052 safe_allocate(res0(1:mesh0%np_part))
2053 safe_allocate(guess1(1:mesh1%np_part))
2055 alpha = m_four*mesh0%spacing(1)
2056 beta = m_one / (alpha**space%dim *
sqrt(m_pi)**space%dim)
2071 call mesh_r(mesh0, ip, rr, origin = xx(:, nn))
2072 guess0(ip) = guess0(ip) + (-1)**nn * beta*
exp(-(rr/alpha)**2)
2076 call dio_function_output (io_function_fill_how(
'AxisX'),
".",
"interpolation_target", global_namespace, &
2077 space, mesh0, guess0, unit_one, ierr)
2078 call dio_function_output (io_function_fill_how(
'AxisZ'),
".",
"interpolation_target", global_namespace, &
2079 space, mesh0, guess0, unit_one, ierr)
2080 call dio_function_output (io_function_fill_how(
'PlaneZ'),
".",
"interpolation_target", global_namespace, &
2081 space, mesh0, guess0, unit_one, ierr)
2088 call dmultigrid_fine2coarse(mgrid%level(1)%tt, mgrid%level(0)%der, mesh1, guess0, guess1, injection)
2090 call dmultigrid_coarse2fine(mgrid%level(1)%tt, mgrid%level(1)%der, mesh0, guess1, res0)
2092 call dio_function_output (io_function_fill_how(
'AxisX'),
".",
"interpolation_result", global_namespace, &
2093 space, mesh0, res0, unit_one, ierr)
2094 call dio_function_output (io_function_fill_how(
'AxisZ'),
".",
"interpolation_result", global_namespace, &
2095 space, mesh0, res0, unit_one, ierr)
2096 call dio_function_output (io_function_fill_how(
'PlaneZ'),
".",
"interpolation_result", global_namespace, &
2097 space, mesh0, res0, unit_one, ierr)
2099 delta = dmf_nrm2(mesh0, guess0(1:mesh0%np)-res0(1:mesh0%np))
2100 write(message(1),
'(a,e13.6)')
'Interpolation test (abs.) = ', delta
2106 call dmultigrid_fine2coarse(mgrid%level(1)%tt, mgrid%level(0)%der, mesh1, guess0, guess1, fullweight)
2108 call dmultigrid_coarse2fine(mgrid%level(1)%tt, mgrid%level(1)%der, mesh0, guess1, res0)
2110 call dio_function_output (io_function_fill_how(
'AxisX'),
".",
"restriction_result", global_namespace, &
2111 space, mesh0, res0, unit_one, ierr)
2112 call dio_function_output (io_function_fill_how(
'AxisZ'),
".",
"restriction_result", global_namespace, &
2113 space, mesh0, res0, unit_one, ierr)
2114 call dio_function_output (io_function_fill_how(
'PlaneZ'),
".",
"restriction_result", global_namespace, &
2115 space, mesh0, res0, unit_one, ierr)
2117 delta = dmf_nrm2(mesh0, guess0(1:mesh0%np)-res0(1:mesh0%np))
2118 write(message(2),
'(a,e13.6)')
'Restriction test (abs.) = ', delta
2119 call messages_info(2)
2121 safe_deallocate_a(guess0)
2122 safe_deallocate_a(res0)
2123 safe_deallocate_a(guess1)
2131 type(namespace_t),
intent(in) :: namespace
2132 type(electrons_t),
pointer :: sys
2134 type(current_t) :: current
2135 character(len=MAX_PATH_LEN) :: fname
2136 integer :: ierr, ip, idir
2137 integer(int64) :: out_how
2138 real(real64),
allocatable :: current_para_ref(:,:), current_dia_ref(:,:), current_mag_ref(:,:), delta(:)
2139 real(real64) :: xx(3), rr, a0, mag_curr, sin_thet, sin_phi, cos_phi, vec_pot_slope
2140 complex(real64) :: alpha
2142 sys => electrons_t(namespace, generate_epot=.false.)
2143 call sys%init_parallelization(mpi_world)
2145 alpha = (0.0_real64, 0.5_real64)
2147 vec_pot_slope = 0.4_real64
2149 call states_elec_allocate_wfns(sys%st, sys%gr, wfs_type = type_cmplx)
2152 call current_init(current, namespace)
2154 call hamiltonian_elec_epot_generate(sys%hm, sys%namespace, sys%space, sys%gr, sys%ions, sys%ext_partners, sys%st)
2156 safe_allocate(sys%hm%hm_base%vector_potential(1:3, 1:sys%gr%np))
2158 sys%hm%hm_base%vector_potential = m_zero
2159 do ip = 1, sys%gr%np
2160 xx = sys%gr%x(ip, 1:3)
2161 sys%hm%hm_base%vector_potential(2, ip) = vec_pot_slope * xx(1) / p_c
2164 call states_elec_allocate_current(sys%st, sys%space, sys%gr)
2165 call density_calc(sys%st, sys%gr, sys%st%rho)
2167 call current_calculate(current, namespace, sys%gr, sys%hm, sys%space, sys%st)
2169 safe_allocate(current_para_ref(1:sys%gr%np,1:3))
2170 safe_allocate(current_dia_ref(1:sys%gr%np,1:3))
2171 safe_allocate(current_mag_ref(1:sys%gr%np,1:3))
2172 safe_allocate(delta(1:sys%gr%np))
2175 current_para_ref(:,:) = m_zero
2176 do ip = 1, sys%gr%np
2177 call mesh_r(sys%gr, ip, rr)
2178 xx = sys%gr%x(ip, 1:3)
2179 if (rr > r_small)
then
2181 psi_1s(rr, a0) *
dr_psi_2s(rr, a0) ) * aimag(alpha) / (1 + abs(alpha)**2) * xx(1:3) / rr
2185 write(fname,
'(a)')
'current_para'
2186 out_how = io_function_fill_how(
"PlaneZ")
2187 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2188 sys%st%current_para(:,:,1), unit_one, ierr)
2190 write(fname,
'(a)')
'current_para-ref'
2191 out_how = io_function_fill_how(
"PlaneZ")
2192 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2193 current_para_ref(:,:), unit_one, ierr)
2197 delta(:) = current_para_ref(1:sys%gr%np, idir) - sys%st%current_para(1:sys%gr%np, idir, 1)
2198 write(message(idir),*)
'idir =',idir,
', norm2(delta paramagnetic)',norm2(delta)
2200 call messages_info(3)
2203 current_dia_ref(:,:) = m_zero
2204 do ip = 1, sys%gr%np
2205 call mesh_r(sys%gr, ip, rr)
2206 current_dia_ref(ip,1:3) = - sys%hm%hm_base%vector_potential(1:3,ip) *&
2210 write(fname,
'(a)')
'current_dia'
2211 out_how = io_function_fill_how(
"PlaneZ")
2212 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2213 sys%st%current_dia(:,:,1), unit_one, ierr)
2215 write(fname,
'(a)')
'current_dia-ref'
2216 out_how = io_function_fill_how(
"PlaneZ")
2217 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2218 current_dia_ref(:,:), unit_one, ierr)
2222 delta(:) = current_dia_ref(1:sys%gr%np, idir) - sys%st%current_dia(1:sys%gr%np, idir, 1)
2223 write(message(idir),*)
'idir =',idir,
', norm2(delta diamagnetic)',norm2(delta)
2225 call messages_info(3)
2228 call current_calculate_mag(sys%gr%der, sys%st)
2231 current_mag_ref(:,:) = m_zero
2232 do ip = 1, sys%gr%np
2233 call mesh_r(sys%gr, ip, rr)
2234 xx = sys%gr%x(ip, 1:3)
2235 if (norm2(xx(1:2)) > r_small .and. rr > r_small)
then
2236 sin_thet = norm2(xx(1:2)) / rr
2237 sin_phi = xx(2) / norm2(xx(1:2))
2238 cos_phi = xx(1) / norm2(xx(1:2))
2242 current_mag_ref(ip,1) = m_half * mag_curr * sin_thet * sin_phi / (1+abs(alpha)**2)
2243 current_mag_ref(ip,2) = -m_half * mag_curr * sin_thet * cos_phi / (1+abs(alpha)**2)
2247 write(fname,
'(a)')
'current_mag'
2248 out_how = io_function_fill_how(
"PlaneZ")
2249 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2250 sys%st%current_mag(:,:,1), unit_one, ierr)
2252 write(fname,
'(a)')
'current_mag-ref'
2253 out_how = io_function_fill_how(
"PlaneZ")
2254 call io_function_output_vector(out_how ,
'./' , trim(fname), namespace, sys%space, sys%gr, &
2255 current_mag_ref(:,:), unit_one, ierr)
2259 delta(:) = current_mag_ref(1:sys%gr%np, idir) - sys%st%current_mag(1:sys%gr%np, idir, 1)
2260 write(message(idir),*)
'idir =',idir,
', norm2(delta magnetization)',norm2(delta)
2262 call messages_info(3)
2264 safe_deallocate_a(current_para_ref)
2265 safe_deallocate_a(current_dia_ref)
2266 safe_deallocate_a(current_mag_ref)
2267 safe_deallocate_a(delta)
2268 safe_deallocate_p(sys)
2274 class(batch_t),
intent(inout) :: psib
2275 class(mesh_t),
intent(in) :: mesh
2276 type(namespace_t),
intent(in) :: namespace
2277 complex(real64),
intent(in) :: alpha
2278 real(real64),
intent(in) :: a0
2280 complex(real64),
allocatable :: zff(:)
2287 safe_allocate(zff(1:mesh%np))
2288 if (type_is_complex(psib%type()))
then
2290 call mesh_r(mesh, ip, rr)
2292 call batch_set_state(psib, 1, mesh%np, zff)
2294 safe_deallocate_a(zff)
2296 write(message(1),*)
"States should be complex for the linear combination of hydrogenic states to work"
2297 call messages_info(1, namespace=namespace)
2304 real(real64),
intent(in) :: a0, rr
2305 complex(real64),
intent(in) :: alpha
2311 real(real64) function psi_1s(rr, a0)
2312 real(real64),
intent(in) :: a0, rr
2318 real(real64) function psi_2s(rr, a0)
2319 real(real64),
intent(in) :: a0, rr
2321 psi_2s =
sqrt(m_two) * a0**(-m_three/m_two) * (m_one - rr/(m_two * a0)) *
exp(-rr/(m_two * a0)) &
2322 / (m_two *
sqrt(m_pi))
2325 real(real64) function dr_psi_1s(rr, a0)
2326 real(real64),
intent(in) :: a0, rr
2331 real(real64) function dr_psi_2s(rr, a0)
2332 real(real64),
intent(in) :: a0, rr
2335 a0**(-m_five/m_two) *
exp(-rr/(m_two * a0)) / (
sqrt(m_two) * m_two *
sqrt(m_pi))
2342 type(namespace_t),
intent(in) :: namespace
2345 integer(int64) :: i, j, k
2346 integer(int64) :: dims(3)
2347 character(len=MAX_PATH_LEN) :: fname
2349 real(real64),
allocatable :: ff(:)
2359 call parse_variable(namespace,
'TestCSVFileName',
"", fname)
2361 message(1) =
"Attempting to probe "//trim(fname)
2362 call messages_info(1, namespace=namespace)
2364 call io_csv_get_info(fname, dims, ierr)
2366 message(1) =
"Probing successful."
2367 write(message(2),
'("found dimensions: ",3I20)') dims
2368 call messages_info(2, namespace=namespace)
2370 write(message(1),
'("Probing failed. ierr = ",I5)') ierr
2371 call messages_fatal(1, namespace=namespace)
2374 safe_allocate(ff(1:dims(1)*dims(2)*dims(3)))
2376 message(1) =
"Attempting to read "//trim(fname)
2377 call messages_info(1, namespace=namespace)
2379 call dread_csv(fname, dims(1)*dims(2)*dims(3), ff, ierr)
2381 message(1) =
"Reading successful."
2382 call messages_info(1, namespace=namespace)
2384 do k=1, min(4_int64, dims(3))
2385 do j=1, min(4_int64, dims(2))
2386 write(message(j),
'("data ",2I5, 1X, 4F8.2)') k, j, &
2387 (ff(i + dims(1)*(j-1) + dims(1)* dims(2)*(k-1)), i=1, min(4_int64, dims(1)))
2389 write(message(int(j, int32)),
'("")')
2390 call messages_info(int(j, int32), namespace=namespace)
2394 message(1) =
"Reading failed."
2395 call messages_fatal(1, namespace=namespace)
2398 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.
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)