Actual source code: ex9.c
petsc-3.9.4 2018-09-11
1: static char help[] = "Performance tests for DMPlex query operations\n\n";
3: #include <petscdmplex.h>
5: typedef struct {
6: PetscInt dim; /* The topological mesh dimension */
7: PetscBool cellSimplex; /* Flag for simplices */
8: PetscBool spectral; /* Flag for spectral element layout */
9: PetscBool interpolate; /* Flag for mesh interpolation */
10: PetscReal refinementLimit; /* Maximum volume of a refined cell */
11: PetscInt numFields; /* The number of section fields */
12: PetscInt *numComponents; /* The number of field components */
13: PetscInt *numDof; /* The dof signature for the section */
14: PetscBool reuseArray; /* Pass in user allocated array to VecGetClosure() */
15: /* Test data */
16: PetscBool errors; /* Treat failures as errors */
17: PetscInt iterations; /* The number of iterations for a query */
18: PetscReal maxConeTime; /* Max time per run for DMPlexGetCone() */
19: PetscReal maxClosureTime; /* Max time per run for DMPlexGetTransitiveClosure() */
20: PetscReal maxVecClosureTime; /* Max time per run for DMPlexVecGetClosure() */
21: } AppCtx;
23: static PetscErrorCode ProcessOptions(AppCtx *options)
24: {
25: PetscInt len;
26: PetscBool flg;
30: options->dim = 2;
31: options->cellSimplex = PETSC_TRUE;
32: options->spectral = PETSC_FALSE;
33: options->interpolate = PETSC_FALSE;
34: options->refinementLimit = 0.0;
35: options->numFields = 0;
36: options->numComponents = NULL;
37: options->numDof = NULL;
38: options->reuseArray = PETSC_FALSE;
39: options->errors = PETSC_FALSE;
40: options->iterations = 1;
41: options->maxConeTime = 0.0;
42: options->maxClosureTime = 0.0;
43: options->maxVecClosureTime = 0.0;
45: PetscOptionsBegin(PETSC_COMM_SELF, "", "Meshing Problem Options", "DMPLEX");
46: PetscOptionsInt("-dim", "The topological mesh dimension", "ex9.c", options->dim, &options->dim, NULL);
47: PetscOptionsBool("-cellSimplex", "Flag for simplices", "ex9.c", options->cellSimplex, &options->cellSimplex, NULL);
48: PetscOptionsBool("-spectral", "Flag for spectral element layout", "ex9.c", options->spectral, &options->spectral, NULL);
49: PetscOptionsBool("-interpolate", "Flag for mesh interpolation", "ex9.c", options->interpolate, &options->interpolate, NULL);
50: PetscOptionsReal("-refinement_limit", "The maximum volume of a refined cell", "ex9.c", options->refinementLimit, &options->refinementLimit, NULL);
51: PetscOptionsInt("-num_fields", "The number of section fields", "ex9.c", options->numFields, &options->numFields, NULL);
52: if (options->numFields) {
53: len = options->numFields;
54: PetscMalloc1(len, &options->numComponents);
55: PetscOptionsIntArray("-num_components", "The number of components per field", "ex9.c", options->numComponents, &len, &flg);
56: if (flg && (len != options->numFields)) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Length of components array is %d should be %d", len, options->numFields);
57: }
58: len = (options->dim+1) * PetscMax(1, options->numFields);
59: PetscMalloc1(len, &options->numDof);
60: PetscOptionsIntArray("-num_dof", "The dof signature for the section", "ex9.c", options->numDof, &len, &flg);
61: if (flg && (len != (options->dim+1) * PetscMax(1, options->numFields))) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Length of dof array is %d should be %d", len, (options->dim+1) * PetscMax(1, options->numFields));
63: /* We are specifying the scalar dof, so augment it for multiple components */
64: {
65: PetscInt f, d;
67: for (f = 0; f < options->numFields; ++f) {
68: for (d = 0; d <= options->dim; ++d) options->numDof[f*(options->dim+1)+d] *= options->numComponents[f];
69: }
70: }
72: PetscOptionsBool("-reuse_array", "Pass in user allocated array to VecGetClosure()", "ex9.c", options->reuseArray, &options->reuseArray, NULL);
73: PetscOptionsBool("-errors", "Treat failures as errors", "ex9.c", options->errors, &options->errors, NULL);
74: PetscOptionsInt("-iterations", "The number of iterations for a query", "ex9.c", options->iterations, &options->iterations, NULL);
75: PetscOptionsReal("-max_cone_time", "The maximum time per run for DMPlexGetCone()", "ex9.c", options->maxConeTime, &options->maxConeTime, NULL);
76: PetscOptionsReal("-max_closure_time", "The maximum time per run for DMPlexGetTransitiveClosure()", "ex9.c", options->maxClosureTime, &options->maxClosureTime, NULL);
77: PetscOptionsReal("-max_vec_closure_time", "The maximum time per run for DMPlexVecGetClosure()", "ex9.c", options->maxVecClosureTime, &options->maxVecClosureTime, NULL);
78: PetscOptionsEnd();
79: return(0);
80: }
82: static PetscErrorCode CreateSimplex_2D(MPI_Comm comm, DM *newdm)
83: {
84: DM dm;
85: PetscInt numPoints[2] = {4, 2};
86: PetscInt coneSize[6] = {3, 3, 0, 0, 0, 0};
87: PetscInt cones[6] = {2, 3, 4, 5, 4, 3};
88: PetscInt coneOrientations[6] = {0, 0, 0, 0, 0, 0};
89: PetscScalar vertexCoords[8] = {-0.5, 0.5, 0.0, 0.0, 0.0, 1.0, 0.5, 0.5};
90: PetscInt markerPoints[8] = {2, 1, 3, 1, 4, 1, 5, 1};
91: PetscInt dim = 2, depth = 1, p;
95: DMCreate(comm, &dm);
96: PetscObjectSetName((PetscObject) dm, "triangular");
97: DMSetType(dm, DMPLEX);
98: DMSetDimension(dm, dim);
99: DMPlexCreateFromDAG(dm, depth, numPoints, coneSize, cones, coneOrientations, vertexCoords);
100: for (p = 0; p < 4; ++p) {
101: DMSetLabelValue(dm, "marker", markerPoints[p*2], markerPoints[p*2+1]);
102: }
103: *newdm = dm;
104: return(0);
105: }
107: static PetscErrorCode CreateSimplex_3D(MPI_Comm comm, DM *newdm)
108: {
109: DM dm;
110: PetscInt numPoints[2] = {5, 2};
111: PetscInt coneSize[23] = {4, 4, 0, 0, 0, 0, 0};
112: PetscInt cones[8] = {2, 4, 3, 5, 3, 4, 6, 5};
113: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
114: PetscScalar vertexCoords[15] = {0.0, 0.0, -0.5, 0.0, -0.5, 0.0, 1.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.5};
115: PetscInt markerPoints[10] = {2, 1, 3, 1, 4, 1, 5, 1, 6, 1};
116: PetscInt dim = 3, depth = 1, p;
120: DMCreate(comm, &dm);
121: PetscObjectSetName((PetscObject) dm, "tetrahedral");
122: DMSetType(dm, DMPLEX);
123: DMSetDimension(dm, dim);
124: DMPlexCreateFromDAG(dm, depth, numPoints, coneSize, cones, coneOrientations, vertexCoords);
125: for (p = 0; p < 5; ++p) {
126: DMSetLabelValue(dm, "marker", markerPoints[p*2], markerPoints[p*2+1]);
127: }
128: *newdm = dm;
129: return(0);
130: }
132: static PetscErrorCode CreateQuad_2D(MPI_Comm comm, DM *newdm)
133: {
134: DM dm;
135: PetscInt numPoints[2] = {6, 2};
136: PetscInt coneSize[8] = {4, 4, 0, 0, 0, 0, 0, 0};
137: PetscInt cones[8] = {2, 3, 4, 5, 3, 6, 7, 4};
138: PetscInt coneOrientations[8] = {0, 0, 0, 0, 0, 0, 0, 0};
139: PetscScalar vertexCoords[12] = {-0.5, 0.0, 0.0, 0.0, 0.0, 1.0, -0.5, 1.0, 0.5, 0.0, 0.5, 1.0};
140: PetscInt markerPoints[12] = {2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1};
141: PetscInt dim = 2, depth = 1, p;
145: DMCreate(comm, &dm);
146: PetscObjectSetName((PetscObject) dm, "quadrilateral");
147: DMSetType(dm, DMPLEX);
148: DMSetDimension(dm, dim);
149: DMPlexCreateFromDAG(dm, depth, numPoints, coneSize, cones, coneOrientations, vertexCoords);
150: for (p = 0; p < 6; ++p) {
151: DMSetLabelValue(dm, "marker", markerPoints[p*2], markerPoints[p*2+1]);
152: }
153: *newdm = dm;
154: return(0);
155: }
157: static PetscErrorCode CreateHex_3D(MPI_Comm comm, DM *newdm)
158: {
159: DM dm;
160: PetscInt numPoints[2] = {12, 2};
161: PetscInt coneSize[14] = {8, 8, 0,0,0,0,0,0,0,0,0,0,0,0};
162: PetscInt cones[16] = {2,5,4,3,6,7,8,9, 3,4,11,10,7,12,13,8};
163: PetscInt coneOrientations[16] = {0,0,0,0,0,0,0,0, 0,0, 0, 0,0, 0, 0,0};
164: PetscScalar vertexCoords[36] = {-0.5,0.0,0.0, 0.0,0.0,0.0, 0.0,1.0,0.0, -0.5,1.0,0.0,
165: -0.5,0.0,1.0, 0.0,0.0,1.0, 0.0,1.0,1.0, -0.5,1.0,1.0,
166: 0.5,0.0,0.0, 0.5,1.0,0.0, 0.5,0.0,1.0, 0.5,1.0,1.0};
167: PetscInt markerPoints[24] = {2,1,3,1,4,1,5,1,6,1,7,1,8,1,9,1,10,1,11,1,12,1,13,1};
168: PetscInt dim = 3, depth = 1, p;
172: DMCreate(comm, &dm);
173: PetscObjectSetName((PetscObject) dm, "hexahedral");
174: DMSetType(dm, DMPLEX);
175: DMSetDimension(dm, dim);
176: DMPlexCreateFromDAG(dm, depth, numPoints, coneSize, cones, coneOrientations, vertexCoords);
177: for(p = 0; p < 12; ++p) {
178: DMSetLabelValue(dm, "marker", markerPoints[p*2], markerPoints[p*2+1]);
179: }
180: *newdm = dm;
181: return(0);
182: }
184: static PetscErrorCode CreateMesh(MPI_Comm comm, AppCtx *user, DM *newdm)
185: {
186: PetscInt dim = user->dim;
187: PetscBool cellSimplex = user->cellSimplex;
191: switch (dim) {
192: case 2:
193: if (cellSimplex) {
194: CreateSimplex_2D(comm, newdm);
195: } else {
196: CreateQuad_2D(comm, newdm);
197: }
198: break;
199: case 3:
200: if (cellSimplex) {
201: CreateSimplex_3D(comm, newdm);
202: } else {
203: CreateHex_3D(comm, newdm);
204: }
205: break;
206: default:
207: SETERRQ1(comm, PETSC_ERR_ARG_OUTOFRANGE, "Cannot make meshes for dimension %d", dim);
208: }
209: if (user->refinementLimit > 0.0) {
210: DM rdm;
211: const char *name;
213: DMPlexSetRefinementUniform(*newdm, PETSC_FALSE);
214: DMPlexSetRefinementLimit(*newdm, user->refinementLimit);
215: DMRefine(*newdm, PETSC_COMM_SELF, &rdm);
216: PetscObjectGetName((PetscObject) *newdm, &name);
217: PetscObjectSetName((PetscObject) rdm, name);
218: DMDestroy(newdm);
219: *newdm = rdm;
220: }
221: if (user->interpolate) {
222: DM idm;
224: DMPlexInterpolate(*newdm, &idm);
225: DMDestroy(newdm);
226: *newdm = idm;
227: }
228: DMSetFromOptions(*newdm);
229: return(0);
230: }
232: static PetscErrorCode TestCone(DM dm, AppCtx *user)
233: {
234: PetscInt numRuns, cStart, cEnd, c, i;
235: PetscReal maxTimePerRun = user->maxConeTime;
236: PetscLogStage stage;
237: PetscLogEvent event;
238: PetscEventPerfInfo eventInfo;
239: PetscErrorCode ierr;
242: PetscLogStageRegister("DMPlex Cone Test", &stage);
243: PetscLogEventRegister("Cone", PETSC_OBJECT_CLASSID, &event);
244: PetscLogStagePush(stage);
245: DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
246: PetscLogEventBegin(event,0,0,0,0);
247: for (i = 0; i < user->iterations; ++i) {
248: for (c = cStart; c < cEnd; ++c) {
249: const PetscInt *cone;
251: DMPlexGetCone(dm, c, &cone);
252: }
253: }
254: PetscLogEventEnd(event,0,0,0,0);
255: PetscLogStagePop();
257: PetscLogEventGetPerfInfo(stage, event, &eventInfo);
258: numRuns = (cEnd-cStart) * user->iterations;
259: if (eventInfo.count != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event calls %d should be %d", eventInfo.count, 1);
260: if ((PetscInt) eventInfo.flops != 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event flops %d should be %d", (PetscInt) eventInfo.flops, 0);
261: if (eventInfo.time > maxTimePerRun * numRuns) {
262: PetscPrintf(PETSC_COMM_SELF, "Cones: %d Average time per cone: %gs standard: %gs\n", numRuns, eventInfo.time/numRuns, maxTimePerRun);
263: if (user->errors) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Average time for cone %g > standard %g", eventInfo.time/numRuns, maxTimePerRun);
264: }
265: return(0);
266: }
268: static PetscErrorCode TestTransitiveClosure(DM dm, AppCtx *user)
269: {
270: PetscInt numRuns, cStart, cEnd, c, i;
271: PetscReal maxTimePerRun = user->maxClosureTime;
272: PetscLogStage stage;
273: PetscLogEvent event;
274: PetscEventPerfInfo eventInfo;
275: PetscErrorCode ierr;
278: PetscLogStageRegister("DMPlex Transitive Closure Test", &stage);
279: PetscLogEventRegister("TransitiveClosure", PETSC_OBJECT_CLASSID, &event);
280: PetscLogStagePush(stage);
281: DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
282: PetscLogEventBegin(event,0,0,0,0);
283: for (i = 0; i < user->iterations; ++i) {
284: for (c = cStart; c < cEnd; ++c) {
285: PetscInt *closure = NULL;
286: PetscInt closureSize;
288: DMPlexGetTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);
289: DMPlexRestoreTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);
290: }
291: }
292: PetscLogEventEnd(event,0,0,0,0);
293: PetscLogStagePop();
295: PetscLogEventGetPerfInfo(stage, event, &eventInfo);
296: numRuns = (cEnd-cStart) * user->iterations;
297: if (eventInfo.count != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event calls %d should be %d", eventInfo.count, 1);
298: if ((PetscInt) eventInfo.flops != 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event flops %d should be %d", (PetscInt) eventInfo.flops, 0);
299: if (eventInfo.time > maxTimePerRun * numRuns) {
300: PetscPrintf(PETSC_COMM_SELF, "Closures: %d Average time per cone: %gs standard: %gs\n", numRuns, eventInfo.time/numRuns, maxTimePerRun);
301: if (user->errors) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Average time for closure %g > standard %g", eventInfo.time/numRuns, maxTimePerRun);
302: }
303: return(0);
304: }
306: static PetscErrorCode TestVecClosure(DM dm, PetscBool useIndex, PetscBool useSpectral, AppCtx *user)
307: {
308: PetscSection s;
309: Vec v;
310: PetscInt numRuns, cStart, cEnd, c, i;
311: PetscScalar tmpArray[64];
312: PetscScalar *userArray = user->reuseArray ? tmpArray : NULL;
313: PetscReal maxTimePerRun = user->maxVecClosureTime;
314: PetscLogStage stage;
315: PetscLogEvent event;
316: PetscEventPerfInfo eventInfo;
317: PetscErrorCode ierr;
320: if (useIndex) {
321: if (useSpectral) {
322: PetscLogStageRegister("DMPlex Vector Closure with Index Test", &stage);
323: PetscLogEventRegister("VecClosureInd", PETSC_OBJECT_CLASSID, &event);
324: } else {
325: PetscLogStageRegister("DMPlex Vector Spectral Closure with Index Test", &stage);
326: PetscLogEventRegister("VecClosureSpecInd", PETSC_OBJECT_CLASSID, &event);
327: }
328: } else {
329: if (useSpectral) {
330: PetscLogStageRegister("DMPlex Vector Spectral Closure Test", &stage);
331: PetscLogEventRegister("VecClosureSpec", PETSC_OBJECT_CLASSID, &event);
332: } else {
333: PetscLogStageRegister("DMPlex Vector Closure Test", &stage);
334: PetscLogEventRegister("VecClosure", PETSC_OBJECT_CLASSID, &event);
335: }
336: }
337: PetscLogStagePush(stage);
338: DMPlexCreateSection(dm, user->dim, user->numFields, user->numComponents, user->numDof, 0, NULL, NULL, NULL, NULL, &s);
339: DMSetDefaultSection(dm, s);
340: if (useIndex) {DMPlexCreateClosureIndex(dm, s);}
341: if (useSpectral) {DMPlexCreateSpectralClosurePermutation(dm, PETSC_DETERMINE, s);}
342: PetscSectionDestroy(&s);
343: DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
344: DMGetLocalVector(dm, &v);
345: PetscLogEventBegin(event,0,0,0,0);
346: for (i = 0; i < user->iterations; ++i) {
347: for (c = cStart; c < cEnd; ++c) {
348: PetscScalar *closure = userArray;
349: PetscInt closureSize = 64;
351: DMPlexVecGetClosure(dm, s, v, c, &closureSize, &closure);
352: if (!user->reuseArray) {DMPlexVecRestoreClosure(dm, s, v, c, &closureSize, &closure);}
353: }
354: }
355: PetscLogEventEnd(event,0,0,0,0);
356: DMRestoreLocalVector(dm, &v);
357: PetscLogStagePop();
359: PetscLogEventGetPerfInfo(stage, event, &eventInfo);
360: numRuns = (cEnd-cStart) * user->iterations;
361: if (eventInfo.count != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event calls %d should be %d", eventInfo.count, 1);
362: if ((PetscInt) eventInfo.flops != 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event flops %d should be %d", (PetscInt) eventInfo.flops, 0);
363: if (eventInfo.time > maxTimePerRun * numRuns) {
364: const char *title = "VecClosures";
365: const char *titleIndex = "VecClosures with Index";
366: const char *titleSpec = "VecClosures Spectral";
367: const char *titleSpecIndex = "VecClosures Spectral with Index";
369: PetscPrintf(PETSC_COMM_SELF, "%s: %d Average time per vector closure: %gs standard: %gs\n", useIndex ? (useSpectral ? titleSpecIndex : titleIndex) : (useSpectral ? titleSpec : title), numRuns, eventInfo.time/numRuns, maxTimePerRun);
370: if (user->errors) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Average time for vector closure %g > standard %g", eventInfo.time/numRuns, maxTimePerRun);
371: }
372: return(0);
373: }
375: static PetscErrorCode CleanupContext(AppCtx *user)
376: {
380: PetscFree(user->numComponents);
381: PetscFree(user->numDof);
382: return(0);
383: }
385: int main(int argc, char **argv)
386: {
387: DM dm;
388: AppCtx user;
391: PetscInitialize(&argc, &argv, NULL,help);if (ierr) return ierr;
392: ProcessOptions(&user);
393: PetscLogDefaultBegin();
394: CreateMesh(PETSC_COMM_SELF, &user, &dm);
395: TestCone(dm, &user);
396: TestTransitiveClosure(dm, &user);
397: TestVecClosure(dm, PETSC_FALSE, PETSC_FALSE, &user);
398: TestVecClosure(dm, PETSC_TRUE, PETSC_FALSE, &user);
399: if (!user.cellSimplex && user.spectral) {
400: TestVecClosure(dm, PETSC_FALSE, PETSC_TRUE, &user);
401: TestVecClosure(dm, PETSC_TRUE, PETSC_TRUE, &user);
402: }
403: DMDestroy(&dm);
404: CleanupContext(&user);
405: PetscFinalize();
406: return ierr;
407: }
409: /*TEST
411: # 2D Simplex P_1 scalar tests
412: test:
413: suffix: 0
414: requires: performance
415: TODO: missing output file
416: args: -num_dof 1,0,0 -iterations 10000 -max_cone_time 1.1e-8 -max_closure_time 1.3e-7 -max_vec_closure_time 3.6e-7
417: test:
418: suffix: 1
419: requires: performance
420: TODO: missing output file
421: args: -refinement_limit 1.0e-5 -num_dof 1,0,0 -iterations 2 -max_cone_time 2.1e-8 -max_closure_time 1.5e-7 -max_vec_closure_time 3.6e-7
422: test:
423: suffix: 2
424: requires: performance
425: TODO: missing output file
426: args: -num_fields 1 -num_components 1 -num_dof 1,0,0 -iterations 10000 -max_cone_time 1.1e-8 -max_closure_time 1.3e-7 -max_vec_closure_time 4.5e-7
427: test:
428: suffix: 3
429: requires: performance
430: TODO: missing output file
431: args: -refinement_limit 1.0e-5 -num_fields 1 -num_components 1 -num_dof 1,0,0 -iterations 2 -max_cone_time 2.1e-8 -max_closure_time 1.5e-7 -max_vec_closure_time 4.7e-7
432: test:
433: suffix: 4
434: requires: performance
435: TODO: missing output file
436: args: -interpolate -num_dof 1,0,0 -iterations 10000 -max_cone_time 1.1e-8 -max_closure_time 6.5e-7 -max_vec_closure_time 1.0e-6
437: test:
438: suffix: 5
439: requires: performance
440: TODO: missing output file
441: args: -interpolate -refinement_limit 1.0e-4 -num_dof 1,0,0 -iterations 2 -max_cone_time 2.1e-8 -max_closure_time 6.5e-7 -max_vec_closure_time 1.0e-6
442: test:
443: suffix: 6
444: requires: performance
445: TODO: missing output file
446: args: -interpolate -num_fields 1 -num_components 1 -num_dof 1,0,0 -iterations 10000 -max_cone_time 1.1e-8 -max_closure_time 6.5e-7 -max_vec_closure_time 1.1e-6
447: test:
448: suffix: 7
449: requires: performance
450: TODO: missing output file
451: args: -interpolate -refinement_limit 1.0e-4 -num_fields 1 -num_components 1 -num_dof 1,0,0 -iterations 2 -max_cone_time 2.1e-8 -max_closure_time 6.5e-7 -max_vec_closure_time 1.2e-6
453: # 2D Simplex P_1 vector tests
454: # 2D Simplex P_2 scalar tests
455: # 2D Simplex P_2 vector tests
456: # 2D Simplex P_2/P_1 vector/scalar tests
457: # 2D Quad P_1 scalar tests
458: # 2D Quad P_1 vector tests
459: # 2D Quad P_2 scalar tests
460: # 2D Quad P_2 vector tests
461: # 3D Simplex P_1 scalar tests
462: # 3D Simplex P_1 vector tests
463: # 3D Simplex P_2 scalar tests
464: # 3D Simplex P_2 vector tests
465: # 3D Hex P_1 scalar tests
466: # 3D Hex P_1 vector tests
467: # 3D Hex P_2 scalar tests
468: # 3D Hex P_2 vector tests
470: TEST*/