Date: 2013-09-02T10:08:45+00:00

Actual source code: davidson.h

      1: /*
      2:   Method: General Davidson Method (includes GD and JD)

      4:   References:
      5:     - Ernest R. Davidson. Super-matrix methods. Computer Physics Communications,
      6:       53:49â€“60, May 1989.

      8:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      9:    SLEPc - Scalable Library for Eigenvalue Problem Computations
     10:    Copyright (c) 2002-2013, Universitat Politecnica de Valencia, Spain

     12:    This file is part of SLEPc.

     14:    SLEPc is free software: you can redistribute it and/or modify it under  the
     15:    terms of version 3 of the GNU Lesser General Public License as published by
     16:    the Free Software Foundation.

     18:    SLEPc  is  distributed in the hope that it will be useful, but WITHOUT  ANY
     19:    WARRANTY;  without even the implied warranty of MERCHANTABILITY or  FITNESS
     20:    FOR  A  PARTICULAR PURPOSE. See the GNU Lesser General Public  License  for
     21:    more details.

     23:    You  should have received a copy of the GNU Lesser General  Public  License
     24:    along with SLEPc. If not, see <http://www.gnu.org/licenses/>.
     25:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     26: */

     28: /*
     29:    Dashboard struct: contains the methods that will be employed and the tunning
     30:    options.
     31: */

     33: #include <slepc-private/epsimpl.h>         /*I "slepceps.h" I*/
     34: #include <slepc-private/stimpl.h>          /*I "slepcst.h" I*/
     35: #include <slepcblaslapack.h>

     37: typedef struct _dvdFunctionList {
     38:   PetscErrorCode (*f)(void*);
     39:   void *d;
     40:   struct _dvdFunctionList *next;
     41: } dvdFunctionList;

     43: typedef PetscInt MatType_t;
     44: #define DVD_MAT_HERMITIAN (1<<1)
     45: #define DVD_MAT_NEG_DEF (1<<2)
     46: #define DVD_MAT_POS_DEF (1<<3)
     47: #define DVD_MAT_SINGULAR (1<<4)
     48: #define DVD_MAT_COMPLEX (1<<5)
     49: #define DVD_MAT_IMPLICIT (1<<6)
     50: #define DVD_MAT_IDENTITY (1<<7)
     51: #define DVD_MAT_DIAG (1<<8)
     52: #define DVD_MAT_TRIANG (1<<9)
     53: #define DVD_MAT_UTRIANG (1<<9)
     54: #define DVD_MAT_LTRIANG (1<<10)
     55: #define DVD_MAT_UNITARY (1<<11)

     57: typedef PetscInt EPType_t;
     58: #define DVD_EP_STD (1<<1)
     59: #define DVD_EP_HERMITIAN (1<<2)
     60: #define DVD_EP_INDEFINITE (1<<3)

     62: #define DVD_IS(T,P) ((T) & (P))
     63: #define DVD_ISNOT(T,P) (((T) & (P)) ^ (P))

     65: typedef enum {
     66:   DVD_HARM_NONE,
     67:   DVD_HARM_RR,
     68:   DVD_HARM_RRR,
     69:   DVD_HARM_REIGS,
     70:   DVD_HARM_LEIGS
     71: } HarmType_t;

     73: typedef enum {
     74:   DVD_INITV_CLASSIC,
     75:   DVD_INITV_KRYLOV
     76: } InitType_t;

     78: typedef enum {
     79:   DVD_PROJ_KXX,
     80:   DVD_PROJ_KZX
     81: } ProjType_t;

     83: typedef enum {
     84:   DVD_METH_GD,
     85:   DVD_METH_JD,
     86:   DVD_METH_GD2
     87: } Method_t;

     89: typedef struct _dvdDashboard {
     90:   /**** Function steps ****/
     91:   /* Initialize V */
     92:   PetscErrorCode (*initV)(struct _dvdDashboard*);
     93:   void *initV_data;

     95:   /* Find the approximate eigenpairs from V */
     96:   PetscErrorCode (*calcPairs)(struct _dvdDashboard*);
     97:   void *calcPairs_data;

     99:   /* Eigenpair test for convergence */
    100:   PetscBool (*testConv)(struct _dvdDashboard*,PetscScalar eigvr,PetscScalar eigvi,PetscReal res,PetscReal *error);
    101:   void *testConv_data;

    103:   /* Number of converged eigenpairs */
    104:   PetscInt nconv;

    106:   /* Number of pairs ready to converge */
    107:   PetscInt npreconv;

    109:   /* Improve the selected eigenpairs */
    110:   PetscErrorCode (*improveX)(struct _dvdDashboard*,Vec *D,PetscInt max_size_D,PetscInt r_s,PetscInt r_e,PetscInt *size_D);
    111:   void *improveX_data;

    113:   /* Check for restarting */
    114:   PetscBool (*isRestarting)(struct _dvdDashboard*);
    115:   void *isRestarting_data;

    117:   /* Perform restarting */
    118:   PetscErrorCode (*restartV)(struct _dvdDashboard*);
    119:   void *restartV_data;

    121:   /* Update V */
    122:   PetscErrorCode (*updateV)(struct _dvdDashboard*);
    123:   void *updateV_data;

    125:   /**** Problem specification ****/
    126:   Mat A, B;         /* Problem matrices */
    127:   MatType_t sA, sB; /* Matrix specifications */
    128:   EPType_t sEP;     /* Problem specifications */
    129:   PetscInt nev;     /* number of eigenpairs */
    130:   EPSWhich which;   /* spectrum selection */
    131:   PetscBool
    132:     withTarget;     /* if there is a target */
    133:   PetscScalar
    134:     target[2];         /* target value */
    135:   PetscReal tol;    /* tolerance */
    136:   PetscBool
    137:     correctXnorm;   /* if true, norm of X are computed */

    139:   /**** Subspaces specification ****/
    140:   Vec *V,           /* searching subspace */
    141:     *real_V,        /* original V */
    142:     *W,             /* testing subspace */
    143:     *real_W,        /* original W */
    144:     *cX,            /* converged right eigenvectors */
    145:     *cY,            /* converged left eigenvectors */
    146:     *BcX,           /* basis of B*cX */
    147:     *AV,            /* A*V */
    148:     *real_AV,       /* original A*V space */
    149:     *BV,            /* B*V */
    150:     *real_BV,       /* original B*V space */
    151:     *BDS;           /* B * eps->DV */
    152:   PetscInt size_V,  /* size of V */
    153:     size_real_V,    /* original size of V */
    154:     size_W,         /* size of W */
    155:     size_real_W,    /* original size of W */
    156:     size_AV,        /* size of AV */
    157:     size_real_AV,   /* original size of AV */
    158:     size_BV,        /* size of BV */
    159:     size_BDS,       /* size of BDS */
    160:     size_real_BV,   /* original size of BV */
    161:     size_cX,        /* size of cX */
    162:     size_cY,        /* size of cY */
    163:     size_D,         /* active vectors */
    164:     size_BcX,       /* size of BcX */
    165:     size_real_eigr, /* size of original eigr, eigi, nR, errest */
    166:     max_size_V,     /* max size of V */
    167:     max_size_W,     /* max size of W */
    168:     max_size_X,     /* max new vectors in V */
    169:     max_size_AV,    /* max size of AV */
    170:     max_size_BV,    /* max size of BV */
    171:     max_size_proj,  /* max size projected problem */
    172:     max_cX_in_proj, /* max vectors from cX in the projected problem */
    173:     max_cX_in_impr, /* max vectros from cX in the projector */
    174:     max_size_P,     /* max unconverged vectors in the projector */
    175:     bs;             /* max vectors that expands the subspace every iteration */
    176:   EPS eps;          /* Connection to SLEPc */

    178:   /**** Auxiliary space ****/
    179:   Vec *auxV;        /* auxiliary vectors */
    180:   PetscScalar
    181:     *auxS;          /* auxiliary scalars */
    182:   PetscInt
    183:     size_auxV,      /* max size of auxV */
    184:     size_auxS;      /* max size of auxS */

    186:   /**** Eigenvalues and errors ****/
    187:   PetscScalar
    188:     *ceigr, *ceigi, /* converged eigenvalues */
    189:     *eigr, *eigi,   /* current eigenvalues */
    190:     *real_eigr,
    191:     *real_eigi;     /* original eigr and eigi */
    192:   PetscReal
    193:     *nR,            /* residual norm */
    194:     *real_nR,       /* original nR */
    195:     *nX,            /* X norm */
    196:     *real_nX,       /* original nX */
    197:     *errest,        /* relative error eigenpairs */
    198:     *real_errest,   /* original errest */
    199:     *nBDS,          /* B-norms of DS */
    200:     *nBV,           /* B-norms of V */
    201:     *nBcX,          /* B-norms of cX */
    202:     *nBpX,          /* B-norms of pX */
    203:     *real_nBV;      /* original nBDS, nBV and nBcX */

    205:   /**** Shared function and variables ****/
    206:   PetscErrorCode (*e_Vchanged)(struct _dvdDashboard*,PetscInt s_imm,PetscInt e_imm,PetscInt s_new,PetscInt e_new);
    207:   void *e_Vchanged_data;

    209:   PetscErrorCode (*calcpairs_residual)(struct _dvdDashboard*,PetscInt s,PetscInt e,Vec *R);
    210:   PetscErrorCode (*calcpairs_residual_eig)(struct _dvdDashboard*,PetscInt s,PetscInt e,Vec *R);
    211:   PetscErrorCode (*calcpairs_selectPairs)(struct _dvdDashboard*,PetscInt n);
    212:   void *calcpairs_residual_data;
    213:   PetscErrorCode (*improvex_precond)(struct _dvdDashboard*,PetscInt i,Vec x,Vec Px);
    214:   void *improvex_precond_data;
    215:   PetscErrorCode (*improvex_jd_proj_uv)(struct _dvdDashboard*,PetscInt i_s,PetscInt i_e,Vec *u,Vec *v,Vec *kr,Vec *auxV,PetscScalar *theta,PetscScalar *thetai,PetscScalar *pX,PetscScalar *pY,PetscInt ld);
    216:   PetscErrorCode (*improvex_jd_lit)(struct _dvdDashboard*,PetscInt i,PetscScalar* theta,PetscScalar* thetai,PetscInt *maxits,PetscReal *tol);
    217:   PetscErrorCode (*calcpairs_W)(struct _dvdDashboard*);
    218:   void *calcpairs_W_data;
    219:   PetscErrorCode (*calcpairs_proj_trans)(struct _dvdDashboard*);
    220:   PetscErrorCode (*calcpairs_eigs_trans)(struct _dvdDashboard*);
    221:   PetscErrorCode (*calcpairs_eig_backtrans)(struct _dvdDashboard*,PetscScalar,PetscScalar,PetscScalar*,PetscScalar*);
    222:   PetscErrorCode (*calcpairs_proj_res)(struct _dvdDashboard*,PetscInt r_s,PetscInt r_e,Vec *R);
    223:   PetscErrorCode (*preTestConv)(struct _dvdDashboard*,PetscInt s,PetscInt pre,PetscInt e,Vec *auxV,PetscScalar *auxS,PetscInt *nConv);

    225:   PetscErrorCode (*e_newIteration)(struct _dvdDashboard*);
    226:   void *e_newIteration_data;

    228:   IP ipI;
    229:   IP ipV,           /* orthogonal routine options for V subspace */
    230:     ipW;            /* orthogonal routine options for W subspace */

    232:   dvdFunctionList
    233:     *startList,     /* starting list */
    234:     *endList,       /* ending list */
    235:     *destroyList;   /* destructor list */

    237:   PetscScalar *H,   /* Projected problem matrix A*/
    238:     *real_H,        /* original H */
    239:     *G,             /* Projected problem matrix B*/
    240:     *real_G,        /* original G */
    241:     *S,             /* first Schur matrix, S = pY'*H*pX */
    242:     *T,             /* second Schur matrix, T = pY'*G*pX */
    243:     *cS,            /* first Schur matrix of converged pairs */
    244:     *cT;            /* second Schur matrix of converged pairs */
    245:   MatType_t
    246:     sH,             /* H properties */
    247:     sG;             /* G properties */
    248:   PetscInt ldH,     /* leading dimension of H */
    249:     ldS,            /* leading dimension of S */
    250:     ldT,            /* leading dimension of T */
    251:     ldcS,           /* leading dimension of cS */
    252:     ldcT,           /* leading dimension of cT */
    253:     size_H,         /* rows and columns in H */
    254:     size_G,         /* rows and columns in G */
    255:     size_MT,        /* rows in MT */
    256:     size_cS,        /* dimension of cS */
    257:     size_cT,        /* dimension of cT */
    258:     max_size_cS,    /* max size of cS and cT */
    259:     cX_in_V,        /* number of converged vectors in V */
    260:     cX_in_W,        /* number of converged vectors in W */
    261:     cX_in_AV,       /* number of converged vectors in AV */
    262:     cX_in_BV,       /* number of converged vectors in BV */
    263:     cX_in_H,        /* number of converged vectors in H */
    264:     cX_in_G;        /* number of converged vectors in G */

    266:   PetscInt
    267:     V_tra_s,
    268:     V_tra_e,        /* cX <- [cX V*MT(0:V_tra_s-1)], V <- V*MT(V_tra_s:V_tra_e) */
    269:     V_new_s,
    270:     V_new_e;        /* added to V the columns V_new_s:V_new_e */
    271:   PetscBool
    272:     BV_shift,       /* if true BV is shifted when vectors converge */
    273:     W_shift;        /* if true W is shifted when vectors converge */
    274:   DS conv_ps,       /* projected problem with the converged pairs */
    275:     ps;             /* projected problem with the search subspace */

    277:   EPSOrthType   orthoV_type;

    279:   void* prof_data;  /* profiler data */
    280: } dvdDashboard;

    282: /* Add the function fun at the beginning of list */
    283: #define DVD_FL_ADD_BEGIN(list, fun) { \
    284:   dvdFunctionList *fl=(list); \
    286:   PetscMalloc(sizeof(dvdFunctionList), &(list)); \
    287:   (list)->f = (PetscErrorCode(*)(void*))(fun); \
    288:   (list)->next = fl; \
    289: }

    291: /* Add the function fun at the end of list */
    292: #define DVD_FL_ADD_END(list, fun) { \
    293:   if ((list)) {DVD_FL_ADD_END0(list, fun);} \
    294:   else {DVD_FL_ADD_BEGIN(list, fun);} }

    296: #define DVD_FL_ADD_END0(list, fun) { \
    297:   dvdFunctionList *fl=(list); \
    299:   for (;fl->next; fl = fl->next); \
    300:   PetscMalloc(sizeof(dvdFunctionList), &fl->next); \
    301:   fl->next->f = (PetscErrorCode(*)(void*))(fun); \
    302:   fl->next->next = NULL; \
    303: }

    305: #define DVD_FL_ADD(list, fun) DVD_FL_ADD_END(list, fun)

    307: #define DVD_FL_CALL(list, arg0) { \
    308:   dvdFunctionList *fl; \
    309:   for (fl=(list); fl; fl=fl->next) \
    310:     if (*(dvdCallback)fl->f) (*(dvdCallback)fl->f)((arg0)); \
    311: }

    313: #define DVD_FL_DEL(list) { \
    314:   dvdFunctionList *fl=(list), *oldfl; \
    316:   while (fl) { \
    317:     oldfl = fl; fl = fl->next; PetscFree(oldfl);\
    318:   } \
    319:   (list) = NULL; \
    320: }

    322: /*
    323:   The blackboard configuration structure: saves information about the memory
    324:   and other requirements.

    326:   The starting memory structure:

    328:   V           W?          AV          BV?          tKZ
    329:   |-----------|-----------|-----------|------------|-------|
    330:   nev+mpd     nev+mpd     scP+mpd     nev?+mpd     sP+scP
    331:               scP+mpd                 scP+mpd

    333:   The final memory structure considering W_shift and BV_shift:

    335:   cX  V       cY?  W?     cAV AV      BcX? BV?     KZ  tKZ
    336:   |---|-------|----|------|---|-------|----|-------|---|---|
    337:   nev mpd     nev  mpd    scP mpd     nev  mpd     scP sP    <- shift
    338:               scP                     scP                    <- !shift
    339: */
    340: typedef struct {
    341:   PetscInt max_size_V,  /* max size of the searching subspace (mpd) */
    342:     max_size_X,         /* max size of X (bs) */
    343:     size_V,             /* real size of V (nev+size_P+mpd) */
    344:     max_size_oldX,      /* max size of oldX */
    345:     max_size_auxV,      /* max size of auxiliary vecs */
    346:     max_size_auxS,      /* max size of auxiliary scalars */
    347:     max_nev,            /* max number of converged pairs */
    348:     max_size_P,         /* number of computed vectors for the projector */
    349:     max_size_cP,        /* number of converged vectors in the projectors */
    350:     max_size_proj,      /* max size projected problem */
    351:     max_size_cX_proj,   /* max converged vectors in the projected problem */
    352:     own_vecs,           /* number of global vecs */
    353:     own_scalars;        /* number of local scalars */
    354:   Vec *free_vecs;       /* free global vectors */
    355:   PetscScalar
    356:     *free_scalars;      /* free scalars */
    357:   PetscInt state;       /* method states:
    358:                             0: preconfiguring
    359:                             1: configuring
    360:                             2: running
    361:                         */
    362: } dvdBlackboard;

    364: #define DVD_STATE_PRECONF 0
    365: #define DVD_STATE_CONF 1
    366: #define DVD_STATE_RUN 2

    368: /* Shared types */
    369: typedef PetscErrorCode (*dvdPrecond)(dvdDashboard*,PetscInt i,Vec x,Vec Px);
    370: typedef PetscErrorCode (*dvdCallback)(dvdDashboard*);
    371: typedef PetscErrorCode (*e_Vchanged_type)(dvdDashboard*,PetscInt s_imm,PetscInt e_imm,PetscInt s_new,PetscInt e_new);
    372: typedef PetscBool (*isRestarting_type)(dvdDashboard*);
    373: typedef PetscErrorCode (*e_newIteration_type)(dvdDashboard*);
    374: typedef PetscErrorCode (*improveX_type)(dvdDashboard*,Vec *D,PetscInt max_size_D,PetscInt r_s,PetscInt r_e,PetscInt *size_D);

    376: /* Structures for blas */
    377: typedef PetscErrorCode (*DvdReductionPostF)(PetscScalar*,PetscInt,void*);
    378: typedef struct {
    379:   PetscScalar
    380:     *out;               /* final vector */
    381:   PetscInt
    382:     size_out;           /* size of out */
    383:   DvdReductionPostF
    384:     f;                  /* function called after the reduction */
    385:   void *ptr;
    386: } DvdReductionChunk;

    388: typedef struct {
    389:   PetscScalar
    390:     *in,                /* vector to sum-up with more nodes */
    391:     *out;               /* final vector */
    392:   PetscInt size_in,     /* size of in */
    393:     max_size_in;        /* max size of in */
    394:   DvdReductionChunk
    395:     *ops;               /* vector of reduction operations */
    396:   PetscInt
    397:     size_ops,           /* size of ops */
    398:     max_size_ops;       /* max size of ops */
    399:   MPI_Comm comm;        /* MPI communicator */
    400: } DvdReduction;

    402: typedef struct {
    403:   PetscInt i0, i1, i2, ld, s0, e0, s1, e1;
    404:   PetscScalar *M;
    405: } DvdMult_copy_func;

    407: /* Routines for initV step */
    408: PETSC_INTERN PetscErrorCode dvd_initV(dvdDashboard *d,dvdBlackboard *b,PetscInt k,PetscInt user,PetscBool krylov);

    410: /* Routines for calcPairs step */
    411: PETSC_INTERN PetscErrorCode dvd_calcpairs_qz(dvdDashboard *d,dvdBlackboard *b,EPSOrthType orth,IP ipI,PetscInt cX_proj,PetscBool harm);

    413: /* Routines for improveX step */
    414: PETSC_INTERN PetscErrorCode dvd_improvex_jd(dvdDashboard *d,dvdBlackboard *b,KSP ksp,PetscInt max_bs,PetscInt cX_impr,PetscBool dynamic);
    415: PETSC_INTERN PetscErrorCode dvd_improvex_jd_proj_uv(dvdDashboard *d,dvdBlackboard *b,ProjType_t p);
    416: PETSC_INTERN PetscErrorCode dvd_improvex_jd_lit_const(dvdDashboard *d,dvdBlackboard *b,PetscInt maxits,PetscReal tol,PetscReal fix);
    417: PETSC_INTERN PetscErrorCode dvd_improvex_gd2(dvdDashboard *d,dvdBlackboard *b,KSP ksp,PetscInt max_bs);
    418: PETSC_INTERN PetscErrorCode dvd_improvex_get_eigenvectors(dvdDashboard *d,PetscScalar *pX,
    419:   PetscScalar *pY,PetscInt ld,PetscScalar *auxS,PetscInt size_auxS);

    421: /* Routines for testConv step */
    422: PETSC_INTERN PetscErrorCode dvd_testconv_basic(dvdDashboard *d,dvdBlackboard *b);
    423: PETSC_INTERN PetscErrorCode dvd_testconv_slepc(dvdDashboard *d,dvdBlackboard *b);

    425: /* Routines for management of V */
    426: PETSC_INTERN PetscErrorCode dvd_managementV_basic(dvdDashboard *d,dvdBlackboard *b,PetscInt bs,PetscInt mpd,PetscInt min_size_V,PetscInt plusk,PetscBool harm,PetscBool allResiduals);

    428: /* Some utilities */
    429: PETSC_INTERN PetscErrorCode dvd_static_precond_PC(dvdDashboard *d,dvdBlackboard *b,PC pc);
    430: PETSC_INTERN PetscErrorCode dvd_jacobi_precond(dvdDashboard *d,dvdBlackboard *b);
    431: PETSC_INTERN PetscErrorCode dvd_profiler(dvdDashboard *d,dvdBlackboard *b);
    432: PETSC_INTERN PetscErrorCode dvd_prof_init();
    433: PETSC_INTERN PetscErrorCode dvd_harm_conf(dvdDashboard *d,dvdBlackboard *b,HarmType_t mode,PetscBool fixedTarget,PetscScalar t);

    435: /* Methods */
    436: PETSC_INTERN PetscErrorCode dvd_schm_basic_preconf(dvdDashboard *d,dvdBlackboard *b,PetscInt mpd,PetscInt min_size_V,PetscInt bs,PetscInt ini_size_V,PetscInt size_initV,PetscInt plusk,HarmType_t harmMode,KSP ksp,InitType_t init,PetscBool allResiduals,EPSOrthType orth,PetscInt cX_proj,PetscInt cX_impr,Method_t method);
    437: PETSC_INTERN PetscErrorCode dvd_schm_basic_conf(dvdDashboard *d,dvdBlackboard *b,PetscInt mpd,PetscInt min_size_V,PetscInt bs,PetscInt ini_size_V,PetscInt size_initV,PetscInt plusk,IP ip,HarmType_t harmMode,PetscBool fixedTarget,PetscScalar t,KSP ksp,PetscReal fix,InitType_t init,PetscBool allResiduals,EPSOrthType orth,PetscInt cX_proj,PetscInt cX_impr,PetscBool dynamic,Method_t method);

    439: /* BLAS routines */
    440: PETSC_INTERN PetscErrorCode SlepcDenseMatProdTriang(PetscScalar *C,MatType_t sC,PetscInt ldC,const PetscScalar *A,MatType_t sA,PetscInt ldA,PetscInt rA,PetscInt cA,PetscBool At,const PetscScalar *B,MatType_t sB,PetscInt ldB,PetscInt rB,PetscInt cB,PetscBool Bt);
    441: PETSC_INTERN PetscErrorCode SlepcDenseNorm(PetscScalar *A,PetscInt ldA,PetscInt _rA,PetscInt cA,PetscScalar *eigi);
    442: PETSC_INTERN PetscErrorCode SlepcDenseCopy(PetscScalar *Y,PetscInt ldY,PetscScalar *X,PetscInt ldX,PetscInt rX,PetscInt cX);
    443: PETSC_INTERN PetscErrorCode SlepcDenseCopyTriang(PetscScalar *Y,MatType_t sY,PetscInt ldY,PetscScalar *X,MatType_t sX,PetscInt ldX,PetscInt rX,PetscInt cX);
    444: PETSC_INTERN PetscErrorCode SlepcUpdateVectorsZ(Vec *Y,PetscScalar beta,PetscScalar alpha,Vec *X,PetscInt cX,const PetscScalar *M,PetscInt ldM,PetscInt rM,PetscInt cM);
    445: PETSC_INTERN PetscErrorCode SlepcUpdateVectorsS(Vec *Y,PetscInt dY,PetscScalar beta,PetscScalar alpha,Vec *X,PetscInt cX,PetscInt dX,const PetscScalar *M,PetscInt ldM,PetscInt rM,PetscInt cM);
    446: PETSC_INTERN PetscErrorCode SlepcUpdateVectorsD(Vec *X,PetscInt cX,PetscScalar alpha,const PetscScalar *M,PetscInt ldM,PetscInt rM,PetscInt cM,PetscScalar *work,PetscInt lwork);
    447: PETSC_INTERN PetscErrorCode VecsMult(PetscScalar *M,MatType_t sM,PetscInt ldM,Vec *U,PetscInt sU,PetscInt eU,Vec *V,PetscInt sV,PetscInt eV,PetscScalar *workS0,PetscScalar *workS1);
    448: PETSC_INTERN PetscErrorCode VecsMultS(PetscScalar *M,MatType_t sM,PetscInt ldM,Vec *U,PetscInt sU,PetscInt eU,Vec *V,PetscInt sV,PetscInt eV,DvdReduction *r,DvdMult_copy_func *sr);
    449: PETSC_INTERN PetscErrorCode VecsMultIb(PetscScalar *M,MatType_t sM,PetscInt ldM,PetscInt rM,PetscInt cM,PetscScalar *auxS,Vec V);
    450: PETSC_INTERN PetscErrorCode VecsMultIa(PetscScalar *M,MatType_t sM,PetscInt ldM,Vec *U,PetscInt sU,PetscInt eU,Vec *V,PetscInt sV,PetscInt eV);
    451: PETSC_INTERN PetscErrorCode SlepcAllReduceSumBegin(DvdReductionChunk *ops,PetscInt max_size_ops,PetscScalar *in,PetscScalar *out,PetscInt max_size_in,DvdReduction *r,MPI_Comm comm);
    452: PETSC_INTERN PetscErrorCode SlepcAllReduceSum(DvdReduction *r,PetscInt size_in,DvdReductionPostF f,void *ptr,PetscScalar **in);
    453: PETSC_INTERN PetscErrorCode SlepcAllReduceSumEnd(DvdReduction *r);
    454: PETSC_INTERN PetscErrorCode dvd_orthV(IP ip,Vec *DS,PetscInt size_DS,Vec *cX,PetscInt size_cX,Vec *V,PetscInt V_new_s,PetscInt V_new_e,PetscScalar *auxS,PetscRandom rand);
    455: PETSC_INTERN PetscErrorCode dvd_BorthV_faster(IP ip,Vec *DS,Vec *BDS,PetscReal *BDSn,PetscInt size_DS,Vec *cX,Vec *BcX,PetscReal *BcXn,PetscInt size_cX,Vec *V,Vec *BV,PetscReal *BVn,PetscInt V_new_s,PetscInt V_new_e,PetscScalar *auxS,PetscRandom rand);
    456: PETSC_INTERN PetscErrorCode dvd_BorthV_stable(IP ip,Vec *defl,PetscReal *BDSn,PetscInt size_DS,Vec *cX,PetscReal *BcXn,PetscInt size_cX,Vec *V,PetscReal *BVn,PetscInt V_new_s,PetscInt V_new_e,PetscScalar *auxS,PetscRandom rand);

    458: /* SLEPc interface routines */
    459: PETSC_INTERN PetscErrorCode SLEPcNotImplemented();
    460: PETSC_INTERN PetscErrorCode EPSCreate_XD(EPS eps);
    461: PETSC_INTERN PetscErrorCode EPSReset_XD(EPS eps);
    462: PETSC_INTERN PetscErrorCode EPSSetUp_XD(EPS eps);
    463: PETSC_INTERN PetscErrorCode EPSSolve_XD(EPS eps);
    464: PETSC_INTERN PetscErrorCode EPSComputeVectors_XD(EPS eps);
    465: PETSC_INTERN PetscErrorCode EPSXDSetKrylovStart_XD(EPS eps,PetscBool krylovstart);
    466: PETSC_INTERN PetscErrorCode EPSXDGetKrylovStart_XD(EPS eps,PetscBool *krylovstart);
    467: PETSC_INTERN PetscErrorCode EPSXDSetBlockSize_XD(EPS eps,PetscInt blocksize);
    468: PETSC_INTERN PetscErrorCode EPSXDGetBlockSize_XD(EPS eps,PetscInt *blocksize);
    469: PETSC_INTERN PetscErrorCode EPSXDSetRestart_XD(EPS eps,PetscInt minv,PetscInt plusk);
    470: PETSC_INTERN PetscErrorCode EPSXDGetRestart_XD(EPS eps,PetscInt *minv,PetscInt *plusk);
    471: PETSC_INTERN PetscErrorCode EPSXDGetInitialSize_XD(EPS eps,PetscInt *initialsize);
    472: PETSC_INTERN PetscErrorCode EPSXDSetInitialSize_XD(EPS eps,PetscInt initialsize);
    473: PETSC_INTERN PetscErrorCode EPSXDGetFix_XD(EPS eps,PetscReal *fix);
    474: PETSC_INTERN PetscErrorCode EPSJDSetFix_JD(EPS eps,PetscReal fix);
    475: PETSC_INTERN PetscErrorCode EPSXDSetBOrth_XD(EPS eps,EPSOrthType borth);
    476: PETSC_INTERN PetscErrorCode EPSXDGetBOrth_XD(EPS eps,EPSOrthType *borth);
    477: PETSC_INTERN PetscErrorCode EPSJDSetConstCorrectionTol_JD(EPS eps,PetscBool constant);
    478: PETSC_INTERN PetscErrorCode EPSJDGetConstCorrectionTol_JD(EPS eps,PetscBool *constant);
    479: PETSC_INTERN PetscErrorCode EPSXDSetWindowSizes_XD(EPS eps,PetscInt pwindow,PetscInt qwindow);
    480: PETSC_INTERN PetscErrorCode EPSXDGetWindowSizes_XD(EPS eps,PetscInt *pwindow,PetscInt *qwindow);
    481: PETSC_INTERN PetscErrorCode EPSXDSetMethod(EPS eps,Method_t method);
    482: PETSC_INTERN PetscErrorCode EPSXDGetMethod_XD(EPS eps,Method_t *method);

    484: /* Common inline function */
    487: PETSC_STATIC_INLINE PetscErrorCode dvd_improvex_compute_X(dvdDashboard *d,PetscInt i_s,PetscInt i_e,Vec *u,PetscScalar *pX,PetscInt ld)
    488: {
    489:   PetscErrorCode  ierr;
    490:   PetscInt        n = i_e - i_s,i;

    493:   SlepcUpdateVectorsZ(u,0.0,1.0,d->V-d->cX_in_H,d->size_V+d->cX_in_H,&pX[ld*i_s],ld,d->size_H,n);
    494:   /* nX(i) <- ||X(i)|| */
    495:   if (d->correctXnorm) {
    496:     for (i=0; i<n; i++) {
    497:       VecNormBegin(u[i],NORM_2,&d->nX[i_s+i]);
    498:     }
    499:     for (i=0; i<n; i++) {
    500:       VecNormEnd(u[i],NORM_2,&d->nX[i_s+i]);
    501:     }
    502: #if !defined(PETSC_USE_COMPLEX)
    503:     for (i=0;i<n;i++) {
    504:       if (d->eigi[i_s+i] != 0.0) {
    505:         d->nX[i_s+i] = d->nX[i_s+i+1] = PetscSqrtScalar(d->nX[i_s+i]*d->nX[i_s+i]+d->nX[i_s+i+1]*d->nX[i_s+i+1]);
    506:         i++;
    507:       }
    508:     }
    509: #endif
    510:   } else {
    511:     for (i=0; i<n; i++) d->nX[i_s+i] = 1.0;
    512:   }
    513:   return(0);
    514: }

    517: #define _Ceil(A,B) ((A)/(B)+((A)%(B)==0?0:1))
    518: #define FromIntToScalar(S) ((PetscInt)_Ceil((S)*sizeof(PetscBLASInt),sizeof(PetscScalar)))
    519: #define FromRealToScalar(S) ((PetscInt)_Ceil((S)*sizeof(PetscReal),sizeof(PetscScalar)))