Actual source code: ex72.c

petsc-master 2020-09-24
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*/