Implement SPH kernels and neighbor scaffold
This commit is contained in:
@@ -0,0 +1,221 @@
|
||||
module sph_neighbor
|
||||
use sph_precision, only: rk, SPH_NDIM
|
||||
use sph_error, only: SPH_SUCCESS, SPH_ERROR_ARGUMENT, sph_error_set
|
||||
use sph_database, only: npart, x, h, particle_cell_id, cell_head, cell_next, &
|
||||
neighbor_count, neighbor_offset, neighbor_list, sph_db_allocate_neighbor_storage
|
||||
use sph_particle, only: SPH_KERNEL_DEFAULT, sph_kernel_support_radius
|
||||
implicit none
|
||||
|
||||
real(rk) :: neighbor_min_corner(SPH_NDIM) = 0.0_rk
|
||||
real(rk) :: neighbor_max_corner(SPH_NDIM) = 0.0_rk
|
||||
real(rk) :: neighbor_cell_size = 1.0_rk
|
||||
integer :: neighbor_cell_dims(SPH_NDIM) = 1
|
||||
integer :: neighbor_num_cells = 1
|
||||
integer :: neighbor_total_links = 0
|
||||
|
||||
contains
|
||||
|
||||
subroutine sph_neighbor_rebuild(ierr)
|
||||
integer, intent(out) :: ierr
|
||||
integer :: max_links
|
||||
|
||||
max_links = npart * npart
|
||||
call sph_neighbor_rebuild_with_capacity(max_links, ierr)
|
||||
end subroutine sph_neighbor_rebuild
|
||||
|
||||
subroutine sph_neighbor_rebuild_with_capacity(max_links, ierr)
|
||||
integer, intent(in) :: max_links
|
||||
integer, intent(out) :: ierr
|
||||
integer :: i
|
||||
integer :: c
|
||||
|
||||
ierr = SPH_SUCCESS
|
||||
neighbor_total_links = 0
|
||||
if (npart <= 0) then
|
||||
call sph_db_allocate_neighbor_storage(0, 0, ierr)
|
||||
return
|
||||
end if
|
||||
if (max_links < 0) then
|
||||
call sph_error_set(SPH_ERROR_ARGUMENT, 'neighbor capacity must be non-negative')
|
||||
ierr = SPH_ERROR_ARGUMENT
|
||||
return
|
||||
end if
|
||||
call sph_neighbor_compute_bounds(ierr)
|
||||
if (ierr /= SPH_SUCCESS) return
|
||||
call sph_neighbor_compute_cells(ierr)
|
||||
if (ierr /= SPH_SUCCESS) return
|
||||
call sph_db_allocate_neighbor_storage(max_links, neighbor_num_cells, ierr)
|
||||
if (ierr /= SPH_SUCCESS) return
|
||||
do i = 1, npart
|
||||
c = sph_neighbor_cell_index_for_particle(i)
|
||||
particle_cell_id(i) = c
|
||||
cell_next(i) = cell_head(c)
|
||||
cell_head(c) = i
|
||||
neighbor_count(i) = 0
|
||||
neighbor_offset(i) = neighbor_total_links + 1
|
||||
end do
|
||||
call sph_neighbor_fill_links(max_links, ierr)
|
||||
end subroutine sph_neighbor_rebuild_with_capacity
|
||||
|
||||
subroutine sph_neighbor_compute_bounds(ierr)
|
||||
integer, intent(out) :: ierr
|
||||
integer :: d
|
||||
real(rk) :: support
|
||||
real(rk) :: max_support
|
||||
|
||||
ierr = SPH_SUCCESS
|
||||
max_support = 0.0_rk
|
||||
neighbor_min_corner = x(:,1)
|
||||
neighbor_max_corner = x(:,1)
|
||||
do d = 1, SPH_NDIM
|
||||
neighbor_min_corner(d) = minval(x(d,1:npart))
|
||||
neighbor_max_corner(d) = maxval(x(d,1:npart))
|
||||
end do
|
||||
do d = 1, npart
|
||||
call sph_kernel_support_radius(SPH_KERNEL_DEFAULT, h(d), support, ierr)
|
||||
if (ierr /= SPH_SUCCESS) return
|
||||
if (support > max_support) max_support = support
|
||||
end do
|
||||
if (max_support <= 0.0_rk) then
|
||||
call sph_error_set(SPH_ERROR_ARGUMENT, 'neighbor support radius must be positive')
|
||||
ierr = SPH_ERROR_ARGUMENT
|
||||
return
|
||||
end if
|
||||
neighbor_cell_size = max_support
|
||||
neighbor_min_corner = neighbor_min_corner - neighbor_cell_size
|
||||
neighbor_max_corner = neighbor_max_corner + neighbor_cell_size
|
||||
end subroutine sph_neighbor_compute_bounds
|
||||
|
||||
subroutine sph_neighbor_compute_cells(ierr)
|
||||
integer, intent(out) :: ierr
|
||||
integer :: d
|
||||
real(rk) :: extent
|
||||
|
||||
ierr = SPH_SUCCESS
|
||||
neighbor_num_cells = 1
|
||||
do d = 1, SPH_NDIM
|
||||
extent = neighbor_max_corner(d) - neighbor_min_corner(d)
|
||||
neighbor_cell_dims(d) = int(extent / neighbor_cell_size) + 1
|
||||
if (neighbor_cell_dims(d) < 1) neighbor_cell_dims(d) = 1
|
||||
neighbor_num_cells = neighbor_num_cells * neighbor_cell_dims(d)
|
||||
end do
|
||||
end subroutine sph_neighbor_compute_cells
|
||||
|
||||
integer function sph_neighbor_cell_index_for_particle(i)
|
||||
integer, intent(in) :: i
|
||||
integer :: ix
|
||||
integer :: iy
|
||||
integer :: iz
|
||||
|
||||
ix = sph_neighbor_cell_coord(x(1,i), 1)
|
||||
iy = sph_neighbor_cell_coord(x(2,i), 2)
|
||||
iz = sph_neighbor_cell_coord(x(3,i), 3)
|
||||
sph_neighbor_cell_index_for_particle = ix + neighbor_cell_dims(1) * &
|
||||
(iy - 1 + neighbor_cell_dims(2) * (iz - 1))
|
||||
end function sph_neighbor_cell_index_for_particle
|
||||
|
||||
integer function sph_neighbor_cell_coord(value, dim)
|
||||
real(rk), intent(in) :: value
|
||||
integer, intent(in) :: dim
|
||||
|
||||
sph_neighbor_cell_coord = int((value - neighbor_min_corner(dim)) / neighbor_cell_size) + 1
|
||||
if (sph_neighbor_cell_coord < 1) sph_neighbor_cell_coord = 1
|
||||
if (sph_neighbor_cell_coord > neighbor_cell_dims(dim)) then
|
||||
sph_neighbor_cell_coord = neighbor_cell_dims(dim)
|
||||
end if
|
||||
end function sph_neighbor_cell_coord
|
||||
|
||||
subroutine sph_neighbor_fill_links(max_links, ierr)
|
||||
integer, intent(in) :: max_links
|
||||
integer, intent(out) :: ierr
|
||||
integer :: i
|
||||
integer :: ix
|
||||
integer :: iy
|
||||
integer :: iz
|
||||
integer :: dx
|
||||
integer :: dy
|
||||
integer :: dz
|
||||
integer :: cx
|
||||
integer :: cy
|
||||
integer :: cz
|
||||
integer :: cell
|
||||
integer :: j
|
||||
|
||||
ierr = SPH_SUCCESS
|
||||
do i = 1, npart
|
||||
call sph_neighbor_decode_cell(particle_cell_id(i), ix, iy, iz)
|
||||
do dz = -1, 1
|
||||
cz = iz + dz
|
||||
if (cz < 1 .or. cz > neighbor_cell_dims(3)) cycle
|
||||
do dy = -1, 1
|
||||
cy = iy + dy
|
||||
if (cy < 1 .or. cy > neighbor_cell_dims(2)) cycle
|
||||
do dx = -1, 1
|
||||
cx = ix + dx
|
||||
if (cx < 1 .or. cx > neighbor_cell_dims(1)) cycle
|
||||
cell = cx + neighbor_cell_dims(1) * &
|
||||
(cy - 1 + neighbor_cell_dims(2) * (cz - 1))
|
||||
j = cell_head(cell)
|
||||
do while (j > 0)
|
||||
if (j /= i) call sph_neighbor_try_add(i, j, max_links, ierr)
|
||||
if (ierr /= SPH_SUCCESS) return
|
||||
j = cell_next(j)
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
end subroutine sph_neighbor_fill_links
|
||||
|
||||
subroutine sph_neighbor_decode_cell(cell, ix, iy, iz)
|
||||
integer, intent(in) :: cell
|
||||
integer, intent(out) :: ix
|
||||
integer, intent(out) :: iy
|
||||
integer, intent(out) :: iz
|
||||
integer :: rest
|
||||
|
||||
rest = cell - 1
|
||||
ix = mod(rest, neighbor_cell_dims(1)) + 1
|
||||
rest = rest / neighbor_cell_dims(1)
|
||||
iy = mod(rest, neighbor_cell_dims(2)) + 1
|
||||
iz = rest / neighbor_cell_dims(2) + 1
|
||||
end subroutine sph_neighbor_decode_cell
|
||||
|
||||
subroutine sph_neighbor_try_add(i, j, max_links, ierr)
|
||||
integer, intent(in) :: i
|
||||
integer, intent(in) :: j
|
||||
integer, intent(in) :: max_links
|
||||
integer, intent(out) :: ierr
|
||||
real(rk) :: rij(SPH_NDIM)
|
||||
real(rk) :: distance
|
||||
real(rk) :: radius
|
||||
|
||||
ierr = SPH_SUCCESS
|
||||
rij = x(:,i) - x(:,j)
|
||||
distance = sqrt(sum(rij * rij))
|
||||
radius = 2.0_rk * max(h(i), h(j))
|
||||
if (distance > radius) return
|
||||
if (neighbor_total_links >= max_links) then
|
||||
call sph_error_set(SPH_ERROR_ARGUMENT, 'neighbor table capacity is too small')
|
||||
ierr = SPH_ERROR_ARGUMENT
|
||||
return
|
||||
end if
|
||||
neighbor_total_links = neighbor_total_links + 1
|
||||
neighbor_list(neighbor_total_links) = j
|
||||
neighbor_count(i) = neighbor_count(i) + 1
|
||||
end subroutine sph_neighbor_try_add
|
||||
|
||||
subroutine sph_neighbor_get_stats(max_neighbors, average_neighbors, ierr)
|
||||
integer, intent(out) :: max_neighbors
|
||||
real(rk), intent(out) :: average_neighbors
|
||||
integer, intent(out) :: ierr
|
||||
|
||||
ierr = SPH_SUCCESS
|
||||
max_neighbors = 0
|
||||
average_neighbors = 0.0_rk
|
||||
if (npart <= 0) return
|
||||
max_neighbors = maxval(neighbor_count(1:npart))
|
||||
average_neighbors = real(sum(neighbor_count(1:npart)), rk) / real(npart, rk)
|
||||
end subroutine sph_neighbor_get_stats
|
||||
|
||||
end module sph_neighbor
|
||||
Reference in New Issue
Block a user