pzlatra.f

Go to the documentation of this file.

      COMPLEX*16         FUNCTION pzlatra( N, A, IA, JA, DESCA )
*
*  -- scalapack auxiliary routine(version 1.7) --
*     university of tennessee, knoxville, oak ridge national laboratory,
*     and university of california, berkeley.
*     may 1, 1997
*
*     .. scalar arguments ..
      INTEGER            ia, ja, n
*     ..
*     .. array arguments ..
      INTEGER            desca( * )
      COMPLEX*16         a( * )
*     ..
*
*  purpose
*  =======
*
*  pzlatra computes the trace of an n-by-n distributed matrix sub( a )
*  denoting a( ia:ia+n-1, ja:ja+n-1 ). the result is left on every
*  process of the grid.
*
*  notes
*  =====
*
*  each global data object is described by an associated description
*  vector.  this vector stores the information required to establish
*  the mapping between an object element and its corresponding process
*  and memory location.
*
*  let a be a generic term for any 2d block cyclicly distributed array.
*  such a global array has an associated description vector desca.
*  in the following comments, the character _ should be read as
*  "of the global array".
*
*  notation        stored in      explanation
*  --------------- -------------- --------------------------------------
*  dtype_a(global) desca( dtype_ )the descriptor type.  in this case,
*                                 dtype_a = 1.
*  ctxt_a(global) desca( ctxt_ ) the blacs context handle, indicating
*                                 the blacs process grid a is distribu-
*                                 ted over. the context itself is glo-
*                                 bal, but the handle(the integer
*                                 value) may vary.
*  m_a(global) desca( m_ )    the number of rows in the global
*                                 array a.
*  n_a(global) desca( n_ )    the number of columns in the global
*                                 array a.
*  mb_a(global) desca( mb_ )   the blocking factor used to distribute
*                                 the rows of the array.
*  nb_a(global) desca( nb_ )   the blocking factor used to distribute
*                                 the columns of the array.
*  rsrc_a(global) desca( rsrc_ ) the process row over which the first
*                                 row of the array a is distributed.
*  csrc_a(global) desca( csrc_ ) the process column over which the
*                                 first column of the array a is
*                                 distributed.
*  lld_a(local)  desca( lld_ )  the leading dimension of the local
*                                 array.  lld_a >= max(1,locr(m_a)).
*
*  let k be the number of rows or columns of a distributed matrix,
*  and assume that its process grid has dimension p x q.
*  locr( k ) denotes the number of elements of k that a process
*  would receive if k were distributed over the p processes of its
*  process column.
*  similarly, locc( k ) denotes the number of elements of k that a
*  process would receive if k were distributed over the q processes of
*  its process row.
*  the values of locr() and locc() may be determined via a call to the
*  scalapack tool function, numroc:
*          locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ),
*          locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
*  an upper bound for these quantities may be computed by:
*          locr( m ) <= ceil( ceil(m/mb_a)/nprow )*mb_a
*          locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a
*
*  arguments
*  =========
*
*  n(global input) integer
*          the number of rows and columns to be operated on i.e the
*          order of the distributed submatrix sub( a ).  n >= 0.
*
*  a(local input) COMPLEX*16 pointer into the local memory
*          to an array of dimension ( LLD_A, LOCc(JA+N-1) ). this array
*          contains the local pieces of the distributed matrix the trace
*          is to be computed.
*
*  ia(global input) integer
*          the row index in the global array a indicating the first
*          row of sub( a ).
*
*  ja(global input) integer
*          the column index in the global array a indicating the
*          first column of sub( a ).
*
*  desca(global and local input) INTEGER array of dimension dlen_.
*          the array descriptor for the distributed matrix a.
*
*  ====================================================================
*
*     .. parameters ..
      INTEGER            block_cyclic_2d, csrc_, ctxt_, dlen_, dtype_,
     $                   lld_, mb_, m_, nb_, n_, rsrc_
      parameter( block_cyclic_2d = 1, dlen_ = 9, dtype_ = 1,
     $                     ctxt_ = 2, m_ = 3, n_ = 4, mb_ = 5, nb_ = 6,
     $                     rsrc_ = 7, csrc_ = 8, lld_ = 9 )
      COMPLEX*16         zero
      parameter( zero = 0.0d+0 )
*     ..
*     .. local scalars ..
      INTEGER            icurcol, icurrow, ii, ioffa, j, jb, jj, jn,
     $                   lda, ll, mycol, myrow, npcol, nprow
      COMPLEX*16         trace
*     ..
*     .. External subroutines ..
      EXTERNAL           blacs_gridinfo, infog2l, zgsum2d
*     ..
*     .. External functions ..
      INTEGER            iceil
      EXTERNAL           iceil
*     ..
*     .. Intrinsic functions ..
      INTRINSIC          min, mod
*     ..
*     .. executable statements ..
*
*     get grid parameters
*
      CALL blacs_gridinfo( desca( ctxt_ ), nprow, npcol, myrow, mycol )
*
      trace = zero
      IF( n.EQ.0 ) THEN
         pzlatra = trace
         RETURN
      END IF
*
      CALL infog2l( ia, ja, desca, nprow, npcol, myrow, mycol, ii, jj,
     $              icurrow, icurcol )
*
      jn = min( iceil( ja, desca( nb_ ) ) * desca( nb_ ), ja+n-1 )
      jb = jn-ja+1
      lda = desca( lld_ )
      ioffa = ii + ( jj - 1 ) * lda
*
*     handle first diagonal block separately
*
      IF( myrow.EQ.icurrow .AND. mycol.EQ.icurcol ) THEN
         DO 10 ll = ioffa, ioffa + (jb-1)*(lda+1), lda+1
            trace = trace + a( ll )
   10    CONTINUE
      END IF
      IF( myrow.EQ.icurrow )
     $   ioffa = ioffa + jb
      IF( mycol.EQ.icurcol )
     $   ioffa = ioffa + jb*lda
      icurrow = mod( icurrow+1, nprow )
      icurcol = mod( icurcol+1, npcol )
*
*     loop over the remaining block of columns
*
      DO 30 j = jn+1, ja+n-1, desca( nb_ )
         jb = min( ja+n-j, desca( nb_ ) )
*
         IF( myrow.EQ.icurrow .AND. mycol.EQ.icurcol ) THEN
            DO 20 ll = ioffa, ioffa + (jb-1)*(lda+1), lda+1
               trace = trace + a( ll )
   20       CONTINUE
         END IF
         IF( myrow.EQ.icurrow )
     $      ioffa = ioffa + jb
         IF( mycol.EQ.icurcol )
     $      ioffa = ioffa + jb*lda
         icurrow = mod( icurrow+1, nprow )
         icurcol = mod( icurcol+1, npcol )
   30 CONTINUE
*
      CALL zgsum2d( desca( ctxt_ ), 'All', ' ', 1, 1, trace, 1, -1,
     $              mycol )
*
      pzlatra = trace
*
      RETURN
*
*     End of pzlatra
*
      END