Actual source code: ex2.c

petsc-3.13.4 2020-08-01
Report Typos and Errors
  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[3] = {0,0,0}, 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:   for (i = 0; i < 3; i++) {
 24:     ISCreateGeneral(PETSC_COMM_WORLD,n,ix[i][rank],PETSC_COPY_VALUES,&isx[i]);
 25:   }

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

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

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

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

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

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

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

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


 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:   }

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

123: /*TEST

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

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

152: TEST*/