subroutine SendProcExcDjs()
! In this routine the excitations are sent to the relevant processors.
! Sent with them will be the Di they were excited from and its sign.
! Each processor will receive nProcessor number of lists with different
! Di determinants. The original Di's will (I think) still be in the
! original InitSingExcSlots positions. This follows the
! directannihilation algorithm closely.
use LoggingData, only: RDMExcitLevel
use Parallel_neci, only: nProcessors, MPIArg, MPIAlltoAll, MPIAlltoAllv
use rdm_data, only: Sing_ExcList, Doub_ExcList, OneEl_Gap, TwoEl_Gap
use rdm_data, only: Sing_ExcDjs, Doub_ExcDjs, Sing_ExcDjs2, Doub_ExcDjs2
integer :: i, j
integer :: error, MaxSendIndex, MaxIndex
integer(MPIArg) :: sendcounts(nProcessors), disps(nProcessors)
integer(MPIArg) :: sing_recvcounts(nProcessors)
integer(MPIArg) :: sing_recvdisps(nProcessors)
integer(MPIArg) :: doub_recvcounts(nProcessors), doub_recvdisps(nProcessors)
do i = 0, nProcessors - 1
! Sendcounts is the number of singly excited determinants we want
! to send for each processor (but goes from 1, not 0).
sendcounts(i + 1) = int(Sing_ExcList(i) - (nint(OneEl_Gap * i) + 1), MPIArg)
! disps is the first slot for each processor - 1.
disps(i + 1) = nint(OneEl_Gap * i, MPIArg)
end do
MaxSendIndex = Sing_ExcList(nProcessors - 1) - 1
! We now need to calculate the recvcounts and recvdisps -
! this is a job for AlltoAll
sing_recvcounts(1:nProcessors) = 0
call MPIAlltoAll(sendcounts, 1, sing_recvcounts, 1, error)
! We can now get recvdisps from recvcounts, since we want the data to
! be contiguous after the move.
sing_recvdisps(1) = 0
do i = 2, nProcessors
sing_recvdisps(i) = sing_recvdisps(i - 1) + sing_recvcounts(i - 1)
end do
MaxIndex = sing_recvdisps(nProcessors) + sing_recvcounts(nProcessors)
! But the actual number of integers we need to send is the calculated
! values * NIfTot+1.
do i = 1, nProcessors
sendcounts(i) = sendcounts(i) * (int(NIfTot + 1, MPIArg))
disps(i) = disps(i) * (int(NIfTot + 1, MPIArg))
sing_recvcounts(i) = sing_recvcounts(i) * (int(NIfTot + 1, MPIArg))
sing_recvdisps(i) = sing_recvdisps(i) * (int(NIfTot + 1, MPIArg))
end do
#ifdef USE_MPI
call MPIAlltoAllv(Sing_ExcDjs(:, 1:MaxSendIndex), sendcounts, disps, &
Sing_ExcDjs2, sing_recvcounts, sing_recvdisps, error)
#else
Sing_ExcDjs2(0:NIfTot, 1:MaxIndex) = Sing_ExcDjs(0:NIfTot, 1:MaxSendIndex)
#endif
call Sing_SearchOccDets(sing_recvcounts, sing_recvdisps)
if (RDMExcitLevel /= 1) then
do i = 0, nProcessors - 1
! Sendcounts is the number of singly excited determinants we
! want to send for each processor (but goes from 1, not 0).
sendcounts(i + 1) = int(Doub_ExcList(i) - (nint(TwoEl_Gap * i) + 1), MPIArg)
! disps is the first slot for each processor - 1.
disps(i + 1) = nint(TwoEl_Gap * i, MPIArg)
end do
MaxSendIndex = Doub_ExcList(nProcessors - 1) - 1
! We now need to calculate the recvcounts and recvdisps -
! this is a job for AlltoAll
doub_recvcounts(1:nProcessors) = 0
call MPIAlltoAll(sendcounts, 1, doub_recvcounts, 1, error)
! We can now get recvdisps from recvcounts, since we want the data
! to be contiguous after the move.
doub_recvdisps(1) = 0
do i = 2, nProcessors
doub_recvdisps(i) = doub_recvdisps(i - 1) + doub_recvcounts(i - 1)
end do
MaxIndex = doub_recvdisps(nProcessors) + doub_recvcounts(nProcessors)
! But the actual number of integers we need to send is the
! calculated values * NIfTot+1.
do i = 1, nProcessors
sendcounts(i) = sendcounts(i) * (int(NIfTot + 1, MPIArg))
disps(i) = disps(i) * (int(NIfTot + 1, MPIArg))
doub_recvcounts(i) = doub_recvcounts(i) * (int(NIfTot + 1, MPIArg))
doub_recvdisps(i) = doub_recvdisps(i) * (int(NIfTot + 1, MPIArg))
end do
! This is the main send of all the single excitations to the
! corresponding processors.
#ifdef USE_MPI
call MPIAlltoAllv(Doub_ExcDjs(:, 1:MaxSendIndex), sendcounts, disps, &
Doub_ExcDjs2, doub_recvcounts, doub_recvdisps, error)
#else
Doub_ExcDjs2(0:NIfTot, 1:MaxIndex) = Doub_ExcDjs(0:NIfTot, 1:MaxSendIndex)
#endif
call Doub_SearchOccDets(doub_recvcounts, doub_recvdisps)
end if
end subroutine SendProcExcDjs