Date: 2021-03-03T22:27:34+00:00

Actual source code: ex72.c
petsc-3.14.5 2021-03-03
Report Typos and Errors

      2: static char help[] = "Reads a PETSc matrix and vector from a file and solves a linear system.\n\
      3: This version first preloads and solves a small system, then loads \n\
      4: another (larger) system and solves it as well.  This example illustrates\n\
      5: preloading of instructions with the smaller system so that more accurate\n\
      6: performance monitoring can be done with the larger one (that actually\n\
      7: is the system of interest).  See the 'Performance Hints' chapter of the\n\
      8: users manual for a discussion of preloading.  Input parameters include\n\
      9:   -f0 <input_file> : first file to load (small system)\n\
     10:   -f1 <input_file> : second file to load (larger system)\n\n\
     11:   -nearnulldim <0> : number of vectors in the near-null space immediately following matrix\n\n\
     12:   -trans  : solve transpose system instead\n\n";
     13: /*
     14:   This code can be used to test PETSc interface to other packages.\n\
     15:   Examples of command line options:       \n\
     16:    ./ex72 -f0 <datafile> -ksp_type preonly  \n\
     17:         -help -ksp_view                  \n\
     18:         -num_numfac <num_numfac> -num_rhs <num_rhs> \n\
     19:         -ksp_type preonly -pc_type lu -pc_factor_mat_solver_type superlu or superlu_dist or mumps \n\
     20:         -ksp_type preonly -pc_type cholesky -pc_factor_mat_solver_type mumps \n\
     21:    mpiexec -n <np> ./ex72 -f0 <datafile> -ksp_type cg -pc_type asm -pc_asm_type basic -sub_pc_type icc -mat_type sbaij
     22:  \n\n";
     23: */
     24: /*T
     25:    Concepts: KSP^solving a linear system
     26:    Processors: n
     27: T*/

     33: /*
     34:   Include "petscksp.h" so that we can use KSP solvers.  Note that this file
     35:   automatically includes:
     36:      petscsys.h       - base PETSc routines   petscvec.h - vectors
     37:      petscmat.h - matrices
     38:      petscis.h     - index sets            petscksp.h - Krylov subspace methods
     39:      petscviewer.h - viewers               petscpc.h  - preconditioners
     40: */
     41: #include <petscksp.h>

     43: int main(int argc,char **args)
     44: {
     45:   KSP            ksp;             /* linear solver context */
     46:   Mat            A;               /* matrix */
     47:   Vec            x,b,u;           /* approx solution, RHS, exact solution */
     48:   PetscViewer    viewer;          /* viewer */
     49:   char           file[4][PETSC_MAX_PATH_LEN];     /* input file name */
     50:   PetscBool      table     =PETSC_FALSE,flg,trans=PETSC_FALSE,initialguess = PETSC_FALSE;
     51:   PetscBool      outputSoln=PETSC_FALSE,constantnullspace = PETSC_FALSE;
     53:   PetscInt       its,num_numfac,m,n,M,nearnulldim = 0;
     54:   PetscReal      norm;
     55:   PetscBool      preload=PETSC_TRUE,isSymmetric,cknorm=PETSC_FALSE,initialguessfile = PETSC_FALSE;
     56:   PetscMPIInt    rank;
     57:   char           initialguessfilename[PETSC_MAX_PATH_LEN];

     59:   PetscInitialize(&argc,&args,(char*)0,help);if (ierr) return ierr;
     60:   MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
     61:   PetscOptionsGetBool(NULL,NULL,"-table",&table,NULL);
     62:   PetscOptionsGetBool(NULL,NULL,"-constantnullspace",&constantnullspace,NULL);
     63:   PetscOptionsGetBool(NULL,NULL,"-trans",&trans,NULL);
     64:   PetscOptionsGetBool(NULL,NULL,"-initialguess",&initialguess,NULL);
     65:   PetscOptionsGetBool(NULL,NULL,"-output_solution",&outputSoln,NULL);
     66:   PetscOptionsGetString(NULL,NULL,"-initialguessfilename",initialguessfilename,sizeof(initialguessfilename),&initialguessfile);
     67:   PetscOptionsGetInt(NULL,NULL,"-nearnulldim",&nearnulldim,NULL);

     69:   /*
     70:      Determine files from which we read the two linear systems
     71:      (matrix and right-hand-side vector).
     72:   */
     73:   PetscOptionsGetString(NULL,NULL,"-f",file[0],sizeof(file[0]),&flg);
     74:   if (flg) {
     75:     PetscStrcpy(file[1],file[0]);
     76:     preload = PETSC_FALSE;
     77:   } else {
     78:     PetscOptionsGetString(NULL,NULL,"-f0",file[0],sizeof(file[0]),&flg);
     79:     if (!flg) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_USER_INPUT,"Must indicate binary file with the -f0 or -f option");
     80:     PetscOptionsGetString(NULL,NULL,"-f1",file[1],sizeof(file[1]),&flg);
     81:     if (!flg) preload = PETSC_FALSE;   /* don't bother with second system */
     82:   }

     84:   /* -----------------------------------------------------------
     85:                   Beginning of linear solver loop
     86:      ----------------------------------------------------------- */
     87:   /*
     88:      Loop through the linear solve 2 times.
     89:       - The intention here is to preload and solve a small system;
     90:         then load another (larger) system and solve it as well.
     91:         This process preloads the instructions with the smaller
     92:         system so that more accurate performance monitoring (via
     93:         -log_view) can be done with the larger one (that actually
     94:         is the system of interest).
     95:   */
     96:   PetscPreLoadBegin(preload,"Load system");

     98:   /* - - - - - - - - - - - New Stage - - - - - - - - - - - - -
     99:                          Load system
    100:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

    102:   /*
    103:      Open binary file.  Note that we use FILE_MODE_READ to indicate
    104:      reading from this file.
    105:   */
    106:   PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[PetscPreLoadIt],FILE_MODE_READ,&viewer);

    108:   /*
    109:      Load the matrix and vector; then destroy the viewer.
    110:   */
    111:   MatCreate(PETSC_COMM_WORLD,&A);
    112:   MatSetFromOptions(A);
    113:   MatLoad(A,viewer);
    114:   if (nearnulldim) {
    115:     MatNullSpace nullsp;
    116:     Vec          *nullvecs;
    117:     PetscInt     i;
    118:     PetscMalloc1(nearnulldim,&nullvecs);
    119:     for (i=0; i<nearnulldim; i++) {
    120:       VecCreate(PETSC_COMM_WORLD,&nullvecs[i]);
    121:       VecLoad(nullvecs[i],viewer);
    122:     }
    123:     MatNullSpaceCreate(PETSC_COMM_WORLD,PETSC_FALSE,nearnulldim,nullvecs,&nullsp);
    124:     MatSetNearNullSpace(A,nullsp);
    125:     for (i=0; i<nearnulldim; i++) {VecDestroy(&nullvecs[i]);}
    126:     PetscFree(nullvecs);
    127:     MatNullSpaceDestroy(&nullsp);
    128:   }
    129:   if (constantnullspace) {
    130:     MatNullSpace constant;
    131:     MatNullSpaceCreate(PETSC_COMM_WORLD,PETSC_TRUE,0,NULL,&constant);
    132:     MatSetNullSpace(A,constant);
    133:     MatNullSpaceDestroy(&constant);
    134:   }
    135:   flg  = PETSC_FALSE;
    136:   PetscOptionsGetString(NULL,NULL,"-rhs",file[2],sizeof(file[2]),&flg);
    137:   VecCreate(PETSC_COMM_WORLD,&b);
    138:   if (flg) {   /* rhs is stored in a separate file */
    139:     if (file[2][0] == '0' || file[2][0] == 0) {
    140:       PetscInt    m;
    141:       PetscScalar one = 1.0;
    142:       PetscInfo(0,"Using vector of ones for RHS\n");
    143:       MatGetLocalSize(A,&m,NULL);
    144:       VecSetSizes(b,m,PETSC_DECIDE);
    145:       VecSetFromOptions(b);
    146:       VecSet(b,one);
    147:     } else {
    148:       PetscViewerDestroy(&viewer);
    149:       PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[2],FILE_MODE_READ,&viewer);
    150:       VecSetFromOptions(b);
    151:       VecLoad(b,viewer);
    152:     }
    153:   } else {   /* rhs is stored in the same file as matrix */
    154:     VecSetFromOptions(b);
    155:     VecLoad(b,viewer);
    156:   }
    157:   PetscViewerDestroy(&viewer);

    159:   /* Make A singular for testing zero-pivot of ilu factorization */
    160:   /* Example: ./ex72 -f0 <datafile> -test_zeropivot -pc_factor_shift_type <shift_type> */
    161:   flg  = PETSC_FALSE;
    162:   PetscOptionsGetBool(NULL,NULL, "-test_zeropivot", &flg,NULL);
    163:   if (flg) { /* set a row as zeros */
    164:     PetscInt          row=0;
    165:     MatSetOption(A,MAT_KEEP_NONZERO_PATTERN,PETSC_TRUE);
    166:     MatZeroRows(A,1,&row,0.0,NULL,NULL);
    167:   }

    169:   /* Check whether A is symmetric, then set A->symmetric option */
    170:   flg = PETSC_FALSE;
    171:   PetscOptionsGetBool(NULL,NULL, "-check_symmetry", &flg,NULL);
    172:   if (flg) {
    173:     MatIsSymmetric(A,0.0,&isSymmetric);
    174:     if (!isSymmetric) {
    175:       PetscPrintf(PETSC_COMM_WORLD,"Warning: A is non-symmetric \n");
    176:     }
    177:   }

    179:   /*
    180:      If the loaded matrix is larger than the vector (due to being padded
    181:      to match the block size of the system), then create a new padded vector.
    182:   */

    184:   MatGetLocalSize(A,&m,&n);
    185:   /*  if (m != n) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ, "This example is not intended for rectangular matrices (%d, %d)", m, n);*/
    186:   MatGetSize(A,&M,NULL);
    187:   VecGetSize(b,&m);
    188:   if (M != m) {   /* Create a new vector b by padding the old one */
    189:     PetscInt    j,mvec,start,end,indx;
    190:     Vec         tmp;
    191:     PetscScalar *bold;

    193:     VecCreate(PETSC_COMM_WORLD,&tmp);
    194:     VecSetSizes(tmp,n,PETSC_DECIDE);
    195:     VecSetFromOptions(tmp);
    196:     VecGetOwnershipRange(b,&start,&end);
    197:     VecGetLocalSize(b,&mvec);
    198:     VecGetArray(b,&bold);
    199:     for (j=0; j<mvec; j++) {
    200:       indx = start+j;
    201:       VecSetValues(tmp,1,&indx,bold+j,INSERT_VALUES);
    202:     }
    203:     VecRestoreArray(b,&bold);
    204:     VecDestroy(&b);
    205:     VecAssemblyBegin(tmp);
    206:     VecAssemblyEnd(tmp);
    207:     b    = tmp;
    208:   }

    210:   MatCreateVecs(A,&x,NULL);
    211:   VecDuplicate(b,&u);
    212:   if (initialguessfile) {
    213:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,initialguessfilename,FILE_MODE_READ,&viewer);
    214:     VecLoad(x,viewer);
    215:     PetscViewerDestroy(&viewer);
    216:     initialguess = PETSC_TRUE;
    217:   } else if (initialguess) {
    218:     VecSet(x,1.0);
    219:   } else {
    220:     VecSet(x,0.0);
    221:   }

    224:   /* Check scaling in A */
    225:   flg  = PETSC_FALSE;
    226:   PetscOptionsGetBool(NULL,NULL, "-check_scaling", &flg,NULL);
    227:   if (flg) {
    228:     Vec       max, min;
    229:     PetscInt  idx;
    230:     PetscReal val;

    232:     VecDuplicate(x, &max);
    233:     VecDuplicate(x, &min);
    234:     MatGetRowMaxAbs(A, max, NULL);
    235:     MatGetRowMinAbs(A, min, NULL);
    236:     {
    237:       PetscViewerASCIIOpen(PETSC_COMM_WORLD, "max.data", &viewer);
    238:       VecView(max, viewer);
    239:       PetscViewerDestroy(&viewer);
    240:       PetscViewerASCIIOpen(PETSC_COMM_WORLD, "min.data", &viewer);
    241:       VecView(min, viewer);
    242:       PetscViewerDestroy(&viewer);
    243:     }
    244:     VecView(max, PETSC_VIEWER_DRAW_WORLD);
    245:     VecMax(max, &idx, &val);
    246:     PetscPrintf(PETSC_COMM_WORLD, "Largest max row element %g at row %D\n", (double)val, idx);
    247:     VecView(min, PETSC_VIEWER_DRAW_WORLD);
    248:     VecMin(min, &idx, &val);
    249:     PetscPrintf(PETSC_COMM_WORLD, "Smallest min row element %g at row %D\n", (double)val, idx);
    250:     VecMin(max, &idx, &val);
    251:     PetscPrintf(PETSC_COMM_WORLD, "Smallest max row element %g at row %D\n", (double)val, idx);
    252:     VecPointwiseDivide(max, max, min);
    253:     VecMax(max, &idx, &val);
    254:     PetscPrintf(PETSC_COMM_WORLD, "Largest row ratio %g at row %D\n", (double)val, idx);
    255:     VecView(max, PETSC_VIEWER_DRAW_WORLD);
    256:     VecDestroy(&max);
    257:     VecDestroy(&min);
    258:   }

    260:   /*  MatView(A,PETSC_VIEWER_STDOUT_WORLD); */
    261:   /* - - - - - - - - - - - New Stage - - - - - - - - - - - - -
    262:                     Setup solve for system
    263:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
    264:   /*
    265:      Conclude profiling last stage; begin profiling next stage.
    266:   */
    267:   PetscPreLoadStage("KSPSetUpSolve");

    269:   /*
    270:      Create linear solver; set operators; set runtime options.
    271:   */
    272:   KSPCreate(PETSC_COMM_WORLD,&ksp);
    273:   KSPSetInitialGuessNonzero(ksp,initialguess);
    274:   num_numfac = 1;
    275:   PetscOptionsGetInt(NULL,NULL,"-num_numfac",&num_numfac,NULL);
    276:   while (num_numfac--) {
    277:     PC        pc;
    278:     PetscBool lsqr,isbddc,ismatis;
    279:     char      str[32];

    281:     PetscOptionsGetString(NULL,NULL,"-ksp_type",str,sizeof(str),&lsqr);
    282:     if (lsqr) {
    283:       PetscStrcmp("lsqr",str,&lsqr);
    284:     }
    285:     if (lsqr) {
    286:       Mat BtB;
    287:       MatTransposeMatMult(A,A,MAT_INITIAL_MATRIX,4,&BtB);
    288:       KSPSetOperators(ksp,A,BtB);
    289:       MatDestroy(&BtB);
    290:     } else {
    291:       KSPSetOperators(ksp,A,A);
    292:     }
    293:     KSPSetFromOptions(ksp);

    295:     /* if we test BDDC, make sure pmat is of type MATIS */
    296:     KSPGetPC(ksp,&pc);
    297:     PetscObjectTypeCompare((PetscObject)pc,PCBDDC,&isbddc);
    298:     PetscObjectTypeCompare((PetscObject)A,MATIS,&ismatis);
    299:     if (isbddc && !ismatis) {
    300:       Mat J;

    302:       MatConvert(A,MATIS,MAT_INITIAL_MATRIX,&J);
    303:       KSPSetOperators(ksp,A,J);
    304:       MatDestroy(&J);
    305:     }

    307:     /*
    308:      Here we explicitly call KSPSetUp() and KSPSetUpOnBlocks() to
    309:      enable more precise profiling of setting up the preconditioner.
    310:      These calls are optional, since both will be called within
    311:      KSPSolve() if they haven't been called already.
    312:     */
    313:     KSPSetUp(ksp);
    314:     KSPSetUpOnBlocks(ksp);

    316:     /* - - - - - - - - - - - New Stage - - - - - - - - - - - - -
    317:                          Solve system
    318:       - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

    320:     /*
    321:      Solve linear system;
    322:     */
    323:     if (trans) {
    324:       KSPSolveTranspose(ksp,b,x);
    325:       KSPGetIterationNumber(ksp,&its);
    326:     } else {
    327:       PetscInt num_rhs=1;
    328:       PetscOptionsGetInt(NULL,NULL,"-num_rhs",&num_rhs,NULL);
    329:       cknorm = PETSC_FALSE;
    330:       PetscOptionsGetBool(NULL,NULL,"-cknorm",&cknorm,NULL);
    331:       while (num_rhs--) {
    332:         if (num_rhs == 1) VecSet(x,0.0);
    333:         KSPSolve(ksp,b,x);
    334:       }
    335:       KSPGetIterationNumber(ksp,&its);
    336:       if (cknorm) {     /* Check error for each rhs */
    337:         if (trans) {
    338:           MatMultTranspose(A,x,u);
    339:         } else {
    340:           MatMult(A,x,u);
    341:         }
    342:         VecAXPY(u,-1.0,b);
    343:         VecNorm(u,NORM_2,&norm);
    344:         PetscPrintf(PETSC_COMM_WORLD,"  Number of iterations = %3D\n",its);
    345:         if (!PetscIsNanScalar(norm)) {
    346:           if (norm < 1.e-12) {
    347:             PetscPrintf(PETSC_COMM_WORLD,"  Residual norm < 1.e-12\n");
    348:           } else {
    349:             PetscPrintf(PETSC_COMM_WORLD,"  Residual norm %g\n",(double)norm);
    350:           }
    351:         }
    352:       }
    353:     }   /* while (num_rhs--) */

    355:     /* - - - - - - - - - - - New Stage - - - - - - - - - - - - -
    356:           Check error, print output, free data structures.
    357:      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

    359:     /*
    360:        Check error
    361:     */
    362:     if (trans) {
    363:       MatMultTranspose(A,x,u);
    364:     } else {
    365:       MatMult(A,x,u);
    366:     }
    367:     VecAXPY(u,-1.0,b);
    368:     VecNorm(u,NORM_2,&norm);
    369:     /*
    370:      Write output (optinally using table for solver details).
    371:       - PetscPrintf() handles output for multiprocessor jobs
    372:         by printing from only one processor in the communicator.
    373:       - KSPView() prints information about the linear solver.
    374:     */
    375:     if (table) {
    376:       char        *matrixname,kspinfo[120];

    378:       /*
    379:        Open a string viewer; then write info to it.
    380:       */
    381:       PetscViewerStringOpen(PETSC_COMM_WORLD,kspinfo,sizeof(kspinfo),&viewer);
    382:       KSPView(ksp,viewer);
    383:       PetscStrrchr(file[PetscPreLoadIt],'/',&matrixname);
    384:       PetscPrintf(PETSC_COMM_WORLD,"%-8.8s %3D %2.0e %s \n",matrixname,its,norm,kspinfo);

    386:       /*
    387:         Destroy the viewer
    388:       */
    389:       PetscViewerDestroy(&viewer);
    390:     } else {
    391:       PetscPrintf(PETSC_COMM_WORLD,"Number of iterations = %3D\n",its);
    392:       if (!PetscIsNanScalar(norm)) {
    393:         if (norm < 1.e-12 && !PetscIsNanScalar((PetscScalar)norm)) {
    394:           PetscPrintf(PETSC_COMM_WORLD,"  Residual norm < 1.e-12\n");
    395:         } else {
    396:           PetscPrintf(PETSC_COMM_WORLD,"Residual norm %g\n",(double)norm);
    397:         }
    398:       }
    399:     }
    400:     PetscOptionsGetString(NULL,NULL,"-solution",file[3],sizeof(file[3]),&flg);
    401:     if (flg) {
    402:       Vec         xstar;
    403:       PetscReal   norm;

    405:       PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[3],FILE_MODE_READ,&viewer);
    406:       VecCreate(PETSC_COMM_WORLD,&xstar);
    407:       VecLoad(xstar,viewer);
    408:       VecAXPY(xstar, -1.0, x);
    409:       VecNorm(xstar, NORM_2, &norm);
    410:       PetscPrintf(PETSC_COMM_WORLD, "Error norm %g\n", (double)norm);
    411:       VecDestroy(&xstar);
    412:       PetscViewerDestroy(&viewer);
    413:     }
    414:     if (outputSoln) {
    415:       PetscViewerBinaryOpen(PETSC_COMM_WORLD,"solution.petsc",FILE_MODE_WRITE,&viewer);
    416:       VecView(x, viewer);
    417:       PetscViewerDestroy(&viewer);
    418:     }

    420:     flg  = PETSC_FALSE;
    421:     PetscOptionsGetBool(NULL,NULL, "-ksp_reason", &flg,NULL);
    422:     if (flg) {
    423:       KSPConvergedReason reason;
    424:       KSPGetConvergedReason(ksp,&reason);
    425:       PetscPrintf(PETSC_COMM_WORLD,"KSPConvergedReason: %D\n", reason);
    426:     }

    428:   }   /* while (num_numfac--) */

    430:   /*
    431:      Free work space.  All PETSc objects should be destroyed when they
    432:      are no longer needed.
    433:   */
    434:   MatDestroy(&A); VecDestroy(&b);
    435:   VecDestroy(&u); VecDestroy(&x);
    436:   KSPDestroy(&ksp);
    437:   PetscPreLoadEnd();
    438:   /* -----------------------------------------------------------
    439:                       End of linear solver loop
    440:      ----------------------------------------------------------- */

    442:   PetscFinalize();
    443:   return ierr;
    444: }

    447: /*TEST

    449:    build:
    450:       requires: !complex

    452:    testset:
    453:       suffix: 1
    454:       nsize: 2
    455:       args: -f0 ${wPETSC_DIR}/share/petsc/datafiles/matrices/spd-real-int@PETSC_INDEX_SIZE@-float@PETSC_SCALAR_SIZE@
    456:       requires: !__float128

    458:    testset:
    459:       suffix: 1a
    460:       args: -f0 ${wPETSC_DIR}/share/petsc/datafiles/matrices/spd-real-int@PETSC_INDEX_SIZE@-float@PETSC_SCALAR_SIZE@
    461:       requires: !__float128

    463:    testset:
    464:       nsize: 2
    465:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    466:       args: -f0 ${DATAFILESPATH}/matrices/medium
    467:       args:  -ksp_type bicg
    468:       test:
    469:          suffix: 2

    471:    testset:
    472:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    473:       args: -f0 ${DATAFILESPATH}/matrices/medium
    474:       args: -ksp_type bicg
    475:       test:
    476:          suffix: 4
    477:          args: -pc_type lu
    478:       test:
    479:          suffix: 5

    481:    testset:
    482:       suffix: 6
    483:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    484:       args: -f0 ${DATAFILESPATH}/matrices/fem1
    485:       args: -pc_factor_levels 2 -pc_factor_fill 1.73 -ksp_gmres_cgs_refinement_type refine_always

    487:    testset:
    488:       TODO: Matrix row/column sizes are not compatible with block size
    489:       suffix: 7
    490:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    491:       args: -f0 ${DATAFILESPATH}/matrices/medium
    492:       args: -viewer_binary_skip_info -mat_type seqbaij
    493:       args: -matload_block_size {{2 3 4 5 6 7 8}separate output}
    494:       args: -ksp_max_it 100 -ksp_gmres_cgs_refinement_type refine_always
    495:       args: -ksp_rtol 1.0e-15 -ksp_monitor_short
    496:       test:
    497:          suffix: a
    498:       test:
    499:          suffix: b
    500:          args: -pc_factor_mat_ordering_type nd
    501:       test:
    502:          suffix: c
    503:          args: -pc_factor_levels 1

    505:    testset:
    506:       TODO: Matrix row/column sizes are not compatible with block size
    507:       suffix: 7_d
    508:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    509:       args: -f0 ${DATAFILESPATH}/matrices/medium
    510:       args: -viewer_binary_skip_info -mat_type seqbaij
    511:       args: -matload_block_size {{2 3 4 5 6 7 8}shared output}
    512:       args: -ksp_type preonly -pc_type lu

    514:    testset:
    515:       suffix: 8
    516:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    517:       args: -f0 ${DATAFILESPATH}/matrices/medium
    518:       args: -ksp_diagonal_scale -pc_type eisenstat -ksp_monitor_short -ksp_diagonal_scale_fix -ksp_gmres_cgs_refinement_type refine_always -mat_no_inode

    520:    testset:
    521:       TODO: Matrix row/column sizes are not compatible with block size
    522:       suffix: 9
    523:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    524:       args: -f0 ${DATAFILESPATH}/matrices/medium
    525:       args: -viewer_binary_skip_info  -matload_block_size {{1 2 3 4 5 6 7}separate output} -ksp_max_it 100 -ksp_gmres_cgs_refinement_type refine_always -ksp_rtol 1.0e-15 -ksp_monitor_short
    526:       test:
    527:          suffix: a
    528:          args: -mat_type seqbaij
    529:       test:
    530:          suffix: b
    531:          args: -mat_type seqbaij -trans
    532:       test:
    533:          suffix: c
    534:          nsize: 2
    535:          args: -mat_type mpibaij
    536:       test:
    537:          suffix: d
    538:          nsize: 2
    539:          args: -mat_type mpibaij -trans
    540:       test:
    541:          suffix: e
    542:          nsize: 3
    543:          args: -mat_type mpibaij
    544:       test:
    545:          suffix: f
    546:          nsize: 3
    547:          args: -mat_type mpibaij -trans

    550:    testset:
    551:       suffix: 10
    552:       nsize: 2
    553:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    554:       args: -ksp_type fgmres -pc_type ksp -f0 ${DATAFILESPATH}/matrices/medium -ksp_fgmres_modifypcksp -ksp_monitor_short

    556:    testset:
    557:       suffix: 12
    558:       requires: matlab
    559:       args: -pc_type lu -pc_factor_mat_solver_type matlab -f0 ${DATAFILESPATH}/matrices/arco1

    561:    testset:
    562:       suffix: 13
    563:       requires: lusol
    564:       args: -f0 ${DATAFILESPATH}/matrices/arco1
    565:       args: -mat_type lusol -pc_type lu

    567:    testset:
    568:       nsize: 3
    569:       args: -f0 ${DATAFILESPATH}/matrices/medium
    570:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    571:       test:
    572:          suffix: 14
    573:          requires: spai
    574:          args: -pc_type spai
    575:       test:
    576:          suffix: 15
    577:          requires: hypre
    578:          args: -pc_type hypre -pc_hypre_type pilut
    579:       test:
    580:          suffix: 16
    581:          requires: hypre
    582:          args: -pc_type hypre -pc_hypre_type parasails
    583:       test:
    584:          suffix: 17
    585:          requires: hypre
    586:          args: -pc_type hypre -pc_hypre_type boomeramg
    587:       test:
    588:          suffix: 18
    589:          requires: hypre
    590:          args: -pc_type hypre -pc_hypre_type euclid

    592:    testset:
    593:       suffix: 19
    594:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    595:       args: -f0 ${DATAFILESPATH}/matrices/poisson1
    596:       args: -ksp_type cg -pc_type icc
    597:       args: -pc_factor_levels {{0 2 4}separate output}
    598:       test:
    599:       test:
    600:          args: -mat_type seqsbaij

    603:    testset:
    604:       suffix: ILU
    605:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    606:       args: -f0 ${DATAFILESPATH}/matrices/small
    607:       args: -pc_factor_levels 1
    608:       test:
    609:       test:
    610:          # This is tested against regular ILU (used to be denoted ILUBAIJ)
    611:          args: -mat_type baij

    613:    testset:
    614:       suffix: aijcusparse
    615:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) cuda
    616:       args: -f0 ${DATAFILESPATH}/matrices/medium -ksp_monitor_short -ksp_view -mat_view ascii::ascii_info -mat_type aijcusparse -pc_factor_mat_solver_type cusparse -pc_type ilu -vec_type cuda

    618:    testset:
    619:       TODO: No output file. Need to determine if deprecated
    620:       suffix: asm_viennacl
    621:       nsize: 2
    622:       requires: viennacl
    623:       args: -pc_type asm -pc_asm_sub_mat_type aijviennacl -f0 ${wPETSC_DIR}/share/petsc/datafiles/matrices/spd-real-int${PETSC_INDEX_SIZE}-float${PETSC_SCALAR_SIZE}

    625:    testset:
    626:       nsize: 2
    627:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) hypre
    628:       args: -f0 ${DATAFILESPATH}/matrices/poisson2.gz -ksp_monitor_short -ksp_rtol 1.E-9 -pc_type hypre -pc_hypre_type boomeramg
    629:       test:
    630:          suffix: boomeramg_euclid
    631:          args: -pc_hypre_boomeramg_smooth_type Euclid -pc_hypre_boomeramg_smooth_num_levels 2 -pc_hypre_boomeramg_eu_level 1 -pc_hypre_boomeramg_eu_droptolerance 0.01
    632:          TODO: Need to determine if deprecated
    633:       test:
    634:          suffix: boomeramg_euclid_bj
    635:          args: -pc_hypre_boomeramg_smooth_type Euclid -pc_hypre_boomeramg_smooth_num_levels 2 -pc_hypre_boomeramg_eu_level 1 -pc_hypre_boomeramg_eu_droptolerance 0.01 -pc_hypre_boomeramg_eu_bj
    636:          TODO: Need to determine if deprecated
    637:       test:
    638:          suffix: boomeramg_parasails
    639:          args: -pc_hypre_boomeramg_smooth_type ParaSails -pc_hypre_boomeramg_smooth_num_levels 2
    640:       test:
    641:          suffix: boomeramg_pilut
    642:          args: -pc_hypre_boomeramg_smooth_type Pilut -pc_hypre_boomeramg_smooth_num_levels 2
    643:       test:
    644:          suffix: boomeramg_schwarz
    645:          args: -pc_hypre_boomeramg_smooth_type Schwarz-smoothers

    647:    testset:
    648:       suffix: cg_singlereduction
    649:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    650:       args: -f0 ${DATAFILESPATH}/matrices/small
    651:       args: -mat_type mpisbaij -ksp_type cg -pc_type eisenstat -ksp_monitor_short -ksp_converged_reason
    652:       test:
    653:       test:
    654:          args: -ksp_cg_single_reduction

    656:    testset:
    657:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    658:       args: -f0 ${DATAFILESPATH}/matrices/poisson2.gz
    659:       args: -ksp_monitor_short -pc_type icc
    660:       test:
    661:          suffix: cr
    662:          args: -ksp_type cr
    663:       test:
    664:          suffix: lcd
    665:          args: -ksp_type lcd

    667:    testset:
    668:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    669:       args: -f0 ${DATAFILESPATH}/matrices/small
    670:       args: -ksp_monitor_short -ksp_view -mat_view ascii::ascii_info
    671:       test:
    672:          suffix: seqaijcrl
    673:          args: -mat_type seqaijcrl
    674:       test:
    675:          suffix: seqaijperm
    676:          args: -mat_type seqaijperm

    678:    testset:
    679:       nsize: 2
    680:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    681:       args: -f0 ${DATAFILESPATH}/matrices/small
    682:       args: -ksp_monitor_short -ksp_view
    683:       # Different output files
    684:       test:
    685:          suffix: mpiaijcrl
    686:          args: -mat_type mpiaijcrl
    687:       test:
    688:          suffix: mpiaijperm
    689:          args: -mat_type mpiaijperm

    691:    testset:
    692:       nsize: 4
    693:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    694:       args: -ksp_monitor_short -ksp_view
    695:       test:
    696:          suffix: xxt
    697:          args: -f0 ${DATAFILESPATH}/matrices/poisson1 -check_symmetry -ksp_type cg -pc_type tfs
    698:       test:
    699:          suffix: xyt
    700:          args: -f0 ${DATAFILESPATH}/matrices/medium -ksp_type gmres -pc_type tfs

    702:    testset:
    703:       # The output file here is the same as mumps
    704:       suffix: mumps_cholesky
    705:       output_file: output/ex72_mumps.out
    706:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps
    707:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type cholesky -pc_factor_mat_solver_type mumps -num_numfac 2 -num_rhs 2
    708:       nsize: {{1 2}}
    709:       test:
    710:          args: -mat_type sbaij -mat_ignore_lower_triangular
    711:       test:
    712:          args: -mat_type aij
    713:       test:
    714:          args: -mat_type aij -matload_spd

    716:    testset:
    717:       # The output file here is the same as mumps
    718:       suffix: mumps_lu
    719:       output_file: output/ex72_mumps.out
    720:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps
    721:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_type mumps -num_numfac 2 -num_rhs 2
    722:       test:
    723:          args: -mat_type seqaij
    724:       test:
    725:          nsize: 2
    726:          args: -mat_type mpiaij
    727:       test:
    728:          args: -mat_type seqbaij -matload_block_size 2
    729:       test:
    730:          nsize: 2
    731:          args: -mat_type mpibaij -matload_block_size 2
    732:       test:
    733:          args: -mat_type aij -mat_mumps_icntl_7 5
    734:          TODO: Need to determine if deprecated

    736:    test:
    737:       suffix: mumps_lu_parmetis
    738:       output_file: output/ex72_mumps.out
    739:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps parmetis
    740:       nsize: 2
    741:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_type mumps -num_numfac 2 -num_rhs 2 -mat_type mpiaij -mat_mumps_icntl_28 2 -mat_mumps_icntl_29 2

    743:    test:
    744:       suffix: mumps_lu_ptscotch
    745:       output_file: output/ex72_mumps.out
    746:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps ptscotch
    747:       nsize: 2
    748:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_type mumps -num_numfac 2 -num_rhs 2 -mat_type mpiaij -mat_mumps_icntl_28 2 -mat_mumps_icntl_29 1

    750:    testset:
    751:       # The output file here is the same as mumps
    752:       suffix: mumps_redundant
    753:       output_file: output/ex72_mumps_redundant.out
    754:       nsize: 8
    755:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps
    756:       args: -f0 ${DATAFILESPATH}/matrices/medium -ksp_type preonly -pc_type redundant -pc_redundant_number {{8 7 6 5 4 3 2 1}} -redundant_pc_factor_mat_solver_type mumps -num_numfac 2 -num_rhs 2

    758:    testset:
    759:       suffix: pastix_cholesky
    760:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) pastix
    761:       output_file: output/ex72_mumps.out
    762:       nsize: {{1 2}}
    763:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_factor_mat_solver_type pastix -num_numfac 2 -num_rhs 2 -pc_type cholesky -mat_type sbaij -mat_ignore_lower_triangular

    765:    testset:
    766:       suffix: pastix_lu
    767:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) pastix
    768:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_type pastix -num_numfac 2 -num_rhs 2
    769:       output_file: output/ex72_mumps.out
    770:       test:
    771:          args: -mat_type seqaij
    772:       test:
    773:          nsize: 2
    774:          args: -mat_type mpiaij

    776:    testset:
    777:       suffix: pastix_redundant
    778:       output_file: output/ex72_mumps_redundant.out
    779:       nsize: 8
    780:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) pastix
    781:       args: -f0 ${DATAFILESPATH}/matrices/medium -ksp_type preonly -pc_type redundant -pc_redundant_number {{8 7 6 5 4 3 2 1}} -redundant_pc_factor_mat_solver_type pastix -num_numfac 2 -num_rhs 2

    784:    testset:
    785:       suffix: superlu_dist_lu
    786:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) superlu_dist
    787:       output_file: output/ex72_mumps.out
    788:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_type superlu_dist -num_numfac 2 -num_rhs 2
    789:       nsize: {{1 2}}

    791:    testset:
    792:       suffix: superlu_dist_redundant
    793:       nsize: 8
    794:       output_file: output/ex72_mumps_redundant.out
    795:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) superlu_dist
    796:       args: -f0 ${DATAFILESPATH}/matrices/medium -ksp_type preonly -pc_type redundant -pc_redundant_number {{8 7 6 5 4 3 2 1}} -redundant_pc_factor_mat_solver_type superlu_dist -num_numfac 2 -num_rhs 2

    798:    testset:
    799:       suffix: superlu_lu
    800:       output_file: output/ex72_mumps.out
    801:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) superlu
    802:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_type superlu -num_numfac 2 -num_rhs 2

    804:    testset:
    805:       suffix: umfpack
    806:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) suitesparse
    807:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -mat_type seqaij -pc_factor_mat_solver_type umfpack -num_numfac 2 -num_rhs 2

    810:    testset:
    811:       suffix: zeropivot
    812:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps
    813:       args: -f0 ${DATAFILESPATH}/matrices/small -test_zeropivot -ksp_converged_reason -ksp_type fgmres -pc_type ksp
    814:       test:
    815:          nsize: 3
    816:          args: -ksp_pc_type bjacobi
    817:       test:
    818:          nsize: 2
    819:          args: -ksp_ksp_type cg -ksp_pc_type bjacobi -ksp_pc_bjacobi_blocks 1
    820:       #test:
    821:          #nsize: 3
    822:          #args: -ksp_ksp_converged_reason -ksp_pc_type bjacobi -ksp_sub_ksp_converged_reason
    823:          #TODO: Need to determine if deprecated

    825:    testset:
    826:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
    827:       args: -f0 ${DATAFILESPATH}/matrices/medium -ksp_type fgmres
    828:       test:
    829:          suffix: bddc_seq
    830:          nsize: 1
    831:          args: -pc_type bddc
    832:       test:
    833:          suffix: bddc_par
    834:          nsize: 2
    835:          args: -pc_type bddc
    836:       test:
    837:          requires: parmetis
    838:          suffix: bddc_par_nd_parmetis
    839:          filter: sed -e "s/Number of iterations =   [0-9]/Number of iterations = 9/g"
    840:          nsize: 4
    841:          args: -ksp_error_if_not_converged -pc_type bddc -mat_is_disassemble_l2g_type nd -mat_partitioning_type parmetis
    842:       test:
    843:          requires: ptscotch define(PETSC_HAVE_SCOTCH_PARMETIS_V3_NODEND)
    844:          suffix: bddc_par_nd_ptscotch
    845:          filter: sed -e "s/Number of iterations =   [0-9]/Number of iterations = 9/g"
    846:          nsize: 4
    847:          args: -ksp_error_if_not_converged -pc_type bddc -mat_is_disassemble_l2g_type nd -mat_partitioning_type ptscotch
    848: TEST*/