Actual source code: ex10.c

petsc-master 2017-11-23
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:    ./ex10 -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_package superlu or superlu_dist or mumps \n\
 20:         -ksp_type preonly -pc_type cholesky -pc_factor_mat_solver_package mumps \n\
 21:    mpiexec -n <np> ./ex10 -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,PETSC_MAX_PATH_LEN,&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],PETSC_MAX_PATH_LEN,&flg);
 74:   if (flg) {
 75:     PetscStrcpy(file[1],file[0]);
 76:     preload = PETSC_FALSE;
 77:   } else {
 78:     PetscOptionsGetString(NULL,NULL,"-f0",file[0],PETSC_MAX_PATH_LEN,&flg);
 79:     if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate binary file with the -f0 or -f option");
 80:     PetscOptionsGetString(NULL,NULL,"-f1",file[1],PETSC_MAX_PATH_LEN,&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],PETSC_MAX_PATH_LEN,&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: ./ex10 -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:     PetscBool lsqr;
278:     char      str[32];
279:     PetscOptionsGetString(NULL,NULL,"-ksp_type",str,32,&lsqr);
280:     if (lsqr) {
281:       PetscStrcmp("lsqr",str,&lsqr);
282:     }
283:     if (lsqr) {
284:       Mat BtB;
285:       MatTransposeMatMult(A,A,MAT_INITIAL_MATRIX,4,&BtB);
286:       KSPSetOperators(ksp,A,BtB);
287:       MatDestroy(&BtB);
288:     } else {
289:       KSPSetOperators(ksp,A,A);
290:     }
291:     KSPSetFromOptions(ksp);

293:     /*
294:      Here we explicitly call KSPSetUp() and KSPSetUpOnBlocks() to
295:      enable more precise profiling of setting up the preconditioner.
296:      These calls are optional, since both will be called within
297:      KSPSolve() if they haven't been called already.
298:     */
299:     KSPSetUp(ksp);
300:     KSPSetUpOnBlocks(ksp);

302:     /* - - - - - - - - - - - New Stage - - - - - - - - - - - - -
303:                          Solve system
304:       - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

306:     /*
307:      Solve linear system;
308:     */
309:     if (trans) {
310:       KSPSolveTranspose(ksp,b,x);
311:       KSPGetIterationNumber(ksp,&its);
312:     } else {
313:       PetscInt num_rhs=1;
314:       PetscOptionsGetInt(NULL,NULL,"-num_rhs",&num_rhs,NULL);
315:       cknorm = PETSC_FALSE;
316:       PetscOptionsGetBool(NULL,NULL,"-cknorm",&cknorm,NULL);
317:       while (num_rhs--) {
318:         if (num_rhs == 1) VecSet(x,0.0);
319:         KSPSolve(ksp,b,x);
320:       }
321:       KSPGetIterationNumber(ksp,&its);
322:       if (cknorm) {     /* Check error for each rhs */
323:         if (trans) {
324:           MatMultTranspose(A,x,u);
325:         } else {
326:           MatMult(A,x,u);
327:         }
328:         VecAXPY(u,-1.0,b);
329:         VecNorm(u,NORM_2,&norm);
330:         PetscPrintf(PETSC_COMM_WORLD,"  Number of iterations = %3D\n",its);
331:         if (!PetscIsNanScalar(norm)) {
332:           if (norm < 1.e-12) {
333:             PetscPrintf(PETSC_COMM_WORLD,"  Residual norm < 1.e-12\n");
334:           } else {
335:             PetscPrintf(PETSC_COMM_WORLD,"  Residual norm %g\n",(double)norm);
336:           }
337:         }
338:       }
339:     }   /* while (num_rhs--) */

341:     /* - - - - - - - - - - - New Stage - - - - - - - - - - - - -
342:           Check error, print output, free data structures.
343:      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

345:     /*
346:        Check error
347:     */
348:     if (trans) {
349:       MatMultTranspose(A,x,u);
350:     } else {
351:       MatMult(A,x,u);
352:     }
353:     VecAXPY(u,-1.0,b);
354:     VecNorm(u,NORM_2,&norm);
355:     /*
356:      Write output (optinally using table for solver details).
357:       - PetscPrintf() handles output for multiprocessor jobs
358:         by printing from only one processor in the communicator.
359:       - KSPView() prints information about the linear solver.
360:     */
361:     if (table) {
362:       char        *matrixname,kspinfo[120];

364:       /*
365:        Open a string viewer; then write info to it.
366:       */
367:       PetscViewerStringOpen(PETSC_COMM_WORLD,kspinfo,120,&viewer);
368:       KSPView(ksp,viewer);
369:       PetscStrrchr(file[PetscPreLoadIt],'/',&matrixname);
370:       PetscPrintf(PETSC_COMM_WORLD,"%-8.8s %3D %2.0e %s \n",matrixname,its,norm,kspinfo);

372:       /*
373:         Destroy the viewer
374:       */
375:       PetscViewerDestroy(&viewer);
376:     } else {
377:       PetscPrintf(PETSC_COMM_WORLD,"Number of iterations = %3D\n",its);
378:       if (!PetscIsNanScalar(norm)) {
379:         if (norm < 1.e-12 && !PetscIsNanScalar((PetscScalar)norm)) {
380:           PetscPrintf(PETSC_COMM_WORLD,"  Residual norm < 1.e-12\n");
381:         } else {
382:           PetscPrintf(PETSC_COMM_WORLD,"Residual norm %g\n",(double)norm);
383:         }
384:       }
385:     }
386:     PetscOptionsGetString(NULL,NULL,"-solution",file[3],PETSC_MAX_PATH_LEN,&flg);
387:     if (flg) {
388:       Vec         xstar;
389:       PetscReal   norm;

391:       PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[3],FILE_MODE_READ,&viewer);
392:       VecCreate(PETSC_COMM_WORLD,&xstar);
393:       VecLoad(xstar,viewer);
394:       VecAXPY(xstar, -1.0, x);
395:       VecNorm(xstar, NORM_2, &norm);
396:       PetscPrintf(PETSC_COMM_WORLD, "Error norm %g\n", (double)norm);
397:       VecDestroy(&xstar);
398:       PetscViewerDestroy(&viewer);
399:     }
400:     if (outputSoln) {
401:       PetscViewerBinaryOpen(PETSC_COMM_WORLD,"solution.petsc",FILE_MODE_WRITE,&viewer);
402:       VecView(x, viewer);
403:       PetscViewerDestroy(&viewer);
404:     }

