Actual source code: cholesky.c

      1: #define PETSCKSP_DLL

      3: /*
      4:    Defines a direct factorization preconditioner for any Mat implementation
      5:    Note: this need not be consided a preconditioner since it supplies
      6:          a direct solver.
      7: */
     8:  #include src/ksp/pc/pcimpl.h

     10: typedef struct {
     11:   Mat             fact;             /* factored matrix */
     12:   PetscReal       actualfill;       /* actual fill in factor */
     13:   PetscTruth      inplace;          /* flag indicating in-place factorization */
     14:   IS              row,col;          /* index sets used for reordering */
     15:   MatOrderingType ordering;         /* matrix ordering */
     16:   PetscTruth      reuseordering;    /* reuses previous reordering computed */
     17:   PetscTruth      reusefill;        /* reuse fill from previous Cholesky */
     18:   MatFactorInfo   info;
     19: } PC_Cholesky;

     24: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetZeroPivot_Cholesky(PC pc,PetscReal z)
     25: {
     26:   PC_Cholesky *ch;

     29:   ch                 = (PC_Cholesky*)pc->data;
     30:   ch->info.zeropivot = z;
     31:   return(0);
     32: }

     38: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetShiftNonzero_Cholesky(PC pc,PetscReal shift)
     39: {
     40:   PC_Cholesky *dir;

     43:   dir = (PC_Cholesky*)pc->data;
     44:   if (shift == (PetscReal) PETSC_DECIDE) {
     45:     dir->info.shiftnz = 1.e-12;
     46:   } else {
     47:     dir->info.shiftnz = shift;
     48:   }
     49:   return(0);
     50: }

     56: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetShiftPd_Cholesky(PC pc,PetscTruth shift)
     57: {
     58:   PC_Cholesky *dir;
     59:
     61:   dir = (PC_Cholesky*)pc->data;
     62:   dir->info.shiftpd = shift;
     63:   if (shift) dir->info.shift_fraction = 0.0;
     64:   return(0);
     65: }

     71: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetReuseOrdering_Cholesky(PC pc,PetscTruth flag)
     72: {
     73:   PC_Cholesky *lu;
     74:
     76:   lu               = (PC_Cholesky*)pc->data;
     77:   lu->reuseordering = flag;
     78:   return(0);
     79: }

     85: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetReuseFill_Cholesky(PC pc,PetscTruth flag)
     86: {
     87:   PC_Cholesky *lu;
     88:
     90:   lu = (PC_Cholesky*)pc->data;
     91:   lu->reusefill = flag;
     92:   return(0);
     93: }

     98: static PetscErrorCode PCSetFromOptions_Cholesky(PC pc)
     99: {
    100:   PC_Cholesky    *lu = (PC_Cholesky*)pc->data;
    102:   PetscTruth     flg;
    103:   char           tname[256];
    104:   PetscFList     ordlist;
    105:
    107:   MatOrderingRegisterAll(PETSC_NULL);
    108:   PetscOptionsHead("Cholesky options");
    109:   PetscOptionsName("-pc_cholesky_in_place","Form Cholesky in the same memory as the matrix","PCCholeskySetUseInPlace",&flg);
    110:   if (flg) {
    111:     PCCholeskySetUseInPlace(pc);
    112:   }
    113:   PetscOptionsReal("-pc_cholesky_fill","Expected non-zeros in Cholesky/non-zeros in matrix","PCCholeskySetFill",lu->info.fill,&lu->info.fill,0);
    114:
    115:   PetscOptionsName("-pc_cholesky_reuse_fill","Use fill from previous factorization","PCCholeskySetReuseFill",&flg);
    116:   if (flg) {
    117:     PCCholeskySetReuseFill(pc,PETSC_TRUE);
    118:   }
    119:   PetscOptionsName("-pc_cholesky_reuse_ordering","Reuse ordering from previous factorization","PCCholeskySetReuseOrdering",&flg);
    120:   if (flg) {
    121:     PCCholeskySetReuseOrdering(pc,PETSC_TRUE);
    122:   }
    123:
    124:   MatGetOrderingList(&ordlist);
    125:   PetscOptionsList("-pc_cholesky_mat_ordering_type","Reordering to reduce nonzeros in Cholesky","PCCholeskySetMatOrdering",ordlist,lu->ordering,tname,256,&flg);
    126:   if (flg) {
    127:     PCCholeskySetMatOrdering(pc,tname);
    128:   }
    129:   PetscOptionsName("-pc_factor_shift_nonzero","Shift added to diagonal","PCFactorSetShiftNonzero",&flg);
    130:   if (flg) {
    131:     PCFactorSetShiftNonzero(pc,(PetscReal) PETSC_DECIDE);
    132:   }
    133:   PetscOptionsReal("-pc_factor_shift_nonzero","Shift added to diagonal","PCFactorSetShiftNonzero",lu->info.shiftnz,&lu->info.shiftnz,0);
    134:   PetscOptionsName("-pc_factor_shift_positive_definite","Manteuffel shift applied to diagonal","PCFactorSetShiftPd",&flg);
    135:   if (flg) {
    136:     PCFactorSetShiftPd(pc,PETSC_TRUE);
    137:   }
    138:   PetscOptionsReal("-pc_factor_zeropivot","Pivot is considered zero if less than","PCFactorSetZeroPivot",lu->info.zeropivot,&lu->info.zeropivot,0);

    140:   PetscOptionsTail();
    141:   return(0);
    142: }

    146: static PetscErrorCode PCView_Cholesky(PC pc,PetscViewer viewer)
    147: {
    148:   PC_Cholesky    *lu = (PC_Cholesky*)pc->data;
    150:   PetscTruth     iascii,isstring;
    151:
    153:   PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&iascii);
    154:   PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_STRING,&isstring);
    155:   if (iascii) {
    156:     MatInfo info;
    157:
    158:     if (lu->inplace) {PetscViewerASCIIPrintf(viewer,"  Cholesky: in-place factorization\n");}
    159:     else             {PetscViewerASCIIPrintf(viewer,"  Cholesky: out-of-place factorization\n");}
    160:     PetscViewerASCIIPrintf(viewer,"    matrix ordering: %s\n",lu->ordering);
    161:     if (lu->fact) {
    162:       MatGetInfo(lu->fact,MAT_LOCAL,&info);
    163:       PetscViewerASCIIPrintf(viewer,"    Cholesky nonzeros %g\n",info.nz_used);
    164:       PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_FACTOR_INFO);
    165:       MatView(lu->fact,viewer);
    166:       PetscViewerPopFormat(viewer);
    167:     }
    168:     if (lu->reusefill)    {PetscViewerASCIIPrintf(viewer,"       Reusing fill from past factorization\n");}
    169:     if (lu->reuseordering) {PetscViewerASCIIPrintf(viewer,"       Reusing reordering from past factorization\n");}
    170:   } else if (isstring) {
    171:     PetscViewerStringSPrintf(viewer," order=%s",lu->ordering);
    172:   } else {
    173:     SETERRQ1(PETSC_ERR_SUP,"Viewer type %s not supported for PCCholesky",((PetscObject)viewer)->type_name);
    174:   }
    175:   return(0);
    176: }

    180: static PetscErrorCode PCGetFactoredMatrix_Cholesky(PC pc,Mat *mat)
    181: {
    182:   PC_Cholesky *dir = (PC_Cholesky*)pc->data;
    183:
    185:   if (!dir->fact) SETERRQ(PETSC_ERR_ORDER,"Matrix not yet factored; call after KSPSetUp() or PCSetUp()");
    186:   *mat = dir->fact;
    187:   return(0);
    188: }

    192: static PetscErrorCode PCSetUp_Cholesky(PC pc)
    193: {
    195:   PetscTruth     flg;
    196:   PC_Cholesky    *dir = (PC_Cholesky*)pc->data;

    199:   if (dir->reusefill && pc->setupcalled) dir->info.fill = dir->actualfill;
    200:
    201:   if (dir->inplace) {
    202:     if (dir->row && dir->col && (dir->row != dir->col)) {
    203:       ISDestroy(dir->row);
    204:       dir->row = 0;
    205:     }
    206:     if (dir->col) {
    207:       ISDestroy(dir->col);
    208:       dir->col = 0;
    209:     }
    210:     MatGetOrdering(pc->pmat,dir->ordering,&dir->row,&dir->col);
    211:     if (dir->col && (dir->row != dir->col)) {  /* only use row ordering for SBAIJ */
    212:       ISDestroy(dir->col);
    213:       dir->col=0;
    214:     }
    215:     if (dir->row) {PetscLogObjectParent(pc,dir->row);}
    216:     MatCholeskyFactor(pc->pmat,dir->row,&dir->info);
    217:     dir->fact = pc->pmat;
    218:   } else {
    219:     MatInfo info;
    220:     if (!pc->setupcalled) {
    221:       MatGetOrdering(pc->pmat,dir->ordering,&dir->row,&dir->col);
    222:       if (dir->col && (dir->row != dir->col)) {  /* only use row ordering for SBAIJ */
    223:         ISDestroy(dir->col);
    224:         dir->col=0;
    225:       }
    226:       PetscOptionsHasName(pc->prefix,"-pc_cholesky_nonzeros_along_diagonal",&flg);
    227:       if (flg) {
    228:         PetscReal tol = 1.e-10;
    229:         PetscOptionsGetReal(pc->prefix,"-pc_cholesky_nonzeros_along_diagonal",&tol,PETSC_NULL);
    230:         MatReorderForNonzeroDiagonal(pc->pmat,tol,dir->row,dir->row);
    231:       }
    232:       if (dir->row) {PetscLogObjectParent(pc,dir->row);}
    233:       MatCholeskyFactorSymbolic(pc->pmat,dir->row,&dir->info,&dir->fact);
    234:       MatGetInfo(dir->fact,MAT_LOCAL,&info);
    235:       dir->actualfill = info.fill_ratio_needed;
    236:       PetscLogObjectParent(pc,dir->fact);
    237:     } else if (pc->flag != SAME_NONZERO_PATTERN) {
    238:       if (!dir->reuseordering) {
    239:         if (dir->row && dir->col && (dir->row != dir->col)) {
    240:           ISDestroy(dir->row);
    241:           dir->row = 0;
    242:         }
    243:         if (dir->col) {
    244:           ISDestroy(dir->col);
    245:           dir->col =0;
    246:         }
    247:         MatGetOrdering(pc->pmat,dir->ordering,&dir->row,&dir->col);
    248:         if (dir->col && (dir->row != dir->col)) {  /* only use row ordering for SBAIJ */
    249:           ISDestroy(dir->col);
    250:           dir->col=0;
    251:         }
    252:         PetscOptionsHasName(pc->prefix,"-pc_cholesky_nonzeros_along_diagonal",&flg);
    253:         if (flg) {
    254:           PetscReal tol = 1.e-10;
    255:           PetscOptionsGetReal(pc->prefix,"-pc_cholesky_nonzeros_along_diagonal",&tol,PETSC_NULL);
    256:           MatReorderForNonzeroDiagonal(pc->pmat,tol,dir->row,dir->row);
    257:         }
    258:         if (dir->row) {PetscLogObjectParent(pc,dir->row);}
    259:       }
    260:       MatDestroy(dir->fact);
    261:       MatCholeskyFactorSymbolic(pc->pmat,dir->row,&dir->info,&dir->fact);
    262:       MatGetInfo(dir->fact,MAT_LOCAL,&info);
    263:       dir->actualfill = info.fill_ratio_needed;
    264:       PetscLogObjectParent(pc,dir->fact);
    265:     }
    266:     MatCholeskyFactorNumeric(pc->pmat,&dir->info,&dir->fact);
    267:   }
    268:   return(0);
    269: }

    273: static PetscErrorCode PCDestroy_Cholesky(PC pc)
    274: {
    275:   PC_Cholesky    *dir = (PC_Cholesky*)pc->data;

    279:   if (!dir->inplace && dir->fact) {MatDestroy(dir->fact);}
    280:   if (dir->row) {ISDestroy(dir->row);}
    281:   if (dir->col) {ISDestroy(dir->col);}
    282:   PetscStrfree(dir->ordering);
    283:   PetscFree(dir);
    284:   return(0);
    285: }

    289: static PetscErrorCode PCApply_Cholesky(PC pc,Vec x,Vec y)
    290: {
    291:   PC_Cholesky    *dir = (PC_Cholesky*)pc->data;
    293:
    295:   if (dir->inplace) {MatSolve(pc->pmat,x,y);}
    296:   else              {MatSolve(dir->fact,x,y);}
    297:   return(0);
    298: }

    302: static PetscErrorCode PCApplyTranspose_Cholesky(PC pc,Vec x,Vec y)
    303: {
    304:   PC_Cholesky    *dir = (PC_Cholesky*)pc->data;

    308:   if (dir->inplace) {MatSolveTranspose(pc->pmat,x,y);}
    309:   else              {MatSolveTranspose(dir->fact,x,y);}
    310:   return(0);
    311: }

    313: /* -----------------------------------------------------------------------------------*/

    318: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetFill_Cholesky(PC pc,PetscReal fill)
    319: {
    320:   PC_Cholesky *dir;
    321:
    323:   dir = (PC_Cholesky*)pc->data;
    324:   dir->info.fill = fill;
    325:   return(0);
    326: }

    332: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetUseInPlace_Cholesky(PC pc)
    333: {
    334:   PC_Cholesky *dir;

    337:   dir = (PC_Cholesky*)pc->data;
    338:   dir->inplace = PETSC_TRUE;
    339:   return(0);
    340: }

    346: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetMatOrdering_Cholesky(PC pc,MatOrderingType ordering)
    347: {
    348:   PC_Cholesky    *dir = (PC_Cholesky*)pc->data;

    352:   PetscStrfree(dir->ordering);
    353:   PetscStrallocpy(ordering,&dir->ordering);
    354:   return(0);
    355: }

    358: /* -----------------------------------------------------------------------------------*/

    362: /*@
    363:    PCCholeskySetReuseOrdering - When similar matrices are factored, this
    364:    causes the ordering computed in the first factor to be used for all
    365:    following factors.

    367:    Collective on PC

    369:    Input Parameters:
    370: +  pc - the preconditioner context
    371: -  flag - PETSC_TRUE to reuse else PETSC_FALSE

    373:    Options Database Key:
    374: .  -pc_cholesky_reuse_ordering - Activate PCCholeskySetReuseOrdering()

    376:    Level: intermediate

    378: .keywords: PC, levels, reordering, factorization, incomplete, LU

    380: .seealso: PCCholeskySetReuseFill(), PCICholeskySetReuseOrdering(), PCICholeskyDTSetReuseFill()
    381: @*/
    382: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetReuseOrdering(PC pc,PetscTruth flag)
    383: {
    384:   PetscErrorCode ierr,(*f)(PC,PetscTruth);

    388:   PetscObjectQueryFunction((PetscObject)pc,"PCCholeskySetReuseOrdering_C",(void (**)(void))&f);
    389:   if (f) {
    390:     (*f)(pc,flag);
    391:   }
    392:   return(0);
    393: }

    397: /*@
    398:    PCCholeskySetReuseFill - When matrices with same nonzero structure are Cholesky factored,
    399:    this causes later ones to use the fill computed in the initial factorization.

    401:    Collective on PC

    403:    Input Parameters:
    404: +  pc - the preconditioner context
    405: -  flag - PETSC_TRUE to reuse else PETSC_FALSE

    407:    Options Database Key:
    408: .  -pc_cholesky_reuse_fill - Activates PCCholeskySetReuseFill()

    410:    Level: intermediate

    412: .keywords: PC, levels, reordering, factorization, incomplete, Cholesky

    414: .seealso: PCICholeskySetReuseOrdering(), PCCholeskySetReuseOrdering(), PCICholeskyDTSetReuseFill()
    415: @*/
    416: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetReuseFill(PC pc,PetscTruth flag)
    417: {
    418:   PetscErrorCode ierr,(*f)(PC,PetscTruth);

    422:   PetscObjectQueryFunction((PetscObject)pc,"PCCholeskySetReuseFill_C",(void (**)(void))&f);
    423:   if (f) {
    424:     (*f)(pc,flag);
    425:   }
    426:   return(0);
    427: }

    431: /*@
    432:    PCCholeskySetFill - Indicates the amount of fill you expect in the factored matrix,
    433:    fill = number nonzeros in factor/number nonzeros in original matrix.

    435:    Collective on PC
    436:
    437:    Input Parameters:
    438: +  pc - the preconditioner context
    439: -  fill - amount of expected fill

    441:    Options Database Key:
    442: .  -pc_cholesky_fill <fill> - Sets fill amount

    444:    Level: intermediate

    446:    Note:
    447:    For sparse matrix factorizations it is difficult to predict how much
    448:    fill to expect. By running with the option -log_info PETSc will print the
    449:    actual amount of fill used; allowing you to set the value accurately for
    450:    future runs. Default PETSc uses a value of 5.0

    452: .keywords: PC, set, factorization, direct, fill

    454: .seealso: PCILUSetFill()
    455: @*/
    456: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetFill(PC pc,PetscReal fill)
    457: {
    458:   PetscErrorCode ierr,(*f)(PC,PetscReal);

    462:   if (fill < 1.0) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Fill factor cannot be less then 1.0");
    463:   PetscObjectQueryFunction((PetscObject)pc,"PCCholeskySetFill_C",(void (**)(void))&f);
    464:   if (f) {
    465:     (*f)(pc,fill);
    466:   }
    467:   return(0);
    468: }

    472: /*@
    473:    PCCholeskySetUseInPlace - Tells the system to do an in-place factorization.
    474:    For dense matrices, this enables the solution of much larger problems.
    475:    For sparse matrices the factorization cannot be done truly in-place
    476:    so this does not save memory during the factorization, but after the matrix
    477:    is factored, the original unfactored matrix is freed, thus recovering that
    478:    space.

    480:    Collective on PC

    482:    Input Parameters:
    483: .  pc - the preconditioner context

    485:    Options Database Key:
    486: .  -pc_cholesky_in_place - Activates in-place factorization

    488:    Notes:
    489:    PCCholeskySetUseInplace() can only be used with the KSP method KSPPREONLY or when
    490:    a different matrix is provided for the multiply and the preconditioner in
    491:    a call to KSPSetOperators().
    492:    This is because the Krylov space methods require an application of the
    493:    matrix multiplication, which is not possible here because the matrix has
    494:    been factored in-place, replacing the original matrix.

    496:    Level: intermediate

    498: .keywords: PC, set, factorization, direct, inplace, in-place, Cholesky

    500: .seealso: PCICholeskySetUseInPlace()
    501: @*/
    502: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetUseInPlace(PC pc)
    503: {
    504:   PetscErrorCode ierr,(*f)(PC);

    508:   PetscObjectQueryFunction((PetscObject)pc,"PCCholeskySetUseInPlace_C",(void (**)(void))&f);
    509:   if (f) {
    510:     (*f)(pc);
    511:   }
    512:   return(0);
    513: }

    517: /*@
    518:     PCCholeskySetMatOrdering - Sets the ordering routine (to reduce fill) to
    519:     be used it the Cholesky factorization.

    521:     Collective on PC

    523:     Input Parameters:
    524: +   pc - the preconditioner context
    525: -   ordering - the matrix ordering name, for example, MATORDERING_ND or MATORDERING_RCM

    527:     Options Database Key:
    528: .   -pc_cholesky_mat_ordering_type <nd,rcm,...> - Sets ordering routine

    530:     Level: intermediate

    532: .seealso: PCICholeskySetMatOrdering()
    533: @*/
    534: PetscErrorCode PETSCKSP_DLLEXPORT PCCholeskySetMatOrdering(PC pc,MatOrderingType ordering)
    535: {
    536:   PetscErrorCode ierr,(*f)(PC,MatOrderingType);

    539:   PetscObjectQueryFunction((PetscObject)pc,"PCCholeskySetMatOrdering_C",(void (**)(void))&f);
    540:   if (f) {
    541:     (*f)(pc,ordering);
    542:   }
    543:   return(0);
    544: }

    546: /*MC
    547:    PCCholesky - Uses a direct solver, based on Cholesky factorization, as a preconditioner

    549:    Options Database Keys:
    550: +  -pc_cholesky_reuse_ordering - Activate PCLUSetReuseOrdering()
    551: .  -pc_cholesky_reuse_fill - Activates PCLUSetReuseFill()
    552: .  -pc_cholesky_fill <fill> - Sets fill amount
    553: .  -pc_cholesky_in_place - Activates in-place factorization
    554: .  -pc_cholesky_mat_ordering_type <nd,rcm,...> - Sets ordering routine
    555: .  -pc_factor_shift_nonzero <shift> - Sets shift amount or PETSC_DECIDE for the default
    556: -  -pc_factor_shift_positive_definite [PETSC_TRUE/PETSC_FALSE] - Activate/Deactivate PCFactorSetShiftPd(); the value
    557:    is optional with PETSC_TRUE being the default

    559:    Notes: Not all options work for all matrix formats

    561:    Level: beginner

    563:    Concepts: Cholesky factorization, direct solver

    565:    Notes: Usually this will compute an "exact" solution in one iteration and does
    566:           not need a Krylov method (i.e. you can use -ksp_type preonly, or
    567:           KSPSetType(ksp,KSPPREONLY) for the Krylov method

    569: .seealso:  PCCreate(), PCSetType(), PCType (for list of available types), PC,
    570:            PCILU, PCLU, PCICC, PCCholeskySetReuseOrdering(), PCCholeskySetReuseFill(), PCGetFactoredMatrix(),
    571:            PCCholeskySetFill(), PCFactorSetShiftNonzero(), PCFactorSetShiftPd(),
    572:            PCCholeskySetUseInPlace(), PCCholeskySetMatOrdering(),PCFactorSetShiftNonzero(),PCFactorSetShiftPd()

    574: M*/

    579: PetscErrorCode PETSCKSP_DLLEXPORT PCCreate_Cholesky(PC pc)
    580: {
    582:   PC_Cholesky    *dir;

    585:   PetscNew(PC_Cholesky,&dir);
    586:   PetscLogObjectMemory(pc,sizeof(PC_Cholesky));

    588:   dir->fact                   = 0;
    589:   dir->inplace                = PETSC_FALSE;
    590:   MatFactorInfoInitialize(&dir->info);
    591:   dir->info.fill              = 5.0;
    592:   dir->info.shiftnz           = 0.0;
    593:   dir->info.shiftpd           = PETSC_FALSE;
    594:   dir->info.shift_fraction    = 0.0;
    595:   dir->info.pivotinblocks     = 1.0;
    596:   dir->col                    = 0;
    597:   dir->row                    = 0;
    598:   PetscStrallocpy(MATORDERING_NATURAL,&dir->ordering);
    599:   dir->reusefill        = PETSC_FALSE;
    600:   dir->reuseordering    = PETSC_FALSE;
    601:   pc->data              = (void*)dir;

    603:   pc->ops->destroy           = PCDestroy_Cholesky;
    604:   pc->ops->apply             = PCApply_Cholesky;
    605:   pc->ops->applytranspose    = PCApplyTranspose_Cholesky;
    606:   pc->ops->setup             = PCSetUp_Cholesky;
    607:   pc->ops->setfromoptions    = PCSetFromOptions_Cholesky;
    608:   pc->ops->view              = PCView_Cholesky;
    609:   pc->ops->applyrichardson   = 0;
    610:   pc->ops->getfactoredmatrix = PCGetFactoredMatrix_Cholesky;

    612:   PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetZeroPivot_C","PCFactorSetZeroPivot_Cholesky",
    613:                     PCFactorSetZeroPivot_Cholesky);
    614:   PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetShiftNonzero_C","PCFactorSetShiftNonzero_Cholesky",
    615:                     PCFactorSetShiftNonzero_Cholesky);
    616:   PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetShiftPd_C","PCFactorSetShiftPd_Cholesky",
    617:                     PCFactorSetShiftPd_Cholesky);

    619:   PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCCholeskySetFill_C","PCCholeskySetFill_Cholesky",
    620:                     PCCholeskySetFill_Cholesky);
    621:   PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCCholeskySetUseInPlace_C","PCCholeskySetUseInPlace_Cholesky",
    622:                     PCCholeskySetUseInPlace_Cholesky);
    623:   PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCCholeskySetMatOrdering_C","PCCholeskySetMatOrdering_Cholesky",
    624:                     PCCholeskySetMatOrdering_Cholesky);
    625:   PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCCholeskySetReuseOrdering_C","PCCholeskySetReuseOrdering_Cholesky",
    626:                     PCCholeskySetReuseOrdering_Cholesky);
    627:   PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCCholeskySetReuseFill_C","PCCholeskySetReuseFill_Cholesky",
    628:                     PCCholeskySetReuseFill_Cholesky);
    629:   return(0);
    630: }