65 integer,
parameter :: INNER_POINT = 1
66 integer,
parameter :: ENLARGEMENT_POINT = 2
67 integer,
parameter :: BOUNDARY = -1
78 subroutine mesh_init_stage_1(mesh, namespace, space, box, coord_system, spacing, enlarge)
79 class(mesh_t),
intent(inout) :: mesh
80 type(namespace_t),
intent(in) :: namespace
81 class(space_t),
intent(in) :: space
82 class(box_t),
target,
intent(in) :: box
83 class(coordinate_system_t),
target,
intent(in) :: coord_system
84 real(real64),
intent(in) :: spacing(1:space%dim)
85 integer,
intent(in) :: enlarge(1:space%dim)
87 integer :: idir, jj, delta
88 real(real64) :: x(space%dim), chi(space%dim), spacing_new(-1:1), box_bounds(2, space%dim), tol
95 safe_allocate(mesh%spacing(1:space%dim))
96 mesh%spacing = spacing
98 mesh%use_curvilinear = coord_system%local_basis
100 mesh%use_vol_pp = mesh%use_curvilinear
101 mesh%coord_system => coord_system
104 mesh%idx%enlarge = enlarge
107 select type (coord_system)
117 do idir = 1, space%dim
124 chi(idir) = real(jj, real64) * mesh%spacing(idir)
125 if (mesh%use_curvilinear)
then
126 x = coord_system%to_cartesian(chi)
127 out = x(idir) > maxval(abs(
box_bounds(:, idir))) + tol
130 out = chi(idir) > maxval(abs(
box_bounds(:, idir))) + tol
133 mesh%idx%nr(2, idir) = jj - 1
137 mesh%idx%nr(1,:) = -mesh%idx%nr(2,:)
140 do idir = 1, space%periodic_dim
141 if (mesh%idx%nr(2, idir) == 0)
then
143 mesh%idx%nr(2, idir) = 1
144 mesh%idx%nr(1, idir) = -1
152 spacing_new(delta) =
m_two*maxval(abs(
box_bounds(:, idir))) / real(2 * mesh%idx%nr(2, idir) + 1 - delta, real64)
153 spacing_new(delta) = abs(spacing_new(delta) - spacing(idir))
156 delta = minloc(spacing_new, dim = 1) - 2
161 mesh%spacing(idir) =
m_two*maxval(abs(
box_bounds(:, idir))) / real(2 * mesh%idx%nr(2, idir) + 1 - delta, real64)
164 if (delta == -1)
then
165 mesh%idx%nr(1, idir) = mesh%idx%nr(1, idir) - 1
166 else if (delta == 1)
then
167 mesh%idx%nr(2, idir) = mesh%idx%nr(2, idir) - 1
172 if ( any(abs(mesh%spacing - spacing) > 1.e-6_real64) )
then
173 call messages_write(
'The spacing has been modified to make it commensurate with the periodicity of the system.')
177 do idir = space%periodic_dim + 1, space%dim
178 if (mesh%idx%nr(2, idir) == 0)
then
179 write(
message(1),
'(a,i2)')
'Spacing > box size in direction ', idir
184 mesh%idx%ll = mesh%idx%nr(2, :) - mesh%idx%nr(1, :) + 1
186 mesh%idx%stride(:) = 1
187 do idir = 2, space%dim+1
188 mesh%idx%stride(idir) = mesh%idx%stride(idir-1) * &
189 (mesh%idx%ll(idir-1) + 2*mesh%idx%enlarge(idir-1))
202 subroutine mesh_init_stage_2(mesh, namespace, space, box, stencil, grp, regenerate)
203 class(
mesh_t),
intent(inout) :: mesh
205 class(
space_t),
intent(in) :: space
206 class(
box_t),
intent(in) :: box
209 logical,
optional,
intent(in) :: regenerate
212 real(real64) :: chi(1:space%dim)
213 real(real64) :: pos(space%dim)
214 integer :: point(space%dim), point_stencil(space%dim), grid_sizes(space%dim)
215 integer(int64) :: global_size
216 integer(int32) :: local_size
217 integer(int64) :: ispatial, ispatialb, istart, iend, spatial_size, ipg
218 integer :: ip, ib, ib2, np, np_boundary, ii
220 type(
lihash_t) :: spatial_to_boundary
221 integer(int64),
allocatable :: boundary_to_spatial(:), boundary_to_spatial_reordered(:)
222 integer(int64),
allocatable :: grid_to_spatial(:), grid_to_spatial_initial(:), grid_to_spatial_reordered(:)
223 integer(int64),
allocatable :: spatial_to_grid(:)
224 integer,
allocatable ::
sizes(:)
225 integer(int64),
allocatable :: offsets(:)
226 integer :: size_boundary
228 integer(int64),
pointer :: ptr(:)
229 type(
mpi_grp_t) :: internode_grp, intranode_grp
236 mesh%idx%nr(1, :) = mesh%idx%nr(1, :) - mesh%idx%enlarge(:)
237 mesh%idx%nr(2, :) = mesh%idx%nr(2, :) + mesh%idx%enlarge(:)
254 grid_sizes = mesh%idx%nr(2, :) - mesh%idx%nr(1, :) + 1
255 mesh%idx%offset = grid_sizes/2
256 if (space%dim > 1 .and. any(grid_sizes > 2**(int(63/space%dim, int64))))
then
257 write(
message(1),
'(A, I10, A, I2, A)')
"Error: grid too large, more than ", 2**(int(63/space%dim, int64)), &
258 " points in one direction for ", space%dim,
" dimensions. This is not supported."
261 global_size = product(int(grid_sizes, int64))
263 mesh%idx%bits = maxval(ceiling(
log(real(grid_sizes, real64) )/
log(2.0_real64)))
266 spatial_size = global_size
268 spatial_size = 2**(space%dim*mesh%idx%bits)
272 istart = spatial_size * grp%rank/grp%size
273 iend = spatial_size * (grp%rank+1)/grp%size - 1
274 if (.not. (iend - istart + 1 < huge(0_int32)))
then
275 write(
message(1),
'(A, I10, A, I2, A)')
"Error: local grid too large, more than ", &
276 huge(0_int32),
" points. This is not supported. Maybe use more MPI ranks?"
279 local_size = int(iend - istart + 1, int32)
281 safe_allocate(grid_to_spatial_initial(1:local_size))
285 do ispatial = istart, iend
288 if (any(point < mesh%idx%nr(1, :) + mesh%idx%enlarge)) cycle
289 if (any(point > mesh%idx%nr(2, :) - mesh%idx%enlarge)) cycle
291 chi = real(point, real64) * mesh%spacing
292 pos = mesh%coord_system%to_cartesian(chi)
293 if (.not. box%contains_point(pos)) cycle
294 grid_to_spatial_initial(ip) = ispatial
295 assert(ip + 1 < huge(ip))
303 safe_deallocate_a(grid_to_spatial_initial)
305 safe_allocate(spatial_to_grid(grid_to_spatial(1):grid_to_spatial(np)))
306 safe_deallocate_a(
sizes)
309 do ispatial = grid_to_spatial(1), grid_to_spatial(np)
310 spatial_to_grid(ispatial) = -1
314 spatial_to_grid(grid_to_spatial(ip)) = ip
320 safe_allocate(boundary_to_spatial(1:size_boundary))
324 do is = 1, stencil%size
325 if (stencil%center == is) cycle
326 point_stencil(1:space%dim) = point(1:space%dim) + stencil%points(1:space%dim, is)
329 assert(ispatialb >= 0)
330 if (ispatialb >= lbound(spatial_to_grid, dim=1, kind=int64) .and. &
331 ispatialb <= ubound(spatial_to_grid, dim=1, kind=int64))
then
332 if (spatial_to_grid(ispatialb) > 0) cycle
335 chi = real(point_stencil, real64) * mesh%spacing
336 pos = mesh%coord_system%to_cartesian(chi)
337 if (box%contains_point(pos)) cycle
342 boundary_to_spatial(ib) = ispatialb
346 if (ib >= size_boundary)
then
347 size_boundary = size_boundary * 2
354 safe_deallocate_a(spatial_to_grid)
357 call reorder_points(namespace, space, grp, mesh%idx, grid_to_spatial, grid_to_spatial_reordered)
358 safe_deallocate_a(grid_to_spatial)
362 mesh%np_global =
sizes(0)
363 do ii = 1, grp%size - 1
364 mesh%np_global = mesh%np_global +
sizes(ii)
366 safe_deallocate_a(
sizes)
367 safe_deallocate_a(grid_to_spatial_reordered)
371 call reorder_points(namespace, space, grp, mesh%idx, boundary_to_spatial, boundary_to_spatial_reordered)
372 safe_deallocate_a(boundary_to_spatial)
375 safe_deallocate_a(boundary_to_spatial_reordered)
378 np_boundary =
sizes(grp%rank)
379 mesh%np_part_global = mesh%np_global +
sizes(0)
380 do ii = 1, grp%size - 1
381 mesh%np_part_global = mesh%np_part_global +
sizes(ii)
383 safe_deallocate_a(
sizes)
389 call create_intranode_communicator(grp, intranode_grp, internode_grp)
390 call lmpi_create_shared_memory_window(mesh%np_part_global, intranode_grp, &
391 mesh%idx%window_grid_to_spatial, mesh%idx%grid_to_spatial_global)
393 safe_allocate(mesh%idx%grid_to_spatial_global(1:mesh%np_part_global))
397 call grp%gatherv(grid_to_spatial, np, mpi_integer8, &
398 mesh%idx%grid_to_spatial_global,
sizes, offsets, mpi_integer8, 0)
402 call grp%gatherv(boundary_to_spatial, np_boundary, mpi_integer8, &
403 mesh%idx%grid_to_spatial_global(mesh%np_global+1:),
sizes, offsets, mpi_integer8, 0)
408 call lmpi_create_shared_memory_window(spatial_size, intranode_grp, &
409 mesh%idx%window_spatial_to_grid, ptr)
410 mesh%idx%spatial_to_grid_global(0:spatial_size-1) => ptr(1:spatial_size)
412 safe_allocate(mesh%idx%spatial_to_grid_global(0:spatial_size-1))
414 if (grp%is_root())
then
417 do ispatial = 0, spatial_size-1
418 mesh%idx%spatial_to_grid_global(ispatial) = 0
421 do ipg = 1, mesh%np_part_global
422 mesh%idx%spatial_to_grid_global(mesh%idx%grid_to_spatial_global(ipg)) = ipg
428 if (intranode_grp%is_root())
then
429 call internode_grp%bcast(mesh%idx%grid_to_spatial_global(1), mesh%np_part_global, mpi_integer8, 0)
430 call internode_grp%bcast(mesh%idx%spatial_to_grid_global(0), spatial_size, mpi_integer8, 0)
432 call lmpi_sync_shared_memory_window(mesh%idx%window_grid_to_spatial, intranode_grp)
433 call lmpi_sync_shared_memory_window(mesh%idx%window_spatial_to_grid, intranode_grp)
436 safe_deallocate_a(offsets)
437 safe_deallocate_a(
sizes)
439 safe_deallocate_a(boundary_to_spatial)
440 safe_deallocate_a(grid_to_spatial)
451 subroutine mesh_init_stage_3(mesh, namespace, space, stencil, mc, parent, regenerate)
452 class(
mesh_t),
intent(inout) :: mesh
454 class(
space_t),
intent(in) :: space
457 type(
mesh_t),
optional,
intent(in) :: parent
458 logical,
optional,
intent(in) :: regenerate
460 integer :: ip, jj(space%dim), np
467 mesh%parallel_in_domains = (mesh%mpi_grp%size > 1)
472 if (mesh%parallel_in_domains)
then
476 assert(mesh%np_part_global < huge(mesh%np_part))
478 mesh%np_part =
i8_to_i4(mesh%np_part_global)
482 mesh%pv%np_global = mesh%np_global
484 mesh%pv%np_bndry = mesh%np_part - mesh%np
490 safe_allocate(mesh%x(1:space%dim, 1:mesh%np_part))
491 safe_allocate(mesh%x_t(1:mesh%np_part, 1:space%dim))
492 do ip = 1, mesh%np_part
494 mesh%x_t(ip, 1:space%dim) = mesh%x(1:space%dim, ip)
498 safe_allocate(mesh%chi(1:space%dim, 1:mesh%np_part))
499 do ip = 1, mesh%np_part
501 mesh%chi(:, ip) = jj*mesh%spacing
507 if (mesh%coord_system%local_basis)
then
512 safe_allocate(mesh%jacobian_inverse(1:space%dim, 1:space%dim, np))
514 mesh%jacobian_inverse(:, :, ip) = mesh%coord_system%jacobian_inverse(mesh%chi(:, ip))
523 integer :: jj, ipart, jpart
524 integer(int64) :: ipg, jpg
525 integer,
allocatable :: gindex(:), gedges(:)
526 logical,
allocatable :: nb(:, :)
527 integer :: idx(space%dim), jx(space%dim)
528 type(mpi_comm) :: graph_comm
529 integer :: iedge, nnb
530 logical :: use_topo, reorder, partition_print
533 logical :: has_virtual_partition = .false.
535 type(
restart_t) :: restart_load, restart_dump
536 integer,
allocatable :: part_vec(:)
544 call restart_load%end()
559 call parse_variable(namespace,
'MeshPartitionVirtualSize', mesh%mpi_grp%size, vsize)
561 if (vsize /= mesh%mpi_grp%size)
then
562 write(
message(1),
'(a,I7)')
"Changing the partition size to", vsize
563 write(
message(2),
'(a)')
"The execution will crash."
565 has_virtual_partition = .
true.
567 has_virtual_partition = .false.
570 if (.not.
present(parent))
then
580 call restart_dump%end()
583 if (has_virtual_partition)
then
586 write(
message(1),
'(a)')
"Execution has ended."
587 write(
message(2),
'(a)')
"If you want to run your system, do not use MeshPartitionVirtualSize."
603 call parse_variable(namespace,
'MeshUseTopology', .false., use_topo)
607 safe_allocate(part_vec(1:mesh%np_global))
613 safe_allocate(nb(1:mesh%mpi_grp%size, 1:mesh%mpi_grp%size))
616 do ipg = 1, mesh%np_global
617 ipart = part_vec(ipg)
619 do jj = 1, stencil%size
620 jx = idx + stencil%points(:, jj)
622 if (jpg > 0 .and. jpg <= mesh%np_global)
then
623 jpart = part_vec(jpg)
624 if (ipart /= jpart ) nb(ipart, jpart) = .
true.
628 safe_deallocate_a(part_vec)
632 safe_allocate(gindex(1:mesh%mpi_grp%size))
633 safe_allocate(gedges(1:count(nb)))
637 do ipart = 1, mesh%mpi_grp%size
638 do jpart = 1, mesh%mpi_grp%size
639 if (nb(ipart, jpart))
then
641 gedges(iedge) = jpart - 1
644 gindex(ipart) = iedge
647 assert(iedge == count(nb))
650 call mpi_graph_create(mesh%mpi_grp%comm, mesh%mpi_grp%size, gindex, gedges, reorder, graph_comm)
655 safe_deallocate_a(nb)
656 safe_deallocate_a(gindex)
657 safe_deallocate_a(gedges)
662 call par_vec_init(mesh%mpi_grp, mesh%np_global, mesh%idx, stencil,&
663 space, mesh%partition, mesh%pv, namespace)
667 jpart = mesh%pv%partno
668 do ipart = 1, mesh%pv%npart
669 if (ipart == jpart) cycle
670 if (mesh%pv%ghost_scounts(ipart) /= 0) nnb = nnb + 1
672 assert(nnb >= 0 .and. nnb < mesh%pv%npart)
675 mesh%np = mesh%pv%np_local
676 mesh%np_part = mesh%np + mesh%pv%np_ghost + mesh%pv%np_bndry
689 if (partition_print)
then
708 if (mesh%use_vol_pp) np = mesh%np_part
710 if (mesh%np_part == 0) np = 0
712 safe_allocate(mesh%vol_pp(1:np))
715 mesh%vol_pp(ip) = product(mesh%spacing)
719 mesh%vol_pp(ip) = mesh%vol_pp(ip)*mesh%coord_system%jacobian_determinant(mesh%chi(:, ip))
722 if (mesh%use_vol_pp .or. mesh%np_part == 0)
then
723 mesh%volume_element =
m_one
725 mesh%volume_element = mesh%vol_pp(1)
749 integer(int64),
contiguous,
intent(in) :: data_input(:)
750 integer(int64),
allocatable,
intent(out) :: data_output(:)
751 integer,
allocatable,
optional,
intent(out) :: output_sizes(:)
753 integer,
allocatable :: initial_sizes(:), final_sizes(:)
754 integer(int64),
allocatable :: initial_offsets(:), final_offsets(:)
755 integer,
allocatable :: scounts(:), sdispls(:)
756 integer,
allocatable :: rcounts(:), rdispls(:)
758 integer(int64) :: itmp
763 safe_allocate(initial_sizes(0:grp%size-1))
764 call grp%allgather(
size(data_input), 1, mpi_integer, initial_sizes(0), 1, mpi_integer)
765 safe_allocate(initial_offsets(0:grp%size))
766 initial_offsets(0) = 0
767 do irank = 1, grp%size
768 initial_offsets(irank) = initial_offsets(irank-1) + initial_sizes(irank-1)
773 safe_allocate(final_offsets(0:grp%size))
774 safe_allocate(final_sizes(0:grp%size-1))
776 do irank = 0, grp%size
777 final_offsets(irank) = sum(int(initial_sizes, int64)) * irank/grp%size
779 do irank = 0, grp%size - 1
780 assert(final_offsets(irank + 1) - final_offsets(irank) < huge(0_int32))
781 final_sizes(irank) = int(final_offsets(irank + 1) - final_offsets(irank), int32)
784 safe_allocate(scounts(0:grp%size-1))
785 safe_allocate(sdispls(0:grp%size-1))
786 safe_allocate(rcounts(0:grp%size-1))
787 safe_allocate(rdispls(0:grp%size-1))
790 do irank = 0, grp%size - 1
792 itmp = min(final_offsets(irank+1), initial_offsets(grp%rank+1)) - &
793 max(final_offsets(irank), initial_offsets(grp%rank))
794 assert(itmp < huge(0_int32))
798 scounts(irank) = int(itmp, int32)
802 do irank = 1, grp%size - 1
803 sdispls(irank) = sdispls(irank - 1) + scounts(irank - 1)
805 assert(sum(int(scounts, int64)) < huge(0_int32))
806 assert(sum(scounts) == initial_sizes(grp%rank))
809 do irank = 0, grp%size - 1
811 itmp = min(final_offsets(grp%rank+1), initial_offsets(irank+1)) - &
812 max(final_offsets(grp%rank), initial_offsets(irank))
813 assert(itmp < huge(0_int32))
817 rcounts(irank) = int(itmp, int32)
821 do irank = 1, grp%size - 1
822 rdispls(irank) = rdispls(irank - 1) + rcounts(irank - 1)
825 assert(sum(rcounts) == final_sizes(grp%rank))
827 safe_allocate(data_output(1:final_sizes(grp%rank)))
828 call grp%alltoallv(data_input, scounts, sdispls, mpi_integer8, &
829 data_output, rcounts, rdispls, mpi_integer8)
832 if (
present(output_sizes))
then
833 safe_allocate(output_sizes(0:grp%size-1))
834 output_sizes(:) = final_sizes(:)
837 safe_deallocate_a(final_offsets)
838 safe_deallocate_a(final_sizes)
840 safe_deallocate_a(scounts)
841 safe_deallocate_a(sdispls)
842 safe_deallocate_a(rcounts)
843 safe_deallocate_a(rdispls)
853 subroutine reorder_points(namespace, space, grp, idx, grid_to_spatial, grid_to_spatial_reordered)
855 class(
space_t),
intent(in) :: space
857 type(
index_t),
intent(in) :: idx
858 integer(int64),
contiguous,
intent(in) :: grid_to_spatial(:)
859 integer(int64),
allocatable,
intent(out) :: grid_to_spatial_reordered(:)
861 integer :: bsize(space%dim), order, default
862 integer :: nn, idir, ipg, ip, number_of_blocks(space%dim)
864 integer,
parameter :: &
866 order_original = 2, &
868 integer :: point(1:space%dim)
869 integer(int64),
allocatable :: reorder_indices(:), reorder_recv(:)
870 integer,
allocatable :: index_map(:), indices(:)
871 integer(int64),
allocatable :: grid_to_spatial_recv(:)
872 integer,
allocatable :: initial_sizes(:)
873 integer(int64),
allocatable :: initial_offsets(:)
874 integer(int64) :: istart, iend, indstart, indend, spatial_size
875 integer :: irank, local_size, num_recv
876 integer :: iunique, nunique
878 logical :: increase_with_dimension
880 integer,
allocatable :: scounts(:), sdispls(:), rcounts(:), rdispls(:)
881 integer(int64),
allocatable :: spatial_cutoff(:)
903 default = order_blocks
906 if (space%dim == 1)
then
907 order = order_original
925 call parse_variable(namespace,
'MeshBlockDirection', 1, direction)
926 increase_with_dimension = direction == 1
927 if (direction /= 1 .and. direction /= 2)
then
932 case (order_original)
934 safe_allocate(grid_to_spatial_reordered(1:
size(grid_to_spatial)))
935 grid_to_spatial_reordered(1:
size(grid_to_spatial)) = grid_to_spatial(1:
size(grid_to_spatial))
936 case (order_blocks, order_cube)
937 if (order == order_cube)
then
938 bsize = idx%nr(2, :) - idx%nr(1, :) + 1
951 if (
conf%target_states_block_size < 16)
then
952 bsize(1) = 80 * 4 / abs(
conf%target_states_block_size)
953 if (space%dim > 1) bsize(2) = 4
954 if (space%dim > 2) bsize(3:) = 10
956 bsize(1) = max(4 * 16 / abs(
conf%target_states_block_size), 1)
957 if (space%dim > 1) bsize(2) = 15
958 if (space%dim > 2) bsize(3:) = 15
961 if (
parse_block(namespace,
'MeshBlockSize', blk) == 0)
then
963 if (nn /= space%dim)
then
964 message(1) =
"Error: number of entries in MeshBlockSize must match the number of dimensions."
973 number_of_blocks = (idx%nr(2, :) - idx%nr(1, :) + 1) / bsize + 1
980 safe_allocate(initial_sizes(0:grp%size-1))
981 call grp%allgather(
size(grid_to_spatial), 1, mpi_integer, initial_sizes(0), 1, mpi_integer)
982 safe_allocate(initial_offsets(0:grp%size))
983 initial_offsets(0) = 0
984 do irank = 1, grp%size
985 initial_offsets(irank) = initial_offsets(irank-1) + initial_sizes(irank-1)
989 istart = initial_offsets(grp%rank)
990 iend = initial_offsets(grp%rank + 1) - 1
991 assert(iend - istart + 1 < huge(0_int32))
992 local_size = int(iend - istart + 1, int32)
993 assert(local_size == initial_sizes(grp%rank))
996 safe_allocate(reorder_indices(1:local_size))
997 safe_allocate(indices(1:local_size))
998 safe_allocate(grid_to_spatial_reordered(1:local_size))
1000 do ip = 1, local_size
1002 point = point + idx%offset
1003 reorder_indices(ip) =
get_blocked_index(space%dim, point, bsize, number_of_blocks, increase_with_dimension)
1007 call sort(reorder_indices, indices)
1010 do ip = 1, local_size
1011 grid_to_spatial_reordered(ip) = grid_to_spatial(indices(ip))
1015 if(local_size > 0)
then
1016 indstart = reorder_indices(1)
1017 indend = reorder_indices(local_size)
1019 indstart = huge(1_int64)
1022 call grp%allreduce_inplace(indstart, 1, mpi_integer8, mpi_min)
1023 call grp%allreduce_inplace(indend, 1, mpi_integer8, mpi_max)
1024 spatial_size = indend - indstart + 1
1027 safe_allocate(spatial_cutoff(0:grp%size-1))
1028 do irank = 0, grp%size - 1
1029 spatial_cutoff(irank) = spatial_size * (irank+1)/grp%size + indstart
1032 safe_allocate(scounts(0:grp%size-1))
1033 safe_allocate(sdispls(0:grp%size-1))
1034 safe_allocate(rcounts(0:grp%size-1))
1035 safe_allocate(rdispls(0:grp%size-1))
1041 do ip = 1, local_size
1042 if (reorder_indices(ip) >= spatial_cutoff(irank))
then
1044 do while (reorder_indices(ip) >= spatial_cutoff(irank))
1047 assert(irank < grp%size)
1049 scounts(irank) = scounts(irank) + 1
1051 safe_deallocate_a(spatial_cutoff)
1052 assert(sum(scounts) == local_size)
1056 do irank = 1, grp%size - 1
1057 sdispls(irank) = sdispls(irank - 1) + scounts(irank - 1)
1060 call grp%alltoall(scounts, 1, mpi_integer, &
1061 rcounts, 1, mpi_integer)
1064 do irank = 1, grp%size - 1
1065 rdispls(irank) = rdispls(irank - 1) + rcounts(irank - 1)
1069 num_recv = max(sum(rcounts), 1)
1071 safe_allocate(reorder_recv(1:num_recv))
1072 call grp%alltoallv(reorder_indices, scounts, sdispls, mpi_integer8, &
1073 reorder_recv, rcounts, rdispls, mpi_integer8)
1074 safe_deallocate_a(reorder_indices)
1077 safe_allocate(grid_to_spatial_recv(1:num_recv))
1078 call grp%alltoallv(grid_to_spatial_reordered, scounts, sdispls, mpi_integer8, &
1079 grid_to_spatial_recv, rcounts, rdispls, mpi_integer8)
1080 safe_deallocate_a(grid_to_spatial_reordered)
1083 safe_allocate(reorder_indices(1:num_recv))
1084 safe_allocate(index_map(1:num_recv))
1085 if (sum(rcounts) > 0)
then
1090 do ipg = 2, sum(rcounts)
1091 if (reorder_indices(ipg) /= reorder_indices(ipg-1))
then
1092 nunique = nunique + 1
1097 safe_allocate(grid_to_spatial_reordered(1:nunique))
1099 grid_to_spatial_reordered(iunique) = grid_to_spatial_recv(index_map(1))
1100 do ipg = 2, sum(rcounts)
1101 if (reorder_indices(ipg) /= reorder_indices(ipg-1))
then
1102 iunique = iunique + 1
1103 grid_to_spatial_reordered(iunique) = grid_to_spatial_recv(index_map(ipg))
1107 safe_allocate(grid_to_spatial_reordered(1:0))
1110 safe_deallocate_a(initial_offsets)
1111 safe_deallocate_a(initial_sizes)
1113 safe_deallocate_a(reorder_indices)
1114 safe_deallocate_a(reorder_recv)
1116 safe_deallocate_a(grid_to_spatial_recv)
1117 safe_deallocate_a(index_map)
1118 safe_deallocate_a(indices)
1120 safe_deallocate_a(scounts)
1121 safe_deallocate_a(sdispls)
1122 safe_deallocate_a(rcounts)
1123 safe_deallocate_a(rdispls)
1132 integer,
intent(in) :: local_size
1133 integer,
allocatable,
intent(out) :: sizes(:)
1134 integer(int64),
allocatable,
intent(out) :: offsets(:)
1141 safe_allocate(sizes(0:mpi_grp%size-1))
1142 call mpi_grp%allgather(local_size, 1, mpi_integer, sizes(0), 1, mpi_integer)
1143 safe_allocate(offsets(0:mpi_grp%size))
1145 do irank = 1, mpi_grp%size
1146 offsets(irank) = offsets(irank-1) + sizes(irank-1)
Box bounds along some axes.
This is the common interface to a sorting routine. It performs the shell algorithm,...
double log(double __x) __attribute__((__nothrow__
double sqrt(double __x) __attribute__((__nothrow__
subroutine do_partition()
subroutine mesh_get_vol_pp()
calculate the volume of integration
pure logical function, public accel_is_enabled()
integer, parameter, public accel_mem_read_only
real(real64), parameter, public box_boundary_delta
This module handles the calculation mode.
integer, parameter, public p_strategy_domains
parallelization in domains
real(real64), parameter, public m_two
subroutine, public global_end()
Finalise parser varinfo file, and MPI.
real(real64), parameter, public m_zero
type(conf_t), public conf
Global instance of Octopus configuration.
real(real64), parameter, public m_one
This module implements a simple hash table for non-negative integer keys and integer values.
integer function, public lihash_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 lihash_insert(h, key, val)
Insert a (key, val) pair into the hash table h.
subroutine, public lihash_end(h)
Free a hash table.
subroutine, public lihash_init(h)
Initialize a hash table h.
This module implements the index, used for the mesh points.
subroutine, public index_init(idx, dim)
This subroutine allocates memory and initializes some components.
integer(int64) function, public get_blocked_index(dim, point, bsize, number_of_blocks, increase_with_dimensions)
subroutine, public index_spatial_to_point(idx, dim, ispatial, point)
integer, parameter, public idx_hilbert
subroutine, public index_point_to_spatial(idx, dim, ispatial, point)
integer, parameter, public idx_cubic
This module is intended to contain "only mathematical" functions and procedures.
subroutine, public merge_sorted_arrays(array, sizes, merged, index_map)
This module contains subroutines, related to the initialization of the mesh.
subroutine rebalance_array(grp, data_input, data_output, output_sizes)
re-distribute the points to improve load balancing
subroutine, public mesh_init_stage_3(mesh, namespace, space, stencil, mc, parent, regenerate)
When running parallel in domains, stencil and np_stencil are needed to compute the ghost points....
subroutine, public mesh_init_stage_1(mesh, namespace, space, box, coord_system, spacing, enlarge)
First stage mesh initialization.
subroutine get_sizes_offsets(local_size, sizes, offsets, mpi_grp)
return the sizes and offsets of a distributed array for all tasks of a mpi group.
subroutine reorder_points(namespace, space, grp, idx, grid_to_spatial, grid_to_spatial_reordered)
reorder the points in the grid according to the variables MeshOrder and MeshLocalOrder
subroutine, public mesh_init_stage_2(mesh, namespace, space, box, stencil, grp, regenerate)
This subroutine creates the global array of spatial indices and the inverse mapping.
This module defines the meshes, which are used in Octopus.
subroutine, public mesh_global_index_to_coords(mesh, ipg, ix)
Given a global point index, this function returns the set of integer coordinates of the point.
integer(int64) function, public mesh_global_index_from_coords(mesh, ix)
This function returns the true global index of the point for a given vector of integer coordinates.
subroutine, public mesh_local_index_to_coords(mesh, ip, ix)
Given a local point index, this function returns the set of integer coordinates of the point.
integer(int64) function, public mesh_local2global(mesh, ip)
This function returns the global mesh index for a given local index.
real(real64) function, dimension(1:mesh%box%dim), public mesh_x_global(mesh, ipg)
Given a global point index, this function returns the coordinates of the point.
subroutine, public mesh_partition_from_parent(mesh, parent)
create a mesh partition from a given parent mesh
subroutine, public mesh_partition_write_info(mesh, iunit, namespace)
subroutine, public mesh_partition_messages_debug(mesh, namespace)
subroutine, public mesh_partition(mesh, namespace, space, lapl_stencil, vsize)
This routine converts the mesh given by grid points into a graph.
subroutine, public mesh_partition_dump(restart, mesh, vsize, ierr)
subroutine, public mesh_partition_load(restart, mesh, ierr)
subroutine, public messages_end()
subroutine, public messages_warning(no_lines, all_nodes, namespace)
subroutine, public print_date(str)
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
subroutine, public messages_input_error(namespace, var, details, row, column)
This module contains some common usage patterns of MPI routines.
subroutine mpi_grp_init(grp, comm)
Initialize MPI group instance.
This module handles the communicators for the various parallelization strategies.
Some general things and nomenclature:
subroutine, public par_vec_end(pv)
Deallocate memory used by pv.
subroutine, public par_vec_init(mpi_grp, np_global, idx, stencil, space, partition, pv, namespace)
Initializes a par_vec_type object (parallel vector).
integer function, public parse_block(namespace, name, blk, check_varinfo_)
subroutine, public partition_get_global(partition, part_global, root)
Returns the global partition. If root is present, the partition is gathered only in that node....
/* To use the profiling module, call profiling_in and profiling_out with the label of the region as a...
subroutine, public profiling_end(namespace)
integer, parameter, public restart_partition
integer, parameter, public restart_type_dump
integer, parameter, public restart_type_load
This module is intended to contain "only mathematical" functions and procedures.
This module defines stencils used in Octopus.
integer, dimension(7), parameter sizes
type(type_t), parameter, public type_float
This module is intended to contain simple general-purpose utility functions and procedures.
subroutine, public make_array_larger(array, new_size)
class to tell whether a point is inside or outside
Describes mesh distribution to nodes.
This is defined even when running serial.
Stores all communicators and groups.
The class representing the stencil, which is used for non-local mesh operations.