On the data structures and algorithms for contact detection in granular media (DEM) V. Ogarko, May 2010, P2C course

Transcription

1 On the data structures and algorithms for contact detection in granular media (DEM) V. Ogarko, May 2010, P2C course

2 Discrete element method (DEM) Single particle Challenges: -performance O(N) (with low const. factor) -memory O(N) - Contacts N ~ Polydispersity ~ CONCRETE Many particles Material FRACTIONS Multiphase flow

3 Contact detection scheme (in general) 1 st stage 2 nd stage simple for spherical particles Broad phase: collect candidate pairs Narrow phase: exact check

4 Data structure desired for DEM - Computational cost O(N) + also for polydisperse particles include cost to create data structure, and # of pair candidates (output) with respect to N -Memory consumption O(N) -Dynamics (conveying belts, etc) -Parallelization -Periodic boundary conditions -Robustness -Additional: easy boundary collision check with DT,

5 Data structures: -All pairs check: never used! unless N < 11 J -Delaunay triangulation -Spatial subdivision Grids (uniform= Linked Cells, hierarchical) HierarchicalTrees (OcTree, ) -Sorting ( sort and sweep, etc): requires sorting ~ NlogN -Verlet list: very easy to implement, but slow for large N [1]

6 Data structures: Kinetic data structures: replace coordinates of objects with function of time. Need to know continuous trajectory (~ like ED) not appropriated for MD. Non kinetic data structures: for MD. Do not confuse kinetic with dynamic!

7 1. Triangulations

8

9 DEF: a Delaunay triangulation for a set P of points in the plane is a triangulation DT(P) such that no point in P is inside the circumcircle of any triangle in DT(P).

10 Contact detection with DT: check all particles connected by edge usually ~ O(N) edges

11 Weighted Delaunay triangulations: why? Not weighted (simple) DT can fail when Rmax / Rmin > Each weighted point (pi, wi) can be regarded as a N dimensional sphere with center pi and radius ri = sqrt(wi).

12 Weighted Delaunay triangulations: is Each weighted point (pi, wi) can be regarded as a N dimensional sphere with center pi and radius ri = sqrt(wi).

13 Exmaple: simple Delaunay fails contact when weighted Delaunay detects. Actual contact is between two red particles.

14 and can be more complicated cases (obtained from MD simulation): Actual contact is between two red particles. simple Delaunay weighted Delaunay

15

16 Weighted Delaunay triangulations: when? Less-orthogonality condition: Theorem.

17 Delaunay triangulation with super linear number of edges. A triangulation with a quadratic number of edges.

18 Stability of Delaunay triangulations. Arbitrarily small displacements can result in large changes to the triangulation. In most cases there is some tolerance around each vertex.

19 2. Spatial partitioning: linked cells, hierarchical grid and trees

20 2.1 Grids

21 On the some issues of uniform grid ( Linked Cells ) Cell Size Issues:

22 On the some issues of uniform grid Cell Size Issues: Cell size is generally adjusted to be large enough to fit the largest object. Then an object overlaps no more than four cells (for a 2D grid; eight for a 3D grid). less work is required to insert, update and to perform the actual overlap tests.

23 Storing objects in a grid. Each cell points to a linked list of objects in cell, or be NULL if empty.

24 Storing objects in a grid. -Insertion new object (at the head of list) is O(1). -Updating and deletion of an arbitrary object is O(m). -Updating and deletion can also be made O(1) by using a double-linked list. -Access to cell position for an object on any level is O(1). -Access to neighbors of current cell is O(1).

25 Storing grid Options: - Dense array (elements one-to-one). Memory required ~ O(grid size) drawback: for large grids just storing the list headers in each grid cell becomes prohibitively expensive need to increase cell size performance decreases L - Hashing (next slides)

26 Why do we need hashing storage? Number of cells is HUGE but only ~ N cells are occupied -especially for high polydispersity -especially for low volume fraction -especially in 3D

27 Hash functions (basic) DEF. A hash function is any well-defined procedure or mathematical function that converts a large, possibly variable-sized amount of data into a single integer. That may serve as an index to an array. Example 1: hash(x, y) = (M1*x + M2*y) mod m, M1, M2 large arb. prime const. M1 = 0x8da6b343; M2 = 0xd ; Col=11612 Example 2: Bernstein hash hash = 0; hash = 33 * hash + x; hash = 33 * hash + y; hash = hash mod m; Bernstein's hash should be used with caution. It performs very well in practice, for no apparently known reasons (much like how the constant 33 does better than more logical constants for no apparent reason), but in theory it is not up to snuff. Always test this function with sample data for every application to ensure that it does not encounter a degenerate case and cause excessive collisions. Col= Example 3: FNV hash hash = ; hash = ( hash * ) ^ x; hash = ( hash * ) ^ y; hash = hash mod m; Col=17774

