1elpa_solve_evp_complex_1stagLei_bdroaurbyleF(u3n)cteilopnas_sMoalnvuea_levp_complex_1stage_double(3)
2
3
4

NAME

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

SYNOPSIS

12   FORTRAN INTERFACE
13       use elpa1
14       success = elpa_solve_evp_complex_1stage_double (na, nev,
15       a(lda,matrixCols), ev(nev), q(ldq, matrixCols), ldq, nblk, matrixCols,
16       mpi_comm_rows, mpi_comm_cols, mpi_comm_all, useGPU)
17
18       With the definitions of the input and output variables:
19
20       integer,     intent(in)    na:            global dimension of quadratic
21       matrix a to solve
22       integer,     intent(in)    nev:           number of eigenvalues to be
23       computed; the first nev eigenvalules are calculated
24       complex*16,  intent(inout) a:             locally distributed part of
25       the matrix a. The local dimensions are lda x matrixCols
26       integer,     intent(in)    lda:           leading dimension of locally
27       distributed matrix a
28       real*8,      intent(inout) ev:            on output the first nev
29       computed eigenvalues
30       complex*16,  intent(inout) q:             on output the first nev
31       computed eigenvectors
32       integer,     intent(in)    ldq:           leading dimension of matrix q
33       which stores the eigenvectors
34       integer,     intent(in)    nblk:          blocksize of block cyclic
35       distributin, must be the same in both directions
36       integer,     intent(in)    matrixCols:    number of columns of locally
37       distributed matrices a and q
38       integer,     intent(in)    mpi_comm_rows: communicator for
39       communication in rows. Constructed with elpa_get_communicators(3)
40       integer, intent(in)        mpi_comm_cols: communicator for
41       communication in colums. Constructed with elpa_get_communicators(3)
42       integer,     intent(in)    mpi_comm_all:  communicator for all
43       processes in the processor set involved in ELPA
44       logical, optional, intent(in) useGPU:     specify whether GPUs should
45       be used or not used
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 = elpa_solve_evp_complex_1stage_double_precision (int na, int
54       nev,  double complex *a, int lda,  double *ev, double complex*q, int
55       ldq, int nblk, int matrixCols, int mpi_comm_rows, int mpi_comm_cols,
56       int 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 processes in the
83       processor set involved in ELPA
84       int             useGPU:        specify whether GPUS should be used or
85       not
86       int             success:       return value indicating success (1) or
87       failure (0)
88
89

DESCRIPTION

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

SEE ALSO

103       Old interface: elpa_get_communicators(3)
104       elpa_solve_evp_real_1stage_double(3)
105       elpa_solve_evp_real_1stage_single(3)
106       elpa_solve_evp_complex_1stage_single(3)
107       elpa_solve_evp_real_2stage_double(3)
108       elpa_solve_evp_real_2stage_single(3)
109       elpa_solve_evp_complex_2stage_double(3)
110       elpa_solve_evp_complex_2stage_single(3)
111       Current interface: elpa2_print_kernels(1)
112
113
114
115ELPA                            Wed Maye1l7pa2_0s1o7lve_evp_complex_1stage_double(3)