Actual source code: ilu.c
1: #define PETSCKSP_DLL
3: /*
4: Defines a ILU factorization preconditioner for any Mat implementation
5: */
6: #include private/pcimpl.h
7: #include src/ksp/pc/impls/factor/ilu/ilu.h
8: #include src/mat/matimpl.h
10: /* ------------------------------------------------------------------------------------------*/
14: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetReuseFill_ILU(PC pc,PetscTruth flag)
15: {
16: PC_ILU *lu;
17:
19: lu = (PC_ILU*)pc->data;
20: lu->reusefill = flag;
21: return(0);
22: }
28: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetZeroPivot_ILU(PC pc,PetscReal z)
29: {
30: PC_ILU *ilu;
33: ilu = (PC_ILU*)pc->data;
34: ilu->info.zeropivot = z;
35: return(0);
36: }
42: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetShiftNonzero_ILU(PC pc,PetscReal shift)
43: {
44: PC_ILU *dir;
47: dir = (PC_ILU*)pc->data;
48: if (shift == (PetscReal) PETSC_DECIDE) {
49: dir->info.shiftnz = 1.e-12;
50: } else {
51: dir->info.shiftnz = shift;
52: }
53: return(0);
54: }
60: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetShiftPd_ILU(PC pc,PetscTruth shift)
61: {
62: PC_ILU *dir;
63:
65: dir = (PC_ILU*)pc->data;
66: if (shift) {
67: dir->info.shift_fraction = 0.0;
68: dir->info.shiftpd = 1.0;
69: } else {
70: dir->info.shiftpd = 0.0;
71: }
72: return(0);
73: }
79: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorReorderForNonzeroDiagonal_ILU(PC pc,PetscReal z)
80: {
81: PC_ILU *ilu = (PC_ILU*)pc->data;
84: ilu->nonzerosalongdiagonal = PETSC_TRUE;
85: if (z == PETSC_DECIDE) {
86: ilu->nonzerosalongdiagonaltol = 1.e-10;
87: } else {
88: ilu->nonzerosalongdiagonaltol = z;
89: }
90: return(0);
91: }
96: PetscErrorCode PCDestroy_ILU_Internal(PC pc)
97: {
98: PC_ILU *ilu = (PC_ILU*)pc->data;
102: if (!ilu->inplace && ilu->fact) {MatDestroy(ilu->fact);}
103: if (ilu->row && ilu->col && ilu->row != ilu->col) {ISDestroy(ilu->row);}
104: if (ilu->col) {ISDestroy(ilu->col);}
105: return(0);
106: }
111: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetUseDropTolerance_ILU(PC pc,PetscReal dt,PetscReal dtcol,PetscInt dtcount)
112: {
113: PC_ILU *ilu;
117: ilu = (PC_ILU*)pc->data;
118: if (pc->setupcalled && (!ilu->usedt || ilu->info.dt != dt || ilu->info.dtcol != dtcol || ilu->info.dtcount != dtcount)) {
119: pc->setupcalled = 0;
120: PCDestroy_ILU_Internal(pc);
121: }
122: ilu->usedt = PETSC_TRUE;
123: ilu->info.dt = dt;
124: ilu->info.dtcol = dtcol;
125: ilu->info.dtcount = dtcount;
126: ilu->info.fill = PETSC_DEFAULT;
127: return(0);
128: }
134: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetFill_ILU(PC pc,PetscReal fill)
135: {
136: PC_ILU *dir;
139: dir = (PC_ILU*)pc->data;
140: dir->info.fill = fill;
141: return(0);
142: }
148: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetMatOrdering_ILU(PC pc,MatOrderingType ordering)
149: {
150: PC_ILU *dir = (PC_ILU*)pc->data;
152: PetscTruth flg;
153:
155: if (!pc->setupcalled) {
156: PetscStrfree(dir->ordering);
157: PetscStrallocpy(ordering,&dir->ordering);
158: } else {
159: PetscStrcmp(dir->ordering,ordering,&flg);
160: if (!flg) {
161: pc->setupcalled = 0;
162: PetscStrfree(dir->ordering);
163: PetscStrallocpy(ordering,&dir->ordering);
164: /* free the data structures, then create them again */
165: PCDestroy_ILU_Internal(pc);
166: }
167: }
168: return(0);
169: }
175: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetReuseOrdering_ILU(PC pc,PetscTruth flag)
176: {
177: PC_ILU *ilu;
180: ilu = (PC_ILU*)pc->data;
181: ilu->reuseordering = flag;
182: return(0);
183: }
189: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetLevels_ILU(PC pc,PetscInt levels)
190: {
191: PC_ILU *ilu;
195: ilu = (PC_ILU*)pc->data;
197: if (!pc->setupcalled) {
198: ilu->info.levels = levels;
199: } else if (ilu->usedt || ilu->info.levels != levels) {
200: ilu->info.levels = levels;
201: pc->setupcalled = 0;
202: ilu->usedt = PETSC_FALSE;
203: PCDestroy_ILU_Internal(pc);
204: }
205: return(0);
206: }
212: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetUseInPlace_ILU(PC pc)
213: {
214: PC_ILU *dir;
217: dir = (PC_ILU*)pc->data;
218: dir->inplace = PETSC_TRUE;
219: return(0);
220: }
226: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetAllowDiagonalFill_ILU(PC pc)
227: {
228: PC_ILU *dir;
231: dir = (PC_ILU*)pc->data;
232: dir->info.diagonal_fill = 1;
233: return(0);
234: }
239: /*@
240: PCFactorSetUseDropTolerance - The preconditioner will use an ILU
241: based on a drop tolerance.
243: Collective on PC
245: Input Parameters:
246: + pc - the preconditioner context
247: . dt - the drop tolerance, try from 1.e-10 to .1
248: . dtcol - tolerance for column pivot, good values [0.1 to 0.01]
249: - maxrowcount - the max number of nonzeros allowed in a row, best value
250: depends on the number of nonzeros in row of original matrix
252: Options Database Key:
253: . -pc_factor_use_drop_tolerance <dt,dtcol,maxrowcount> - Sets drop tolerance
255: Level: intermediate
257: Notes:
258: This uses the iludt() code of Saad's SPARSKIT package
260: .keywords: PC, levels, reordering, factorization, incomplete, ILU
261: @*/
262: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetUseDropTolerance(PC pc,PetscReal dt,PetscReal dtcol,PetscInt maxrowcount)
263: {
264: PetscErrorCode ierr,(*f)(PC,PetscReal,PetscReal,PetscInt);
268: PetscObjectQueryFunction((PetscObject)pc,"PCFactorSetUseDropTolerance_C",(void (**)(void))&f);
269: if (f) {
270: (*f)(pc,dt,dtcol,maxrowcount);
271: }
272: return(0);
273: }
277: /*@
278: PCFactorSetLevels - Sets the number of levels of fill to use.
280: Collective on PC
282: Input Parameters:
283: + pc - the preconditioner context
284: - levels - number of levels of fill
286: Options Database Key:
287: . -pc_factor_levels <levels> - Sets fill level
289: Level: intermediate
291: .keywords: PC, levels, fill, factorization, incomplete, ILU
292: @*/
293: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetLevels(PC pc,PetscInt levels)
294: {
295: PetscErrorCode ierr,(*f)(PC,PetscInt);
299: if (levels < 0) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"negative levels");
300: PetscObjectQueryFunction((PetscObject)pc,"PCFactorSetLevels_C",(void (**)(void))&f);
301: if (f) {
302: (*f)(pc,levels);
303: }
304: return(0);
305: }
309: /*@
310: PCFactorSetAllowDiagonalFill - Causes all diagonal matrix entries to be
311: treated as level 0 fill even if there is no non-zero location.
313: Collective on PC
315: Input Parameters:
316: + pc - the preconditioner context
318: Options Database Key:
319: . -pc_factor_diagonal_fill
321: Notes:
322: Does not apply with 0 fill.
324: Level: intermediate
326: .keywords: PC, levels, fill, factorization, incomplete, ILU
327: @*/
328: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetAllowDiagonalFill(PC pc)
329: {
330: PetscErrorCode ierr,(*f)(PC);
334: PetscObjectQueryFunction((PetscObject)pc,"PCFactorSetAllowDiagonalFill_C",(void (**)(void))&f);
335: if (f) {
336: (*f)(pc);
337: }
338: return(0);
339: }
341: /* ------------------------------------------------------------------------------------------*/
346: PetscErrorCode PETSCKSP_DLLEXPORT PCFactorSetPivotInBlocks_ILU(PC pc,PetscTruth pivot)
347: {
348: PC_ILU *dir = (PC_ILU*)pc->data;
351: dir->info.pivotinblocks = pivot ? 1.0 : 0.0;
352: return(0);
353: }
358: static PetscErrorCode PCSetFromOptions_ILU(PC pc)
359: {
361: PetscInt dtmax = 3,itmp;
362: PetscTruth flg,set;
363: PetscReal dt[3];
364: char tname[256];
365: PC_ILU *ilu = (PC_ILU*)pc->data;
366: PetscFList ordlist;
367: PetscReal tol;
370: MatOrderingRegisterAll(PETSC_NULL);
371: PetscOptionsHead("ILU Options");
372: PetscOptionsInt("-pc_factor_levels","levels of fill","PCFactorSetLevels",(PetscInt)ilu->info.levels,&itmp,&flg);
373: if (flg) ilu->info.levels = itmp;
374: PetscOptionsName("-pc_factor_in_place","do factorization in place","PCFactorSetUseInPlace",&ilu->inplace);
375: PetscOptionsName("-pc_factor_diagonal_fill","Allow fill into empty diagonal entry","PCFactorSetAllowDiagonalFill",&flg);
376: ilu->info.diagonal_fill = (double) flg;
377: PetscOptionsName("-pc_factor_reuse_fill","Reuse fill ratio from previous factorization","PCFactorSetReuseFill",&ilu->reusefill);
378: PetscOptionsName("-pc_factor_reuse_ordering","Reuse previous reordering","PCFactorSetReuseOrdering",&ilu->reuseordering);
380: PetscOptionsName("-pc_factor_shift_nonzero","Shift added to diagonal","PCFactorSetShiftNonzero",&flg);
381: if (flg) {
382: PCFactorSetShiftNonzero(pc,(PetscReal)PETSC_DECIDE);
383: }
384: PetscOptionsReal("-pc_factor_shift_nonzero","Shift added to diagonal","PCFactorSetShiftNonzero",ilu->info.shiftnz,&ilu->info.shiftnz,0);
385:
386: PetscOptionsName("-pc_factor_shift_positive_definite","Manteuffel shift applied to diagonal","PCFactorSetShiftPd",&flg);
387: if (flg) {
388: PetscOptionsInt("-pc_factor_shift_positive_definite","Manteuffel shift applied to diagonal","PCFactorSetShiftPd",(PetscInt)ilu->info.shiftpd,&itmp,&flg);
389: if (flg && !itmp) {
390: PCFactorSetShiftPd(pc,PETSC_FALSE);
391: } else {
392: PCFactorSetShiftPd(pc,PETSC_TRUE);
393: }
394: }
395: PetscOptionsReal("-pc_factor_zeropivot","Pivot is considered zero if less than","PCFactorSetZeroPivot",ilu->info.zeropivot,&ilu->info.zeropivot,0);
397: dt[0] = ilu->info.dt;
398: dt[1] = ilu->info.dtcol;
399: dt[2] = ilu->info.dtcount;
400: PetscOptionsRealArray("-pc_factor_use_drop_tolerance","<dt,dtcol,maxrowcount>","PCFactorSetUseDropTolerance",dt,&dtmax,&flg);
401: if (flg) {
402: PCFactorSetUseDropTolerance(pc,dt[0],dt[1],(PetscInt)dt[2]);
403: }
404: PetscOptionsReal("-pc_factor_fill","Expected fill in factorization","PCFactorSetFill",ilu->info.fill,&ilu->info.fill,&flg);
405: PetscOptionsName("-pc_factor_nonzeros_along_diagonal","Reorder to remove zeros from diagonal","PCFactorReorderForNonzeroDiagonal",&flg);
406: if (flg) {
407: tol = PETSC_DECIDE;
408: PetscOptionsReal("-pc_factor_nonzeros_along_diagonal","Reorder to remove zeros from diagonal","PCFactorReorderForNonzeroDiagonal",ilu->nonzerosalongdiagonaltol,&tol,0);
409: PCFactorReorderForNonzeroDiagonal(pc,tol);
410: }
412: MatGetOrderingList(&ordlist);
413: PetscOptionsList("-pc_factor_mat_ordering_type","Reorder to reduce nonzeros in ILU","PCFactorSetMatOrdering",ordlist,ilu->ordering,tname,256,&flg);
414: if (flg) {
415: PCFactorSetMatOrdering(pc,tname);
416: }
417: flg = ilu->info.pivotinblocks ? PETSC_TRUE : PETSC_FALSE;
418: PetscOptionsTruth("-pc_factor_pivot_in_blocks","Pivot inside matrix blocks for BAIJ and SBAIJ","PCFactorSetPivotInBlocks",flg,&flg,&set);
419: if (set) {
420: PCFactorSetPivotInBlocks(pc,flg);
421: }
422: PetscOptionsTail();
423: return(0);
424: }
428: static PetscErrorCode PCView_ILU(PC pc,PetscViewer viewer)
429: {
430: PC_ILU *ilu = (PC_ILU*)pc->data;
432: PetscTruth isstring,iascii;
435: PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_STRING,&isstring);
436: PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&iascii);
437: if (iascii) {
438: if (ilu->usedt) {
439: PetscViewerASCIIPrintf(viewer," ILU: drop tolerance %G\n",ilu->info.dt);
440: PetscViewerASCIIPrintf(viewer," ILU: max nonzeros per row %D\n",(PetscInt)ilu->info.dtcount);
441: PetscViewerASCIIPrintf(viewer," ILU: column permutation tolerance %G\n",ilu->info.dtcol);
442: } else if (ilu->info.levels == 1) {
443: PetscViewerASCIIPrintf(viewer," ILU: %D level of fill\n",(PetscInt)ilu->info.levels);
444: } else {
445: PetscViewerASCIIPrintf(viewer," ILU: %D levels of fill\n",(PetscInt)ilu->info.levels);
446: }
447: PetscViewerASCIIPrintf(viewer," ILU: max fill ratio allocated %G\n",ilu->info.fill);
448: PetscViewerASCIIPrintf(viewer," ILU: tolerance for zero pivot %G\n",ilu->info.zeropivot);
449: if (ilu->info.shiftpd) {PetscViewerASCIIPrintf(viewer," ILU: using Manteuffel shift\n");}
450: if (ilu->inplace) {PetscViewerASCIIPrintf(viewer," in-place factorization\n");}
451: else {PetscViewerASCIIPrintf(viewer," out-of-place factorization\n");}
452: PetscViewerASCIIPrintf(viewer," matrix ordering: %s\n",ilu->ordering);
453: if (ilu->reusefill) {PetscViewerASCIIPrintf(viewer," Reusing fill from past factorization\n");}
454: if (ilu->reuseordering) {PetscViewerASCIIPrintf(viewer," Reusing reordering from past factorization\n");}
455: if (ilu->fact) {
456: PetscViewerASCIIPrintf(viewer," Factored matrix follows\n");
457: PetscViewerASCIIPushTab(viewer);
458: PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO);
459: MatView(ilu->fact,viewer);
460: PetscViewerPopFormat(viewer);
461: PetscViewerASCIIPopTab(viewer);
462: }
463: } else if (isstring) {
464: PetscViewerStringSPrintf(viewer," lvls=%D,order=%s",(PetscInt)ilu->info.levels,ilu->ordering);
465: } else {
466: SETERRQ1(PETSC_ERR_SUP,"Viewer type %s not supported for PCILU",((PetscObject)viewer)->type_name);
467: }
468: return(0);
469: }
473: static PetscErrorCode PCSetUp_ILU(PC pc)
474: {
476: PC_ILU *ilu = (PC_ILU*)pc->data;
479: if (ilu->inplace) {
480: if (!pc->setupcalled) {
482: /* In-place factorization only makes sense with the natural ordering,
483: so we only need to get the ordering once, even if nonzero structure changes */
484: MatGetOrdering(pc->pmat,ilu->ordering,&ilu->row,&ilu->col);
485: if (ilu->row) {PetscLogObjectParent(pc,ilu->row);}
486: if (ilu->col) {PetscLogObjectParent(pc,ilu->col);}
487: }
489: /* In place ILU only makes sense with fill factor of 1.0 because
490: cannot have levels of fill */
491: ilu->info.fill = 1.0;
492: ilu->info.diagonal_fill = 0;
493: MatILUFactor(pc->pmat,ilu->row,ilu->col,&ilu->info);
494: ilu->fact = pc->pmat;
495: } else if (ilu->usedt) {
496: if (!pc->setupcalled) {
497: MatGetOrdering(pc->pmat,ilu->ordering,&ilu->row,&ilu->col);
498: if (ilu->row) {PetscLogObjectParent(pc,ilu->row);}
499: if (ilu->col) {PetscLogObjectParent(pc,ilu->col);}
500: MatILUDTFactor(pc->pmat,ilu->row,ilu->col,&ilu->info,&ilu->fact);
501: PetscLogObjectParent(pc,ilu->fact);
502: } else if (pc->flag != SAME_NONZERO_PATTERN) {
503: MatDestroy(ilu->fact);
504: if (!ilu->reuseordering) {
505: if (ilu->row) {ISDestroy(ilu->row);}
506: if (ilu->col) {ISDestroy(ilu->col);}
507: MatGetOrdering(pc->pmat,ilu->ordering,&ilu->row,&ilu->col);
508: if (ilu->row) {PetscLogObjectParent(pc,ilu->row);}
509: if (ilu->col) {PetscLogObjectParent(pc,ilu->col);}
510: }
511: MatILUDTFactor(pc->pmat,ilu->row,ilu->col,&ilu->info,&ilu->fact);
512: PetscLogObjectParent(pc,ilu->fact);
513: } else if (!ilu->reusefill) {
514: MatDestroy(ilu->fact);
515: MatILUDTFactor(pc->pmat,ilu->row,ilu->col,&ilu->info,&ilu->fact);
516: PetscLogObjectParent(pc,ilu->fact);
517: } else {
518: MatLUFactorNumeric(pc->pmat,&ilu->info,&ilu->fact);
519: }
520: } else {
521: if (!pc->setupcalled) {
522: /* first time in so compute reordering and symbolic factorization */
523: MatGetOrdering(pc->pmat,ilu->ordering,&ilu->row,&ilu->col);
524: if (ilu->row) {PetscLogObjectParent(pc,ilu->row);}
525: if (ilu->col) {PetscLogObjectParent(pc,ilu->col);}
526: /* Remove zeros along diagonal? */
527: if (ilu->nonzerosalongdiagonal) {
528: MatReorderForNonzeroDiagonal(pc->pmat,ilu->nonzerosalongdiagonaltol,ilu->row,ilu->col);
529: }
530: MatILUFactorSymbolic(pc->pmat,ilu->row,ilu->col,&ilu->info,&ilu->fact);
531: PetscLogObjectParent(pc,ilu->fact);
532: } else if (pc->flag != SAME_NONZERO_PATTERN) {
533: if (!ilu->reuseordering) {
534: /* compute a new ordering for the ILU */
535: ISDestroy(ilu->row);
536: ISDestroy(ilu->col);
537: MatGetOrdering(pc->pmat,ilu->ordering,&ilu->row,&ilu->col);
538: if (ilu->row) {PetscLogObjectParent(pc,ilu->row);}
539: if (ilu->col) {PetscLogObjectParent(pc,ilu->col);}
540: /* Remove zeros along diagonal? */
541: if (ilu->nonzerosalongdiagonal) {
542: MatReorderForNonzeroDiagonal(pc->pmat,ilu->nonzerosalongdiagonaltol,ilu->row,ilu->col);
543: }
544: }
545: MatDestroy(ilu->fact);
546: MatILUFactorSymbolic(pc->pmat,ilu->row,ilu->col,&ilu->info,&ilu->fact);
547: PetscLogObjectParent(pc,ilu->fact);
548: }
549: MatLUFactorNumeric(pc->pmat,&ilu->info,&ilu->fact);
550: }
551: return(0);
552: }
556: static PetscErrorCode PCDestroy_ILU(PC pc)
557: {
558: PC_ILU *ilu = (PC_ILU*)pc->data;
562: PCDestroy_ILU_Internal(pc);
563: PetscStrfree(ilu->ordering);
564: PetscFree(ilu);
565: return(0);
566: }
570: static PetscErrorCode PCApply_ILU(PC pc,Vec x,Vec y)
571: {
572: PC_ILU *ilu = (PC_ILU*)pc->data;
576: MatSolve(ilu->fact,x,y);
577: return(0);
578: }
582: static PetscErrorCode PCApplyTranspose_ILU(PC pc,Vec x,Vec y)
583: {
584: PC_ILU *ilu = (PC_ILU*)pc->data;
588: MatSolveTranspose(ilu->fact,x,y);
589: return(0);
590: }
594: static PetscErrorCode PCGetFactoredMatrix_ILU(PC pc,Mat *mat)
595: {
596: PC_ILU *ilu = (PC_ILU*)pc->data;
599: if (!ilu->fact) SETERRQ(PETSC_ERR_ORDER,"Matrix not yet factored; call after KSPSetUp() or PCSetUp()");
600: *mat = ilu->fact;
601: return(0);
602: }
604: /*MC
605: PCILU - Incomplete factorization preconditioners.
607: Options Database Keys:
608: + -pc_factor_levels <k> - number of levels of fill for ILU(k)
609: . -pc_factor_in_place - only for ILU(0) with natural ordering, reuses the space of the matrix for
610: its factorization (overwrites original matrix)
611: . -pc_factor_diagonal_fill - fill in a zero diagonal even if levels of fill indicate it wouldn't be fill
612: . -pc_factor_reuse_ordering - reuse ordering of factorized matrix from previous factorization
613: . -pc_factor_use_drop_tolerance <dt,dtcol,maxrowcount> - use Saad's drop tolerance ILUdt
614: . -pc_factor_fill <nfill> - expected amount of fill in factored matrix compared to original matrix, nfill > 1
615: . -pc_factor_nonzeros_along_diagonal - reorder the matrix before factorization to remove zeros from the diagonal,
616: this decreases the chance of getting a zero pivot
617: . -pc_factor_mat_ordering_type <natural,nd,1wd,rcm,qmd> - set the row/column ordering of the factored matrix
618: . -pc_factor_pivot_in_blocks - for block ILU(k) factorization, i.e. with BAIJ matrices with block size larger
619: than 1 the diagonal blocks are factored with partial pivoting (this increases the
620: stability of the ILU factorization
621: . -pc_factor_shift_nonzero <shift> - Sets shift amount or PETSC_DECIDE for the default
622: - -pc_factor_shift_positive_definite [PETSC_TRUE/PETSC_FALSE] - Activate/Deactivate PCFactorSetShiftPd(); the value
623: is optional with PETSC_TRUE being the default
625: Level: beginner
627: Concepts: incomplete factorization
629: Notes: Only implemented for some matrix formats. Not implemented in parallel
631: For BAIJ matrices this implements a point block ILU
633: .seealso: PCCreate(), PCSetType(), PCType (for list of available types), PC, PCSOR, MatOrderingType,
634: PCFactorSetZeroPivot(), PCFactorSetShiftNonzero(), PCFactorSetShiftPd(), PCFactorSetUseDropTolerance(),
635: PCFactorSetFill(), PCFactorSetMatOrdering(), PCFactorSetReuseOrdering(),
636: PCFactorSetLevels(), PCFactorSetUseInPlace(), PCFactorSetAllowDiagonalFill(), PCFactorSetPivotInBlocks(),
637: PCFactorSetShiftNonzero(),PCFactorSetShiftPd()
639: M*/
644: PetscErrorCode PETSCKSP_DLLEXPORT PCCreate_ILU(PC pc)
645: {
647: PC_ILU *ilu;
650: PetscNew(PC_ILU,&ilu);
651: PetscLogObjectMemory(pc,sizeof(PC_ILU));
653: ilu->fact = 0;
654: MatFactorInfoInitialize(&ilu->info);
655: ilu->info.levels = 0;
656: ilu->info.fill = 1.0;
657: ilu->col = 0;
658: ilu->row = 0;
659: ilu->inplace = PETSC_FALSE;
660: PetscStrallocpy(MATORDERING_NATURAL,&ilu->ordering);
661: ilu->reuseordering = PETSC_FALSE;
662: ilu->usedt = PETSC_FALSE;
663: ilu->info.dt = PETSC_DEFAULT;
664: ilu->info.dtcount = PETSC_DEFAULT;
665: ilu->info.dtcol = PETSC_DEFAULT;
666: ilu->info.shiftnz = 0.0;
667: ilu->info.shiftpd = 0.0; /* false */
668: ilu->info.shift_fraction = 0.0;
669: ilu->info.zeropivot = 1.e-12;
670: ilu->info.pivotinblocks = 1.0;
671: ilu->reusefill = PETSC_FALSE;
672: ilu->info.diagonal_fill = 0;
673: pc->data = (void*)ilu;
675: pc->ops->destroy = PCDestroy_ILU;
676: pc->ops->apply = PCApply_ILU;
677: pc->ops->applytranspose = PCApplyTranspose_ILU;
678: pc->ops->setup = PCSetUp_ILU;
679: pc->ops->setfromoptions = PCSetFromOptions_ILU;
680: pc->ops->getfactoredmatrix = PCGetFactoredMatrix_ILU;
681: pc->ops->view = PCView_ILU;
682: pc->ops->applyrichardson = 0;
684: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetZeroPivot_C","PCFactorSetZeroPivot_ILU",
685: PCFactorSetZeroPivot_ILU);
686: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetShiftNonzero_C","PCFactorSetShiftNonzero_ILU",
687: PCFactorSetShiftNonzero_ILU);
688: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetShiftPd_C","PCFactorSetShiftPd_ILU",
689: PCFactorSetShiftPd_ILU);
691: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetUseDropTolerance_C","PCFactorSetUseDropTolerance_ILU",
692: PCFactorSetUseDropTolerance_ILU);
693: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetFill_C","PCFactorSetFill_ILU",
694: PCFactorSetFill_ILU);
695: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetMatOrdering_C","PCFactorSetMatOrdering_ILU",
696: PCFactorSetMatOrdering_ILU);
697: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetReuseOrdering_C","PCFactorSetReuseOrdering_ILU",
698: PCFactorSetReuseOrdering_ILU);
699: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetReuseFill_C","PCFactorSetReuseFill_ILU",
700: PCFactorSetReuseFill_ILU);
701: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetLevels_C","PCFactorSetLevels_ILU",
702: PCFactorSetLevels_ILU);
703: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetUseInPlace_C","PCFactorSetUseInPlace_ILU",
704: PCFactorSetUseInPlace_ILU);
705: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetAllowDiagonalFill_C","PCFactorSetAllowDiagonalFill_ILU",
706: PCFactorSetAllowDiagonalFill_ILU);
707: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorSetPivotInBlocks_C","PCFactorSetPivotInBlocks_ILU",
708: PCFactorSetPivotInBlocks_ILU);
709: PetscObjectComposeFunctionDynamic((PetscObject)pc,"PCFactorReorderForNonzeroDiagonal_C","PCFactorReorderForNonzeroDiagonal_ILU",
710: PCFactorReorderForNonzeroDiagonal_ILU);
711: return(0);
712: }