Actual source code: ex94.c
petsc-3.11.3 2019-06-26
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::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>
12: /*
13: B = A - B
14: norm = norm(B)
15: */
16: PetscErrorCode MatNormDifference(Mat A,Mat B,PetscReal *norm)
17: {
21: MatAXPY(B,-1.0,A,DIFFERENT_NONZERO_PATTERN);
22: MatNorm(B,NORM_FROBENIUS,norm);
23: return(0);
24: }
26: int main(int argc,char **args)
27: {
28: Mat A,A_save,B,P,R,C,C1;
29: Vec x,v1,v2,v3,v4;
30: PetscViewer viewer;
32: PetscMPIInt size,rank;
33: PetscInt i,m,n,j,*idxn,M,N,nzp,rstart,rend;
34: PetscReal norm,norm_abs,norm_tmp,fill=4.0;
35: PetscRandom rdm;
36: char file[4][128];
37: PetscBool flg,preload = PETSC_TRUE;
38: PetscScalar *a,rval,alpha,none = -1.0;
39: PetscBool Test_MatMatMult=PETSC_TRUE,Test_MatMatTr=PETSC_TRUE,Test_MatPtAP=PETSC_TRUE,Test_MatRARt=PETSC_TRUE,Test_MatMatMatMult=PETSC_TRUE;
40: PetscBool Test_MatAXPY=PETSC_FALSE;
41: PetscInt pm,pn,pM,pN;
42: MatInfo info;
43: PetscBool seqaij;
44: MatType mattype;
46: PetscInitialize(&argc,&args,(char*)0,help);if (ierr) return ierr;
47: MPI_Comm_size(PETSC_COMM_WORLD,&size);
48: MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
50: PetscOptionsGetReal(NULL,NULL,"-fill",&fill,NULL);
52: /* Load the matrices A_save and B */
53: PetscOptionsGetString(NULL,NULL,"-f0",file[0],sizeof(file[0]),&flg);
54: if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate a file name for small matrix A with the -f0 option.");
55: PetscOptionsGetString(NULL,NULL,"-f1",file[1],sizeof(file[1]),&flg);
56: if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate a file name for small matrix B with the -f1 option.");
57: PetscOptionsGetString(NULL,NULL,"-f2",file[2],sizeof(file[2]),&flg);
58: if (!flg) {
59: preload = PETSC_FALSE;
60: } else {
61: PetscOptionsGetString(NULL,NULL,"-f3",file[3],128,&flg);
62: if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate a file name for test matrix B with the -f3 option.");
63: }
65: PetscPreLoadBegin(preload,"Load system");
66: PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[2*PetscPreLoadIt],FILE_MODE_READ,&viewer);
67: MatCreate(PETSC_COMM_WORLD,&A_save);
68: MatSetFromOptions(A_save);
69: MatLoad(A_save,viewer);
70: PetscViewerDestroy(&viewer);
72: PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[2*PetscPreLoadIt+1],FILE_MODE_READ,&viewer);
73: MatCreate(PETSC_COMM_WORLD,&B);
74: MatSetFromOptions(B);
75: MatLoad(B,viewer);
76: PetscViewerDestroy(&viewer);
78: MatGetType(B,&mattype);
80: MatGetSize(B,&M,&N);
81: nzp = PetscMax((PetscInt)(0.1*M),5);
82: PetscMalloc((nzp+1)*(sizeof(PetscInt)+sizeof(PetscScalar)),&idxn);
83: a = (PetscScalar*)(idxn + nzp);
85: /* Create vectors v1 and v2 that are compatible with A_save */
86: VecCreate(PETSC_COMM_WORLD,&v1);
87: MatGetLocalSize(A_save,&m,NULL);
88: VecSetSizes(v1,m,PETSC_DECIDE);
89: VecSetFromOptions(v1);
90: VecDuplicate(v1,&v2);
92: PetscRandomCreate(PETSC_COMM_WORLD,&rdm);
93: PetscRandomSetFromOptions(rdm);
94: PetscOptionsGetReal(NULL,NULL,"-fill",&fill,NULL);
96: /* Test MatAXPY() */
97: /*-------------------*/
98: PetscOptionsHasName(NULL,NULL,"-test_MatAXPY",&Test_MatAXPY);
99: if (Test_MatAXPY) {
100: Mat Btmp;
101: MatDuplicate(A_save,MAT_COPY_VALUES,&A);
102: MatDuplicate(B,MAT_COPY_VALUES,&Btmp);
103: MatAXPY(A,-1.0,B,DIFFERENT_NONZERO_PATTERN); /* A = -B + A_save */
105: MatScale(A,-1.0); /* A = -A = B - A_save */
106: MatAXPY(Btmp,-1.0,A,DIFFERENT_NONZERO_PATTERN); /* Btmp = -A + B = A_save */
107: MatMultEqual(A_save,Btmp,10,&flg);
108: if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"MatAXPY() is incorrect\n");
109: MatDestroy(&A);
110: MatDestroy(&Btmp);
112: Test_MatMatMult = PETSC_FALSE;
113: Test_MatMatTr = PETSC_FALSE;
114: Test_MatPtAP = PETSC_FALSE;
115: Test_MatRARt = PETSC_FALSE;
116: Test_MatMatMatMult = PETSC_FALSE;
117: }
119: /* 1) Test MatMatMult() */
120: /* ---------------------*/
121: if (Test_MatMatMult) {
122: MatDuplicate(A_save,MAT_COPY_VALUES,&A);
123: MatMatMult(A,B,MAT_INITIAL_MATRIX,fill,&C);
124: MatSetOptionsPrefix(C,"matmatmult_"); /* enable option '-matmatmult_' for matrix C */
125: MatGetInfo(C,MAT_GLOBAL_SUM,&info);
127: /* Test MAT_REUSE_MATRIX - reuse symbolic C */
128: alpha=1.0;
129: for (i=0; i<2; i++) {
130: alpha -=0.1;
131: MatScale(A,alpha);
132: MatMatMult(A,B,MAT_REUSE_MATRIX,fill,&C);
133: }
134: MatMatMultEqual(A,B,C,10,&flg);
135: if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error: MatMatMult()\n");
136: MatDestroy(&A);
138: /* Test MatDuplicate() of C=A*B */
139: MatDuplicate(C,MAT_COPY_VALUES,&C1);
140: MatDestroy(&C1);
141: MatDestroy(&C);
142: } /* if (Test_MatMatMult) */
144: /* 2) Test MatTransposeMatMult() and MatMatTransposeMult() */
145: /* ------------------------------------------------------- */
146: if (Test_MatMatTr) {
147: /* Create P */
148: PetscInt PN,rstart,rend;
149: PN = M/2;
150: nzp = 5; /* num of nonzeros in each row of P */
151: MatCreate(PETSC_COMM_WORLD,&P);
152: MatSetSizes(P,PETSC_DECIDE,PETSC_DECIDE,M,PN);
153: MatSetType(P,mattype);
154: MatSeqAIJSetPreallocation(P,nzp,NULL);
155: MatMPIAIJSetPreallocation(P,nzp,NULL,nzp,NULL);
156: MatGetOwnershipRange(P,&rstart,&rend);
157: for (i=0; i<nzp; i++) {
158: PetscRandomGetValue(rdm,&a[i]);
159: }
160: for (i=rstart; i<rend; i++) {
161: for (j=0; j<nzp; j++) {
162: PetscRandomGetValue(rdm,&rval);
163: idxn[j] = (PetscInt)(PetscRealPart(rval)*PN);
164: }
165: MatSetValues(P,1,&i,nzp,idxn,a,ADD_VALUES);
166: }
167: MatAssemblyBegin(P,MAT_FINAL_ASSEMBLY);
168: MatAssemblyEnd(P,MAT_FINAL_ASSEMBLY);
170: /* Create R = P^T */
171: MatTranspose(P,MAT_INITIAL_MATRIX,&R);
173: { /* Test R = P^T, C1 = R*B */
174: MatMatMult(R,B,MAT_INITIAL_MATRIX,fill,&C1);
175: MatTranspose(P,MAT_REUSE_MATRIX,&R);
176: MatMatMult(R,B,MAT_REUSE_MATRIX,fill,&C1);
177: MatDestroy(&C1);
178: }
180: /* C = P^T*B */
181: MatTransposeMatMult(P,B,MAT_INITIAL_MATRIX,fill,&C);
182: MatGetInfo(C,MAT_GLOBAL_SUM,&info);
184: /* Test MAT_REUSE_MATRIX - reuse symbolic C */
185: MatTransposeMatMult(P,B,MAT_REUSE_MATRIX,fill,&C);
186: MatFreeIntermediateDataStructures(C);
188: /* Compare P^T*B and R*B */
189: MatMatMult(R,B,MAT_INITIAL_MATRIX,fill,&C1);
190: MatNormDifference(C,C1,&norm);
191: if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Error in MatTransposeMatMult(): %g\n",(double)norm);
192: MatDestroy(&C1);
194: /* Test MatDuplicate() of C=P^T*B */
195: MatDuplicate(C,MAT_COPY_VALUES,&C1);
196: MatDestroy(&C1);
197: MatDestroy(&C);
199: /* C = B*R^T */
200: PetscObjectTypeCompare((PetscObject)B,MATSEQAIJ,&seqaij);
201: if (size == 1 && seqaij) {
202: MatMatTransposeMult(B,R,MAT_INITIAL_MATRIX,fill,&C);
203: MatSetOptionsPrefix(C,"matmatmulttr_"); /* enable '-matmatmulttr_' for matrix C */
204: MatGetInfo(C,MAT_GLOBAL_SUM,&info);
206: /* Test MAT_REUSE_MATRIX - reuse symbolic C */
207: MatMatTransposeMult(B,R,MAT_REUSE_MATRIX,fill,&C);
209: /* Check */
210: MatMatMult(B,P,MAT_INITIAL_MATRIX,fill,&C1);
211: MatNormDifference(C,C1,&norm);
212: if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Error in MatMatTransposeMult() %g\n",(double)norm);
213: MatDestroy(&C1);
214: MatDestroy(&C);
215: }
216: MatDestroy(&P);
217: MatDestroy(&R);
218: }
220: /* 3) Test MatPtAP() */
221: /*-------------------*/
222: if (Test_MatPtAP) {
223: PetscInt PN;
224: Mat Cdup;
225: PetscBool view=PETSC_FALSE;
227: PetscOptionsGetBool(NULL,NULL,"-matptap_view",&view,NULL);
228: MatDuplicate(A_save,MAT_COPY_VALUES,&A);
229: MatGetSize(A,&M,&N);
230: MatGetLocalSize(A,&m,&n);
232: PN = M/2;
233: nzp = (PetscInt)(0.1*PN+1); /* num of nozeros in each row of P */
234: MatCreate(PETSC_COMM_WORLD,&P);
235: MatSetSizes(P,PETSC_DECIDE,PETSC_DECIDE,N,PN);
236: MatSetType(P,mattype);
237: MatSeqAIJSetPreallocation(P,nzp,NULL);
238: MatMPIAIJSetPreallocation(P,nzp,NULL,nzp,NULL);
239: for (i=0; i<nzp; i++) {
240: PetscRandomGetValue(rdm,&a[i]);
241: }
242: MatGetOwnershipRange(P,&rstart,&rend);
243: for (i=rstart; i<rend; i++) {
244: for (j=0; j<nzp; j++) {
245: PetscRandomGetValue(rdm,&rval);
246: idxn[j] = (PetscInt)(PetscRealPart(rval)*PN);
247: }
248: MatSetValues(P,1,&i,nzp,idxn,a,ADD_VALUES);
249: }
250: MatAssemblyBegin(P,MAT_FINAL_ASSEMBLY);
251: MatAssemblyEnd(P,MAT_FINAL_ASSEMBLY);
253: /* MatView(P,PETSC_VIEWER_STDOUT_WORLD); */
254: MatGetSize(P,&pM,&pN);
255: MatGetLocalSize(P,&pm,&pn);
256: MatPtAP(A,P,MAT_INITIAL_MATRIX,fill,&C);
258: /* Test MAT_REUSE_MATRIX - reuse symbolic C */
259: alpha=1.0;
260: for (i=0; i<2; i++) {
261: alpha -=0.1;
262: MatScale(A,alpha);
263: MatPtAP(A,P,MAT_REUSE_MATRIX,fill,&C);
264: }
266: /* Test PtAP ops with P SeqDense and A either SeqAIJ or SeqDense (it assumes MatPtAP_SeqAIJ_SeqAIJ is fine) */
267: if (size == 1) {
268: Mat Cdensetest,Pdense,Cdense,Adense;
269: PetscReal norm;
271: MatConvert(C,MATSEQDENSE,MAT_INITIAL_MATRIX,&Cdensetest);
272: MatConvert(P,MATSEQDENSE,MAT_INITIAL_MATRIX,&Pdense);
274: /* test with A SeqAIJ */
275: PetscObjectTypeCompare((PetscObject)A,MATSEQAIJ,&seqaij);
276: if (seqaij) {
277: MatPtAP(A,Pdense,MAT_INITIAL_MATRIX,fill,&Cdense);
278: MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
279: MatNorm(Cdense,NORM_FROBENIUS,&norm);
280: if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqAIJ and P SeqDense: %g\n",(double)norm);
281: MatScale(Cdense,-1.);
282: MatPtAP(A,Pdense,MAT_REUSE_MATRIX,fill,&Cdense);
283: MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
284: MatNorm(Cdense,NORM_FROBENIUS,&norm);
285: if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqAIJ and P SeqDense and MAT_REUSE_MATRIX: %g\n",(double)norm);
286: MatDestroy(&Cdense);
287: }
289: /* test with A SeqDense */
290: MatConvert(A,MATSEQDENSE,MAT_INITIAL_MATRIX,&Adense);
291: MatPtAP(Adense,Pdense,MAT_INITIAL_MATRIX,fill,&Cdense);
292: MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
293: MatNorm(Cdense,NORM_FROBENIUS,&norm);
294: if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqDense and P SeqDense: %g\n",(double)norm);
295: MatScale(Cdense,-1.);
296: MatPtAP(Adense,Pdense,MAT_REUSE_MATRIX,fill,&Cdense);
297: MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
298: MatNorm(Cdense,NORM_FROBENIUS,&norm);
299: if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqDense and P SeqDense and MAT_REUSE_MATRIX: %g\n",(double)norm);
300: MatDestroy(&Cdense);
301: MatDestroy(&Cdensetest);
302: MatDestroy(&Pdense);
303: MatDestroy(&Adense);
304: }
306: /* Test MatDuplicate() of C=PtAP and MatView(Cdup,...) */
307: MatDuplicate(C,MAT_COPY_VALUES,&Cdup);
308: if (view) {
309: MatView(Cdup,PETSC_VIEWER_STDOUT_WORLD);
310: }
311: MatDestroy(&Cdup);
313: if (size>1 || !seqaij) Test_MatRARt = PETSC_FALSE;
314: /* 4) Test MatRARt() */
315: /* ----------------- */
316: if (Test_MatRARt) {
317: Mat R, RARt;
318: MatTranspose(P,MAT_INITIAL_MATRIX,&R);
319: MatRARt(A,R,MAT_INITIAL_MATRIX,2.0,&RARt);
320: MatNormDifference(C,RARt,&norm);
321: if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"|PtAP - RARt| = %g",(double)norm);
322: MatDestroy(&R);
323: MatDestroy(&RARt);
324: }
326: if (Test_MatMatMatMult && size == 1) {
327: Mat R, RAP;
328: MatTranspose(P,MAT_INITIAL_MATRIX,&R);
329: MatMatMatMult(R,A,P,MAT_INITIAL_MATRIX,2.0,&RAP);
330: MatNormDifference(C,RAP,&norm);
331: if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"PtAP != RAP %g",(double)norm);
332: MatDestroy(&R);
333: MatDestroy(&RAP);
334: }
336: /* Create vector x that is compatible with P */
337: VecCreate(PETSC_COMM_WORLD,&x);
338: MatGetLocalSize(P,&m,&n);
339: VecSetSizes(x,n,PETSC_DECIDE);
340: VecSetFromOptions(x);
342: VecCreate(PETSC_COMM_WORLD,&v3);
343: VecSetSizes(v3,n,PETSC_DECIDE);
344: VecSetFromOptions(v3);
345: VecDuplicate(v3,&v4);
347: norm = 0.0;
348: for (i=0; i<10; i++) {
349: VecSetRandom(x,rdm);
350: MatMult(P,x,v1);
351: MatMult(A,v1,v2); /* v2 = A*P*x */
353: MatMultTranspose(P,v2,v3); /* v3 = Pt*A*P*x */
354: MatMult(C,x,v4); /* v3 = C*x */
355: VecNorm(v4,NORM_2,&norm_abs);
356: VecAXPY(v4,none,v3);
357: VecNorm(v4,NORM_2,&norm_tmp);
359: norm_tmp /= norm_abs;
360: if (norm_tmp > norm) norm = norm_tmp;
361: }
362: if (norm >= PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error: MatPtAP(), |v1 - v2|: %g\n",(double)norm);
364: MatDestroy(&A);
365: MatDestroy(&P);
366: MatDestroy(&C);
367: VecDestroy(&v3);
368: VecDestroy(&v4);
369: VecDestroy(&x);
370: }
372: /* Destroy objects */
373: VecDestroy(&v1);
374: VecDestroy(&v2);
375: PetscRandomDestroy(&rdm);
376: PetscFree(idxn);
378: MatDestroy(&A_save);
379: MatDestroy(&B);
381: PetscPreLoadEnd();
382: PetscFinalize();
383: return ierr;
384: }
388: /*TEST
390: test:
391: suffix: 2_mattransposematmult_matmatmult
392: nsize: 3
393: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
394: args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium -mattransposematmult_via matmatmult> ex94_2.tmp 2>&1
396: test:
397: suffix: 2_mattransposematmult_scalable
398: nsize: 3
399: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
400: args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium -mattransposematmult_via scalable> ex94_2.tmp 2>&1
401: output_file: output/ex94_1.out
403: test:
404: suffix: axpy_mpiaij
405: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
406: nsize: 8
407: args: -f0 ${DATAFILESPATH}/matrices/poisson_2d5p -f1 ${DATAFILESPATH}/matrices/poisson_2d13p -test_MatAXPY
408: output_file: output/ex94_1.out
410: test:
411: suffix: axpy_mpibaij
412: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
413: nsize: 8
414: args: -f0 ${DATAFILESPATH}/matrices/poisson_2d5p -f1 ${DATAFILESPATH}/matrices/poisson_2d13p -test_MatAXPY -mat_type baij
415: output_file: output/ex94_1.out
417: test:
418: suffix: axpy_mpisbaij
419: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
420: nsize: 8
421: args: -f0 ${DATAFILESPATH}/matrices/poisson_2d5p -f1 ${DATAFILESPATH}/matrices/poisson_2d13p -test_MatAXPY -mat_type sbaij
422: output_file: output/ex94_1.out
424: test:
425: suffix: matmatmult
426: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
427: args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -viewer_binary_skip_info
428: output_file: output/ex94_1.out
430: test:
431: suffix: matmatmult_2
432: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
433: args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -mat_type mpiaij -viewer_binary_skip_info
434: output_file: output/ex94_1.out
436: test:
437: suffix: matmatmult_scalable
438: nsize: 4
439: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
440: args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -matmatmult_via scalable
441: output_file: output/ex94_1.out
443: test:
444: suffix: ptap
445: nsize: 3
446: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
447: args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium -matptap_via scalable
448: output_file: output/ex94_1.out
450: test:
451: suffix: rap
452: nsize: 3
453: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
454: args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium
455: output_file: output/ex94_1.out
457: test:
458: suffix: scalable0
459: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
460: args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -viewer_binary_skip_info
461: output_file: output/ex94_1.out
463: test:
464: suffix: scalable1
465: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
466: args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -viewer_binary_skip_info -matptap_via scalable
467: output_file: output/ex94_1.out
469: test:
470: suffix: view
471: nsize: 2
472: requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
473: args: -f0 ${DATAFILESPATH}/matrices/tiny -f1 ${DATAFILESPATH}/matrices/tiny -viewer_binary_skip_info -matptap_view
474: output_file: output/ex94_2.out
476: TEST*/