1solve_evp_real_1stage_doubleL(i3b)rary Functions Mansuoallve_evp_real_1stage_double(3)
2
3
4

NAME

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

SYNOPSIS

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

DESCRIPTION

88       Solve the real eigenvalue problem with the 1-stage solver. The ELPA
89       communicators mpi_comm_rows and mpi_comm_cols are obtained with the
90       elpa_get_communicators(3) function. The distributed quadratic marix a
91       has global dimensions na x na, and a local size lda x matrixCols. The
92       solver will compute the first nev eigenvalues, which will be stored on
93       exit in ev. The eigenvectors corresponding to the eigenvalues will be
94       stored in q. All memory of the arguments must be allocated outside the
95       call to the solver.
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)
101       solve_evp_real_1stage_single(3) solve_evp_complex_1stage_double(3)
102       solve_evp_complex_1stage_single(3)  solve_evp_real_2stage_double(3)
103       solve_evp_real_2stage_single(3) solve_evp_complex_2stage_double(3)
104       solve_evp_complex_2stage_single(3)
105       Current interface: elpa2_print_kernels(1)
106
107
108
109ELPA                            Wed May 17 2017solve_evp_real_1stage_double(3)
Impressum