1solve_evp_complex_1stage_douLbilber(a3r)y FunctionssMoalnvuea_levp_complex_1stage_double(3)
2
3
4

NAME

6       solve_evp_complex_1stage_double - solve the double-precision complex
7       eigenvalue problem with the 1-stage ELPA solver (legacy interface)
8
9

SYNOPSIS

11   FORTRAN INTERFACE
12       use elpa1
13       success = solve_evp_complex_1stage_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, 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       complex*16,  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       complex*16,  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 MPI
42       processes used in ELPA
43       logical, optional, intent(in) useGPU:        decide whether GPUs should
44       be used or not
45
46       logical                    success:       return value indicating
47       success or failure
48
49   C INTERFACE
50       #include "elpa_legacy.h"
51       #include <complex.h>
52
53       success = solve_evp_complex_1stage_double_precision (int na, int nev,
54       double complex *a, int lda,  double *ev, double complex*q, int ldq, int
55       nblk, int matrixCols, int mpi_comm_rows, int mpi_comm_cols, int
56       mpi_comm_all, int useGPU);
57
58       With the definitions of the input and output variables:
59
60       int             na:            global dimension of quadratic matrix a
61       to solve
62       int             nev:           number of eigenvalues to be computed;
63       the first nev eigenvalules are calculated
64       double complex *a:             pointer to locally distributed part of
65       the matrix a. The local dimensions are lda x matrixCols
66       int             lda:           leading dimension of locally distributed
67       matrix a
68       double         *ev:            pointer to memory containing on output
69       the first nev computed eigenvalues
70       double complex *q:             pointer to memory containing on output
71       the first nev computed eigenvectors
72       int             ldq:           leading dimension of matrix q which
73       stores the eigenvectors
74       int             nblk:          blocksize of block cyclic distributin,
75       must be the same in both directions
76       int             matrixCols:    number of columns of locally distributed
77       matrices a and q
78       int             mpi_comm_rows: communicator for communication in rows.
79       Constructed with elpa_get_communicators(3)
80       int             mpi_comm_cols: communicator for communication in
81       colums. Constructed with elpa_get_communicators(3)
82       int             mpi_comm_all:  communicator for all MPI processes used
83       in ELPA
84       int             useGPU:        decide whether GPUs should be used or
85       not
86
87       int             success:       return value indicating success (1) or
88       failure (0)
89
90

DESCRIPTION

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

SEE ALSO

104       Old interface: elpa_get_communicators(3) elpa_solve_evp_real_double(3)
105       elpa_solve_evp_real_single(3) elpa_solve_evp_complex_double(3)
106       elpa_solve_evp_complex_single(3) solve_evp_real_1stage_double(3)
107       solve_evp_real_1stage_single(3) solve_evp_complex_1stage_single(3)
108       solve_evp_real_2stage_double(3) solve_evp_real_2stage_single(3)
109       solve_evp_complex_2stage_double(3) solve_evp_complex_2stage_single(3)
110       Current interface: elpa2_print_kernels(1)
111
112
113
114ELPA                            Wed May 17 20s1o7lve_evp_complex_1stage_double(3)