28 Designing hash functions Designing a hash function is more trial and error with a touch of theory than any well defined procedure. For example, beyond making the connection between random numbers and the desirable random distribution of hash values, the better part of the design for my JSW hash involved playing around with constants to see what would work best. Iwould also be lying if I said that the choice of operations was not almost completely random trial and error by pulling from a pool of combinations of XOR, OR, AND, addition, subtraction, and multiplication. I will not claim that hash function design is always like that, but the evidence certainly suggests it. If you design hash functions in a deterministic way, I would love to hear from you. (c) Julienne Walker Exercise 1: Design your hash function and compare it with those from Examples # 1, 2, 3 for you data set (check the number of hash collisions).

29 Issues: hash collisions resolution methods 1) Chaining (= open hashing or closed addressing ) next slide 2) Linear probing (= closed hashing ) Load factor = the ratio N / S, S size of bucket array, N = # elements stored My recommendations: S = closest prime to 2 * N (or power of two - better) Load factor = 0.5 Do not use load factor > 0.7!

30 Issues: hash collisions Chaining GRID Hash table

31 Storing grid: summary Options: Dense array (elements one-to-one). Memory required ~ O(grid size) drawback: for large grids just storing the list headers in each grid cell becomes prohibitively expensive Hash storage Memory required ~ O(number of objects)!!! advantages: -allowing the grid to be unbounded in size! -independent of the grid (system) size, as consequence don t need to rebuild grid for systems with variable size (e.g. moving walls) drawback: -hash collisions resolution but we can make it! J

32 CONTD Uniform grid object-object test issues What object feature should be used to determine which cell the object goes into? Usual approaches: 1) object bounding sphere center 2) top leftmost corner of the axis-aligned bounding box (AABB) For spherical particles the choice is evident J

33 Uniform grid object-object test issues Should objects be placed in just one representative cell or all cells they overlap? Advantages of all cells -possibly less number of cells to test, in the best case only one (depends of how many cells objects overlap) But, it complicates for updating when objects move and uses more memory. My choice: ONE CELL

34 AABB overlap test: almost always is good! Exercise 2: Check advantage of AABB overlap test for you data set.

35 2.2 Hierarchical tree

36 Hierarchical tree representation Flat array: parent node node[i] has children node[8*i+1] node[8*i+8] (for an octree) -requires the tree being stored as a complete tree -tree must be preallocated to a specific depth and cannot easily grow further => more suitable for static scenes Pointer-based: more useful for dynamic scenes in which the tree is constantly updated. Small pointer-based tree:

37 Storing objects in a tree. -Each node contains linked list of objects. -Insertion new object is O(log m), m number of nodes in the tree. -Access to the node is O(log n) -Access to the children nodes is O(1) -Access to the neighbors is expensive

38 Hierarchical tree issues Put an object on the deepest level where it is not straddling a partitioning plane. (because access to the neighbor nodes is expensive) -stuck at the 0 level -stuck at the 1st level -lie at the 2nd level (fit 100%)

39 Hierarchical tree object-object test issues: all test at time Objects of each nonempty node are checked against all objects in the subtree below the node. A-B A-C A-D A-E A-F A-G A-N A-O B-D B-E B-H B-I B-J B-K D-H D-I

40 Other trees. -Linear Octrees (Hash-based) - access to any node O(1) -Loose Octrees -deal with stuck high up problem -insertion an object is O(1) -k-d Trees -divides space along one dimension at a time -for collision detection -for point location -for nearest neighbor search -for range search -not good for dynamic data 2D k-d tree -Hybrid Schemes

41 2.3 Hierarchical hashed grid. Problem of uniform grid: inability to deal with objects of greatly varying sizes in a graceful way. Solution: use hierarchical grids -set of uniform grids of varying cell sizes, all overlapping to cover the same space. Objects are inserted into a single cell on just one of the levels. Choose level where the cells are large enough to contain the bounding volume of the object. Grid is stored in a hash table

42 Hierarchical hashed grid (for bi-disperse system)

43 A small 1D hierarchical grid: Objects, A through F, have each been inserted in the cell containing the object center point, on the appropriate grid level. The shaded cells must be tested when performing a collision check for object C.

44 Advantages: -Performance O(N) -Memory consumption O(N) - Unbounded systems - Parallelization - Periodic BC s - Dynamics Hierarchical hashed grid Open questions: -Optimum number of levels (?) -Cell sizes (?) Ok!??

45 Hierarchical hashed grid Algorithm: on white board

46 Comparison hierarchical trees (simple) and grids. -Trees are rooted. Time is spent traversing the (largely) empty top of the tree to get at the lower-level nodes where the objects are. -In tree objects could stuck in high level. -Hgrid (hashed) doesn t need to know the world size, but tree does. -Insertion object in hgrid is O(1), but in tree O(m). -Hgrid levels can be dynamically deactivated so that no empty levels are processed. Possible to avoid some of tree problems by using other types of trees, but not for free.

47 Results for polydisperse packings (Rmax/Rmin=10). 2D case.

48 Results for polydisperse packings (Rmax/Rmin=10). 3D case.

49 Thank you J