Date: 2013-09-02T10:04:39+00:00

Actual source code: jd.c

      1: /*

      3:    SLEPc eigensolver: "jd"

      5:    Method: Jacobi-Davidson

      7:    Algorithm:

      9:        Jacobi-Davidson with various subspace extraction and
     10:        restart techniques.

     12:    References:

     14:        [1] G.L.G. Sleijpen and H.A. van der Vorst, "A Jacobi-Davidson
     15:            iteration method for linear eigenvalue problems", SIAM J.
     16:            Matrix Anal. Appl. 17(2):401-425, 1996.

     18:        [2] E. Romero and J.E. Roman, "A parallel implementation of
     19:            Davidson methods for large-scale eigenvalue problems in
     20:            SLEPc", submitted, 2013.

     22:    Last update: Jul 2012

     24:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     25:    SLEPc - Scalable Library for Eigenvalue Problem Computations
     26:    Copyright (c) 2002-2013, Universitat Politecnica de Valencia, Spain

     28:    This file is part of SLEPc.

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

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

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

     44: #include <slepc-private/epsimpl.h>                /*I "slepceps.h" I*/
     45: #include <../src/eps/impls/davidson/common/davidson.h>

     49: PetscErrorCode EPSSetFromOptions_JD(EPS eps)
     50: {
     52:   PetscBool      flg,op;
     53:   PetscInt       opi,opi0;
     54:   PetscReal      opf;
     55:   KSP            ksp;
     56:   EPSOrthType    orth;
     57:   const char     *orth_list[3] = {"I","B","B_opt"};

     60:   PetscOptionsHead("EPS Jacobi-Davidson (JD) Options");

     62:   EPSJDGetKrylovStart(eps,&op);
     63:   PetscOptionsBool("-eps_jd_krylov_start","Start the searching subspace with a krylov basis","EPSJDSetKrylovStart",op,&op,&flg);
     64:   if (flg) { EPSJDSetKrylovStart(eps,op); }

     66:   EPSJDGetBlockSize(eps,&opi);
     67:   PetscOptionsInt("-eps_jd_blocksize","Number vectors add to the searching subspace","EPSJDSetBlockSize",opi,&opi,&flg);
     68:   if (flg) { EPSJDSetBlockSize(eps,opi); }

     70:   EPSJDGetRestart(eps,&opi,&opi0);
     71:   PetscOptionsInt("-eps_jd_minv","Set the size of the searching subspace after restarting","EPSJDSetRestart",opi,&opi,&flg);
     72:   if (flg) { EPSJDSetRestart(eps,opi,opi0); }

     74:   PetscOptionsInt("-eps_jd_plusk","Set the number of saved eigenvectors from the previous iteration when restarting","EPSJDSetRestart",opi0,&opi0,&flg);
     75:   if (flg) { EPSJDSetRestart(eps,opi,opi0); }

     77:   EPSJDGetInitialSize(eps,&opi);
     78:   PetscOptionsInt("-eps_jd_initial_size","Set the initial size of the searching subspace","EPSJDSetInitialSize",opi,&opi,&flg);
     79:   if (flg) { EPSJDSetInitialSize(eps,opi); }

     81:   EPSJDGetFix(eps,&opf);
     82:   PetscOptionsReal("-eps_jd_fix","Set the tolerance for changing the target in the correction equation","EPSJDSetFix",opf,&opf,&flg);
     83:   if (flg) { EPSJDSetFix(eps,opf); }

     85:   EPSJDGetBOrth(eps,&orth);
     86:   PetscOptionsEList("-eps_jd_borth","orthogonalization used in the search subspace","EPSJDSetBOrth",orth_list,3,orth_list[orth-1],&opi,&flg);
     87:   if (flg) { EPSJDSetBOrth(eps,(EPSOrthType)(opi+1)); }

     89:   EPSJDGetConstCorrectionTol(eps,&op);
     90:   PetscOptionsBool("-eps_jd_const_correction_tol","Disable the dynamic stopping criterion when solving the correction equation","EPSJDSetConstCorrectionTol",op,&op,&flg);
     91:   if (flg) { EPSJDSetConstCorrectionTol(eps,op); }

     93:   EPSJDGetWindowSizes(eps,&opi,&opi0);
     94:   PetscOptionsInt("-eps_jd_pwindow","(Experimental!) Set the number of converged vectors in the projector","EPSJDSetWindowSizes",opi,&opi,&flg);
     95:   if (flg) { EPSJDSetWindowSizes(eps,opi,opi0); }

     97:   PetscOptionsInt("-eps_jd_qwindow","(Experimental!) Set the number of converged vectors in the projected problem","EPSJDSetWindowSizes",opi0,&opi0,&flg);
     98:   if (flg) { EPSJDSetWindowSizes(eps,opi,opi0); }

    100:   /* Set STPrecond as the default ST */
    101:   if (!((PetscObject)eps->st)->type_name) {
    102:     STSetType(eps->st,STPRECOND);
    103:   }
    104:   STPrecondSetKSPHasMat(eps->st,PETSC_FALSE);

    106:   /* Set the default options of the KSP */
    107:   STGetKSP(eps->st,&ksp);
    108:   if (!((PetscObject)ksp)->type_name) {
    109:     KSPSetType(ksp,KSPBCGSL);
    110:     KSPSetTolerances(ksp,1e-4,PETSC_DEFAULT,PETSC_DEFAULT,90);
    111:   }
    112:   PetscOptionsTail();
    113:   return(0);
    114: }

    118: PetscErrorCode EPSSetUp_JD(EPS eps)
    119: {
    121:   PetscBool      t;
    122:   KSP            ksp;

    125:   /* Setup common for all davidson solvers */
    126:   EPSSetUp_XD(eps);

    128:   /* Set the default options of the KSP */
    129:   STGetKSP(eps->st,&ksp);
    130:   if (!((PetscObject)ksp)->type_name) {
    131:     KSPSetType(ksp,KSPBCGSL);
    132:     KSPSetTolerances(ksp,1e-4,PETSC_DEFAULT,PETSC_DEFAULT,90);
    133:   }

    135:   /* Check some constraints */
    136:   PetscObjectTypeCompare((PetscObject)ksp,KSPPREONLY,&t);
    137:   if (t) SETERRQ(PetscObjectComm((PetscObject)eps),PETSC_ERR_SUP,"EPSJD does not work with KSPPREONLY");
    138:   return(0);
    139: }

    143: PetscErrorCode EPSDestroy_JD(EPS eps)
    144: {
    145:   PetscErrorCode  ierr;

    148:   PetscFree(eps->data);
    149:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetKrylovStart_C",NULL);
    150:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetKrylovStart_C",NULL);
    151:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetBlockSize_C",NULL);
    152:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetBlockSize_C",NULL);
    153:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetRestart_C",NULL);
    154:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetRestart_C",NULL);
    155:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetInitialSize_C",NULL);
    156:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetInitialSize_C",NULL);
    157:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetFix_C",NULL);
    158:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetFix_C",NULL);
    159:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetConstCorrectionTol_C",NULL);
    160:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetConstCorrectionTol_C",NULL);
    161:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetWindowSizes_C",NULL);
    162:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetWindowSizes_C",NULL);
    163:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetBOrth_C",NULL);
    164:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetBOrth_C",NULL);
    165:   return(0);
    166: }

    170: /*@
    171:    EPSJDSetKrylovStart - Activates or deactivates starting the searching
    172:    subspace with a Krylov basis.

    174:    Logically Collective on EPS

    176:    Input Parameters:
    177: +  eps - the eigenproblem solver context
    178: -  krylovstart - boolean flag

    180:    Options Database Key:
    181: .  -eps_jd_krylov_start - Activates starting the searching subspace with a
    182:     Krylov basis

    184:    Level: advanced

    186: .seealso: EPSJDGetKrylovStart()
    187: @*/
    188: PetscErrorCode EPSJDSetKrylovStart(EPS eps,PetscBool krylovstart)
    189: {

    195:   PetscTryMethod(eps,"EPSJDSetKrylovStart_C",(EPS,PetscBool),(eps,krylovstart));
    196:   return(0);
    197: }

    201: /*@
    202:    EPSJDGetKrylovStart - Returns a flag indicating if the searching subspace is started with a
    203:    Krylov basis.

    205:    Not Collective

    207:    Input Parameter:
    208: .  eps - the eigenproblem solver context

    210:    Output Parameters:
    211: .  krylovstart - boolean flag indicating if the searching subspace is started
    212:    with a Krylov basis

    214:    Level: advanced

    216: .seealso: EPSJDGetKrylovStart()
    217: @*/
    218: PetscErrorCode EPSJDGetKrylovStart(EPS eps,PetscBool *krylovstart)
    219: {

    225:   PetscTryMethod(eps,"EPSJDGetKrylovStart_C",(EPS,PetscBool*),(eps,krylovstart));
    226:   return(0);
    227: }

    231: /*@
    232:    EPSJDSetBlockSize - Sets the number of vectors to be added to the searching space
    233:    in every iteration.

    235:    Logically Collective on EPS

    237:    Input Parameters:
    238: +  eps - the eigenproblem solver context
    239: -  blocksize - number of vectors added to the search space in every iteration

    241:    Options Database Key:
    242: .  -eps_jd_blocksize - number of vectors added to the searching space every iteration

    244:    Level: advanced

    246: .seealso: EPSJDSetKrylovStart()
    247: @*/
    248: PetscErrorCode EPSJDSetBlockSize(EPS eps,PetscInt blocksize)
    249: {

    255:   PetscTryMethod(eps,"EPSJDSetBlockSize_C",(EPS,PetscInt),(eps,blocksize));
    256:   return(0);
    257: }

    261: /*@
    262:    EPSJDGetBlockSize - Returns the number of vectors to be added to the searching space
    263:    in every iteration.

    265:    Not Collective

    267:    Input Parameter:
    268: .  eps - the eigenproblem solver context

    270:    Output Parameter:
    271: .  blocksize - number of vectors added to the search space in every iteration

    273:    Level: advanced

    275: .seealso: EPSJDSetBlockSize()
    276: @*/
    277: PetscErrorCode EPSJDGetBlockSize(EPS eps,PetscInt *blocksize)
    278: {

    284:   PetscTryMethod(eps,"EPSJDGetBlockSize_C",(EPS,PetscInt*),(eps,blocksize));
    285:   return(0);
    286: }

    290: /*@
    291:    EPSJDGetRestart - Gets the number of vectors of the searching space after
    292:    restarting and the number of vectors saved from the previous iteration.

    294:    Not Collective

    296:    Input Parameter:
    297: .  eps - the eigenproblem solver context

    299:    Output Parameter:
    300: +  minv - number of vectors of the searching subspace after restarting
    301: -  plusk - number of vectors saved from the previous iteration

    303:    Level: advanced

    305: .seealso: EPSJDSetRestart()
    306: @*/
    307: PetscErrorCode EPSJDGetRestart(EPS eps,PetscInt *minv,PetscInt *plusk)
    308: {

    313:   PetscTryMethod(eps,"EPSJDGetRestart_C",(EPS,PetscInt*,PetscInt*),(eps,minv,plusk));
    314:   return(0);
    315: }

    319: /*@
    320:    EPSJDSetRestart - Sets the number of vectors of the searching space after
    321:    restarting and the number of vectors saved from the previous iteration.

    323:    Logically Collective on EPS

    325:    Input Parameters:
    326: +  eps - the eigenproblem solver context
    327: .  minv - number of vectors of the searching subspace after restarting
    328: -  plusk - number of vectors saved from the previous iteration

    330:    Options Database Keys:
    331: +  -eps_jd_minv - number of vectors of the searching subspace after restarting
    332: -  -eps_jd_plusk - number of vectors saved from the previous iteration

    334:    Level: advanced

    336: .seealso: EPSJDGetRestart()
    337: @*/
    338: PetscErrorCode EPSJDSetRestart(EPS eps,PetscInt minv,PetscInt plusk)
    339: {

    346:   PetscTryMethod(eps,"EPSJDSetRestart_C",(EPS,PetscInt,PetscInt),(eps,minv,plusk));
    347:   return(0);
    348: }

    352: /*@
    353:    EPSJDGetInitialSize - Returns the initial size of the searching space.

    355:    Not Collective

    357:    Input Parameter:
    358: .  eps - the eigenproblem solver context

    360:    Output Parameter:
    361: .  initialsize - number of vectors of the initial searching subspace

    363:    Notes:
    364:    If EPSJDGetKrylovStart() is PETSC_FALSE and the user provides vectors with
    365:    EPSSetInitialSpace(), up to initialsize vectors will be used; and if the
    366:    provided vectors are not enough, the solver completes the subspace with
    367:    random vectors. In the case of EPSJDGetKrylovStart() being PETSC_TRUE, the solver
    368:    gets the first vector provided by the user or, if not available, a random vector,
    369:    and expands the Krylov basis up to initialsize vectors.

    371:    Level: advanced

    373: .seealso: EPSJDSetInitialSize(), EPSJDGetKrylovStart()
    374: @*/
    375: PetscErrorCode EPSJDGetInitialSize(EPS eps,PetscInt *initialsize)
    376: {

    382:   PetscTryMethod(eps,"EPSJDGetInitialSize_C",(EPS,PetscInt*),(eps,initialsize));
    383:   return(0);
    384: }

    388: /*@
    389:    EPSJDSetInitialSize - Sets the initial size of the searching space.

    391:    Logically Collective on EPS

    393:    Input Parameters:
    394: +  eps - the eigenproblem solver context
    395: -  initialsize - number of vectors of the initial searching subspace

    397:    Options Database Key:
    398: .  -eps_jd_initial_size - number of vectors of the initial searching subspace

    400:    Notes:
    401:    If EPSJDGetKrylovStart() is PETSC_FALSE and the user provides vectors with
    402:    EPSSetInitialSpace(), up to initialsize vectors will be used; and if the
    403:    provided vectors are not enough, the solver completes the subspace with
    404:    random vectors. In the case of EPSJDGetKrylovStart() being PETSC_TRUE, the solver
    405:    gets the first vector provided by the user or, if not available, a random vector,
    406:    and expands the Krylov basis up to initialsize vectors.

    408:    Level: advanced

    410: .seealso: EPSJDGetInitialSize(), EPSJDGetKrylovStart()
    411: @*/
    412: PetscErrorCode EPSJDSetInitialSize(EPS eps,PetscInt initialsize)
    413: {

    419:   PetscTryMethod(eps,"EPSJDSetInitialSize_C",(EPS,PetscInt),(eps,initialsize));
    420:   return(0);
    421: }

    425: /*@
    426:    EPSJDGetFix - Returns the threshold for changing the target in the correction
    427:    equation.

    429:    Not Collective

    431:    Input Parameter:
    432: .  eps - the eigenproblem solver context

    434:    Output Parameter:
    435: .  fix - threshold for changing the target

    437:    Note:
    438:    The target in the correction equation is fixed at the first iterations.
    439:    When the norm of the residual vector is lower than the fix value,
    440:    the target is set to the corresponding eigenvalue.

    442:    Level: advanced

    444: .seealso: EPSJDSetFix()
    445: @*/
    446: PetscErrorCode EPSJDGetFix(EPS eps,PetscReal *fix)
    447: {

    453:   PetscTryMethod(eps,"EPSJDGetFix_C",(EPS,PetscReal*),(eps,fix));
    454:   return(0);
    455: }

    459: /*@
    460:    EPSJDSetFix - Sets the threshold for changing the target in the correction
    461:    equation.

    463:    Logically Collective on EPS

    465:    Input Parameters:
    466: +  eps - the eigenproblem solver context
    467: -  fix - threshold for changing the target

    469:    Options Database Key:
    470: .  -eps_jd_fix - the fix value

    472:    Note:
    473:    The target in the correction equation is fixed at the first iterations.
    474:    When the norm of the residual vector is lower than the fix value,
    475:    the target is set to the corresponding eigenvalue.

    477:    Level: advanced

    479: .seealso: EPSJDGetFix()
    480: @*/
    481: PetscErrorCode EPSJDSetFix(EPS eps,PetscReal fix)
    482: {

    488:   PetscTryMethod(eps,"EPSJDSetFix_C",(EPS,PetscReal),(eps,fix));
    489:   return(0);
    490: }

    494: /*@
    495:    EPSJDSetConstCorrectionTol - If true, deactivates the dynamic stopping criterion
    496:    (also called Newton) that sets the KSP relative tolerance
    497:    to 0.5**i, where i is the number of EPS iterations from the last converged value.

    499:    Logically Collective on EPS

    501:    Input Parameters:
    502: +  eps - the eigenproblem solver context
    503: -  constant - if false, the KSP relative tolerance is set to 0.5**i.

    505:    Options Database Key:
    506: .  -eps_jd_const_correction_tol - Deactivates the dynamic stopping criterion.

    508:    Level: advanced

    510: .seealso: EPSJDGetConstCorrectionTol()
    511: @*/
    512: PetscErrorCode EPSJDSetConstCorrectionTol(EPS eps,PetscBool constant)
    513: {

    519:   PetscTryMethod(eps,"EPSJDSetConstCorrectionTol_C",(EPS,PetscBool),(eps,constant));
    520:   return(0);
    521: }

    525: /*@
    526:    EPSJDGetConstCorrectionTol - Returns a flag indicating if the dynamic stopping is being used for
    527:    solving the correction equation. If the flag is false the KSP relative tolerance is set
    528:    to 0.5**i, where i is the number of EPS iterations from the last converged value.

    530:    Not Collective

    532:    Input Parameter:
    533: .  eps - the eigenproblem solver context

    535:    Output Parameters:
    536: .  constant - boolean flag indicating if the dynamic stopping criterion is not being used.

    538:    Level: advanced

    540: .seealso: EPSJDGetConstCorrectionTol()
    541: @*/
    542: PetscErrorCode EPSJDGetConstCorrectionTol(EPS eps,PetscBool *constant)
    543: {

    549:   PetscTryMethod(eps,"EPSJDGetConstCorrectionTol",(EPS,PetscBool*),(eps,constant));
    550:   return(0);
    551: }

    555: /*@
    556:    EPSJDGetWindowSizes - Gets the number of converged vectors in the projected
    557:    problem (or Rayleigh quotient) and in the projector employed in the correction
    558:    equation.

    560:    Not Collective

    562:    Input Parameter:
    563: .  eps - the eigenproblem solver context

    565:    Output Parameter:
    566: +  pwindow - number of converged vectors in the projector
    567: -  qwindow - number of converged vectors in the projected problem

    569:    Level: advanced

    571: .seealso: EPSJDSetWindowSizes()
    572: @*/
    573: PetscErrorCode EPSJDGetWindowSizes(EPS eps,PetscInt *pwindow,PetscInt *qwindow)
    574: {

    579:   PetscTryMethod(eps,"EPSJDGetWindowSizes_C",(EPS,PetscInt*,PetscInt*),(eps,pwindow,qwindow));
    580:   return(0);
    581: }

    585: /*@
    586:    EPSJDSetWindowSizes - Sets the number of converged vectors in the projected
    587:    problem (or Rayleigh quotient) and in the projector employed in the correction
    588:    equation.

    590:    Logically Collective on EPS

    592:    Input Parameters:
    593: +  eps - the eigenproblem solver context
    594: .  pwindow - number of converged vectors in the projector
    595: -  qwindow - number of converged vectors in the projected problem

    597:    Options Database Keys:
    598: +  -eps_jd_pwindow - set the number of converged vectors in the projector
    599: -  -eps_jd_qwindow - set the number of converged vectors in the projected problem

    601:    Level: advanced

    603: .seealso: EPSJDGetWindowSizes()
    604: @*/
    605: PetscErrorCode EPSJDSetWindowSizes(EPS eps,PetscInt pwindow,PetscInt qwindow)
    606: {

    613:   PetscTryMethod(eps,"EPSJDSetWindowSizes_C",(EPS,PetscInt,PetscInt),(eps,pwindow,qwindow));
    614:   return(0);
    615: }

    619: /*@
    620:    EPSJDSetBOrth - Selects the orthogonalization that will be used in the search
    621:    subspace in case of generalized Hermitian problems.

    623:    Logically Collective on EPS

    625:    Input Parameters:
    626: +  eps   - the eigenproblem solver context
    627: -  borth - the kind of orthogonalization

    629:    Possible values:
    630:    The parameter 'borth' can have one of these values

    632: +   EPS_ORTH_I - orthogonalization of the search subspace
    633: .   EPS_ORTH_B - B-orthogonalization of the search subspace
    634: -   EPS_ORTH_BOPT - B-orthogonalization of the search subspace with an alternative method

    636:    Options Database Key:
    637: .  -eps_jd_borth - Set the orthogonalization used in the search subspace

    639:    Notes:
    640:    If borth is EPS_ORTH_B, the solver uses a variant of Gram-Schmidt (selected in
    641:    IP associated to the EPS) with the inner product defined by the matrix problem B.
    642:    If borth is EPS_ORTH_BOPT, it uses another variant of Gram-Schmidt that only performs
    643:    one matrix-vector product although more than one reorthogonalization would be done.

    645:    Level: advanced

    647: .seealso: EPSJDGetBOrth()
    648: @*/
    649: PetscErrorCode EPSJDSetBOrth(EPS eps,EPSOrthType borth)
    650: {

    656:   PetscTryMethod(eps,"EPSJDSetBOrth_C",(EPS,EPSOrthType),(eps,borth));
    657:   return(0);
    658: }

    662: /*@
    663:    EPSJDGetBOrth - Returns the orthogonalization used in the search
    664:    subspace in case of generalized Hermitian problems.

    666:    Not Collective

    668:    Input Parameter:
    669: .  eps - the eigenproblem solver context

    671:    Output Parameters:
    672: .  borth - the kind of orthogonalization

    674:    Notes:
    675:    See EPSJDSetBOrth() for possible values of 'borth'.

    677:    Level: advanced

    679: .seealso: EPSJDSetBOrth(), EPSOrthType
    680: @*/
    681: PetscErrorCode EPSJDGetBOrth(EPS eps,EPSOrthType *borth)
    682: {

    688:   PetscTryMethod(eps,"EPSJDGetBOrth_C",(EPS,EPSOrthType*),(eps,borth));
    689:   return(0);
    690: }

    694: PETSC_EXTERN PetscErrorCode EPSCreate_JD(EPS eps)
    695: {

    699:   /* Load the Davidson solver */
    700:   EPSCreate_XD(eps);
    701:   EPSXDSetMethod(eps,DVD_METH_JD);

    703:   /* Overload the JD properties */
    704:   eps->ops->setfromoptions = EPSSetFromOptions_JD;
    705:   eps->ops->setup          = EPSSetUp_JD;
    706:   eps->ops->destroy        = EPSDestroy_JD;

    708:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetKrylovStart_C",EPSXDSetKrylovStart_XD);
    709:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetKrylovStart_C",EPSXDGetKrylovStart_XD);
    710:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetBlockSize_C",EPSXDSetBlockSize_XD);
    711:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetBlockSize_C",EPSXDGetBlockSize_XD);
    712:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetRestart_C",EPSXDSetRestart_XD);
    713:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetRestart_C",EPSXDGetRestart_XD);
    714:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetInitialSize_C",EPSXDSetInitialSize_XD);
    715:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetInitialSize_C",EPSXDGetInitialSize_XD);
    716:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetFix_C",EPSJDSetFix_JD);
    717:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetFix_C",EPSXDGetFix_XD);
    718:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetConstCorrectionTol_C",EPSJDSetConstCorrectionTol_JD);
    719:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetConstCorrectionTol_C",EPSJDGetConstCorrectionTol_JD);
    720:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetWindowSizes_C",EPSXDSetWindowSizes_XD);
    721:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetWindowSizes_C",EPSXDGetWindowSizes_XD);
    722:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDSetBOrth_C",EPSXDSetBOrth_XD);
    723:   PetscObjectComposeFunction((PetscObject)eps,"EPSJDGetBOrth_C",EPSXDGetBOrth_XD);
    724:   return(0);
    725: }