429 lines
9.7 KiB
Fortran
429 lines
9.7 KiB
Fortran
|
|
subroutine create_selection_buffer(N, size_in, res)
|
|
use selection_types
|
|
implicit none
|
|
BEGIN_DOC
|
|
! Allocates the memory for a selection buffer.
|
|
! The arrays have dimension size_in and the maximum number of elements is N
|
|
END_DOC
|
|
|
|
integer, intent(in) :: N, size_in
|
|
type(selection_buffer), intent(out) :: res
|
|
|
|
integer :: siz
|
|
siz = max(size_in,1)
|
|
|
|
double precision :: rss
|
|
double precision, external :: memory_of_double
|
|
rss = memory_of_double(siz)*(N_int*2+1)
|
|
call check_mem(rss,irp_here)
|
|
|
|
allocate(res%det(N_int, 2, siz), res%val(siz))
|
|
|
|
res%val(:) = 0d0
|
|
res%det(:,:,:) = 0_8
|
|
res%N = N
|
|
res%mini = 0d0
|
|
res%cur = 0
|
|
end subroutine
|
|
|
|
subroutine delete_selection_buffer(b)
|
|
use selection_types
|
|
implicit none
|
|
type(selection_buffer), intent(inout) :: b
|
|
if (associated(b%det)) then
|
|
deallocate(b%det)
|
|
endif
|
|
if (associated(b%val)) then
|
|
deallocate(b%val)
|
|
endif
|
|
NULLIFY(b%det)
|
|
NULLIFY(b%val)
|
|
b%cur = 0
|
|
b%mini = 0.d0
|
|
b%N = 0
|
|
end
|
|
|
|
|
|
subroutine add_to_selection_buffer(b, det, val)
|
|
use selection_types
|
|
implicit none
|
|
|
|
type(selection_buffer), intent(inout) :: b
|
|
integer(bit_kind), intent(in) :: det(N_int, 2)
|
|
double precision, intent(in) :: val
|
|
integer :: i
|
|
|
|
if(b%N > 0 .and. val <= b%mini) then
|
|
b%cur += 1
|
|
b%det(1:N_int,1:2,b%cur) = det(1:N_int,1:2)
|
|
b%val(b%cur) = val
|
|
if(b%cur == size(b%val)) then
|
|
call sort_selection_buffer(b)
|
|
b%cur = b%cur-1
|
|
end if
|
|
end if
|
|
end subroutine
|
|
|
|
subroutine merge_selection_buffers(b1, b2)
|
|
use selection_types
|
|
implicit none
|
|
BEGIN_DOC
|
|
! Merges the selection buffers b1 and b2 into b2
|
|
END_DOC
|
|
type(selection_buffer), intent(inout) :: b1
|
|
type(selection_buffer), intent(inout) :: b2
|
|
integer(bit_kind), pointer :: detmp(:,:,:)
|
|
double precision, pointer :: val(:)
|
|
integer :: i, i1, i2, k, nmwen, sze
|
|
if (b1%cur == 0) return
|
|
do while (b1%val(b1%cur) > b2%mini)
|
|
b1%cur = b1%cur-1
|
|
if (b1%cur == 0) then
|
|
return
|
|
endif
|
|
enddo
|
|
nmwen = min(b1%N, b1%cur+b2%cur)
|
|
double precision :: rss
|
|
double precision, external :: memory_of_double
|
|
sze = max(size(b1%val), size(b2%val))
|
|
! rss = memory_of_double(sze) + 2*N_int*memory_of_double(sze)
|
|
! call check_mem(rss,irp_here)
|
|
allocate(val(sze), detmp(N_int, 2, sze))
|
|
i1=1
|
|
i2=1
|
|
|
|
select case (N_int)
|
|
BEGIN_TEMPLATE
|
|
case $case
|
|
do i=1,nmwen
|
|
if ( (i1 > b1%cur).and.(i2 > b2%cur) ) then
|
|
exit
|
|
else if (i1 > b1%cur) then
|
|
val(i) = b2%val(i2)
|
|
detmp(1:$N_int,1,i) = b2%det(1:$N_int,1,i2)
|
|
detmp(1:$N_int,2,i) = b2%det(1:$N_int,2,i2)
|
|
i2=i2+1
|
|
else if (i2 > b2%cur) then
|
|
val(i) = b1%val(i1)
|
|
detmp(1:$N_int,1,i) = b1%det(1:$N_int,1,i1)
|
|
detmp(1:$N_int,2,i) = b1%det(1:$N_int,2,i1)
|
|
i1=i1+1
|
|
else
|
|
if (b1%val(i1) <= b2%val(i2)) then
|
|
val(i) = b1%val(i1)
|
|
detmp(1:$N_int,1,i) = b1%det(1:$N_int,1,i1)
|
|
detmp(1:$N_int,2,i) = b1%det(1:$N_int,2,i1)
|
|
i1=i1+1
|
|
else
|
|
val(i) = b2%val(i2)
|
|
detmp(1:$N_int,1,i) = b2%det(1:$N_int,1,i2)
|
|
detmp(1:$N_int,2,i) = b2%det(1:$N_int,2,i2)
|
|
i2=i2+1
|
|
endif
|
|
endif
|
|
enddo
|
|
do i=nmwen+1,b2%N
|
|
val(i) = 0.d0
|
|
! detmp(1:$N_int,1,i) = 0_bit_kind
|
|
! detmp(1:$N_int,2,i) = 0_bit_kind
|
|
enddo
|
|
SUBST [ case, N_int ]
|
|
(1); 1;;
|
|
(2); 2;;
|
|
(3); 3;;
|
|
(4); 4;;
|
|
default; N_int;;
|
|
END_TEMPLATE
|
|
end select
|
|
deallocate(b2%det, b2%val)
|
|
b2%det => detmp
|
|
b2%val => val
|
|
b2%mini = min(b2%mini,b2%val(b2%N))
|
|
b2%cur = nmwen
|
|
end
|
|
|
|
|
|
subroutine sort_selection_buffer(b)
|
|
use selection_types
|
|
implicit none
|
|
|
|
type(selection_buffer), intent(inout) :: b
|
|
integer, allocatable :: iorder(:)
|
|
integer(bit_kind), pointer :: detmp(:,:,:)
|
|
integer :: i, nmwen
|
|
logical, external :: detEq
|
|
if (b%N == 0 .or. b%cur == 0) return
|
|
nmwen = min(b%N, b%cur)
|
|
|
|
double precision :: rss
|
|
double precision, external :: memory_of_double, memory_of_int
|
|
! rss = memory_of_int(b%cur) + 2*N_int*memory_of_double(size(b%det,3))
|
|
! call check_mem(rss,irp_here)
|
|
allocate(iorder(b%cur), detmp(N_int, 2, size(b%det,3)))
|
|
do i=1,b%cur
|
|
iorder(i) = i
|
|
end do
|
|
call dsort(b%val, iorder, b%cur)
|
|
do i=1, nmwen
|
|
detmp(1:N_int,1,i) = b%det(1:N_int,1,iorder(i))
|
|
detmp(1:N_int,2,i) = b%det(1:N_int,2,iorder(i))
|
|
end do
|
|
deallocate(b%det,iorder)
|
|
b%det => detmp
|
|
b%mini = min(b%mini,b%val(b%N))
|
|
b%cur = nmwen
|
|
end subroutine
|
|
|
|
subroutine make_selection_buffer_s2(b)
|
|
use selection_types
|
|
type(selection_buffer), intent(inout) :: b
|
|
|
|
integer(bit_kind), allocatable :: o(:,:,:)
|
|
double precision, allocatable :: val(:)
|
|
|
|
integer :: n_d
|
|
integer :: i,k,sze,n_alpha,j,n
|
|
logical :: dup
|
|
|
|
! Sort
|
|
integer, allocatable :: iorder(:)
|
|
integer*8, allocatable :: bit_tmp(:)
|
|
integer*8, external :: configuration_search_key
|
|
integer(bit_kind), allocatable :: tmp_array(:,:,:)
|
|
logical, allocatable :: duplicate(:)
|
|
|
|
n_d = b%cur
|
|
double precision :: rss
|
|
double precision, external :: memory_of_double
|
|
rss = (4*N_int+4)*memory_of_double(n_d)
|
|
call check_mem(rss,irp_here)
|
|
allocate(o(N_int,2,n_d), iorder(n_d), duplicate(n_d), bit_tmp(n_d), &
|
|
tmp_array(N_int,2,n_d), val(n_d) )
|
|
|
|
do i=1,n_d
|
|
do k=1,N_int
|
|
o(k,1,i) = ieor(b%det(k,1,i), b%det(k,2,i))
|
|
o(k,2,i) = iand(b%det(k,1,i), b%det(k,2,i))
|
|
enddo
|
|
iorder(i) = i
|
|
bit_tmp(i) = configuration_search_key(o(1,1,i),N_int)
|
|
enddo
|
|
|
|
deallocate(b%det)
|
|
|
|
call i8sort(bit_tmp,iorder,n_d)
|
|
|
|
do i=1,n_d
|
|
do k=1,N_int
|
|
tmp_array(k,1,i) = o(k,1,iorder(i))
|
|
tmp_array(k,2,i) = o(k,2,iorder(i))
|
|
enddo
|
|
val(i) = b%val(iorder(i))
|
|
duplicate(i) = .False.
|
|
enddo
|
|
|
|
! Find duplicates
|
|
do i=1,n_d-1
|
|
if (duplicate(i)) then
|
|
cycle
|
|
endif
|
|
j = i+1
|
|
do while (bit_tmp(j)==bit_tmp(i))
|
|
if (duplicate(j)) then
|
|
j+=1
|
|
if (j>n_d) then
|
|
exit
|
|
endif
|
|
cycle
|
|
endif
|
|
dup = .True.
|
|
do k=1,N_int
|
|
if ( (tmp_array(k,1,i) /= tmp_array(k,1,j)) .or. &
|
|
(tmp_array(k,2,i) /= tmp_array(k,2,j)) ) then
|
|
dup = .False.
|
|
exit
|
|
endif
|
|
enddo
|
|
if (dup) then
|
|
val(i) = min(val(i), val(j))
|
|
duplicate(j) = .True.
|
|
endif
|
|
j+=1
|
|
if (j>n_d) then
|
|
exit
|
|
endif
|
|
enddo
|
|
enddo
|
|
|
|
deallocate (b%val)
|
|
! Copy filtered result
|
|
integer :: n_p
|
|
n_p=0
|
|
do i=1,n_d
|
|
if (duplicate(i)) then
|
|
cycle
|
|
endif
|
|
n_p = n_p + 1
|
|
do k=1,N_int
|
|
o(k,1,n_p) = tmp_array(k,1,i)
|
|
o(k,2,n_p) = tmp_array(k,2,i)
|
|
enddo
|
|
val(n_p) = val(i)
|
|
enddo
|
|
|
|
! Sort by importance
|
|
do i=1,n_p
|
|
iorder(i) = i
|
|
end do
|
|
call dsort(val,iorder,n_p)
|
|
do i=1,n_p
|
|
do k=1,N_int
|
|
tmp_array(k,1,i) = o(k,1,iorder(i))
|
|
tmp_array(k,2,i) = o(k,2,iorder(i))
|
|
enddo
|
|
enddo
|
|
do i=1,n_p
|
|
do k=1,N_int
|
|
o(k,1,i) = tmp_array(k,1,i)
|
|
o(k,2,i) = tmp_array(k,2,i)
|
|
enddo
|
|
enddo
|
|
|
|
! Create determinants
|
|
n_d = 0
|
|
do i=1,n_p
|
|
call configuration_to_dets_size(o(1,1,i),sze,elec_alpha_num,N_int)
|
|
n_d = n_d + sze
|
|
if (n_d > b%cur) then
|
|
exit
|
|
endif
|
|
enddo
|
|
|
|
rss = (4*N_int+2)*memory_of_double(n_d)
|
|
call check_mem(rss,irp_here)
|
|
allocate(b%det(N_int,2,2*n_d), b%val(2*n_d))
|
|
k=1
|
|
do i=1,n_p
|
|
n=n_d
|
|
call configuration_to_dets_size(o(1,1,i),n,elec_alpha_num,N_int)
|
|
call configuration_to_dets(o(1,1,i),b%det(1,1,k),n,elec_alpha_num,N_int)
|
|
do j=k,k+n-1
|
|
b%val(j) = val(i)
|
|
enddo
|
|
k = k+n
|
|
if (k > n_d) exit
|
|
enddo
|
|
deallocate(o)
|
|
b%cur = n_d
|
|
b%N = n_d
|
|
end
|
|
|
|
|
|
|
|
|
|
subroutine remove_duplicates_in_selection_buffer(b)
|
|
use selection_types
|
|
type(selection_buffer), intent(inout) :: b
|
|
|
|
integer(bit_kind), allocatable :: o(:,:,:)
|
|
double precision, allocatable :: val(:)
|
|
|
|
integer :: n_d
|
|
integer :: i,k,sze,n_alpha,j,n
|
|
logical :: dup
|
|
|
|
! Sort
|
|
integer, allocatable :: iorder(:)
|
|
integer*8, allocatable :: bit_tmp(:)
|
|
integer*8, external :: det_search_key
|
|
integer(bit_kind), allocatable :: tmp_array(:,:,:)
|
|
logical, allocatable :: duplicate(:)
|
|
|
|
logical :: found_duplicates
|
|
double precision :: rss
|
|
double precision, external :: memory_of_double
|
|
|
|
n_d = b%cur
|
|
rss = (4*N_int+4)*memory_of_double(n_d)
|
|
call check_mem(rss,irp_here)
|
|
|
|
found_duplicates = .False.
|
|
allocate(iorder(n_d), duplicate(n_d), bit_tmp(n_d), &
|
|
tmp_array(N_int,2,n_d), val(n_d) )
|
|
|
|
do i=1,n_d
|
|
iorder(i) = i
|
|
bit_tmp(i) = det_search_key(b%det(1,1,i),N_int)
|
|
enddo
|
|
|
|
call i8sort(bit_tmp,iorder,n_d)
|
|
|
|
do i=1,n_d
|
|
do k=1,N_int
|
|
tmp_array(k,1,i) = b%det(k,1,iorder(i))
|
|
tmp_array(k,2,i) = b%det(k,2,iorder(i))
|
|
enddo
|
|
val(i) = b%val(iorder(i))
|
|
duplicate(i) = .False.
|
|
enddo
|
|
|
|
! Find duplicates
|
|
do i=1,n_d-1
|
|
if (duplicate(i)) then
|
|
cycle
|
|
endif
|
|
j = i+1
|
|
do while (bit_tmp(j)==bit_tmp(i))
|
|
if (duplicate(j)) then
|
|
j+=1
|
|
if (j>n_d) then
|
|
exit
|
|
endif
|
|
cycle
|
|
endif
|
|
dup = .True.
|
|
do k=1,N_int
|
|
if ( (tmp_array(k,1,i) /= tmp_array(k,1,j)) &
|
|
.or. (tmp_array(k,2,i) /= tmp_array(k,2,j)) ) then
|
|
dup = .False.
|
|
exit
|
|
endif
|
|
enddo
|
|
if (dup) then
|
|
duplicate(j) = .True.
|
|
found_duplicates = .True.
|
|
endif
|
|
j+=1
|
|
if (j>n_d) then
|
|
exit
|
|
endif
|
|
enddo
|
|
enddo
|
|
|
|
if (found_duplicates) then
|
|
|
|
! Copy filtered result
|
|
integer :: n_p
|
|
n_p=0
|
|
do i=1,n_d
|
|
if (duplicate(i)) then
|
|
cycle
|
|
endif
|
|
n_p = n_p + 1
|
|
do k=1,N_int
|
|
b%det(k,1,n_p) = tmp_array(k,1,i)
|
|
b%det(k,2,n_p) = tmp_array(k,2,i)
|
|
enddo
|
|
val(n_p) = val(i)
|
|
enddo
|
|
b%cur=n_p
|
|
b%N=n_p
|
|
|
|
endif
|
|
|
|
end
|
|
|
|
|
|
|