1solve_evp_real_2stage_doubleL(i3b)rary Functions Mansuoallve_evp_real_2stage_double(3)
2
3
4

NAME

6       solve_evp_real_2stage_double - solve the double-precision real
7       eigenvalue problem with the 2-stage ELPA solver (legacy interface)
8
9

SYNOPSIS

11   FORTRAN INTERFACE
12       use elpa1 use elpa2
13       success = solve_evp_real_2stage_double (na, nev, a(lda,matrixCols),
14       ev(nev), q(ldq, matrixCols), ldq, nblk, matrixCols, mpi_comm_rows,
15       mpi_comm_cols, mpi_comm_all, THIS_REAL_ELPA_KERNEL, useQR, useGPU)
16
17       With the definitions of the input and output variables:
18
19       integer, intent(in)            na:            global dimension of
20       quadratic matrix a to solve
21       integer, intent(in)            nev:           number of eigenvalues to
22       be computed; the first nev eigenvalules are calculated
23       real*8,  intent(inout)         a:             locally distributed part
24       of the matrix a. The local dimensions are lda x matrixCols
25       integer, intent(in)            lda:           leading dimension of
26       locally distributed matrix a
27       real*8,  intent(inout)         ev:            on output the first nev
28       computed eigenvalues
29       real*8,  intent(inout)         q:             on output the first nev
30       computed eigenvectors
31       integer, intent(in)            ldq:           leading dimension of
32       matrix q which stores the eigenvectors
33       integer, intent(in)            nblk:          blocksize of block cyclic
34       distributin, must be the same in both directions
35       integer, intent(in)            matrixCols:    number of columns of
36       locally distributed matrices a and q
37       integer, intent(in)            mpi_comm_rows: communicator for
38       communication in rows. Constructed with elpa_get_communicators(3)
39       integer, intent(in)            mpi_comm_cols: communicator for
40       communication in colums. Constructed with elpa_get_communicators(3)
41       integer, intent(in)            mpi_comm_all:  communicator for all
42       processes in the processor set involved in ELPA
43       logical, intent(in), optional: useQR:         optional argument;
44       switches to QR-decomposition if set to .true.
45       logical, intent(in), optional: useGPU:        decide whether GPUs
46       should be used or not
47       logical                        success:       return value indicating
48       success or failure
49
50   C INTERFACE
51       #include "elpa_legacy.h"
52
53       success = solve_evp_real_2stage_double_precision (int na, int nev,
54       double *a, int lda,  double *ev, double *q, int ldq, int nblk, int
55       matrixCols, int mpi_comm_rows, int mpi_comm_cols, int mpi_comm_all, int
56       THIS_ELPA_REAL_KERNEL, int useQR, int useGPU);
57
58       With the definitions of the input and output variables:
59
60       int     na:            global dimension of quadratic matrix a to solve
61       int     nev:           number of eigenvalues to be computed; the first
62       nev eigenvalules are calculated
63       double *a:             pointer to locally distributed part of the
64       matrix a. The local dimensions are lda x matrixCols
65       int     lda:           leading dimension of locally distributed matrix
66       a
67       double *ev:            pointer to memory containing on output the first
68       nev computed eigenvalues
69       double *q:             pointer to memory containing on output the first
70       nev computed eigenvectors
71       int     ldq:           leading dimension of matrix q which stores the
72       eigenvectors
73       int     nblk:          blocksize of block cyclic distributin, must be
74       the same in both directions
75       int     matrixCols:    number of columns of locally distributed
76       matrices a and q
77       int     mpi_comm_rows: communicator for communication in rows.
78       Constructed with elpa_get_communicators(3)
79       int     mpi_comm_cols: communicator for communication in colums.
80       Constructed with elpa_get_communicators(3)
81       int     mpi_comm_all:  communicator for all processes in the processor
82       set involved in ELPA
83       int     useQR:         if set to 1 switch to QR-decomposition
84       int     useGPU:        decide whether GPUs should be used or nor
85       int     success:       return value indicating success (1) or failure
86       (0)
87
88

DESCRIPTION

90       Solve the real eigenvalue problem with the 2-stage solver. The ELPA
91       communicators mpi_comm_rows and mpi_comm_cols are obtained with the
92       elpa_get_communicators(3) function. The distributed quadratic marix a
93       has global dimensions na x na, and a local size lda x matrixCols. The
94       solver will compute the first nev eigenvalues, which will be stored on
95       exit in ev. The eigenvectors corresponding to the eigenvalues will be
96       stored in q. All memory of the arguments must be allocated outside the
97       call to the solver.
98       This function is part of the legacy API of the ELPA library. Better use
99       the current API.
100

SEE ALSO

102       Old interface: elpa_get_communicators(3)
103       solve_evp_real_1stage_double(3) solve_evp_real_1stage_single(3)
104       solve_evp_complex_1stage_double(3) solve_evp_complex_1stage_single(3)
105       solve_evp_complex_2stage_double(3) solve_evp_complex_2stage_single(3)
106       solve_evp_real_2stage_single(3)
107       Current interface: elpa2_print_kernels(1)
108
109
110
111ELPA                            Wed May 17 2017solve_evp_real_2stage_double(3)
Impressum