2. New results on mesh refinement Benoît Hudson, CMU Joint work with Gary Miller and Todd Phillips Papers available at http://www.cs.cmu.edu/~bhudson

3. CAD model

4. Will it work?

5. Equations Navier-Stokes: Heat transfer:

6. Run simulations! CAD model Partial Diff. Eqs. Weak form Mesh Solve Visualize

7. Input Points Segments Polygons

8. Input Points Segments Polygons ‘P’ courtesy of Shewchuk

9. Output ‘P’ courtesy of Shewchuk

10. Simpler Input

11. Two possible meshes

12. Which is better? Example: f(x,y) = 1-x 2

13. This is a bad mesh f(x,y) = 1-x 2 At mesh vertices: read the value At other points p: Find t that contains p Weighted average of points of t 0 1 0 0 0 0 0 0 0 1 1

14. This is a better mesh Still bad at boundary f(x,y) = 1-x 2 At mesh vertices: read the value At other points p: Find t that contains p Weighted average of points of t 0 1 0 0 0 0 0 0 0 1 1

15. Good aspect ratio  good interpolation R r Good aspect ratio if: Equivalent: all angles  

16. Aspect ratio R r Bad aspect ratio if: Equivalent: some angle  

17. This is a better mesh Still bad at boundary 0 1 0 0 0 0 0 0 0 1 1 This mesh is Delaunay: best possible for those points

18. This is a good mesh Add Steiner points

19. This is a good mesh 0 0 0 0

20. Formal problem Input: –Piecewise Linear Complex (PLC) points, segments, polygons, … –quality bound: angle   Output: –quality triangulation (angle   ) –all features appear (perhaps subdivided) –O(m opt ) vertices

21. Grading Good aspect ratio  good grading Small feature Small triangles Big features Big triangles Grade linearly away from small feature Good aspect ratio  bounded degree

22. Outline Two older methods –quadtree refinement –Delaunay refinement Our algorithm: SVR as a hybrid Parallel SVR Dynamic meshing: too much for this talk. See me afterwards.

23. Older Solutions 1950-now: construct mesh by hand! –Takes days to months. Automatic methods: ca. 1980-now –no quality, size, or time bounds BEG90: quality and size in O(n lg n + m) (buggy proof, fixed in BET93) Rup92: smaller in practice, no time bound.

24. Simpler input Just points for now

25. Quadtree refinement  [BEG90, MV92, BET93]

26. Crowded two points in cell, or one point in cell, one in neighbour Quadtree rules Unbalanced Neighbor is small

27. Quadtree

30. Quadtree in a word Quality mesh (17  ) O(m opt ) output size O(n lg n + m) runtime General approach: top-down (think: binary search tree)

31. Delaunay Refinement [Rup92, She97]

32. Add a bounding box

33. Triangulate (use Delaunay)

34. Identify skinny triangle

35. Find circumcenter

36. Insert, retriangulate

37. Find more skinny triangles

43. Ruppert’s algorithm in a word Quality mesh (any   20.7  ) O(m opt ) output size O(n 2 + m) runtime worst case –works fast in practice General approach: bottom-up In practice, 35  often works.

44. Compare and contrast 35 triangles, 30  69 triangles, 17 

45. Ruppert’s algorithm in a word Quality mesh O(m opt ) output size –smaller than quadtree in practice O(n 2 + m) runtime worst case –works fast in practice General approach: bottom-up

46. Restrictions Ruppert’s algorithm handles segments only at 60  angles to each other. 3d extensions [She97, MPW02]: segment face segment face 60  ~70  90  Smaller angles may cause infinite loops

47. Meshing well, quickly Hudson, Miller, Phillips 2006 Sparse Voronoi Refinement 15th International Meshing Roundtable

48. The Goal Ruppert’s small meshes Quadtree’s fast runtime In dimension 3 + !

49. The intuition Quadtree’s fast time: slowly zero in on small features, keep mesh good quality always. Large size: warp to input too late. Ruppert’s small size: immediately resolve all features. Ruppert’s bad timing: allow horrid mesh quality. SVR: always good quality, resolve when necessary

50. SVR

51. Add a bounding box

52. Triangulate just the box! Triangles keep track of points

53. Apply splitting rules 1.If a triangle is skinny, split it. 2.If a triangle contains input, split it.

54. Apply splitting rules 1.If a triangle is skinny, split it. 2.If a triangle contains input, split it.

55. Split Split(t) 2. Shrink by k 3. Choose a point 4. Insert it, retriangulate 1.If a triangle is skinny, split it. 2.If a triangle contains input, split it. 1. Draw circle

56. Apply splitting rules 1.If a triangle is skinny, split it. 2.If a triangle contains input, split it. Split(t) 2. Shrink by k 3. Choose a point 4. Insert it, retriangulate 1. Draw circle

57. Apply splitting rules 1.If a triangle is skinny, split it. 2.If a triangle contains input, split it.

58. Apply splitting rules 1.If a triangle is skinny, split it. 2.If a triangle contains input, split it.

59. General flavour Like quadtree, refine top-down Like Ruppert, use input points and circumcenters

60. SVR in a word Quality mesh O(m opt ) output size O(n lg L/s + m) runtime worst case General approach: hybrid Early evidence: indistinguishable from Ruppert’s L: largest distance s: smallest distance L/s  spread Normally: L/s  poly(n) lg L/s  lg n

