Actual source code: ex2.c
petsc-3.13.4 2020-08-01
1: static char help[] = "Create a mesh, refine and coarsen simultaneously, and transfer a field\n\n";
3: #include <petscds.h>
4: #include <petscdmplex.h>
5: #include <petscdmforest.h>
6: #include <petscoptions.h>
8: static PetscErrorCode AddIdentityLabel(DM dm)
9: {
10: PetscInt pStart,pEnd,p;
14: DMCreateLabel(dm, "identity");
15: DMPlexGetChart(dm, &pStart, &pEnd);
16: for (p = pStart; p < pEnd; p++) {DMSetLabelValue(dm, "identity", p, p);}
17: return(0);
18: }
20: static PetscErrorCode CreateAdaptivityLabel(DM forest,DMLabel *adaptLabel)
21: {
22: DMLabel identLabel;
23: PetscInt cStart, cEnd, c;
27: DMLabelCreate(PETSC_COMM_SELF,"adapt",adaptLabel);
28: DMLabelSetDefaultValue(*adaptLabel,DM_ADAPT_COARSEN);
29: DMGetLabel(forest,"identity",&identLabel);
30: DMForestGetCellChart(forest,&cStart,&cEnd);
31: for (c = cStart; c < cEnd; c++) {
32: PetscInt basePoint;
34: DMLabelGetValue(identLabel,c,&basePoint);
35: if (!basePoint) {DMLabelSetValue(*adaptLabel,c,DM_ADAPT_REFINE);}
36: }
37: return(0);
38: }
40: static PetscErrorCode LinearFunction(PetscInt dim,PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar u[], void *ctx)
41: {
43: u[0] = (x[0] * 2.0 + 1.) + (x[1] * 20.0 + 10.) + ((dim == 3) ? (x[2] * 200.0 + 100.) : 0.);
44: return(0);
45: }
47: static PetscErrorCode MultiaffineFunction(PetscInt dim,PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar u[], void *ctx)
48: {
50: u[0] = (x[0] * 1.0 + 2.0) * (x[1] * 3.0 - 4.0) * ((dim == 3) ? (x[2] * 5.0 + 6.0) : 1.);
51: return(0);
52: }
54: static PetscErrorCode CoordsFunction(PetscInt dim,PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar u[], void *ctx)
55: {
56: PetscInt f;
59: for (f=0;f<Nf;f++) u[f] = x[f];
60: return(0);
61: }
63: typedef struct _bc_func_ctx
64: {
65: PetscErrorCode (*func) (PetscInt,PetscReal,const PetscReal [], PetscInt, PetscScalar [], void *);
66: PetscInt dim;
67: PetscInt Nf;
68: void *ctx;
69: }
70: bc_func_ctx;
72: static PetscErrorCode bc_func_fv (PetscReal time, const PetscReal *c, const PetscReal *n, const PetscScalar *xI, PetscScalar *xG, void *ctx)
73: {
74: bc_func_ctx *bcCtx;
78: bcCtx = (bc_func_ctx *) ctx;
79: (bcCtx->func)(bcCtx->dim,time,c,bcCtx->Nf,xG,bcCtx->ctx);
80: return(0);
81: }
83: static PetscErrorCode IdentifyBadPoints (DM dm, Vec vec, PetscReal tol)
84: {
85: DM dmplex;
86: PetscInt p, pStart, pEnd, maxDof;
87: Vec vecLocal;
88: DMLabel depthLabel;
89: PetscSection section;
93: DMCreateLocalVector(dm, &vecLocal);
94: DMGlobalToLocalBegin(dm, vec, INSERT_VALUES, vecLocal);
95: DMGlobalToLocalEnd(dm, vec, INSERT_VALUES, vecLocal);
96: DMConvert(dm ,DMPLEX, &dmplex);
97: DMPlexGetChart(dmplex, &pStart, &pEnd);
98: DMPlexGetDepthLabel(dmplex, &depthLabel);
99: DMGetLocalSection(dmplex, §ion);
100: PetscSectionGetMaxDof(section, &maxDof);
101: for (p = pStart; p < pEnd; p++) {
102: PetscInt s, c, cSize, parent, childID, numChildren;
103: PetscInt cl, closureSize, *closure = NULL;
104: PetscScalar *values = NULL;
105: PetscBool bad = PETSC_FALSE;
107: VecGetValuesSection(vecLocal, section, p, &values);
108: PetscSectionGetDof(section, p, &cSize);
109: for (c = 0; c < cSize; c++) {
110: PetscReal absDiff = PetscAbsScalar(values[c]);
111: if (absDiff > tol) {bad = PETSC_TRUE; break;}
112: }
113: if (!bad) continue;
114: PetscPrintf(PETSC_COMM_SELF, "Bad point %D\n", p);
115: DMLabelGetValue(depthLabel, p, &s);
116: PetscPrintf(PETSC_COMM_SELF, " Depth %D\n", s);
117: DMPlexGetTransitiveClosure(dmplex, p, PETSC_TRUE, &closureSize, &closure);
118: for (cl = 0; cl < closureSize; cl++) {
119: PetscInt cp = closure[2 * cl];
120: DMPlexGetTreeParent(dmplex, cp, &parent, &childID);
121: if (parent != cp) {
122: PetscPrintf(PETSC_COMM_SELF, " Closure point %D (%D) child of %D (ID %D)\n", cl, cp, parent, childID);
123: }
124: DMPlexGetTreeChildren(dmplex, cp, &numChildren, NULL);
125: if (numChildren) {
126: PetscPrintf(PETSC_COMM_SELF, " Closure point %D (%D) is parent\n", cl, cp);
127: }
128: }
129: DMPlexRestoreTransitiveClosure(dmplex, p, PETSC_TRUE, &closureSize, &closure);
130: for (c = 0; c < cSize; c++) {
131: PetscReal absDiff = PetscAbsScalar(values[c]);
132: if (absDiff > tol) {
133: PetscPrintf(PETSC_COMM_SELF, " Bad dof %D\n", c);
134: }
135: }
136: }
137: DMDestroy(&dmplex);
138: VecDestroy(&vecLocal);
139: return(0);
140: }
142: int main(int argc, char **argv)
143: {
144: MPI_Comm comm;
145: DM base, preForest, postForest;
146: PetscInt dim = 2, Nf = 1;
147: PetscInt step, adaptSteps = 1;
148: PetscInt preCount, postCount;
149: Vec preVec, postVecTransfer, postVecExact;
150: PetscErrorCode (*funcs[1]) (PetscInt,PetscReal,const PetscReal [],PetscInt,PetscScalar [], void *) = {MultiaffineFunction};
151: char filename[PETSC_MAX_PATH_LEN];
152: void *ctxs[1] = {NULL};
153: const PetscInt cells[] = {3, 3, 3};
154: PetscReal diff, tol = PETSC_SMALL;
155: DMBoundaryType periodicity[] = {DM_BOUNDARY_NONE,DM_BOUNDARY_NONE,DM_BOUNDARY_NONE};
156: PetscBool linear = PETSC_FALSE;
157: PetscBool coords = PETSC_FALSE;
158: PetscBool useFV = PETSC_FALSE;
159: PetscBool conv = PETSC_FALSE;
160: PetscBool distribute_base = PETSC_FALSE;
161: PetscBool transfer_from_base[2] = {PETSC_TRUE,PETSC_FALSE};
162: PetscBool use_bcs = PETSC_TRUE;
163: PetscBool periodic = PETSC_FALSE;
164: bc_func_ctx bcCtx;
165: DMLabel adaptLabel;
166: size_t len;
169: filename[0] = '\0';
170: PetscInitialize(&argc, &argv, NULL,help);if (ierr) return ierr;
171: comm = PETSC_COMM_WORLD;
172: PetscOptionsBegin(comm, "", "DMForestTransferVec() Test Options", "DMFOREST");
173: PetscOptionsRangeInt("-dim", "The dimension (2 or 3)", "ex2.c", dim, &dim, NULL,2,3);
174: PetscOptionsBool("-linear","Transfer a simple linear function", "ex2.c", linear, &linear, NULL);
175: PetscOptionsBool("-coords","Transfer a simple coordinate function", "ex2.c", coords, &coords, NULL);
176: PetscOptionsBool("-use_fv","Use a finite volume approximation", "ex2.c", useFV, &useFV, NULL);
177: PetscOptionsBool("-test_convert","Test conversion to DMPLEX",NULL,conv,&conv,NULL);
178: PetscOptionsString("-filename", "Read the base mesh from file", "ex2.c", filename, filename, PETSC_MAX_PATH_LEN, NULL);
179: PetscOptionsBool("-distribute_base","Distribute base DM", "ex2.c", distribute_base, &distribute_base, NULL);
180: PetscOptionsBool("-transfer_from_base","Transfer a vector from base DM to DMForest", "ex2.c", transfer_from_base[0], &transfer_from_base[0], NULL);
181: transfer_from_base[1] = transfer_from_base[0];
182: PetscOptionsBool("-transfer_from_base_steps","Transfer a vector from base DM to the latest DMForest after the adaptivity steps", "ex2.c", transfer_from_base[1], &transfer_from_base[1], NULL);
183: PetscOptionsBool("-use_bcs","Use dirichlet boundary conditions", "ex2.c", use_bcs, &use_bcs, NULL);
184: PetscOptionsBoundedInt("-adapt_steps","Number of adaptivity steps", "ex2.c", adaptSteps, &adaptSteps, NULL,0);
185: PetscOptionsBool("-periodic","Use periodic box mesh", "ex2.c", periodic, &periodic, NULL);
186: PetscOptionsEnd();
188: tol = PetscMax(1.e-10,tol); /* XXX fix for quadruple precision -> why do I need to do this? */
190: if (periodic) periodicity[0] = periodicity[1] = periodicity[2] = DM_BOUNDARY_PERIODIC;
192: if (linear) {
193: funcs[0] = LinearFunction;
194: }
195: if (coords) {
196: funcs[0] = CoordsFunction;
197: Nf = dim;
198: }
200: bcCtx.func = funcs[0];
201: bcCtx.dim = dim;
202: bcCtx.Nf = Nf;
203: bcCtx.ctx = NULL;
205: /* the base mesh */
206: PetscStrlen(filename, &len);
207: if (!len) {
208: DMPlexCreateBoxMesh(comm,dim,PETSC_FALSE,cells,NULL,NULL,periodicity,PETSC_TRUE,&base);
209: } else {
210: DM tdm = NULL;
212: DMPlexCreateFromFile(comm,filename,PETSC_TRUE,&base);
213: DMGetDimension(base,&dim);
214: DMPlexSetCellRefinerType(base, DM_REFINER_TO_BOX);
215: DMRefine(base, PETSC_COMM_WORLD, &tdm);
216: if (tdm) {
217: DMDestroy(&base);
218: base = tdm;
219: }
220: use_bcs = PETSC_FALSE;
221: }
222: AddIdentityLabel(base);
223: if (distribute_base) {
224: DM baseParallel;
225: PetscPartitioner part;
227: DMPlexGetPartitioner(base,&part);
228: PetscPartitionerSetFromOptions(part);
229: DMPlexDistribute(base,0,NULL,&baseParallel);
230: if (baseParallel) {
231: DMDestroy(&base);
232: base = baseParallel;
233: }
234: }
235: if (useFV) {
236: PetscFV fv;
237: PetscLimiter limiter;
238: DM baseFV;
240: DMPlexConstructGhostCells(base,NULL,NULL,&baseFV);
241: DMViewFromOptions(baseFV, NULL, "-fv_dm_view");
242: DMDestroy(&base);
243: base = baseFV;
244: PetscFVCreate(comm, &fv);
245: PetscFVSetSpatialDimension(fv,dim);
246: PetscFVSetType(fv,PETSCFVLEASTSQUARES);
247: PetscFVSetNumComponents(fv,Nf);
248: PetscLimiterCreate(comm,&limiter);
249: PetscLimiterSetType(limiter,PETSCLIMITERNONE);
250: PetscFVSetLimiter(fv,limiter);
251: PetscLimiterDestroy(&limiter);
252: PetscFVSetFromOptions(fv);
253: DMSetField(base,0,NULL,(PetscObject)fv);
254: PetscFVDestroy(&fv);
255: } else {
256: PetscFE fe;
258: PetscFECreateDefault(comm,dim,Nf,PETSC_FALSE,NULL,PETSC_DEFAULT,&fe);
259: DMSetField(base,0,NULL,(PetscObject)fe);
260: PetscFEDestroy(&fe);
261: }
262: DMCreateDS(base);
264: if (use_bcs) {
265: PetscDS prob;
266: PetscInt ids[] = {1, 2, 3, 4, 5, 6};
268: DMGetDS(base,&prob);
269: PetscDSAddBoundary(prob,DM_BC_ESSENTIAL, "bc", "marker", 0, 0, NULL, useFV ? (void(*)(void)) bc_func_fv : (void(*)(void)) funcs[0], 2 * dim, ids, useFV ? (void *) &bcCtx : NULL);
270: }
271: DMViewFromOptions(base,NULL,"-dm_base_view");
273: /* the pre adaptivity forest */
274: DMCreate(comm,&preForest);
275: DMSetType(preForest,(dim == 2) ? DMP4EST : DMP8EST);
276: DMCopyDisc(base,preForest);
277: DMForestSetBaseDM(preForest,base);
278: DMForestSetMinimumRefinement(preForest,0);
279: DMForestSetInitialRefinement(preForest,1);
280: DMSetFromOptions(preForest);
281: DMSetUp(preForest);
282: DMViewFromOptions(preForest,NULL,"-dm_pre_view");
284: /* the pre adaptivity field */
285: DMCreateGlobalVector(preForest,&preVec);
286: DMProjectFunction(preForest,0.,funcs,ctxs,INSERT_VALUES,preVec);
287: VecViewFromOptions(preVec,NULL,"-vec_pre_view");
289: /* communicate between base and pre adaptivity forest */
290: if (transfer_from_base[0]) {
291: Vec baseVec, baseVecMapped;
293: DMGetGlobalVector(base,&baseVec);
294: DMProjectFunction(base,0.,funcs,ctxs,INSERT_VALUES,baseVec);
295: PetscObjectSetName((PetscObject)baseVec,"Function Base");
296: VecViewFromOptions(baseVec,NULL,"-vec_base_view");
298: DMGetGlobalVector(preForest,&baseVecMapped);
299: DMForestTransferVecFromBase(preForest,baseVec,baseVecMapped);
300: VecViewFromOptions(baseVecMapped,NULL,"-vec_map_base_view");
302: /* compare */
303: VecAXPY(baseVecMapped,-1.,preVec);
304: VecViewFromOptions(baseVecMapped,NULL,"-vec_map_diff_view");
305: VecNorm(baseVecMapped,NORM_2,&diff);
307: /* output */
308: if (diff < tol) {
309: PetscPrintf(comm,"DMForestTransferVecFromBase() passes.\n");
310: } else {
311: PetscPrintf(comm,"DMForestTransferVecFromBase() fails with error %g and tolerance %g\n",(double)diff,(double)tol);
312: }
314: DMRestoreGlobalVector(base,&baseVec);
315: DMRestoreGlobalVector(preForest,&baseVecMapped);
316: }
318: for (step = 0; step < adaptSteps; ++step) {
320: if (!transfer_from_base[1]) {
321: PetscObjectGetReference((PetscObject)preForest,&preCount);
322: }
324: /* adapt */
325: CreateAdaptivityLabel(preForest,&adaptLabel);
326: DMForestTemplate(preForest,comm,&postForest);
327: if (step) { DMForestSetAdaptivityLabel(postForest,adaptLabel); }
328: DMLabelDestroy(&adaptLabel);
329: DMSetUp(postForest);
330: DMViewFromOptions(postForest,NULL,"-dm_post_view");
332: /* transfer */
333: DMCreateGlobalVector(postForest,&postVecTransfer);
334: DMForestTransferVec(preForest,preVec,postForest,postVecTransfer,PETSC_TRUE,0.0);
335: VecViewFromOptions(postVecTransfer,NULL,"-vec_post_transfer_view");
337: /* the exact post adaptivity field */
338: DMCreateGlobalVector(postForest,&postVecExact);
339: DMProjectFunction(postForest,0.,funcs,ctxs,INSERT_VALUES,postVecExact);
340: VecViewFromOptions(postVecExact,NULL,"-vec_post_exact_view");
342: /* compare */
343: VecAXPY(postVecExact,-1.,postVecTransfer);
344: VecViewFromOptions(postVecExact,NULL,"-vec_diff_view");
345: VecNorm(postVecExact,NORM_2,&diff);
347: /* output */
348: if (diff < tol) {
349: PetscPrintf(comm,"DMForestTransferVec() passes.\n");
350: } else {
351: PetscPrintf(comm,"DMForestTransferVec() fails with error %g and tolerance %g\n",(double)diff,(double)tol);
352: IdentifyBadPoints(postForest, postVecExact, tol);
353: }
354: VecDestroy(&postVecExact);
356: /* disconnect preForest from postForest if we don't test the transfer throughout the entire refinement process */
357: if (!transfer_from_base[1]) {
358: DMForestSetAdaptivityForest(postForest,NULL);
359: PetscObjectGetReference((PetscObject)preForest,&postCount);
360: if (postCount != preCount) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Adaptation not memory neutral: reference count increase from %d to %d\n",preCount,postCount);
361: }
363: if (conv) {
364: DM dmConv;
366: DMConvert(postForest,DMPLEX,&dmConv);
367: DMViewFromOptions(dmConv,NULL,"-dm_conv_view");
368: DMPlexCheckCellShape(dmConv,PETSC_TRUE,PETSC_DETERMINE);
369: DMDestroy(&dmConv);
370: }
372: VecDestroy(&preVec);
373: DMDestroy(&preForest);
375: preVec = postVecTransfer;
376: preForest = postForest;
377: }
379: if (transfer_from_base[1]) {
380: Vec baseVec, baseVecMapped;
382: /* communicate between base and last adapted forest */
383: DMGetGlobalVector(base,&baseVec);
384: DMProjectFunction(base,0.,funcs,ctxs,INSERT_VALUES,baseVec);
385: PetscObjectSetName((PetscObject)baseVec,"Function Base");
386: VecViewFromOptions(baseVec,NULL,"-vec_base_view");
388: DMGetGlobalVector(preForest,&baseVecMapped);
389: DMForestTransferVecFromBase(preForest,baseVec,baseVecMapped);
390: VecViewFromOptions(baseVecMapped,NULL,"-vec_map_base_view");
392: /* compare */
393: VecAXPY(baseVecMapped,-1.,preVec);
394: VecViewFromOptions(baseVecMapped,NULL,"-vec_map_diff_view");
395: VecNorm(baseVecMapped,NORM_2,&diff);
397: /* output */
398: if (diff < tol) {
399: PetscPrintf(comm,"DMForestTransferVecFromBase() passes.\n");
400: } else {
401: PetscPrintf(comm,"DMForestTransferVecFromBase() fails with error %g and tolerance %g\n",(double)diff,(double)tol);
402: }
404: DMRestoreGlobalVector(base,&baseVec);
405: DMRestoreGlobalVector(preForest,&baseVecMapped);
406: }
408: /* cleanup */
409: VecDestroy(&preVec);
410: DMDestroy(&preForest);
411: DMDestroy(&base);
412: PetscFinalize();
413: return ierr;
414: }
416: /*TEST
418: test:
419: output_file: output/ex2_2d.out
420: suffix: p4est_2d
421: args: -petscspace_type tensor -petscspace_degree 2 -dim 2
422: nsize: 3
423: requires: p4est !single
425: test:
426: output_file: output/ex2_2d.out
427: suffix: p4est_2d_deg4
428: args: -petscspace_type tensor -petscspace_degree 4 -dim 2
429: requires: p4est !single
431: test:
432: output_file: output/ex2_2d.out
433: suffix: p4est_2d_deg8
434: args: -petscspace_type tensor -petscspace_degree 8 -dim 2
435: requires: p4est !single
437: test:
438: output_file: output/ex2_steps2.out
439: suffix: p4est_2d_deg2_steps2
440: args: -petscspace_type tensor -petscspace_degree 2 -dim 2 -coords -adapt_steps 2
441: nsize: 3
442: requires: p4est !single
444: test:
445: output_file: output/ex2_steps3.out
446: suffix: p4est_2d_deg3_steps3
447: args: -petscspace_type tensor -petscspace_degree 3 -dim 2 -coords -adapt_steps 3 -petscdualspace_lagrange_node_type equispaced -petscdualspace_lagrange_node_endpoints 1
448: nsize: 3
449: requires: p4est !single
451: test:
452: output_file: output/ex2_steps3.out
453: suffix: p4est_2d_deg3_steps3_L2_periodic
454: args: -petscspace_type tensor -petscspace_degree 3 -petscdualspace_lagrange_continuity 0 -dim 2 -coords -adapt_steps 3 -periodic -use_bcs 0 -petscdualspace_lagrange_node_type equispaced
455: nsize: 3
456: requires: p4est !single
458: test:
459: output_file: output/ex2_steps3.out
460: suffix: p4est_3d_deg2_steps3_L2_periodic
461: args: -petscspace_type tensor -petscspace_degree 2 -petscdualspace_lagrange_continuity 0 -dim 3 -coords -adapt_steps 3 -periodic -use_bcs 0
462: nsize: 3
463: requires: p4est !single
465: test:
466: output_file: output/ex2_steps2.out
467: suffix: p4est_3d_deg2_steps2
468: args: -petscspace_type tensor -petscspace_degree 2 -dim 3 -coords -adapt_steps 2
469: nsize: 3
470: requires: p4est !single
472: test:
473: output_file: output/ex2_steps3.out
474: suffix: p4est_3d_deg3_steps3
475: args: -petscspace_type tensor -petscspace_degree 3 -dim 3 -coords -adapt_steps 3 -petscdualspace_lagrange_node_type equispaced -petscdualspace_lagrange_node_endpoints 1
476: nsize: 3
477: requires: p4est !single
479: test:
480: output_file: output/ex2_2d_fv.out
481: suffix: p4est_2d_fv
482: args: -transfer_from_base 0 -use_fv -linear -dim 2 -dm_forest_partition_overlap 1
483: nsize: 3
484: requires: p4est !single
486: test:
487: TODO: broken (codimension adjacency)
488: output_file: output/ex2_2d_fv.out
489: suffix: p4est_2d_fv_adjcodim
490: args: -transfer_from_base 0 -use_fv -linear -dim 2 -dm_forest_partition_overlap 1 -dm_forest_adjacency_codimension 1
491: nsize: 2
492: requires: p4est !single
494: test:
495: TODO: broken (dimension adjacency)
496: output_file: output/ex2_2d_fv.out
497: suffix: p4est_2d_fv_adjdim
498: args: -transfer_from_base 0 -use_fv -linear -dim 2 -dm_forest_partition_overlap 1 -dm_forest_adjacency_dimension 1
499: nsize: 2
500: requires: p4est !single
502: test:
503: output_file: output/ex2_2d_fv.out
504: suffix: p4est_2d_fv_zerocells
505: args: -transfer_from_base 0 -use_fv -linear -dim 2 -dm_forest_partition_overlap 1
506: nsize: 10
507: requires: p4est !single
509: test:
510: output_file: output/ex2_3d.out
511: suffix: p4est_3d
512: args: -petscspace_type tensor -petscspace_degree 1 -dim 3
513: nsize: 3
514: requires: p4est !single
516: test:
517: output_file: output/ex2_3d.out
518: suffix: p4est_3d_deg3
519: args: -petscspace_type tensor -petscspace_degree 3 -dim 3
520: nsize: 3
521: requires: p4est !single
523: test:
524: output_file: output/ex2_2d.out
525: suffix: p4est_2d_deg2_coords
526: args: -petscspace_type tensor -petscspace_degree 2 -dim 2 -coords
527: nsize: 3
528: requires: p4est !single
530: test:
531: output_file: output/ex2_3d.out
532: suffix: p4est_3d_deg2_coords
533: args: -petscspace_type tensor -petscspace_degree 2 -dim 3 -coords
534: nsize: 3
535: requires: p4est !single
537: test:
538: output_file: output/ex2_3d_fv.out
539: suffix: p4est_3d_fv
540: args: -transfer_from_base 0 -use_fv -linear -dim 3 -dm_forest_partition_overlap 1
541: nsize: 3
542: requires: p4est !single
544: test:
545: suffix: p4est_3d_nans
546: args: -dim 3 -dm_forest_partition_overlap 1 -test_convert -petscspace_type tensor -petscspace_degree 1
547: nsize: 2
548: requires: p4est !single
550: test:
551: TODO: not broken, but the 3D case below is broken, so I do not trust this one
552: output_file: output/ex2_steps2.out
553: suffix: p4est_2d_tfb_distributed_nc
554: args: -petscspace_type tensor -petscspace_degree 3 -dim 2 -dm_forest_maximum_refinement 2 -dm_p4est_refine_pattern hash -use_bcs 0 -coords -adapt_steps 2 -distribute_base -petscpartitioner_type shell -petscpartitioner_shell_random
555: nsize: 3
556: requires: p4est !single
558: test:
559: TODO: broken
560: output_file: output/ex2_steps2.out
561: suffix: p4est_3d_tfb_distributed_nc
562: args: -petscspace_type tensor -petscspace_degree 2 -dim 3 -dm_forest_maximum_refinement 2 -dm_p4est_refine_pattern hash -use_bcs 0 -coords -adapt_steps 2 -distribute_base -petscpartitioner_type shell -petscpartitioner_shell_random
563: nsize: 3
564: requires: p4est !single
566: test:
567: TODO: broken
568: output_file: output/ex2_3d.out
569: suffix: p4est_3d_transfer_fails
570: args: -petscspace_type tensor -petscspace_degree 1 -filename ${wPETSC_DIR}/share/petsc/datafiles/meshes/doublet-tet.msh -adapt_steps 1 -dm_forest_initial_refinement 1
571: requires: p4est !single
573: test:
574: TODO: broken
575: output_file: output/ex2_steps2_notfb.out
576: suffix: p4est_3d_transfer_fails_2
577: args: -petscspace_type tensor -petscspace_degree 1 -filename ${wPETSC_DIR}/share/petsc/datafiles/meshes/doublet-tet.msh -adapt_steps 2 -dm_forest_initial_refinement 0 -transfer_from_base 0
578: requires: p4est !single
580: test:
581: output_file: output/ex2_steps2.out
582: suffix: p4est_3d_multi_transfer_s2t
583: args: -petscspace_type tensor -petscspace_degree 3 -filename ${wPETSC_DIR}/share/petsc/datafiles/meshes/doublet-tet.msh -adapt_steps 2 -dm_forest_initial_refinement 1 -petscdualspace_lagrange_continuity 0 -use_bcs 0
584: requires: p4est !single
586: test:
587: output_file: output/ex2_steps2.out
588: suffix: p4est_3d_coords_transfer_s2t
589: args: -petscspace_type tensor -petscspace_degree 3 -filename ${wPETSC_DIR}/share/petsc/datafiles/meshes/doublet-tet.msh -adapt_steps 2 -dm_forest_initial_refinement 1 -petscdualspace_lagrange_continuity 0 -coords -use_bcs 0
590: requires: p4est !single
592: TEST*/