Actual source code: ex94.c

petsc-3.7.0 2016-04-25
Report Typos and Errors
  2: static char help[] = "Tests sequential and parallel MatMatMult() and MatPtAP(), MatTransposeMatMult(), sequential MatMatTransposeMult(), MatRARt()\n\
  3: Input arguments are:\n\
  4:   -f0 <input_file> -f1 <input_file> -f2 <input_file> -f3 <input_file> : file to load\n\n";
  5: /* Example of usage:
  6:    ./ex94 -f0 <A_binary> -f1 <B_binary> -matmatmult_mat_view ::ascii_info -matmatmulttr_mat_view
  7:    mpiexec -n 3 ./ex94 -f0 medium -f1 medium -f2 arco1 -f3 arco1 -matmatmult_mat_view
  8: */

 10: #include <petscmat.h>

 14: int main(int argc,char **args)
 15: {
 16:   Mat            A,A_save,B,P,R,C,C1;
 17:   Vec            x,v1,v2,v3,v4;
 18:   PetscViewer    viewer;
 20:   PetscMPIInt    size,rank;
 21:   PetscInt       i,m,n,j,*idxn,M,N,nzp,rstart,rend;
 22:   PetscReal      norm,norm_abs,norm_tmp,tol=1.e-8,fill=4.0;
 23:   PetscRandom    rdm;
 24:   char           file[4][128];
 25:   PetscBool      flg,preload = PETSC_TRUE;
 26:   PetscScalar    *a,rval,alpha,none = -1.0;
 27:   PetscBool      Test_MatMatMult=PETSC_TRUE,Test_MatMatTr=PETSC_TRUE,Test_MatPtAP=PETSC_TRUE,Test_MatRARt=PETSC_TRUE,Test_MatMatMatMult=PETSC_TRUE;
 28:   PetscBool      Test_MatAXPY=PETSC_FALSE;
 29:   PetscInt       pm,pn,pM,pN;
 30:   MatInfo        info;

 32:   PetscInitialize(&argc,&args,(char*)0,help);
 33:   MPI_Comm_size(PETSC_COMM_WORLD,&size);
 34:   MPI_Comm_rank(PETSC_COMM_WORLD,&rank);

 36:   PetscOptionsGetReal(NULL,NULL,"-fill",&fill,NULL);

 38:   /*  Load the matrices A_save and B */
 39:   PetscOptionsGetString(NULL,NULL,"-f0",file[0],128,&flg);
 40:   if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate a file name for small matrix A with the -f0 option.");
 41:   PetscOptionsGetString(NULL,NULL,"-f1",file[1],128,&flg);
 42:   if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate a file name for small matrix B with the -f1 option.");
 43:   PetscOptionsGetString(NULL,NULL,"-f2",file[2],128,&flg);
 44:   if (!flg) {
 45:     preload = PETSC_FALSE;
 46:   } else {
 47:     PetscOptionsGetString(NULL,NULL,"-f3",file[3],128,&flg);
 48:     if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate a file name for test matrix B with the -f3 option.");
 49:   }

 51:   PetscPreLoadBegin(preload,"Load system");
 52:   PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[2*PetscPreLoadIt],FILE_MODE_READ,&viewer);
 53:   MatCreate(PETSC_COMM_WORLD,&A_save);
 54:   MatSetFromOptions(A_save);
 55:   MatLoad(A_save,viewer);
 56:   PetscViewerDestroy(&viewer);

 58:   PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[2*PetscPreLoadIt+1],FILE_MODE_READ,&viewer);
 59:   MatCreate(PETSC_COMM_WORLD,&B);
 60:   MatSetFromOptions(B);
 61:   MatLoad(B,viewer);
 62:   PetscViewerDestroy(&viewer);

 64:   MatGetSize(B,&M,&N);
 65:   nzp  = PetscMax((PetscInt)(0.1*M),5);
 66:   PetscMalloc((nzp+1)*(sizeof(PetscInt)+sizeof(PetscScalar)),&idxn);
 67:   a    = (PetscScalar*)(idxn + nzp);

 69:   /* Create vectors v1 and v2 that are compatible with A_save */
 70:   VecCreate(PETSC_COMM_WORLD,&v1);
 71:   MatGetLocalSize(A_save,&m,NULL);
 72:   VecSetSizes(v1,m,PETSC_DECIDE);
 73:   VecSetFromOptions(v1);
 74:   VecDuplicate(v1,&v2);

 76:   PetscRandomCreate(PETSC_COMM_WORLD,&rdm);
 77:   PetscRandomSetFromOptions(rdm);
 78:   PetscOptionsGetReal(NULL,NULL,"-fill",&fill,NULL);

 80:   /* Test MatAXPY()    */
 81:   /*-------------------*/
 82:   PetscOptionsHasName(NULL,NULL,"-test_MatAXPY",&Test_MatAXPY);
 83:   if (Test_MatAXPY) {
 84:     Mat Btmp;
 85:     /* if (!rank) printf(" Loading matrices is done...\n"); */
 86:     MatDuplicate(A_save,MAT_COPY_VALUES,&A);
 87:     MatDuplicate(B,MAT_COPY_VALUES,&Btmp);
 88:     MatAXPY(A,-1.0,B,DIFFERENT_NONZERO_PATTERN); /* A = -B + A_save */

 90:     /* if (!rank) printf(" Test_MatAXPY is done, now checking accuracy ...\n"); */
 91:     MatScale(A,-1.0); /* A = -A = B - A_save */
 92:     MatAXPY(Btmp,-1.0,A,DIFFERENT_NONZERO_PATTERN); /* Btmp = -A + B = A_save */
 93:     MatMultEqual(A_save,Btmp,10,&flg);
 94:     if (!flg) SETERRQ(PETSC_COMM_SELF,0,"MatAXPY() is incorrect\n");
 95:     MatDestroy(&A);
 96:     MatDestroy(&Btmp);

 98:     Test_MatMatMult    = PETSC_FALSE;
 99:     Test_MatMatTr      = PETSC_FALSE;
100:     Test_MatPtAP       = PETSC_FALSE;
101:     Test_MatRARt       = PETSC_FALSE;
102:     Test_MatMatMatMult = PETSC_FALSE;
103:   }

