1elpa_solve_evp_real_1stage_dLoiubbrlaer(y3)FunctioneslpMaa_nsuoallve_evp_real_1stage_double(3)
2
3
4

NAME

6       elpa_solve_evp_real_1stage_double - solve the real eigenvalue problem
7       with the 1-stage ELPA solver (legacy interface)
8
9

SYNOPSIS

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

DESCRIPTION

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

SEE ALSO

100       Old interface: elpa_get_communicators(3) elpa_solve_evp_real_double(3)
101       elpa_solve_evp_real_single(3) elpa_solve_evp_complex_double(3)
102       elpa_solve_evp_complex_single(3)
103       elpa_solve_evp_complex_1stage_double(3)
104       elpa_solve_evp_complex_1stage_single solve_evp_real_2stage_double(3)
105       solve_evp_real_2stage_single(3) solve_evp_complex_2stage_double(3)
106       solve_evp_complex_2stage_single(3)
107       Current interface: elpa2_print_kernels(1)
108
109
110
111ELPA                            Wed Mai 17e2l0p1a7_solve_evp_real_1stage_double(3)