Actual source code: factimpl.c
petsc-3.10.5 2019-03-28
Report Typos and Errors

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

      4: /* ------------------------------------------------------------------------------------------*/

      7: PetscErrorCode PCFactorSetUpMatSolverType_Factor(PC pc)
      8: {
      9:   PC_Factor      *icc = (PC_Factor*)pc->data;

     13:   if (!pc->pmat) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"You can only call this routine after the matrix object has been provided to the solver, for example with KSPSetOperators() or SNESSetJacobian()");
     14:   if (!pc->setupcalled && !((PC_Factor*)icc)->fact) {
     15:     MatGetFactor(pc->pmat,((PC_Factor*)icc)->solvertype,((PC_Factor*)icc)->factortype,&((PC_Factor*)icc)->fact);
     16:   }
     17:   return(0);
     18: }

     20: PetscErrorCode  PCFactorSetZeroPivot_Factor(PC pc,PetscReal z)
     21: {
     22:   PC_Factor *ilu = (PC_Factor*)pc->data;

     25:   ilu->info.zeropivot = z;
     26:   return(0);
     27: }

     29: PetscErrorCode  PCFactorSetShiftType_Factor(PC pc,MatFactorShiftType shifttype)
     30: {
     31:   PC_Factor *dir = (PC_Factor*)pc->data;

     34:   if (shifttype == (MatFactorShiftType)PETSC_DECIDE) dir->info.shifttype = (PetscReal) MAT_SHIFT_NONE;
     35:   else {
     36:     dir->info.shifttype = (PetscReal) shifttype;
     37:     if ((shifttype == MAT_SHIFT_NONZERO || shifttype ==  MAT_SHIFT_INBLOCKS) && dir->info.shiftamount == 0.0) {
     38:       dir->info.shiftamount = 100.0*PETSC_MACHINE_EPSILON; /* set default amount if user has not called PCFactorSetShiftAmount() yet */
     39:     }
     40:   }
     41:   return(0);
     42: }

     44: PetscErrorCode  PCFactorSetShiftAmount_Factor(PC pc,PetscReal shiftamount)
     45: {
     46:   PC_Factor *dir = (PC_Factor*)pc->data;

     49:   if (shiftamount == (PetscReal) PETSC_DECIDE) dir->info.shiftamount = 100.0*PETSC_MACHINE_EPSILON;
     50:   else dir->info.shiftamount = shiftamount;
     51:   return(0);
     52: }

     54: PetscErrorCode  PCFactorSetDropTolerance_Factor(PC pc,PetscReal dt,PetscReal dtcol,PetscInt dtcount)
     55: {
     56:   PC_Factor *ilu = (PC_Factor*)pc->data;

     59:   if (pc->setupcalled && (!ilu->info.usedt || ((PC_Factor*)ilu)->info.dt != dt || ((PC_Factor*)ilu)->info.dtcol != dtcol || ((PC_Factor*)ilu)->info.dtcount != dtcount)) {
     60:     SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Cannot change tolerance after use");
     61:   }
     62:   ilu->info.usedt   = PETSC_TRUE;
     63:   ilu->info.dt      = dt;
     64:   ilu->info.dtcol   = dtcol;
     65:   ilu->info.dtcount = dtcount;
     66:   ilu->info.fill    = PETSC_DEFAULT;
     67:   return(0);
     68: }

     70: PetscErrorCode  PCFactorSetFill_Factor(PC pc,PetscReal fill)
     71: {
     72:   PC_Factor *dir = (PC_Factor*)pc->data;

     75:   dir->info.fill = fill;
     76:   return(0);
     77: }

     79: PetscErrorCode  PCFactorSetMatOrderingType_Factor(PC pc,MatOrderingType ordering)
     80: {
     81:   PC_Factor      *dir = (PC_Factor*)pc->data;
     83:   PetscBool      flg;

     86:   if (!pc->setupcalled) {
     87:     PetscFree(dir->ordering);
     88:     PetscStrallocpy(ordering,(char**)&dir->ordering);
     89:   } else {
     90:     PetscStrcmp(dir->ordering,ordering,&flg);
     91:     if (!flg) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Cannot change ordering after use");
     92:   }
     93:   return(0);
     94: }

     96: PetscErrorCode  PCFactorGetLevels_Factor(PC pc,PetscInt *levels)
     97: {
     98:   PC_Factor      *ilu = (PC_Factor*)pc->data;

    101:   *levels = ilu->info.levels;
    102:   return(0);
    103: }

    105: PetscErrorCode  PCFactorGetZeroPivot_Factor(PC pc,PetscReal *pivot)
    106: {
    107:   PC_Factor      *ilu = (PC_Factor*)pc->data;

    110:   *pivot = ilu->info.zeropivot;
    111:   return(0);
    112: }

    114: PetscErrorCode  PCFactorGetShiftAmount_Factor(PC pc,PetscReal *shift)
    115: {
    116:   PC_Factor      *ilu = (PC_Factor*)pc->data;

    119:   *shift = ilu->info.shiftamount;
    120:   return(0);
    121: }

    123: PetscErrorCode  PCFactorGetShiftType_Factor(PC pc,MatFactorShiftType *type)
    124: {
    125:   PC_Factor      *ilu = (PC_Factor*)pc->data;

    128:   *type = (MatFactorShiftType) (int) ilu->info.shifttype;
    129:   return(0);
    130: }

    132: PetscErrorCode  PCFactorSetLevels_Factor(PC pc,PetscInt levels)
    133: {
    134:   PC_Factor      *ilu = (PC_Factor*)pc->data;

    138:   if (!pc->setupcalled) ilu->info.levels = levels;
    139:   else if (ilu->info.levels != levels) {
    140:     (*pc->ops->reset)(pc); /* remove previous factored matrices */
    141:     pc->setupcalled  = 0; /* force a complete rebuild of preconditioner factored matrices */
    142:     ilu->info.levels = levels;
    143:   } else if (ilu->info.usedt) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Cannot change levels after use with ILUdt");
    144:   return(0);
    145: }

    147: PetscErrorCode  PCFactorSetAllowDiagonalFill_Factor(PC pc,PetscBool flg)
    148: {
    149:   PC_Factor *dir = (PC_Factor*)pc->data;

    152:   dir->info.diagonal_fill = (PetscReal) flg;
    153:   return(0);
    154: }

    156: PetscErrorCode  PCFactorGetAllowDiagonalFill_Factor(PC pc,PetscBool *flg)
    157: {
    158:   PC_Factor *dir = (PC_Factor*)pc->data;

    161:   *flg = dir->info.diagonal_fill ? PETSC_TRUE : PETSC_FALSE;
    162:   return(0);
    163: }

    165: /* ------------------------------------------------------------------------------------------*/

    167: PetscErrorCode  PCFactorSetPivotInBlocks_Factor(PC pc,PetscBool pivot)
    168: {
    169:   PC_Factor *dir = (PC_Factor*)pc->data;

    172:   dir->info.pivotinblocks = pivot ? 1.0 : 0.0;
    173:   return(0);
    174: }

    176: PetscErrorCode  PCFactorGetMatrix_Factor(PC pc,Mat *mat)
    177: {
    178:   PC_Factor *ilu = (PC_Factor*)pc->data;

    181:   if (!ilu->fact) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ORDER,"Matrix not yet factored; call after KSPSetUp() or PCSetUp()");
    182:   *mat = ilu->fact;
    183:   return(0);
    184: }

    186: PetscErrorCode  PCFactorSetMatSolverType_Factor(PC pc,MatSolverType stype)
    187: {
    189:   PC_Factor      *lu = (PC_Factor*)pc->data;

    192:   if (lu->fact) {
    193:     MatSolverType ltype;
    194:     PetscBool     flg;
    195:     MatFactorGetSolverType(lu->fact,&ltype);
    196:     PetscStrcmp(stype,ltype,&flg);
    197:     if (!flg) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Cannot change solver matrix package after PC has been setup or used");
    198:   }
    199:
    200:   PetscFree(lu->solvertype);
    201:   PetscStrallocpy(stype,&lu->solvertype);
    202:   return(0);
    203: }

    205: PetscErrorCode  PCFactorGetMatSolverType_Factor(PC pc,MatSolverType *stype)
    206: {
    207:   PC_Factor *lu = (PC_Factor*)pc->data;

    210:   *stype = lu->solvertype;
    211:   return(0);
    212: }

    214: PetscErrorCode  PCFactorSetColumnPivot_Factor(PC pc,PetscReal dtcol)
    215: {
    216:   PC_Factor *dir = (PC_Factor*)pc->data;

    219:   if (dtcol < 0.0 || dtcol > 1.0) SETERRQ1(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_OUTOFRANGE,"Column pivot tolerance is %g must be between 0 and 1",(double)dtcol);
    220:   dir->info.dtcol = dtcol;
    221:   return(0);
    222: }

    224: PetscErrorCode  PCSetFromOptions_Factor(PetscOptionItems *PetscOptionsObject,PC pc)
    225: {
    226:   PC_Factor         *factor = (PC_Factor*)pc->data;
    227:   PetscErrorCode    ierr;
    228:   PetscBool         flg,set;
    229:   char              tname[256], solvertype[64];
    230:   PetscFunctionList ordlist;
    231:   PetscEnum         etmp;
    232:   PetscBool         inplace;

    235:   PCFactorGetUseInPlace(pc,&inplace);
    236:   PetscOptionsBool("-pc_factor_in_place","Form factored matrix in the same memory as the matrix","PCFactorSetUseInPlace",inplace,&flg,&set);
    237:   if (set) {
    238:     PCFactorSetUseInPlace(pc,flg);
    239:   }
    240:   PetscOptionsReal("-pc_factor_fill","Expected non-zeros in factored matrix","PCFactorSetFill",((PC_Factor*)factor)->info.fill,&((PC_Factor*)factor)->info.fill,NULL);

    242:   PetscOptionsEnum("-pc_factor_shift_type","Type of shift to add to diagonal","PCFactorSetShiftType",MatFactorShiftTypes,(PetscEnum)(int)((PC_Factor*)factor)->info.shifttype,&etmp,&flg);
    243:   if (flg) {
    244:     PCFactorSetShiftType(pc,(MatFactorShiftType)etmp);
    245:   }
    246:   PetscOptionsReal("-pc_factor_shift_amount","Shift added to diagonal","PCFactorSetShiftAmount",((PC_Factor*)factor)->info.shiftamount,&((PC_Factor*)factor)->info.shiftamount,0);

    248:   PetscOptionsReal("-pc_factor_zeropivot","Pivot is considered zero if less than","PCFactorSetZeroPivot",((PC_Factor*)factor)->info.zeropivot,&((PC_Factor*)factor)->info.zeropivot,0);
    249:   PetscOptionsReal("-pc_factor_column_pivot","Column pivot tolerance (used only for some factorization)","PCFactorSetColumnPivot",((PC_Factor*)factor)->info.dtcol,&((PC_Factor*)factor)->info.dtcol,&flg);

    251:   PetscOptionsBool("-pc_factor_pivot_in_blocks","Pivot inside matrix dense blocks for BAIJ and SBAIJ","PCFactorSetPivotInBlocks",((PC_Factor*)factor)->info.pivotinblocks ? PETSC_TRUE : PETSC_FALSE,&flg,&set);
    252:   if (set) {
    253:     PCFactorSetPivotInBlocks(pc,flg);
    254:   }

    256:   PetscOptionsBool("-pc_factor_reuse_fill","Use fill from previous factorization","PCFactorSetReuseFill",PETSC_FALSE,&flg,&set);
    257:   if (set) {
    258:     PCFactorSetReuseFill(pc,flg);
    259:   }
    260:   PetscOptionsBool("-pc_factor_reuse_ordering","Reuse ordering from previous factorization","PCFactorSetReuseOrdering",PETSC_FALSE,&flg,&set);
    261:   if (set) {
    262:     PCFactorSetReuseOrdering(pc,flg);
    263:   }

    265:   MatGetOrderingList(&ordlist);
    266:   PetscOptionsFList("-pc_factor_mat_ordering_type","Reordering to reduce nonzeros in factored matrix","PCFactorSetMatOrderingType",ordlist,((PC_Factor*)factor)->ordering,tname,256,&flg);
    267:   if (flg) {
    268:     PCFactorSetMatOrderingType(pc,tname);
    269:   }

    271:   /* maybe should have MatGetSolverTypes(Mat,&list) like the ordering list */
    272:   PetscOptionsDeprecated("-pc_factor_mat_solver_package","-pc_factor_mat_solver_type","3.9",NULL);
    273:   PetscOptionsString("-pc_factor_mat_solver_type","Specific direct solver to use","MatGetFactor",((PC_Factor*)factor)->solvertype,solvertype,64,&flg);
    274:   if (flg) {
    275:     PCFactorSetMatSolverType(pc,solvertype);
    276:   }
    277:   return(0);
    278: }

    280: PetscErrorCode PCView_Factor(PC pc,PetscViewer viewer)
    281: {
    282:   PC_Factor      *factor = (PC_Factor*)pc->data;
    284:   PetscBool      isstring,iascii;

    287:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING,&isstring);
    288:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    289:   if (iascii) {
    290:     if (factor->inplace) {
    291:       PetscViewerASCIIPrintf(viewer,"  in-place factorization\n");
    292:     } else {
    293:       PetscViewerASCIIPrintf(viewer,"  out-of-place factorization\n");
    294:     }

    296:     if (factor->reusefill)     {PetscViewerASCIIPrintf(viewer,"  Reusing fill from past factorization\n");}
    297:     if (factor->reuseordering) {PetscViewerASCIIPrintf(viewer,"  Reusing reordering from past factorization\n");}
    298:     if (factor->factortype == MAT_FACTOR_ILU || factor->factortype == MAT_FACTOR_ICC) {
    299:       if (factor->info.dt > 0) {
    300:         PetscViewerASCIIPrintf(viewer,"  drop tolerance %g\n",(double)factor->info.dt);
    301:         PetscViewerASCIIPrintf(viewer,"  max nonzeros per row %D\n",factor->info.dtcount);
    302:         PetscViewerASCIIPrintf(viewer,"  column permutation tolerance %g\n",(double)factor->info.dtcol);
    303:       } else if (factor->info.levels == 1) {
    304:         PetscViewerASCIIPrintf(viewer,"  %D level of fill\n",(PetscInt)factor->info.levels);
    305:       } else {
    306:         PetscViewerASCIIPrintf(viewer,"  %D levels of fill\n",(PetscInt)factor->info.levels);
    307:       }
    308:     }

    310:     PetscViewerASCIIPrintf(viewer,"  tolerance for zero pivot %g\n",(double)factor->info.zeropivot);
    311:     if (MatFactorShiftTypesDetail[(int)factor->info.shifttype]) { /* Only print when using a nontrivial shift */
    312:       PetscViewerASCIIPrintf(viewer,"  using %s [%s]\n",MatFactorShiftTypesDetail[(int)factor->info.shifttype],MatFactorShiftTypes[(int)factor->info.shifttype]);
    313:     }

    315:     PetscViewerASCIIPrintf(viewer,"  matrix ordering: %s\n",factor->ordering);

    317:     if (factor->fact) {
    318:       MatInfo info;
    319:       MatGetInfo(factor->fact,MAT_LOCAL,&info);
    320:       PetscViewerASCIIPrintf(viewer,"  factor fill ratio given %g, needed %g\n",(double)info.fill_ratio_given,(double)info.fill_ratio_needed);
    321:       PetscViewerASCIIPrintf(viewer,"    Factored matrix follows:\n");
    322:       PetscViewerASCIIPushTab(viewer);
    323:       PetscViewerASCIIPushTab(viewer);
    324:       PetscViewerASCIIPushTab(viewer);
    325:       PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO);
    326:       MatView(factor->fact,viewer);
    327:       PetscViewerPopFormat(viewer);
    328:       PetscViewerASCIIPopTab(viewer);
    329:       PetscViewerASCIIPopTab(viewer);
    330:       PetscViewerASCIIPopTab(viewer);
    331:     }

    333:   } else if (isstring) {
    334:     MatFactorType t;
    335:     MatGetFactorType(factor->fact,&t);
    336:     if (t == MAT_FACTOR_ILU || t == MAT_FACTOR_ICC) {
    337:       PetscViewerStringSPrintf(viewer," lvls=%D,order=%s",(PetscInt)factor->info.levels,factor->ordering);
    338:     }
    339:   }
    340:   return(0);
    341: }