105:   /* Test MatMatMult() */
106:   /*-------------------*/
107:   if (Test_MatMatMult) {
108:     MatDuplicate(A_save,MAT_COPY_VALUES,&A);
109:     MatMatMult(A,B,MAT_INITIAL_MATRIX,fill,&C);
110:     MatSetOptionsPrefix(C,"matmatmult_"); /* enable option '-matmatmult_' for matrix C */
111:     MatGetInfo(C,MAT_GLOBAL_SUM,&info);
112:     /* PetscPrintf(PETSC_COMM_WORLD,"MatMatMult: nz_allocated = %g; nz_used = %g; nz_unneeded = %g\n",info.nz_allocated,info.nz_used, info.nz_unneeded); */

114:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
115:     alpha=1.0;
116:     for (i=0; i<2; i++) {
117:       alpha -=0.1;
118:       MatScale(A,alpha);
119:       MatMatMult(A,B,MAT_REUSE_MATRIX,fill,&C);
120:     }
121:     MatMatMultEqual(A,B,C,10,&flg);
122:     if (!flg) {
123:       PetscPrintf(PETSC_COMM_SELF,"Error: MatMatMult()\n");
124:     }
125:     MatDestroy(&A);

127:     /* Test MatDuplicate() of C */
128:     MatDuplicate(C,MAT_COPY_VALUES,&C1);
129:     MatDestroy(&C1);
130:     MatDestroy(&C);
131:   } /* if (Test_MatMatMult) */

