Actual source code: ex9.c

petsc-3.8.4 2018-03-24
Report Typos and Errors
  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 = NULL;
223:     const char *name;

225:     DMPlexInterpolate(*newdm, &idm);
226:     PetscObjectGetName((PetscObject) *newdm, &name);
227:     PetscObjectSetName((PetscObject)    idm,  name);
228:     DMPlexCopyCoordinates(*newdm, idm);
229:     DMDestroy(newdm);
230:     *newdm = idm;
231:   }
232:   DMSetFromOptions(*newdm);
233:   return(0);
234: }

236: static PetscErrorCode TestCone(DM dm, AppCtx *user)
237: {
238:   PetscInt           numRuns, cStart, cEnd, c, i;
239:   PetscReal          maxTimePerRun = user->maxConeTime;
240:   PetscLogStage      stage;
241:   PetscLogEvent      event;
242:   PetscEventPerfInfo eventInfo;
243:   PetscErrorCode     ierr;

246:   PetscLogStageRegister("DMPlex Cone Test", &stage);
247:   PetscLogEventRegister("Cone", PETSC_OBJECT_CLASSID, &event);
248:   PetscLogStagePush(stage);
249:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
250:   PetscLogEventBegin(event,0,0,0,0);
251:   for (i = 0; i < user->iterations; ++i) {
252:     for (c = cStart; c < cEnd; ++c) {
253:       const PetscInt *cone;

255:       DMPlexGetCone(dm, c, &cone);
256:     }
257:   }
258:   PetscLogEventEnd(event,0,0,0,0);
259:   PetscLogStagePop();

261:   PetscLogEventGetPerfInfo(stage, event, &eventInfo);
262:   numRuns = (cEnd-cStart) * user->iterations;
263:   if (eventInfo.count != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event calls %d should be %d", eventInfo.count, 1);
264:   if ((PetscInt) eventInfo.flops != 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event flops %d should be %d", (PetscInt) eventInfo.flops, 0);
265:   if (eventInfo.time > maxTimePerRun * numRuns) {
266:     PetscPrintf(PETSC_COMM_SELF, "Cones: %d Average time per cone: %gs standard: %gs\n", numRuns, eventInfo.time/numRuns, maxTimePerRun);
267:     if (user->errors) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Average time for cone %g > standard %g", eventInfo.time/numRuns, maxTimePerRun);
268:   }
269:   return(0);
270: }

272: static PetscErrorCode TestTransitiveClosure(DM dm, AppCtx *user)
273: {
274:   PetscInt           numRuns, cStart, cEnd, c, i;
275:   PetscReal          maxTimePerRun = user->maxClosureTime;
276:   PetscLogStage      stage;
277:   PetscLogEvent      event;
278:   PetscEventPerfInfo eventInfo;
279:   PetscErrorCode     ierr;

282:   PetscLogStageRegister("DMPlex Transitive Closure Test", &stage);
283:   PetscLogEventRegister("TransitiveClosure", PETSC_OBJECT_CLASSID, &event);
284:   PetscLogStagePush(stage);
285:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
286:   PetscLogEventBegin(event,0,0,0,0);
287:   for (i = 0; i < user->iterations; ++i) {
288:     for (c = cStart; c < cEnd; ++c) {
289:       PetscInt *closure = NULL;
290:       PetscInt  closureSize;

292:       DMPlexGetTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);
293:       DMPlexRestoreTransitiveClosure(dm, c, PETSC_TRUE, &closureSize, &closure);
294:     }
295:   }
296:   PetscLogEventEnd(event,0,0,0,0);
297:   PetscLogStagePop();

299:   PetscLogEventGetPerfInfo(stage, event, &eventInfo);
300:   numRuns = (cEnd-cStart) * user->iterations;
301:   if (eventInfo.count != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event calls %d should be %d", eventInfo.count, 1);
302:   if ((PetscInt) eventInfo.flops != 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event flops %d should be %d", (PetscInt) eventInfo.flops, 0);
303:   if (eventInfo.time > maxTimePerRun * numRuns) {
304:     PetscPrintf(PETSC_COMM_SELF, "Closures: %d Average time per cone: %gs standard: %gs\n", numRuns, eventInfo.time/numRuns, maxTimePerRun);
305:     if (user->errors) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Average time for closure %g > standard %g", eventInfo.time/numRuns, maxTimePerRun);
306:   }
307:   return(0);
308: }

310: static PetscErrorCode TestVecClosure(DM dm, PetscBool useIndex, PetscBool useSpectral, AppCtx *user)
311: {
312:   PetscSection       s;
313:   Vec                v;
314:   PetscInt           numRuns, cStart, cEnd, c, i;
315:   PetscScalar        tmpArray[64];
316:   PetscScalar       *userArray     = user->reuseArray ? tmpArray : NULL;
317:   PetscReal          maxTimePerRun = user->maxVecClosureTime;
318:   PetscLogStage      stage;
319:   PetscLogEvent      event;
320:   PetscEventPerfInfo eventInfo;
321:   PetscErrorCode     ierr;

324:   if (useIndex) {
325:     if (useSpectral) {
326:       PetscLogStageRegister("DMPlex Vector Closure with Index Test", &stage);
327:       PetscLogEventRegister("VecClosureInd", PETSC_OBJECT_CLASSID, &event);
328:     } else {
329:       PetscLogStageRegister("DMPlex Vector Spectral Closure with Index Test", &stage);
330:       PetscLogEventRegister("VecClosureSpecInd", PETSC_OBJECT_CLASSID, &event);
331:     }
332:   } else {
333:     if (useSpectral) {
334:       PetscLogStageRegister("DMPlex Vector Spectral Closure Test", &stage);
335:       PetscLogEventRegister("VecClosureSpec", PETSC_OBJECT_CLASSID, &event);
336:     } else {
337:       PetscLogStageRegister("DMPlex Vector Closure Test", &stage);
338:       PetscLogEventRegister("VecClosure", PETSC_OBJECT_CLASSID, &event);
339:     }
340:   }
341:   PetscLogStagePush(stage);
342:   DMPlexCreateSection(dm, user->dim, user->numFields, user->numComponents, user->numDof, 0, NULL, NULL, NULL, NULL, &s);
343:   DMSetDefaultSection(dm, s);
344:   if (useIndex) {DMPlexCreateClosureIndex(dm, s);}
345:   if (useSpectral) {DMPlexCreateSpectralClosurePermutation(dm, s);}
346:   PetscSectionDestroy(&s);
347:   DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);
348:   DMGetLocalVector(dm, &v);
349:   PetscLogEventBegin(event,0,0,0,0);
350:   for (i = 0; i < user->iterations; ++i) {
351:     for (c = cStart; c < cEnd; ++c) {
352:       PetscScalar *closure     = userArray;
353:       PetscInt     closureSize = 64;

355:       DMPlexVecGetClosure(dm, s, v, c, &closureSize, &closure);
356:       if (!user->reuseArray) {DMPlexVecRestoreClosure(dm, s, v, c, &closureSize, &closure);}
357:     }
358:   }
359:   PetscLogEventEnd(event,0,0,0,0);
360:   DMRestoreLocalVector(dm, &v);
361:   PetscLogStagePop();

363:   PetscLogEventGetPerfInfo(stage, event, &eventInfo);
364:   numRuns = (cEnd-cStart) * user->iterations;
365:   if (eventInfo.count != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event calls %d should be %d", eventInfo.count, 1);
366:   if ((PetscInt) eventInfo.flops != 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event flops %d should be %d", (PetscInt) eventInfo.flops, 0);
367:   if (eventInfo.time > maxTimePerRun * numRuns) {
368:     const char *title = "VecClosures";
369:     const char *titleIndex = "VecClosures with Index";
370:     const char *titleSpec = "VecClosures Spectral";
371:     const char *titleSpecIndex = "VecClosures Spectral with Index";

373:     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);
374:     if (user->errors) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Average time for vector closure %g > standard %g", eventInfo.time/numRuns, maxTimePerRun);
375:   }
376:   return(0);
377: }

379: static PetscErrorCode CleanupContext(AppCtx *user)
380: {

384:   PetscFree(user->numComponents);
385:   PetscFree(user->numDof);
386:   return(0);
387: }

389: int main(int argc, char **argv)
390: {
391:   DM             dm;
392:   AppCtx         user;

395:   PetscInitialize(&argc, &argv, NULL,help);if (ierr) return ierr;
396:   ProcessOptions(&user);
397:   PetscLogDefaultBegin();
398:   CreateMesh(PETSC_COMM_SELF, &user, &dm);
399:   TestCone(dm, &user);
400:   TestTransitiveClosure(dm, &user);
401:   TestVecClosure(dm, PETSC_FALSE, PETSC_FALSE, &user);
402:   TestVecClosure(dm, PETSC_TRUE,  PETSC_FALSE, &user);
403:   if (!user.cellSimplex && user.spectral) {
404:     TestVecClosure(dm, PETSC_FALSE, PETSC_TRUE,  &user);
405:     TestVecClosure(dm, PETSC_TRUE,  PETSC_TRUE,  &user);
406:   }
407:   DMDestroy(&dm);
408:   CleanupContext(&user);
409:   PetscFinalize();
410:   return ierr;
411: }

413: /*TEST

415:   # 2D Simplex P_1 scalar tests
416:   test:
417:     suffix: 0
418:     requires: performance
419:     TODO: missing output file
420:     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
421:   test:
422:     suffix: 1
423:     requires: performance
424:     TODO: missing output file
425:     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
426:   test:
427:     suffix: 2
428:     requires: performance
429:     TODO: missing output file
430:     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
431:   test:
432:     suffix: 3
433:     requires: performance
434:     TODO: missing output file
435:     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
436:   test:
437:     suffix: 4
438:     requires: performance
439:     TODO: missing output file
440:     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
441:   test:
442:     suffix: 5
443:     requires: performance
444:     TODO: missing output file
445:     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
446:   test:
447:     suffix: 6
448:     requires: performance
449:     TODO: missing output file
450:     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
451:   test:
452:     suffix: 7
453:     requires: performance
454:     TODO: missing output file
455:     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

457:   # 2D Simplex P_1 vector tests
458:   # 2D Simplex P_2 scalar tests
459:   # 2D Simplex P_2 vector tests
460:   # 2D Simplex P_2/P_1 vector/scalar tests
461:   # 2D Quad P_1 scalar tests
462:   # 2D Quad P_1 vector tests
463:   # 2D Quad P_2 scalar tests
464:   # 2D Quad P_2 vector tests
465:   # 3D Simplex P_1 scalar tests
466:   # 3D Simplex P_1 vector tests
467:   # 3D Simplex P_2 scalar tests
468:   # 3D Simplex P_2 vector tests
469:   # 3D Hex P_1 scalar tests
470:   # 3D Hex P_1 vector tests
471:   # 3D Hex P_2 scalar tests
472:   # 3D Hex P_2 vector tests

474: TEST*/