You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
239 lines
9.2 KiB
239 lines
9.2 KiB
module neighbors
|
|
|
|
use parameters
|
|
use elements
|
|
use subroutines
|
|
use functions
|
|
use box
|
|
|
|
integer, allocatable :: nei_list(:,:), nei_num(:), nn(:), periodvec(:,:,:)
|
|
real(kind=dp), allocatable :: init_vec(:,:,:), output(:), microrotation(:,:)
|
|
public
|
|
|
|
contains
|
|
|
|
subroutine build_cell_list(numinlist, r_list, rc_off, cell_num, num_in_cell, cell_list, which_cell)
|
|
!This subroutine builds a cell list based on rc_off
|
|
|
|
!----------------------------------------Input/output variables-------------------------------------------
|
|
|
|
integer, intent(in) :: numinlist !The number of points within r_list
|
|
|
|
real(kind=dp), dimension(3,numinlist), intent(in) :: r_list !List of points to be used for the construction of
|
|
!the cell list.
|
|
|
|
real(kind=dp), intent(in) :: rc_off ! Cutoff radius which dictates the size of the cells
|
|
|
|
integer, dimension(3), intent(inout) :: cell_num !Number of cells in each dimension.
|
|
|
|
integer, allocatable, intent(inout) :: num_in_cell(:,:,:) !Number of points within each cell
|
|
|
|
integer, allocatable, intent(inout) :: cell_list(:,:,:,:) !Index of points from r_list within each cell.
|
|
|
|
integer, dimension(3,numinlist), intent(out) :: which_cell !The cell index for each point in r_list
|
|
|
|
!----------------------------------------Begin Subroutine -------------------------------------------
|
|
|
|
integer :: i, j, cell_lim, c(3)
|
|
real(kind=dp) :: box_len(3)
|
|
integer, allocatable :: resize_cell_list(:,:,:,:)
|
|
|
|
!First calculate the number of cells that we need in each dimension
|
|
do i = 1,3
|
|
box_len(i) = box_bd(2*i) - box_bd(2*i-1)
|
|
cell_num(i) = int(box_len(i)/(rc_off/2))+1
|
|
end do
|
|
|
|
!Initialize/allocate variables
|
|
cell_lim = 10
|
|
allocate(num_in_cell(cell_num(1),cell_num(2),cell_num(3)), cell_list(cell_lim, cell_num(1), cell_num(2), cell_num(3)))
|
|
|
|
!Now place points within cell
|
|
num_in_cell = 0
|
|
|
|
do i = 1, numinlist
|
|
!Check to see if the current point is a filler point and if so just skip it
|
|
if(r_list(1,i) < box_bd(1)) cycle
|
|
|
|
!c is the position of the cell that the point belongs to
|
|
do j = 1, 3
|
|
c(j) = int((r_list(j,i)-box_bd(2*j-1))/(rc_off)) + 1
|
|
end do
|
|
|
|
!Place the index in the correct position, growing if necessary
|
|
num_in_cell(c(1),c(2),c(3)) = num_in_cell(c(1),c(2),c(3)) + 1
|
|
if (num_in_cell(c(1),c(2),c(3)) > cell_lim) then
|
|
allocate(resize_cell_list(cell_lim+10,cell_num(1),cell_num(2),cell_num(3)))
|
|
resize_cell_list(1:cell_lim, :, :, :) = cell_list(1:cell_lim, :, :, :)
|
|
resize_cell_list(cell_lim+1:, :, :, :) = 0
|
|
call move_alloc(resize_cell_list, cell_list)
|
|
cell_lim = cell_lim + 10
|
|
end if
|
|
|
|
cell_list(num_in_cell(c(1),c(2),c(3)),c(1),c(2),c(3)) = i
|
|
which_cell(:,i) = c
|
|
end do
|
|
|
|
return
|
|
end subroutine build_cell_list
|
|
|
|
subroutine calc_neighbor(rc_off, r_list, n)
|
|
!This function populates the neighbor list in this module
|
|
|
|
real(kind=dp), intent(in) :: rc_off
|
|
integer, intent(in) :: n
|
|
real(kind=dp), dimension(3,n) :: r_list
|
|
|
|
integer :: i, j, c(3),cn(3), ci, cj, ck, num_nei, nei, v(3), period_dir(3)
|
|
!Variables for cell list code
|
|
integer, dimension(3) ::cell_num
|
|
integer, allocatable :: num_in_cell(:,:,:), cell_list(:,:,:,:)
|
|
integer :: which_cell(3,n)
|
|
real(kind=dp) :: r(3), box_len(3)
|
|
logical :: period_bd(3)
|
|
|
|
!First reallocate the neighbor list codes
|
|
if (allocated(nei_list)) then
|
|
deallocate(nei_list,nei_num, periodvec)
|
|
end if
|
|
|
|
allocate(nei_list(100,n),nei_num(n), periodvec(3,100,n))
|
|
nei_list=0
|
|
periodvec=0
|
|
nei_num=0
|
|
|
|
!Now first pass the position list and and point num to the cell algorithm
|
|
call build_cell_list(n, r_list, rc_off, cell_num, num_in_cell, cell_list, which_cell)
|
|
|
|
do i=1, 3
|
|
if (box_bc(i:i) == 'p') then
|
|
period_bd(i) = .true.
|
|
else
|
|
period_bd(i)=.false.
|
|
end if
|
|
box_len(i) = box_bd(2*i) - box_bd(2*i-1)
|
|
end do
|
|
!Now loop over every point and find it's neighbors
|
|
pointloop: do i = 1, n
|
|
|
|
!First check to see if the point is a filler point, if so then skip it
|
|
if(r_list(1,i) < box_bd(1)) cycle
|
|
|
|
!c is the position of the cell that the point belongs to
|
|
c = which_cell(:,i)
|
|
|
|
!Loop over all neighboring cells
|
|
do ci = -1, 1, 1
|
|
do cj = -1, 1, 1
|
|
do ck = -1, 1, 1
|
|
!First try to apply periodic boundaries
|
|
v=(/ ck, cj, ci /)
|
|
cn=0
|
|
period_dir=0
|
|
do j=1, 3
|
|
if ((c(j) + v(j) == 0).and.period_bd(j)) then
|
|
cn(j) = cell_num(j)
|
|
period_dir(j) = 1
|
|
else if ((c(j) + v(j) > cell_num(j)).and.period_bd(j)) then
|
|
cn(j) = 1
|
|
period_dir(j) = -1
|
|
|
|
else if ((c(j)+v(j) >= 1) .and. (c(j)+v(j) <= cell_num(j))) then
|
|
cn(j) = c(j) + v(j)
|
|
end if
|
|
end do
|
|
if(any((c + (/ ck, cj, ci /)) == 0)) cycle
|
|
|
|
do num_nei = 1, num_in_cell(cn(1),cn(2),cn(3))
|
|
nei = cell_list(num_nei,cn(1),cn(2),cn(3))
|
|
|
|
!Check to make sure the atom isn't the same index as the atom we are checking
|
|
!and that the neighbor hasn't already been deleted
|
|
if((nei /= i)) then
|
|
|
|
!Now check to see if it is in the cutoff radius, if it is add it to the neighbor list for that
|
|
!atom and calculate the initial neighbor vector
|
|
|
|
r = r_list(:,nei) + period_dir*box_len
|
|
if (norm2(r-r_list(:,i)) < rc_off) then
|
|
|
|
nei_num(i) = nei_num(i) + 1
|
|
nei_list(nei_num(i), i) = nei
|
|
periodvec(:,nei_num(i),i) = period_dir
|
|
|
|
end if
|
|
end if
|
|
end do
|
|
end do
|
|
end do
|
|
end do
|
|
|
|
end do pointloop
|
|
|
|
return
|
|
end subroutine calc_neighbor
|
|
|
|
subroutine calc_NN(n,points, rc_off)
|
|
|
|
integer, intent(in) :: n
|
|
real(kind=dp), intent(in) :: points(3,n)
|
|
real(kind=dp), intent(in) :: rc_off
|
|
|
|
integer :: i, c(3), ci, cj, ck, nei
|
|
!cell arrays
|
|
integer, dimension(3) ::cell_num
|
|
integer, allocatable :: num_in_cell(:,:,:), cell_list(:,:,:,:)
|
|
integer :: which_cell(3,n)
|
|
real(kind = dp) :: rmin
|
|
|
|
!First reallocate the neighbor list codes
|
|
if (allocated(nn)) then
|
|
deallocate(nn)
|
|
end if
|
|
|
|
allocate(nn(n))
|
|
nn=0
|
|
|
|
!First build the cell lists
|
|
call build_cell_list(n, points, rc_off, cell_num, num_in_cell, cell_list, which_cell)
|
|
|
|
pointloop: do i = 1, n
|
|
!First check to see if the point is a filler point, if so then skip it
|
|
if(points(1,i) < -Huge(-1.0_dp)+1) cycle
|
|
|
|
!Get the positon of the cell
|
|
c = which_cell(:,i)
|
|
|
|
!Initialize the min vec
|
|
rmin=rc_off
|
|
|
|
!loop over all neighboring cells
|
|
do ci = -1, 1, 1
|
|
do cj = -1, 1, 1
|
|
do ck = -1, 1, 1
|
|
if(any((c + (/ ck, cj, ci /)) == 0)) cycle
|
|
if( (c(1) + ck > cell_num(1)).or.(c(2) + cj > cell_num(2)).or. (c(3) + ci > cell_num(3))) cycle
|
|
|
|
do num_nei = 1, num_in_cell(c(1) + ck, c(2) + cj, c(3) + ci)
|
|
nei = cell_list(num_nei,c(1) + ck, c(2) + cj, c(3) + ci)
|
|
|
|
!Check to make sure the atom isn't the same index as the atom we are checking
|
|
if((nei /= i)) then
|
|
!If it's the minimum position than we add it to the nearest neighbor list and updat e the min vec
|
|
|
|
if (norm2(points(:,nei)-points(:,i)) < rmin) then
|
|
rmin = norm2(points(:, nei) - points(:,i))
|
|
nn(i)=(nei)
|
|
end if
|
|
end if
|
|
end do
|
|
end do
|
|
end do
|
|
end do
|
|
end do pointloop
|
|
|
|
return
|
|
end subroutine calc_NN
|
|
|
|
end module neighbors
|