Actual source code: factor.c

      2: #include <../src/ksp/pc/impls/factor/factor.h>

      4: static PetscErrorCode PCFactorSetReuseOrdering_Factor(PC pc,PetscBool flag)
      5: {
      6:   PC_Factor *lu = (PC_Factor*)pc->data;

      9:   lu->reuseordering = flag;
     10:   return(0);
     11: }

     13: static PetscErrorCode PCFactorSetReuseFill_Factor(PC pc,PetscBool flag)
     14: {
     15:   PC_Factor *lu = (PC_Factor*)pc->data;

     18:   lu->reusefill = flag;
     19:   return(0);
     20: }

     22: static PetscErrorCode  PCFactorSetUseInPlace_Factor(PC pc,PetscBool flg)
     23: {
     24:   PC_Factor *dir = (PC_Factor*)pc->data;

     27:   dir->inplace = flg;
     28:   return(0);
     29: }

     31: static PetscErrorCode  PCFactorGetUseInPlace_Factor(PC pc,PetscBool *flg)
     32: {
     33:   PC_Factor *dir = (PC_Factor*)pc->data;

     36:   *flg = dir->inplace;
     37:   return(0);
     38: }

     40: /*@
     41:     PCFactorSetUpMatSolverType - Can be called after KSPSetOperators() or PCSetOperators(), causes MatGetFactor() to be called so then one may
     42:        set the options for that particular factorization object.

     44:   Input Parameter:
     45: .  pc  - the preconditioner context

     47:   Notes:
     48:     After you have called this function (which has to be after the KSPSetOperators() or PCSetOperators()) you can call PCFactorGetMatrix() and then set factor options on that matrix.

     50:   Level: intermediate

     52: .seealso: PCFactorSetMatSolverType(), PCFactorGetMatrix()
     53: @*/
     54: PetscErrorCode PCFactorSetUpMatSolverType(PC pc)
     55: {

     60:   PetscTryMethod(pc,"PCFactorSetUpMatSolverType_C",(PC),(pc));
     61:   return(0);
     62: }

     64: /*@
     65:    PCFactorSetZeroPivot - Sets the size at which smaller pivots are declared to be zero

     67:    Logically Collective on PC

     69:    Input Parameters:
     70: +  pc - the preconditioner context
     71: -  zero - all pivots smaller than this will be considered zero

     73:    Options Database Key:
     74: .  -pc_factor_zeropivot <zero> - Sets tolerance for what is considered a zero pivot

     76:    Level: intermediate

     78: .seealso: PCFactorSetShiftType(), PCFactorSetShiftAmount()
     79: @*/
     80: PetscErrorCode  PCFactorSetZeroPivot(PC pc,PetscReal zero)
     81: {

     87:   PetscTryMethod(pc,"PCFactorSetZeroPivot_C",(PC,PetscReal),(pc,zero));
     88:   return(0);
     89: }

     91: /*@
     92:    PCFactorSetShiftType - adds a particular type of quantity to the diagonal of the matrix during
     93:      numerical factorization, thus the matrix has nonzero pivots

     95:    Logically Collective on PC

     97:    Input Parameters:
     98: +  pc - the preconditioner context
     99: -  shifttype - type of shift; one of MAT_SHIFT_NONE, MAT_SHIFT_NONZERO,  MAT_SHIFT_POSITIVE_DEFINITE, MAT_SHIFT_INBLOCKS

    101:    Options Database Key:
    102: .  -pc_factor_shift_type <shifttype> - Sets shift type; use '-help' for a list of available types

    104:    Level: intermediate

    106: .seealso: PCFactorSetZeroPivot(), PCFactorSetShiftAmount()
    107: @*/
    108: PetscErrorCode  PCFactorSetShiftType(PC pc,MatFactorShiftType shifttype)
    109: {

    115:   PetscTryMethod(pc,"PCFactorSetShiftType_C",(PC,MatFactorShiftType),(pc,shifttype));
    116:   return(0);
    117: }

    119: /*@
    120:    PCFactorSetShiftAmount - adds a quantity to the diagonal of the matrix during
    121:      numerical factorization, thus the matrix has nonzero pivots

    123:    Logically Collective on PC

    125:    Input Parameters:
    126: +  pc - the preconditioner context
    127: -  shiftamount - amount of shift

    129:    Options Database Key:
    130: .  -pc_factor_shift_amount <shiftamount> - Sets shift amount or PETSC_DECIDE for the default

    132:    Level: intermediate

    134: .seealso: PCFactorSetZeroPivot(), PCFactorSetShiftType()
    135: @*/
    136: PetscErrorCode  PCFactorSetShiftAmount(PC pc,PetscReal shiftamount)
    137: {

    143:   PetscTryMethod(pc,"PCFactorSetShiftAmount_C",(PC,PetscReal),(pc,shiftamount));
    144:   return(0);
    145: }

    147: /*@
    148:    PCFactorSetDropTolerance - The preconditioner will use an ILU
    149:    based on a drop tolerance. (Under development)

    151:    Logically Collective on PC

    153:    Input Parameters:
    154: +  pc - the preconditioner context
    155: .  dt - the drop tolerance, try from 1.e-10 to .1
    156: .  dtcol - tolerance for column pivot, good values [0.1 to 0.01]
    157: -  maxrowcount - the max number of nonzeros allowed in a row, best value
    158:                  depends on the number of nonzeros in row of original matrix

    160:    Options Database Key:
    161: .  -pc_factor_drop_tolerance <dt,dtcol,maxrowcount> - Sets drop tolerance

    163:    Level: intermediate

    165:       There are NO default values for the 3 parameters, you must set them with reasonable values for your
    166:       matrix. We don't know how to compute reasonable values.

    168: @*/
    169: PetscErrorCode  PCFactorSetDropTolerance(PC pc,PetscReal dt,PetscReal dtcol,PetscInt maxrowcount)
    170: {

    177:   PetscTryMethod(pc,"PCFactorSetDropTolerance_C",(PC,PetscReal,PetscReal,PetscInt),(pc,dt,dtcol,maxrowcount));
    178:   return(0);
    179: }

    181: /*@
    182:    PCFactorGetZeroPivot - Gets the tolerance used to define a zero privot

    184:    Not Collective

    186:    Input Parameters:
    187: .  pc - the preconditioner context

    189:    Output Parameter:
    190: .  pivot - the tolerance

    192:    Level: intermediate

    194: .seealso: PCFactorSetZeroPivot()
    195: @*/
    196: PetscErrorCode  PCFactorGetZeroPivot(PC pc,PetscReal *pivot)
    197: {

    202:   PetscUseMethod(pc,"PCFactorGetZeroPivot_C",(PC,PetscReal*),(pc,pivot));
    203:   return(0);
    204: }

    206: /*@
    207:    PCFactorGetShiftAmount - Gets the tolerance used to define a zero privot

    209:    Not Collective

    211:    Input Parameters:
    212: .  pc - the preconditioner context

    214:    Output Parameter:
    215: .  shift - how much to shift the diagonal entry

    217:    Level: intermediate

    219: .seealso: PCFactorSetShiftAmount(), PCFactorSetShiftType(), PCFactorGetShiftType()
    220: @*/
    221: PetscErrorCode  PCFactorGetShiftAmount(PC pc,PetscReal *shift)
    222: {

    227:   PetscUseMethod(pc,"PCFactorGetShiftAmount_C",(PC,PetscReal*),(pc,shift));
    228:   return(0);
    229: }

    231: /*@
    232:    PCFactorGetShiftType - Gets the type of shift, if any, done when a zero pivot is detected

    234:    Not Collective

    236:    Input Parameters:
    237: .  pc - the preconditioner context

    239:    Output Parameter:
    240: .  type - one of MAT_SHIFT_NONE, MAT_SHIFT_NONZERO,  MAT_SHIFT_POSITIVE_DEFINITE, or MAT_SHIFT_INBLOCKS

    242:    Level: intermediate

    244: .seealso: PCFactorSetShiftType(), MatFactorShiftType, PCFactorSetShiftAmount(), PCFactorGetShiftAmount()
    245: @*/
    246: PetscErrorCode  PCFactorGetShiftType(PC pc,MatFactorShiftType *type)
    247: {

    252:   PetscUseMethod(pc,"PCFactorGetShiftType_C",(PC,MatFactorShiftType*),(pc,type));
    253:   return(0);
    254: }

    256: /*@
    257:    PCFactorGetLevels - Gets the number of levels of fill to use.

    259:    Logically Collective on PC

    261:    Input Parameters:
    262: .  pc - the preconditioner context

    264:    Output Parameter:
    265: .  levels - number of levels of fill

    267:    Level: intermediate

    269: @*/
    270: PetscErrorCode  PCFactorGetLevels(PC pc,PetscInt *levels)
    271: {

    276:   PetscUseMethod(pc,"PCFactorGetLevels_C",(PC,PetscInt*),(pc,levels));
    277:   return(0);
    278: }

    280: /*@
    281:    PCFactorSetLevels - Sets the number of levels of fill to use.

    283:    Logically Collective on PC

    285:    Input Parameters:
    286: +  pc - the preconditioner context
    287: -  levels - number of levels of fill

    289:    Options Database Key:
    290: .  -pc_factor_levels <levels> - Sets fill level

    292:    Level: intermediate

    294: @*/
    295: PetscErrorCode  PCFactorSetLevels(PC pc,PetscInt levels)
    296: {

    301:   if (levels < 0) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_OUTOFRANGE,"negative levels");
    303:   PetscTryMethod(pc,"PCFactorSetLevels_C",(PC,PetscInt),(pc,levels));
    304:   return(0);
    305: }

    307: /*@
    308:    PCFactorSetAllowDiagonalFill - Causes all diagonal matrix entries to be
    309:    treated as level 0 fill even if there is no non-zero location.

    311:    Logically Collective on PC

    313:    Input Parameters:
    314: +  pc - the preconditioner context
    315: -  flg - PETSC_TRUE to turn on, PETSC_FALSE to turn off

    317:    Options Database Key:
    318: .  -pc_factor_diagonal_fill

    320:    Notes:
    321:    Does not apply with 0 fill.

    323:    Level: intermediate

    325: .seealso: PCFactorGetAllowDiagonalFill()
    326: @*/
    327: PetscErrorCode  PCFactorSetAllowDiagonalFill(PC pc,PetscBool flg)
    328: {

    333:   PetscTryMethod(pc,"PCFactorSetAllowDiagonalFill_C",(PC,PetscBool),(pc,flg));
    334:   return(0);
    335: }

    337: /*@
    338:    PCFactorGetAllowDiagonalFill - Determines if all diagonal matrix entries are
    339:        treated as level 0 fill even if there is no non-zero location.

    341:    Logically Collective on PC

    343:    Input Parameter:
    344: .  pc - the preconditioner context

    346:    Output Parameter:
    347: .   flg - PETSC_TRUE to turn on, PETSC_FALSE to turn off

    349:    Options Database Key:
    350: .  -pc_factor_diagonal_fill

    352:    Notes:
    353:    Does not apply with 0 fill.

    355:    Level: intermediate

    357: .seealso: PCFactorSetAllowDiagonalFill()
    358: @*/
    359: PetscErrorCode  PCFactorGetAllowDiagonalFill(PC pc,PetscBool *flg)
    360: {

    365:   PetscUseMethod(pc,"PCFactorGetAllowDiagonalFill_C",(PC,PetscBool*),(pc,flg));
    366:   return(0);
    367: }

    369: /*@
    370:    PCFactorReorderForNonzeroDiagonal - reorders rows/columns of matrix to remove zeros from diagonal

    372:    Logically Collective on PC

    374:    Input Parameters:
    375: +  pc - the preconditioner context
    376: -  tol - diagonal entries smaller than this in absolute value are considered zero

    378:    Options Database Key:
    379: .  -pc_factor_nonzeros_along_diagonal <tol>

    381:    Level: intermediate

    383: .seealso: PCFactorSetFill(), PCFactorSetShiftNonzero(), PCFactorSetZeroPivot(), MatReorderForNonzeroDiagonal()
    384: @*/
    385: PetscErrorCode  PCFactorReorderForNonzeroDiagonal(PC pc,PetscReal rtol)
    386: {

    392:   PetscTryMethod(pc,"PCFactorReorderForNonzeroDiagonal_C",(PC,PetscReal),(pc,rtol));
    393:   return(0);
    394: }

    396: /*@C
    397:    PCFactorSetMatSolverType - sets the software that is used to perform the factorization

    399:    Logically Collective on PC

    401:    Input Parameters:
    402: +  pc - the preconditioner context
    403: -  stype - for example, superlu, superlu_dist

    405:    Options Database Key:
    406: .  -pc_factor_mat_solver_type <stype> - petsc, superlu, superlu_dist, mumps, cusparse

    408:    Level: intermediate

    410:    Note:
    411:      By default this will use the PETSc factorization if it exists

    413: .seealso: MatGetFactor(), MatSolverType, PCFactorGetMatSolverType()
    414: @*/
    415: PetscErrorCode  PCFactorSetMatSolverType(PC pc,MatSolverType stype)
    416: {

    421:   PetscTryMethod(pc,"PCFactorSetMatSolverType_C",(PC,MatSolverType),(pc,stype));
    422:   return(0);
    423: }

    425: /*@C
    426:    PCFactorGetMatSolverType - gets the software that is used to perform the factorization

    428:    Not Collective

    430:    Input Parameter:
    431: .  pc - the preconditioner context

    433:    Output Parameter:
    434: .   stype - for example, superlu, superlu_dist (NULL if the PC does not have a solver package)

    436:    Level: intermediate

    438: .seealso: MatGetFactor(), MatSolverType, PCFactorGetMatSolverType()
    439: @*/
    440: PetscErrorCode  PCFactorGetMatSolverType(PC pc,MatSolverType *stype)
    441: {
    442:   PetscErrorCode ierr,(*f)(PC,MatSolverType*);

    446:   PetscObjectQueryFunction((PetscObject)pc,"PCFactorGetMatSolverType_C",&f);
    447:   if (f) {
    448:     (*f)(pc,stype);
    449:   } else {
    450:     *stype = NULL;
    451:   }
    452:   return(0);
    453: }

    455: /*@
    456:    PCFactorSetFill - Indicate the amount of fill you expect in the factored matrix,
    457:    fill = number nonzeros in factor/number nonzeros in original matrix.

    459:    Not Collective, each process can expect a different amount of fill

    461:    Input Parameters:
    462: +  pc - the preconditioner context
    463: -  fill - amount of expected fill

    465:    Options Database Key:
    466: .  -pc_factor_fill <fill> - Sets fill amount

    468:    Level: intermediate

    470:    Note:
    471:    For sparse matrix factorizations it is difficult to predict how much
    472:    fill to expect. By running with the option -info PETSc will print the
    473:    actual amount of fill used; allowing you to set the value accurately for
    474:    future runs. Default PETSc uses a value of 5.0

    476:    This parameter has NOTHING to do with the levels-of-fill of ILU(). That is set with PCFactorSetLevels() or -pc_factor_levels.

    478: @*/
    479: PetscErrorCode  PCFactorSetFill(PC pc,PetscReal fill)
    480: {

    485:   if (fill < 1.0) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_OUTOFRANGE,"Fill factor cannot be less then 1.0");
    486:   PetscTryMethod(pc,"PCFactorSetFill_C",(PC,PetscReal),(pc,fill));
    487:   return(0);
    488: }

    490: /*@
    491:    PCFactorSetUseInPlace - Tells the system to do an in-place factorization.
    492:    For dense matrices, this enables the solution of much larger problems.
    493:    For sparse matrices the factorization cannot be done truly in-place
    494:    so this does not save memory during the factorization, but after the matrix
    495:    is factored, the original unfactored matrix is freed, thus recovering that
    496:    space. For ICC(0) and ILU(0) with the default natural ordering the factorization is done efficiently in-place.

    498:    Logically Collective on PC

    500:    Input Parameters:
    501: +  pc - the preconditioner context
    502: -  flg - PETSC_TRUE to enable, PETSC_FALSE to disable

    504:    Options Database Key:
    505: .  -pc_factor_in_place <true,false>- Activate/deactivate in-place factorization

    507:    Notes:
    508:    PCFactorSetUseInplace() can only be used with the KSP method KSPPREONLY or when
    509:    a different matrix is provided for the multiply and the preconditioner in
    510:    a call to KSPSetOperators().
    511:    This is because the Krylov space methods require an application of the
    512:    matrix multiplication, which is not possible here because the matrix has
    513:    been factored in-place, replacing the original matrix.

    515:    Level: intermediate

    517: .seealso: PCFactorGetUseInPlace()
    518: @*/
    519: PetscErrorCode  PCFactorSetUseInPlace(PC pc,PetscBool flg)
    520: {

    525:   PetscTryMethod(pc,"PCFactorSetUseInPlace_C",(PC,PetscBool),(pc,flg));
    526:   return(0);
    527: }

    529: /*@
    530:    PCFactorGetUseInPlace - Determines if an in-place factorization is being used.

    532:    Logically Collective on PC

    534:    Input Parameter:
    535: .  pc - the preconditioner context

    537:    Output Parameter:
    538: .  flg - PETSC_TRUE to enable, PETSC_FALSE to disable

    540:    Level: intermediate

    542: .seealso: PCFactorSetUseInPlace()
    543: @*/
    544: PetscErrorCode  PCFactorGetUseInPlace(PC pc,PetscBool *flg)
    545: {

    550:   PetscUseMethod(pc,"PCFactorGetUseInPlace_C",(PC,PetscBool*),(pc,flg));
    551:   return(0);
    552: }

    554: /*@C
    555:     PCFactorSetMatOrderingType - Sets the ordering routine (to reduce fill) to
    556:     be used in the LU, ILU, Cholesky, and ICC factorizations.

    558:     Logically Collective on PC

    560:     Input Parameters:
    561: +   pc - the preconditioner context
    562: -   ordering - the matrix ordering name, for example, MATORDERINGND or MATORDERINGRCM

    564:     Options Database Key:
    565: .   -pc_factor_mat_ordering_type <nd,rcm,...,external> - Sets ordering routine

    567:     Level: intermediate

    569:     Notes:
    570:     nested dissection is used by default

    572:     For Cholesky and ICC and the SBAIJ format the only reordering available is natural since only the upper half of the matrix is stored
    573:     and reordering this matrix is very expensive.

    575:     You can use SeqAIJ matrix with Cholesky and ICC and use any ordering

    577:     external means PETSc will not compute an ordering and the package will use its own ordering, for MATSOLVERCHOLMOD and MATSOLVERUMFPACK

    579: .seealso: MatOrderingType

    581: @*/
    582: PetscErrorCode  PCFactorSetMatOrderingType(PC pc,MatOrderingType ordering)
    583: {

    588:   PetscTryMethod(pc,"PCFactorSetMatOrderingType_C",(PC,MatOrderingType),(pc,ordering));
    589:   return(0);
    590: }

    592: /*@
    593:     PCFactorSetColumnPivot - Determines when column pivoting is done during matrix factorization.
    594:       For PETSc dense matrices column pivoting is always done, for PETSc sparse matrices
    595:       it is never done. For the MATLAB and SuperLU factorization this is used.

    597:     Logically Collective on PC

    599:     Input Parameters:
    600: +   pc - the preconditioner context
    601: -   dtcol - 0.0 implies no pivoting, 1.0 complete pivoting (slower, requires more memory but more stable)

    603:     Options Database Key:
    604: .   -pc_factor_pivoting <dtcol>

    606:     Level: intermediate

    608: .seealso: PCILUSetMatOrdering(), PCFactorSetPivotInBlocks()
    609: @*/
    610: PetscErrorCode  PCFactorSetColumnPivot(PC pc,PetscReal dtcol)
    611: {

    617:   PetscTryMethod(pc,"PCFactorSetColumnPivot_C",(PC,PetscReal),(pc,dtcol));
    618:   return(0);
    619: }

    621: /*@
    622:     PCFactorSetPivotInBlocks - Determines if pivoting is done while factoring each block
    623:       with BAIJ or SBAIJ matrices

    625:     Logically Collective on PC

    627:     Input Parameters:
    628: +   pc - the preconditioner context
    629: -   pivot - PETSC_TRUE or PETSC_FALSE

    631:     Options Database Key:
    632: .   -pc_factor_pivot_in_blocks <true,false>

    634:     Level: intermediate

    636: .seealso: PCILUSetMatOrdering(), PCFactorSetColumnPivot()
    637: @*/
    638: PetscErrorCode  PCFactorSetPivotInBlocks(PC pc,PetscBool pivot)
    639: {

    645:   PetscTryMethod(pc,"PCFactorSetPivotInBlocks_C",(PC,PetscBool),(pc,pivot));
    646:   return(0);
    647: }

    649: /*@
    650:    PCFactorSetReuseFill - When matrices with different nonzero structure are factored,
    651:    this causes later ones to use the fill ratio computed in the initial factorization.

    653:    Logically Collective on PC

    655:    Input Parameters:
    656: +  pc - the preconditioner context
    657: -  flag - PETSC_TRUE to reuse else PETSC_FALSE

    659:    Options Database Key:
    660: .  -pc_factor_reuse_fill - Activates PCFactorSetReuseFill()

    662:    Level: intermediate

    664: .seealso: PCFactorSetReuseOrdering()
    665: @*/
    666: PetscErrorCode  PCFactorSetReuseFill(PC pc,PetscBool flag)
    667: {

    673:   PetscTryMethod(pc,"PCFactorSetReuseFill_C",(PC,PetscBool),(pc,flag));
    674:   return(0);
    675: }

    677: PetscErrorCode PCFactorInitialize(PC pc)
    678: {
    680:   PC_Factor       *fact = (PC_Factor*)pc->data;

    683:   MatFactorInfoInitialize(&fact->info);
    684:   fact->info.shifttype       = (PetscReal)MAT_SHIFT_NONE;
    685:   fact->info.shiftamount     = 100.0*PETSC_MACHINE_EPSILON;
    686:   fact->info.zeropivot       = 100.0*PETSC_MACHINE_EPSILON;
    687:   fact->info.pivotinblocks   = 1.0;
    688:   pc->ops->getfactoredmatrix = PCFactorGetMatrix_Factor;

    690:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetZeroPivot_C",PCFactorSetZeroPivot_Factor);
    691:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorGetZeroPivot_C",PCFactorGetZeroPivot_Factor);
    692:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetShiftType_C",PCFactorSetShiftType_Factor);
    693:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorGetShiftType_C",PCFactorGetShiftType_Factor);
    694:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetShiftAmount_C",PCFactorSetShiftAmount_Factor);
    695:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorGetShiftAmount_C",PCFactorGetShiftAmount_Factor);
    696:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorGetMatSolverType_C",PCFactorGetMatSolverType_Factor);
    697:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetMatSolverType_C",PCFactorSetMatSolverType_Factor);
    698:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetUpMatSolverType_C",PCFactorSetUpMatSolverType_Factor);
    699:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetFill_C",PCFactorSetFill_Factor);
    700:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetMatOrderingType_C",PCFactorSetMatOrderingType_Factor);
    701:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetLevels_C",PCFactorSetLevels_Factor);
    702:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorGetLevels_C",PCFactorGetLevels_Factor);
    703:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetAllowDiagonalFill_C",PCFactorSetAllowDiagonalFill_Factor);
    704:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorGetAllowDiagonalFill_C",PCFactorGetAllowDiagonalFill_Factor);
    705:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetPivotInBlocks_C",PCFactorSetPivotInBlocks_Factor);
    706:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetUseInPlace_C",PCFactorSetUseInPlace_Factor);
    707:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorGetUseInPlace_C",PCFactorGetUseInPlace_Factor);
    708:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetReuseOrdering_C",PCFactorSetReuseOrdering_Factor);
    709:   PetscObjectComposeFunction((PetscObject)pc,"PCFactorSetReuseFill_C",PCFactorSetReuseFill_Factor);
    710:   return(0);
    711: }