406:     flg  = PETSC_FALSE;
407:     PetscOptionsGetBool(NULL,NULL, "-ksp_reason", &flg,NULL);
408:     if (flg) {
409:       KSPConvergedReason reason;
410:       KSPGetConvergedReason(ksp,&reason);
411:       PetscPrintf(PETSC_COMM_WORLD,"KSPConvergedReason: %D\n", reason);
412:     }

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

416:   /*
417:      Free work space.  All PETSc objects should be destroyed when they
418:      are no longer needed.
419:   */
420:   MatDestroy(&A); VecDestroy(&b);
421:   VecDestroy(&u); VecDestroy(&x);
422:   KSPDestroy(&ksp);
423:   PetscPreLoadEnd();
424:   /* -----------------------------------------------------------
425:                       End of linear solver loop
426:      ----------------------------------------------------------- */

428:   PetscFinalize();
429:   return ierr;
430: }


433: /*TEST

435:    build:
436:       requires: !complex

438:    testset:
439:       suffix: 1
440:       nsize: 2
441:       args: -f0 ${wPETSC_DIR}/share/petsc/datafiles/matrices/spd-real-int@PETSC_INDEX_SIZE@-float@PETSC_SCALAR_SIZE@

443:    testset:
444:       suffix: 1a
445:       args: -f0 ${wPETSC_DIR}/share/petsc/datafiles/matrices/spd-real-int@PETSC_INDEX_SIZE@-float@PETSC_SCALAR_SIZE@

447:    testset:
448:       nsize: 2
449:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
450:       args: -f0 ${DATAFILESPATH}/matrices/medium
451:       args:  -ksp_type bicg
452:       test:
453:          suffix: 2
454:       test:
455:          suffix: 3
456:          args: -pc_type asm

458:    testset:
459:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
460:       args: -f0 ${DATAFILESPATH}/matrices/medium
461:       args: -ksp_type bicg
462:       test:
463:          suffix: 4
464:          args: -pc_type lu
465:       test:
466:          suffix: 5

468:    testset:
469:       suffix: 6
470:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
471:       args: -f0 ${DATAFILESPATH}/matrices/fem1
472:       args: -pc_factor_levels 2 -pc_factor_fill 1.73 -ksp_gmres_cgs_refinement_type refine_always

474:    testset:
475:       suffix: 7
476:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
477:       args: -f0 ${DATAFILESPATH}/matrices/medium
478:       args: -viewer_binary_skip_info -mat_type seqbaij
479:       args: -matload_block_size {{2 3 4 5 6 7 8}separate output}
480:       args: -ksp_max_it 100 -ksp_gmres_cgs_refinement_type refine_always
481:       args: -ksp_rtol 1.0e-15 -ksp_monitor_short
482:       test:
483:          suffix: a
484:       test:
485:          suffix: b
486:          args: -pc_factor_mat_ordering_type nd
487:       test:
488:          suffix: c
489:          args: -pc_factor_levels 1

491:    testset:
492:       suffix: 7_d
493:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
494:       args: -f0 ${DATAFILESPATH}/matrices/medium
495:       args: -viewer_binary_skip_info -mat_type seqbaij
496:       args: -matload_block_size {{2 3 4 5 6 7 8}shared output}
497:       args: -ksp_type preonly -pc_type lu

499:    testset:
500:       suffix: 8
501:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
502:       args: -f0 ${DATAFILESPATH}/matrices/medium
503:       args: -ksp_diagonal_scale -pc_type eisenstat -ksp_monitor_short -ksp_diagonal_scale_fix -ksp_gmres_cgs_refinement_type refine_always -mat_no_inode

505:    testset:
506:       suffix: 9
507:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
508:       args: -f0 ${DATAFILESPATH}/matrices/medium
509:       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
510:       test:
511:          suffix: a
512:          args: -mat_type seqbaij
513:       test:
514:          suffix: b
515:          args: -mat_type seqbaij -trans
516:       test:
517:          suffix: c
518:          nsize: 2
519:          args: -mat_type mpibaij
520:       test:
521:          suffix: d
522:          nsize: 2
523:          args: -mat_type mpibaij -trans
524:       test:
525:          suffix: e
526:          nsize: 3
527:          args: -mat_type mpibaij
528:       test:
529:          suffix: f
530:          nsize: 3
531:          args: -mat_type mpibaij -trans


534:    testset:
535:       suffix: 10
536:       nsize: 2
537:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
538:       args: -ksp_type fgmres -pc_type ksp -f0 ${DATAFILESPATH}/matrices/medium -ksp_fgmres_modifypcksp -ksp_monitor_short

540:    testset:
541:       TODO: Need to determine goal of this test
542:       suffix: 11
543:       nsize: 2
544:       args: -f0 http://ftp.mcs.anl.gov/pub/petsc/matrices/testmatrix.gz

546:    testset:
547:       suffix: 12
548:       requires: matlab
549:       args: -pc_type lu -pc_factor_mat_solver_package matlab -f0 ${DATAFILESPATH}/matrices/arco1

551:    testset:
552:       suffix: 13
553:       requires: lusol
554:       args: -f0 ${DATAFILESPATH}/matrices/arco1
555:       args: -mat_type lusol -pc_type lu

557:    testset:
558:       nsize: 3
559:       args: -f0 ${DATAFILESPATH}/matrices/medium
560:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
561:       test:
562:          suffix: 14
563:          requires: spai
564:          args: -pc_type spai
565:       test:
566:          suffix: 15
567:          requires: hypre
568:          args: -pc_type hypre -pc_hypre_type pilut
569:       test:
570:          suffix: 16
571:          requires: hypre
572:          args: -pc_type hypre -pc_hypre_type parasails
573:       test:
574:          suffix: 17
575:          requires: hypre
576:          args: -pc_type hypre -pc_hypre_type boomeramg

578:    testset:
579:       suffix: 19
580:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
581:       args: -f0 ${DATAFILESPATH}/matrices/poisson1
582:       args: -ksp_type cg -pc_type icc
583:       args: -pc_factor_levels {{0 2 4}separate output}
584:       test:
585:       test:
586:          args: -mat_type seqsbaij


589:    testset:
590:       suffix: ILU
591:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
592:       args: -f0 ${DATAFILESPATH}/matrices/small
593:       args: -pc_factor_levels 1
594:       test:
595:       test:
596:          # This is tested against regular ILU (used to be denoted ILUBAIJ)
597:          args: -mat_type baij

599:    testset:
600:       suffix: aijcusparse
601:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) cusparse
602:       args: -f0 ${DATAFILESPATH}/matrices/medium -ksp_monitor_short -ksp_view -mat_view ascii::ascii_info -mat_type aijcusparse -pc_factor_mat_solver_package cusparse -pc_type ilu

604:    testset:
605:       TODO: No output file. Need to determine if deprecated
606:       suffix: asm_viennacl
607:       nsize: 2
608:       requires: viennacl
609:       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}

611:    testset:
612:       nsize: 2
613:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) hypre
614:       args: -f0 ${DATAFILESPATH}/matrices/poisson2.gz -ksp_monitor_short -ksp_rtol 1.E-9 -pc_type hypre -pc_hypre_type boomeramg
615:       test:
616:          suffix: boomeramg_euclid
617:          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
618:          TODO: Need to determine if deprecated
619:       test:
620:          suffix: boomeramg_euclid_bj
621:          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
622:          TODO: Need to determine if deprecated
623:       test:
624:          suffix: boomeramg_parasails
625:          args: -pc_hypre_boomeramg_smooth_type ParaSails -pc_hypre_boomeramg_smooth_num_levels 2
626:       test:
627:          suffix: boomeramg_pilut
628:          args: -pc_hypre_boomeramg_smooth_type Pilut -pc_hypre_boomeramg_smooth_num_levels 2
629:       test:
630:          suffix: boomeramg_schwarz
631:          args: -pc_hypre_boomeramg_smooth_type Schwarz-smoothers

633:    testset:
634:       suffix: cg_singlereduction
635:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
636:       args: -f0 ${DATAFILESPATH}/matrices/small
637:       args: -mat_type mpisbaij -ksp_type cg -pc_type eisenstat -ksp_monitor_short -ksp_converged_reason
638:       test:
639:       test:
640:          args: -ksp_cg_single_reduction

642:    testset:
643:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
644:       args: -f0 ${DATAFILESPATH}/matrices/poisson2.gz
645:       args: -ksp_monitor_short -pc_type icc
646:       test:
647:          suffix: cr
648:          args: -ksp_type cr
649:       test:
650:          suffix: lcd
651:          args: -ksp_type lcd

653:    testset:
654:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
655:       args: -f0 ${DATAFILESPATH}/matrices/small
656:       args: -ksp_monitor_short -ksp_view -mat_view ascii::ascii_info
657:       test:
658:          suffix: seqaijcrl
659:          args: -mat_type seqaijcrl
660:       test:
661:          suffix: seqaijperm
662:          args: -mat_type seqaijperm

664:    testset:
665:       nsize: 2
666:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
667:       args: -f0 ${DATAFILESPATH}/matrices/small
668:       args: -ksp_monitor_short -ksp_view
669:       # Different output files
670:       test:
671:          suffix: mpiaijcrl
672:          args: -mat_type mpiaijcrl
673:       test:
674:          suffix: mpiaijperm
675:          args: -mat_type mpiaijperm

677:    testset:
678:       nsize: 8
679:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES)
680:       args: -ksp_monitor_short -ksp_view
681:       test:
682:          suffix: xxt
683:          args: -f0 ${DATAFILESPATH}/matrices/poisson1 -check_symmetry -ksp_type cg -pc_type tfs
684:       test:
685:          suffix: xyt
686:          args: -f0 ${DATAFILESPATH}/matrices/arco1 -ksp_type gmres -pc_type tfs

688:    testset:
689:       # The output file here is the same as mumps
690:       suffix: mumps_cholesky
691:       output_file: output/ex10_mumps.out
692:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps
693:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type cholesky -pc_factor_mat_solver_package mumps -num_numfac 2 -num_rhs 2
694:       nsize: {{1 2}}
695:       test:
696:          args: -mat_type sbaij -mat_ignore_lower_triangular
697:       test:
698:          args: -mat_type aij
699:       test:
700:          args: -mat_type aij -matload_spd

702:    testset:
703:       # The output file here is the same as mumps
704:       suffix: mumps_lu
705:       output_file: output/ex10_mumps.out
706:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps
707:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_package mumps -num_numfac 2 -num_rhs 2
708:       test:
709:          args: -mat_type seqaij
710:       test:
711:          nsize: 2
712:          args: -mat_type mpiaij
713:       test:
714:          args: -mat_type seqbaij -matload_block_size 2
715:       test:
716:          nsize: 2
717:          args: -mat_type mpibaij -matload_block_size 2
718:       test:
719:          args: -mat_type aij -mat_mumps_icntl_7 5
720:          TODO: Need to determine if deprecated
721:       test:
722:          nsize: 2
723:          args: -mat_type mpiaij -mat_mumps_icntl_28 2 -mat_mumps_icntl_29 2
724:          TODO: Need to determine if deprecated

726:    testset:
727:       # The output file here is the same as mumps
728:       suffix: mumps_redundant
729:       output_file: output/ex10_mumps_redundant.out
730:       nsize: 8
731:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps
732:       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_package mumps -num_numfac 2 -num_rhs 2

734:    testset:
735:       suffix: pastix_cholesky
736:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) pastix
737:       output_file: output/ex10_mumps.out
738:       nsize: {{1 2}}
739:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_factor_mat_solver_package pastix -num_numfac 2 -num_rhs 2 -pc_type cholesky -mat_type sbaij -mat_ignore_lower_triangular

741:    testset:
742:       suffix: pastix_lu
743:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) pastix
744:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_package pastix -num_numfac 2 -num_rhs 2
745:       output_file: output/ex10_mumps.out
746:       test:
747:          args: -mat_type seqaij
748:       test:
749:          nsize: 2
750:          args: -mat_type mpiaij

752:    testset:
753:       suffix: pastix_redundant
754:       output_file: output/ex10_mumps_redundant.out
755:       nsize: 8
756:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) pastix
757:       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_package pastix -num_numfac 2 -num_rhs 2


760:    testset:
761:       suffix: superlu_dist_lu
762:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) superlu_dist
763:       output_file: output/ex10_mumps.out
764:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_package superlu_dist -num_numfac 2 -num_rhs 2
765:       nsize: {{1 2}}

767:    testset:
768:       suffix: superlu_dist_redundant
769:       nsize: 8
770:       output_file: output/ex10_mumps_redundant.out
771:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) superlu
772:       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_package superlu_dist -num_numfac 2 -num_rhs 2

774:    testset:
775:       suffix: superlu_lu
776:       output_file: output/ex10_mumps.out
777:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) superlu
778:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -pc_factor_mat_solver_package superlu -num_numfac 2 -num_rhs 2

780:    testset:
781:       suffix: umfpack
782:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) suitesparse
783:       args: -f0 ${DATAFILESPATH}/matrices/small -ksp_type preonly -pc_type lu -mat_type seqaij -pc_factor_mat_solver_package umfpack -num_numfac 2 -num_rhs 2


786:    testset:
787:       suffix: zeropivot
788:       requires: datafilespath double !define(PETSC_USE_64BIT_INDICES) mumps
789:       args: -f0 ${DATAFILESPATH}/matrices/small -test_zeropivot -ksp_converged_reason -ksp_type fgmres -pc_type ksp
790:       test:
791:          nsize: 3
792:          args: -ksp_pc_type bjacobi
793:       test:
794:          nsize: 2
795:          args: -ksp_ksp_type cg -ksp_pc_type bjacobi -ksp_pc_bjacobi_blocks 1
796:       #test:
797:          #nsize: 3
798:          #args: -ksp_ksp_converged_reason -ksp_pc_type bjacobi -ksp_sub_ksp_converged_reason
799:          #TODO: Need to determine if deprecated
800: TEST*/