61. Overall Comparison SVR [HMP06] Quadtree [BEG90] Ruppert [Rup92] Octtree [MV92] Shewchuk [She97] any d 2d 3d O(n lg L/s + m) O(n lg “n” + m) O(mn)  (n 2 ), O(m 2 n) n: number of input points, segments, … m: number of output points L/s: spread of the input lg “n”: assumes L/s  poly(n) hybrid top-down bottom-up top-down bottom-up [Miller04]: O((n lg  + m) lg m) [HPU05]: O(n lg L/s + m) on point sets

62. Overall Comparison SVR [HMP06] Quadtree [BEG90] Ruppert [Rup92] Octtree [MV92] Shewchuk [She97] any d 2d 3d O(n lg L/s + m) O(n lg “n” + m) O(mn)  (n 2 ), O(m 2 n) n: number of input points, segments, … m: number of output points L/s: spread of the input lg “n”: assumes L/s  poly(n) hybrid top-down bottom-up top-down bottom-up O(n lg “n” + m) on point sets  (n 2 ) even on point sets

63. In practice n/2 points around circle n/2 points along line Delaunay has n 2 /4 tets

64. In practice: n=2000 Algorithm SVR Shewchuk Max #tets 81K 1.014M Max degree 39 ~1,000 Output #tets 81K 87K n/2 points around circle n/2 points along line

65. In practice: n=20000 n/2 points around circle n/2 points along line SVR: outputs 774K tets in 8 minutes Shewchuk: thrashes, ^c after 4 hours (Calculate: Pyramid needs 10 8 tets, each tet is 8 pointers  ~ 3.2 GB)

66. Parallel SVR Hudson, Miller, Phillips 2007 Sparse Parallel Delaunay Refinement To appear, SPAA.

67. Why parallel? Low-end desktops have dual-core CPUs. Understanding the dependencies: –Helps with constant factors in sequential case –Helps with out-of-core, distributed, compression, dynamic case, …

68. Parallel Comparison SVR [HMP07] Quadtree [BET93] Ruppert [STU02] any d 2d 2d, 3d O(lg (L/s) lg(m)) O(lg “n”) O(polylog(L/s)) n: number of input points, segments, … m: number of output points L/s: spread of the input lg “n”: assumes L/s  poly(n) O(n lg L/s + m) O(n lg “n” + m) O( ??? ) DepthWork

69. A sample work set What can we do in parallel?

70. Conflict

71. Block

72. Moot

73. Independent events

74. The algorithm: parallel Build a bounding box While workset not empty –Compute conflicts, blocking, mooting –Defer blocked moves to later –Colour the conflict graph in colours {1..  } –for 1..  perform all the moves in parallel remove mooted moves collect new moves for next round

75. Why does it work? No move is blocked more than O(1) rounds –either it happens –or it gets mooted Proof: –If a break move blocks, there is a clean move nearby. –Clean moves don’t block. –By packing, only O(1) clean moves can be nearby. –QED.

76. Summary No move is blocked long Break moves are discovered quickly Thus the time bound of O(lg L/s) rounds –And O(lg m) per round overhead In practice: we can use any number of shared-memory processors

77. Conclusions: SVR O(n lg (L/s) + m) time –Matches best 2d bound –First sub-quadratic 3d time bound –First 4 + d mesh refinement algorithm –Practical Parallelizes!

78. Open problems

79. (1) Constrained Delaunay Refinement SVR meshes tiny gap. Gap is exterior: how can we ignore it? Traditional method: Constrained Delaunay Triangulation. Hope: CDT/SVR

80. (2) Slivers Points almost coplanar Good radius/edge ratio Bad solid angles  numerically bad Best proofs guarantee 0.00…1  In practice get ~10 

81. (3) Small(ish) angles SVR needs  90  angles between faces 80  ? 60  ? 30  ?

82. (4) Small angles What if angle is 1  ? –What’s a legal output? MPS07: guarantee no large angles in 2d –Extends to 3d?

83. (5) Curves CAD models use curves, curved surfaces No good theoretical bounds on refining curved surfaces

84. (6) Laundry list Dynamic meshing –(my thesis topic) Moving meshes Streaming Distributed-memory CAD cleaning Handling large spread Non-Euclidian metrics Better constant bounds

85. Bibliography [BEG90]: Bern, Eppstein, Gilbert “Provably good mesh generation”, 1994 [MV92]: Mitchell, Vavasis “Quality mesh generation …”, 2000 [Rup92]: Ruppert “A Delaunay refinement algorithm for …”, 1995 [BET93]: Bern, Eppstein, Teng “Parallel construction …”, 1999 [She97]: Shewchuk “Delaunay refinement mesh generation”, 1997 [MPW02]: Miller, Pav, Walkington “Fully incremental …”, 2002 [STU02]: Spielman, Teng, Ungor “Parallel Delaunay …”, 2002 [Mil04]: Miller, “A time-efficient Delaunay Refinement …”, 2004 [HPU05]: Har-Peled, Ungor, “A time-optimal Delaunay …”, 2005 [HMP06]: Hudson, Miller, Phillips, “Sparse Voronoi Refinement”, 2006 [HMP07]: ~, “Sparse Parallel Delaunay Refinement”, 2007 [MPS07]: Miller, Phillips, Sheehy, “Size competitive …”, submitted [HA07]: Hudson, Acar, “Dynamic quad-tree mesh refinement”, submitted