mirror of
https://github.com/LCPQ/quantum_package
synced 2024-11-03 20:54:00 +01:00
Merge branch 'develop' of github.com:scemama/quantum_package into develop
This commit is contained in:
commit
3747b3c2a8
@ -9,7 +9,7 @@
|
||||
FC : ifort
|
||||
LAPACK_LIB : -mkl=parallel
|
||||
IRPF90 : irpf90
|
||||
IRPF90_FLAGS : --ninja --align=32 -DZMQ_PUSH
|
||||
IRPF90_FLAGS : --ninja --align=32
|
||||
|
||||
# Global options
|
||||
################
|
||||
|
||||
@ -1,15 +0,0 @@
|
||||
#!/bin/bash -x
|
||||
|
||||
TARGET=gpi2
|
||||
#GPI_OPTIONS=--with-infiniband
|
||||
GPI_OPTIONS=--with-ethernet
|
||||
|
||||
function _install()
|
||||
{
|
||||
cd _build/gpi2
|
||||
./install.sh -p $QP_ROOT $GPI_OPTIONS
|
||||
cp src/GASPI.f90 $QP_ROOT/plugins/GPI2/
|
||||
return 0
|
||||
}
|
||||
|
||||
source scripts/build.sh
|
||||
@ -88,7 +88,7 @@ subroutine run_selection_slave(thread,iproc,energy)
|
||||
end do
|
||||
|
||||
integer, external :: disconnect_from_taskserver
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,zmq_socket_push,worker_id) == -1) then
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,worker_id) == -1) then
|
||||
continue
|
||||
endif
|
||||
|
||||
|
||||
@ -1,4 +1,11 @@
|
||||
program cis
|
||||
implicit none
|
||||
read_wf = .False.
|
||||
SOFT_TOUCH read_wf
|
||||
call run
|
||||
end
|
||||
|
||||
subroutine run
|
||||
implicit none
|
||||
integer :: i
|
||||
|
||||
|
||||
@ -29,10 +29,10 @@ size: (full_ci_zmq.n_iter)
|
||||
interface: ezfio
|
||||
doc: The energy without a pt2 correction for n_det
|
||||
type: double precision
|
||||
size: (full_ci_zmq.n_iter,determinants.n_states)
|
||||
size: (determinants.n_states,full_ci_zmq.n_iter)
|
||||
|
||||
[pt2_iter]
|
||||
interface: ezfio
|
||||
doc: The pt2 correction for n_det
|
||||
type: double precision
|
||||
size: (full_ci_zmq.n_iter,determinants.n_states)
|
||||
size: (determinants.n_states,full_ci_zmq.n_iter)
|
||||
|
||||
@ -112,6 +112,8 @@ program fci_zmq
|
||||
write(*,fmt) '# Excit. (eV)', ( (CI_energy(k)+pt2(k)-CI_energy(1)-pt2(1))*27.211396641308d0, &
|
||||
dsqrt(error(k)*error(k)+error(1)*error(1))*27.211396641308d0, k=1,N_states_p)
|
||||
endif
|
||||
write(fmt,*) '(''# ============'',', N_states_p, '(1X,''=============================''))'
|
||||
write(*,fmt)
|
||||
print *, ''
|
||||
|
||||
print *, 'N_det = ', N_det
|
||||
|
||||
246
plugins/Full_CI_ZMQ/fci_zmq_nos.irp.f
Normal file
246
plugins/Full_CI_ZMQ/fci_zmq_nos.irp.f
Normal file
@ -0,0 +1,246 @@
|
||||
program fci_zmq
|
||||
implicit none
|
||||
integer :: i,j,k
|
||||
double precision, allocatable :: pt2(:)
|
||||
integer :: degree
|
||||
integer :: n_det_before, to_select
|
||||
double precision :: threshold_davidson_in
|
||||
|
||||
allocate (pt2(N_states))
|
||||
|
||||
double precision :: hf_energy_ref
|
||||
logical :: has
|
||||
double precision :: relative_error, absolute_error
|
||||
integer :: N_states_p
|
||||
character*(512) :: fmt
|
||||
|
||||
relative_error=PT2_relative_error
|
||||
absolute_error=PT2_absolute_error
|
||||
|
||||
pt2 = -huge(1.e0)
|
||||
threshold_davidson_in = threshold_davidson
|
||||
threshold_davidson = threshold_davidson_in * 100.d0
|
||||
SOFT_TOUCH threshold_davidson
|
||||
|
||||
call diagonalize_CI
|
||||
call save_wavefunction
|
||||
|
||||
call ezfio_has_hartree_fock_energy(has)
|
||||
if (has) then
|
||||
call ezfio_get_hartree_fock_energy(hf_energy_ref)
|
||||
else
|
||||
hf_energy_ref = ref_bitmask_energy
|
||||
endif
|
||||
|
||||
if (N_det > N_det_max) then
|
||||
psi_det = psi_det_sorted
|
||||
psi_coef = psi_coef_sorted
|
||||
N_det = N_det_max
|
||||
soft_touch N_det psi_det psi_coef
|
||||
call diagonalize_CI
|
||||
call save_wavefunction
|
||||
N_states_p = min(N_det,N_states)
|
||||
endif
|
||||
|
||||
n_det_before = 0
|
||||
|
||||
character*(8) :: pt2_string
|
||||
double precision :: correlation_energy_ratio
|
||||
double precision :: threshold_selectors_save, threshold_generators_save
|
||||
threshold_selectors_save = threshold_selectors
|
||||
threshold_generators_save = threshold_generators
|
||||
double precision :: error(N_states)
|
||||
|
||||
correlation_energy_ratio = 0.d0
|
||||
|
||||
if (.True.) then ! Avoid pre-calculation of CI_energy
|
||||
do while ( &
|
||||
(N_det < N_det_max) .and. &
|
||||
(maxval(abs(pt2(1:N_states))) > pt2_max) .and. &
|
||||
(correlation_energy_ratio <= correlation_energy_ratio_max) &
|
||||
)
|
||||
write(*,'(A)') '--------------------------------------------------------------------------------'
|
||||
|
||||
|
||||
if (do_pt2) then
|
||||
pt2_string = ' '
|
||||
pt2 = 0.d0
|
||||
threshold_selectors = 1.d0
|
||||
threshold_generators = 1d0
|
||||
SOFT_TOUCH threshold_selectors threshold_generators
|
||||
call ZMQ_pt2(CI_energy, pt2,relative_error,absolute_error,error) ! Stochastic PT2
|
||||
threshold_selectors = threshold_selectors_save
|
||||
threshold_generators = threshold_generators_save
|
||||
SOFT_TOUCH threshold_selectors threshold_generators
|
||||
else
|
||||
pt2_string = '(approx)'
|
||||
endif
|
||||
|
||||
|
||||
correlation_energy_ratio = (CI_energy(1) - hf_energy_ref) / &
|
||||
(CI_energy(1) + pt2(1) - hf_energy_ref)
|
||||
correlation_energy_ratio = min(1.d0,correlation_energy_ratio)
|
||||
|
||||
N_states_p = min(N_det,N_states)
|
||||
|
||||
print *, ''
|
||||
print '(A,I12)', 'Summary at N_det = ', N_det
|
||||
print '(A)', '-----------------------------------'
|
||||
print *, ''
|
||||
call write_double(6,correlation_energy_ratio, 'Correlation ratio')
|
||||
print *, ''
|
||||
|
||||
write(fmt,*) '(''# ============'',', N_states_p, '(1X,''=============================''))'
|
||||
write(*,fmt)
|
||||
write(fmt,*) '(12X,', N_states_p, '(6X,A7,1X,I6,10X))'
|
||||
write(*,fmt) ('State',k, k=1,N_states_p)
|
||||
write(fmt,*) '(''# ============'',', N_states_p, '(1X,''=============================''))'
|
||||
write(*,fmt)
|
||||
write(fmt,*) '(A12,', N_states_p, '(1X,F14.8,15X))'
|
||||
write(*,fmt) '# E ', CI_energy(1:N_states_p)
|
||||
if (N_states_p > 1) then
|
||||
write(*,fmt) '# Excit. (au)', CI_energy(1:N_states_p)-CI_energy(1)
|
||||
write(*,fmt) '# Excit. (eV)', (CI_energy(1:N_states_p)-CI_energy(1))*27.211396641308d0
|
||||
endif
|
||||
write(fmt,*) '(A12,', 2*N_states_p, '(1X,F14.8))'
|
||||
write(*,fmt) '# PT2'//pt2_string, (pt2(k), error(k), k=1,N_states_p)
|
||||
write(*,'(A)') '#'
|
||||
write(*,fmt) '# E+PT2 ', (CI_energy(k)+pt2(k),error(k), k=1,N_states_p)
|
||||
if (N_states_p > 1) then
|
||||
write(*,fmt) '# Excit. (au)', ( (CI_energy(k)+pt2(k)-CI_energy(1)-pt2(1)), &
|
||||
dsqrt(error(k)*error(k)+error(1)*error(1)), k=1,N_states_p)
|
||||
write(*,fmt) '# Excit. (eV)', ( (CI_energy(k)+pt2(k)-CI_energy(1)-pt2(1))*27.211396641308d0, &
|
||||
dsqrt(error(k)*error(k)+error(1)*error(1))*27.211396641308d0, k=1,N_states_p)
|
||||
endif
|
||||
write(fmt,*) '(''# ============'',', N_states_p, '(1X,''=============================''))'
|
||||
write(*,fmt)
|
||||
print *, ''
|
||||
|
||||
print *, 'N_det = ', N_det
|
||||
print *, 'N_states = ', N_states
|
||||
print*, 'correlation_ratio = ', correlation_energy_ratio
|
||||
|
||||
do k=1, N_states_p
|
||||
print*,'State ',k
|
||||
print *, 'PT2 = ', pt2(k)
|
||||
print *, 'E = ', CI_energy(k)
|
||||
print *, 'E+PT2'//pt2_string//' = ', CI_energy(k)+pt2(k), ' +/- ', error(k)
|
||||
enddo
|
||||
|
||||
print *, '-----'
|
||||
if(N_states.gt.1)then
|
||||
print *, 'Variational Energy difference (au | eV)'
|
||||
do i=2, N_states_p
|
||||
print*,'Delta E = ', (CI_energy(i) - CI_energy(1)), &
|
||||
(CI_energy(i) - CI_energy(1)) * 27.211396641308d0
|
||||
enddo
|
||||
print *, '-----'
|
||||
print*, 'Variational + perturbative Energy difference (au | eV)'
|
||||
do i=2, N_states_p
|
||||
print*,'Delta E = ', (CI_energy(i)+ pt2(i) - (CI_energy(1) + pt2(1))), &
|
||||
(CI_energy(i)+ pt2(i) - (CI_energy(1) + pt2(1))) * 27.211396641308d0
|
||||
enddo
|
||||
endif
|
||||
call ezfio_set_full_ci_zmq_energy_pt2(CI_energy(1)+pt2(1))
|
||||
call dump_fci_iterations_value(N_det,CI_energy,pt2)
|
||||
|
||||
n_det_before = N_det
|
||||
if (s2_eig) then
|
||||
to_select = N_det/2+1
|
||||
to_select = max(N_det/2+1, to_select)
|
||||
to_select = min(to_select, N_det_max-n_det_before)
|
||||
else
|
||||
to_select = N_det
|
||||
to_select = max(N_det, to_select)
|
||||
to_select = min(to_select, N_det_max-n_det_before)
|
||||
endif
|
||||
call save_natural_mos
|
||||
call map_deinit(mo_integrals_map)
|
||||
FREE mo_integrals_map
|
||||
PROVIDE mo_integrals_map
|
||||
call four_index_transform_zmq(ao_integrals_map,mo_integrals_map, &
|
||||
mo_coef, size(mo_coef,1), &
|
||||
1, 1, 1, 1, ao_num, ao_num, ao_num, ao_num, &
|
||||
1, 1, 1, 1, mo_num, mo_num, mo_num, mo_num)
|
||||
|
||||
call ZMQ_selection(to_select, pt2)
|
||||
|
||||
PROVIDE psi_coef
|
||||
PROVIDE psi_det
|
||||
PROVIDE psi_det_sorted
|
||||
|
||||
if (N_det >= N_det_max) then
|
||||
threshold_davidson = threshold_davidson_in
|
||||
end if
|
||||
call diagonalize_CI
|
||||
call save_wavefunction
|
||||
call ezfio_set_full_ci_zmq_energy(CI_energy(1))
|
||||
enddo
|
||||
endif
|
||||
|
||||
if (N_det < N_det_max) then
|
||||
threshold_davidson = threshold_davidson_in
|
||||
call diagonalize_CI
|
||||
call save_wavefunction
|
||||
call ezfio_set_full_ci_zmq_energy(CI_energy(1))
|
||||
call ezfio_set_full_ci_zmq_energy_pt2(CI_energy(1)+pt2(1))
|
||||
endif
|
||||
|
||||
if (do_pt2) then
|
||||
pt2 = 0.d0
|
||||
threshold_selectors = 1.d0
|
||||
threshold_generators = 1d0
|
||||
SOFT_TOUCH threshold_selectors threshold_generators
|
||||
call ZMQ_pt2(CI_energy, pt2,relative_error,absolute_error,error) ! Stochastic PT2
|
||||
threshold_selectors = threshold_selectors_save
|
||||
threshold_generators = threshold_generators_save
|
||||
SOFT_TOUCH threshold_selectors threshold_generators
|
||||
call ezfio_set_full_ci_zmq_energy(CI_energy(1))
|
||||
call ezfio_set_full_ci_zmq_energy_pt2(CI_energy(1)+pt2(1))
|
||||
endif
|
||||
print *, 'N_det = ', N_det
|
||||
print *, 'N_states = ', N_states
|
||||
print*, 'correlation_ratio = ', correlation_energy_ratio
|
||||
|
||||
|
||||
call dump_fci_iterations_value(N_det,CI_energy,pt2)
|
||||
|
||||
print *, ''
|
||||
print '(A,I12)', 'Summary at N_det = ', N_det
|
||||
print '(A)', '-----------------------------------'
|
||||
print *, ''
|
||||
call write_double(6,correlation_energy_ratio, 'Correlation ratio')
|
||||
print *, ''
|
||||
|
||||
|
||||
N_states_p = min(N_det,N_states)
|
||||
print *, ''
|
||||
write(fmt,*) '(''# ============'',', N_states_p, '(1X,''=============================''))'
|
||||
write(*,fmt)
|
||||
write(fmt,*) '(12X,', N_states_p, '(6X,A7,1X,I6,10X))'
|
||||
write(*,fmt) ('State',k, k=1,N_states_p)
|
||||
write(fmt,*) '(''# ============'',', N_states_p, '(1X,''=============================''))'
|
||||
write(*,fmt)
|
||||
write(fmt,*) '(A12,', N_states_p, '(1X,F14.8,15X))'
|
||||
write(*,fmt) '# E ', CI_energy(1:N_states_p)
|
||||
if (N_states_p > 1) then
|
||||
write(*,fmt) '# Excit. (au)', CI_energy(1:N_states_p)-CI_energy(1)
|
||||
write(*,fmt) '# Excit. (eV)', (CI_energy(1:N_states_p)-CI_energy(1))*27.211396641308d0
|
||||
endif
|
||||
write(fmt,*) '(A12,', 2*N_states_p, '(1X,F14.8))'
|
||||
write(*,fmt) '# PT2'//pt2_string, (pt2(k), error(k), k=1,N_states_p)
|
||||
write(*,'(A)') '#'
|
||||
write(*,fmt) '# E+PT2 ', (CI_energy(k)+pt2(k),error(k), k=1,N_states_p)
|
||||
if (N_states_p > 1) then
|
||||
write(*,fmt) '# Excit. (au)', ( (CI_energy(k)+pt2(k)-CI_energy(1)-pt2(1)), &
|
||||
dsqrt(error(k)*error(k)+error(1)*error(1)), k=1,N_states_p)
|
||||
write(*,fmt) '# Excit. (eV)', ( (CI_energy(k)+pt2(k)-CI_energy(1)-pt2(1))*27.211396641308d0, &
|
||||
dsqrt(error(k)*error(k)+error(1)*error(1))*27.211396641308d0, k=1,N_states_p)
|
||||
endif
|
||||
write(fmt,*) '(''# ============'',', N_states_p, '(1X,''=============================''))'
|
||||
write(*,fmt)
|
||||
print *, ''
|
||||
|
||||
|
||||
|
||||
end
|
||||
@ -141,10 +141,7 @@ subroutine ZMQ_pt2(E, pt2,relative_error, absolute_error, error)
|
||||
|
||||
deallocate(pt2_detail, comb, computed, tbc)
|
||||
enddo
|
||||
pt2_stoch_istate = 1
|
||||
w(:) = 1.d0/N_states
|
||||
call update_psi_average_norm_contrib(w)
|
||||
SOFT_TOUCH psi_average_norm_contrib
|
||||
FREE psi_average_norm_contrib pt2_stoch_istate
|
||||
endif
|
||||
do k=N_det+1,N_states
|
||||
pt2(k) = 0.d0
|
||||
|
||||
@ -73,7 +73,7 @@ subroutine run_pt2_slave(thread,iproc,energy)
|
||||
end do
|
||||
|
||||
integer, external :: disconnect_from_taskserver
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,zmq_socket_push,worker_id) == -1) then
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,worker_id) == -1) then
|
||||
continue
|
||||
endif
|
||||
|
||||
|
||||
@ -93,7 +93,7 @@ subroutine run_selection_slave(thread,iproc,energy)
|
||||
|
||||
|
||||
integer, external :: disconnect_from_taskserver
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,zmq_socket_push,worker_id) == -1) then
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,worker_id) == -1) then
|
||||
continue
|
||||
endif
|
||||
|
||||
|
||||
@ -1 +1 @@
|
||||
Perturbation Selectors_full SingleRefMethod
|
||||
Perturbation Selectors_full SingleRefMethod ZMQ
|
||||
|
||||
@ -9,7 +9,7 @@ subroutine run
|
||||
double precision, allocatable :: pt2(:), norm_pert(:)
|
||||
double precision :: H_pert_diag, E_old
|
||||
integer :: N_st, iter
|
||||
PROVIDE Fock_matrix_diag_mo
|
||||
PROVIDE Fock_matrix_diag_mo H_apply_buffer_allocated
|
||||
N_st = N_states
|
||||
allocate (pt2(N_st), norm_pert(N_st))
|
||||
E_old = HF_energy
|
||||
|
||||
@ -1084,6 +1084,8 @@ subroutine H_S2_u_0_mrcc_nstates(v_0,s_0,u_0,H_jj,S2_jj,n,keys_tmp,Nint,istate_i
|
||||
! Begin Specific to dressing
|
||||
! --------------------------
|
||||
|
||||
!TODO : DRESSING 1 column
|
||||
|
||||
!$OMP DO
|
||||
do ii=1,n_det_ref
|
||||
i = idx_ref(ii)
|
||||
|
||||
@ -195,34 +195,34 @@ END_PROVIDER
|
||||
|
||||
if (diag_algorithm == "Davidson") then
|
||||
|
||||
allocate (eigenvectors(size(CI_eigenvectors_dressed,1),size(CI_eigenvectors_dressed,2)), &
|
||||
eigenvalues(size(CI_electronic_energy_dressed,1)))
|
||||
allocate (eigenvectors(size(CI_eigenvectors_dressed,1),size(CI_eigenvectors_dressed,2)),&
|
||||
eigenvalues(size(CI_electronic_energy_dressed,1)))
|
||||
do j=1,min(N_states,N_det)
|
||||
do i=1,N_det
|
||||
eigenvectors(i,j) = psi_coef(i,j)
|
||||
enddo
|
||||
enddo
|
||||
do mrcc_state=1,N_states
|
||||
do j=mrcc_state,min(N_states,N_det)
|
||||
do i=1,N_det
|
||||
eigenvectors(i,j) = psi_coef(i,j)
|
||||
enddo
|
||||
enddo
|
||||
call davidson_diag_mrcc_HS2(psi_det,eigenvectors,&
|
||||
size(eigenvectors,1), &
|
||||
eigenvalues,N_det,N_states,N_states_diag,N_int, &
|
||||
output_determinants,mrcc_state)
|
||||
CI_eigenvectors_dressed(1:N_det,mrcc_state) = eigenvectors(1:N_det,mrcc_state)
|
||||
CI_electronic_energy_dressed(mrcc_state) = eigenvalues(mrcc_state)
|
||||
enddo
|
||||
do k=N_states+1,N_states_diag
|
||||
CI_eigenvectors_dressed(1:N_det,k) = eigenvectors(1:N_det,k)
|
||||
CI_electronic_energy_dressed(k) = eigenvalues(k)
|
||||
enddo
|
||||
call u_0_S2_u_0(CI_eigenvectors_s2_dressed,CI_eigenvectors_dressed,N_det,psi_det,N_int,&
|
||||
N_states_diag,size(CI_eigenvectors_dressed,1))
|
||||
|
||||
deallocate (eigenvectors,eigenvalues)
|
||||
do j=mrcc_state,min(N_states,N_det)
|
||||
do i=1,N_det
|
||||
eigenvectors(i,j) = psi_coef(i,j)
|
||||
enddo
|
||||
enddo
|
||||
call davidson_diag_mrcc_HS2(psi_det,eigenvectors, &
|
||||
size(eigenvectors,1), &
|
||||
eigenvalues,N_det,N_states,N_states_diag,N_int, &
|
||||
output_determinants,mrcc_state)
|
||||
CI_eigenvectors_dressed(1:N_det,mrcc_state) = eigenvectors(1:N_det,mrcc_state)
|
||||
CI_electronic_energy_dressed(mrcc_state) = eigenvalues(mrcc_state)
|
||||
enddo
|
||||
do k=N_states+1,N_states_diag
|
||||
CI_eigenvectors_dressed(1:N_det,k) = eigenvectors(1:N_det,k)
|
||||
CI_electronic_energy_dressed(k) = eigenvalues(k)
|
||||
enddo
|
||||
call u_0_S2_u_0(CI_eigenvectors_s2_dressed,CI_eigenvectors_dressed,N_det,psi_det,N_int,&
|
||||
N_states_diag,size(CI_eigenvectors_dressed,1))
|
||||
|
||||
deallocate (eigenvectors,eigenvalues)
|
||||
|
||||
else if (diag_algorithm == "Lapack") then
|
||||
|
||||
|
||||
@ -3,6 +3,7 @@ program analyze_wf
|
||||
BEGIN_DOC
|
||||
! Wave function analyzis
|
||||
END_DOC
|
||||
PROVIDE mo_tot_num psi_det psi_coef
|
||||
read_wf = .True.
|
||||
SOFT_TOUCH read_wf
|
||||
call run()
|
||||
@ -29,11 +30,11 @@ subroutine run
|
||||
write(*,'(A)') '============='
|
||||
write(*,'(A)') ''
|
||||
do istate=1,N_states
|
||||
call get_occupation_from_dets(occupation,istate)
|
||||
write(*,'(A)') ''
|
||||
write(*,'(A,I3)'), 'State ', istate
|
||||
write(*,'(A)') '---------------'
|
||||
write(*,'(A)') ''
|
||||
call get_occupation_from_dets(istate,occupation)
|
||||
write (*,'(A)') '======== ================'
|
||||
class = 0
|
||||
do i=1,mo_tot_num
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
subroutine get_occupation_from_dets(occupation, istate)
|
||||
subroutine get_occupation_from_dets(istate,occupation)
|
||||
implicit none
|
||||
double precision, intent(out) :: occupation(mo_tot_num)
|
||||
integer, intent(in) :: istate
|
||||
@ -9,6 +9,8 @@ subroutine get_occupation_from_dets(occupation, istate)
|
||||
integer :: list(N_int*bit_kind_size,2)
|
||||
integer :: n_elements(2)
|
||||
double precision :: c
|
||||
ASSERT (istate > 0)
|
||||
ASSERT (istate <= N_states)
|
||||
|
||||
occupation = 0.d0
|
||||
do i=1,N_det
|
||||
@ -16,6 +18,7 @@ subroutine get_occupation_from_dets(occupation, istate)
|
||||
call bitstring_to_list_ab(psi_det(1,1,i), list, n_elements, N_int)
|
||||
do ispin=1,2
|
||||
do j=1,n_elements(ispin)
|
||||
ASSERT ( list(j,ispin) < mo_tot_num )
|
||||
occupation( list(j,ispin) ) += c
|
||||
enddo
|
||||
enddo
|
||||
|
||||
@ -1,6 +1,272 @@
|
||||
use bitmasks
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ integer, N_mrcc_teeth ]
|
||||
N_mrcc_teeth = 10
|
||||
END_PROVIDER
|
||||
|
||||
BEGIN_PROVIDER [ double precision, mrcc_norm_acc, (0:N_det_non_ref, N_states) ]
|
||||
&BEGIN_PROVIDER [ double precision, mrcc_norm, (0:N_det_non_ref, N_states) ]
|
||||
&BEGIN_PROVIDER [ double precision, mrcc_teeth_size, (0:N_det_non_ref, N_states) ]
|
||||
&BEGIN_PROVIDER [ integer, mrcc_teeth, (0:N_mrcc_teeth+1, N_states) ]
|
||||
implicit none
|
||||
integer :: i, j, st, nt
|
||||
double precision :: norm_sto, jump, norm_mwen, norm_loc
|
||||
|
||||
if(N_states /= 1) stop "mrcc_sto may not work with N_states /= 1"
|
||||
|
||||
do st=1,N_states
|
||||
|
||||
!norm_non_ref = 1d0
|
||||
!do i=1,N_det_ref
|
||||
! norm_non_ref -= psi_ref_coef(i,st)**2
|
||||
!end do
|
||||
|
||||
mrcc_teeth(0,st) = 1
|
||||
!norm_non_sto = norm_non_ref
|
||||
norm_sto = 1d0
|
||||
do i=1,N_det
|
||||
mrcc_teeth(1,st) = i
|
||||
jump = (1d0 / dfloat(N_mrcc_teeth)) * norm_sto
|
||||
if(psi_coef_generators(i,1)**2 < jump / 2d0) exit
|
||||
!if(i==80) exit
|
||||
norm_sto -= psi_coef_generators(i,1)**2
|
||||
end do
|
||||
|
||||
print *, "FIRST", mrcc_teeth(1,st)
|
||||
|
||||
norm_loc = 0d0
|
||||
mrcc_norm_acc(0,st) = 0d0
|
||||
nt = 1
|
||||
|
||||
do i=1,mrcc_teeth(1,st)-1
|
||||
mrcc_norm_acc(i,st) = mrcc_norm_acc(i-1,st) + psi_coef_generators(i,st)**2
|
||||
end do
|
||||
|
||||
do i=mrcc_teeth(1,st), N_det_generators!-mrcc_teeth(1,st)+1
|
||||
norm_mwen = psi_coef_generators(i,st)**2!-1+mrcc_teeth(1,st),st)**2
|
||||
mrcc_norm_acc(i,st) = mrcc_norm_acc(i-1,st) + norm_mwen
|
||||
norm_loc += norm_mwen
|
||||
if(norm_loc > (jump*dfloat(nt))) then
|
||||
nt = nt + 1
|
||||
mrcc_teeth(nt,st) = i
|
||||
end if
|
||||
end do
|
||||
if(nt > N_mrcc_teeth+1) then
|
||||
print *, "foireouse mrcc_teeth", nt, mrcc_teeth(nt,st), N_det_non_ref
|
||||
stop
|
||||
end if
|
||||
|
||||
mrcc_teeth(N_mrcc_teeth+1,st) = N_det_non_ref+1
|
||||
!mrcc_norm_acc(:,st) = mrcc_norm_acc(:,st) / norm_non_ref
|
||||
norm_loc = 0d0
|
||||
do i=N_mrcc_teeth, 0, -1
|
||||
mrcc_teeth_size(i,st) = mrcc_norm_acc(mrcc_teeth(i+1,st)-1,st) - mrcc_norm_acc(mrcc_teeth(i,st)-1, st)
|
||||
mrcc_norm_acc(mrcc_teeth(i,st):mrcc_teeth(i+1,st)-1,st) -= mrcc_norm_acc(mrcc_teeth(i,st)-1, st)
|
||||
mrcc_norm_acc(mrcc_teeth(i,st):mrcc_teeth(i+1,st)-1,st) = &
|
||||
mrcc_norm_acc(mrcc_teeth(i,st):mrcc_teeth(i+1,st)-1,st) / mrcc_teeth_size(i,st)
|
||||
mrcc_norm(mrcc_teeth(i,st), st) = mrcc_norm_acc(mrcc_teeth(i,st), st)
|
||||
do j=mrcc_teeth(i,st)+1, mrcc_teeth(i+1,1)-1
|
||||
mrcc_norm(j,1) = mrcc_norm_acc(j, st) - mrcc_norm_acc(j-1, st)
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ double precision, delta_ij_mrcc_sto,(N_states,N_det_non_ref,N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ii_mrcc_sto, (N_states, N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ij_s2_mrcc_sto, (N_states,N_det_non_ref,N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ii_s2_mrcc_sto, (N_states, N_det_ref) ]
|
||||
use bitmasks
|
||||
implicit none
|
||||
integer :: gen, h, p, n, t, i, j, h1, h2, p1, p2, s1, s2, iproc
|
||||
integer(bit_kind) :: mask(N_int, 2), omask(N_int, 2)
|
||||
integer(bit_kind),allocatable :: buf(:,:,:)
|
||||
logical :: ok
|
||||
logical, external :: detEq
|
||||
integer, external :: omp_get_thread_num
|
||||
double precision :: coefs(N_det_non_ref), myCoef
|
||||
integer :: n_in_teeth
|
||||
double precision :: contrib(N_states), curn, in_teeth_step, curlim, curnorm
|
||||
|
||||
contrib = 0d0
|
||||
read(*,*) n_in_teeth
|
||||
!n_in_teeth = 2
|
||||
in_teeth_step = 1d0 / dfloat(n_in_teeth)
|
||||
!double precision :: delta_ij_mrcc_tmp,(N_states,N_det_non_ref,N_det_ref) ]
|
||||
!double precision :: delta_ii_mrcc_tmp, (N_states,N_det_ref) ]
|
||||
!double precision :: delta_ij_s2_mrcc_tmp(N_states,N_det_non_ref,N_det_ref)
|
||||
!double precision :: delta_ii_s2_mrcc_tmp(N_states, N_det_ref)
|
||||
|
||||
coefs = 0d0
|
||||
coefs(:mrcc_teeth(1,1)-1) = 1d0
|
||||
|
||||
do i=1,N_mrcc_teeth
|
||||
print *, "TEETH SIZE", i, mrcc_teeth(i+1,1)-mrcc_teeth(i,1)
|
||||
if(mrcc_teeth(i+1,1) - mrcc_teeth(i,1) <= n_in_teeth) then
|
||||
coefs(mrcc_teeth(i,1):mrcc_teeth(i+1,1)-1) = 1d0
|
||||
else if(.false.) then
|
||||
curnorm = 0d0
|
||||
curn = 0.5d0
|
||||
curlim = curn / dfloat(n_in_teeth)
|
||||
do j=mrcc_teeth(i,1), mrcc_teeth(i+1,1)-1
|
||||
if(mrcc_norm_acc(j,1) >= curlim) then
|
||||
coefs(j) = 1d0
|
||||
curnorm += mrcc_norm(j,1)
|
||||
do while(mrcc_norm_acc(j,1) > curlim)
|
||||
curn += 1d0
|
||||
curlim = curn / dfloat(n_in_teeth)
|
||||
end do
|
||||
end if
|
||||
end do
|
||||
do j=mrcc_teeth(i,1), mrcc_teeth(i+1,1)-1
|
||||
coefs(j) = coefs(j) / curnorm ! 1d0 / norm computed in teeth
|
||||
end do
|
||||
else if(.true.) then
|
||||
coefs(mrcc_teeth(i,1):mrcc_teeth(i,1)+n_in_teeth-1) = 1d0 / mrcc_norm_acc(mrcc_teeth(i,1)+n_in_teeth-1, 1)
|
||||
else
|
||||
curnorm = 0d0
|
||||
n = mrcc_teeth(i+1,1) - mrcc_teeth(i,1)
|
||||
do j=1,n_in_teeth
|
||||
t = int((dfloat(j)-0.5d0) * dfloat(n) / dfloat(n_in_teeth)) + 1 + mrcc_teeth(i,1) - 1
|
||||
curnorm += mrcc_norm(t,1)
|
||||
coefs(t) = 1d0
|
||||
end do
|
||||
do j=mrcc_teeth(i,1), mrcc_teeth(i+1,1)-1
|
||||
coefs(j) = coefs(j) / curnorm ! 1d0 / norm computed in teeth
|
||||
end do
|
||||
end if
|
||||
!coefs(mrcc_teeth(i,1)) =
|
||||
end do
|
||||
|
||||
!coefs = coefs * dfloat(N_det_generators)
|
||||
|
||||
|
||||
delta_ij_mrcc_sto = 0d0
|
||||
delta_ii_mrcc_sto = 0d0
|
||||
delta_ij_s2_mrcc_sto = 0d0
|
||||
delta_ii_s2_mrcc_sto = 0d0
|
||||
PROVIDE dij
|
||||
provide hh_shortcut psi_det_size! lambda_mrcc
|
||||
!$OMP PARALLEL DO default(none) schedule(dynamic) &
|
||||
!$OMP shared(psi_ref, psi_non_ref, hh_exists, pp_exists, N_int, hh_shortcut) &
|
||||
!$OMP shared(N_det_generators, coefs,N_det_non_ref, N_det_ref, delta_ii_mrcc_sto, delta_ij_mrcc_sto) &
|
||||
!$OMP shared(contrib,psi_det_generators, delta_ii_s2_mrcc_sto, delta_ij_s2_mrcc_sto) &
|
||||
!$OMP private(i,j,curnorm,myCoef, h, n, mask, omask, buf, ok, iproc)
|
||||
do gen= 1,N_det_generators
|
||||
if(coefs(gen) == 0d0) cycle
|
||||
myCoef = coefs(gen)
|
||||
allocate(buf(N_int, 2, N_det_non_ref))
|
||||
iproc = omp_get_thread_num() + 1
|
||||
if(mod(gen, 1000) == 0) print *, "mrcc_sto ", gen, "/", N_det_generators
|
||||
|
||||
do h=1, hh_shortcut(0)
|
||||
call apply_hole_local(psi_det_generators(1,1,gen), hh_exists(1, h), mask, ok, N_int)
|
||||
if(.not. ok) cycle
|
||||
omask = 0_bit_kind
|
||||
if(hh_exists(1, h) /= 0) omask = mask
|
||||
n = 1
|
||||
do p=hh_shortcut(h), hh_shortcut(h+1)-1
|
||||
call apply_particle_local(mask, pp_exists(1, p), buf(1,1,n), ok, N_int)
|
||||
if(ok) n = n + 1
|
||||
if(n > N_det_non_ref) stop "Buffer too small in MRCC..."
|
||||
end do
|
||||
n = n - 1
|
||||
if(n /= 0) then
|
||||
call mrcc_part_dress(delta_ij_mrcc_sto, delta_ii_mrcc_sto, delta_ij_s2_mrcc_sto, &
|
||||
delta_ii_s2_mrcc_sto, gen,n,buf,N_int,omask,myCoef,contrib)
|
||||
endif
|
||||
end do
|
||||
deallocate(buf)
|
||||
end do
|
||||
!$OMP END PARALLEL DO
|
||||
|
||||
|
||||
|
||||
curnorm = 0d0
|
||||
do i=1,N_det_ref
|
||||
do j=1,N_det_non_ref
|
||||
curnorm += delta_ij_mrcc_sto(1, j, i)**2
|
||||
end do
|
||||
end do
|
||||
print *, "NORM DELTA ", curnorm**0.5d0
|
||||
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ double precision, delta_ij_cancel, (N_states,N_det_non_ref,N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ii_cancel, (N_states, N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ij_s2_cancel, (N_states,N_det_non_ref,N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ii_s2_cancel, (N_states, N_det_ref) ]
|
||||
use bitmasks
|
||||
implicit none
|
||||
|
||||
|
||||
integer :: i_state, i, i_I, J, k, k2, k1, kk, ll, m,l, deg, ni, m2
|
||||
integer :: n(2)
|
||||
integer :: p1,p2,h1,h2,s1,s2, blok, I_s, J_s, kn
|
||||
logical :: ok
|
||||
double precision :: phase_ia, phase_Ik, phase_Jl, phase_Ji,phase_la, phase_ka, phase_tmp
|
||||
double precision :: Hka, Hla, Ska, Sla, tmp
|
||||
double precision :: diI, hIi, hJi, delta_JI, dkI, HkI,ci_inv(N_states), cj_inv(N_states)
|
||||
double precision :: contrib, contrib_s2, wall, iwall
|
||||
integer, dimension(0:2,2,2) :: exc_iI, exc_Ik, exc_IJ, exc
|
||||
integer(bit_kind) :: det_tmp(N_int, 2), det_tmp2(N_int, 2),inac, virt
|
||||
integer, external :: get_index_in_psi_det_sorted_bit, searchDet,detCmp
|
||||
logical, external :: is_in_wavefunction
|
||||
|
||||
provide dij
|
||||
|
||||
delta_ij_cancel = 0d0
|
||||
delta_ii_cancel = 0d0
|
||||
|
||||
do i=1,N_det_ref
|
||||
!$OMP PARALLEL DO default(shared) private(kk, k, blok, exc_Ik,det_tmp2,ok,deg,phase_Ik, l,ll) &
|
||||
!$OMP private(contrib, contrib_s2, i_state)
|
||||
do kk = 1, nlink(i)
|
||||
k = det_cepa0_idx(linked(kk, i))
|
||||
blok = blokMwen(kk, i)
|
||||
call get_excitation(psi_ref(1,1,i),psi_non_ref(1,1,k),exc_Ik,deg,phase_Ik,N_int)
|
||||
|
||||
do j=1,N_det_ref
|
||||
if(j == i) cycle
|
||||
call apply_excitation(psi_ref(1,1,J),exc_Ik,det_tmp2,ok,N_int)
|
||||
if(.not. ok) cycle
|
||||
|
||||
l = searchDet(det_cepa0(1,1,cepa0_shortcut(blok)), det_tmp2,cepa0_shortcut(blok+1)-cepa0_shortcut(blok), N_int)
|
||||
if(l == -1) cycle
|
||||
ll = cepa0_shortcut(blok)-1+l
|
||||
l = det_cepa0_idx(ll)
|
||||
ll = child_num(ll, J)
|
||||
|
||||
do i_state = 1, N_states
|
||||
contrib = (dij(j, l, i_state) - dij(i, k, i_state)) * delta_cas(i,j,i_state)! * Hla *phase_ia * phase_ik
|
||||
contrib_s2 = dij(j, l, i_state) - dij(i, k, i_state)! * Sla*phase_ia * phase_ik
|
||||
if(dabs(psi_ref_coef(i,i_state)).ge.1.d-3) then
|
||||
!$OMP ATOMIC
|
||||
delta_ij_cancel(i_state,l,i) += contrib
|
||||
!$OMP ATOMIC
|
||||
delta_ij_s2_cancel(i_state,l,i) += contrib_s2
|
||||
!$OMP ATOMIC
|
||||
delta_ii_cancel(i_state,i) -= contrib / psi_ref_coef(i, i_state) * psi_non_ref_coef(l,i_state)
|
||||
!$OMP ATOMIC
|
||||
delta_ii_s2_cancel(i_state,i) -= contrib_s2 / psi_ref_coef(i, i_state) * psi_non_ref_coef(l,i_state)
|
||||
else
|
||||
!$OMP ATOMIC
|
||||
delta_ij_cancel(i_state,l,i) += contrib * 0.5d0
|
||||
!$OMP ATOMIC
|
||||
delta_ij_s2_cancel(i_state,l,i) += contrib_s2 * 0.5d0
|
||||
endif
|
||||
end do
|
||||
end do
|
||||
end do
|
||||
!$OMP END PARALLEL DO
|
||||
enddo
|
||||
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ double precision, delta_ij_mrcc, (N_states,N_det_non_ref,N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ii_mrcc, (N_states, N_det_ref) ]
|
||||
@ -14,15 +280,19 @@ use bitmasks
|
||||
logical :: ok
|
||||
logical, external :: detEq
|
||||
integer, external :: omp_get_thread_num
|
||||
double precision :: contrib(N_states)
|
||||
|
||||
provide dij hh_shortcut psi_det_size
|
||||
|
||||
contrib = 0d0
|
||||
delta_ij_mrcc = 0d0
|
||||
delta_ii_mrcc = 0d0
|
||||
delta_ij_s2_mrcc = 0d0
|
||||
delta_ii_s2_mrcc = 0d0
|
||||
PROVIDE dij
|
||||
provide hh_shortcut psi_det_size! lambda_mrcc
|
||||
|
||||
|
||||
!$OMP PARALLEL DO default(none) schedule(dynamic) &
|
||||
!$OMP shared(psi_det_generators, N_det_generators, hh_exists, pp_exists, N_int, hh_shortcut) &
|
||||
!$OMP shared(contrib,psi_det_generators, N_det_generators, hh_exists, pp_exists, N_int, hh_shortcut) &
|
||||
!$OMP shared(N_det_non_ref, N_det_ref, delta_ii_mrcc, delta_ij_mrcc, delta_ii_s2_mrcc, delta_ij_s2_mrcc) &
|
||||
!$OMP private(h, n, mask, omask, buf, ok, iproc)
|
||||
do gen= 1, N_det_generators
|
||||
@ -43,7 +313,7 @@ use bitmasks
|
||||
n = n - 1
|
||||
|
||||
if(n /= 0) then
|
||||
call mrcc_part_dress(delta_ij_mrcc, delta_ii_mrcc, delta_ij_s2_mrcc, delta_ii_s2_mrcc, gen,n,buf,N_int,omask)
|
||||
call mrcc_part_dress(delta_ij_mrcc, delta_ii_mrcc, delta_ij_s2_mrcc, delta_ii_s2_mrcc, gen,n,buf,N_int,omask,1d0,contrib)
|
||||
endif
|
||||
|
||||
end do
|
||||
@ -59,7 +329,7 @@ END_PROVIDER
|
||||
! end subroutine
|
||||
|
||||
|
||||
subroutine mrcc_part_dress(delta_ij_, delta_ii_,delta_ij_s2_, delta_ii_s2_,i_generator,n_selected,det_buffer,Nint,key_mask)
|
||||
subroutine mrcc_part_dress(delta_ij_, delta_ii_,delta_ij_s2_, delta_ii_s2_,i_generator,n_selected,det_buffer,Nint,key_mask,coef,contrib)
|
||||
use bitmasks
|
||||
implicit none
|
||||
|
||||
@ -99,7 +369,10 @@ subroutine mrcc_part_dress(delta_ij_, delta_ii_,delta_ij_s2_, delta_ii_s2_,i_gen
|
||||
logical, external :: detEq, is_generable
|
||||
!double precision, external :: get_dij, get_dij_index
|
||||
double precision :: Delta_E_inv(N_states)
|
||||
|
||||
double precision, intent(in) :: coef
|
||||
double precision, intent(inout) :: contrib(N_states)
|
||||
double precision :: sdress, hdress
|
||||
|
||||
if (perturbative_triples) then
|
||||
PROVIDE one_anhil fock_virt_total fock_core_inactive_total one_creat
|
||||
endif
|
||||
@ -194,6 +467,288 @@ subroutine mrcc_part_dress(delta_ij_, delta_ii_,delta_ij_s2_, delta_ii_s2_,i_gen
|
||||
k_sd = idx_alpha(l_sd)
|
||||
call i_h_j(tq(1,1,i_alpha),psi_non_ref(1,1,idx_alpha(l_sd)),Nint,hij_cache(k_sd))
|
||||
call get_s2(tq(1,1,i_alpha),psi_non_ref(1,1,idx_alpha(l_sd)),Nint,sij_cache(k_sd))
|
||||
!if(sij_cache(k_sd) /= 0D0) PRINT *, "SIJ ", sij_cache(k_sd)
|
||||
enddo
|
||||
|
||||
! |I>
|
||||
do i_I=1,N_det_ref
|
||||
! Find triples and quadruple grand parents
|
||||
call get_excitation_degree(tq(1,1,i_alpha),psi_ref(1,1,i_I),degree1,Nint)
|
||||
if (degree1 > 4) then
|
||||
cycle
|
||||
endif
|
||||
|
||||
do i_state=1,N_states
|
||||
dIa(i_state) = 0.d0
|
||||
enddo
|
||||
|
||||
! <I| <> |alpha>
|
||||
do k_sd=1,idx_alpha(0)
|
||||
|
||||
call get_excitation_degree(psi_ref(1,1,i_I),psi_non_ref(1,1,idx_alpha(k_sd)),degree,Nint)
|
||||
if (degree > 2) then
|
||||
cycle
|
||||
endif
|
||||
|
||||
! <I| /k\ |alpha>
|
||||
|
||||
! |l> = Exc(k -> alpha) |I>
|
||||
call get_excitation(psi_non_ref(1,1,idx_alpha(k_sd)),tq(1,1,i_alpha),exc,degree2,phase,Nint)
|
||||
call decode_exc(exc,degree2,h1,p1,h2,p2,s1,s2)
|
||||
do k=1,N_int
|
||||
tmp_det(k,1) = psi_ref(k,1,i_I)
|
||||
tmp_det(k,2) = psi_ref(k,2,i_I)
|
||||
enddo
|
||||
logical :: ok
|
||||
call apply_excitation(psi_ref(1,1,i_I), exc, tmp_det, ok, Nint)
|
||||
|
||||
do i_state=1,N_states
|
||||
dIK(i_state) = dij(i_I, idx_alpha(k_sd), i_state)
|
||||
enddo
|
||||
|
||||
! <I| \l/ |alpha>
|
||||
do i_state=1,N_states
|
||||
dka(i_state) = 0.d0
|
||||
enddo
|
||||
|
||||
if (ok) then
|
||||
do l_sd=k_sd+1,idx_alpha(0)
|
||||
call get_excitation_degree(tmp_det,psi_non_ref(1,1,idx_alpha(l_sd)),degree,Nint)
|
||||
if (degree == 0) then
|
||||
call get_excitation(psi_ref(1,1,i_I),psi_non_ref(1,1,idx_alpha(l_sd)),exc,degree,phase2,Nint)
|
||||
do i_state=1,N_states
|
||||
dka(i_state) = dij(i_I, idx_alpha(l_sd), i_state) * phase * phase2
|
||||
enddo
|
||||
exit
|
||||
endif
|
||||
enddo
|
||||
|
||||
else if (perturbative_triples) then
|
||||
! Linked
|
||||
|
||||
hka = hij_cache(idx_alpha(k_sd))
|
||||
if (dabs(hka) > 1.d-12) then
|
||||
call get_delta_e_dyall_general_mp(psi_ref(1,1,i_I),tq(1,1,i_alpha),Delta_E_inv)
|
||||
|
||||
do i_state=1,N_states
|
||||
ASSERT (Delta_E_inv(i_state) < 0.d0)
|
||||
dka(i_state) = hka / Delta_E_inv(i_state)
|
||||
enddo
|
||||
endif
|
||||
|
||||
endif
|
||||
|
||||
if (perturbative_triples.and. (degree2 == 1) ) then
|
||||
call i_h_j(psi_ref(1,1,i_I),tmp_det,Nint,hka)
|
||||
hka = hij_cache(idx_alpha(k_sd)) - hka
|
||||
if (dabs(hka) > 1.d-12) then
|
||||
call get_delta_e_dyall_general_mp(psi_ref(1,1,i_I),tq(1,1,i_alpha),Delta_E_inv)
|
||||
do i_state=1,N_states
|
||||
ASSERT (Delta_E_inv(i_state) < 0.d0)
|
||||
dka(i_state) = hka / Delta_E_inv(i_state)
|
||||
enddo
|
||||
endif
|
||||
|
||||
endif
|
||||
|
||||
do i_state=1,N_states
|
||||
dIa(i_state) = dIa(i_state) + dIk(i_state) * dka(i_state)
|
||||
enddo
|
||||
enddo
|
||||
|
||||
do i_state=1,N_states
|
||||
ci_inv(i_state) = psi_ref_coef_inv(i_I,i_state)
|
||||
enddo
|
||||
do l_sd=1,idx_alpha(0)
|
||||
k_sd = idx_alpha(l_sd)
|
||||
hla = hij_cache(k_sd)
|
||||
sla = sij_cache(k_sd)
|
||||
do i_state=1,N_states
|
||||
dIa_hla(i_state,k_sd) = dIa(i_state) * hla * coef
|
||||
dIa_sla(i_state,k_sd) = dIa(i_state) * sla * coef
|
||||
enddo
|
||||
enddo
|
||||
do i_state=1,N_states
|
||||
if(dabs(psi_ref_coef(1,i_state)).ge.1.d-3)then
|
||||
do l_sd=1,idx_alpha(0)
|
||||
k_sd = idx_alpha(l_sd)
|
||||
p1 = 1
|
||||
hdress = dIa_hla(i_state,k_sd) * psi_ref_coef(i_I,i_state) / psi_ref_coef(p1,i_state)
|
||||
sdress = dIa_sla(i_state,k_sd) * psi_ref_coef(i_I,i_state) / psi_ref_coef(p1,i_state)
|
||||
!$OMP ATOMIC
|
||||
contrib(i_state) += hdress * psi_ref_coef(p1, i_state) * psi_non_ref_coef(k_sd, i_state)
|
||||
!$OMP ATOMIC
|
||||
delta_ij_(i_state,k_sd,p1) += hdress
|
||||
!$OMP ATOMIC
|
||||
!delta_ii_(i_state,i_I) = delta_ii_(i_state,i_I) - dIa_hla(i_state,k_sd) * ci_inv(i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
delta_ii_(i_state,p1) -= hdress / psi_ref_coef(p1,i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
!$OMP ATOMIC
|
||||
delta_ij_s2_(i_state,k_sd,p1) += sdress
|
||||
!$OMP ATOMIC
|
||||
!delta_ii_s2_(i_state,i_I) = delta_ii_s2_(i_state,i_I) - dIa_sla(i_state,k_sd) * ci_inv(i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
delta_ii_s2_(i_state,p1) -= sdress / psi_ref_coef(p1,i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
enddo
|
||||
else
|
||||
!stop "dress with coef < 1d-3"
|
||||
delta_ii_(i_state,1) = 0.d0
|
||||
do l_sd=1,idx_alpha(0)
|
||||
k_sd = idx_alpha(l_sd)
|
||||
p1 = 1
|
||||
hdress = dIa_hla(i_state,k_sd) * psi_ref_coef(i_I,i_state) / psi_ref_coef(p1,i_state)
|
||||
sdress = dIa_sla(i_state,k_sd) * psi_ref_coef(i_I,i_state) / psi_ref_coef(p1,i_state)
|
||||
!$OMP ATOMIC
|
||||
delta_ij_(i_state,k_sd,p1) = delta_ij_(i_state,k_sd,p1) + 0.5d0*hdress
|
||||
!$OMP ATOMIC
|
||||
delta_ij_s2_(i_state,k_sd,p1) = delta_ij_s2_(i_state,k_sd,p1) + 0.5d0*sdress
|
||||
enddo
|
||||
endif
|
||||
enddo
|
||||
enddo
|
||||
enddo
|
||||
deallocate (dIa_hla,dIa_sla,hij_cache,sij_cache)
|
||||
deallocate(miniList, idx_miniList)
|
||||
end
|
||||
|
||||
|
||||
|
||||
subroutine mrcc_part_dress_1c(delta_ij_, delta_ii_,delta_ij_s2_, delta_ii_s2_,i_generator,n_selected,det_buffer,Nint,key_mask,contrib)
|
||||
use bitmasks
|
||||
implicit none
|
||||
|
||||
integer, intent(in) :: i_generator,n_selected, Nint
|
||||
double precision, intent(inout) :: delta_ij_(N_states,N_det_non_ref)
|
||||
double precision, intent(inout) :: delta_ii_(N_states)
|
||||
double precision, intent(inout) :: delta_ij_s2_(N_states,N_det_non_ref)
|
||||
double precision, intent(inout) :: delta_ii_s2_(N_states)
|
||||
|
||||
integer(bit_kind), intent(in) :: det_buffer(Nint,2,n_selected)
|
||||
integer :: i,j,k,l,m
|
||||
integer,allocatable :: idx_alpha(:), degree_alpha(:)
|
||||
logical :: good, fullMatch
|
||||
|
||||
integer(bit_kind),allocatable :: tq(:,:,:)
|
||||
integer :: N_tq, c_ref ,degree1, degree2, degree
|
||||
|
||||
double precision :: hIk, hla, hIl, sla, dIk(N_states), dka(N_states), dIa(N_states), hka
|
||||
double precision, allocatable :: dIa_hla(:,:), dIa_sla(:,:)
|
||||
double precision :: haj, phase, phase2
|
||||
double precision :: f(N_states), ci_inv(N_states)
|
||||
integer :: exc(0:2,2,2)
|
||||
integer :: h1,h2,p1,p2,s1,s2
|
||||
integer(bit_kind) :: tmp_det(Nint,2)
|
||||
integer :: iint, ipos
|
||||
integer :: i_state, k_sd, l_sd, i_I, i_alpha
|
||||
|
||||
integer(bit_kind),allocatable :: miniList(:,:,:)
|
||||
integer(bit_kind),intent(in) :: key_mask(Nint, 2)
|
||||
integer,allocatable :: idx_miniList(:)
|
||||
integer :: N_miniList, ni, leng
|
||||
double precision, allocatable :: hij_cache(:), sij_cache(:)
|
||||
|
||||
integer(bit_kind), allocatable :: microlist(:,:,:), microlist_zero(:,:,:)
|
||||
integer, allocatable :: idx_microlist(:), N_microlist(:), ptr_microlist(:), idx_microlist_zero(:)
|
||||
integer :: mobiles(2), smallerlist
|
||||
logical, external :: detEq, is_generable
|
||||
!double precision, external :: get_dij, get_dij_index
|
||||
double precision :: Delta_E_inv(N_states)
|
||||
double precision, intent(inout) :: contrib(N_states)
|
||||
double precision :: sdress, hdress
|
||||
|
||||
if (perturbative_triples) then
|
||||
PROVIDE one_anhil fock_virt_total fock_core_inactive_total one_creat
|
||||
endif
|
||||
|
||||
|
||||
leng = max(N_det_generators, N_det_non_ref)
|
||||
allocate(miniList(Nint, 2, leng), tq(Nint,2,n_selected), idx_minilist(leng), hij_cache(N_det_non_ref), sij_cache(N_det_non_ref))
|
||||
allocate(idx_alpha(0:psi_det_size), degree_alpha(psi_det_size))
|
||||
call create_minilist_find_previous(key_mask, psi_det_generators, miniList, i_generator-1, N_miniList, fullMatch, Nint)
|
||||
|
||||
allocate(ptr_microlist(0:mo_tot_num*2+1), &
|
||||
N_microlist(0:mo_tot_num*2) )
|
||||
allocate( microlist(Nint,2,N_minilist*4), &
|
||||
idx_microlist(N_minilist*4))
|
||||
|
||||
if(key_mask(1,1) /= 0) then
|
||||
call create_microlist(miniList, N_minilist, key_mask, microlist, idx_microlist, N_microlist, ptr_microlist, Nint)
|
||||
call filter_tq_micro(i_generator,n_selected,det_buffer,Nint,tq,N_tq,microlist,ptr_microlist,N_microlist,key_mask)
|
||||
else
|
||||
call filter_tq(i_generator,n_selected,det_buffer,Nint,tq,N_tq,miniList,N_minilist)
|
||||
end if
|
||||
|
||||
|
||||
|
||||
deallocate(microlist, idx_microlist)
|
||||
|
||||
allocate (dIa_hla(N_states,N_det_non_ref), dIa_sla(N_states,N_det_non_ref))
|
||||
|
||||
! |I>
|
||||
|
||||
! |alpha>
|
||||
|
||||
if(N_tq > 0) then
|
||||
call create_minilist(key_mask, psi_non_ref, miniList, idx_minilist, N_det_non_ref, N_minilist, Nint)
|
||||
if(N_minilist == 0) return
|
||||
|
||||
|
||||
if(sum(abs(key_mask(1:N_int,1))) /= 0) then
|
||||
allocate(microlist_zero(Nint,2,N_minilist), idx_microlist_zero(N_minilist))
|
||||
|
||||
allocate( microlist(Nint,2,N_minilist*4), &
|
||||
idx_microlist(N_minilist*4))
|
||||
call create_microlist(miniList, N_minilist, key_mask, microlist, idx_microlist, N_microlist, ptr_microlist, Nint)
|
||||
|
||||
|
||||
do i=0,mo_tot_num*2
|
||||
do k=ptr_microlist(i),ptr_microlist(i+1)-1
|
||||
idx_microlist(k) = idx_minilist(idx_microlist(k))
|
||||
end do
|
||||
end do
|
||||
|
||||
do l=1,N_microlist(0)
|
||||
do k=1,Nint
|
||||
microlist_zero(k,1,l) = microlist(k,1,l)
|
||||
microlist_zero(k,2,l) = microlist(k,2,l)
|
||||
enddo
|
||||
idx_microlist_zero(l) = idx_microlist(l)
|
||||
enddo
|
||||
end if
|
||||
end if
|
||||
|
||||
|
||||
do i_alpha=1,N_tq
|
||||
if(key_mask(1,1) /= 0) then
|
||||
call getMobiles(tq(1,1,i_alpha), key_mask, mobiles, Nint)
|
||||
|
||||
if(N_microlist(mobiles(1)) < N_microlist(mobiles(2))) then
|
||||
smallerlist = mobiles(1)
|
||||
else
|
||||
smallerlist = mobiles(2)
|
||||
end if
|
||||
|
||||
|
||||
do l=0,N_microlist(smallerlist)-1
|
||||
microlist_zero(:,:,ptr_microlist(1) + l) = microlist(:,:,ptr_microlist(smallerlist) + l)
|
||||
idx_microlist_zero(ptr_microlist(1) + l) = idx_microlist(ptr_microlist(smallerlist) + l)
|
||||
end do
|
||||
|
||||
call get_excitation_degree_vector(microlist_zero,tq(1,1,i_alpha),degree_alpha,Nint,N_microlist(smallerlist)+N_microlist(0),idx_alpha)
|
||||
do j=1,idx_alpha(0)
|
||||
idx_alpha(j) = idx_microlist_zero(idx_alpha(j))
|
||||
end do
|
||||
|
||||
else
|
||||
call get_excitation_degree_vector(miniList,tq(1,1,i_alpha),degree_alpha,Nint,N_minilist,idx_alpha)
|
||||
do j=1,idx_alpha(0)
|
||||
idx_alpha(j) = idx_miniList(idx_alpha(j))
|
||||
end do
|
||||
end if
|
||||
|
||||
do l_sd=1,idx_alpha(0)
|
||||
k_sd = idx_alpha(l_sd)
|
||||
call i_h_j(tq(1,1,i_alpha),psi_non_ref(1,1,idx_alpha(l_sd)),Nint,hij_cache(k_sd))
|
||||
call get_s2(tq(1,1,i_alpha),psi_non_ref(1,1,idx_alpha(l_sd)),Nint,sij_cache(k_sd))
|
||||
!if(sij_cache(k_sd) /= 0D0) PRINT *, "SIJ ", sij_cache(k_sd)
|
||||
enddo
|
||||
|
||||
! |I>
|
||||
@ -295,26 +850,37 @@ subroutine mrcc_part_dress(delta_ij_, delta_ii_,delta_ij_s2_, delta_ii_s2_,i_gen
|
||||
enddo
|
||||
enddo
|
||||
do i_state=1,N_states
|
||||
if(dabs(psi_ref_coef(i_I,i_state)).ge.1.d-3)then
|
||||
if(dabs(psi_ref_coef(1,i_state)).ge.1.d-3)then
|
||||
do l_sd=1,idx_alpha(0)
|
||||
k_sd = idx_alpha(l_sd)
|
||||
p1 = 1
|
||||
hdress = dIa_hla(i_state,k_sd) * psi_ref_coef(i_I,i_state) / psi_ref_coef(p1,i_state)
|
||||
sdress = dIa_sla(i_state,k_sd) * psi_ref_coef(i_I,i_state) / psi_ref_coef(p1,i_state)
|
||||
!$OMP ATOMIC
|
||||
delta_ij_(i_state,k_sd,i_I) = delta_ij_(i_state,k_sd,i_I) + dIa_hla(i_state,k_sd)
|
||||
contrib(i_state) += hdress * psi_ref_coef(p1, i_state) * psi_non_ref_coef(k_sd, i_state)
|
||||
!$OMP ATOMIC
|
||||
delta_ii_(i_state,i_I) = delta_ii_(i_state,i_I) - dIa_hla(i_state,k_sd) * ci_inv(i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
delta_ij_(i_state,k_sd) += hdress
|
||||
!$OMP ATOMIC
|
||||
delta_ij_s2_(i_state,k_sd,i_I) = delta_ij_s2_(i_state,k_sd,i_I) + dIa_sla(i_state,k_sd)
|
||||
!delta_ii_(i_state,i_I) = delta_ii_(i_state,i_I) - dIa_hla(i_state,k_sd) * ci_inv(i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
delta_ii_(i_state) -= hdress / psi_ref_coef(p1,i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
!$OMP ATOMIC
|
||||
delta_ii_s2_(i_state,i_I) = delta_ii_s2_(i_state,i_I) - dIa_sla(i_state,k_sd) * ci_inv(i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
delta_ij_s2_(i_state,k_sd) += sdress
|
||||
!$OMP ATOMIC
|
||||
!delta_ii_s2_(i_state,i_I) = delta_ii_s2_(i_state,i_I) - dIa_sla(i_state,k_sd) * ci_inv(i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
delta_ii_s2_(i_state) -= sdress / psi_ref_coef(p1,i_state) * psi_non_ref_coef_transp(i_state,k_sd)
|
||||
enddo
|
||||
else
|
||||
delta_ii_(i_state,i_I) = 0.d0
|
||||
!stop "dress with coef < 1d-3"
|
||||
delta_ii_(i_state) = 0.d0
|
||||
do l_sd=1,idx_alpha(0)
|
||||
k_sd = idx_alpha(l_sd)
|
||||
p1 = 1
|
||||
hdress = dIa_hla(i_state,k_sd) * psi_ref_coef(i_I,i_state) / psi_ref_coef(p1,i_state)
|
||||
sdress = dIa_sla(i_state,k_sd) * psi_ref_coef(i_I,i_state) / psi_ref_coef(p1,i_state)
|
||||
!$OMP ATOMIC
|
||||
delta_ij_(i_state,k_sd,i_I) = delta_ij_(i_state,k_sd,i_I) + 0.5d0*dIa_hla(i_state,k_sd)
|
||||
delta_ij_(i_state,k_sd) = delta_ij_(i_state,k_sd) + 0.5d0*hdress
|
||||
!$OMP ATOMIC
|
||||
delta_ij_s2_(i_state,k_sd,i_I) = delta_ij_s2_(i_state,k_sd,i_I) + 0.5d0*dIa_sla(i_state,k_sd)
|
||||
delta_ij_s2_(i_state,k_sd) = delta_ij_s2_(i_state,k_sd) + 0.5d0*sdress
|
||||
enddo
|
||||
endif
|
||||
enddo
|
||||
@ -325,6 +891,56 @@ subroutine mrcc_part_dress(delta_ij_, delta_ii_,delta_ij_s2_, delta_ii_s2_,i_gen
|
||||
end
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ double precision, mrcc_previous_E, (N_states) ]
|
||||
implicit none
|
||||
BEGIN_DOC
|
||||
!energy difference between last two mrcc iterations
|
||||
END_DOC
|
||||
mrcc_previous_E(:) = ref_bitmask_energy
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ double precision, delta_ij_mrcc_zmq, (N_states,N_det_non_ref,N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ii_mrcc_zmq, (N_states, N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ij_s2_mrcc_zmq, (N_states,N_det_non_ref,N_det_ref) ]
|
||||
&BEGIN_PROVIDER [ double precision, delta_ii_s2_mrcc_zmq, (N_states, N_det_ref) ]
|
||||
use bitmasks
|
||||
implicit none
|
||||
|
||||
integer :: i,j,k
|
||||
|
||||
double precision, allocatable :: mrcc(:)
|
||||
double precision :: E_CI_before, relative_error
|
||||
double precision, save :: errr = 0d0
|
||||
|
||||
allocate(mrcc(N_states))
|
||||
|
||||
|
||||
delta_ij_mrcc_zmq = 0d0
|
||||
delta_ii_mrcc_zmq = 0d0
|
||||
delta_ij_s2_mrcc_zmq = 0d0
|
||||
delta_ii_s2_mrcc_zmq = 0d0
|
||||
|
||||
!call random_seed()
|
||||
E_CI_before = mrcc_E0_denominator(1) + nuclear_repulsion
|
||||
threshold_selectors = 1.d0
|
||||
threshold_generators = 1d0
|
||||
!errr = errr / 2d0
|
||||
if(errr /= 0d0) then
|
||||
errr = errr / 2d0 ! (-mrcc_E0_denominator(1) + mrcc_previous_E(1)) / 1d1
|
||||
else
|
||||
errr = 1d-4
|
||||
end if
|
||||
relative_error = errr
|
||||
print *, "RELATIVE ERROR", relative_error
|
||||
call ZMQ_mrcc(E_CI_before, mrcc, delta_ij_mrcc_zmq, delta_ij_s2_mrcc_zmq, abs(relative_error))
|
||||
!errr =
|
||||
mrcc_previous_E(:) = mrcc_E0_denominator(:)
|
||||
do i=N_det_non_ref,1,-1
|
||||
delta_ii_mrcc_zmq(:,1) -= delta_ij_mrcc_zmq(:, i, 1) / psi_ref_coef(1,1) * psi_non_ref_coef(i, 1)
|
||||
delta_ii_s2_mrcc_zmq(:,1) -= delta_ij_s2_mrcc_zmq(:, i, 1) / psi_ref_coef(1,1) * psi_non_ref_coef(i, 1)
|
||||
end do
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ double precision, delta_ij, (N_states,N_det_non_ref,N_det_ref) ]
|
||||
@ -336,8 +952,33 @@ end
|
||||
integer :: i, j, i_state
|
||||
|
||||
!mrmode : 1=mrcepa0, 2=mrsc2 add, 3=mrcc
|
||||
|
||||
if(mrmode == 3) then
|
||||
if(mrmode == 4) then
|
||||
do i = 1, N_det_ref
|
||||
do i_state = 1, N_states
|
||||
delta_ii(i_state,i)= delta_ii_mrcc_sto(i_state,i)
|
||||
delta_ii_s2(i_state,i)= delta_ii_s2_mrcc_sto(i_state,i)
|
||||
enddo
|
||||
do j = 1, N_det_non_ref
|
||||
do i_state = 1, N_states
|
||||
delta_ij(i_state,j,i) = delta_ij_mrcc_sto(i_state,j,i)
|
||||
delta_ij_s2(i_state,j,i) = delta_ij_s2_mrcc_sto(i_state,j,i)
|
||||
enddo
|
||||
end do
|
||||
end do
|
||||
else if(mrmode == 5) then
|
||||
do i = 1, N_det_ref
|
||||
do i_state = 1, N_states
|
||||
delta_ii(i_state,i)= delta_ii_mrcc_zmq(i_state,i)
|
||||
delta_ii_s2(i_state,i)= delta_ii_s2_mrcc_zmq(i_state,i)
|
||||
enddo
|
||||
do j = 1, N_det_non_ref
|
||||
do i_state = 1, N_states
|
||||
delta_ij(i_state,j,i) = delta_ij_mrcc_zmq(i_state,j,i)
|
||||
delta_ij_s2(i_state,j,i) = delta_ij_s2_mrcc_zmq(i_state,j,i)
|
||||
enddo
|
||||
end do
|
||||
end do
|
||||
else if(mrmode == 3) then
|
||||
do i = 1, N_det_ref
|
||||
do i_state = 1, N_states
|
||||
delta_ii(i_state,i)= delta_ii_mrcc(i_state,i)
|
||||
@ -407,6 +1048,19 @@ end
|
||||
else
|
||||
stop "invalid mrmode"
|
||||
end if
|
||||
|
||||
!if(mrmode == 2 .or. mrmode == 3) then
|
||||
! do i = 1, N_det_ref
|
||||
! do i_state = 1, N_states
|
||||
! delta_ii(i_state,i) += delta_ii_cancel(i_state,i)
|
||||
! enddo
|
||||
! do j = 1, N_det_non_ref
|
||||
! do i_state = 1, N_states
|
||||
! delta_ij(i_state,j,i) += delta_ij_cancel(i_state,j,i)
|
||||
! enddo
|
||||
! end do
|
||||
! end do
|
||||
!end if
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
@ -774,8 +1428,8 @@ end subroutine
|
||||
notf = notf+1
|
||||
|
||||
! call i_h_j(psi_non_ref(1,1,det_cepa0_idx(k)),psi_ref(1,1,J),N_int,HJk)
|
||||
contrib = delta_cas(II, J, i_state) * dij(J, det_cepa0_idx(k), i_state)
|
||||
contrib_s2 = delta_cas_s2(II, J, i_state) * dij(J, det_cepa0_idx(k), i_state)
|
||||
contrib = delta_cas(II, J, i_state)* dij(J, det_cepa0_idx(k), i_state)
|
||||
contrib_s2 = delta_cas_s2(II, J, i_state) * dij(J, det_cepa0_idx(k), i_state)
|
||||
|
||||
if(dabs(psi_ref_coef(J,i_state)).ge.1.d-3) then
|
||||
contrib2 = contrib / psi_ref_coef(J, i_state) * psi_non_ref_coef(det_cepa0_idx(i),i_state)
|
||||
|
||||
@ -208,7 +208,7 @@ subroutine mrsc2_dressing_slave(thread,iproc)
|
||||
|
||||
deallocate(delta)
|
||||
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,zmq_socket_push,worker_id) == -1) then
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,worker_id) == -1) then
|
||||
continue
|
||||
endif
|
||||
call end_zmq_to_qp_run_socket(zmq_to_qp_run_socket)
|
||||
|
||||
21
plugins/mrcepa0/energy.irp.f
Normal file
21
plugins/mrcepa0/energy.irp.f
Normal file
@ -0,0 +1,21 @@
|
||||
BEGIN_PROVIDER [ logical, initialize_mrcc_E0_denominator ]
|
||||
implicit none
|
||||
BEGIN_DOC
|
||||
! If true, initialize mrcc_E0_denominator
|
||||
END_DOC
|
||||
initialize_mrcc_E0_denominator = .True.
|
||||
END_PROVIDER
|
||||
|
||||
BEGIN_PROVIDER [ double precision, mrcc_E0_denominator, (N_states) ]
|
||||
implicit none
|
||||
BEGIN_DOC
|
||||
! E0 in the denominator of the mrcc
|
||||
END_DOC
|
||||
if (initialize_mrcc_E0_denominator) then
|
||||
mrcc_E0_denominator(1:N_states) = psi_energy(1:N_states)
|
||||
call write_double(6,mrcc_E0_denominator(1)+nuclear_repulsion, 'mrcc Energy denominator')
|
||||
else
|
||||
mrcc_E0_denominator = -huge(1.d0)
|
||||
endif
|
||||
END_PROVIDER
|
||||
|
||||
76
plugins/mrcepa0/mrcc_slave.irp.f
Normal file
76
plugins/mrcepa0/mrcc_slave.irp.f
Normal file
@ -0,0 +1,76 @@
|
||||
program mrcc_slave
|
||||
implicit none
|
||||
BEGIN_DOC
|
||||
! Helper program to compute the mrcc in distributed mode.
|
||||
END_DOC
|
||||
print *, "SLAVE"
|
||||
read_wf = .False.
|
||||
distributed_davidson = .False.
|
||||
SOFT_TOUCH read_wf distributed_davidson
|
||||
call provide_everything
|
||||
call switch_qp_run_to_master
|
||||
call run_wf
|
||||
end
|
||||
|
||||
subroutine provide_everything
|
||||
PROVIDE H_apply_buffer_allocated mo_bielec_integrals_in_map psi_det_generators psi_coef_generators psi_det_sorted_bit psi_selectors n_det_generators n_states generators_bitmask zmq_context
|
||||
end
|
||||
|
||||
subroutine run_wf
|
||||
use f77_zmq
|
||||
implicit none
|
||||
|
||||
integer(ZMQ_PTR), external :: new_zmq_to_qp_run_socket
|
||||
integer(ZMQ_PTR) :: zmq_to_qp_run_socket
|
||||
double precision :: energy(N_states_diag)
|
||||
character*(64) :: states(1)
|
||||
integer :: rc, i
|
||||
|
||||
call provide_everything
|
||||
|
||||
zmq_context = f77_zmq_ctx_new ()
|
||||
states(1) = 'mrcc'
|
||||
|
||||
zmq_to_qp_run_socket = new_zmq_to_qp_run_socket()
|
||||
|
||||
do
|
||||
|
||||
call wait_for_states(states,zmq_state,1)
|
||||
|
||||
if(trim(zmq_state) == 'Stopped') then
|
||||
|
||||
exit
|
||||
|
||||
else if (trim(zmq_state) == 'mrcc') then
|
||||
|
||||
! Selection
|
||||
! ---------
|
||||
|
||||
print *, 'mrcc'
|
||||
call zmq_get_psi(zmq_to_qp_run_socket,1,energy,N_states)
|
||||
|
||||
PROVIDE psi_bilinear_matrix_columns_loc psi_det_alpha_unique psi_det_beta_unique
|
||||
PROVIDE psi_bilinear_matrix_rows psi_det_sorted_order psi_bilinear_matrix_order
|
||||
PROVIDE psi_bilinear_matrix_transp_rows_loc psi_bilinear_matrix_transp_columns
|
||||
PROVIDE psi_bilinear_matrix_transp_order
|
||||
|
||||
!$OMP PARALLEL PRIVATE(i)
|
||||
i = omp_get_thread_num()
|
||||
call mrcc_slave_tcp(i, energy)
|
||||
!$OMP END PARALLEL
|
||||
print *, 'mrcc done'
|
||||
|
||||
endif
|
||||
|
||||
end do
|
||||
end
|
||||
|
||||
subroutine mrcc_slave_tcp(i,energy)
|
||||
implicit none
|
||||
double precision, intent(in) :: energy(N_states_diag)
|
||||
integer, intent(in) :: i
|
||||
logical :: lstop
|
||||
lstop = .False.
|
||||
call run_mrcc_slave(0,i,energy,lstop)
|
||||
end
|
||||
|
||||
27
plugins/mrcepa0/mrcc_sto.irp.f
Normal file
27
plugins/mrcepa0/mrcc_sto.irp.f
Normal file
@ -0,0 +1,27 @@
|
||||
program mrsc2sub
|
||||
implicit none
|
||||
double precision, allocatable :: energy(:)
|
||||
allocate (energy(N_states))
|
||||
|
||||
!!mrmode : 1=mrcepa0, 2=mrsc2 add, 3=mrcc
|
||||
mrmode = 4
|
||||
|
||||
read_wf = .True.
|
||||
SOFT_TOUCH read_wf
|
||||
call set_generators_bitmasks_as_holes_and_particles
|
||||
if (.True.) then
|
||||
integer :: i,j
|
||||
do j=1,N_states
|
||||
do i=1,N_det
|
||||
psi_coef(i,j) = CI_eigenvectors(i,j)
|
||||
enddo
|
||||
enddo
|
||||
SOFT_TOUCH psi_coef
|
||||
endif
|
||||
call run(N_states,energy)
|
||||
if(do_pt2)then
|
||||
call run_pt2(N_states,energy)
|
||||
endif
|
||||
deallocate(energy)
|
||||
end
|
||||
|
||||
38
plugins/mrcepa0/mrcc_stoch.irp.f
Normal file
38
plugins/mrcepa0/mrcc_stoch.irp.f
Normal file
@ -0,0 +1,38 @@
|
||||
program mrcc_stoch
|
||||
implicit none
|
||||
read_wf = .True.
|
||||
SOFT_TOUCH read_wf
|
||||
PROVIDE mo_bielec_integrals_in_map
|
||||
call run
|
||||
end
|
||||
|
||||
subroutine run
|
||||
implicit none
|
||||
integer :: i,j,k
|
||||
logical, external :: detEq
|
||||
|
||||
double precision, allocatable :: mrcc(:)
|
||||
integer :: degree
|
||||
integer :: n_det_before, to_select
|
||||
double precision :: threshold_davidson_in
|
||||
|
||||
double precision :: E_CI_before, relative_error
|
||||
|
||||
allocate (mrcc(N_states))
|
||||
mrcc = 0.d0
|
||||
!call random_seed()
|
||||
E_CI_before = mrcc_E0_denominator(1) + nuclear_repulsion
|
||||
threshold_selectors = 1.d0
|
||||
threshold_generators = 1d0
|
||||
relative_error = 5.d-2
|
||||
call ZMQ_mrcc(E_CI_before, mrcc, relative_error)
|
||||
!print *, 'Final step'
|
||||
!print *, 'N_det = ', N_det
|
||||
print *, 'mrcc = ', mrcc
|
||||
!print *, 'E = ', E_CI_before
|
||||
!print *, 'E+mrcc = ', E_CI_before+mrcc
|
||||
!print *, '-----'
|
||||
!call ezfio_set_full_ci_zmq_energy_mrcc(E_CI_before+mrcc(1))
|
||||
end
|
||||
|
||||
|
||||
640
plugins/mrcepa0/mrcc_stoch_routines.irp.f
Normal file
640
plugins/mrcepa0/mrcc_stoch_routines.irp.f
Normal file
@ -0,0 +1,640 @@
|
||||
BEGIN_PROVIDER [ integer, fragment_first ]
|
||||
implicit none
|
||||
fragment_first = first_det_of_teeth(1)
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
subroutine ZMQ_mrcc(E, mrcc, delta, delta_s2, relative_error)
|
||||
use dress_types
|
||||
use f77_zmq
|
||||
|
||||
implicit none
|
||||
|
||||
character(len=64000) :: task
|
||||
integer(ZMQ_PTR) :: zmq_to_qp_run_socket, zmq_socket_pull
|
||||
integer, external :: omp_get_thread_num
|
||||
double precision, intent(in) :: relative_error, E
|
||||
double precision, intent(out) :: mrcc(N_states)
|
||||
double precision, intent(out) :: delta(N_states, N_det_non_ref)
|
||||
double precision, intent(out) :: delta_s2(N_states, N_det_non_ref)
|
||||
|
||||
|
||||
integer :: i, j, k, Ncp
|
||||
|
||||
double precision, external :: omp_get_wtime
|
||||
double precision :: time
|
||||
double precision :: w(N_states)
|
||||
|
||||
|
||||
|
||||
provide nproc fragment_first fragment_count mo_bielec_integrals_in_map mo_mono_elec_integral mrcc_weight psi_selectors
|
||||
|
||||
w(:) = 0.d0
|
||||
w(mrcc_stoch_istate) = 1.d0
|
||||
call update_psi_average_norm_contrib(w)
|
||||
|
||||
|
||||
|
||||
|
||||
print *, '========== ================= ================= ================='
|
||||
print *, ' Samples Energy Stat. Error Seconds '
|
||||
print *, '========== ================= ================= ================='
|
||||
|
||||
call new_parallel_job(zmq_to_qp_run_socket,zmq_socket_pull, 'mrcc')
|
||||
|
||||
integer, external :: zmq_put_psi
|
||||
integer, external :: zmq_put_N_det_generators
|
||||
integer, external :: zmq_put_N_det_selectors
|
||||
integer, external :: zmq_put_dvector
|
||||
|
||||
if (zmq_put_psi(zmq_to_qp_run_socket,1) == -1) then
|
||||
stop 'Unable to put psi on ZMQ server'
|
||||
endif
|
||||
if (zmq_put_N_det_generators(zmq_to_qp_run_socket, 1) == -1) then
|
||||
stop 'Unable to put N_det_generators on ZMQ server'
|
||||
endif
|
||||
if (zmq_put_N_det_selectors(zmq_to_qp_run_socket, 1) == -1) then
|
||||
stop 'Unable to put N_det_selectors on ZMQ server'
|
||||
endif
|
||||
if (zmq_put_dvector(zmq_to_qp_run_socket,1,'energy',mrcc_e0_denominator,size(mrcc_e0_denominator)) == -1) then
|
||||
stop 'Unable to put energy on ZMQ server'
|
||||
endif
|
||||
|
||||
! do i=1,comb_teeth
|
||||
! print *, "TOOTH", first_det_of_teeth(i+1) - first_det_of_teeth(i)
|
||||
! end do
|
||||
|
||||
integer(ZMQ_PTR), external :: new_zmq_to_qp_run_socket
|
||||
integer :: ipos
|
||||
ipos=1
|
||||
do i=1,N_mrcc_jobs
|
||||
if(mrcc_jobs(i) > fragment_first) then
|
||||
write(task(ipos:ipos+20),'(I9,1X,I9,''|'')') 0, mrcc_jobs(i)
|
||||
ipos += 20
|
||||
if (ipos > 63980) then
|
||||
if (add_task_to_taskserver(zmq_to_qp_run_socket,trim(task(1:ipos))) == -1) then
|
||||
stop 'Unable to add task to task server'
|
||||
endif
|
||||
ipos=1
|
||||
endif
|
||||
else
|
||||
do j=1,fragment_count
|
||||
write(task(ipos:ipos+20),'(I9,1X,I9,''|'')') j, mrcc_jobs(i)
|
||||
ipos += 20
|
||||
if (ipos > 63980) then
|
||||
if (add_task_to_taskserver(zmq_to_qp_run_socket,trim(task(1:ipos))) == -1) then
|
||||
stop 'Unable to add task to task server'
|
||||
endif
|
||||
ipos=1
|
||||
endif
|
||||
end do
|
||||
end if
|
||||
end do
|
||||
if (ipos > 1) then
|
||||
if (add_task_to_taskserver(zmq_to_qp_run_socket,trim(task(1:ipos))) == -1) then
|
||||
stop 'Unable to add task to task server'
|
||||
endif
|
||||
endif
|
||||
|
||||
if (zmq_set_running(zmq_to_qp_run_socket) == -1) then
|
||||
print *, irp_here, ': Failed in zmq_set_running'
|
||||
endif
|
||||
|
||||
!$OMP PARALLEL DEFAULT(shared) NUM_THREADS(nproc+1) &
|
||||
!$OMP PRIVATE(i)
|
||||
i = omp_get_thread_num()
|
||||
if (i==0) then
|
||||
call mrcc_collector(zmq_socket_pull,E(mrcc_stoch_istate), relative_error, delta, delta_s2, mrcc)
|
||||
else
|
||||
call mrcc_slave_inproc(i)
|
||||
endif
|
||||
!$OMP END PARALLEL
|
||||
call end_parallel_job(zmq_to_qp_run_socket, zmq_socket_pull, 'mrcc')
|
||||
|
||||
print *, '========== ================= ================= ================='
|
||||
end subroutine
|
||||
|
||||
|
||||
subroutine mrcc_slave_inproc(i)
|
||||
implicit none
|
||||
integer, intent(in) :: i
|
||||
|
||||
call run_mrcc_slave(1,i,mrcc_e0_denominator)
|
||||
end
|
||||
|
||||
|
||||
subroutine mrcc_collector(zmq_socket_pull, E, relative_error, delta, delta_s2, mrcc)
|
||||
use dress_types
|
||||
use f77_zmq
|
||||
use bitmasks
|
||||
implicit none
|
||||
|
||||
|
||||
integer(ZMQ_PTR), intent(in) :: zmq_socket_pull
|
||||
double precision, intent(in) :: relative_error, E
|
||||
double precision, intent(out) :: mrcc(N_states)
|
||||
double precision, allocatable :: cp(:,:,:,:)
|
||||
|
||||
double precision, intent(out) :: delta(N_states, N_det_non_ref)
|
||||
double precision, intent(out) :: delta_s2(N_states, N_det_non_ref)
|
||||
double precision, allocatable :: delta_loc(:,:,:), delta_det(:,:,:,:)
|
||||
double precision, allocatable :: mrcc_detail(:,:)
|
||||
double precision :: mrcc_mwen(N_states)
|
||||
integer(ZMQ_PTR),external :: new_zmq_to_qp_run_socket
|
||||
integer(ZMQ_PTR) :: zmq_to_qp_run_socket
|
||||
|
||||
integer(ZMQ_PTR), external :: new_zmq_pull_socket
|
||||
integer(ZMQ_PTR) :: zmq_socket_pull
|
||||
|
||||
integer :: more
|
||||
integer :: i, j, k, i_state, N, ntask
|
||||
integer, allocatable :: task_id(:)
|
||||
integer :: Nindex
|
||||
integer, allocatable :: ind(:)
|
||||
double precision, save :: time0 = -1.d0
|
||||
double precision :: time, timeLast, old_tooth
|
||||
double precision, external :: omp_get_wtime
|
||||
integer :: cur_cp, old_cur_cp
|
||||
integer, allocatable :: parts_to_get(:)
|
||||
logical, allocatable :: actually_computed(:)
|
||||
integer :: total_computed
|
||||
|
||||
allocate(delta_det(N_states, N_det_non_ref, 0:comb_teeth+1, 2))
|
||||
allocate(cp(N_states, N_det_non_ref, N_cp, 2), mrcc_detail(N_states, N_det_generators))
|
||||
allocate(delta_loc(N_states, N_det_non_ref, 2))
|
||||
mrcc_detail = 0d0
|
||||
delta_det = 0d0
|
||||
!mrcc_detail = mrcc_detail / 0d0
|
||||
cp = 0d0
|
||||
total_computed = 0
|
||||
character*(512) :: task
|
||||
|
||||
allocate(actually_computed(N_det_generators), parts_to_get(N_det_generators))
|
||||
|
||||
mrcc_mwen =0.d0
|
||||
|
||||
parts_to_get(:) = 1
|
||||
if(fragment_first > 0) then
|
||||
do i=1,fragment_first
|
||||
parts_to_get(i) = fragment_count
|
||||
enddo
|
||||
endif
|
||||
|
||||
actually_computed = .false.
|
||||
|
||||
zmq_to_qp_run_socket = new_zmq_to_qp_run_socket()
|
||||
zmq_socket_pull = new_zmq_pull_socket()
|
||||
allocate(task_id(N_det_generators), ind(1))
|
||||
more = 1
|
||||
if (time0 < 0.d0) then
|
||||
call wall_time(time0)
|
||||
endif
|
||||
timeLast = time0
|
||||
cur_cp = 0
|
||||
old_cur_cp = 0
|
||||
pullLoop : do while (more == 1)
|
||||
call pull_mrcc_results(zmq_socket_pull, Nindex, ind, mrcc_mwen, delta_loc, task_id, ntask)
|
||||
|
||||
if(Nindex /= 1) stop "tried pull multiple Nindex"
|
||||
|
||||
do i=1,Nindex
|
||||
mrcc_detail(:, ind(i)) += mrcc_mwen(:)
|
||||
do j=1,N_cp !! optimizable
|
||||
if(cps(ind(i), j) > 0d0) then
|
||||
if(tooth_of_det(ind(i)) < cp_first_tooth(j)) stop "coef on supposedely deterministic det"
|
||||
double precision :: fac
|
||||
integer :: toothMwen
|
||||
logical :: fracted
|
||||
fac = cps(ind(i), j) / cps_N(j) * mrcc_weight_inv(ind(i)) * comb_step
|
||||
do k=1,N_det_non_ref
|
||||
do i_state=1,N_states
|
||||
cp(i_state,k,j,1) += delta_loc(i_state,k,1) * fac
|
||||
cp(i_state,k,j,2) += delta_loc(i_state,k,2) * fac
|
||||
end do
|
||||
end do
|
||||
end if
|
||||
end do
|
||||
toothMwen = tooth_of_det(ind(i))
|
||||
fracted = (toothMwen /= 0)
|
||||
if(fracted) fracted = (ind(i) == first_det_of_teeth(toothMwen))
|
||||
|
||||
if(fracted) then
|
||||
delta_det(:,:,toothMwen-1, 1) += delta_loc(:,:,1) * (1d0-fractage(toothMwen))
|
||||
delta_det(:,:,toothMwen-1, 2) += delta_loc(:,:,2) * (1d0-fractage(toothMwen))
|
||||
delta_det(:,:,toothMwen, 1) += delta_loc(:,:,1) * (fractage(toothMwen))
|
||||
delta_det(:,:,toothMwen, 2) += delta_loc(:,:,2) * (fractage(toothMwen))
|
||||
else
|
||||
delta_det(:,:,toothMwen, 1) += delta_loc(:,:,1)
|
||||
delta_det(:,:,toothMwen, 2) += delta_loc(:,:,2)
|
||||
end if
|
||||
|
||||
parts_to_get(ind(i)) -= 1
|
||||
if(parts_to_get(ind(i)) == 0) then
|
||||
actually_computed(ind(i)) = .true.
|
||||
!print *, "CONTRIB", ind(i), psi_non_ref_coef(ind(i),1), mrcc_detail(1, ind(i))
|
||||
total_computed += 1
|
||||
end if
|
||||
end do
|
||||
|
||||
integer, external :: zmq_delete_tasks
|
||||
if (zmq_delete_tasks(zmq_to_qp_run_socket,zmq_socket_pull,task_id,ntask,more) == -1) then
|
||||
stop 'Unable to delete tasks'
|
||||
endif
|
||||
|
||||
time = omp_get_wtime()
|
||||
|
||||
|
||||
|
||||
if(time - timeLast > 1d0 .or. more /= 1) then
|
||||
timeLast = time
|
||||
cur_cp = N_cp
|
||||
if(.not. actually_computed(mrcc_jobs(1))) cycle pullLoop
|
||||
|
||||
do i=2,N_det_generators
|
||||
if(.not. actually_computed(mrcc_jobs(i))) then
|
||||
print *, "first not comp", i
|
||||
cur_cp = done_cp_at(i-1)
|
||||
exit
|
||||
end if
|
||||
end do
|
||||
if(cur_cp == 0) cycle pullLoop
|
||||
|
||||
!!!!!!!!!!!!
|
||||
double precision :: su, su2, eqt, avg, E0, val
|
||||
integer, external :: zmq_abort
|
||||
su = 0d0
|
||||
su2 = 0d0
|
||||
|
||||
if(N_states > 1) stop "mrcc_stoch : N_states == 1"
|
||||
do i=1, int(cps_N(cur_cp))
|
||||
!if(.not. actually_computed(i)) stop "not computed"
|
||||
!call get_comb_val(comb(i), mrcc_detail, cp_first_tooth(cur_cp), val)
|
||||
call get_comb_val(comb(i), mrcc_detail, cur_cp, val)
|
||||
!val = mrcc_detail(1, i) * mrcc_weight_inv(i) * comb_step
|
||||
su += val ! cps(i, cur_cp) * val
|
||||
su2 += val**2 ! cps(i, cur_cp) * val**2
|
||||
end do
|
||||
avg = su / cps_N(cur_cp)
|
||||
eqt = dsqrt( ((su2 / cps_N(cur_cp)) - avg**2) / cps_N(cur_cp) )
|
||||
E0 = sum(mrcc_detail(1, :first_det_of_teeth(cp_first_tooth(cur_cp))-1))
|
||||
if(cp_first_tooth(cur_cp) <= comb_teeth) then
|
||||
E0 = E0 + mrcc_detail(1, first_det_of_teeth(cp_first_tooth(cur_cp))) * (1d0-fractage(cp_first_tooth(cur_cp)))
|
||||
end if
|
||||
call wall_time(time)
|
||||
if ((dabs(eqt) < relative_error .and. cps_N(cur_cp) >= 30) .or. total_computed == N_det_generators) then
|
||||
! Termination
|
||||
!print '(G10.3, 2X, F16.7, 2X, G16.3, 2X, F16.4, A20)', Nabove(tooth), avg+E, eqt, time-time0, ''
|
||||
! print *, "GREPME", cur_cp, E+E0+avg, eqt, time-time0, total_computed
|
||||
if (zmq_abort(zmq_to_qp_run_socket) == -1) then
|
||||
call sleep(1)
|
||||
if (zmq_abort(zmq_to_qp_run_socket) == -1) then
|
||||
print *, irp_here, ': Error in sending abort signal (2)'
|
||||
endif
|
||||
endif
|
||||
|
||||
else
|
||||
if (cur_cp > old_cur_cp) then
|
||||
old_cur_cp = cur_cp
|
||||
! print *, "GREPME", cur_cp, E+E0+avg, eqt, time-time0, total_computed
|
||||
!print '(G10.3, 2X, F16.7, 2X, G16.3, 2X, F16.4, A20)', Nabove(tooth), avg+E, eqt, time-time0, ''
|
||||
endif
|
||||
endif
|
||||
end if
|
||||
end do pullLoop
|
||||
|
||||
if(total_computed == N_det_generators) then
|
||||
print *, "TOTALLY COMPUTED"
|
||||
delta = 0d0
|
||||
delta_s2 = 0d0
|
||||
do i=comb_teeth+1,0,-1
|
||||
delta += delta_det(:,:,i,1)
|
||||
delta_s2 += delta_det(:,:,i,2)
|
||||
end do
|
||||
else
|
||||
|
||||
|
||||
delta = cp(:,:,cur_cp,1)
|
||||
delta_s2 = cp(:,:,cur_cp,2)
|
||||
|
||||
do i=cp_first_tooth(cur_cp)-1,0,-1
|
||||
delta += delta_det(:,:,i,1)
|
||||
delta_s2 += delta_det(:,:,i,2)
|
||||
end do
|
||||
|
||||
end if
|
||||
|
||||
mrcc(1) = E
|
||||
|
||||
call end_zmq_to_qp_run_socket(zmq_to_qp_run_socket)
|
||||
end subroutine
|
||||
|
||||
|
||||
integer function mrcc_find(v, w, sze, imin, imax)
|
||||
implicit none
|
||||
integer, intent(in) :: sze, imin, imax
|
||||
double precision, intent(in) :: v, w(sze)
|
||||
integer :: i,l,h
|
||||
integer, parameter :: block=64
|
||||
|
||||
l = imin
|
||||
h = imax-1
|
||||
|
||||
do while(h-l >= block)
|
||||
i = ishft(h+l,-1)
|
||||
if(w(i+1) > v) then
|
||||
h = i-1
|
||||
else
|
||||
l = i+1
|
||||
end if
|
||||
end do
|
||||
!DIR$ LOOP COUNT (64)
|
||||
do mrcc_find=l,h
|
||||
if(w(mrcc_find) >= v) then
|
||||
exit
|
||||
end if
|
||||
end do
|
||||
end function
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ integer, gen_per_cp ]
|
||||
&BEGIN_PROVIDER [ integer, comb_teeth ]
|
||||
&BEGIN_PROVIDER [ integer, N_cps_max ]
|
||||
implicit none
|
||||
comb_teeth = 16
|
||||
N_cps_max = 32
|
||||
!comb_per_cp = 64
|
||||
gen_per_cp = (N_det_generators / N_cps_max) + 1
|
||||
N_cps_max += 1
|
||||
!N_cps_max = N_det_generators / comb_per_cp + 1
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ integer, N_cp ]
|
||||
&BEGIN_PROVIDER [ double precision, cps_N, (N_cps_max) ]
|
||||
&BEGIN_PROVIDER [ integer, cp_first_tooth, (N_cps_max) ]
|
||||
&BEGIN_PROVIDER [ integer, done_cp_at, (N_det_generators) ]
|
||||
&BEGIN_PROVIDER [ double precision, cps, (N_det_generators, N_cps_max) ]
|
||||
&BEGIN_PROVIDER [ integer, N_mrcc_jobs ]
|
||||
&BEGIN_PROVIDER [ integer, mrcc_jobs, (N_det_generators) ]
|
||||
&BEGIN_PROVIDER [ double precision, comb, (N_det_generators) ]
|
||||
! subroutine get_carlo_workbatch(Ncp, tbc, cps, done_cp_at)
|
||||
implicit none
|
||||
logical, allocatable :: computed(:)
|
||||
integer :: i, j, last_full, dets(comb_teeth)
|
||||
integer :: k, l, cur_cp, under_det(comb_teeth+1)
|
||||
integer, allocatable :: iorder(:), first_cp(:)
|
||||
|
||||
allocate(iorder(N_det_generators), first_cp(N_cps_max+1))
|
||||
allocate(computed(N_det_generators))
|
||||
first_cp = 1
|
||||
cps = 0d0
|
||||
cur_cp = 1
|
||||
done_cp_at = 0
|
||||
|
||||
computed = .false.
|
||||
|
||||
N_mrcc_jobs = first_det_of_comb - 1
|
||||
do i=1, N_mrcc_jobs
|
||||
mrcc_jobs(i) = i
|
||||
computed(i) = .true.
|
||||
end do
|
||||
|
||||
l=first_det_of_comb
|
||||
call RANDOM_NUMBER(comb)
|
||||
do i=1,N_det_generators
|
||||
comb(i) = comb(i) * comb_step
|
||||
!DIR$ FORCEINLINE
|
||||
call add_comb(comb(i), computed, cps(1, cur_cp), N_mrcc_jobs, mrcc_jobs)
|
||||
|
||||
if(N_mrcc_jobs / gen_per_cp > (cur_cp-1) .or. N_mrcc_jobs == N_det_generators) then
|
||||
!if(mod(i, comb_per_cp) == 0 .or. N_mrcc_jobs == N_det_generators) then
|
||||
first_cp(cur_cp+1) = N_mrcc_jobs
|
||||
done_cp_at(N_mrcc_jobs) = cur_cp
|
||||
cps_N(cur_cp) = dfloat(i)
|
||||
if(N_mrcc_jobs /= N_det_generators) then
|
||||
cps(:, cur_cp+1) = cps(:, cur_cp)
|
||||
cur_cp += 1
|
||||
end if
|
||||
!cps(:, cur_cp) = cps(:, cur_cp) / dfloat(i)
|
||||
|
||||
if (N_mrcc_jobs == N_det_generators) exit
|
||||
end if
|
||||
do while (computed(l))
|
||||
l=l+1
|
||||
enddo
|
||||
k=N_mrcc_jobs+1
|
||||
mrcc_jobs(k) = l
|
||||
computed(l) = .True.
|
||||
N_mrcc_jobs = k
|
||||
enddo
|
||||
N_cp = cur_cp
|
||||
if(N_mrcc_jobs /= N_det_generators .or. N_cp > N_cps_max) then
|
||||
print *, N_mrcc_jobs, N_det_generators, N_cp, N_cps_max
|
||||
stop "carlo workcarlo_workbatch"
|
||||
end if
|
||||
|
||||
cur_cp = 0
|
||||
do i=1,N_mrcc_jobs
|
||||
if(done_cp_at(i) /= 0) cur_cp = done_cp_at(i)
|
||||
done_cp_at(i) = cur_cp
|
||||
end do
|
||||
|
||||
|
||||
under_det = 0
|
||||
cp_first_tooth = 0
|
||||
do i=1,N_mrcc_jobs
|
||||
do j=comb_teeth+1,1,-1
|
||||
if(mrcc_jobs(i) <= first_det_of_teeth(j)) then
|
||||
under_det(j) = under_det(j) + 1
|
||||
if(under_det(j) == first_det_of_teeth(j))then
|
||||
do l=done_cp_at(i)+1, N_cp
|
||||
cps(:first_det_of_teeth(j)-1, l) = 0d0
|
||||
cp_first_tooth(l) = j
|
||||
end do
|
||||
cps(first_det_of_teeth(j), done_cp_at(i)+1) = &
|
||||
cps(first_det_of_teeth(j), done_cp_at(i)+1) * fractage(j)
|
||||
end if
|
||||
else
|
||||
exit
|
||||
end if
|
||||
end do
|
||||
end do
|
||||
cps(:, N_cp) = 0d0
|
||||
cp_first_tooth(N_cp) = comb_teeth+1
|
||||
|
||||
iorder = -1132154665
|
||||
do i=1,N_cp-1
|
||||
call isort(mrcc_jobs(first_cp(i)+1:first_cp(i+1)),iorder,first_cp(i+1)-first_cp(i))
|
||||
end do
|
||||
! end subroutine
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
subroutine get_comb_val(stato, detail, cur_cp, val)
|
||||
implicit none
|
||||
integer, intent(in) :: cur_cp
|
||||
integer :: first
|
||||
double precision, intent(in) :: stato, detail(N_states, N_det_generators)
|
||||
double precision, intent(out) :: val
|
||||
double precision :: curs
|
||||
integer :: j, k
|
||||
integer, external :: mrcc_find
|
||||
|
||||
curs = 1d0 - stato
|
||||
val = 0d0
|
||||
first = cp_first_tooth(cur_cp)
|
||||
|
||||
do j = comb_teeth, first, -1
|
||||
!DIR$ FORCEINLINE
|
||||
k = mrcc_find(curs, mrcc_cweight,size(mrcc_cweight), first_det_of_teeth(j), first_det_of_teeth(j+1))
|
||||
!if(k < first_det_of_teeth(first)) exit
|
||||
if(k == first_det_of_teeth(first)) then
|
||||
val += detail(1, k) * mrcc_weight_inv(k) * comb_step * fractage(first)
|
||||
else
|
||||
val += detail(1, k) * mrcc_weight_inv(k) * comb_step
|
||||
end if
|
||||
|
||||
curs -= comb_step
|
||||
end do
|
||||
end subroutine
|
||||
|
||||
|
||||
subroutine get_comb(stato, dets)
|
||||
implicit none
|
||||
double precision, intent(in) :: stato
|
||||
integer, intent(out) :: dets(comb_teeth)
|
||||
double precision :: curs
|
||||
integer :: j
|
||||
integer, external :: mrcc_find
|
||||
|
||||
curs = 1d0 - stato
|
||||
do j = comb_teeth, 1, -1
|
||||
!DIR$ FORCEINLINE
|
||||
dets(j) = mrcc_find(curs, mrcc_cweight,size(mrcc_cweight), first_det_of_teeth(j), first_det_of_teeth(j+1))
|
||||
curs -= comb_step
|
||||
end do
|
||||
end subroutine
|
||||
|
||||
|
||||
subroutine add_comb(com, computed, cp, N, tbc)
|
||||
implicit none
|
||||
double precision, intent(in) :: com
|
||||
integer, intent(inout) :: N
|
||||
double precision, intent(inout) :: cp(N_det_non_ref)
|
||||
logical, intent(inout) :: computed(N_det_generators)
|
||||
integer, intent(inout) :: tbc(N_det_generators)
|
||||
integer :: i, k, l, dets(comb_teeth)
|
||||
|
||||
!DIR$ FORCEINLINE
|
||||
call get_comb(com, dets)
|
||||
|
||||
k=N+1
|
||||
do i = 1, comb_teeth
|
||||
l = dets(i)
|
||||
cp(l) += 1d0 ! mrcc_weight_inv(l) * comb_step
|
||||
if(.not.(computed(l))) then
|
||||
tbc(k) = l
|
||||
k = k+1
|
||||
computed(l) = .true.
|
||||
end if
|
||||
end do
|
||||
N = k-1
|
||||
end subroutine
|
||||
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ double precision, mrcc_weight, (N_det_generators) ]
|
||||
&BEGIN_PROVIDER [ double precision, mrcc_weight_inv, (N_det_generators) ]
|
||||
&BEGIN_PROVIDER [ double precision, mrcc_cweight, (N_det_generators) ]
|
||||
&BEGIN_PROVIDER [ double precision, mrcc_cweight_cache, (N_det_generators) ]
|
||||
&BEGIN_PROVIDER [ double precision, fractage, (comb_teeth) ]
|
||||
&BEGIN_PROVIDER [ double precision, comb_step ]
|
||||
&BEGIN_PROVIDER [ integer, first_det_of_teeth, (comb_teeth+1) ]
|
||||
&BEGIN_PROVIDER [ integer, first_det_of_comb ]
|
||||
&BEGIN_PROVIDER [ integer, tooth_of_det, (N_det_generators) ]
|
||||
implicit none
|
||||
integer :: i
|
||||
double precision :: norm_left, stato
|
||||
integer, external :: mrcc_find
|
||||
|
||||
mrcc_weight(1) = psi_coef_generators(1,1)**2
|
||||
mrcc_cweight(1) = psi_coef_generators(1,1)**2
|
||||
|
||||
do i=1,N_det_generators
|
||||
mrcc_weight(i) = psi_coef_generators(i,1)**2
|
||||
enddo
|
||||
|
||||
! Important to loop backwards for numerical precision
|
||||
mrcc_cweight(N_det_generators) = mrcc_weight(N_det_generators)
|
||||
do i=N_det_generators-1,1,-1
|
||||
mrcc_cweight(i) = mrcc_weight(i) + mrcc_cweight(i+1)
|
||||
end do
|
||||
|
||||
do i=1,N_det_generators
|
||||
mrcc_weight(i) = mrcc_weight(i) / mrcc_cweight(1)
|
||||
mrcc_cweight(i) = mrcc_cweight(i) / mrcc_cweight(1)
|
||||
enddo
|
||||
|
||||
do i=1,N_det_generators-1
|
||||
mrcc_cweight(i) = 1.d0 - mrcc_cweight(i+1)
|
||||
end do
|
||||
mrcc_cweight(N_det_generators) = 1.d0
|
||||
|
||||
norm_left = 1d0
|
||||
|
||||
comb_step = 1d0/dfloat(comb_teeth)
|
||||
first_det_of_comb = 1
|
||||
do i=1,N_det_generators
|
||||
if(mrcc_weight(i)/norm_left < .25d0*comb_step) then
|
||||
first_det_of_comb = i
|
||||
exit
|
||||
end if
|
||||
norm_left -= mrcc_weight(i)
|
||||
end do
|
||||
first_det_of_comb = max(2,first_det_of_comb)
|
||||
call write_int(6, first_det_of_comb-1, 'Size of deterministic set')
|
||||
|
||||
|
||||
comb_step = (1d0 - mrcc_cweight(first_det_of_comb-1)) * comb_step
|
||||
|
||||
stato = 1d0 - comb_step
|
||||
iloc = N_det_generators
|
||||
do i=comb_teeth, 1, -1
|
||||
integer :: iloc
|
||||
iloc = mrcc_find(stato, mrcc_cweight, N_det_generators, 1, iloc)
|
||||
first_det_of_teeth(i) = iloc
|
||||
fractage(i) = (mrcc_cweight(iloc) - stato) / mrcc_weight(iloc)
|
||||
stato -= comb_step
|
||||
end do
|
||||
first_det_of_teeth(comb_teeth+1) = N_det_generators + 1
|
||||
first_det_of_teeth(1) = first_det_of_comb
|
||||
|
||||
|
||||
if(first_det_of_teeth(1) /= first_det_of_comb) then
|
||||
print *, 'Error in ', irp_here
|
||||
stop "comb provider"
|
||||
endif
|
||||
|
||||
do i=1,N_det_generators
|
||||
mrcc_weight_inv(i) = 1.d0/mrcc_weight(i)
|
||||
enddo
|
||||
|
||||
tooth_of_det(:first_det_of_teeth(1)-1) = 0
|
||||
do i=1,comb_teeth
|
||||
tooth_of_det(first_det_of_teeth(i):first_det_of_teeth(i+1)-1) = i
|
||||
end do
|
||||
|
||||
!double precision :: cur
|
||||
!fractage = 1d0
|
||||
!do i=1,comb_teeth-1
|
||||
! cur = 1d0 - dfloat(i)*comb_step
|
||||
|
||||
!end do
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
27
plugins/mrcepa0/mrcc_zmq.irp.f
Normal file
27
plugins/mrcepa0/mrcc_zmq.irp.f
Normal file
@ -0,0 +1,27 @@
|
||||
program mrsc2sub
|
||||
implicit none
|
||||
double precision, allocatable :: energy(:)
|
||||
allocate (energy(N_states))
|
||||
|
||||
!mrmode : 1=mrcepa0, 2=mrsc2 add, 3=mrcc
|
||||
mrmode = 5
|
||||
|
||||
read_wf = .True.
|
||||
SOFT_TOUCH read_wf
|
||||
call set_generators_bitmasks_as_holes_and_particles
|
||||
if (.True.) then
|
||||
integer :: i,j
|
||||
do j=1,N_states
|
||||
do i=1,N_det
|
||||
psi_coef(i,j) = CI_eigenvectors(i,j)
|
||||
enddo
|
||||
enddo
|
||||
SOFT_TOUCH psi_coef
|
||||
endif
|
||||
call run(N_states,energy)
|
||||
if(do_pt2)then
|
||||
call run_pt2(N_states,energy)
|
||||
endif
|
||||
deallocate(energy)
|
||||
end
|
||||
|
||||
@ -41,15 +41,12 @@ subroutine run(N_st,energy)
|
||||
print *, 'Iteration', iteration, '/', n_it_mrcc_max
|
||||
print *, '==============================================='
|
||||
print *, ''
|
||||
E_old = sum(ci_energy_dressed(1:N_states))
|
||||
E_old = mrcc_e0_denominator(1) !sum(ci_energy_dressed(1:N_states))
|
||||
do i=1,N_st
|
||||
call write_double(6,ci_energy_dressed(i),"Energy")
|
||||
enddo
|
||||
call diagonalize_ci_dressed(lambda)
|
||||
E_new = sum(ci_energy_dressed(1:N_states))
|
||||
! if (.true.) then
|
||||
! provide delta_ij_mrcc_pouet
|
||||
! endif
|
||||
E_new = mrcc_e0_denominator(1) !sum(ci_energy_dressed(1:N_states))
|
||||
delta_E = (E_new - E_old)/dble(N_states)
|
||||
print *, ''
|
||||
call write_double(6,thresh_mrcc,"thresh_mrcc")
|
||||
|
||||
242
plugins/mrcepa0/run_mrcc_slave.irp.f
Normal file
242
plugins/mrcepa0/run_mrcc_slave.irp.f
Normal file
@ -0,0 +1,242 @@
|
||||
|
||||
BEGIN_PROVIDER [ integer, fragment_count ]
|
||||
implicit none
|
||||
BEGIN_DOC
|
||||
! Number of fragments for the deterministic part
|
||||
END_DOC
|
||||
fragment_count = 1 !! (elec_alpha_num-n_core_orb)**2
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
subroutine run_mrcc_slave(thread,iproc,energy)
|
||||
use f77_zmq
|
||||
implicit none
|
||||
|
||||
double precision, intent(in) :: energy(N_states_diag)
|
||||
integer, intent(in) :: thread, iproc
|
||||
integer :: rc, i
|
||||
|
||||
integer :: worker_id, task_id(1), ctask, ltask
|
||||
character*(512) :: task
|
||||
|
||||
integer(ZMQ_PTR),external :: new_zmq_to_qp_run_socket
|
||||
integer(ZMQ_PTR) :: zmq_to_qp_run_socket
|
||||
|
||||
integer(ZMQ_PTR), external :: new_zmq_push_socket
|
||||
integer(ZMQ_PTR) :: zmq_socket_push
|
||||
|
||||
logical :: done
|
||||
|
||||
double precision,allocatable :: mrcc_detail(:,:)
|
||||
integer :: ind(1)
|
||||
integer :: Nindex
|
||||
|
||||
integer(bit_kind),allocatable :: abuf(:,:,:)
|
||||
integer(bit_kind) :: mask(N_int,2), omask(N_int,2)
|
||||
|
||||
double precision,allocatable :: delta_ij_loc(:,:,:)
|
||||
double precision,allocatable :: delta_ii_loc(:,:)
|
||||
!double precision,allocatable :: delta_ij_s2_loc(:,:,:)
|
||||
!double precision,allocatable :: delta_ii_s2_loc(:,:)
|
||||
integer :: h,p,n
|
||||
logical :: ok
|
||||
double precision :: contrib(N_states)
|
||||
|
||||
allocate(delta_ij_loc(N_states,N_det_non_ref,2) &
|
||||
,delta_ii_loc(N_states,2))! &
|
||||
!,delta_ij_s2_loc(N_states,N_det_non_ref,N_det_ref) &
|
||||
!,delta_ii_s2_loc(N_states, N_det_ref))
|
||||
|
||||
|
||||
allocate(abuf(N_int, 2, N_det_non_ref))
|
||||
|
||||
allocate(mrcc_detail(N_states, N_det_generators))
|
||||
zmq_to_qp_run_socket = new_zmq_to_qp_run_socket()
|
||||
zmq_socket_push = new_zmq_push_socket(thread)
|
||||
call connect_to_taskserver(zmq_to_qp_run_socket,worker_id,thread)
|
||||
if(worker_id == -1) then
|
||||
print *, "WORKER -1"
|
||||
call end_zmq_to_qp_run_socket(zmq_to_qp_run_socket)
|
||||
call end_zmq_push_socket(zmq_socket_push,thread)
|
||||
return
|
||||
end if
|
||||
!buf%N = 0
|
||||
ctask = 1
|
||||
Nindex=1
|
||||
mrcc_detail = 0d0
|
||||
do
|
||||
call get_task_from_taskserver(zmq_to_qp_run_socket,worker_id, task_id(ctask), task)
|
||||
|
||||
done = task_id(ctask) == 0
|
||||
if (done) then
|
||||
ctask = ctask - 1
|
||||
else
|
||||
integer :: i_generator, i_i_generator, subset
|
||||
read (task,*) subset, ind
|
||||
|
||||
! if(buf%N == 0) then
|
||||
! ! Only first time
|
||||
! call create_selection_buffer(1, 2, buf)
|
||||
! end if
|
||||
do i_i_generator=1, Nindex
|
||||
contrib = 0d0
|
||||
i_generator = ind(i_i_generator)
|
||||
delta_ij_loc = 0d0
|
||||
delta_ii_loc = 0d0
|
||||
!delta_ij_s2_loc = 0d0
|
||||
!delta_ii_s2_loc = 0d0
|
||||
!call select_connected(i_generator,energy,mrcc_detail(1, i_i_generator),buf,subset)
|
||||
|
||||
!!!!!!!!!!!!!!!!!!!!!!
|
||||
!if(mod(gen, 1000) == 0) print *, "mrcc ", gen, "/", N_det_generators
|
||||
do h=1, hh_shortcut(0)
|
||||
call apply_hole_local(psi_det_generators(1,1,i_generator), hh_exists(1, h), mask, ok, N_int)
|
||||
if(.not. ok) cycle
|
||||
omask = 0_bit_kind
|
||||
if(hh_exists(1, h) /= 0) omask = mask
|
||||
n = 1
|
||||
do p=hh_shortcut(h), hh_shortcut(h+1)-1
|
||||
call apply_particle_local(mask, pp_exists(1, p), abuf(1,1,n), ok, N_int)
|
||||
if(ok) n = n + 1
|
||||
if(n > N_det_non_ref) stop "Buffer too small in MRCC..."
|
||||
end do
|
||||
n = n - 1
|
||||
|
||||
if(n /= 0) then
|
||||
call mrcc_part_dress_1c(delta_ij_loc(1,1,1), delta_ii_loc(1,1), delta_ij_loc(1,1,2), delta_ii_loc(1,2), &
|
||||
i_generator,n,abuf,N_int,omask,contrib)
|
||||
endif
|
||||
end do
|
||||
!!!!!!!!!!!!!!!!!!!!!!
|
||||
!print *, "contrib", i_generator, contrib
|
||||
mrcc_detail(:, i_i_generator) = contrib
|
||||
if(Nindex /= 1) stop "run_mrcc_slave multiple dress not supported"
|
||||
enddo
|
||||
endif
|
||||
|
||||
if(done .or. (ctask == size(task_id)) ) then
|
||||
! if(buf%N == 0 .and. ctask > 0) stop "uninitialized selection_buffer"
|
||||
do i=1, ctask
|
||||
call task_done_to_taskserver(zmq_to_qp_run_socket,worker_id,task_id(i))
|
||||
end do
|
||||
if(ctask > 0) then
|
||||
call push_mrcc_results(zmq_socket_push, Nindex, ind, mrcc_detail, delta_ij_loc(1,1,1), task_id(1), ctask)
|
||||
mrcc_detail(:,:Nindex) = 0d0
|
||||
! buf%cur = 0
|
||||
end if
|
||||
ctask = 0
|
||||
end if
|
||||
|
||||
if(done) exit
|
||||
ctask = ctask + 1
|
||||
end do
|
||||
call disconnect_from_taskserver(zmq_to_qp_run_socket,worker_id)
|
||||
call end_zmq_to_qp_run_socket(zmq_to_qp_run_socket)
|
||||
call end_zmq_push_socket(zmq_socket_push,thread)
|
||||
! call delete_selection_buffer(buf)
|
||||
end subroutine
|
||||
|
||||
|
||||
subroutine push_mrcc_results(zmq_socket_push, N, ind, mrcc_detail, delta_loc, task_id, ntask)
|
||||
use f77_zmq
|
||||
implicit none
|
||||
|
||||
integer(ZMQ_PTR), intent(in) :: zmq_socket_push
|
||||
double precision, intent(in) :: mrcc_detail(N_states, N_det_generators)
|
||||
double precision, intent(in) :: delta_loc(N_states, N_det_non_ref, 2)
|
||||
integer, intent(in) :: ntask, N, ind(*), task_id(*)
|
||||
integer :: rc, i
|
||||
|
||||
if(N/=1) stop "mrcc_stoch, tried to push N>1"
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, N, 4, ZMQ_SNDMORE)
|
||||
if(rc /= 4) stop "push"
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, ind, 4*N, ZMQ_SNDMORE)
|
||||
if(rc /= 4*N) stop "push"
|
||||
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, mrcc_detail, 8*N_states*N, ZMQ_SNDMORE)
|
||||
if(rc /= 8*N_states*N) stop "push"
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, delta_loc(1,1,1), 8*N_states*N_det_non_ref*N, ZMQ_SNDMORE)
|
||||
if(rc /= 8*N_states*N_det_non_ref*N) stop "push"
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, delta_loc(1,1,2), 8*N_states*N_det_non_ref*N, ZMQ_SNDMORE)
|
||||
if(rc /= 8*N_states*N_det_non_ref*N) stop "push"
|
||||
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, ntask, 4, ZMQ_SNDMORE)
|
||||
if(rc /= 4) stop "push"
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, task_id, ntask*4, 0)
|
||||
if(rc /= 4*ntask) stop "push"
|
||||
|
||||
! Activate is zmq_socket_push is a REQ
|
||||
IRP_IF ZMQ_PUSH
|
||||
IRP_ELSE
|
||||
character*(2) :: ok
|
||||
rc = f77_zmq_recv( zmq_socket_push, ok, 2, 0)
|
||||
IRP_ENDIF
|
||||
|
||||
end subroutine
|
||||
|
||||
|
||||
subroutine pull_mrcc_results(zmq_socket_pull, N, ind, mrcc_detail, delta_loc, task_id, ntask)
|
||||
use f77_zmq
|
||||
implicit none
|
||||
integer(ZMQ_PTR), intent(in) :: zmq_socket_pull
|
||||
double precision, intent(inout) :: mrcc_detail(N_states)
|
||||
double precision, intent(inout) :: delta_loc(N_states, N_det_non_ref, 2)
|
||||
double precision, allocatable :: mrcc_dress_mwen(:,:)
|
||||
integer, intent(out) :: ind(*)
|
||||
integer, intent(out) :: N, ntask, task_id(*)
|
||||
integer :: rc, rn, i
|
||||
|
||||
allocate(mrcc_dress_mwen(N_states, N_det_non_ref))
|
||||
|
||||
rc = f77_zmq_recv( zmq_socket_pull, N, 4, 0)
|
||||
if(rc /= 4) stop "pull"
|
||||
if(N /= 1) stop "mrcc : pull with N>1 not supported"
|
||||
|
||||
rc = f77_zmq_recv( zmq_socket_pull, ind, 4, 0)
|
||||
if(rc /= 4*N) stop "pull"
|
||||
|
||||
rc = f77_zmq_recv( zmq_socket_pull, mrcc_detail, N_states*8*N, 0)
|
||||
if(rc /= 8*N_states*N) stop "pull"
|
||||
|
||||
!do i=1,N
|
||||
rc = f77_zmq_recv( zmq_socket_pull, delta_loc(1,1,1), N_states*8*N_det_non_ref, 0)
|
||||
if(rc /= 8*N_states*N_det_non_ref) stop "pull"
|
||||
!call add_to_dress_buffer(mrcc_dress(1), ind(i), mrcc_dress_mwen)
|
||||
!end do
|
||||
|
||||
!do i=1,N
|
||||
rc = f77_zmq_recv( zmq_socket_pull, delta_loc(1,1,2), N_states*8*N_det_non_ref, 0)
|
||||
if(rc /= 8*N_states*N_det_non_ref) stop "pull"
|
||||
!call add_to_dress_buffer(mrcc_dress(2), ind(i), mrcc_dress_mwen)
|
||||
!end do
|
||||
|
||||
rc = f77_zmq_recv( zmq_socket_pull, ntask, 4, 0)
|
||||
if(rc /= 4) stop "pull"
|
||||
|
||||
rc = f77_zmq_recv( zmq_socket_pull, task_id, ntask*4, 0)
|
||||
if(rc /= 4*ntask) stop "pull"
|
||||
|
||||
! Activate is zmq_socket_pull is a REP
|
||||
IRP_IF ZMQ_PUSH
|
||||
IRP_ELSE
|
||||
rc = f77_zmq_send( zmq_socket_pull, 'ok', 2, 0)
|
||||
IRP_ENDIF
|
||||
|
||||
end subroutine
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ double precision, mrcc_workload, (N_det_generators) ]
|
||||
integer :: i
|
||||
do i=1,N_det_generators
|
||||
mrcc_workload(i) = dfloat(N_det_generators - i + 1)**2
|
||||
end do
|
||||
mrcc_workload = mrcc_workload / sum(mrcc_workload)
|
||||
END_PROVIDER
|
||||
|
||||
@ -8,7 +8,6 @@ copy_buffer
|
||||
declarations
|
||||
decls_main
|
||||
deinit_thread
|
||||
skip
|
||||
init_main
|
||||
filter_integrals
|
||||
filter2p
|
||||
@ -56,7 +55,6 @@ parameters
|
||||
params_main
|
||||
printout_always
|
||||
printout_now
|
||||
skip
|
||||
subroutine
|
||||
""".split()
|
||||
|
||||
@ -82,25 +80,24 @@ class H_apply(object):
|
||||
self.energy = "CI_electronic_energy"
|
||||
self.perturbation = None
|
||||
self.do_double_exc = do_double_exc
|
||||
#s["omp_parallel"] = """!$OMP PARALLEL DEFAULT(NONE) &
|
||||
s["omp_parallel"] = """ PROVIDE elec_num_tab
|
||||
!$OMP PARALLEL DEFAULT(SHARED) &
|
||||
!$OMP PRIVATE(i,j,k,l,keys_out,hole,particle, &
|
||||
!$OMP occ_particle,occ_hole,j_a,k_a,other_spin, &
|
||||
!$OMP hole_save,ispin,jj,l_a,ib_jb_pairs,array_pairs, &
|
||||
!$OMP accu,i_a,hole_tmp,particle_tmp,occ_particle_tmp, &
|
||||
!$OMP occ_hole_tmp,key_idx,i_b,j_b,key,N_elec_in_key_part_1,&
|
||||
!$OMP N_elec_in_key_hole_1,N_elec_in_key_part_2, &
|
||||
!$OMP N_elec_in_key_hole_2,ia_ja_pairs,key_union_hole_part) &
|
||||
!$OMP SHARED(key_in,N_int,elec_num_tab,mo_tot_num, &
|
||||
!$OMP hole_1, particl_1, hole_2, particl_2, &
|
||||
!$OMP elec_alpha_num,i_generator) FIRSTPRIVATE(iproc)"""
|
||||
s["omp_end_parallel"] = "!$OMP END PARALLEL"
|
||||
s["omp_master"] = "!$OMP MASTER"
|
||||
s["omp_end_master"] = "!$OMP END MASTER"
|
||||
s["omp_barrier"] = "!$OMP BARRIER"
|
||||
s["omp_do"] = "!$OMP DO SCHEDULE (static,1)"
|
||||
s["omp_enddo"] = "!$OMP ENDDO NOWAIT"
|
||||
# s["omp_parallel"] = """ PROVIDE elec_num_tab
|
||||
# !$OMP PARALLEL DEFAULT(SHARED) &
|
||||
# !$OMP PRIVATE(i,j,k,l,keys_out,hole,particle, &
|
||||
# !$OMP occ_particle,occ_hole,j_a,k_a,other_spin, &
|
||||
# !$OMP hole_save,ispin,jj,l_a,ib_jb_pairs,array_pairs, &
|
||||
# !$OMP accu,i_a,hole_tmp,particle_tmp,occ_particle_tmp, &
|
||||
# !$OMP occ_hole_tmp,key_idx,i_b,j_b,key,N_elec_in_key_part_1,&
|
||||
# !$OMP N_elec_in_key_hole_1,N_elec_in_key_part_2, &
|
||||
# !$OMP N_elec_in_key_hole_2,ia_ja_pairs,key_union_hole_part) &
|
||||
# !$OMP SHARED(key_in,N_int,elec_num_tab,mo_tot_num, &
|
||||
# !$OMP hole_1, particl_1, hole_2, particl_2, &
|
||||
# !$OMP elec_alpha_num,i_generator) FIRSTPRIVATE(iproc)"""
|
||||
# s["omp_end_parallel"] = "!$OMP END PARALLEL"
|
||||
# s["omp_master"] = "!$OMP MASTER"
|
||||
# s["omp_end_master"] = "!$OMP END MASTER"
|
||||
# s["omp_barrier"] = "!$OMP BARRIER"
|
||||
# s["omp_do"] = "!$OMP DO SCHEDULE (static,1)"
|
||||
# s["omp_enddo"] = "!$OMP ENDDO"
|
||||
|
||||
d = { True : '.True.', False : '.False.'}
|
||||
s["do_mono_excitations"] = d[do_mono_exc]
|
||||
@ -289,11 +286,6 @@ class H_apply(object):
|
||||
"""
|
||||
|
||||
|
||||
def unset_skip(self):
|
||||
self["skip"] = """
|
||||
"""
|
||||
|
||||
|
||||
def set_filter_2h_2p(self):
|
||||
self["filter2h2p_double"] = """
|
||||
if (is_a_two_holes_two_particles(key)) cycle
|
||||
@ -400,9 +392,9 @@ class H_apply(object):
|
||||
pt2_old(k) = pt2(k)
|
||||
enddo
|
||||
"""
|
||||
self.data["omp_parallel"] += """&
|
||||
!$OMP SHARED(N_st) PRIVATE(e_2_pert_buffer,coef_pert_buffer) &
|
||||
!$OMP PRIVATE(sum_e_2_pert, sum_norm_pert, sum_H_pert_diag)"""
|
||||
# self.data["omp_parallel"] += """&
|
||||
# !$OMP SHARED(N_st) PRIVATE(e_2_pert_buffer,coef_pert_buffer) &
|
||||
# !$OMP PRIVATE(sum_e_2_pert, sum_norm_pert, sum_H_pert_diag)"""
|
||||
|
||||
def set_selection_pt2(self,pert):
|
||||
if self.selection_pt2 is not None:
|
||||
@ -434,22 +426,8 @@ class H_apply(object):
|
||||
call fill_H_apply_buffer_selection(key_idx,keys_out,e_2_pert_buffer, &
|
||||
coef_pert_buffer,N_st,N_int,iproc,select_max_out)
|
||||
"""
|
||||
self.data["omp_parallel"] += """&
|
||||
!$OMP REDUCTION (max:select_max_out)"""
|
||||
self.data["skip"] = """
|
||||
if (i_generator < size_select_max) then
|
||||
if (select_max(i_generator) < selection_criterion_min*selection_criterion_factor) then
|
||||
! OMP CRITICAL
|
||||
do k=1,N_st
|
||||
norm_psi(k) = norm_psi(k) + psi_coef_generators(i_generator,k)*psi_coef_generators(i_generator,k)
|
||||
pt2_old(k) = 0.d0
|
||||
enddo
|
||||
! OMP END CRITICAL
|
||||
cycle
|
||||
endif
|
||||
select_max(i_generator) = 0.d0
|
||||
endif
|
||||
"""
|
||||
# self.data["omp_parallel"] += """&
|
||||
# !$OMP REDUCTION (max:select_max_out)"""
|
||||
|
||||
|
||||
def unset_openmp(self):
|
||||
@ -498,15 +476,4 @@ class H_apply_zmq(H_apply):
|
||||
|
||||
def set_selection_pt2(self,pert):
|
||||
H_apply.set_selection_pt2(self,pert)
|
||||
self.data["skip"] = """
|
||||
if (i_generator < size_select_max) then
|
||||
if (select_max(i_generator) < selection_criterion_min*selection_criterion_factor) then
|
||||
do k=1,N_st
|
||||
pt2(k) = select_max(i_generator)
|
||||
enddo
|
||||
cycle
|
||||
endif
|
||||
select_max(i_generator) = 0.d0
|
||||
endif
|
||||
"""
|
||||
|
||||
|
||||
@ -45,7 +45,7 @@ subroutine davidson_run_slave(thread,iproc)
|
||||
call davidson_slave_work(zmq_to_qp_run_socket, zmq_socket_push, N_states_diag, N_det, worker_id)
|
||||
|
||||
integer, external :: disconnect_from_taskserver
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,zmq_socket_push,worker_id) == -1) then
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,worker_id) == -1) then
|
||||
continue
|
||||
endif
|
||||
|
||||
|
||||
@ -14,14 +14,6 @@ subroutine $subroutine_diexc(key_in, key_prev, hole_1,particl_1, hole_2, particl
|
||||
|
||||
$declarations
|
||||
|
||||
! print *, "bbbbbbbbbbbbbbb"
|
||||
! call debug_det(key_in, N_int)
|
||||
! call debug_det(hole_1, N_int)
|
||||
! call debug_det(hole_2, N_int)
|
||||
! call debug_det(particl_1, N_int)
|
||||
! call debug_det(particl_2, N_int)
|
||||
! print *, "eeeeeeeeeeeeeeee"
|
||||
|
||||
highest = 0
|
||||
do k=1,N_int*bit_kind_size
|
||||
status(k,1) = 0
|
||||
@ -43,32 +35,6 @@ subroutine $subroutine_diexc(key_in, key_prev, hole_1,particl_1, hole_2, particl
|
||||
end do
|
||||
end do
|
||||
|
||||
! ! GEL D'ELECTRONS
|
||||
! ! nt = 0
|
||||
! do i=1,i_generator-1
|
||||
! if(key_in(1,1) == key_prev(1,1,i)) then
|
||||
! tmp = xor(key_in(1,2), key_prev(1,2,i))
|
||||
! if(popcnt(tmp) == 2) then
|
||||
! ns = 1+trailz(iand(tmp, key_in(1,2)))
|
||||
! ! if(status(ns, 2) /= 0) then
|
||||
! ! nt += 1
|
||||
! ! end if
|
||||
! status(ns, 2) = 0
|
||||
! end if
|
||||
! else if(key_in(1,2) == key_prev(1,2,i)) then
|
||||
! tmp = xor(key_in(1,1), key_prev(1,1,i))
|
||||
! if(popcnt(tmp) == 2) then
|
||||
! ns = 1+trailz(iand(tmp, key_in(1,1)))
|
||||
! ! if(status(ns, 1) /= 0) then
|
||||
! ! nt += 1
|
||||
! ! end if
|
||||
! status(ns, 1) = 0
|
||||
! end if
|
||||
! end if
|
||||
! end do
|
||||
! ! print *, "nt", nt, i_generator
|
||||
|
||||
|
||||
do sp=1,2
|
||||
do p1=1,highest
|
||||
if(status(p1, sp) == 0) then
|
||||
|
||||
@ -9,7 +9,7 @@ subroutine $subroutine($params_main)
|
||||
|
||||
$decls_main
|
||||
|
||||
integer :: i_generator, nmax
|
||||
integer :: i_generator
|
||||
double precision :: wall_0, wall_1
|
||||
integer(bit_kind), allocatable :: mask(:,:,:)
|
||||
integer :: ispin, k
|
||||
@ -20,15 +20,11 @@ subroutine $subroutine($params_main)
|
||||
PROVIDE H_apply_buffer_allocated mo_bielec_integrals_in_map psi_det_generators psi_coef_generators
|
||||
|
||||
|
||||
nmax = mod( N_det_generators,nproc )
|
||||
|
||||
call wall_time(wall_0)
|
||||
|
||||
iproc = 0
|
||||
allocate( mask(N_int,2,6), fock_diag_tmp(2,mo_tot_num+1) )
|
||||
do i_generator=1,nmax
|
||||
|
||||
$skip
|
||||
do i_generator=1,N_det_generators
|
||||
|
||||
! Compute diagonal of the Fock matrix
|
||||
call build_fock_tmp(fock_diag_tmp,psi_det_generators(1,1,i_generator),N_int)
|
||||
@ -78,67 +74,6 @@ subroutine $subroutine($params_main)
|
||||
|
||||
deallocate( mask, fock_diag_tmp )
|
||||
|
||||
!$OMP PARALLEL DEFAULT(SHARED) &
|
||||
!$OMP PRIVATE(i_generator,wall_1,wall_0,ispin,k,mask,iproc,fock_diag_tmp)
|
||||
call wall_time(wall_0)
|
||||
!$ iproc = omp_get_thread_num()
|
||||
allocate( mask(N_int,2,6), fock_diag_tmp(2,mo_tot_num+1) )
|
||||
!$OMP DO SCHEDULE(dynamic,1)
|
||||
do i_generator=nmax+1,N_det_generators
|
||||
$skip
|
||||
|
||||
! Compute diagonal of the Fock matrix
|
||||
call build_fock_tmp(fock_diag_tmp,psi_det_generators(1,1,i_generator),N_int)
|
||||
|
||||
! Create bit masks for holes and particles
|
||||
do ispin=1,2
|
||||
do k=1,N_int
|
||||
mask(k,ispin,s_hole) = &
|
||||
iand(generators_bitmask(k,ispin,s_hole,i_bitmask_gen), &
|
||||
psi_det_generators(k,ispin,i_generator) )
|
||||
mask(k,ispin,s_part) = &
|
||||
iand(generators_bitmask(k,ispin,s_part,i_bitmask_gen), &
|
||||
not(psi_det_generators(k,ispin,i_generator)) )
|
||||
mask(k,ispin,d_hole1) = &
|
||||
iand(generators_bitmask(k,ispin,d_hole1,i_bitmask_gen), &
|
||||
psi_det_generators(k,ispin,i_generator) )
|
||||
mask(k,ispin,d_part1) = &
|
||||
iand(generators_bitmask(k,ispin,d_part1,i_bitmask_gen), &
|
||||
not(psi_det_generators(k,ispin,i_generator)) )
|
||||
mask(k,ispin,d_hole2) = &
|
||||
iand(generators_bitmask(k,ispin,d_hole2,i_bitmask_gen), &
|
||||
psi_det_generators(k,ispin,i_generator) )
|
||||
mask(k,ispin,d_part2) = &
|
||||
iand(generators_bitmask(k,ispin,d_part2,i_bitmask_gen), &
|
||||
not (psi_det_generators(k,ispin,i_generator)) )
|
||||
enddo
|
||||
enddo
|
||||
|
||||
if($do_double_excitations)then
|
||||
call $subroutine_diexc(psi_det_generators(1,1,i_generator), &
|
||||
psi_det_generators(1,1,1), &
|
||||
mask(1,1,d_hole1), mask(1,1,d_part1), &
|
||||
mask(1,1,d_hole2), mask(1,1,d_part2), &
|
||||
fock_diag_tmp, i_generator, iproc $params_post)
|
||||
endif
|
||||
if($do_mono_excitations)then
|
||||
call $subroutine_monoexc(psi_det_generators(1,1,i_generator), &
|
||||
mask(1,1,s_hole ), mask(1,1,s_part ), &
|
||||
fock_diag_tmp, i_generator, iproc $params_post)
|
||||
endif
|
||||
!$OMP CRITICAL
|
||||
call wall_time(wall_1)
|
||||
$printout_always
|
||||
if (wall_1 - wall_0 > 2.d0) then
|
||||
$printout_now
|
||||
wall_0 = wall_1
|
||||
endif
|
||||
!$OMP END CRITICAL
|
||||
enddo
|
||||
!$OMP END DO
|
||||
deallocate( mask, fock_diag_tmp )
|
||||
!$OMP END PARALLEL
|
||||
|
||||
$copy_buffer
|
||||
$generate_psi_guess
|
||||
|
||||
|
||||
@ -22,8 +22,8 @@ subroutine $subroutine($params_main)
|
||||
$initialization
|
||||
PROVIDE H_apply_buffer_allocated mo_bielec_integrals_in_map psi_det_generators psi_coef_generators
|
||||
|
||||
integer(ZMQ_PTR), external :: new_zmq_pair_socket, zmq_socket_pull
|
||||
integer(ZMQ_PTR) :: zmq_socket_pair
|
||||
integer(ZMQ_PTR), external :: new_zmq_pair_socket
|
||||
integer(ZMQ_PTR) :: zmq_socket_pair, zmq_socket_pull
|
||||
|
||||
integer(ZMQ_PTR) :: zmq_to_qp_run_socket
|
||||
double precision, allocatable :: pt2_generators(:,:), norm_pert_generators(:,:)
|
||||
@ -41,10 +41,10 @@ subroutine $subroutine($params_main)
|
||||
if (zmq_put_psi(zmq_to_qp_run_socket,1) == -1) then
|
||||
stop 'Unable to put psi on ZMQ server'
|
||||
endif
|
||||
if (zmq_put_N_det_generators(zmq_to_qp_run_socket, worker_id) == -1) then
|
||||
if (zmq_put_N_det_generators(zmq_to_qp_run_socket, 1) == -1) then
|
||||
stop 'Unable to put N_det_generators on ZMQ server'
|
||||
endif
|
||||
if (zmq_put_N_det_selectors(zmq_to_qp_run_socket, worker_id) == -1) then
|
||||
if (zmq_put_N_det_selectors(zmq_to_qp_run_socket, 1) == -1) then
|
||||
stop 'Unable to put N_det_selectors on ZMQ server'
|
||||
endif
|
||||
if (zmq_put_dvector(zmq_to_qp_run_socket,1,'energy',energy,size(energy)) == -1) then
|
||||
@ -67,7 +67,7 @@ subroutine $subroutine($params_main)
|
||||
PROVIDE nproc N_states
|
||||
!$OMP PARALLEL DEFAULT(NONE) &
|
||||
!$OMP PRIVATE(i) &
|
||||
!$OMP SHARED(zmq_socket_pair,N_states, pt2_generators, norm_pert_generators, H_pert_diag_generators, n, task_id, i_generator) &
|
||||
!$OMP SHARED(zmq_socket_pair,N_states, pt2_generators, norm_pert_generators, H_pert_diag_generators, n, task_id, i_generator,zmq_socket_pull) &
|
||||
!$OMP num_threads(nproc+1)
|
||||
i = omp_get_thread_num()
|
||||
if (i == 0) then
|
||||
@ -213,7 +213,7 @@ subroutine $subroutine_slave(thread, iproc)
|
||||
|
||||
|
||||
integer, external :: disconnect_from_taskserver
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,zmq_socket_push,worker_id) == -1) then
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,worker_id) == -1) then
|
||||
continue
|
||||
endif
|
||||
call end_zmq_push_socket(zmq_socket_push,thread)
|
||||
|
||||
@ -177,14 +177,15 @@ BEGIN_PROVIDER [ double precision, psi_coef, (psi_det_size,N_states) ]
|
||||
|
||||
integer :: i,k, N_int2
|
||||
logical :: exists
|
||||
double precision, allocatable :: psi_coef_read(:,:)
|
||||
character*(64) :: label
|
||||
|
||||
|
||||
PROVIDE read_wf N_det mo_label ezfio_filename
|
||||
psi_coef = 0.d0
|
||||
do i=1,min(N_states,psi_det_size)
|
||||
psi_coef(i,i) = 1.d0
|
||||
enddo
|
||||
|
||||
|
||||
if (mpi_master) then
|
||||
if (read_wf) then
|
||||
call ezfio_has_determinants_psi_coef(exists)
|
||||
@ -195,12 +196,21 @@ BEGIN_PROVIDER [ double precision, psi_coef, (psi_det_size,N_states) ]
|
||||
exists = (label == mo_label)
|
||||
endif
|
||||
endif
|
||||
if (exists) then
|
||||
call ezfio_get_determinants_psi_coef(psi_coef)
|
||||
endif
|
||||
endif
|
||||
|
||||
if (exists) then
|
||||
|
||||
allocate (psi_coef_read(N_det,N_states))
|
||||
call ezfio_get_determinants_psi_coef(psi_coef_read)
|
||||
do k=1,N_states
|
||||
do i=1,N_det
|
||||
psi_coef(i,k) = psi_coef_read(i,k)
|
||||
enddo
|
||||
enddo
|
||||
deallocate(psi_coef_read)
|
||||
print *, 'Read psi_coef'
|
||||
|
||||
endif
|
||||
print *, 'Read psi_coef'
|
||||
endif
|
||||
IRP_IF MPI
|
||||
include 'mpif.h'
|
||||
@ -517,6 +527,7 @@ subroutine save_wavefunction_general(ndet,nstates,psidet,dim_psicoef,psicoef)
|
||||
call ezfio_set_determinants_mo_label(mo_label)
|
||||
|
||||
allocate (psi_det_save(N_int,2,ndet))
|
||||
!$OMP PARALLEL DO DEFAULT(NONE) PRIVATE(i,j,k) SHARED(psi_det_save,psidet,ndet,N_int)
|
||||
do i=1,ndet
|
||||
do j=1,2
|
||||
do k=1,N_int
|
||||
@ -524,6 +535,7 @@ subroutine save_wavefunction_general(ndet,nstates,psidet,dim_psicoef,psicoef)
|
||||
enddo
|
||||
enddo
|
||||
enddo
|
||||
!$OMP END PARALLEL DO
|
||||
call ezfio_set_determinants_psi_det(psi_det_save)
|
||||
deallocate (psi_det_save)
|
||||
|
||||
|
||||
@ -261,10 +261,6 @@ subroutine four_index_transform_block(map_a,map_c,matrix_B,LDB, &
|
||||
enddo
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
!$OMP CRITICAL
|
||||
call map_update(map_c, key, value, idx,1.d-15)
|
||||
!$OMP END CRITICAL
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
subroutine four_index_transform_slave(map_a,map_c,matrix_B,LDB, &
|
||||
subroutine four_index_transform_slave_work(map_a,matrix_B,LDB, &
|
||||
i_start, j_start, k_start, l_start, &
|
||||
i_end , j_end , k_end , l_end , &
|
||||
a_start, b_start, c_start, d_start, &
|
||||
@ -13,7 +13,6 @@ subroutine four_index_transform_slave(map_a,map_c,matrix_B,LDB, &
|
||||
! Loops run over *_start->*_end
|
||||
END_DOC
|
||||
type(map_type), intent(in) :: map_a
|
||||
type(map_type), intent(inout) :: map_c
|
||||
integer, intent(in) :: LDB
|
||||
double precision, intent(in) :: matrix_B(LDB,*)
|
||||
integer, intent(in) :: i_start, j_start, k_start, l_start
|
||||
@ -66,7 +65,14 @@ subroutine four_index_transform_slave(map_a,map_c,matrix_B,LDB, &
|
||||
integer*8 :: new_size
|
||||
new_size = max(1024_8, 5_8 * map_a % n_elements )
|
||||
|
||||
allocate(a_array_ik(new_size), a_array_j(new_size), a_array_value(new_size))
|
||||
integer*8 :: tempspace
|
||||
integer :: npass, l_block
|
||||
|
||||
tempspace = (new_size * 16_8) / (1024_8 * 1024_8)
|
||||
npass = int(min(int(l_end-l_start,8),1_8 + tempspace / 1024_8),4) ! 1 GiB of scratch space
|
||||
l_block = (l_end-l_start+1)/npass
|
||||
|
||||
allocate(a_array_ik(new_size/npass), a_array_j(new_size/npass), a_array_value(new_size/npass))
|
||||
|
||||
|
||||
allocate(l_pointer(l_start:l_end+1), value((i_max*k_max)) )
|
||||
@ -127,18 +133,18 @@ subroutine four_index_transform_slave(map_a,map_c,matrix_B,LDB, &
|
||||
!open(unit=10,file='OUTPUT',form='FORMATTED')
|
||||
! END INPUT DATA
|
||||
|
||||
|
||||
!$OMP PARALLEL DEFAULT(NONE) SHARED(a_array_ik,a_array_j,a_array_value, &
|
||||
!$OMP a_start,a_end,b_start,b_end,c_start,c_end,d_start,d_end,&
|
||||
!$OMP i_start,i_end,j_start,j_end,k_start,k_end,l_start,l_end,&
|
||||
!$OMP i_min,i_max,j_min,j_max,k_min,k_max,l_min,l_max, &
|
||||
!$OMP map_c,matrix_B,l_pointer) &
|
||||
!$OMP matrix_B,l_pointer,thread,task_id) &
|
||||
!$OMP PRIVATE(key,value,T,U,V,i,j,k,l,idx,ik,ll, &
|
||||
!$OMP a,b,c,d,tmp,T2d,V2d,ii)
|
||||
!$OMP a,b,c,d,p,q,tmp,T2d,V2d,ii,zmq_socket_push)
|
||||
allocate( key(i_max*j_max*k_max), value(i_max*j_max*k_max) )
|
||||
allocate( U(a_start:a_end, c_start:c_end, b_start:b_end) )
|
||||
|
||||
integer(ZMQ_PTR) :: zmq_socket_push
|
||||
integer(ZMQ_PTR), external :: new_zmq_push_socket
|
||||
zmq_socket_push = new_zmq_push_socket(thread)
|
||||
|
||||
|
||||
@ -232,22 +238,27 @@ subroutine four_index_transform_slave(map_a,map_c,matrix_B,LDB, &
|
||||
enddo
|
||||
|
||||
idx = 0_8
|
||||
|
||||
integer :: p, q
|
||||
do b=b_start,d
|
||||
q = b+ishft(d*d-d,-1)
|
||||
do c=c_start,c_end
|
||||
p = a_start+ishft(c*c-c,-1)
|
||||
do a=a_start,min(b,c)
|
||||
if (dabs(U(a,c,b)) < 1.d-15) then
|
||||
cycle
|
||||
endif
|
||||
if ((a==b).and.(p>q)) cycle
|
||||
p = p+1
|
||||
idx = idx+1_8
|
||||
call bielec_integrals_index(a,b,c,d,key(idx))
|
||||
!print *, int(key(idx),4), int(a,2),int(b,2),int(c,2),int(d,2), p, q
|
||||
value(idx) = U(a,c,b)
|
||||
enddo
|
||||
enddo
|
||||
enddo
|
||||
|
||||
!$OMP CRITICAL
|
||||
call four_idx_push_results(zmq_socket_push, key, value, idx, task_id)
|
||||
!$OMP END CRITICAL
|
||||
call four_idx_push_results(zmq_socket_push, key, value, idx, -task_id)
|
||||
|
||||
!WRITE OUTPUT
|
||||
! OMP CRITICAL
|
||||
@ -268,10 +279,13 @@ subroutine four_index_transform_slave(map_a,map_c,matrix_B,LDB, &
|
||||
|
||||
enddo
|
||||
!$OMP END DO
|
||||
call end_zmq_push_socket(zmq_socket_push,thread)
|
||||
deallocate(key,value,V,T)
|
||||
!$OMP BARRIER
|
||||
!$OMP MASTER
|
||||
call four_idx_push_results(zmq_socket_push, 0_8, 0.d0, 0, task_id)
|
||||
!$OMP END MASTER
|
||||
call end_zmq_push_socket(zmq_socket_push)
|
||||
!$OMP END PARALLEL
|
||||
call map_merge(map_c)
|
||||
|
||||
deallocate(l_pointer)
|
||||
deallocate(a_array_ik,a_array_j,a_array_value)
|
||||
361
src/FourIdx/four_index_zmq.irp.f
Normal file
361
src/FourIdx/four_index_zmq.irp.f
Normal file
@ -0,0 +1,361 @@
|
||||
subroutine four_index_transform_zmq(map_a,map_c,matrix_B,LDB, &
|
||||
i_start, j_start, k_start, l_start, &
|
||||
i_end , j_end , k_end , l_end , &
|
||||
a_start, b_start, c_start, d_start, &
|
||||
a_end , b_end , c_end , d_end )
|
||||
implicit none
|
||||
use f77_zmq
|
||||
use map_module
|
||||
BEGIN_DOC
|
||||
! Performs a four-index transformation of map_a(N^4) into map_c(M^4) using b(NxM)
|
||||
! C_{abcd} = \sum_{ijkl} A_{ijkl}.B_{ia}.B_{jb}.B_{kc}.B_{ld}
|
||||
! Loops run over *_start->*_end
|
||||
END_DOC
|
||||
type(map_type), intent(in) :: map_a
|
||||
type(map_type), intent(inout) :: map_c
|
||||
integer, intent(in) :: LDB
|
||||
double precision, intent(in) :: matrix_B(LDB,*)
|
||||
integer, intent(in) :: i_start, j_start, k_start, l_start
|
||||
integer, intent(in) :: i_end , j_end , k_end , l_end
|
||||
integer, intent(in) :: a_start, b_start, c_start, d_start
|
||||
integer, intent(in) :: a_end , b_end , c_end , d_end
|
||||
|
||||
double precision, allocatable :: T(:,:), U(:,:,:), V(:,:)
|
||||
double precision, allocatable :: T2d(:,:), V2d(:,:)
|
||||
integer :: i_max, j_max, k_max, l_max
|
||||
integer :: i_min, j_min, k_min, l_min
|
||||
integer :: i, j, k, l, ik, ll
|
||||
integer :: l_start_block, l_end_block, l_block
|
||||
integer :: a, b, c, d
|
||||
double precision, external :: get_ao_bielec_integral
|
||||
integer*8 :: ii
|
||||
integer(key_kind) :: idx
|
||||
real(integral_kind) :: tmp
|
||||
integer(key_kind), allocatable :: key(:)
|
||||
real(integral_kind), allocatable :: value(:)
|
||||
integer*8, allocatable :: l_pointer(:)
|
||||
|
||||
ASSERT (k_start == i_start)
|
||||
ASSERT (l_start == j_start)
|
||||
ASSERT (a_start == c_start)
|
||||
ASSERT (b_start == d_start)
|
||||
|
||||
i_min = min(i_start,a_start)
|
||||
i_max = max(i_end ,a_end )
|
||||
j_min = min(j_start,b_start)
|
||||
j_max = max(j_end ,b_end )
|
||||
k_min = min(k_start,c_start)
|
||||
k_max = max(k_end ,c_end )
|
||||
l_min = min(l_start,d_start)
|
||||
l_max = max(l_end ,d_end )
|
||||
|
||||
ASSERT (0 < i_max)
|
||||
ASSERT (0 < j_max)
|
||||
ASSERT (0 < k_max)
|
||||
ASSERT (0 < l_max)
|
||||
ASSERT (LDB >= i_max)
|
||||
ASSERT (LDB >= j_max)
|
||||
ASSERT (LDB >= k_max)
|
||||
ASSERT (LDB >= l_max)
|
||||
|
||||
|
||||
integer(ZMQ_PTR) :: zmq_to_qp_run_socket
|
||||
integer(ZMQ_PTR) :: zmq_socket_pull
|
||||
call new_parallel_job(zmq_to_qp_run_socket,zmq_socket_pull,'four_idx')
|
||||
|
||||
integer*8 :: new_size
|
||||
new_size = max(1024_8, 5_8 * map_a % n_elements )
|
||||
|
||||
integer :: npass
|
||||
integer*8 :: tempspace
|
||||
|
||||
tempspace = (new_size * 16_8) / (1024_8 * 1024_8)
|
||||
npass = int(min(int(l_end-l_start,8),1_8 + tempspace / 1024_8),4) ! 1 GiB of scratch space
|
||||
l_block = (l_end-l_start+1)/npass
|
||||
|
||||
! Create tasks
|
||||
! ============
|
||||
|
||||
character(len=256) :: task
|
||||
|
||||
integer, external :: add_task_to_taskserver
|
||||
|
||||
do l_start_block = l_start, l_end, l_block
|
||||
l_end_block = min(l_end, l_start_block+l_block-1)
|
||||
write(task,'(16(I10,X))') &
|
||||
i_start, j_start, k_start, l_start_block, &
|
||||
i_end , j_end , k_end , l_end_block , &
|
||||
a_start, b_start, c_start, d_start, &
|
||||
a_end , b_end , c_end , d_end
|
||||
if (add_task_to_taskserver(zmq_to_qp_run_socket,trim(task)) == -1) then
|
||||
stop 'Unable to add task to server'
|
||||
endif
|
||||
enddo
|
||||
|
||||
integer, external :: zmq_set_running
|
||||
if (zmq_set_running(zmq_to_qp_run_socket) == -1) then
|
||||
print *, irp_here, ': Failed in zmq_set_running'
|
||||
endif
|
||||
|
||||
|
||||
PROVIDE nproc
|
||||
|
||||
call omp_set_nested(.True.)
|
||||
integer :: ithread
|
||||
!$OMP PARALLEL NUM_THREADS(2) PRIVATE(ithread)
|
||||
ithread = omp_get_thread_num()
|
||||
if (ithread==0) then
|
||||
call four_idx_collector(zmq_socket_pull,map_c)
|
||||
else
|
||||
call four_index_transform_slave_inproc(ithread)
|
||||
endif
|
||||
!$OMP END PARALLEL
|
||||
|
||||
call end_parallel_job(zmq_to_qp_run_socket, zmq_socket_pull, 'four_idx')
|
||||
|
||||
|
||||
end
|
||||
|
||||
|
||||
subroutine four_index_transform_slave_tcp(i)
|
||||
implicit none
|
||||
integer, intent(in) :: i
|
||||
BEGIN_DOC
|
||||
! Computes a buffer of integrals. i is the ID of the current thread.
|
||||
END_DOC
|
||||
call four_index_transform_slave(0,i)
|
||||
end
|
||||
|
||||
|
||||
subroutine four_index_transform_slave_inproc(i)
|
||||
implicit none
|
||||
integer, intent(in) :: i
|
||||
BEGIN_DOC
|
||||
! Computes a buffer of integrals. i is the ID of the current thread.
|
||||
END_DOC
|
||||
call four_index_transform_slave(1,i)
|
||||
end
|
||||
|
||||
|
||||
|
||||
subroutine four_index_transform_slave(thread,worker_id)
|
||||
use f77_zmq
|
||||
implicit none
|
||||
|
||||
integer(ZMQ_PTR) :: zmq_to_qp_run_socket
|
||||
integer,intent(in) :: worker_id, thread
|
||||
integer :: task_id
|
||||
character*(512) :: msg
|
||||
|
||||
integer :: i_start, j_start, k_start, l_start_block
|
||||
integer :: i_end , j_end , k_end , l_end_block
|
||||
integer :: a_start, b_start, c_start, d_start
|
||||
integer :: a_end , b_end , c_end , d_end
|
||||
|
||||
integer, external :: get_task_from_taskserver
|
||||
integer(ZMQ_PTR), external :: new_zmq_to_qp_run_socket
|
||||
|
||||
zmq_to_qp_run_socket = new_zmq_to_qp_run_socket()
|
||||
|
||||
integer, external :: connect_to_taskserver
|
||||
if (connect_to_taskserver(zmq_to_qp_run_socket,worker_id,thread) == -1) then
|
||||
call end_zmq_to_qp_run_socket(zmq_to_qp_run_socket)
|
||||
return
|
||||
endif
|
||||
|
||||
do
|
||||
if (get_task_from_taskserver(zmq_to_qp_run_socket,worker_id, task_id, msg) == -1) then
|
||||
exit
|
||||
endif
|
||||
if(task_id == 0) exit
|
||||
read (msg,*) &
|
||||
i_start, j_start, k_start, l_start_block, &
|
||||
i_end , j_end , k_end , l_end_block , &
|
||||
a_start, b_start, c_start, d_start, &
|
||||
a_end , b_end , c_end , d_end
|
||||
|
||||
call four_index_transform_slave_work(ao_integrals_map, &
|
||||
mo_coef, size(mo_coef,1), &
|
||||
i_start, j_start, k_start, l_start_block, &
|
||||
i_end , j_end , k_end , l_end_block , &
|
||||
a_start, b_start, c_start, d_start, &
|
||||
a_end , b_end , c_end , d_end, &
|
||||
task_id, thread)
|
||||
|
||||
integer, external :: task_done_to_taskserver
|
||||
if (task_done_to_taskserver(zmq_to_qp_run_socket,worker_id,task_id) == -1) then
|
||||
print *, irp_here, ': Unable to send task_done'
|
||||
stop
|
||||
endif
|
||||
|
||||
enddo
|
||||
integer, external :: disconnect_from_taskserver
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,thread) == -1) then
|
||||
call end_zmq_to_qp_run_socket(zmq_to_qp_run_socket)
|
||||
return
|
||||
endif
|
||||
call end_zmq_to_qp_run_socket(zmq_to_qp_run_socket)
|
||||
|
||||
end
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ integer, nthreads_four_idx ]
|
||||
implicit none
|
||||
BEGIN_DOC
|
||||
! Number of threads for 4-index transformation
|
||||
END_DOC
|
||||
nthreads_four_idx = nproc
|
||||
character*(32) :: env
|
||||
call getenv('NTHREADS_FOUR_IDX',env)
|
||||
if (trim(env) /= '') then
|
||||
read(env,*) nthreads_four_idx
|
||||
endif
|
||||
call write_int(6,nthreads_four_idx,'Number of threads for 4-index transformation')
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
|
||||
subroutine four_idx_collector(zmq_socket_pull,map_c)
|
||||
use f77_zmq
|
||||
use map_module
|
||||
implicit none
|
||||
type(map_type), intent(inout) :: map_c
|
||||
integer(ZMQ_PTR), intent(in) :: zmq_socket_pull
|
||||
|
||||
integer :: more
|
||||
integer, external :: zmq_delete_task
|
||||
integer(ZMQ_PTR), external :: new_zmq_to_qp_run_socket
|
||||
integer(ZMQ_PTR) :: zmq_to_qp_run_socket
|
||||
integer :: task_id
|
||||
|
||||
|
||||
zmq_to_qp_run_socket = new_zmq_to_qp_run_socket()
|
||||
|
||||
more = 1
|
||||
do while (more == 1)
|
||||
call four_idx_pull_results(zmq_socket_pull, map_c, task_id)
|
||||
if (task_id > 0) then
|
||||
if (zmq_delete_task(zmq_to_qp_run_socket,zmq_socket_pull,task_id,more) == -1) then
|
||||
stop 'Unable to delete task'
|
||||
endif
|
||||
endif
|
||||
enddo
|
||||
|
||||
call end_zmq_to_qp_run_socket(zmq_to_qp_run_socket)
|
||||
|
||||
end
|
||||
|
||||
|
||||
subroutine four_idx_pull_results(zmq_socket_pull, map_c, task_id)
|
||||
use f77_zmq
|
||||
use map_module
|
||||
implicit none
|
||||
type(map_type), intent(inout) :: map_c
|
||||
integer(ZMQ_PTR), intent(inout) :: zmq_socket_pull
|
||||
|
||||
integer, intent(out) :: task_id
|
||||
|
||||
integer :: rc, sze
|
||||
integer*8 :: rc8
|
||||
|
||||
|
||||
rc = f77_zmq_recv( zmq_socket_pull, task_id, 4, 0)
|
||||
if(rc /= 4) stop 'four_idx_pull_results failed to pull task_id'
|
||||
|
||||
if (task_id > 0) then
|
||||
IRP_IF ZMQ_PUSH
|
||||
IRP_ELSE
|
||||
rc = f77_zmq_send( zmq_socket_pull, 'ok', 2, 0)
|
||||
if (rc /= 2) then
|
||||
print *, irp_here, ' : f77_zmq_send (zmq_socket_pull,...'
|
||||
stop 'error'
|
||||
endif
|
||||
IRP_ENDIF
|
||||
call map_merge(map_c)
|
||||
return
|
||||
endif
|
||||
|
||||
rc = f77_zmq_recv( zmq_socket_pull, sze, 4, 0)
|
||||
if(rc /= 4) stop 'four_idx_pull_results failed to pull sze'
|
||||
|
||||
integer(key_kind), allocatable :: key(:)
|
||||
real(integral_kind), allocatable :: value(:)
|
||||
|
||||
allocate(key(sze), value(sze))
|
||||
|
||||
rc8 = f77_zmq_recv8( zmq_socket_pull, key, int(key_kind*sze,8), 0)
|
||||
if(rc8 /= key_kind*sze) stop 'four_idx_pull_results failed to pull key'
|
||||
|
||||
rc8 = f77_zmq_recv8( zmq_socket_pull, value, int(integral_kind*sze,8), 0)
|
||||
if(rc8 /= integral_kind*sze) stop 'four_idx_pull_results failed to pull value'
|
||||
|
||||
call map_update(map_c, key, value, sze, mo_integrals_threshold)
|
||||
|
||||
! Activate if zmq_socket_pull is a REP
|
||||
IRP_IF ZMQ_PUSH
|
||||
IRP_ELSE
|
||||
rc = f77_zmq_send( zmq_socket_pull, 'ok', 2, 0)
|
||||
if (rc /= 2) then
|
||||
print *, irp_here, ' : f77_zmq_send (zmq_socket_pull,...'
|
||||
stop 'error'
|
||||
endif
|
||||
IRP_ENDIF
|
||||
|
||||
deallocate(key, value)
|
||||
end
|
||||
|
||||
|
||||
|
||||
subroutine four_idx_push_results(zmq_socket_push, key, value, sze, task_id)
|
||||
use f77_zmq
|
||||
use map_module
|
||||
implicit none
|
||||
integer, intent(in) :: sze
|
||||
integer(key_kind), intent(in) :: key(sze)
|
||||
real(integral_kind), intent(in) :: value(sze)
|
||||
integer(ZMQ_PTR), intent(in) :: zmq_socket_push
|
||||
integer, intent(in) :: task_id
|
||||
|
||||
integer :: rc
|
||||
integer*8 :: rc8
|
||||
|
||||
|
||||
if (task_id > 0) then
|
||||
rc = f77_zmq_send( zmq_socket_push, task_id, 4, 0)
|
||||
if(rc /= 4) stop 'four_idx_push_results failed to push task_id'
|
||||
else
|
||||
rc = f77_zmq_send( zmq_socket_push, task_id, 4, ZMQ_SNDMORE)
|
||||
if(rc /= 4) stop 'four_idx_push_results failed to push task_id'
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, sze, 4, ZMQ_SNDMORE)
|
||||
if(rc /= 4) stop 'four_idx_push_results failed to push sze'
|
||||
|
||||
rc8 = f77_zmq_send8( zmq_socket_push, key, int(key_kind*sze,8), ZMQ_SNDMORE)
|
||||
if(rc8 /= key_kind*sze) then
|
||||
print *, sze, key_kind, rc8
|
||||
stop 'four_idx_push_results failed to push key'
|
||||
endif
|
||||
|
||||
rc8 = f77_zmq_send8( zmq_socket_push, value, int(integral_kind*sze,8), 0)
|
||||
if(rc8 /= integral_kind*sze) then
|
||||
print *, sze, integral_kind, rc8
|
||||
stop 'four_idx_push_results failed to push value'
|
||||
endif
|
||||
endif
|
||||
|
||||
|
||||
! Activate if zmq_socket_push is a REP
|
||||
IRP_IF ZMQ_PUSH
|
||||
IRP_ELSE
|
||||
character*(2) :: reply
|
||||
rc = f77_zmq_recv( zmq_socket_push, reply, 2, 0)
|
||||
if (reply(1:2) /= 'ok') then
|
||||
print *, reply(1:rc)
|
||||
print *, irp_here, ' : f77_zmq_send (zmq_socket_push,...'
|
||||
stop 'error'
|
||||
endif
|
||||
IRP_ENDIF
|
||||
|
||||
end
|
||||
|
||||
|
||||
@ -1,273 +0,0 @@
|
||||
subroutine four_index_transform_zmq(map_a,map_c,matrix_B,LDB, &
|
||||
i_start, j_start, k_start, l_start, &
|
||||
i_end , j_end , k_end , l_end , &
|
||||
a_start, b_start, c_start, d_start, &
|
||||
a_end , b_end , c_end , d_end )
|
||||
implicit none
|
||||
use f77_zmq
|
||||
use map_module
|
||||
BEGIN_DOC
|
||||
! Performs a four-index transformation of map_a(N^4) into map_c(M^4) using b(NxM)
|
||||
! C_{abcd} = \sum_{ijkl} A_{ijkl}.B_{ia}.B_{jb}.B_{kc}.B_{ld}
|
||||
! Loops run over *_start->*_end
|
||||
END_DOC
|
||||
type(map_type), intent(in) :: map_a
|
||||
type(map_type), intent(inout) :: map_c
|
||||
integer, intent(in) :: LDB
|
||||
double precision, intent(in) :: matrix_B(LDB,*)
|
||||
integer, intent(in) :: i_start, j_start, k_start, l_start
|
||||
integer, intent(in) :: i_end , j_end , k_end , l_end
|
||||
integer, intent(in) :: a_start, b_start, c_start, d_start
|
||||
integer, intent(in) :: a_end , b_end , c_end , d_end
|
||||
|
||||
double precision, allocatable :: T(:,:), U(:,:,:), V(:,:)
|
||||
double precision, allocatable :: T2d(:,:), V2d(:,:)
|
||||
integer :: i_max, j_max, k_max, l_max
|
||||
integer :: i_min, j_min, k_min, l_min
|
||||
integer :: i, j, k, l, ik, ll
|
||||
integer :: l_start_block, l_end_block, l_block
|
||||
integer :: a, b, c, d
|
||||
double precision, external :: get_ao_bielec_integral
|
||||
integer*8 :: ii
|
||||
integer(key_kind) :: idx
|
||||
real(integral_kind) :: tmp
|
||||
integer(key_kind), allocatable :: key(:)
|
||||
real(integral_kind), allocatable :: value(:)
|
||||
integer*8, allocatable :: l_pointer(:)
|
||||
|
||||
ASSERT (k_start == i_start)
|
||||
ASSERT (l_start == j_start)
|
||||
ASSERT (a_start == c_start)
|
||||
ASSERT (b_start == d_start)
|
||||
|
||||
i_min = min(i_start,a_start)
|
||||
i_max = max(i_end ,a_end )
|
||||
j_min = min(j_start,b_start)
|
||||
j_max = max(j_end ,b_end )
|
||||
k_min = min(k_start,c_start)
|
||||
k_max = max(k_end ,c_end )
|
||||
l_min = min(l_start,d_start)
|
||||
l_max = max(l_end ,d_end )
|
||||
|
||||
ASSERT (0 < i_max)
|
||||
ASSERT (0 < j_max)
|
||||
ASSERT (0 < k_max)
|
||||
ASSERT (0 < l_max)
|
||||
ASSERT (LDB >= i_max)
|
||||
ASSERT (LDB >= j_max)
|
||||
ASSERT (LDB >= k_max)
|
||||
ASSERT (LDB >= l_max)
|
||||
|
||||
|
||||
integer(ZMQ_PTR) :: zmq_to_qp_run_socket
|
||||
call new_parallel_job(zmq_to_qp_run_socket,'four_idx')
|
||||
|
||||
integer*8 :: new_size
|
||||
new_size = max(1024_8, 5_8 * map_a % n_elements )
|
||||
|
||||
integer :: npass
|
||||
integer*8 :: tempspace
|
||||
|
||||
tempspace = (new_size * 14_8) / (1024_8 * 1024_8)
|
||||
npass = min(l_end-l_start,1 + tempspace / 2048) ! 2 GiB of scratch space
|
||||
l_block = (l_end-l_start)/npass
|
||||
|
||||
! Create tasks
|
||||
! ============
|
||||
|
||||
character(len=64), allocatable :: task
|
||||
|
||||
do l_start_block = l_start, l_end, l_block
|
||||
l_end_block = min(l_end, l_start_block+l_block-1)
|
||||
write(task,'I10,X,I10') l_start_block, l_end_block
|
||||
call add_task_to_taskserver(zmq_to_qp_run_socket,trim(task))
|
||||
enddo
|
||||
|
||||
call zmq_set_running(zmq_to_qp_run_socket)
|
||||
|
||||
PROVIDE nproc
|
||||
|
||||
call omp_set_nested(.True.)
|
||||
integer :: ithread
|
||||
!$OMP PARALLEL NUM_THREADS(2) PRIVATE(ithread)
|
||||
ithread = omp_get_thread_num()
|
||||
if (ithread==0) then
|
||||
call four_idx_collector(zmq_to_qp_run_socket,map_c)
|
||||
else
|
||||
!TODO : Put strings of map_a and matrix_b on server and broadcast
|
||||
call four_index_transform_slave_inproc(map_a,map_c,matrix_B,LDB, &
|
||||
i_start, j_start, k_start, l_start_block, &
|
||||
i_end , j_end , k_end , l_end_block , &
|
||||
a_start, b_start, c_start, d_start, &
|
||||
a_end , b_end , c_end , d_end, 1 )
|
||||
endif
|
||||
!$OMP END PARALLEL
|
||||
|
||||
call end_parallel_job(zmq_to_qp_run_socket, 'four_idx')
|
||||
|
||||
|
||||
end
|
||||
|
||||
|
||||
subroutine four_idx_slave_work(zmq_to_qp_run_socket, worker_id)
|
||||
use f77_zmq
|
||||
implicit none
|
||||
|
||||
integer(ZMQ_PTR),intent(in) :: zmq_to_qp_run_socket
|
||||
integer,intent(in) :: worker_id
|
||||
integer :: task_id
|
||||
character*(512) :: msg
|
||||
|
||||
integer :: i_start, j_start, k_start, l_start_block
|
||||
integer :: i_end , j_end , k_end , l_end_block
|
||||
integer :: a_start, b_start, c_start, d_start
|
||||
integer :: a_end , b_end , c_end , d_end
|
||||
|
||||
!TODO : get map_a and matrix_B from server
|
||||
do
|
||||
call get_task_from_taskserver(zmq_to_qp_run_socket,worker_id, task_id, msg)
|
||||
if(task_id == 0) exit
|
||||
read (msg,*) LDB, &
|
||||
i_start, j_start, k_start, l_start_block, &
|
||||
i_end , j_end , k_end , l_end_block , &
|
||||
a_start, b_start, c_start, d_start, &
|
||||
a_end , b_end , c_end , d_end
|
||||
|
||||
call four_index_transform_slave(map_a,map_c,matrix_B,LDB, &
|
||||
i_start, j_start, k_start, l_start_block, &
|
||||
i_end , j_end , k_end , l_end_block , &
|
||||
a_start, b_start, c_start, d_start, &
|
||||
a_end , b_end , c_end , d_end, zmq_to_qp_run_socket, &
|
||||
task_id)
|
||||
call task_done_to_taskserver(zmq_to_qp_run_socket,worker_id,task_id)
|
||||
|
||||
enddo
|
||||
end
|
||||
|
||||
|
||||
BEGIN_PROVIDER [ integer, nthreads_four_idx ]
|
||||
implicit none
|
||||
BEGIN_DOC
|
||||
! Number of threads for 4-index transformation
|
||||
END_DOC
|
||||
nthreads_four_idx = nproc
|
||||
character*(32) :: env
|
||||
call getenv('NTHREADS_FOUR_IDX',env)
|
||||
if (trim(env) /= '') then
|
||||
read(env,*) nthreads_four_idx
|
||||
endif
|
||||
call write_int(6,nthreads_davidson,'Number of threads for 4-index transformation')
|
||||
END_PROVIDER
|
||||
|
||||
|
||||
|
||||
subroutine four_idx_collector(zmq_to_qp_run_socket,map_c)
|
||||
use f77_zmq
|
||||
use map_module
|
||||
implicit none
|
||||
type(map_type), intent(inout) :: map_c
|
||||
|
||||
integer :: more
|
||||
integer(ZMQ_PTR), external :: new_zmq_pull_socket
|
||||
integer(ZMQ_PTR) :: zmq_socket_pull
|
||||
|
||||
|
||||
more = 1
|
||||
zmq_socket_pull = new_zmq_pull_socket()
|
||||
|
||||
do while (more == 1)
|
||||
call four_idx_pull_results(zmq_socket_pull, map_c, task_id)
|
||||
call zmq_delete_task(zmq_to_qp_run_socket,zmq_socket_pull,task_id,more)
|
||||
enddo
|
||||
|
||||
call end_zmq_pull_socket(zmq_socket_pull)
|
||||
|
||||
end
|
||||
|
||||
|
||||
subroutine four_idx_pull_results(zmq_socket_pull, map_c, task_id)
|
||||
use f77_zmq
|
||||
use map_module
|
||||
implicit none
|
||||
type(map_type), intent(inout) :: map_c
|
||||
integer(ZMQ_PTR), intent(inout) :: zmq_socket_pull
|
||||
|
||||
integer, intent(out) :: task_id
|
||||
|
||||
integer :: rc, sze
|
||||
integer*8 :: rc8
|
||||
|
||||
|
||||
rc = f77_zmq_recv( zmq_socket_pull, task_id, 4, 0)
|
||||
if(rc /= 4) stop "four_idx_pull_results failed to pull task_id"
|
||||
|
||||
rc = f77_zmq_recv( zmq_socket_pull, sze, 4, 0)
|
||||
if(rc /= 4) stop "four_idx_pull_results failed to pull sze"
|
||||
|
||||
integer(key_kind), allocatable :: key(:)
|
||||
real(integral_kind), allocatable :: value(:)
|
||||
|
||||
allocate(key(sze), value(sze))
|
||||
|
||||
rc8 = f77_zmq_recv8( zmq_socket_pull, key, key_kind*sze, 0)
|
||||
if(rc8 /= key_kind*sze) stop "four_idx_pull_results failed to pull key"
|
||||
|
||||
rc8 = f77_zmq_recv8( zmq_socket_pull, value, integral_kind*sze, 0)
|
||||
if(rc8 /= integral_kind*sze) stop "four_idx_pull_results failed to pull value"
|
||||
|
||||
! Activate if zmq_socket_pull is a REP
|
||||
IRP_IF ZMQ_PUSH
|
||||
IRP_ELSE
|
||||
rc = f77_zmq_send( zmq_socket_pull, 0, 4, 0)
|
||||
if (rc /= 4) then
|
||||
print *, irp_here, ' : f77_zmq_send (zmq_socket_pull,...'
|
||||
stop 'error'
|
||||
endif
|
||||
IRP_ENDIF
|
||||
|
||||
call map_update(map_c, key, value, sze, 1.d-15) ! TODO : threshold
|
||||
|
||||
deallocate(key, value)
|
||||
end
|
||||
|
||||
|
||||
|
||||
subroutine four_idx_push_results(zmq_socket_push, key, value, sze, task_id)
|
||||
use f77_zmq
|
||||
use map_module
|
||||
implicit none
|
||||
integer, intent(in) :: sze
|
||||
integer(key_kind), intent(in) :: key(sze)
|
||||
real(integral_kind), intent(in) :: value(sze)
|
||||
integer(ZMQ_PTR), intent(in) :: zmq_socket_push
|
||||
integer, intent(in) :: task_id
|
||||
|
||||
integer :: rc, sze
|
||||
integer*8 :: rc8
|
||||
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, task_id, 4, ZMQ_SNDMORE)
|
||||
if(rc /= 4) stop "four_idx_push_results failed to push task_id"
|
||||
|
||||
rc = f77_zmq_send( zmq_socket_push, sze, 4, ZMQ_SNDMORE)
|
||||
if(rc /= 4) stop "four_idx_push_results failed to push sze"
|
||||
|
||||
rc8 = f77_zmq_send8( zmq_socket_push, key, key_kind*sze, ZMQ_SNDMORE)
|
||||
if(rc8 /= key_kind*sze) stop "four_idx_push_results failed to push key"
|
||||
|
||||
rc8 = f77_zmq_send8( zmq_socket_push, value, integral_kind*sze, 0)
|
||||
if(rc8 /= integral_kind*sze) stop "four_idx_push_results failed to push value"
|
||||
|
||||
! Activate if zmq_socket_push is a REP
|
||||
IRP_IF ZMQ_PUSH
|
||||
IRP_ELSE
|
||||
rc = f77_zmq_send( zmq_socket_push, 0, 4, 0)
|
||||
if (rc /= 4) then
|
||||
print *, irp_here, ' : f77_zmq_send (zmq_socket_push,...'
|
||||
stop 'error'
|
||||
endif
|
||||
IRP_ENDIF
|
||||
|
||||
end
|
||||
|
||||
|
||||
@ -126,7 +126,7 @@ subroutine ao_bielec_integrals_in_map_slave(thread,iproc)
|
||||
enddo
|
||||
|
||||
integer, external :: disconnect_from_taskserver
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,zmq_socket_push,worker_id) == -1) then
|
||||
if (disconnect_from_taskserver(zmq_to_qp_run_socket,worker_id) == -1) then
|
||||
continue
|
||||
endif
|
||||
deallocate( buffer_i, buffer_value )
|
||||
|
||||
@ -38,6 +38,11 @@ BEGIN_PROVIDER [ logical, mo_bielec_integrals_in_map ]
|
||||
else
|
||||
PROVIDE ao_bielec_integrals_in_map
|
||||
endif
|
||||
|
||||
print *, ''
|
||||
print *, 'AO -> MO integrals transformation'
|
||||
print *, '---------------------------------'
|
||||
print *, ''
|
||||
|
||||
if(no_vvvv_integrals)then
|
||||
integer :: i,j,k,l
|
||||
@ -119,11 +124,16 @@ BEGIN_PROVIDER [ logical, mo_bielec_integrals_in_map ]
|
||||
else
|
||||
! call add_integrals_to_map(full_ijkl_bitmask_4)
|
||||
|
||||
call four_index_transform_block(ao_integrals_map,mo_integrals_map, &
|
||||
call four_index_transform_zmq(ao_integrals_map,mo_integrals_map, &
|
||||
mo_coef, size(mo_coef,1), &
|
||||
1, 1, 1, 1, ao_num, ao_num, ao_num, ao_num, &
|
||||
1, 1, 1, 1, mo_num, mo_num, mo_num, mo_num)
|
||||
!
|
||||
! call four_index_transform_block(ao_integrals_map,mo_integrals_map, &
|
||||
! mo_coef, size(mo_coef,1), &
|
||||
! 1, 1, 1, 1, ao_num, ao_num, ao_num, ao_num, &
|
||||
! 1, 1, 1, 1, mo_num, mo_num, mo_num, mo_num)
|
||||
!
|
||||
! call four_index_transform(ao_integrals_map,mo_integrals_map, &
|
||||
! mo_coef, size(mo_coef,1), &
|
||||
! 1, 1, 1, 1, ao_num, ao_num, ao_num, ao_num, &
|
||||
|
||||
@ -691,15 +691,13 @@ integer function connect_to_taskserver(zmq_to_qp_run_socket,worker_id,thread)
|
||||
connect_to_taskserver = -1
|
||||
end
|
||||
|
||||
integer function disconnect_from_taskserver(zmq_to_qp_run_socket, &
|
||||
zmq_socket_push, worker_id)
|
||||
integer function disconnect_from_taskserver(zmq_to_qp_run_socket, worker_id)
|
||||
use f77_zmq
|
||||
implicit none
|
||||
BEGIN_DOC
|
||||
! Disconnect from the task server
|
||||
END_DOC
|
||||
integer(ZMQ_PTR), intent(in) :: zmq_to_qp_run_socket
|
||||
integer(ZMQ_PTR), intent(in) :: zmq_socket_push
|
||||
integer, intent(in) :: worker_id
|
||||
|
||||
integer :: rc, sze
|
||||
|
||||
Loading…
Reference in New Issue
Block a user