133:   /* Test MatTransposeMatMult() and MatMatTransposeMult() */
134:   /*------------------------------------------------------*/
135:   if (Test_MatMatTr) {
136:     /* Create P */
137:     PetscInt PN,rstart,rend;
138:     PN   = M/2;
139:     nzp  = 5; /* num of nonzeros in each row of P */
140:     MatCreate(PETSC_COMM_WORLD,&P);
141:     MatSetSizes(P,PETSC_DECIDE,PETSC_DECIDE,M,PN);
142:     MatSetType(P,MATAIJ);
143:     MatSeqAIJSetPreallocation(P,nzp,NULL);
144:     MatMPIAIJSetPreallocation(P,nzp,NULL,nzp,NULL);
145:     MatGetOwnershipRange(P,&rstart,&rend);
146:     for (i=0; i<nzp; i++) {
147:       PetscRandomGetValue(rdm,&a[i]);
148:     }
149:     for (i=rstart; i<rend; i++) {
150:       for (j=0; j<nzp; j++) {
151:         PetscRandomGetValue(rdm,&rval);
152:         idxn[j] = (PetscInt)(PetscRealPart(rval)*PN);
153:       }
154:       MatSetValues(P,1,&i,nzp,idxn,a,ADD_VALUES);
155:     }
156:     MatAssemblyBegin(P,MAT_FINAL_ASSEMBLY);
157:     MatAssemblyEnd(P,MAT_FINAL_ASSEMBLY);

159:     /* Create R = P^T */
160:     MatTranspose(P,MAT_INITIAL_MATRIX,&R);

162:     { /* Test R = P^T, C1 = R*B */
163:       MatMatMult(R,B,MAT_INITIAL_MATRIX,fill,&C1);
164:       MatTranspose(P,MAT_REUSE_MATRIX,&R);
165:       MatMatMult(R,B,MAT_REUSE_MATRIX,fill,&C1);
166:       MatDestroy(&C1);
167:     }

169:     /* C = P^T*B */
170:     MatTransposeMatMult(P,B,MAT_INITIAL_MATRIX,fill,&C);
171:     MatGetInfo(C,MAT_GLOBAL_SUM,&info);

173:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
174:     MatTransposeMatMult(P,B,MAT_REUSE_MATRIX,fill,&C);

176:     /* Compare P^T*B and R*B */
177:     MatMatMult(R,B,MAT_INITIAL_MATRIX,fill,&C1);
178:     MatEqual(C,C1,&flg);
179:     if (!flg) {
180:       /* Check norm of C1 = (-1.0)*C + C1 */
181:       PetscReal nrm;
182:       MatAXPY(C1,-1.0,C,DIFFERENT_NONZERO_PATTERN);
183:       MatNorm(C1,NORM_INFINITY,&nrm);
184:       if (nrm > 1.e-14) {
185:         PetscPrintf(PETSC_COMM_WORLD,"Error in MatTransposeMatMult(): %g\n",nrm);
186:       }
187:     }
188:     MatDestroy(&C1);
189:     MatDestroy(&C);

191:     /* C = B*R^T */
192:     if (size == 1) {
193:       MatMatTransposeMult(B,R,MAT_INITIAL_MATRIX,fill,&C);
194:       MatSetOptionsPrefix(C,"matmatmulttr_"); /* enable '-matmatmulttr_' for matrix C */
195:       MatGetInfo(C,MAT_GLOBAL_SUM,&info);

197:       /* Test MAT_REUSE_MATRIX - reuse symbolic C */
198:       MatMatTransposeMult(B,R,MAT_REUSE_MATRIX,fill,&C);

200:       /* Check */
201:       MatMatMult(B,P,MAT_INITIAL_MATRIX,fill,&C1);
202:       MatEqual(C,C1,&flg);
203:       if (!flg) {
204:         PetscPrintf(PETSC_COMM_WORLD,"Error in MatMatTransposeMult()\n");
205:       }
206:       MatDestroy(&C1);
207:       MatDestroy(&C);
208:     }
209:     MatDestroy(&P);
210:     MatDestroy(&R);
211:   }

