Actual source code: ex225.c


  2: static char help[] = "Test Hypre matrix APIs\n";

  4: #include <petscmathypre.h>

  6: int main(int argc,char **args)
  7: {
  8:   Mat            A, B, C;
  9:   PetscReal      err;
 10:   PetscInt       i,j,M = 20;
 11:   PetscMPIInt    NP;
 12:   MPI_Comm       comm;
 13:   PetscInt       *rows;

 15:   PetscInitialize(&argc,&args,(char*)0,help);
 16:   comm = PETSC_COMM_WORLD;
 17:   MPI_Comm_size(comm,&NP);
 18:   PetscOptionsGetInt(NULL,NULL,"-M",&M,NULL);
 20:   /* Hypre matrix */
 21:   MatCreate(comm,&B);
 22:   MatSetSizes(B,PETSC_DECIDE,PETSC_DECIDE,M,M);
 23:   MatSetType(B,MATHYPRE);
 24:   MatHYPRESetPreallocation(B,9,NULL,9,NULL);

 26:   /* PETSc AIJ matrix */
 27:   MatCreate(comm,&A);
 28:   MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,M,M);
 29:   MatSetType(A,MATAIJ);
 30:   MatSeqAIJSetPreallocation(A,9,NULL);
 31:   MatMPIAIJSetPreallocation(A,9,NULL,9,NULL);

 33:   /*Set Values */
 34:   for (i=0; i<M; i++) {
 35:     PetscInt    cols[] = {0,1,2,3,4,5};
 36:     PetscScalar vals[6] = {0};
 37:     PetscScalar value[] = {100};
 38:     for (j=0; j<6; j++)
 39:       vals[j] = ((PetscReal)j)/NP;

 41:     MatSetValues(B,1,&i,6,cols,vals,ADD_VALUES);
 42:     MatSetValues(B,1,&i,1,&i,value,ADD_VALUES);
 43:     MatSetValues(A,1,&i,6,cols,vals,ADD_VALUES);
 44:     MatSetValues(A,1,&i,1,&i,value,ADD_VALUES);
 45:   }

 47:   /* MAT_FLUSH_ASSEMBLY currently not supported */
 48:   MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);
 49:   MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);
 50:   MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);
 51:   MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);

 53:   /* Compare A and B */
 54:   MatConvert(B,MATAIJ,MAT_INITIAL_MATRIX,&C);
 55:   MatAXPY(C,-1.,A,SAME_NONZERO_PATTERN);
 56:   MatNorm(C,NORM_INFINITY,&err);
 58:   MatDestroy(&C);

 60:   /* MatZeroRows */
 61:   PetscMalloc1(M, &rows);
 62:   for (i=0; i<M; i++) rows[i] = i;
 63:   MatZeroRows(B, M, rows, 10.0, NULL, NULL);
 64:   MatSetOption(A, MAT_KEEP_NONZERO_PATTERN, PETSC_TRUE);
 65:   MatZeroRows(A, M, rows, 10.0,NULL, NULL);
 66:   MatConvert(B,MATAIJ,MAT_INITIAL_MATRIX,&C);
 67:   MatAXPY(C,-1.,A,SAME_NONZERO_PATTERN);
 68:   MatNorm(C,NORM_INFINITY,&err);
 70:   MatDestroy(&C);
 71:   PetscFree(rows);

 73:   /* Test MatZeroEntries */
 74:   MatZeroEntries(B);
 75:   MatConvert(B,MATAIJ,MAT_INITIAL_MATRIX,&C);
 76:   MatNorm(C,NORM_INFINITY,&err);
 78:   MatDestroy(&C);

 80:   /* Insert Values */
 81:   for (i=0; i<M; i++) {
 82:     PetscInt    cols[] = {0,1,2,3,4,5};
 83:     PetscScalar vals[6] = {0};
 84:     PetscScalar value[] = {100};

 86:     for (j=0; j<6; j++)
 87:       vals[j] = ((PetscReal)j)/NP;

 89:     MatSetValues(B,1,&i,6,cols,vals,INSERT_VALUES);
 90:     MatSetValues(B,1,&i,1,&i,value,INSERT_VALUES);
 91:     MatSetValues(A,1,&i,6,cols,vals,INSERT_VALUES);
 92:     MatSetValues(A,1,&i,1,&i,value,INSERT_VALUES);
 93:   }

 95:   /* MAT_FLUSH_ASSEMBLY currently not supported */
 96:   MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);
 97:   MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);
 98:   MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);
 99:   MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);

101:   /* Rows are not sorted with HYPRE so we need an intermediate sort
102:      They use a temporary buffer, so we can sort inplace the const memory */
103:   {
104:     const PetscInt    *idxA,*idxB;
105:     const PetscScalar *vA, *vB;
106:     PetscInt          rstart, rend, nzA, nzB;
107:     PetscInt          cols[] = {0,1,2,3,4,-5};
108:     PetscInt          *rows;
109:     PetscScalar       *valuesA, *valuesB;
110:     PetscBool         flg;

112:     MatGetOwnershipRange(A,&rstart,&rend);
113:     for (i=rstart; i<rend; i++) {
114:       MatGetRow(A,i,&nzA,&idxA,&vA);
115:       MatGetRow(B,i,&nzB,&idxB,&vB);
117:       PetscSortIntWithScalarArray(nzB,(PetscInt*)idxB,(PetscScalar*)vB);
118:       PetscArraycmp(idxA,idxB,nzA,&flg);
120:       PetscArraycmp(vA,vB,nzA,&flg);
122:       MatRestoreRow(A,i,&nzA,&idxA,&vA);
123:       MatRestoreRow(B,i,&nzB,&idxB,&vB);
124:     }

126:     MatGetOwnershipRange(A,&rstart,&rend);
127:     PetscCalloc3((rend-rstart)*6,&valuesA,(rend-rstart)*6,&valuesB,rend-rstart,&rows);
128:     for (i=rstart; i<rend; i++) rows[i-rstart] =i;

130:     MatGetValues(A,rend-rstart,rows,6,cols,valuesA);
131:     MatGetValues(B,rend-rstart,rows,6,cols,valuesB);

133:     for (i=0; i<(rend-rstart); i++) {
134:       PetscArraycmp(valuesA + 6*i,valuesB + 6*i,6,&flg);
136:     }
137:     PetscFree3(valuesA,valuesB,rows);
138:   }

140:   /* Compare A and B */
141:   MatConvert(B,MATAIJ,MAT_INITIAL_MATRIX,&C);
142:   MatAXPY(C,-1.,A,SAME_NONZERO_PATTERN);
143:   MatNorm(C,NORM_INFINITY,&err);

146:   MatDestroy(&A);
147:   MatDestroy(&B);
148:   MatDestroy(&C);

150:   PetscFinalize();
151:   return 0;
152: }

154: /*TEST

156:    build:
157:       requires: hypre

159:    test:
160:       suffix: 1
161:       requires: !defined(PETSC_HAVE_HYPRE_DEVICE)

163:    test:
164:       suffix: 2
165:       requires: !defined(PETSC_HAVE_HYPRE_DEVICE)
166:       output_file: output/ex225_1.out
167:       nsize: 2

169: TEST*/