scnc
/
quantum-espresso
mirror of https://gitlab.com/QEF/q-e.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quantum-espresso/PW/regterg.f90

1392 lines
38 KiB
Fortran
Raw Normal View History

PW, Gamma and NEB are now unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@449 c92efa57-630b-4861-b058-cf58834340f0
2003-12-10 22:57:07 +08:00
!
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! Copyright (C) 2003-2006 Quantum-ESPRESSO group
PW, Gamma and NEB are now unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@449 c92efa57-630b-4861-b058-cf58834340f0
2003-12-10 22:57:07 +08:00
! This file is distributed under the terms of the
! GNU General Public License. See the file `License'
! in the root directory of the present distribution,
! or http://www.gnu.org/copyleft/gpl.txt .
!
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
#define ZERO ( 0.D0, 0.D0 )
#define ONE ( 1.D0, 0.D0 )
PW, Gamma and NEB are now unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@449 c92efa57-630b-4861-b058-cf58834340f0
2003-12-10 22:57:07 +08:00
!
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
#include "f_defs.h"
!
!----------------------------------------------------------------------------
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
SUBROUTINE regterg( npw, npwx, nvec, nvecx, evc, ethr, &
Fixed an array out of bound in Gram-Schmidt. Cleanup of parallel Davidson. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3061 c92efa57-630b-4861-b058-cf58834340f0
2006-05-02 06:14:22 +08:00
uspp, gstart, e, btype, notcnv, lrot, dav_iter )
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!----------------------------------------------------------------------------
PW, Gamma and NEB are now unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@449 c92efa57-630b-4861-b058-cf58834340f0
2003-12-10 22:57:07 +08:00
!
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
! ... iterative solution of the eigenvalue problem:
PW, Gamma and NEB are now unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@449 c92efa57-630b-4861-b058-cf58834340f0
2003-12-10 22:57:07 +08:00
!
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
! ... ( H - e S ) * evc = 0
PW, Gamma and NEB are now unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@449 c92efa57-630b-4861-b058-cf58834340f0
2003-12-10 22:57:07 +08:00
!
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
! ... where H is an hermitean operator, e is a real scalar,
Fixed an array out of bound in Gram-Schmidt. Cleanup of parallel Davidson. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3061 c92efa57-630b-4861-b058-cf58834340f0
2006-05-02 06:14:22 +08:00
! ... S is an uspp matrix, evc is a complex vector
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
! ... (real wavefunctions with only half plane waves stored)
PW, Gamma and NEB are now unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@449 c92efa57-630b-4861-b058-cf58834340f0
2003-12-10 22:57:07 +08:00
!
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
USE kinds, ONLY : DP
USE io_global, ONLY : stdout
- reduce replaced by mp_sum - sub. reduce, removed from para! git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4826 c92efa57-630b-4861-b058-cf58834340f0
2008-04-21 05:23:37 +08:00
USE mp_global, ONLY : intra_pool_comm
This is the first iteration in trying to implement a real space treatment of projectors in USPPs. Hopefully this will allow one to study larger systems. The modifications are done primarily keeping TDDFPT code in mind (a branch of QE, you may see detailed explanation in qe-forge which I am trying to keep tightly integrated). Please do not modify/beautify/make more elegant the corresponding subroutines without prior notice, due to their dependencies. I have tested that the current modifications do not alter the behaviour of pw.x other than designed with a number of small tests in HG1. Some Pointers: -All the new subroutines reside in PW/realus.f90 -A new flag real_space in &electrons control the implementation -tqr flag is treated seperately. -The implementation works only for (serial) gamma point single point calculations. ToDo: -I have written K point and task groups implementations of most of the corresponding routines, but did not have time to implement. -Parallelism issues are still to be checked. -The discrepancy in total energy is <0.002 eV for cutoff of 55Ry/550Ry however, there are some strange force components. I do not know how this will effect a possible optimization scheme. Other: Trying the compile CVS version in HG1 of sissa, using the "default" compiler sets, I encountered a very strange compiler bug. Please have a look at Modules/read_cards.f90 for details. Remove the stupid workaround to your liking. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5493 c92efa57-630b-4861-b058-cf58834340f0
2009-04-03 00:05:09 +08:00
USE mp, ONLY : mp_sum
USE realus, ONLY : real_space, fft_orbital_gamma, initialisation_level,&
bfft_orbital_gamma, calbec_rs_gamma, s_psir_gamma
USE wvfct, ONLY : nbnd
USE control_flags, ONLY : gamma_only
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!
IMPLICIT NONE
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
INTEGER, INTENT(IN) :: npw, npwx, nvec, nvecx, gstart
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! dimension of the matrix to be diagonalized
! leading dimension of matrix evc, as declared in the calling pgm unit
! integer number of searched low-lying roots
! maximum dimension of the reduced basis set
! (the basis set is refreshed when its dimension would exceed nvecx)
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
COMPLEX(DP), INTENT(INOUT) :: evc(npwx,nvec)
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! evc contains the refined estimates of the eigenvectors
Davidson with parallel subspace diagonalization implemented. At startup the code automatically checks whether or not it is convenient to use the parallel diagonalizer reporting the result. The output is still verbose to facilitate the identification of bugs. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@2767 c92efa57-630b-4861-b058-cf58834340f0
2006-02-04 04:20:55 +08:00
REAL(DP), INTENT(IN) :: ethr
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! energy threshold for convergence: root improvement is stopped,
! when two consecutive estimates of the root differ by less than ethr.
Fixed an array out of bound in Gram-Schmidt. Cleanup of parallel Davidson. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3061 c92efa57-630b-4861-b058-cf58834340f0
2006-05-02 06:14:22 +08:00
LOGICAL, INTENT(IN) :: uspp
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! if .FALSE. : S|psi> not needed
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
INTEGER, INTENT(IN) :: btype(nvec)
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! band type ( 1 = occupied, 0 = empty )
lrot must be logical [Gerardo] git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1777 c92efa57-630b-4861-b058-cf58834340f0
2005-03-31 19:07:34 +08:00
LOGICAL, INTENT(IN) :: lrot
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! .TRUE. if the wfc have already be rotated
REAL(DP), INTENT(OUT) :: e(nvec)
! contains the estimated roots.
INTEGER, INTENT(OUT) :: dav_iter, notcnv
! integer number of iterations performed
! number of unconverged roots
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!
! ... LOCAL variables
!
INTEGER, PARAMETER :: maxter = 20
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! maximum number of iterations
Davidson with parallel subspace diagonalization implemented. At startup the code automatically checks whether or not it is convenient to use the parallel diagonalizer reporting the result. The output is still verbose to facilitate the identification of bugs. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@2767 c92efa57-630b-4861-b058-cf58834340f0
2006-02-04 04:20:55 +08:00
!
This is the first iteration in trying to implement a real space treatment of projectors in USPPs. Hopefully this will allow one to study larger systems. The modifications are done primarily keeping TDDFPT code in mind (a branch of QE, you may see detailed explanation in qe-forge which I am trying to keep tightly integrated). Please do not modify/beautify/make more elegant the corresponding subroutines without prior notice, due to their dependencies. I have tested that the current modifications do not alter the behaviour of pw.x other than designed with a number of small tests in HG1. Some Pointers: -All the new subroutines reside in PW/realus.f90 -A new flag real_space in &electrons control the implementation -tqr flag is treated seperately. -The implementation works only for (serial) gamma point single point calculations. ToDo: -I have written K point and task groups implementations of most of the corresponding routines, but did not have time to implement. -Parallelism issues are still to be checked. -The discrepancy in total energy is <0.002 eV for cutoff of 55Ry/550Ry however, there are some strange force components. I do not know how this will effect a possible optimization scheme. Other: Trying the compile CVS version in HG1 of sissa, using the "default" compiler sets, I encountered a very strange compiler bug. Please have a look at Modules/read_cards.f90 for details. Remove the stupid workaround to your liking. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5493 c92efa57-630b-4861-b058-cf58834340f0
2009-04-03 00:05:09 +08:00
INTEGER :: kter, nbase, np, n, m, nb1, ibnd
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! counter on iterations
! dimension of the reduced basis
! counter on the reduced basis vectors
! do-loop counters
This is the first iteration in trying to implement a real space treatment of projectors in USPPs. Hopefully this will allow one to study larger systems. The modifications are done primarily keeping TDDFPT code in mind (a branch of QE, you may see detailed explanation in qe-forge which I am trying to keep tightly integrated). Please do not modify/beautify/make more elegant the corresponding subroutines without prior notice, due to their dependencies. I have tested that the current modifications do not alter the behaviour of pw.x other than designed with a number of small tests in HG1. Some Pointers: -All the new subroutines reside in PW/realus.f90 -A new flag real_space in &electrons control the implementation -tqr flag is treated seperately. -The implementation works only for (serial) gamma point single point calculations. ToDo: -I have written K point and task groups implementations of most of the corresponding routines, but did not have time to implement. -Parallelism issues are still to be checked. -The discrepancy in total energy is <0.002 eV for cutoff of 55Ry/550Ry however, there are some strange force components. I do not know how this will effect a possible optimization scheme. Other: Trying the compile CVS version in HG1 of sissa, using the "default" compiler sets, I encountered a very strange compiler bug. Please have a look at Modules/read_cards.f90 for details. Remove the stupid workaround to your liking. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5493 c92efa57-630b-4861-b058-cf58834340f0
2009-04-03 00:05:09 +08:00
! counter on the bands
Davidson with parallel subspace diagonalization implemented. At startup the code automatically checks whether or not it is convenient to use the parallel diagonalizer reporting the result. The output is still verbose to facilitate the identification of bugs. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@2767 c92efa57-630b-4861-b058-cf58834340f0
2006-02-04 04:20:55 +08:00
REAL(DP), ALLOCATABLE :: hr(:,:), sr(:,:), vr(:,:), ew(:)
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! Hamiltonian on the reduced basis
! S matrix on the reduced basis
! eigenvectors of the Hamiltonian
! eigenvalues of the reduced hamiltonian
Davidson with parallel subspace diagonalization implemented. At startup the code automatically checks whether or not it is convenient to use the parallel diagonalizer reporting the result. The output is still verbose to facilitate the identification of bugs. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@2767 c92efa57-630b-4861-b058-cf58834340f0
2006-02-04 04:20:55 +08:00
COMPLEX(DP), ALLOCATABLE :: psi(:,:), hpsi(:,:), spsi(:,:)
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! work space, contains psi
! the product of H and psi
! the product of S and psi
LOGICAL, ALLOCATABLE :: conv(:)
! true if the root is converged
Davidson with parallel subspace diagonalization implemented. At startup the code automatically checks whether or not it is convenient to use the parallel diagonalizer reporting the result. The output is still verbose to facilitate the identification of bugs. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@2767 c92efa57-630b-4861-b058-cf58834340f0
2006-02-04 04:20:55 +08:00
REAL(DP) :: empty_ethr
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! threshold for empty bands
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
INTEGER :: npw2, npwx2
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!
Davidson with parallel subspace diagonalization implemented. At startup the code automatically checks whether or not it is convenient to use the parallel diagonalizer reporting the result. The output is still verbose to facilitate the identification of bugs. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@2767 c92efa57-630b-4861-b058-cf58834340f0
2006-02-04 04:20:55 +08:00
REAL(DP), EXTERNAL :: DDOT
Conjugate-gradient: added a routine for gamma-only calculations. collinear and noncollinear routines unified. Davidson: minor improvements of the davidson algorithm. collinear and noncollinear routines unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1769 c92efa57-630b-4861-b058-cf58834340f0
2005-03-30 22:37:55 +08:00
!
Some compilers complain for double colon after EXTERNAL. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1183 c92efa57-630b-4861-b058-cf58834340f0
2004-08-27 16:29:48 +08:00
EXTERNAL h_psi, s_psi, g_psi
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
! h_psi(npwx,npw,nvec,psi,hpsi)
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! calculates H|psi>
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
! s_psi(npwx,npw,nvec,psi,spsi)
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! calculates S|psi> (if needed)
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
! Vectors psi,hpsi,spsi are dimensioned (npwx,nvec)
! g_psi(npwx,npw,notcnv,psi,e)
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! calculates (diag(h)-e)^-1 * psi, diagonal approx. to (h-e)^-1*psi
! the first nvec columns contain the trial eigenvectors
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL start_clock( 'regterg' )
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!
IF ( nvec > nvecx / 2 ) CALL errore( 'regter', 'nvecx is too small', 1 )
!
! ... threshold for empty bands
!
empty_ethr = MAX( ( ethr * 5.D0 ), 1.D-5 )
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
ALLOCATE( psi( npwx, nvecx ) )
ALLOCATE( hpsi( npwx, nvecx ) )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
IF ( uspp ) ALLOCATE( spsi( npwx, nvecx ) )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
ALLOCATE( sr( nvecx, nvecx ) )
ALLOCATE( hr( nvecx, nvecx ) )
ALLOCATE( vr( nvecx, nvecx ) )
ALLOCATE( ew( nvecx ) )
ALLOCATE( conv( nvec ) )
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
npw2 = 2*npw
npwx2 = 2*npwx
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
notcnv = nvec
nbase = nvec
conv = .FALSE.
!
IF ( uspp ) spsi = ZERO
!
hpsi = ZERO
psi = ZERO
psi(:,1:nvec) = evc(:,1:nvec)
h_psi in the Gamma case used to force the input psi(G=0) to be real, in order to prevent numerical trouble. Changed to set the output h*psi(G=0) to be real: it should be equivalent and it is much more logical. Just in case, and in order to have the same behavior, Im [psi(G=0)] is set to 0 before calls to h_psi git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5427 c92efa57-630b-4861-b058-cf58834340f0
2009-02-16 22:56:23 +08:00
! ... set Im[ psi(G=0) ] - needed for numerical stability
IF ( gstart == 2 ) psi(1,1:nvec) = CMPLX( DBLE( psi(1,1:nvec) ), 0.D0 )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
! ... hpsi contains h times the basis vectors
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL h_psi( npwx, npw, nvec, psi, hpsi )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
This is the first iteration in trying to implement a real space treatment of projectors in USPPs. Hopefully this will allow one to study larger systems. The modifications are done primarily keeping TDDFPT code in mind (a branch of QE, you may see detailed explanation in qe-forge which I am trying to keep tightly integrated). Please do not modify/beautify/make more elegant the corresponding subroutines without prior notice, due to their dependencies. I have tested that the current modifications do not alter the behaviour of pw.x other than designed with a number of small tests in HG1. Some Pointers: -All the new subroutines reside in PW/realus.f90 -A new flag real_space in &electrons control the implementation -tqr flag is treated seperately. -The implementation works only for (serial) gamma point single point calculations. ToDo: -I have written K point and task groups implementations of most of the corresponding routines, but did not have time to implement. -Parallelism issues are still to be checked. -The discrepancy in total energy is <0.002 eV for cutoff of 55Ry/550Ry however, there are some strange force components. I do not know how this will effect a possible optimization scheme. Other: Trying the compile CVS version in HG1 of sissa, using the "default" compiler sets, I encountered a very strange compiler bug. Please have a look at Modules/read_cards.f90 for details. Remove the stupid workaround to your liking. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5493 c92efa57-630b-4861-b058-cf58834340f0
2009-04-03 00:05:09 +08:00
IF ( uspp ) then
if (real_space ) then
!print *, "regterg in real space"
if (gamma_only) then
do ibnd = 1 , nvec , 2
call fft_orbital_gamma(psi,ibnd,nvec) !transform the orbital to real space
call s_psir_gamma(ibnd,nvec)
call bfft_orbital_gamma(spsi,ibnd,nvec)
enddo
else
CALL errore( 'regter', 'k-point real space implementation under development', 1 )
endif
else
CALL s_psi( npwx, npw, nvec, psi, spsi )
endif
endif
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
! ... hr contains the projection of the hamiltonian onto the reduced
! ... space vr contains the eigenvectors of hr
!
hr(:,:) = 0.D0
sr(:,:) = 0.D0
vr(:,:) = 0.D0
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'T', 'N', nbase, nbase, npw2, 2.D0 , &
psi, npwx2, hpsi, npwx2, 0.D0, hr, nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( gstart == 2 ) &
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGER( nbase, nbase, -1.D0, psi, npwx2, hpsi, npwx2, hr, nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
- reduce replaced by mp_sum - sub. reduce, removed from para! git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4826 c92efa57-630b-4861-b058-cf58834340f0
2008-04-21 05:23:37 +08:00
CALL mp_sum( hr( :, 1:nbase ), intra_pool_comm )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( uspp ) THEN
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'T', 'N', nbase, nbase, npw2, 2.D0, &
psi, npwx2, spsi, npwx2, 0.D0, sr, nvecx )
DIIS: fixed some bugs in the diis procedure. Performance issue still to be addressed. Davidson: minor cleanup C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1133 c92efa57-630b-4861-b058-cf58834340f0
2004-08-20 00:22:51 +08:00
!
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
IF ( gstart == 2 ) &
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGER( nbase, nbase, -1.D0, psi, npwx2, spsi, npwx2, sr, nvecx )
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!
Conjugate-gradient: added a routine for gamma-only calculations. collinear and noncollinear routines unified. Davidson: minor improvements of the davidson algorithm. collinear and noncollinear routines unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1769 c92efa57-630b-4861-b058-cf58834340f0
2005-03-30 22:37:55 +08:00
ELSE
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'T', 'N', nbase, nbase, npw2, 2.D0, &
psi, npwx2, psi, npwx2, 0.D0, sr, nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( gstart == 2 ) &
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGER( nbase, nbase, -1.D0, psi, npwx2, psi, npwx2, sr, nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
END IF
!
- reduce replaced by mp_sum - sub. reduce, removed from para! git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4826 c92efa57-630b-4861-b058-cf58834340f0
2008-04-21 05:23:37 +08:00
CALL mp_sum( sr( :, 1:nbase ), intra_pool_comm )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( lrot ) THEN
!
DO n = 1, nbase
!
e(n) = hr(n,n)
vr(n,n) = 1.D0
!
END DO
!
ELSE
!
! ... diagonalize the reduced hamiltonian
!
CALL rdiaghg( nbase, nvec, hr, sr, nvecx, ew, vr )
!
e(1:nvec) = ew(1:nvec)
Conjugate-gradient: added a routine for gamma-only calculations. collinear and noncollinear routines unified. Davidson: minor improvements of the davidson algorithm. collinear and noncollinear routines unified. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1769 c92efa57-630b-4861-b058-cf58834340f0
2005-03-30 22:37:55 +08:00
!
END IF
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
! ... iterate
!
iterate: DO kter = 1, maxter
!
dav_iter = kter
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL start_clock( 'regterg:update' )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
np = 0
!
DO n = 1, nvec
!
IF ( .NOT. conv(n) ) THEN
!
! ... this root not yet converged ...
!
np = np + 1
!
! ... reorder eigenvectors so that coefficients for unconverged
! ... roots come first. This allows to use quick matrix-matrix
! ... multiplications to set a new basis vector (see below)
!
IF ( np /= n ) vr(:,np) = vr(:,n)
!
! ... for use in g_psi
!
ew(nbase+np) = e(n)
!
END IF
!
END DO
!
nb1 = nbase + 1
!
! ... expand the basis set with new basis vectors ( H - e*S )|psi> ...
!
IF ( uspp ) THEN
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, notcnv, nbase, 1.D0, &
spsi, npwx2, vr, nvecx, 0.D0, psi(1,nb1), npwx2 )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
ELSE
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, notcnv, nbase, 1.D0, &
psi, npwx2, vr, nvecx, 0.D0, psi(1,nb1), npwx2 )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
END IF
!
DO np = 1, notcnv
!
psi(:,nbase+np) = - ew(nbase+np) * psi(:,nbase+np)
!
END DO
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, notcnv, nbase, 1.D0, &
hpsi, npwx2, vr, nvecx, 1.D0, psi(1,nb1), npwx2 )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:update' )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
! ... approximate inverse iteration
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL g_psi( npwx, npw, notcnv, 1, psi(1,nb1), ew(nb1) )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
! ... "normalize" correction vectors psi(:,nb1:nbase+notcnv) in
! ... order to improve numerical stability of subspace diagonalization
! ... (cdiaghg) ew is used as work array :
!
! ... ew = <psi_i|psi_i>, i = nbase + 1, nbase + notcnv
!
DO n = 1, notcnv
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
ew(n) = 2.D0 * DDOT( npw2, psi(1,nbase+n), 1, psi(1,nbase+n), 1 )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( gstart == 2 ) ew(n) = ew(n) - psi(1,nbase+n) * psi(1,nbase+n)
!
END DO
!
- reduce replaced by mp_sum - sub. reduce, removed from para! git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4826 c92efa57-630b-4861-b058-cf58834340f0
2008-04-21 05:23:37 +08:00
CALL mp_sum( ew( 1:notcnv ), intra_pool_comm )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
DO n = 1, notcnv
!
psi(:,nbase+n) = psi(:,nbase+n) / SQRT( ew(n) )
h_psi in the Gamma case used to force the input psi(G=0) to be real, in order to prevent numerical trouble. Changed to set the output h*psi(G=0) to be real: it should be equivalent and it is much more logical. Just in case, and in order to have the same behavior, Im [psi(G=0)] is set to 0 before calls to h_psi git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5427 c92efa57-630b-4861-b058-cf58834340f0
2009-02-16 22:56:23 +08:00
! ... set Im[ psi(G=0) ] - needed for numerical stability
IF ( gstart == 2 ) psi(1,nbase+n) = CMPLX( DBLE(psi(1,nbase+n)), 0.D0 )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
END DO
!
! ... here compute the hpsi and spsi of the new functions
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL h_psi( npwx, npw, notcnv, psi(1,nb1), hpsi(1,nb1) )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
This is the first iteration in trying to implement a real space treatment of projectors in USPPs. Hopefully this will allow one to study larger systems. The modifications are done primarily keeping TDDFPT code in mind (a branch of QE, you may see detailed explanation in qe-forge which I am trying to keep tightly integrated). Please do not modify/beautify/make more elegant the corresponding subroutines without prior notice, due to their dependencies. I have tested that the current modifications do not alter the behaviour of pw.x other than designed with a number of small tests in HG1. Some Pointers: -All the new subroutines reside in PW/realus.f90 -A new flag real_space in &electrons control the implementation -tqr flag is treated seperately. -The implementation works only for (serial) gamma point single point calculations. ToDo: -I have written K point and task groups implementations of most of the corresponding routines, but did not have time to implement. -Parallelism issues are still to be checked. -The discrepancy in total energy is <0.002 eV for cutoff of 55Ry/550Ry however, there are some strange force components. I do not know how this will effect a possible optimization scheme. Other: Trying the compile CVS version in HG1 of sissa, using the "default" compiler sets, I encountered a very strange compiler bug. Please have a look at Modules/read_cards.f90 for details. Remove the stupid workaround to your liking. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5493 c92efa57-630b-4861-b058-cf58834340f0
2009-04-03 00:05:09 +08:00
IF ( uspp ) then
if (real_space ) then
!print *, "regterg in real space"
if (gamma_only) then
do ibnd = 1 , notcnv , 2
call fft_orbital_gamma(psi(1:,nb1:),ibnd,notcnv) !transform the orbital to real space
call s_psir_gamma(ibnd,notcnv)
call bfft_orbital_gamma(spsi(1:,nb1:),ibnd,notcnv)
enddo
else
CALL errore( 'regter', 'k-point real space implementation under development', 1 )
endif
else
CALL s_psi( npwx, npw, notcnv, psi(1,nb1), spsi(1,nb1) )
endif
endif
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
! ... update the reduced hamiltonian
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL start_clock( 'regterg:overlap' )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'T', 'N', nbase+notcnv, notcnv, npw2, 2.D0, psi, &
npwx2, hpsi(1,nb1), npwx2, 0.D0, hr(1,nb1), nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( gstart == 2 ) &
CALL DGER( nbase+notcnv, notcnv, -1.D0, psi, &
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
npwx2, hpsi(1,nb1), npwx2, hr(1,nb1), nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
- reduce replaced by mp_sum - sub. reduce, removed from para! git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4826 c92efa57-630b-4861-b058-cf58834340f0
2008-04-21 05:23:37 +08:00
CALL mp_sum( hr( :, nb1 : nb1+notcnv-1 ), intra_pool_comm )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( uspp ) THEN
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'T', 'N', nbase+notcnv, notcnv, npw2, 2.D0, psi, &
npwx2, spsi(1,nb1), npwx2, 0.D0, sr(1,nb1), nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( gstart == 2 ) &
CALL DGER( nbase+notcnv, notcnv, -1.D0, psi, &
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
npwx2, spsi(1,nb1), npwx2, sr(1,nb1), nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
ELSE
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'T', 'N', nbase+notcnv, notcnv, npw2, 2.D0, psi, &
npwx2, psi(1,nb1), npwx2, 0.D0, sr(1,nb1) , nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( gstart == 2 ) &
CALL DGER( nbase+notcnv, notcnv, -1.D0, psi, &
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
npwx2, psi(1,nb1), npwx2, sr(1,nb1), nvecx )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
END IF
!
- reduce replaced by mp_sum - sub. reduce, removed from para! git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4826 c92efa57-630b-4861-b058-cf58834340f0
2008-04-21 05:23:37 +08:00
CALL mp_sum( sr( :, nb1 : nb1+notcnv-1 ), intra_pool_comm )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:overlap' )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
nbase = nbase + notcnv
!
DO n = 1, nbase
!
DO m = n + 1, nbase
!
hr(m,n) = hr(n,m)
sr(m,n) = sr(n,m)
!
END DO
!
END DO
!
! ... diagonalize the reduced hamiltonian
!
CALL rdiaghg( nbase, nvec, hr, sr, nvecx, ew, vr )
!
! ... test for convergence
!
WHERE( btype(1:nvec) == 1 )
!
conv(1:nvec) = ( ( ABS( ew(1:nvec) - e(1:nvec) ) < ethr ) )
!
ELSEWHERE
!
conv(1:nvec) = ( ( ABS( ew(1:nvec) - e(1:nvec) ) < empty_ethr ) )
!
END WHERE
!
notcnv = COUNT( .NOT. conv(:) )
!
e(1:nvec) = ew(1:nvec)
!
! ... if overall convergence has been achieved, or the dimension of
! ... the reduced basis set is becoming too large, or in any case if
! ... we are at the last iteration refresh the basis set. i.e. replace
! ... the first nvec elements with the current estimate of the
! ... eigenvectors; set the basis dimension to nvec.
!
IF ( notcnv == 0 .OR. &
nbase+notcnv > nvecx .OR. dav_iter == maxter ) THEN
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL start_clock( 'regterg:last' )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, nvec, nbase, 1.D0, &
psi, npwx2, vr, nvecx, 0.D0, evc, npwx2 )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
IF ( notcnv == 0 ) THEN
!
! ... all roots converged: return
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:last' )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
EXIT iterate
!
ELSE IF ( dav_iter == maxter ) THEN
!
! ... last iteration, some roots not converged: return
!
WRITE( stdout, '(5X,"WARNING: ",I5, &
& " eigenvalues not converged")' ) notcnv
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:last' )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
EXIT iterate
!
END IF
!
! ... refresh psi, H*psi and S*psi
!
psi(:,1:nvec) = evc(:,1:nvec)
!
IF ( uspp ) THEN
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, nvec, nbase, 1.D0, spsi, &
npwx2, vr, nvecx, 0.D0, psi(1,nvec+1), npwx2 )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
spsi(:,1:nvec) = psi(:,nvec+1:nvec+nvec)
!
END IF
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, nvec, nbase, 1.D0, hpsi, &
npwx2, vr, nvecx, 0.D0, psi(1,nvec+1), npwx2 )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
hpsi(:,1:nvec) = psi(:,nvec+1:nvec+nvec)
!
! ... refresh the reduced hamiltonian
!
nbase = nvec
!
hr(:,1:nbase) = 0.D0
sr(:,1:nbase) = 0.D0
vr(:,1:nbase) = 0.D0
!
DO n = 1, nbase
!
hr(n,n) = e(n)
sr(n,n) = 1.D0
vr(n,n) = 1.D0
!
END DO
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:last' )
Added parallel routines for matrix-matrix, and matrix-vector multiplications and for Cholesky decomposition. These routines are used to parallelize the solvers for the generalized eigenvalue problems, namely rdiaghg and cdiaghg (notice that the inversion of the lower triangular matrix L is still done using a serial lapack routine). These two routines are now used for Davidson parallelization. Old algorithm based on the orthogonalization of the correction vectors has been removed (it was awfully slow). The performance of the new algorithm should be decent. Beware unexpected side effects. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@3310 c92efa57-630b-4861-b058-cf58834340f0
2006-08-09 05:14:26 +08:00
!
END IF
!
END DO iterate
!
DEALLOCATE( conv )
DEALLOCATE( ew )
DEALLOCATE( vr )
DEALLOCATE( hr )
DEALLOCATE( sr )
!
IF ( uspp ) DEALLOCATE( spsi )
!
DEALLOCATE( hpsi )
DEALLOCATE( psi )
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg' )
In the diagonalization two different tresholds are used for occupied and empty bands (as done in diis). Marginal speed-up (of the order of 10%-20%), but safe. C.S. git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@1041 c92efa57-630b-4861-b058-cf58834340f0
2004-07-05 14:53:39 +08:00
!
RETURN
!
END SUBROUTINE regterg
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
!
! Subroutine with distributed matrixes
! (written by Carlo Cavazzoni)
!
!----------------------------------------------------------------------------
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
SUBROUTINE pregterg( npw, npwx, nvec, nvecx, evc, ethr, &
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
uspp, gstart, e, btype, notcnv, lrot, dav_iter )
!----------------------------------------------------------------------------
!
! ... iterative solution of the eigenvalue problem:
!
! ... ( H - e S ) * evc = 0
!
! ... where H is an hermitean operator, e is a real scalar,
! ... S is an uspp matrix, evc is a complex vector
! ... (real wavefunctions with only half plane waves stored)
!
USE kinds, ONLY : DP
USE io_global, ONLY : stdout
USE mp_global, ONLY : npool, nproc_pool, me_pool, root_pool, &
intra_pool_comm, init_ortho_group, &
ortho_comm, np_ortho, me_ortho, ortho_comm_id, leg_ortho
USE descriptors, ONLY : descla_siz_ , descla_init , lambda_node_ , la_nx_ , la_nrl_ , la_n_ , &
ilac_ , ilar_ , nlar_ , nlac_ , la_npc_ , la_npr_ , la_me_ , la_comm_ , &
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
la_myr_ , la_myc_ , nlax_ , descla_local_dims
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
USE parallel_toolkit, ONLY : dsqmdst, dsqmcll, dsqmred, dsqmsym
- small cleanups git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4168 c92efa57-630b-4861-b058-cf58834340f0
2007-08-21 06:01:04 +08:00
USE mp, ONLY : mp_bcast, mp_root_sum, mp_sum
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IMPLICIT NONE
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
INTEGER, INTENT(IN) :: npw, npwx, nvec, nvecx, gstart
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
! dimension of the matrix to be diagonalized
! leading dimension of matrix evc, as declared in the calling pgm unit
! integer number of searched low-lying roots
! maximum dimension of the reduced basis set
! (the basis set is refreshed when its dimension would exceed nvecx)
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
COMPLEX(DP), INTENT(INOUT) :: evc(npwx,nvec)
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
! evc contains the refined estimates of the eigenvectors
REAL(DP), INTENT(IN) :: ethr
! energy threshold for convergence: root improvement is stopped,
! when two consecutive estimates of the root differ by less than ethr.
LOGICAL, INTENT(IN) :: uspp
! if .FALSE. : S|psi> not needed
INTEGER, INTENT(IN) :: btype(nvec)
! band type ( 1 = occupied, 0 = empty )
LOGICAL, INTENT(IN) :: lrot
! .TRUE. if the wfc have already be rotated
REAL(DP), INTENT(OUT) :: e(nvec)
! contains the estimated roots.
INTEGER, INTENT(OUT) :: dav_iter, notcnv
! integer number of iterations performed
! number of unconverged roots
!
! ... LOCAL variables
!
INTEGER, PARAMETER :: maxter = 20
! maximum number of iterations
!
INTEGER :: kter, nbase, np, n, m, nb1
! counter on iterations
! dimension of the reduced basis
! counter on the reduced basis vectors
! do-loop counters
REAL(DP), ALLOCATABLE :: ew(:)
REAL(DP), ALLOCATABLE :: hl(:,:), sl(:,:), vl(:,:)
! Hamiltonian on the reduced basis
! S matrix on the reduced basis
! eigenvectors of the Hamiltonian
! eigenvalues of the reduced hamiltonian
COMPLEX(DP), ALLOCATABLE :: psi(:,:), hpsi(:,:), spsi(:,:)
! work space, contains psi
! the product of H and psi
! the product of S and psi
LOGICAL, ALLOCATABLE :: conv(:)
! true if the root is converged
REAL(DP) :: empty_ethr
! threshold for empty bands
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
INTEGER :: npw2, npwx2
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
INTEGER :: desc( descla_siz_ ), desc_old( descla_siz_ )
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
INTEGER, ALLOCATABLE :: irc_ip( : )
INTEGER, ALLOCATABLE :: nrc_ip( : )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
INTEGER, ALLOCATABLE :: rank_ip( :, : )
! matrix distribution descriptors
INTEGER :: nx
! maximum local block dimension
LOGICAL :: la_proc
! flag to distinguish procs involved in linear algebra
INTEGER, ALLOCATABLE :: notcnv_ip( : )
INTEGER, ALLOCATABLE :: ic_notcnv( : )
!
REAL(DP), EXTERNAL :: DDOT
!
EXTERNAL h_psi, s_psi, g_psi
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
! h_psi(npwx,npw,nvec,psi,hpsi)
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
! calculates H|psi>
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
! s_psi(npwx,npw,nvec,psi,spsi)
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
! calculates S|psi> (if needed)
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
! Vectors psi,hpsi,spsi are dimensioned (npwx,nvec)
! g_psi(npwx,npw,notcnv,psi,e)
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
! calculates (diag(h)-e)^-1 * psi, diagonal approx. to (h-e)^-1*psi
! the first nvec columns contain the trial eigenvectors
!
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL start_clock( 'regterg' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF ( nvec > nvecx / 2 ) CALL errore( 'regter', 'nvecx is too small', 1 )
!
! ... threshold for empty bands
!
empty_ethr = MAX( ( ethr * 5.D0 ), 1.D-5 )
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
ALLOCATE( psi( npwx, nvecx ) )
ALLOCATE( hpsi( npwx, nvecx ) )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
IF ( uspp ) ALLOCATE( spsi( npwx, nvecx ) )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
! ... Initialize the matrix descriptor
!
ALLOCATE( ic_notcnv( np_ortho(2) ) )
ALLOCATE( notcnv_ip( np_ortho(2) ) )
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
ALLOCATE( irc_ip( np_ortho(1) ) )
ALLOCATE( nrc_ip( np_ortho(1) ) )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
ALLOCATE( rank_ip( np_ortho(1), np_ortho(2) ) )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
CALL desc_init( nvec, desc, irc_ip, nrc_ip )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF( la_proc ) THEN
!
! only procs involved in the diagonalization need to allocate local
! matrix block.
!
ALLOCATE( vl( nx , nx ) )
ALLOCATE( sl( nx , nx ) )
ALLOCATE( hl( nx , nx ) )
!
- some compiler (like PGI) does not like unallocated variables to be passed as dummy argument (I think this is a compiler bug). then allocate variable on all procs with size 1 git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4159 c92efa57-630b-4861-b058-cf58834340f0
2007-08-19 22:32:33 +08:00
ELSE
!
ALLOCATE( vl( 1 , 1 ) )
ALLOCATE( sl( 1 , 1 ) )
ALLOCATE( hl( 1 , 1 ) )
!
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
END IF
!
ALLOCATE( ew( nvecx ) )
ALLOCATE( conv( nvec ) )
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
npw2 = 2*npw
npwx2 = 2*npwx
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
notcnv = nvec
nbase = nvec
conv = .FALSE.
!
IF ( uspp ) spsi = ZERO
!
hpsi = ZERO
psi = ZERO
psi(:,1:nvec) = evc(:,1:nvec)
h_psi in the Gamma case used to force the input psi(G=0) to be real, in order to prevent numerical trouble. Changed to set the output h*psi(G=0) to be real: it should be equivalent and it is much more logical. Just in case, and in order to have the same behavior, Im [psi(G=0)] is set to 0 before calls to h_psi git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5427 c92efa57-630b-4861-b058-cf58834340f0
2009-02-16 22:56:23 +08:00
! ... set Im[ psi(G=0) ] - needed for numerical stability
IF ( gstart == 2 ) psi(1,1:nvec) = CMPLX( DBLE( psi(1,1:nvec) ), 0.D0 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
! ... hpsi contains h times the basis vectors
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL h_psi( npwx, npw, nvec, psi, hpsi )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
IF ( uspp ) CALL s_psi( npwx, npw, nvec, psi, spsi )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
! ... hl contains the projection of the hamiltonian onto the reduced
! ... space, vl contains the eigenvectors of hl. Remember hl, vl and sl
! ... are all distributed across processors, global replicated matrixes
! ... here are never allocated
!
CALL compute_distmat( hl, psi, hpsi )
!
IF ( uspp ) THEN
!
CALL compute_distmat( sl, psi, spsi )
!
ELSE
!
CALL compute_distmat( sl, psi, psi )
!
END IF
!
IF ( lrot ) THEN
!
CALL set_e_from_h()
!
CALL set_to_identity( vl, desc )
!
ELSE
!
! ... diagonalize the reduced hamiltonian
! Calling block parallel algorithm
!
CALL prdiaghg( nbase, hl, sl, nx, ew, vl, desc )
!
e(1:nvec) = ew(1:nvec)
!
END IF
!
! ... iterate
!
iterate: DO kter = 1, maxter
!
dav_iter = kter
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL start_clock( 'regterg:update' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
CALL reorder_v()
!
nb1 = nbase + 1
!
! ... expand the basis set with new basis vectors ( H - e*S )|psi> ...
!
CALL hpsi_dot_v()
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:update' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
! ... approximate inverse iteration
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL g_psi( npwx, npw, notcnv, 1, psi(1,nb1), ew(nb1) )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
! ... "normalize" correction vectors psi(:,nb1:nbase+notcnv) in
! ... order to improve numerical stability of subspace diagonalization
! ... (cdiaghg) ew is used as work array :
!
! ... ew = <psi_i|psi_i>, i = nbase + 1, nbase + notcnv
!
DO n = 1, notcnv
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
ew(n) = 2.D0 * DDOT( npw2, psi(1,nbase+n), 1, psi(1,nbase+n), 1 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF ( gstart == 2 ) ew(n) = ew(n) - psi(1,nbase+n) * psi(1,nbase+n)
!
END DO
!
- reduce replaced by mp_sum - sub. reduce, removed from para! git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4826 c92efa57-630b-4861-b058-cf58834340f0
2008-04-21 05:23:37 +08:00
CALL mp_sum( ew( 1:notcnv ), intra_pool_comm )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
DO n = 1, notcnv
!
psi(:,nbase+n) = psi(:,nbase+n) / SQRT( ew(n) )
h_psi in the Gamma case used to force the input psi(G=0) to be real, in order to prevent numerical trouble. Changed to set the output h*psi(G=0) to be real: it should be equivalent and it is much more logical. Just in case, and in order to have the same behavior, Im [psi(G=0)] is set to 0 before calls to h_psi git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5427 c92efa57-630b-4861-b058-cf58834340f0
2009-02-16 22:56:23 +08:00
! ... set Im[ psi(G=0) ] - needed for numerical stability
IF ( gstart == 2 ) psi(1,nbase+n) = CMPLX( DBLE(psi(1,nbase+n)), 0.D0 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
END DO
!
! ... here compute the hpsi and spsi of the new functions
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL h_psi( npwx, npw, notcnv, psi(1,nb1), hpsi(1,nb1) )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
IF ( uspp ) CALL s_psi( npwx, npw, notcnv, psi(1,nb1), spsi(1,nb1) )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
! ... update the reduced hamiltonian
!
! we need to save the old descriptor in order to redistribute marixes
!
desc_old = desc
!
! ... RE-Initialize the matrix descriptor
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
CALL desc_init( nbase+notcnv, desc, irc_ip, nrc_ip )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF( la_proc ) THEN
! redistribute hl and sl (see dsqmred), since the dimension of the subspace has changed
!
vl = hl
DEALLOCATE( hl )
ALLOCATE( hl( nx , nx ) )
- wrong leading dimension used for matrix blocks ( too large! ) git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4160 c92efa57-630b-4861-b058-cf58834340f0
2007-08-20 00:20:30 +08:00
CALL dsqmred( nbase, vl, desc_old( nlax_ ), desc_old, nbase+notcnv, hl, nx, desc )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
vl = sl
DEALLOCATE( sl )
ALLOCATE( sl( nx , nx ) )
- wrong leading dimension used for matrix blocks ( too large! ) git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4160 c92efa57-630b-4861-b058-cf58834340f0
2007-08-20 00:20:30 +08:00
CALL dsqmred( nbase, vl, desc_old( nlax_ ), desc_old, nbase+notcnv, sl, nx, desc )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
DEALLOCATE( vl )
ALLOCATE( vl( nx , nx ) )
END IF
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL start_clock( 'regterg:overlap' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
CALL update_distmat( hl, psi, hpsi )
!
IF ( uspp ) THEN
!
CALL update_distmat( sl, psi, spsi )
!
ELSE
!
CALL update_distmat( sl, psi, psi )
!
END IF
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:overlap' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
nbase = nbase + notcnv
!
! ... diagonalize the reduced hamiltonian
! Call block parallel algorithm
!
CALL prdiaghg( nbase, hl, sl, nx, ew, vl, desc )
!
! ... test for convergence
!
WHERE( btype(1:nvec) == 1 )
!
conv(1:nvec) = ( ( ABS( ew(1:nvec) - e(1:nvec) ) < ethr ) )
!
ELSEWHERE
!
conv(1:nvec) = ( ( ABS( ew(1:nvec) - e(1:nvec) ) < empty_ethr ) )
!
END WHERE
!
notcnv = COUNT( .NOT. conv(:) )
!
e(1:nvec) = ew(1:nvec)
!
! ... if overall convergence has been achieved, or the dimension of
! ... the reduced basis set is becoming too large, or in any case if
! ... we are at the last iteration refresh the basis set. i.e. replace
! ... the first nvec elements with the current estimate of the
! ... eigenvectors; set the basis dimension to nvec.
!
IF ( notcnv == 0 .OR. nbase+notcnv > nvecx .OR. dav_iter == maxter ) THEN
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL start_clock( 'regterg:last' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
CALL refresh_evc()
!
IF ( notcnv == 0 ) THEN
!
! ... all roots converged: return
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:last' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
EXIT iterate
!
ELSE IF ( dav_iter == maxter ) THEN
!
! ... last iteration, some roots not converged: return
!
WRITE( stdout, '(5X,"WARNING: ",I5, &
& " eigenvalues not converged")' ) notcnv
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:last' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
EXIT iterate
!
END IF
!
! ... refresh psi, H*psi and S*psi
!
psi(:,1:nvec) = evc(:,1:nvec)
!
IF ( uspp ) THEN
!
CALL refresh_spsi()
!
END IF
!
CALL refresh_hpsi()
!
! ... refresh the reduced hamiltonian
!
nbase = nvec
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
CALL desc_init( nvec, desc, irc_ip, nrc_ip )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF( la_proc ) THEN
!
! note that nx has been changed by desc_init
! we need to re-alloc with the new size.
!
DEALLOCATE( vl, hl, sl )
ALLOCATE( vl( nx, nx ) )
ALLOCATE( hl( nx, nx ) )
ALLOCATE( sl( nx, nx ) )
!
END IF
!
CALL set_h_from_e( )
!
CALL set_to_identity( vl, desc )
CALL set_to_identity( sl, desc )
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg:last' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
END IF
!
END DO iterate
!
- some compiler (like PGI) does not like unallocated variables to be passed as dummy argument (I think this is a compiler bug). then allocate variable on all procs with size 1 git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4159 c92efa57-630b-4861-b058-cf58834340f0
2007-08-19 22:32:33 +08:00
DEALLOCATE( vl, hl, sl )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
DEALLOCATE( rank_ip )
DEALLOCATE( ic_notcnv )
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
DEALLOCATE( irc_ip )
DEALLOCATE( nrc_ip )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
DEALLOCATE( notcnv_ip )
DEALLOCATE( conv )
DEALLOCATE( ew )
!
IF ( uspp ) DEALLOCATE( spsi )
!
DEALLOCATE( hpsi )
DEALLOCATE( psi )
!
Cleanup of cpu time printout; start_clock and stop_clock modified to avoid trouble if label is longer than expected git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4473 c92efa57-630b-4861-b058-cf58834340f0
2007-11-24 00:00:25 +08:00
CALL stop_clock( 'regterg' )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
RETURN
!
!
CONTAINS
!
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
SUBROUTINE desc_init( nsiz, desc, irc_ip, nrc_ip )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
INTEGER, INTENT(IN) :: nsiz
INTEGER, INTENT(OUT) :: desc(:)
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
INTEGER, INTENT(OUT) :: irc_ip(:)
INTEGER, INTENT(OUT) :: nrc_ip(:)
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
INTEGER :: i, j, rank
!
CALL descla_init( desc, nsiz, nsiz, np_ortho, me_ortho, ortho_comm, ortho_comm_id )
!
- wrong leading dimension used for matrix blocks ( too large! ) git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4160 c92efa57-630b-4861-b058-cf58834340f0
2007-08-20 00:20:30 +08:00
nx = desc( nlax_ )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
DO j = 0, desc( la_npc_ ) - 1
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
CALL descla_local_dims( irc_ip( j + 1 ), nrc_ip( j + 1 ), desc( la_n_ ), desc( la_nx_ ), np_ortho(1), j )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
DO i = 0, desc( la_npr_ ) - 1
CALL GRID2D_RANK( 'R', desc( la_npr_ ), desc( la_npc_ ), i, j, rank )
rank_ip( i+1, j+1 ) = rank * leg_ortho
END DO
END DO
!
la_proc = .FALSE.
IF( desc( lambda_node_ ) > 0 ) la_proc = .TRUE.
!
RETURN
END SUBROUTINE desc_init
!
!
SUBROUTINE set_to_identity( distmat, desc )
INTEGER, INTENT(IN) :: desc(:)
REAL(DP), INTENT(OUT) :: distmat(:,:)
INTEGER :: i
distmat = 0_DP
IF( desc( la_myc_ ) == desc( la_myr_ ) .AND. desc( lambda_node_ ) > 0 ) THEN
DO i = 1, desc( nlac_ )
distmat( i, i ) = 1_DP
END DO
END IF
RETURN
END SUBROUTINE set_to_identity
!
!
SUBROUTINE reorder_v()
!
INTEGER :: ipc, ipr
INTEGER :: nc, ic
INTEGER :: nl, npl
!
np = 0
!
notcnv_ip = 0
!
n = 0
!
DO ipc = 1, desc( la_npc_ )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nc = nrc_ip( ipc )
ic = irc_ip( ipc )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
npl = 0
!
IF( ic <= nvec ) THEN
!
DO nl = 1, min( nvec - ic + 1, nc )
!
n = n + 1
!
IF ( .NOT. conv(n) ) THEN
!
! ... this root not yet converged ...
!
np = np + 1
npl = npl + 1
IF( npl == 1 ) ic_notcnv( ipc ) = np
!
! ... reorder eigenvectors so that coefficients for unconverged
! ... roots come first. This allows to use quick matrix-matrix
! ... multiplications to set a new basis vector (see below)
!
notcnv_ip( ipc ) = notcnv_ip( ipc ) + 1
!
IF ( npl /= nl ) THEN
IF( la_proc .AND. desc( la_myc_ ) == ipc-1 ) THEN
vl( :, npl) = vl( :, nl )
END IF
END IF
!
! ... for use in g_psi
!
ew(nbase+np) = e(n)
!
END IF
!
END DO
!
END IF
!
END DO
!
END SUBROUTINE reorder_v
!
!
SUBROUTINE hpsi_dot_v()
!
INTEGER :: ipc, ipr
INTEGER :: nr, nc, ir, ic, notcl, root, np
REAL(DP), ALLOCATABLE :: vtmp( :, : )
COMPLEX(DP), ALLOCATABLE :: ptmp( :, : )
REAL(DP) :: beta
ALLOCATE( vtmp( nx, nx ) )
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
ALLOCATE( ptmp( npwx, nx ) )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
DO ipc = 1, desc( la_npc_ )
!
IF( notcnv_ip( ipc ) > 0 ) THEN
notcl = notcnv_ip( ipc )
ic = ic_notcnv( ipc )
ptmp = 0.0d0
beta = 0.0d0
DO ipr = 1, desc( la_npr_ )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nr = nrc_ip( ipr )
ir = irc_ip( ipr )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
root = rank_ip( ipr, ipc )
IF( ipr-1 == desc( la_myr_ ) .AND. ipc-1 == desc( la_myc_ ) .AND. la_proc ) THEN
vtmp(:,1:notcl) = vl(:,1:notcl)
END IF
CALL mp_bcast( vtmp(:,1:notcl), root, intra_pool_comm )
!
IF ( uspp ) THEN
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, notcl, nr, 1.D0, &
spsi( 1, ir ), npwx2, vtmp, nx, beta, psi(1,nb1+ic-1), npwx2 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
ELSE
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, notcl, nr, 1.D0, &
psi( 1, ir ), npwx2, vtmp, nx, beta, psi(1,nb1+ic-1), npwx2 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
END IF
!
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, notcl, nr, 1.D0, &
hpsi( 1, ir ), npwx2, vtmp, nx, 1.D0, ptmp, npwx2 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
beta = 1.0d0
END DO
DO np = 1, notcl
!
psi(:,nbase+np+ic-1) = ptmp(:,np) - ew(nbase+np+ic-1) * psi(:,nbase+np+ic-1)
!
END DO
!
END IF
!
END DO
DEALLOCATE( vtmp )
DEALLOCATE( ptmp )
RETURN
END SUBROUTINE hpsi_dot_v
!
!
SUBROUTINE refresh_evc( )
!
INTEGER :: ipc, ipr
INTEGER :: nr, nc, ir, ic, root
REAL(DP), ALLOCATABLE :: vtmp( :, : )
REAL(DP) :: beta
ALLOCATE( vtmp( nx, nx ) )
!
DO ipc = 1, desc( la_npc_ )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nc = nrc_ip( ipc )
ic = irc_ip( ipc )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF( ic <= nvec ) THEN
!
nc = min( nc, nvec - ic + 1 )
!
beta = 0.0d0
DO ipr = 1, desc( la_npr_ )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nr = nrc_ip( ipr )
ir = irc_ip( ipr )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
root = rank_ip( ipr, ipc )
IF( ipr-1 == desc( la_myr_ ) .AND. ipc-1 == desc( la_myc_ ) .AND. la_proc ) THEN
!
! this proc sends his block
!
CALL mp_bcast( vl(:,1:nc), root, intra_pool_comm )
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, nc, nr, 1.D0, &
psi(1,ir), npwx2, vl, nx, beta, evc(1,ic), npwx2 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
ELSE
!
! all other procs receive
!
CALL mp_bcast( vtmp(:,1:nc), root, intra_pool_comm )
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, nc, nr, 1.D0, &
psi(1,ir), npwx2, vtmp, nx, beta, evc(1,ic), npwx2 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
END IF
!
beta = 1.0d0
END DO
!
END IF
!
END DO
!
DEALLOCATE( vtmp )
RETURN
END SUBROUTINE refresh_evc
!
!
SUBROUTINE refresh_spsi( )
!
INTEGER :: ipc, ipr
INTEGER :: nr, nc, ir, ic, root
REAL(DP), ALLOCATABLE :: vtmp( :, : )
REAL(DP) :: beta
ALLOCATE( vtmp( nx, nx ) )
!
DO ipc = 1, desc( la_npc_ )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nc = nrc_ip( ipc )
ic = irc_ip( ipc )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF( ic <= nvec ) THEN
!
nc = min( nc, nvec - ic + 1 )
!
beta = 0_DP
!
DO ipr = 1, desc( la_npr_ )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nr = nrc_ip( ipr )
ir = irc_ip( ipr )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
root = rank_ip( ipr, ipc )
IF( ipr-1 == desc( la_myr_ ) .AND. ipc-1 == desc( la_myc_ ) .AND. la_proc ) THEN
!
! this proc sends his block
!
CALL mp_bcast( vl(:,1:nc), root, intra_pool_comm )
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, nc, nr, 1.D0, &
spsi(1,ir), npwx2, vl, nx, beta, psi(1,nvec+ic), npwx2 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
ELSE
!
! all other procs receive
!
CALL mp_bcast( vtmp(:,1:nc), root, intra_pool_comm )
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, nc, nr, 1.D0, &
spsi(1,ir), npwx2, vtmp, nx, beta, psi(1,nvec+ic), npwx2 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
END IF
!
beta = 1_DP
END DO
!
END IF
!
END DO
!
spsi(:,1:nvec) = psi(:,nvec+1:nvec+nvec)
!
DEALLOCATE( vtmp )
RETURN
END SUBROUTINE refresh_spsi
!
!
!
SUBROUTINE refresh_hpsi( )
!
INTEGER :: ipc, ipr
INTEGER :: nr, nc, ir, ic, root
REAL(DP), ALLOCATABLE :: vtmp( :, : )
REAL(DP) :: beta
ALLOCATE( vtmp( nx, nx ) )
!
DO ipc = 1, desc( la_npc_ )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nc = nrc_ip( ipc )
ic = irc_ip( ipc )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF( ic <= nvec ) THEN
!
nc = min( nc, nvec - ic + 1 )
!
beta = 0.0d0
!
DO ipr = 1, desc( la_npr_ )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nr = nrc_ip( ipr )
ir = irc_ip( ipr )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
root = rank_ip( ipr, ipc )
IF( ipr-1 == desc( la_myr_ ) .AND. ipc-1 == desc( la_myc_ ) .AND. la_proc ) THEN
!
! this proc sends his block
!
CALL mp_bcast( vl(:,1:nc), root, intra_pool_comm )
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, nc, nr, 1.D0, &
hpsi(1,ir), npwx2, vl, nx, beta, psi(1,nvec+ic), npwx2 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
ELSE
!
! all other procs receive
!
CALL mp_bcast( vtmp(:,1:nc), root, intra_pool_comm )
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'N', 'N', npw2, nc, nr, 1.D0, &
hpsi(1,ir), npwx2, vtmp, nx, beta, psi(1,nvec+ic), npwx2 )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
END IF
!
beta = 1.0d0
END DO
!
END IF
!
END DO
!
DEALLOCATE( vtmp )
hpsi(:,1:nvec) = psi(:,nvec+1:nvec+nvec)
RETURN
END SUBROUTINE refresh_hpsi
!
!
SUBROUTINE compute_distmat( dm, v, w )
!
! This subroutine compute <vi|wj> and store the
! result in distributed matrix dm
!
INTEGER :: ipc, ipr
INTEGER :: nr, nc, ir, ic, root
REAL(DP), INTENT(OUT) :: dm( :, : )
COMPLEX(DP) :: v(:,:), w(:,:)
REAL(DP), ALLOCATABLE :: work( :, : )
!
ALLOCATE( work( nx, nx ) )
!
work = 0.0d0
!
DO ipc = 1, desc( la_npc_ ) ! loop on column procs
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nc = nrc_ip( ipc )
ic = irc_ip( ipc )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
DO ipr = 1, ipc ! use symmetry for the loop on row procs
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nr = nrc_ip( ipr )
ir = irc_ip( ipr )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
! rank of the processor for which this block (ipr,ipc) is destinated
!
root = rank_ip( ipr, ipc )
! use blas subs. on the matrix block
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'T', 'N', nr, nc, npw2, 2.D0 , &
v(1,ir), npwx2, w(1,ic), npwx2, 0.D0, work, nx )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
IF ( gstart == 2 ) &
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGER( nr, nc, -1.D0, v(1,ir), npwx2, w(1,ic), npwx2, work, nx )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
! accumulate result on dm of root proc.
CALL mp_root_sum( work, dm, root, intra_pool_comm )
END DO
!
END DO
!
CALL dsqmsym( nbase, dm, nx, desc )
!
DEALLOCATE( work )
!
RETURN
END SUBROUTINE compute_distmat
!
!
SUBROUTINE update_distmat( dm, v, w )
!
INTEGER :: ipc, ipr
INTEGER :: nr, nc, ir, ic, root, icc, ii
REAL(DP) :: dm( :, : )
COMPLEX(DP) :: v(:,:), w(:,:)
REAL(DP), ALLOCATABLE :: vtmp( :, : )
ALLOCATE( vtmp( nx, nx ) )
!
vtmp = 0.0d0
!
DO ipc = 1, desc( la_npc_ )
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nc = nrc_ip( ipc )
ic = irc_ip( ipc )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF( ic+nc-1 >= nb1 ) THEN
nc = MIN( nc, ic+nc-1 - nb1 + 1 )
IF( ic >= nb1 ) THEN
ii = ic
icc = 1
ELSE
ii = nb1
icc = nb1-ic+1
END IF
DO ipr = 1, ipc ! desc( la_npr_ ) use symmetry
!
- small cleanup git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@5256 c92efa57-630b-4861-b058-cf58834340f0
2008-11-03 00:04:42 +08:00
nr = nrc_ip( ipr )
ir = irc_ip( ipr )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
root = rank_ip( ipr, ipc )
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGEMM( 'T', 'N', nr, nc, npw2, 2.D0, v( 1, ir ), &
npwx2, w(1,ii), npwx2, 0.D0, vtmp, nx )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
!
IF ( gstart == 2 ) &
In all diagonalization-related routines, ndmx => npwx, ndim => npw . Why? because the presence of different variables with the same name makes usage of "grep" ineffective... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4260 c92efa57-630b-4861-b058-cf58834340f0
2007-09-18 22:28:03 +08:00
CALL DGER( nr, nc, -1.D0, v( 1, ir ), npwx2, w(1,ii), npwx2, vtmp, nx )
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
- fix for half bug, array sections git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4818 c92efa57-630b-4861-b058-cf58834340f0
2008-04-18 19:03:20 +08:00
IF( (desc( lambda_node_ ) > 0) .AND. (ipr-1 == desc( la_myr_ )) .AND. (ipc-1 == desc( la_myc_ )) ) THEN
CALL mp_root_sum( vtmp(:,1:nc), dm(:,icc:icc+nc-1), root, intra_pool_comm )
ELSE
CALL mp_root_sum( vtmp(:,1:nc), dm, root, intra_pool_comm )
END IF
- new version of reghter ( preghter ) without global replicated data. Matrixes are distributed across processors. - to turn on the use of the new algorithm, a new value for input parameter "diagonalization", has been introduced: diagonalization = 'david+distpara' work like david but use fully distributed memory iteration loop. Allocated memory scale down with the number of procs. Procs involved in diagonalization can be changed with input parameter "ortho_para". On multi core/CPUs often it is convenient to let only one core per CPU to work on linear algebra. User can tune the number of core involved in diag. with the keyword in electrons namelist: ortho_para = NN then the code will use the largest square smaller than NN, since matrixes are always distributed on a suqre grid of procs. Note that if NN < 2*nproc, then one proc every two is taken for parellel diag. The same for NN < 4*proc, one every four is taken. This is to minimize memory contention on multi core proc. In example, if you run with 64procs on a 4core CPU cluster, it may be convenient to specify: ortho_para = 16 So that only one core per CPU is involved in diagonalization. Further performance enhancements will be possible using OpenMP BLAS inside regter/cegter/rdiaghg/cdiaghg (to be implemented) for the time been, all this is only for gamma_only calculation, ceghter will follow... git-svn-id: http://qeforge.qe-forge.org/svn/q-e/trunk/espresso@4154 c92efa57-630b-4861-b058-cf58834340f0
2007-08-18 23:48:07 +08:00
END DO
!
END IF
!
END DO
!
CALL dsqmsym( nbase+notcnv, dm, nx, desc )
!
DEALLOCATE( vtmp )
RETURN
END SUBROUTINE update_distmat
!
!
!
SUBROUTINE set_e_from_h()
INTEGER :: nc, ic, i
e(1:nbase) = 0.0d0
IF( desc( la_myc_ ) == desc( la_myr_ ) .AND. la_proc ) THEN
nc = desc( nlac_ )
ic = desc( ilac_ )
DO i = 1, nc
e( i + ic - 1 ) = hl( i, i )
END DO
END IF
CALL mp_sum( e(1:nbase), intra_pool_comm )
RETURN
END SUBROUTINE set_e_from_h
!
SUBROUTINE set_h_from_e()
INTEGER :: nc, ic, i
IF( la_proc ) THEN
hl = 0.0d0
IF( desc( la_myc_ ) == desc( la_myr_ ) ) THEN
nc = desc( nlac_ )
ic = desc( ilac_ )
DO i = 1, nc
hl(i,i) = e( i + ic - 1 )
END DO
END IF
END IF
RETURN
END SUBROUTINE set_h_from_e
!
END SUBROUTINE pregterg