213:   /* Test MatPtAP() */
214:   /*----------------------*/
215:   if (Test_MatPtAP) {
216:     PetscInt PN;
217:     Mat      Cdup;

219:     MatDuplicate(A_save,MAT_COPY_VALUES,&A);
220:     MatGetSize(A,&M,&N);
221:     MatGetLocalSize(A,&m,&n);
222:     /* PetscPrintf(PETSC_COMM_SELF,"[%d] A: %d,%d, %d,%d\n",rank,m,n,M,N); */

224:     PN   = M/2;
225:     nzp  = (PetscInt)(0.1*PN+1); /* num of nozeros in each row of P */
226:     MatCreate(PETSC_COMM_WORLD,&P);
227:     MatSetSizes(P,PETSC_DECIDE,PETSC_DECIDE,N,PN);
228:     MatSetType(P,MATAIJ);
229:     MatSeqAIJSetPreallocation(P,nzp,NULL);
230:     MatMPIAIJSetPreallocation(P,nzp,NULL,nzp,NULL);
231:     for (i=0; i<nzp; i++) {
232:       PetscRandomGetValue(rdm,&a[i]);
233:     }
234:     MatGetOwnershipRange(P,&rstart,&rend);
235:     for (i=rstart; i<rend; i++) {
236:       for (j=0; j<nzp; j++) {
237:         PetscRandomGetValue(rdm,&rval);
238:         idxn[j] = (PetscInt)(PetscRealPart(rval)*PN);
239:       }
240:       MatSetValues(P,1,&i,nzp,idxn,a,ADD_VALUES);
241:     }
242:     MatAssemblyBegin(P,MAT_FINAL_ASSEMBLY);
243:     MatAssemblyEnd(P,MAT_FINAL_ASSEMBLY);

245:     /* MatView(P,PETSC_VIEWER_STDOUT_WORLD); */
246:     MatGetSize(P,&pM,&pN);
247:     MatGetLocalSize(P,&pm,&pn);
248:     MatPtAP(A,P,MAT_INITIAL_MATRIX,fill,&C);
249:     /* if (!rank) {PetscPrintf(PETSC_COMM_SELF," MatPtAP() is done, P, %d, %d, %d,%d\n",pm,pn,pM,pN);} */

251:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
252:     alpha=1.0;
253:     for (i=0; i<2; i++) {
254:       alpha -=0.1;
255:       MatScale(A,alpha);
256:       MatPtAP(A,P,MAT_REUSE_MATRIX,fill,&C);
257:     }

259:     /* Test PtAP ops with P SeqDense and A either SeqAIJ or SeqDense (it assumes MatPtAP_SeqAIJ_SeqAIJ is fine) */
260:     if (size == 1) {
261:       Mat       Cdensetest,Pdense,Cdense,Adense;
262:       PetscReal norm;

264:       MatConvert(C,MATSEQDENSE,MAT_INITIAL_MATRIX,&Cdensetest);
265:       MatConvert(P,MATSEQDENSE,MAT_INITIAL_MATRIX,&Pdense);

267:       /* test with A SeqAIJ */
268:       MatPtAP(A,Pdense,MAT_INITIAL_MATRIX,fill,&Cdense);
269:       MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
270:       MatNorm(Cdense,NORM_FROBENIUS,&norm);
271:       if (norm > PETSC_SMALL) {
272:         PetscPrintf(PETSC_COMM_SELF,"Error in MatPtAP with A SeqAIJ and P SeqDense: %g\n",norm);
273:       }
274:       MatScale(Cdense,-1.);
275:       MatPtAP(A,Pdense,MAT_REUSE_MATRIX,fill,&Cdense);
276:       MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
277:       MatNorm(Cdense,NORM_FROBENIUS,&norm);
278:       if (norm > PETSC_SMALL) {
279:         PetscPrintf(PETSC_COMM_SELF,"Error in MatPtAP with A SeqAIJ and P SeqDense and MAT_REUSE_MATRIX: %g\n",norm);
280:       }
281:       MatDestroy(&Cdense);

283:       /* test with A SeqDense */
284:       MatConvert(A,MATSEQDENSE,MAT_INITIAL_MATRIX,&Adense);
285:       MatPtAP(Adense,Pdense,MAT_INITIAL_MATRIX,fill,&Cdense);
286:       MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
287:       MatNorm(Cdense,NORM_FROBENIUS,&norm);
288:       if (norm > PETSC_SMALL) {
289:         PetscPrintf(PETSC_COMM_SELF,"Error in MatPtAP with A SeqDense and P SeqDense: %g\n",norm);
290:       }
291:       MatScale(Cdense,-1.);
292:       MatPtAP(Adense,Pdense,MAT_REUSE_MATRIX,fill,&Cdense);
293:       MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
294:       MatNorm(Cdense,NORM_FROBENIUS,&norm);
295:       if (norm > PETSC_SMALL) {
296:         PetscPrintf(PETSC_COMM_SELF,"Error in MatPtAP with A SeqDense and P SeqDense and MAT_REUSE_MATRIX: %g\n",norm);
297:       }
298:       MatDestroy(&Cdense);

300:       MatDestroy(&Cdensetest);
301:       MatDestroy(&Pdense);
302:       MatDestroy(&Adense);
303:     }

305:     /* Test MatDuplicate() */
306:     MatDuplicate(C,MAT_COPY_VALUES,&Cdup);
307:     MatDestroy(&Cdup);

309:     if (size>1) Test_MatRARt = PETSC_FALSE;
310:     /* Test MatRARt() */
311:     if (Test_MatRARt) {
312:       Mat       R, RARt;
313:       PetscBool equal;
314:       MatTranspose(P,MAT_INITIAL_MATRIX,&R);
315:       MatRARt(A,R,MAT_INITIAL_MATRIX,2.0,&RARt);
316:       MatEqual(C,RARt,&equal);
317:       if (!equal) {
318:         PetscReal norm;
319:         MatAXPY(RARt,-1.0,C,DIFFERENT_NONZERO_PATTERN); /* RARt = -RARt + C */
320:         MatNorm(RARt,NORM_FROBENIUS,&norm);
321:         if (norm > 1.e-12) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"|PtAP - RARt| = %g",norm);
322:       }
323:       MatDestroy(&R);
324:       MatDestroy(&RARt);
325:     }

