Debian Codegraph @

python/test/unit/geometry/test_bounding_box_tree.py

raw
1 """Unit tests for BoundingBoxTree"""
2
3 # Copyright (C) 2013-2014 Anders Logg
4 #
5 # This file is part of DOLFIN.
6 #
7 # DOLFIN is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU Lesser General Public License as published by
9 # the Free Software Foundation, either version 3 of the License, or
10 # (at your option) any later version.
11 #
12 # DOLFIN is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU Lesser General Public License for more details.
16 #
17 # You should have received a copy of the GNU Lesser General Public License
18 # along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
19
20 import pytest
21 import numpy
22
23 from dolfin import BoundingBoxTree
24 from dolfin import UnitIntervalMesh, UnitSquareMesh, UnitCubeMesh
25 from dolfin import Point
26 from dolfin import MeshEntity
27 from dolfin import MPI
28 from dolfin_utils.test import skip_in_parallel
29
30
31 #--- compute_collisions with point ---
32
33 @skip_in_parallel
34 def test_compute_collisions_point_1d():
35
36 reference = {1: set([4])}
37
38 p = Point(0.3)
39 mesh = UnitIntervalMesh(16)
40 for dim in range(1, 2):
41 tree = BoundingBoxTree()
42 tree.build(mesh, dim)
43 entities = tree.compute_collisions(p)
44 assert set(entities) == reference[dim]
45
46 @skip_in_parallel
47 def test_compute_collisions_point_2d():
48
49 reference = {1: set([226]),
50 2: set([136, 137])}
51
52 p = Point(0.3, 0.3)
53 mesh = UnitSquareMesh(16, 16)
54 for dim in range(1, 3):
55 tree = BoundingBoxTree()
56 tree.build(mesh, dim)
57 entities = tree.compute_collisions(p)
58 for e in entities:
59 ent = MeshEntity(mesh, dim, e)
60 mp = ent.midpoint()
61 x = (mp.x(), mp.y())
62 print("test: {}".format(x))
63 #assert set(entities) == reference[dim]
64
65 @skip_in_parallel
66 def test_compute_collisions_point_3d():
67
68 reference = {1: set([1364]),
69 2: set([1967, 1968, 1970, 1972, 1974, 1976]),
70 3: set([876, 877, 878, 879, 880, 881])}
71
72 p = Point(0.3, 0.3, 0.3)
73 mesh = UnitCubeMesh(8, 8, 8)
74 for dim in range(1, 4):
75 tree = BoundingBoxTree()
76 tree.build(mesh, dim)
77 entities = tree.compute_collisions(p)
78
79 # FIXME: Face and edges tests are excluded because test
80 # mistakingly relies on the face and edge indices
81 tdim = mesh.topology().dim()
82 if dim != tdim - 1 and dim != tdim - 2:
83 assert set(entities) == reference[dim]
84
85 #--- compute_collisions with tree ---
86
87 @skip_in_parallel
88 def test_compute_collisions_tree_1d():
89
90 references = [[set([8, 9, 10, 11, 12, 13, 14, 15]),
91 set([0, 1, 2, 3, 4, 5, 6, 7])],
92 [set([14, 15]),
93 set([0, 1])]]
94
95 points = [Point(0.52), Point(0.9)]
96
97 for i, point in enumerate(points):
98
99 mesh_A = UnitIntervalMesh(16)
100 mesh_B = UnitIntervalMesh(16)
101
102 mesh_B.translate(point)
103
104 tree_A = BoundingBoxTree()
105 tree_A.build(mesh_A)
106
107 tree_B = BoundingBoxTree()
108 tree_B.build(mesh_B)
109
110 entities_A, entities_B = tree_A.compute_collisions(tree_B)
111
112 assert set(entities_A) == references[i][0]
113 assert set(entities_B) == references[i][1]
114
115 @skip_in_parallel
116 def test_compute_collisions_tree_2d():
117
118 references = [[set([20, 21, 22, 23, 28, 29, 30, 31]),
119 set([0, 1, 2, 3, 8, 9, 10, 11])],
120 [set([6, 7]),
121 set([24, 25])]]
122
123 points = [Point(0.52, 0.51), Point(0.9, -0.9)]
124
125 for i, point in enumerate(points):
126
127 mesh_A = UnitSquareMesh(4, 4)
128 mesh_B = UnitSquareMesh(4, 4)
129
130 mesh_B.translate(point)
131
132 tree_A = BoundingBoxTree()
133 tree_A.build(mesh_A)
134
135 tree_B = BoundingBoxTree()
136 tree_B.build(mesh_B)
137
138 entities_A, entities_B = tree_A.compute_collisions(tree_B)
139
140 assert set(entities_A) == references[i][0]
141 assert set(entities_B) == references[i][1]
142
143 @skip_in_parallel
144 def test_compute_collisions_tree_3d():
145
146 references = [[set([18, 19, 20, 21, 22, 23, 42, 43, 44, 45, 46, 47]),
147 set([0, 1, 2, 3, 4, 5, 24, 25, 26, 27, 28, 29])],
148 [set([6, 7, 8, 9, 10, 11, 30, 31, 32, 33, 34, 35]),
149 set([12, 13, 14, 15, 16, 17, 36, 37, 38, 39, 40, 41])]]
150
151 points = [Point(0.52, 0.51, 0.3), Point(0.9, -0.9, 0.3)]
152
153 for i, point in enumerate(points):
154
155 mesh_A = UnitCubeMesh(2, 2, 2)
156 mesh_B = UnitCubeMesh(2, 2, 2)
157
158 mesh_B.translate(point)
159
160 tree_A = BoundingBoxTree()
161 tree_A.build(mesh_A)
162
163 tree_B = BoundingBoxTree()
164 tree_B.build(mesh_B)
165
166 entities_A, entities_B = tree_A.compute_collisions(tree_B)
167
168 assert set(entities_A) == references[i][0]
169 assert set(entities_B) == references[i][1]
170
171 #--- compute_entity_collisions with point ---
172
173 @skip_in_parallel
174 def test_compute_entity_collisions_1d():
175
176 reference = set([4])
177
178 p = Point(0.3)
179 mesh = UnitIntervalMesh(16)
180
181 tree = BoundingBoxTree()
182 tree.build(mesh)
183 entities = tree.compute_entity_collisions(p)
184 assert set(entities) == reference
185
186 tree = mesh.bounding_box_tree()
187 entities = tree.compute_entity_collisions(p)
188 assert set(entities) == reference
189
190 @skip_in_parallel
191 def test_compute_entity_collisions_2d():
192
193 reference = set([136, 137])
194
195 p = Point(0.3, 0.3)
196 mesh = UnitSquareMesh(16, 16)
197
198 tree = BoundingBoxTree()
199 tree.build(mesh)
200 entities = tree.compute_entity_collisions(p)
201 assert set(entities) == reference
202
203 tree = mesh.bounding_box_tree()
204 entities = tree.compute_entity_collisions(p)
205 assert set(entities) == reference
206
207 @skip_in_parallel
208 def test_compute_entity_collisions_3d():
209
210 reference = set([876, 877, 878, 879, 880, 881])
211
212 p = Point(0.3, 0.3, 0.3)
213 mesh = UnitCubeMesh(8, 8, 8)
214
215 tree = BoundingBoxTree()
216 tree.build(mesh)
217 entities = tree.compute_entity_collisions(p)
218 assert set(entities) == reference
219
220 #--- compute_entity_collisions with tree ---
221
222 @skip_in_parallel
223 def test_compute_entity_collisions_tree_1d():
224
225 references = [[set([8, 9, 10, 11, 12, 13, 14, 15]),
226 set([0, 1, 2, 3, 4, 5, 6, 7])],
227 [set([14, 15]),
228 set([0, 1])]]
229
230 points = [Point(0.52), Point(0.9)]
231
232 for i, point in enumerate(points):
233
234 mesh_A = UnitIntervalMesh(16)
235 mesh_B = UnitIntervalMesh(16)
236
237 mesh_B.translate(point)
238
239 tree_A = BoundingBoxTree()
240 tree_A.build(mesh_A)
241
242 tree_B = BoundingBoxTree()
243 tree_B.build(mesh_B)
244
245 entities_A, entities_B = tree_A.compute_entity_collisions(tree_B)
246
247 assert set(entities_A) == references[i][0]
248 assert set(entities_B) == references[i][1]
249
250 @skip_in_parallel
251 def test_compute_entity_collisions_tree_2d():
252
253 references = [[set([20, 21, 22, 23, 28, 29, 30, 31]),
254 set([0, 1, 2, 3, 8, 9, 10, 11])],
255 [set([6]),
256 set([25])]]
257
258 points = [Point(0.52, 0.51), Point(0.9, -0.9)]
259
260 for i, point in enumerate(points):
261
262 mesh_A = UnitSquareMesh(4, 4)
263 mesh_B = UnitSquareMesh(4, 4)
264
265 mesh_B.translate(point)
266
267 tree_A = BoundingBoxTree()
268 tree_A.build(mesh_A)
269
270 tree_B = BoundingBoxTree()
271 tree_B.build(mesh_B)
272
273 entities_A, entities_B = tree_A.compute_entity_collisions(tree_B)
274
275 assert set(entities_A) == references[i][0]
276 assert set(entities_B) == references[i][1]
277
278 @skip_in_parallel
279 def test_compute_entity_collisions_tree_3d():
280
281 references = [[set([18, 19, 20, 21, 22, 23, 42, 43, 44, 45, 46, 47]),
282 set([0, 1, 2, 3, 4, 5, 24, 25, 26, 27, 28, 29])],
283 [set([7, 8, 30, 31, 32]),
284 set([15, 16, 17, 39, 41])]]
285
286 points = [Point(0.52, 0.51, 0.3), Point(0.9, -0.9, 0.3)]
287
288 for i, point in enumerate(points):
289
290 mesh_A = UnitCubeMesh(2, 2, 2)
291 mesh_B = UnitCubeMesh(2, 2, 2)
292
293 mesh_B.translate(point)
294
295 tree_A = BoundingBoxTree()
296 tree_A.build(mesh_A)
297
298 tree_B = BoundingBoxTree()
299 tree_B.build(mesh_B)
300
301 entities_A, entities_B = tree_A.compute_entity_collisions(tree_B)
302
303 assert set(entities_A) == references[i][0]
304 assert set(entities_B) == references[i][1]
305
306 #--- compute_first_collision with point ---
307
308 @skip_in_parallel
309 def test_compute_first_collision_1d():
310
311 reference = {1: [4]}
312
313 p = Point(0.3)
314 mesh = UnitIntervalMesh(16)
315 for dim in range(1, 2):
316 tree = BoundingBoxTree()
317 tree.build(mesh, dim)
318 first = tree.compute_first_collision(p)
319 assert first in reference[dim]
320
321 tree = mesh.bounding_box_tree()
322 first = tree.compute_first_collision(p)
323 assert first in reference[mesh.topology().dim()]
324
325 @skip_in_parallel
326 def test_compute_first_collision_2d():
327
328 # FIXME: This test should not use facet indices as there are no guarantees
329 # on how DOLFIN numbers facets
330 reference = {1: [226],
331 2: [136, 137]}
332
333 p = Point(0.3, 0.3)
334 mesh = UnitSquareMesh(16, 16)
335 for dim in range(1, 3):
336 tree = BoundingBoxTree()
337 tree.build(mesh, dim)
338 first = tree.compute_first_collision(p)
339
340 # FIXME: Facet test is excluded because it mistakingly relies in the
341 # facet indices
342 if dim != mesh.topology().dim() - 1:
343 assert first in reference[dim]
344
345 tree = mesh.bounding_box_tree()
346 first = tree.compute_first_collision(p)
347 assert first in reference[mesh.topology().dim()]
348
349 @skip_in_parallel
350 def test_compute_first_collision_3d():
351
352 # FIXME: This test should not use facet indices as there are no guarantees
353 # on how DOLFIN numbers facets
354
355 reference = {1: [1364],
356 2: [1967, 1968, 1970, 1972, 1974, 1976],
357 3: [876, 877, 878, 879, 880, 881]}
358
359 p = Point(0.3, 0.3, 0.3)
360 mesh = UnitCubeMesh(8, 8, 8)
361 for dim in range(1, 4):
362 tree = BoundingBoxTree()
363 tree.build(mesh, dim)
364 first = tree.compute_first_collision(p)
365
366 # FIXME: Face and test is excluded because it mistakingly
367 # relies in the facet indices
368 tdim = mesh.topology().dim()
369 if dim != tdim - 1 and dim != tdim - 2:
370 assert first in reference[dim]
371
372 tree = mesh.bounding_box_tree()
373 first = tree.compute_first_collision(p)
374 assert first in reference[mesh.topology().dim()]
375
376 #--- compute_first_entity_collision with point ---
377
378 @skip_in_parallel
379 def test_compute_first_entity_collision_1d():
380
381 reference = [4]
382
383 p = Point(0.3)
384 mesh = UnitIntervalMesh(16)
385 tree = BoundingBoxTree()
386 tree.build(mesh)
387 first = tree.compute_first_entity_collision(p)
388 assert first in reference
389
390 tree = mesh.bounding_box_tree()
391 first = tree.compute_first_entity_collision(p)
392 assert first in reference
393
394 @skip_in_parallel
395 def test_compute_first_entity_collision_2d():
396
397 reference = [136, 137]
398
399 p = Point(0.3, 0.3)
400 mesh = UnitSquareMesh(16, 16)
401 tree = BoundingBoxTree()
402 tree.build(mesh)
403 first = tree.compute_first_entity_collision(p)
404 assert first in reference
405
406 tree = mesh.bounding_box_tree()
407 first = tree.compute_first_entity_collision(p)
408 assert first in reference
409
410 @skip_in_parallel
411 def test_compute_first_entity_collision_3d():
412
413 reference = [876, 877, 878, 879, 880, 881]
414
415 p = Point(0.3, 0.3, 0.3)
416 mesh = UnitCubeMesh(8, 8, 8)
417 tree = BoundingBoxTree()
418 tree.build(mesh)
419 first = tree.compute_first_entity_collision(p)
420 assert first in reference
421
422 tree = mesh.bounding_box_tree()
423 first = tree.compute_first_entity_collision(p)
424 assert first in reference
425
426 #--- compute_closest_entity with point ---
427
428 @skip_in_parallel
429 def test_compute_closest_entity_1d():
430
431 reference = (0, 1.0)
432
433 p = Point(-1.0)
434 mesh = UnitIntervalMesh(16)
435 tree = BoundingBoxTree()
436 tree.build(mesh)
437 entity, distance = tree.compute_closest_entity(p)
438
439 assert entity == reference[0]
440 assert round(distance - reference[1], 7) == 0
441
442 tree = mesh.bounding_box_tree()
443 entity, distance = tree.compute_closest_entity(p)
444 assert entity == reference[0]
445 assert round(distance - reference[1], 7) == 0
446
447 @skip_in_parallel
448 def test_compute_closest_entity_2d():
449
450 reference = (1, 1.0)
451
452 p = Point(-1.0, 0.01)
453 mesh = UnitSquareMesh(16, 16)
454 tree = BoundingBoxTree()
455 tree.build(mesh)
456 entity, distance = tree.compute_closest_entity(p)
457
458 assert entity == reference[0]
459 assert round(distance - reference[1], 7) == 0
460
461 tree = mesh.bounding_box_tree()
462 entity, distance = tree.compute_closest_entity(p)
463 assert entity == reference[0]
464 assert round(distance - reference[1], 7) == 0
465
466 @skip_in_parallel
467 def test_compute_closest_entity_3d():
468
469 reference = (0, 0.1)
470
471 p = Point(0.1, 0.05, -0.1)
472 mesh = UnitCubeMesh(8, 8, 8)
473 tree = BoundingBoxTree()
474 tree.build(mesh)
475 entity, distance = tree.compute_closest_entity(p)
476
477 assert entity == reference[0]
478 assert round(distance - reference[1], 7) == 0
479
480 tree = mesh.bounding_box_tree()
481 entity, distance = tree.compute_closest_entity(p)
482 assert entity == reference[0]
483 assert round(distance - reference[1], 7) == 0