Télécharger TARWORK.INC

Retour à la liste

Numérotation des lignes :

  1. ************************************************************************
  2. * INCLUDE DES VARIABLES DE TRAVAIL ARPACK *
  3. ************************************************************************
  4.  
  5. SEGMENT MAUP
  6. INTEGER ido
  7. CHARACTER*1 bmat
  8. CHARACTER*2 which
  9. REAL*8 tol
  10. REAL*8 resid(ndim)
  11. INTEGER info
  12. INTEGER nev
  13. REAL*8 v(ndim,ncv)
  14. INTEGER iparam(11)
  15. INTEGER ishift
  16. INTEGER ipntr(lipntr)
  17. REAL*8 workd(3*ndim)
  18. REAL*8 workl(lworkl)
  19. LOGICAL eigvec
  20. CHARACTER*1 howmny
  21. LOGICAL select(ncv)
  22. REAL*8 dr(lnev)
  23. REAL*8 di(lnev)
  24. INTEGER ldv
  25. REAL*8 sigmar
  26. REAL*8 sigmai
  27. REAL*8 workev(3*ncv)
  28. ENDSEGMENT
  29.  
  30. * IDO Integer. (INPUT/OUTPUT)
  31. * Reverse communication flag. IDO must be zero on the first
  32. * call to d-aupd . IDO will be set internally to
  33. * indicate the type of operation to be performed.
  34. *
  35. * BMAT Character*1. (INPUT)
  36. * BMAT specifies the type of the matrix B that defines the
  37. * semi-inner product for the operator OP.
  38. * B = 'I' -> standard eigenvalue problem A*x = lambda*x
  39. * B = 'G' -> generalized eigenvalue problem A*x = lambda*B*x
  40. *
  41. * TOL Double precision
  42. * Tolerance
  43. *
  44. * NDIM Integer. (INPUT)
  45. * Dimension of the eigenproblem.
  46. *
  47. * WHICH Character*2. (INPUT)
  48. * Specify which of the Ritz values of OP to compute.
  49. *
  50. * 'LA' - compute the NEV largest (algebraic) eigenvalues.
  51. * 'SA' - compute the NEV smallest (algebraic) eigenvalues.
  52. * 'LM' - compute the NEV largest (in magnitude) eigenvalues.
  53. * 'SM' - compute the NEV smallest (in magnitude) eigenvalues.
  54. * 'BE' - compute NEV eigenvalues, half from each end of the
  55. * spectrum. When NEV is odd, compute one more from the
  56. * high end than from the low end.
  57. * 'SM' -> want the NEV eigenvalues of smallest magnitude.
  58. * 'LR' -> want the NEV eigenvalues of largest real part.
  59. * 'SR' -> want the NEV eigenvalues of smallest real part.
  60. * 'LI' -> want the NEV eigenvalues of largest imaginary part.
  61. * 'SI' -> want the NEV eigenvalues of smallest imaginary part
  62. *
  63. * NEV (=lnev-1) Integer. (INPUT)
  64. * Number of eigenvalues of OP to be computed
  65. *
  66. * RESID Double precision array of length N. (INPUT/OUTPUT)
  67. * On INPUT:
  68. * If INFO .EQ. 0, a random initial residual vector is used.
  69. * If INFO .NE. 0, RESID contains the initial residual vector,
  70. * possibly from a previous run.
  71. * On OUTPUT:
  72. * RESID contains the final residual vector.
  73. *
  74. * NCV Integer. (INPUT)
  75. * Number of columns of the matrix V (less than or equal to N).
  76. * This will indicate how many Arnoldi vectors are generated
  77. * at each iteration.
  78. *
  79. * V REAL*8 N by NCV array. (OUTPUT)
  80. * After the factorisation building:
  81. * The NCV columns of V contain the Arnoldi basis vectors.
  82. * After the post-processing:
  83. * The NCV columns of V contain the eigenvectors
  84. *
  85. * Note : If the eigenpairs are complex, an eigenvector is
  86. * containted in two colums : the first is the real part and
  87. * the next one is the imaginary part. The conjugated one is
  88. * implicit
  89. *
  90. * LDV Integer. (INPUT)
  91. * Leading dimension of V exactly as declared in the calling
  92. * program.
  93. *
  94. * IPARAM Integer array (INPUT/OUTPUT)
  95. *
  96. * Note : Only the most relevant parameters are described below
  97. *
  98. * IPARAM(3) = MXITER
  99. * On INPUT: maximum number of Arnoldi update
  100. * iterations allowed.
  101. * On OUTPUT: actual number of Arnoldi update iterations taken.
  102. *
  103. * IPARAM(5) = NCONV: number of "converged" Ritz values.
  104. * This represents the number of Ritz values that satisfy
  105. * the convergence criterion.
  106. *
  107. * IPARAM(7) = MODE
  108. * On INPUT determines what type of eigenproblem is being
  109. * solved.
  110. * Must be 1,2,3,4,5; See under \Description of d-aupd for the
  111. * five modes available.
  112. *
  113. * IPARAM(9) = NUMOP, IPARAM(10) = NUMOPB, IPARAM(11) = NUMREO,
  114. * OUTPUT: NUMOP = total number of OP*x operations,
  115. * NUMOPB = total number of B*x operations if BMAT='G',
  116. * NUMREO = total number of steps of
  117. * re-orthogonalization.
  118. *
  119. * IPNTR Integer array (OUTPUT)
  120. * Pointer to mark the starting locations in the WORKD and WORKL
  121. * arrays for matrices/vectors used by the Lanczos iteration.
  122. *
  123. * WORKD Double precision work array of length 3*N.
  124. * (REVERSE COMMUNICATION)
  125. * Distributed array to be used in the basic Arnoldi iteration
  126. * for reverse communication.
  127. *
  128. * WORKL Double precision work array of length LWORKL.
  129. * OUTPUT/WORKSPACE)
  130. * Private (replicated) array on each PE or array allocated on
  131. * the front end.
  132. *
  133. * INFO Integer. (INPUT/OUTPUT)
  134. * Information about the reason of the exit from d--pd
  135. *
  136. * RVEC LOGICAL (INPUT)
  137. * Specifies whether a basis for the invariant subspace
  138. * corresponding to the converged Ritz value approximations for
  139. * the eigenproblem A*z = lambda*B*z is computed.
  140. *
  141. * RVEC = .FALSE. Compute Ritz values only.
  142. * RVEC = .TRUE. Compute the Ritz vectors or
  143. * Schur vectors.
  144. *
  145. * HOWMNY Character*1 (INPUT)
  146. * Specifies the form of the basis for the invariant subspace
  147. * corresponding to the converged Ritz values that is to be
  148. * computed.
  149. *
  150. * = 'A': Compute NEV Ritz vectors;
  151. * = 'P': Compute NEV Schur vectors;
  152. * = 'S': compute some of the Ritz vectors, specified
  153. * by the logical array SELECT.
  154. *
  155. * SELECT Logical array of dimension NCV. (INPUT)
  156. * No longer used (we always compute all eigenvectors)
  157. *
  158. * DR REAL*8 array of dimension NEV+1. (OUTPUT)
  159. * Contains the real part of the eigenvalues ONLY IF the shift
  160. * is real. Otherwise, eigenvalues has to be computed with the
  161. * Rayleigh's quotients
  162. *
  163. * DI REAL*8 array of dimension NEV+1. (OUTPUT)
  164. * (Used only if the problem is non-symmetric)
  165. * Contains the imaginary part of the eigenvalues ONLY IF
  166. * the shift is real. Otherwise, eigenvalues has to be computed
  167. * with the Rayleigh's quotients
  168. *
  169. * SIGMAR Double precision (INPUT)
  170. * Real part of the shift
  171. *
  172. * SIGMAI Double precision (INPUT)
  173. * Imaginary part of the shift.
  174. *
  175. * WORKEV Double precision work array of dimension 3*NCV WORKSPACE)
  176.  
  177.  
  178. SEGMENT MRITRA
  179. INTEGER RIGI(NB)
  180. INTEGER SYME(NB)
  181. ENDSEGMENT
  182.  
  183.  
  184. * RIGI(NB) INTEGER array of dimension NB
  185. * Array for the pointers of the operators used by ARPACK
  186. *
  187. *
  188. * SYME(NB) INTEGER array of dimension NB
  189. * Indicates if the corresponding operator (see RIGI) symmetric
  190. * - 0 : symmetric
  191. * - 1 : indefinite
  192.  
  193.  
  194.  
  195.  
  196.  
  197.  

© Cast3M 2003 - Tous droits réservés.
Mentions légales