23 use,
intrinsic :: iso_fortran_env
51 integer,
parameter :: SERIAL = 1
52 integer,
parameter :: WORLD = 2
53 integer,
parameter :: DOMAIN = 3
54 integer,
parameter :: N_CNF = 3
60 real(real64),
allocatable :: kernel(:, :, :)
61 integer :: nfft1, nfft2, nfft3
62 type(mpi_grp_t) :: mpi_grp
68 type(MPI_Comm) :: all_nodes_comm
69 type(isf_cnf_t) :: cnf(1:N_CNF)
72 integer,
parameter :: order_scaling_function = 8
78 subroutine poisson_isf_init(this, namespace, mesh, cube, all_nodes_comm, init_world)
79 type(poisson_isf_t),
intent(out) :: this
80 type(namespace_t),
target,
intent(in) :: namespace
81 type(mesh_t),
intent(in) :: mesh
82 type(cube_t),
intent(inout) :: cube
83 type(MPI_Comm),
intent(in) :: all_nodes_comm
84 logical,
optional,
intent(in) :: init_world
88 integer :: m1, m2, m3, md1, md2, md3
90 logical :: init_world_
91 integer :: default_nodes
93 integer,
allocatable :: ranks(:)
99 type(MPI_Group) :: world_grp, poisson_grp
105 if (
present(init_world)) init_world_ = init_world
107 if (.not. mesh%parallel_in_domains)
then
112 n1 = this%cnf(
serial)%nfft1/2 + 1
113 n2 = this%cnf(
serial)%nfft2/2 + 1
114 n3 = this%cnf(
serial)%nfft3/2 + 1
116 safe_allocate(this%cnf(
serial)%kernel(1:n1, 1:n2, 1:n3))
118 call build_kernel(cube%rs_n_global(1), cube%rs_n_global(2), cube%rs_n_global(3), &
120 real(cube%spacing(1), real64), order_scaling_function, this%cnf(SERIAL)%kernel)
123#if !defined(HAVE_MPI)
146 call parse_variable(namespace,
'PoissonSolverNodes', default_nodes, nodes)
148 this%all_nodes_comm = all_nodes_comm
151 call mpi_comm_size(all_nodes_comm, world_size)
154 if (nodes <= 0 .or. nodes > world_size) nodes = world_size
155 this%cnf(
world)%all_nodes = (nodes == world_size)
157 safe_allocate(ranks(1:nodes))
168 call mpi_comm_group(all_nodes_comm, world_grp, ierr)
169 call mpi_group_incl(world_grp, nodes, ranks, poisson_grp, ierr)
170 call mpi_comm_create(all_nodes_comm, poisson_grp, this%cnf(
world)%mpi_grp%comm, ierr)
173 safe_deallocate_a(ranks)
177 if (this%cnf(
world)%mpi_grp%comm /= mpi_comm_null)
then
178 call mpi_comm_rank(this%cnf(
world)%mpi_grp%comm, this%cnf(
world)%mpi_grp%rank, ierr)
179 call mpi_comm_size(this%cnf(
world)%mpi_grp%comm, this%cnf(
world)%mpi_grp%size, ierr)
181 this%cnf(
world)%mpi_grp%rank = -1
182 this%cnf(
world)%mpi_grp%size = -1
190 if ((i_cnf ==
world .and. .not. init_world_) &
191 .or. (i_cnf ==
domain .and. .not. mesh%parallel_in_domains) &
195 if (this%cnf(i_cnf)%mpi_grp%rank /= -1 .or. i_cnf /=
world)
then
197 m1, m2, m3, n1, n2, n3, md1, md2, md3, this%cnf(i_cnf)%nfft1, this%cnf(i_cnf)%nfft2, &
198 this%cnf(i_cnf)%nfft3, this%cnf(i_cnf)%mpi_grp%size)
201 n(1) = this%cnf(i_cnf)%nfft1
202 n(2) = this%cnf(i_cnf)%nfft2
203 n(3) = this%cnf(i_cnf)%nfft3
205 safe_allocate(this%cnf(i_cnf)%kernel(1:n(1), 1:n(2), 1:n(3)/this%cnf(i_cnf)%mpi_grp%size))
207 call par_build_kernel(cube%rs_n_global(1), cube%rs_n_global(2), cube%rs_n_global(3), n1, n2, n3, &
208 this%cnf(i_cnf)%nfft1, this%cnf(i_cnf)%nfft2, this%cnf(i_cnf)%nfft3, &
209 cube%spacing(1), order_scaling_function, &
210 this%cnf(i_cnf)%mpi_grp%rank, this%cnf(i_cnf)%mpi_grp%size, this%cnf(i_cnf)%mpi_grp%comm, &
211 this%cnf(i_cnf)%kernel)
223 type(mesh_t),
intent(in) :: mesh
224 type(cube_t),
intent(in) :: cube
225 real(real64),
contiguous,
intent(out) :: pot(:)
226 real(real64),
contiguous,
intent(in) :: rho(:)
227 logical,
intent(in) :: all_nodes
228 type(submesh_t),
optional,
intent(in) :: sm
230 integer :: i_cnf, nn(1:3)
231 type(cube_function_t) :: rho_cf
233 integer(int64) :: number_points
238 call dcube_function_alloc_rs(cube, rho_cf)
240 if (
present(sm))
then
241 call dsubmesh_to_cube(sm, rho, cube, rho_cf)
243 call dmesh_to_cube(mesh, rho, cube, rho_cf)
252 else if (mesh%parallel_in_domains)
then
257#if !defined(HAVE_MPI)
263 nn(1) = this%cnf(
serial)%nfft1
264 nn(2) = this%cnf(
serial)%nfft2
265 nn(3) = this%cnf(
serial)%nfft3
266 call psolver_kernel(cube%rs_n_global(1), cube%rs_n_global(2), cube%rs_n_global(3), &
267 nn(1), nn(2), nn(3), &
268 real(mesh%spacing(1), real64), this%cnf(
serial)%kernel, rho_cf%drs)
271 nn(1) = this%cnf(i_cnf)%nfft1
272 nn(2) = this%cnf(i_cnf)%nfft2
273 nn(3) = this%cnf(i_cnf)%nfft3
274 if (this%cnf(i_cnf)%mpi_grp%size /= -1 .or. i_cnf /=
world)
then
275 call par_psolver_kernel(cube%rs_n_global(1), cube%rs_n_global(2), cube%rs_n_global(3), &
276 nn(1), nn(2), nn(3), &
277 real(mesh%spacing(1), real64), this%cnf(i_cnf)%kernel, rho_cf%drs, &
278 this%cnf(i_cnf)%mpi_grp%rank, this%cnf(i_cnf)%mpi_grp%size, this%cnf(i_cnf)%mpi_grp%comm)
282 if (i_cnf ==
world .and. .not. this%cnf(
world)%all_nodes)
then
285 number_points = cube%rs_n_global(1) * cube%rs_n_global(2)
286 number_points = number_points * cube%rs_n_global(3)
287 if (number_points >= huge(0))
then
288 message(1) =
"Error: too many points for the normal cube. Please try to use a distributed FFT."
289 call messages_fatal(1)
291 call mpi_bcast(rho_cf%drs(1, 1, 1, 1), cube%rs_n_global(1)*cube%rs_n_global(2)*cube%rs_n_global(3), &
292 mpi_double_precision, 0, this%all_nodes_comm)
297 if (
present(sm))
then
298 call dcube_to_submesh(cube, rho_cf, sm, pot)
300 call dcube_to_mesh(cube, rho_cf, mesh, pot)
303 call dcube_function_free_rs(cube, rho_cf)
320 safe_deallocate_a(this%cnf(i_cnf)%kernel)
322 if (this%cnf(
world)%mpi_grp%comm /= mpi_comm_null)
then
323 call mpi_comm_free(this%cnf(
world)%mpi_grp%comm)
326 safe_deallocate_a(this%cnf(
serial)%kernel)
378 subroutine psolver_kernel(n01, n02, n03, nfft1, nfft2, nfft3, hgrid, karray, rhopot)
379 integer,
intent(in) :: n01
380 integer,
intent(in) :: n02
381 integer,
intent(in) :: n03
382 integer,
intent(in) :: nfft1
383 integer,
intent(in) :: nfft2
384 integer,
intent(in) :: nfft3
385 real(real64),
intent(in) :: hgrid
386 real(real64),
intent(in) :: karray(nfft1/2 + 1,nfft2/2 + 1, nfft3/2 + 1)
387 real(real64),
intent(inout) :: rhopot(n01, n02, n03)
389 real(real64),
allocatable :: zarray(:,:,:)
390 real(real64) :: factor
391 integer :: n1, n2, n3, nd1, nd2, nd3, n1h, nd1h
392 integer :: inzee, i_sign
401 nd1 = n1 + modulo(n1+1,2)
402 nd2 = n2 + modulo(n2+1,2)
403 nd3 = n3 + modulo(n3+1,2)
406 safe_allocate(zarray(1:2, 1:nd1h*nd2*nd3, 1:2))
408 zarray(:, :, 2) = m_zero
411 call zarray_in(n01,n02,n03,nd1h,nd2,nd3,rhopot,zarray)
417 call fft(n1h,n2,n3,nd1h,nd2,nd3,zarray,i_sign,inzee)
420 call kernel_application(n1,n2,n3,nd1h,nd2,nd3,nfft1,nfft2,nfft3,zarray,karray,inzee)
425 call fft(n1h,n2,n3,nd1h,nd2,nd3,zarray,i_sign,inzee)
429 factor = hgrid**3/(real(n1*n2, real64)*real(n3, real64))
432 call zarray_out(n01, n02, n03, nd1h, nd2, nd3, rhopot, zarray(1, 1, inzee), factor)
434 safe_deallocate_a(zarray)
465 subroutine kernel_application(n1,n2,n3,nd1h,nd2,nd3,nfft1,nfft2,nfft3,zarray,karray,inzee)
466 integer,
intent(in) :: n1,n2,n3,nd1h,nd2,nd3,nfft1,nfft2,nfft3,inzee
467 real(real64),
intent(in) :: karray(1:nfft1/2 + 1, 1:nfft2/2 + 1, 1:nfft3/2 + 1)
468 real(real64),
intent(inout) :: zarray(1:2, 1:nd1h, 1:nd2, 1:nd3, 1:2)
470 real(real64),
dimension(:),
allocatable :: cos_array,sin_array
471 real(real64) :: a,b,c,d,pi2,g1,cp,sp
472 real(real64) :: rfe,ife,rfo,ifo,rk,ik,rk2,ik2,re,ro,ie,io,rhk,ihk
473 integer :: i1,i2,i3,j1,j2,j3, ouzee,n1h,n2h,n3h
474 integer :: si1,si2,si3
482 safe_allocate(cos_array(1:n1h + 1))
483 safe_allocate(sin_array(1:n1h + 1))
485 pi2 = 8._real64*datan(1._real64)
486 pi2 = pi2/real(n1, real64)
488 cos_array(i1) = dcos(pi2*(i1-1))
489 sin_array(i1) = -dsin(pi2*(i1-1))
511 a = zarray(1,i1,i2,i3,inzee)
512 b = zarray(2,i1,i2,i3,inzee)
513 c = zarray(1,si1,si2,si3,inzee)
514 d = zarray(2,si1,si2,si3,inzee)
515 rfe = .5_real64*(a+c)
516 ife = .5_real64*(b-d)
517 rfo = .5_real64*(a-c)
518 ifo = .5_real64*(b+d)
521 rk = rfe+cp*ifo-sp*rfo
522 ik = ife-cp*rfo-sp*ifo
523 g1 = karray(i1,j2,j3)
527 zarray(1,1,i2,i3,ouzee) = rk2
528 zarray(2,1,i2,i3,ouzee) = ik2
534 a=zarray(1,i1,i2,i3,inzee)
535 b=zarray(2,i1,i2,i3,inzee)
536 c=zarray(1,si1,si2,si3,inzee)
537 d=zarray(2,si1,si2,si3,inzee)
550 zarray(1,i1,i2,i3,ouzee) = rk2
551 zarray(2,i1,i2,i3,ouzee) = ik2
558 a=zarray(1,1,i2,i3,inzee)
559 b=zarray(2,1,i2,i3,inzee)
560 c=zarray(1,si1,si2,si3,inzee)
561 d=zarray(2,si1,si2,si3,inzee)
574 zarray(1,i1,i2,i3,ouzee) = rk2
575 zarray(2,i1,i2,i3,ouzee) = ik2
580 j2=n2h+1-abs(n2h+1-i2)
586 a=zarray(1,i1,i2,i3,inzee)
587 b=zarray(2,i1,i2,i3,inzee)
588 c=zarray(1,si1,si2,si3,inzee)
589 d=zarray(2,si1,si2,si3,inzee)
602 zarray(1,1,i2,i3,ouzee) = rk2
603 zarray(2,1,i2,i3,ouzee) = ik2
609 a=zarray(1,i1,i2,i3,inzee)
610 b=zarray(2,i1,i2,i3,inzee)
611 c=zarray(1,si1,si2,si3,inzee)
612 d=zarray(2,si1,si2,si3,inzee)
625 zarray(1,i1,i2,i3,ouzee) = rk2
626 zarray(2,i1,i2,i3,ouzee) = ik2
633 a=zarray(1,1,i2,i3,inzee)
634 b=zarray(2,1,i2,i3,inzee)
635 c=zarray(1,si1,si2,si3,inzee)
636 d=zarray(2,si1,si2,si3,inzee)
649 zarray(1,i1,i2,i3,ouzee) = rk2
650 zarray(2,i1,i2,i3,ouzee) = ik2
656 j3=n3h+1-abs(n3h+1-i3)
667 a=zarray(1,i1,i2,i3,inzee)
668 b=zarray(2,i1,i2,i3,inzee)
669 c=zarray(1,si1,si2,si3,inzee)
670 d=zarray(2,si1,si2,si3,inzee)
683 zarray(1,1,i2,i3,ouzee) = rk2
684 zarray(2,1,i2,i3,ouzee) = ik2
690 a=zarray(1,i1,i2,i3,inzee)
691 b=zarray(2,i1,i2,i3,inzee)
692 c=zarray(1,si1,si2,si3,inzee)
693 d=zarray(2,si1,si2,si3,inzee)
706 zarray(1,i1,i2,i3,ouzee) = rk2
707 zarray(2,i1,i2,i3,ouzee) = ik2
714 a=zarray(1,1,i2,i3,inzee)
715 b=zarray(2,1,i2,i3,inzee)
716 c=zarray(1,si1,si2,si3,inzee)
717 d=zarray(2,si1,si2,si3,inzee)
730 zarray(1,i1,i2,i3,ouzee) = rk2
731 zarray(2,i1,i2,i3,ouzee) = ik2
736 j2=n2h+1-abs(n2h+1-i2)
742 a=zarray(1,i1,i2,i3,inzee)
743 b=zarray(2,i1,i2,i3,inzee)
744 c=zarray(1,si1,si2,si3,inzee)
745 d=zarray(2,si1,si2,si3,inzee)
758 zarray(1,1,i2,i3,ouzee) = rk2
759 zarray(2,1,i2,i3,ouzee) = ik2
765 a=zarray(1,i1,i2,i3,inzee)
766 b=zarray(2,i1,i2,i3,inzee)
767 c=zarray(1,si1,si2,si3,inzee)
768 d=zarray(2,si1,si2,si3,inzee)
781 zarray(1,i1,i2,i3,ouzee) = rk2
782 zarray(2,i1,i2,i3,ouzee) = ik2
789 a=zarray(1,1,i2,i3,inzee)
790 b=zarray(2,1,i2,i3,inzee)
791 c=zarray(1,si1,si2,si3,inzee)
792 d=zarray(2,si1,si2,si3,inzee)
805 zarray(1,i1,i2,i3,ouzee) = rk2
806 zarray(2,i1,i2,i3,ouzee) = ik2
825 a=zarray(1,i1,i2,i3,ouzee)
826 b=zarray(2,i1,i2,i3,ouzee)
827 c=zarray(1,j1,j2,j3,ouzee)
828 d=-zarray(2,j1,j2,j3,ouzee)
838 zarray(1,i1,i2,i3,inzee)=rhk
839 zarray(2,i1,i2,i3,inzee)=ihk
847 a=zarray(1,i1,i2,i3,ouzee)
848 b=zarray(2,i1,i2,i3,ouzee)
849 c=zarray(1,j1,j2,j3,ouzee)
850 d=-zarray(2,j1,j2,j3,ouzee)
860 zarray(1,i1,i2,i3,inzee)=rhk
861 zarray(2,i1,i2,i3,inzee)=ihk
875 a=zarray(1,i1,i2,i3,ouzee)
876 b=zarray(2,i1,i2,i3,ouzee)
877 c=zarray(1,j1,j2,j3,ouzee)
878 d=-zarray(2,j1,j2,j3,ouzee)
888 zarray(1,i1,i2,i3,inzee)=rhk
889 zarray(2,i1,i2,i3,inzee)=ihk
897 a=zarray(1,i1,i2,i3,ouzee)
898 b=zarray(2,i1,i2,i3,ouzee)
899 c=zarray(1,j1,j2,j3,ouzee)
900 d=-zarray(2,j1,j2,j3,ouzee)
910 zarray(1,i1,i2,i3,inzee)=rhk
911 zarray(2,i1,i2,i3,inzee)=ihk
918 safe_deallocate_a(cos_array)
919 safe_deallocate_a(sin_array)
933 subroutine norm_ind(nd1,nd2,nd3,i1,i2,i3,ind)
934 integer :: nd1,nd2,nd3,i1,i2,i3
954 ind = a1 + nd1 * (a2 - 1) + nd1 * nd2 * (a3 - 1)
968 subroutine symm_ind(nd1,nd2,nd3,i1,i2,i3,ind)
969 integer :: nd1,nd2,nd3,i1,i2,i3
988 ind=a1+nd1*(a2-1)+nd1*nd2*(a3-1)
1001 subroutine zarray_in(n01,n02,n03,nd1,nd2,nd3,density,zarray)
1002 integer :: n01,n02,n03,nd1,nd2,nd3
1003 real(real64),
dimension(n01,n02,n03) :: density
1004 real(real64),
dimension(2,nd1,nd2,nd3) :: zarray
1006 integer :: i1,i2,i3,n01h,nd1hm,nd3hm,nd2hm
1019 zarray(1,i1,i2,i3) = 0.0_8
1020 zarray(2,i1,i2,i3) = 0.0_8
1028 zarray(1,i1+nd1hm,i2+nd2hm,i3+nd3hm) = density(2*i1-1,i2,i3)
1029 zarray(2,i1+nd1hm,i2+nd2hm,i3+nd3hm) = density(2*i1,i2,i3)
1033 if (modulo(n01,2) == 1)
then
1036 zarray(1,n01h+1+nd1hm,i2+nd2hm,i3+nd3hm) = density(n01,i2,i3)
1056 subroutine zarray_out(n01, n02, n03, nd1, nd2, nd3, rhopot, zarray, factor)
1057 integer,
intent(in) :: n01,n02,n03,nd1,nd2,nd3
1058 real(real64),
intent(out) :: rhopot(n01,n02,n03)
1059 real(real64),
intent(in) :: zarray(2*nd1,nd2,nd3)
1061 real(real64),
intent(in) :: factor
1070 rhopot(i1, i2, i3) = factor*zarray(i1,i2,i3)
1111 subroutine build_kernel(n01,n02,n03,nfft1,nfft2,nfft3,hgrid,itype_scf,karrayout)
1112 integer,
intent(in) :: n01,n02,n03,nfft1,nfft2,nfft3,itype_scf
1113 real(real64),
intent(in) :: hgrid
1114 real(real64),
dimension(nfft1/2+1,nfft2/2+1,nfft3/2+1),
intent(out) :: karrayout
1117 integer,
parameter :: N_GAUSS = 89
1119 integer,
parameter :: n_points = 2**6
1123 real(real64),
parameter :: p0_ref = 1._real64
1124 real(real64),
dimension(N_GAUSS) :: p_gauss,w_gauss
1126 real(real64),
allocatable :: kernel_scf(:), kern_1_scf(:)
1127 real(real64),
allocatable :: x_scf(:), y_scf(:)
1128 real(real64),
allocatable :: karrayhalf(:, :, :)
1130 real(real64) :: ur_gauss,dr_gauss,acc_gauss,pgauss,kern,a_range
1131 real(real64) :: factor,factor2,dx,absci,p0gauss,p0_cell
1132 real(real64) :: a1,a2,a3
1133 integer :: nd1,nd2,nd3,n1k,n2k,n3k,n_scf
1134 integer :: i_gauss,n_range,n_cell
1135 integer :: i,n_iter,i1,i2,i3,i_kern
1136 integer :: i01,i02,i03,inkee,n1h,n2h,n3h,nd1h
1141 n_scf=2*itype_scf*n_points
1149 nd1 = nfft1 + modulo(nfft1+1,2)
1150 nd2 = nfft2 + modulo(nfft2+1,2)
1151 nd3 = nfft3 + modulo(nfft3+1,2)
1157 safe_allocate(x_scf(0:n_scf))
1158 safe_allocate(y_scf(0:n_scf))
1161 call scaling_function(itype_scf,n_scf,n_range,x_scf,y_scf)
1163 dx = real(n_range, real64)/real(n_scf, real64)
1165 n_cell = max(n01,n02,n03)
1166 n_range = max(n_cell,n_range)
1169 safe_allocate(kernel_scf(-n_range:n_range))
1170 safe_allocate(kern_1_scf(-n_range:n_range))
1173 a1 = hgrid * real(n01, real64)
1174 a2 = hgrid * real(n02, real64)
1175 a3 = hgrid * real(n03, real64)
1177 x_scf(:) = hgrid * x_scf(:)
1178 y_scf(:) = 1._real64/hgrid * y_scf(:)
1181 p0_cell = p0_ref/(hgrid*hgrid)
1184 call gequad(n_gauss,p_gauss,w_gauss,ur_gauss,dr_gauss,acc_gauss)
1188 a_range =
sqrt(a1*a1+a2*a2+a3*a3)
1189 factor = 1._real64/a_range
1191 factor2 = 1._real64/(a1*a1+a2*a2+a3*a3)
1192 do i_gauss=1,n_gauss
1193 p_gauss(i_gauss) = factor2*p_gauss(i_gauss)
1195 do i_gauss=1,n_gauss
1196 w_gauss(i_gauss) = factor*w_gauss(i_gauss)
1199 karrayout(:,:,:) = 0.0_8
1202 loop_gauss:
do i_gauss=n_gauss,1,-1
1204 pgauss = p_gauss(i_gauss)
1207 n_iter = nint((
log(pgauss) -
log(p0_cell))/
log(4._real64))
1208 if (n_iter <= 0)
then
1212 p0gauss = pgauss/4._real64**n_iter
1217 kernel_scf(:) = 0.0_8
1221 absci = x_scf(i) - real(i_kern, real64)*hgrid
1223 kern = kern + y_scf(i)*
exp(-p0gauss*absci)*dx
1225 kernel_scf(i_kern) = kern
1226 kernel_scf(-i_kern) = kern
1227 if (abs(kern) < 1.d-18)
then
1234 call scf_recursion(itype_scf,n_iter,n_range,kernel_scf,kern_1_scf)
1243 karrayout(i1,i2,i3) = karrayout(i1,i2,i3) + w_gauss(i_gauss)* &
1244 kernel_scf(i01)*kernel_scf(i02)*kernel_scf(i03)
1251 safe_deallocate_a(kernel_scf)
1252 safe_deallocate_a(kern_1_scf)
1253 safe_deallocate_a(x_scf)
1254 safe_deallocate_a(y_scf)
1257 safe_allocate(karrayhalf(1:2, 1:nd1h*nd2*nd3, 1:2))
1259 karrayhalf(:, :, 2) = m_zero
1263 call karrayhalf_in(n01,n02,n03,n1k,n2k,n3k,nfft1,nfft2,nfft3,nd1,nd2,nd3,&
1264 karrayout,karrayhalf)
1265 call fft(n1h,nfft2,nfft3,nd1h,nd2,nd3,karrayhalf,1,inkee)
1267 call kernel_recon(n1k,n2k,n3k,nfft1,nfft2,nfft3,nd1,nd2,nd3,&
1268 karrayhalf(1,1,inkee),karrayout)
1270 safe_deallocate_a(karrayhalf)
1286 integer,
intent(in) :: n01,n02,n03
1287 integer,
intent(out) :: nfft1,nfft2,nfft3
1289 integer :: i1,i2,i3,l1
1299 call fourier_dim(i1,nfft1)
1300 call fourier_dim(nfft1/2,l1)
1301 if (modulo(nfft1,2) == 0 .and. modulo(l1,2) == 0 .and. 2*l1 == nfft1)
then
1307 call fourier_dim(i2,nfft2)
1308 if (modulo(nfft2,2) == 0)
then
1314 call fourier_dim(i3,nfft3)
1315 if (modulo(nfft3,2) == 0)
then
1339 subroutine karrayhalf_in(n01,n02,n03,n1k,n2k,n3k,nfft1,nfft2,nfft3,nd1,nd2,nd3, kernel,karrayhalf)
1340 integer,
intent(in) :: n01,n02,n03,n1k,n2k,n3k,nfft1,nfft2,nfft3,nd1,nd2,nd3
1341 real(real64),
dimension(n1k,n2k,n3k),
intent(in) :: kernel
1342 real(real64),
dimension(2,(nd1+1)/2,nd2,nd3),
intent(out) :: karrayhalf
1344 real(real64),
dimension(:),
allocatable :: karray
1345 integer :: i1,i2,i3,nd1h,n1h,n2h,n3h
1354 safe_allocate(karray(1:nfft1))
1357 karrayhalf(:,:,:,:) = 0.0_8
1362 karray(i1+n1h) = kernel(i1,i2,i3)
1365 karray(n1h-i1+1+nd1-nfft1) = kernel(i1,i2,i3)
1368 karrayhalf(1,i1,i2+n2h,i3+n3h) = karray(2*i1-1)
1369 karrayhalf(2,i1,i2+n2h,i3+n3h) = karray(2*i1)
1374 karrayhalf(:,i1,n2h-i2+1+nd2-nfft2,i3+n3h) = &
1375 karrayhalf(:,i1,i2+n2h,i3+n3h)
1382 karrayhalf(:,i1,i2,n3h-i3+1+nd3-nfft3) = karrayhalf(:,i1,i2,i3+n3h)
1387 safe_deallocate_a(karray)
1403 subroutine kernel_recon(n1k,n2k,n3k,nfft1,nfft2,nfft3,nd1,nd2,nd3,zarray,karray)
1404 integer,
intent(in) :: n1k,n2k,n3k,nfft1,nfft2,nfft3,nd1,nd2,nd3
1405 real(real64),
dimension(2,(nd1+1)/2*nd2*nd3),
intent(in) :: zarray
1406 real(real64),
dimension(n1k,n2k,n3k),
intent(out) :: karray
1408 real(real64),
dimension(:),
allocatable :: cos_array,sin_array
1409 integer :: i1,i2,i3,ind1,ind2,nd1h,n1h,n2h,n3h
1410 real(real64) :: rfe,ife,rfo,ifo,cp,sp,rk,ik,a,b,c,d,pi2
1419 pi2=8._real64*datan(1._real64)
1420 pi2=pi2/real(nfft1, real64)
1422 safe_allocate(cos_array(1:nd1h))
1423 safe_allocate(sin_array(1:nd1h))
1426 cos_array(i1)= dcos(pi2*(i1-1))
1427 sin_array(i1)=-dsin(pi2*(i1-1))
1432 call norm_ind(nd1h,nd2,nd3,i1,i2,i3,ind1)
1433 call symm_ind(nd1h,nd2,nd3,i1,i2,i3,ind2)
1438 rfe=0.5_real64*(a+c)
1439 ife=0.5_real64*(b-d)
1440 rfo=0.5_real64*(a-c)
1441 ifo=0.5_real64*(b+d)
1444 rk=rfe+cp*ifo-sp*rfo
1445 ik=ife-cp*rfo-sp*ifo
1459 safe_deallocate_a(cos_array)
1460 safe_deallocate_a(sin_array)
1503 subroutine par_calculate_dimensions(n01,n02,n03,m1,m2,m3,n1,n2,n3, md1,md2,md3,nd1,nd2,nd3,nproc)
1504 integer,
intent(in) :: n01,n02,n03,nproc
1505 integer,
intent(out) :: m1,m2,m3,n1,n2,n3,md1,md2,md3,nd1,nd2,nd3
1529 call fourier_dim(l1,n1)
1531 if (modulo(n1,2) == 0&
1538 call fourier_dim(l2,n2)
1539 if (modulo(n2,2) == 0)
then
1545 call fourier_dim(l3,n3)
1547 if (modulo(n3,2) == 0 &
1560151
if (nproc*(md2/nproc) < n2/2)
then
1572250
if (modulo(nd3,nproc) /= 0)
then
1619 subroutine par_psolver_kernel(n01, n02, n03, nd1, nd2, nd3, hgrid, kernelLOC, rhopot, iproc, nproc, comm)
1620 integer,
intent(in) :: n01,n02,n03,iproc,nproc
1621 integer,
intent(inout) :: nd1,nd2,nd3
1622 real(real64),
intent(in) :: hgrid
1623 real(real64),
intent(in),
dimension(nd1,nd2,nd3/nproc) :: kernelLOC
1624 real(real64),
intent(inout),
dimension(n01,n02,n03) :: rhopot
1625 type(mpi_comm),
intent(in) :: comm
1627 integer :: m1,m2,m3,n1,n2,n3,md1,md2,md3
1631 call par_calculate_dimensions(n01, n02, n03, m1, m2, m3, n1, n2, n3, md1, md2, md3, nd1, nd2, nd3, nproc)
1632 call pconvxc_off(m1, m2, m3, n1, n2, n3, nd1, nd2, nd3, md1, md2, md3, iproc, nproc, rhopot, kernelloc, hgrid, comm)
1675 subroutine pconvxc_off(m1, m2, m3, n1, n2, n3, nd1, nd2, nd3, md1, md2, md3, iproc, nproc, rhopot, kernelloc, hgrid, comm)
1676 integer,
intent(in) :: m1,m2,m3,n1,n2,n3,nd1,nd2,nd3,md1,md2,md3,iproc,nproc
1677 real(real64),
dimension(nd1,nd2,nd3/nproc),
intent(in) :: kernelloc
1678 real(real64),
dimension(m1,m3,m2),
intent(inout) :: rhopot
1679 real(real64),
intent(in) :: hgrid
1680 type(mpi_comm),
intent(in) :: comm
1683 integer :: istart,iend,jend,jproc
1684 real(real64) :: scal
1685 real(real64),
dimension(:,:,:),
allocatable :: zf, lrhopot(:, :, :)
1686 integer,
dimension(:),
allocatable :: counts, displs
1691 scal=hgrid**3/(real(n1*n2, real64)*real(n3, real64))
1693 safe_allocate(zf(1:md1, 1:md3, 1:md2/nproc))
1694 safe_allocate(counts(0:nproc-1))
1695 safe_allocate(displs(0:nproc-1))
1698 call enterdensity(rhopot(1,1,1), m1, m2, m3, md1, md2, md3, iproc, nproc, zf(1,1,1))
1701 call convolxc_off(n1, n2, n3, nd1, nd2, nd3, md1, md2, md3, nproc, iproc, kernelloc, zf, scal, comm)
1705 do jproc = 0, nproc - 1
1706 istart = min(jproc*(md2/nproc),m2-1)
1707 jend = max(min(md2/nproc, m2 - md2/nproc*jproc), 0)
1708 counts(jproc) = m1*m3*jend
1709 displs(jproc) = istart*m1*m3
1713 istart=min(iproc*(md2/nproc),m2-1)
1714 jend=max(min(md2/nproc,m2-md2/nproc*iproc),0)
1717 if (jend == 0) jend = 1
1719 safe_allocate(lrhopot(1:m1, 1:m3, 1:jend))
1721 lrhopot(1:m1, 1:m3, 1:jend) = zf(1:m1, 1:m3, 1:jend)
1723 call profiling_in(
"ISF_GATHER")
1724#if defined(HAVE_MPI)
1725 call mpi_allgatherv(lrhopot(1, 1, 1), counts(iproc), mpi_double_precision, rhopot(1, 1, 1), counts,&
1726 displs, mpi_double_precision, comm)
1728 call profiling_out(
"ISF_GATHER")
1730 safe_deallocate_a(zf)
1731 safe_deallocate_a(lrhopot)
1732 safe_deallocate_a(counts)
1733 safe_deallocate_a(displs)
1757 subroutine enterdensity(rhopot,m1,m2,m3,md1,md2,md3,iproc,nproc,zf)
1758 integer,
intent(in) :: m1,m2,m3,md1,md2,md3,iproc,nproc
1759 real(real64),
dimension(0:md1-1,0:md3-1,0:md2/nproc-1),
intent(out) :: zf
1760 real(real64),
dimension(0:m1-1,0:m3-1,0:m2-1),
intent(in) :: rhopot
1762 integer :: j1,j2,j3,jp2
1767 do jp2=0,md2/nproc-1
1768 j2=iproc*(md2/nproc)+jp2
1769 if (j2 <= m2-1)
then
1772 zf(j1,j3,jp2)=rhopot(j1,j3,j2)
1826 subroutine par_build_kernel(n01,n02,n03,nfft1,nfft2,nfft3,n1k,n2k,n3k,hgrid,itype_scf, &
1827 iproc,nproc,comm,karrayoutLOC)
1828 integer,
intent(in) :: n01,n02,n03,nfft1,nfft2,nfft3,n1k,n2k,n3k,itype_scf,iproc,nproc
1829 real(real64),
intent(in) :: hgrid
1830 real(real64),
intent(out) :: karrayoutLOC(1:n1k, 1:n2k, 1:n3k/nproc)
1831 type(mpi_comm),
intent(in) :: comm
1834 integer,
parameter :: N_GAUSS = 89
1836 integer,
parameter :: N_POINTS = 2**6
1840 real(real64),
parameter :: p0_ref = 1._real64
1841 real(real64) :: p_gauss(N_GAUSS), w_gauss(N_GAUSS)
1843 real(real64),
dimension(:),
allocatable :: kernel_scf,kern_1_scf
1844 real(real64),
dimension(:),
allocatable :: x_scf ,y_scf
1845 real(real64),
dimension(:,:,:,:),
allocatable :: karrayfour
1846 real(real64),
dimension(:,:,:),
allocatable :: karray
1848 real(real64) :: ur_gauss,dr_gauss,acc_gauss,pgauss,kern,a_range
1849 real(real64) :: factor,factor2,dx,absci,p0gauss,p0_cell
1850 real(real64) :: a1,a2,a3
1851 integer :: n_scf,nker1,nker2,nker3
1852 integer :: i_gauss,n_range,n_cell,istart,iend,istart1,istart2,iend1,iend2
1853 integer :: i,n_iter,i1,i2,i3,i_kern
1854 integer :: i01,i02,i03,n1h,n2h,n3h
1859 n_scf=2*itype_scf*n_points
1878 if (modulo(nker2,nproc) == 0)
exit
1882 if (modulo(nker3,nproc) == 0)
exit
1887 safe_allocate(karray(1:nker1,1:nfft3,1:nker2/nproc))
1892 istart=iproc*nker2/nproc+1
1893 iend=min((iproc+1)*nker2/nproc,n2h+n03)
1896 if (iproc == 0) istart1=n2h-n03+2
1902 if (istart > n2h)
then
1906 if (iend <= n2h)
then
1919 safe_allocate(x_scf(0:n_scf))
1920 safe_allocate(y_scf(0:n_scf))
1923 call scaling_function(itype_scf, n_scf, n_range, x_scf, y_scf)
1925 dx = real(n_range, real64)/real(n_scf, real64)
1927 n_cell = max(n01,n02,n03)
1928 n_range = max(n_cell,n_range)
1931 safe_allocate(kernel_scf(-n_range:n_range))
1932 safe_allocate(kern_1_scf(-n_range:n_range))
1935 a1 = hgrid * real(n01, real64)
1936 a2 = hgrid * real(n02, real64)
1937 a3 = hgrid * real(n03, real64)
1939 x_scf(:) = hgrid * x_scf(:)
1940 y_scf(:) = 1._real64/hgrid * y_scf(:)
1943 p0_cell = p0_ref/(hgrid*hgrid)
1946 call gequad(n_gauss,p_gauss,w_gauss,ur_gauss,dr_gauss,acc_gauss)
1950 a_range =
sqrt(a1*a1+a2*a2+a3*a3)
1951 factor = 1._real64/a_range
1953 factor2 = 1._real64/(a1*a1+a2*a2+a3*a3)
1954 do i_gauss=1,n_gauss
1955 p_gauss(i_gauss) = factor2*p_gauss(i_gauss)
1957 do i_gauss=1,n_gauss
1958 w_gauss(i_gauss) = factor*w_gauss(i_gauss)
1961 karray(:,:,:) = 0.0_8
1963 loop_gauss:
do i_gauss = n_gauss, 1, -1
1965 pgauss = p_gauss(i_gauss)
1968 n_iter = nint((
log(pgauss) -
log(p0_cell))/
log(4._real64))
1969 if (n_iter <= 0)
then
1973 p0gauss = pgauss/4._real64**n_iter
1978 kernel_scf(:) = 0.0_8
1982 absci = x_scf(i) - real(i_kern, real64)*hgrid
1984 kern = kern + y_scf(i)*
exp(-p0gauss*absci)*dx
1986 kernel_scf(i_kern) = kern
1987 kernel_scf(-i_kern) = kern
1988 if (abs(kern) < 1.d-18)
then
1995 call scf_recursion(itype_scf,n_iter,n_range,kernel_scf,kern_1_scf)
2005 karray(i1+n1h,i2+n3h,i3-istart+1) = karray(i1+n1h,i2+n3h,i3-istart+1) + w_gauss(i_gauss)* &
2006 kernel_scf(i01)*kernel_scf(i02)*kernel_scf(i03)
2016 karray(i1+n1h,i2+n3h,i3-istart+1) = karray(i1+n1h,i2+n3h,i3-istart+1) + w_gauss(i_gauss)* &
2017 kernel_scf(i01)*kernel_scf(i02)*kernel_scf(i03)
2030 karray(n1h+2-i1,i2+n3h,i3-istart+1) = karray(i1+n1h,i2+n3h,i3-istart+1)
2035 karray(i1,n3h+2-i2,i3-istart+1) = karray(i1,i2+n3h,i3-istart+1)
2042 safe_deallocate_a(kernel_scf)
2043 safe_deallocate_a(kern_1_scf)
2044 safe_deallocate_a(x_scf)
2045 safe_deallocate_a(y_scf)
2049 safe_allocate(karrayfour(1:2, 1:nker1, 1:nker2, 1:nker3/nproc))
2053 call kernelfft(nfft1,nfft2,nfft3,nker1,nker2,nker3,nproc,iproc,karray,karrayfour,comm)
2059 karrayoutloc(i1,i2,i3)=karrayfour(1,i1,i2,i3)
2065 safe_deallocate_a(karray)
2066 safe_deallocate_a(karrayfour)
2073 subroutine gequad(n_gauss, p_gauss, w_gauss, ur_gauss, dr_gauss, acc_gauss)
2074 integer,
intent(in) :: n_gauss
2075 real(real64),
intent(out) :: p_gauss(:)
2076 real(real64),
intent(out) :: w_gauss(:)
2077 real(real64),
intent(out) :: ur_gauss
2078 real(real64),
intent(out) :: dr_gauss
2079 real(real64),
intent(out) :: acc_gauss
2081 integer :: iunit, i, idx
2086 dr_gauss = 1.0e-08_8
2087 acc_gauss = 1.0e-08_8
2089 iunit = io_open(trim(conf%share)//
'/gequad.data', action =
'read', status =
'old')
2092 read(iunit, *) idx, p_gauss(i), w_gauss(i)
2095 call io_close(iunit)
double log(double __x) __attribute__((__nothrow__
double exp(double __x) __attribute__((__nothrow__
double sqrt(double __x) __attribute__((__nothrow__
This module defines the meshes, which are used in Octopus.
subroutine symm_ind(nd1, nd2, nd3, i1, i2, i3, ind)
subroutine zarray_in(n01, n02, n03, nd1, nd2, nd3, density, zarray)
subroutine karrayhalf_in(n01, n02, n03, n1k, n2k, n3k, nfft1, nfft2, nfft3, nd1, nd2, nd3, kernel, karrayhalf)
subroutine pconvxc_off(m1, m2, m3, n1, n2, n3, nd1, nd2, nd3, md1, md2, md3, iproc, nproc, rhopot, kernelloc, hgrid, comm)
subroutine, public poisson_isf_end(this)
subroutine build_kernel(n01, n02, n03, nfft1, nfft2, nfft3, hgrid, itype_scf, karrayout)
integer, parameter serial
subroutine norm_ind(nd1, nd2, nd3, i1, i2, i3, ind)
subroutine enterdensity(rhopot, m1, m2, m3, md1, md2, md3, iproc, nproc, zf)
subroutine par_psolver_kernel(n01, n02, n03, nd1, nd2, nd3, hgrid, kernelLOC, rhopot, iproc, nproc, comm)
subroutine kernel_application(n1, n2, n3, nd1h, nd2, nd3, nfft1, nfft2, nfft3, zarray, karray, inzee)
subroutine, public poisson_isf_init(this, namespace, mesh, cube, all_nodes_comm, init_world)
subroutine, public poisson_isf_solve(this, mesh, cube, pot, rho, all_nodes, sm)
subroutine gequad(n_gauss, p_gauss, w_gauss, ur_gauss, dr_gauss, acc_gauss)
subroutine calculate_dimensions(n01, n02, n03, nfft1, nfft2, nfft3)
subroutine par_build_kernel(n01, n02, n03, nfft1, nfft2, nfft3, n1k, n2k, n3k, hgrid, itype_scf, iproc, nproc, comm, karrayoutLOC)
integer, parameter domain
subroutine zarray_out(n01, n02, n03, nd1, nd2, nd3, rhopot, zarray, factor)
subroutine par_calculate_dimensions(n01, n02, n03, m1, m2, m3, n1, n2, n3, md1, md2, md3, nd1, nd2, nd3, nproc)
subroutine psolver_kernel(n01, n02, n03, nfft1, nfft2, nfft3, hgrid, karray, rhopot)
subroutine kernel_recon(n1k, n2k, n3k, nfft1, nfft2, nfft3, nd1, nd2, nd3, zarray, karray)
/* To use the profiling module, call profiling_in and profiling_out with the label of the region as a...
These routines are part of the ISF poisson solver, eventually they will be integrated with the other ...