Actual source code: ex2.c

  1: static char help[]= "Tests ISView() and ISLoad() \n\n";

  3: #include <petscis.h>
  4: #include <petscviewer.h>

  6: int main(int argc,char **argv)
  7: {
  8:   PetscErrorCode         ierr;
  9:   PetscInt               n = 3, *izero, j, i;
 10:   PetscInt               ix[3][3][3] = {{{3,5,4},{1,7,9},{0,2,8}},
 11:                                         {{0,2,8},{3,5,4},{1,7,9}},
 12:                                         {{1,7,9},{0,2,8},{3,5,4}}};
 13:   IS                     isx[3],il;
 14:   PetscMPIInt            size,rank;
 15:   PetscViewer            vx,vl;
 16:   PetscBool              equal;

 18:   PetscInitialize(&argc,&argv,NULL,help);if (ierr) return ierr;
 19:   MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
 20:   MPI_Comm_size(PETSC_COMM_WORLD,&size);
 21:   if (size > 3) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_ARG_SIZ,"Example only works with up to three processes");

 23:   PetscCalloc1(size*n,&izero);
 24:   for (i = 0; i < 3; i++) {
 25:     ISCreateGeneral(PETSC_COMM_WORLD,n,ix[i][rank],PETSC_COPY_VALUES,&isx[i]);
 26:   }

 28:   for (j = 0; j < 3; j++) {
 29:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,"testfile",FILE_MODE_WRITE,&vx);
 30:     ISView(isx[0],vx);
 31:     PetscViewerDestroy(&vx);

 33:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,"testfile",FILE_MODE_READ,&vl);
 34:     ISCreate(PETSC_COMM_WORLD,&il);
 35:     ISLoad(il,vl);
 36:     ISEqual(il,isx[0],&equal);
 37:     if (!equal) SETERRQ1(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Iteration %D - Index set loaded from file does not match",j);
 38:     ISDestroy(&il);
 39:     PetscViewerDestroy(&vl);

 41:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,"testfile",FILE_MODE_APPEND,&vx);
 42:     ISView(isx[1],vx);
 43:     ISView(isx[2],vx);
 44:     PetscViewerDestroy(&vx);

 46:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,"testfile",FILE_MODE_READ,&vl);
 47:     for (i = 0; i < 3; i++) {
 48:       ISCreate(PETSC_COMM_WORLD,&il);
 49:       ISLoad(il,vl);
 50:       ISEqual(il,isx[i],&equal);
 51:       if (!equal) SETERRQ2(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Iteration %D - Index set %D loaded from file does not match",j,i);
 52:       ISDestroy(&il);
 53:     }
 54:     PetscViewerDestroy(&vl);

 56:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,"testfile",FILE_MODE_READ,&vl);
 57:     for (i = 0; i < 3; i++) {
 58:       ISCreateGeneral(PETSC_COMM_WORLD,n,izero,PETSC_COPY_VALUES,&il);
 59:       ISLoad(il,vl);
 60:       ISEqual(il,isx[i],&equal);
 61:       if (!equal) SETERRQ2(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Iteration %D - Index set %D loaded from file does not match",j,i);
 62:       ISDestroy(&il);
 63:     }
 64:     PetscViewerDestroy(&vl);
 65:   }

 67:   for (j = 0; j < 3; j++) {
 68:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,"testfile_noheader",FILE_MODE_WRITE,&vx);
 69:     PetscViewerBinarySetSkipHeader(vx,PETSC_TRUE);
 70:     for (i = 0; i < 3; i++) {
 71:       ISView(isx[i],vx);
 72:     }
 73:     PetscViewerDestroy(&vx);

 75:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,"testfile_noheader",FILE_MODE_READ,&vl);
 76:     PetscViewerBinarySetSkipHeader(vl,PETSC_TRUE);
 77:     for (i = 0; i < 3; i++) {
 78:       ISCreateGeneral(PETSC_COMM_WORLD,n,izero,PETSC_COPY_VALUES,&il);
 79:       ISLoad(il,vl);
 80:       ISEqual(il,isx[i],&equal);
 81:       if (!equal) SETERRQ2(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Iteration %D - Index set %D loaded from file does not match",j,i);
 82:       ISDestroy(&il);
 83:     }
 84:     PetscViewerDestroy(&vl);
 85:   }

 87:   for (i = 0; i < 3; i++) {
 88:     ISDestroy(&isx[i]);
 89:   }

 91:   for (j = 0; j < 2; j++) {
 92:     const char *filename  = (j == 0) ? "testfile_isstride" : "testfile_isblock";
 93:     PetscInt    blocksize = (j == 0) ? 1 : size;
 94:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,filename,FILE_MODE_WRITE,&vx);
 95:     for (i = 0; i < 3; i++) {
 96:       if (j == 0) {
 97:         ISCreateStride(PETSC_COMM_WORLD,n,rank,rank+1,&isx[i]);
 98:       } else {
 99:         ISCreateBlock(PETSC_COMM_WORLD,blocksize,n,ix[i][rank],PETSC_COPY_VALUES,&isx[i]);
100:       }
101:       ISView(isx[i],vx);
102:       ISToGeneral(isx[i]);
103:     }
104:     PetscViewerDestroy(&vx);
105:     PetscViewerBinaryOpen(PETSC_COMM_WORLD,filename,FILE_MODE_READ,&vl);
106:     for (i = 0; i < 3; i++) {
107:       ISCreateGeneral(PETSC_COMM_WORLD,blocksize*n,izero,PETSC_COPY_VALUES,&il);
108:       ISLoad(il,vl);
109:       ISEqual(il,isx[i],&equal);
110:       if (!equal) SETERRQ2(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Iteration %D - Index set %D loaded from file does not match",j,i);
111:       ISDestroy(&il);
112:     }
113:     PetscViewerDestroy(&vl);
114:     for (i = 0; i < 3; i++) {
115:       ISDestroy(&isx[i]);
116:     }
117:   }
118:   PetscFree(izero);

120:   PetscFinalize();
121:   return ierr;
122: }

124: /*TEST

126:    testset:
127:       args: -viewer_binary_mpiio 0
128:       output_file: output/ex2_1.out
129:       test:
130:         suffix: stdio_1
131:         nsize: 1
132:       test:
133:         suffix: stdio_2
134:         nsize: 2
135:       test:
136:         suffix: stdio_3
137:         nsize: 3

139:    testset:
140:       requires: mpiio
141:       args: -viewer_binary_mpiio 1
142:       output_file: output/ex2_1.out
143:       test:
144:         suffix: mpiio_1
145:         nsize: 1
146:       test:
147:         suffix: mpiio_2
148:         nsize: 2
149:       test:
150:         suffix: mpiio_3
151:         nsize: 3

153: TEST*/