327:     if (Test_MatMatMatMult && size == 1) {
328:       Mat       R, RAP;
329:       PetscBool equal;
330:       MatTranspose(P,MAT_INITIAL_MATRIX,&R);
331:       MatMatMatMult(R,A,P,MAT_INITIAL_MATRIX,2.0,&RAP);
332:       MatEqual(C,RAP,&equal);
333:       if (!equal) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"PtAP != RAP");
334:       MatDestroy(&R);
335:       MatDestroy(&RAP);
336:     }

338:     /* Create vector x that is compatible with P */
339:     VecCreate(PETSC_COMM_WORLD,&x);
340:     MatGetLocalSize(P,&m,&n);
341:     VecSetSizes(x,n,PETSC_DECIDE);
342:     VecSetFromOptions(x);

344:     VecCreate(PETSC_COMM_WORLD,&v3);
345:     VecSetSizes(v3,n,PETSC_DECIDE);
346:     VecSetFromOptions(v3);
347:     VecDuplicate(v3,&v4);

349:     norm = 0.0;
350:     for (i=0; i<10; i++) {
351:       VecSetRandom(x,rdm);
352:       MatMult(P,x,v1);
353:       MatMult(A,v1,v2);  /* v2 = A*P*x */

355:       MatMultTranspose(P,v2,v3); /* v3 = Pt*A*P*x */
356:       MatMult(C,x,v4);           /* v3 = C*x   */
357:       VecNorm(v4,NORM_2,&norm_abs);
358:       VecAXPY(v4,none,v3);
359:       VecNorm(v4,NORM_2,&norm_tmp);

361:       norm_tmp /= norm_abs;
362:       if (norm_tmp > norm) norm = norm_tmp;
363:     }
364:     if (norm >= tol) {
365:       PetscPrintf(PETSC_COMM_SELF,"Error: MatPtAP(), |v1 - v2|: %g\n",(double)norm);
366:     }

368:     MatDestroy(&A);
369:     MatDestroy(&P);
370:     MatDestroy(&C);
371:     VecDestroy(&v3);
372:     VecDestroy(&v4);
373:     VecDestroy(&x);
374:   }

376:   /* Destroy objects */
377:   VecDestroy(&v1);
378:   VecDestroy(&v2);
379:   PetscRandomDestroy(&rdm);
380:   PetscFree(idxn);

382:   MatDestroy(&A_save);
383:   MatDestroy(&B);

385:   PetscPreLoadEnd();
386:   PetscFinalize();
387:   return 0;
388: }