1 #include "MeshSet.hpp"
2 #include "AEntityFactory.hpp"
3 #include "TestUtil.hpp"
4 #include "moab/Core.hpp"
5 #include "moab/SetIterator.hpp"
6
7 using namespace moab;
8
9 #include <iostream>
10
11 //! test add_entities, get_entities, num_entities
12 void test_add_entities( unsigned flags );
13 //! test remove_entities, get_entities, num_entities
14 void test_remove_entities( unsigned flags );
15 //! test get_entities_by_type, num_entities_by_type
16 void test_entities_by_type( unsigned flags );
17 //! test get_entities_by_dimension, num_entities_by_dimension
18 void test_entities_by_dimension( unsigned flags );
19 //! test subtract_meshset
20 void test_subtract( unsigned flags1, unsigned flags2 );
21 //! test intersect_meshset
22 void test_intersect( unsigned flags1, unsigned flags2 );
23 //! test unite_meshset
24 void test_unite( unsigned flags1, unsigned flags2 );
25 //! test MeshSet::contains_entities
26 void test_contains_entities( unsigned flags );
27 //! test clear_meshset
28 void test_clear( unsigned flags );
29
30 //! Create 10x10x10 hex mesh
31 void make_mesh( Interface& iface );
32 //! Create 10x10x10 hex mesh, return ranges of handles
33 void make_mesh( Interface& iface, EntityHandle& vstart, EntityHandle& vend, EntityHandle& hstart, EntityHandle& hend );
34 //! Print std::vector<EntityHandle>
35 void print_handle_vect( const char* prefix, const std::vector<EntityHandle>& vect );
36 //! Print Range
37 void print_mbrange( const char* prefix, const Range& range );
38 //! Compare set contents against passed vector, and if MESHSET_TRACK_OWNER then check adjacencies
39 bool check_set_contents( Core& mb, EntityHandle set, const std::vector<EntityHandle>& expected );
40 //! Compare result of get_entities_by_type to result of get_entities_by_handle
41 bool check_set_contents( Core& mb, EntityType type, EntityHandle set, unsigned flags );
42 //! Compare result of get_entities_by_dimension to result of get_entities_by_handle
43 bool check_set_contents( Core& mb, int dim, EntityHandle set, unsigned flags );
44 //! For each entry in range, if one or more occurances in vect, remove last occurance from vect.
45 void remove_from_back( std::vector<EntityHandle>& vect, const Range& range );
46 enum BoolOp { UNITE, INTERSECT, SUBTRACT };
47 //! Perform boolean op on two entity sets and verify result
48 bool test_boolean( Core& mb, BoolOp op,
49 unsigned flags1, const Range& set1_ents,
50 unsigned flags2, const Range& set2_ents );
51 void test_iterator(Interface &moab, SetIterator *iter,
52 EntityHandle set, EntityType etype, int dim);
53 void test_iterators(unsigned int flags, bool type, bool dim);
54 void test_all_iterators();
55
56
test_add_entities_ordered()57 void test_add_entities_ordered() { test_add_entities( MESHSET_ORDERED ); }
test_add_entities_set()58 void test_add_entities_set() { test_add_entities( MESHSET_SET ); }
test_add_entities_ordered_tracking()59 void test_add_entities_ordered_tracking() { test_add_entities( MESHSET_TRACK_OWNER|MESHSET_ORDERED ); }
test_add_entities_set_tracking()60 void test_add_entities_set_tracking() { test_add_entities( MESHSET_TRACK_OWNER|MESHSET_SET ); }
61
test_remove_entities_ordered()62 void test_remove_entities_ordered() { test_remove_entities( MESHSET_ORDERED ); }
test_remove_entities_set()63 void test_remove_entities_set() { test_remove_entities( MESHSET_SET ); }
test_remove_entities_ordered_tracking()64 void test_remove_entities_ordered_tracking() { test_remove_entities( MESHSET_TRACK_OWNER|MESHSET_ORDERED ); }
test_remove_entities_set_tracking()65 void test_remove_entities_set_tracking() { test_remove_entities( MESHSET_TRACK_OWNER|MESHSET_SET ); }
66
test_entities_by_type_ordered()67 void test_entities_by_type_ordered() { test_entities_by_type ( MESHSET_ORDERED ); }
test_entities_by_type_set()68 void test_entities_by_type_set() { test_entities_by_type ( MESHSET_SET ); }
test_entities_by_dim_ordered()69 void test_entities_by_dim_ordered() { test_entities_by_dimension( MESHSET_ORDERED ); }
test_entities_by_dim_set()70 void test_entities_by_dim_set() { test_entities_by_dimension( MESHSET_SET ); }
71
test_subtract_set_set()72 void test_subtract_set_set() { test_subtract( MESHSET_SET , MESHSET_SET ); }
test_subtract_set_ordered()73 void test_subtract_set_ordered() { test_subtract( MESHSET_SET , MESHSET_ORDERED ); }
test_subtract_ordered_set()74 void test_subtract_ordered_set() { test_subtract( MESHSET_ORDERED, MESHSET_SET ); }
test_subtract_ordered_ordered()75 void test_subtract_ordered_ordered() { test_subtract( MESHSET_ORDERED, MESHSET_ORDERED ); }
test_subtract_set_set_tracking()76 void test_subtract_set_set_tracking() { test_subtract( MESHSET_TRACK_OWNER|MESHSET_SET , MESHSET_TRACK_OWNER|MESHSET_SET ); }
test_subtract_set_ordered_tracking()77 void test_subtract_set_ordered_tracking() { test_subtract( MESHSET_TRACK_OWNER|MESHSET_SET , MESHSET_TRACK_OWNER|MESHSET_ORDERED ); }
test_subtract_ordered_set_tracking()78 void test_subtract_ordered_set_tracking() { test_subtract( MESHSET_TRACK_OWNER|MESHSET_ORDERED, MESHSET_TRACK_OWNER|MESHSET_SET ); }
test_subtract_ordered_ordered_tracking()79 void test_subtract_ordered_ordered_tracking() { test_subtract( MESHSET_TRACK_OWNER|MESHSET_ORDERED, MESHSET_TRACK_OWNER|MESHSET_ORDERED ); }
80
test_itersect_set_set()81 void test_itersect_set_set() { test_intersect( MESHSET_SET , MESHSET_SET ); }
test_itersect_set_ordered()82 void test_itersect_set_ordered() { test_intersect( MESHSET_SET , MESHSET_ORDERED ); }
test_itersect_ordered_set()83 void test_itersect_ordered_set() { test_intersect( MESHSET_ORDERED, MESHSET_SET ); }
test_itersect_ordered_ordered()84 void test_itersect_ordered_ordered() { test_intersect( MESHSET_ORDERED, MESHSET_ORDERED ); }
test_itersect_set_set_tracking()85 void test_itersect_set_set_tracking() { test_intersect( MESHSET_TRACK_OWNER|MESHSET_SET , MESHSET_TRACK_OWNER|MESHSET_SET ); }
test_itersect_set_ordered_tracking()86 void test_itersect_set_ordered_tracking() { test_intersect( MESHSET_TRACK_OWNER|MESHSET_SET , MESHSET_TRACK_OWNER|MESHSET_ORDERED ); }
test_itersect_ordered_set_tracking()87 void test_itersect_ordered_set_tracking() { test_intersect( MESHSET_TRACK_OWNER|MESHSET_ORDERED, MESHSET_TRACK_OWNER|MESHSET_SET ); }
test_itersect_ordered_ordered_tracking()88 void test_itersect_ordered_ordered_tracking() { test_intersect( MESHSET_TRACK_OWNER|MESHSET_ORDERED, MESHSET_TRACK_OWNER|MESHSET_ORDERED ); }
89
test_unite_set_set()90 void test_unite_set_set() { test_unite( MESHSET_SET , MESHSET_SET ); }
test_unite_set_ordered()91 void test_unite_set_ordered() { test_unite( MESHSET_SET , MESHSET_ORDERED ); }
test_unite_ordered_set()92 void test_unite_ordered_set() { test_unite( MESHSET_ORDERED, MESHSET_SET ); }
test_unite_ordered_ordered()93 void test_unite_ordered_ordered() { test_unite( MESHSET_ORDERED, MESHSET_ORDERED ); }
test_unite_set_set_tracking()94 void test_unite_set_set_tracking() { test_unite( MESHSET_TRACK_OWNER|MESHSET_SET , MESHSET_TRACK_OWNER|MESHSET_SET ); }
test_unite_set_ordered_tracking()95 void test_unite_set_ordered_tracking() { test_unite( MESHSET_TRACK_OWNER|MESHSET_SET , MESHSET_TRACK_OWNER|MESHSET_ORDERED ); }
test_unite_ordered_set_tracking()96 void test_unite_ordered_set_tracking() { test_unite( MESHSET_TRACK_OWNER|MESHSET_ORDERED, MESHSET_TRACK_OWNER|MESHSET_SET ); }
test_unite_ordered_ordered_tracking()97 void test_unite_ordered_ordered_tracking() { test_unite( MESHSET_TRACK_OWNER|MESHSET_ORDERED, MESHSET_TRACK_OWNER|MESHSET_ORDERED ); }
98
test_contains_entities_ordered()99 void test_contains_entities_ordered() { test_contains_entities( MESHSET_ORDERED ); }
test_contains_entities_set()100 void test_contains_entities_set() { test_contains_entities( MESHSET_SET ); }
101
test_clear_ordered()102 void test_clear_ordered() { test_clear( MESHSET_ORDERED ); }
test_clear_set()103 void test_clear_set() { test_clear( MESHSET_SET ); }
test_clear_ordered_tracking()104 void test_clear_ordered_tracking() { test_clear( MESHSET_TRACK_OWNER|MESHSET_ORDERED ); }
test_clear_set_tracking()105 void test_clear_set_tracking() { test_clear( MESHSET_TRACK_OWNER|MESHSET_SET ); }
106
107 // Reproduce contitions that resulted in bug reported to
108 // mailing list:
109 // http://lists.mcs.anl.gov/pipermail/moab-dev/2010/002714.html
110 void regression_insert_set_1();
111
main()112 int main()
113 {
114 int err = 0;
115
116 err += RUN_TEST(test_add_entities_ordered);
117 err += RUN_TEST(test_add_entities_set);
118 err += RUN_TEST(test_add_entities_ordered_tracking);
119 err += RUN_TEST(test_add_entities_set_tracking);
120
121 err += RUN_TEST(test_remove_entities_ordered);
122 err += RUN_TEST(test_remove_entities_set);
123 err += RUN_TEST(test_remove_entities_ordered_tracking);
124 err += RUN_TEST(test_remove_entities_set_tracking);
125
126 err += RUN_TEST(test_entities_by_type_ordered);
127 err += RUN_TEST(test_entities_by_type_set);
128 err += RUN_TEST(test_entities_by_dim_ordered);
129 err += RUN_TEST(test_entities_by_dim_set);
130
131 err += RUN_TEST(test_subtract_set_set);
132 err += RUN_TEST(test_subtract_set_ordered);
133 err += RUN_TEST(test_subtract_ordered_set);
134 err += RUN_TEST(test_subtract_ordered_ordered);
135 err += RUN_TEST(test_subtract_set_set_tracking);
136 err += RUN_TEST(test_subtract_set_ordered_tracking);
137 err += RUN_TEST(test_subtract_ordered_set_tracking);
138 err += RUN_TEST(test_subtract_ordered_ordered_tracking);
139
140 err += RUN_TEST(test_itersect_set_set);
141 err += RUN_TEST(test_itersect_set_ordered);
142 err += RUN_TEST(test_itersect_ordered_set);
143 err += RUN_TEST(test_itersect_ordered_ordered);
144 err += RUN_TEST(test_itersect_set_set_tracking);
145 err += RUN_TEST(test_itersect_set_ordered_tracking);
146 err += RUN_TEST(test_itersect_ordered_set_tracking);
147 err += RUN_TEST(test_itersect_ordered_ordered_tracking);
148
149 err += RUN_TEST(test_unite_set_set);
150 err += RUN_TEST(test_unite_set_ordered);
151 err += RUN_TEST(test_unite_ordered_set);
152 err += RUN_TEST(test_unite_ordered_ordered);
153 err += RUN_TEST(test_unite_set_set_tracking);
154 err += RUN_TEST(test_unite_set_ordered_tracking);
155 err += RUN_TEST(test_unite_ordered_set_tracking);
156 err += RUN_TEST(test_unite_ordered_ordered_tracking);
157
158 err += RUN_TEST(test_contains_entities_ordered);
159 err += RUN_TEST(test_contains_entities_set);
160
161 err += RUN_TEST(test_clear_ordered);
162 err += RUN_TEST(test_clear_set);
163 err += RUN_TEST(test_clear_ordered_tracking);
164 err += RUN_TEST(test_clear_set_tracking);
165
166 err += RUN_TEST(regression_insert_set_1);
167
168 err += RUN_TEST(test_all_iterators);
169
170 if (!err)
171 printf("ALL TESTS PASSED\n");
172 else
173 printf("%d TESTS FAILED\n",err);
174
175 return err;
176 }
177
178 // Create 100x100x100 hex mesh
make_mesh(Interface & iface)179 void make_mesh( Interface& iface )
180 {
181 const int dim = 10;
182
183 // create vertices
184 EntityHandle prev_handle = 0;
185 for (int z = 0; z <= dim; ++z) {
186 for (int y = 0; y <= dim; ++y) {
187 for (int x = 0; x <= dim; ++x) {
188 const double coords[] = {static_cast<double>(x), static_cast<double>(y),
189 static_cast<double>(z)};
190 EntityHandle new_handle = 0;
191 ErrorCode rval = iface.create_vertex( coords, new_handle );
192 CHECK_ERR(rval);
193 CHECK_EQUAL( ++prev_handle, new_handle );
194 }
195 }
196 }
197
198 // create hexes
199 const int dim1 = dim + 1;
200 const int dimq = dim1 * dim1;
201 prev_handle = FIRST_HANDLE(MBHEX);
202 for (int z = 0; z < dim; ++z) {
203 for (int y = 0; y < dim; ++y) {
204 for (int x = 0; x < dim; ++x) {
205 const EntityHandle off = 1 + x + dim1*y + dimq*z;
206 const EntityHandle conn[] = { off, off+1, off+1+dim1, off+dim1,
207 off+dimq, off+1+dimq, off+1+dim1+dimq, off+dim1+dimq };
208 EntityHandle new_handle = 0;
209 ErrorCode rval = iface.create_element( MBHEX, conn, 8, new_handle );
210 CHECK_ERR(rval);
211 CHECK_EQUAL( prev_handle++, new_handle );
212 }
213 }
214 }
215
216 }
217
make_mesh(Interface & mb,EntityHandle & first_vert,EntityHandle & last_vert,EntityHandle & first_hex,EntityHandle & last_hex)218 void make_mesh( Interface& mb, EntityHandle& first_vert, EntityHandle& last_vert, EntityHandle& first_hex, EntityHandle& last_hex )
219 {
220 make_mesh( mb );
221
222 // Get handle ranges, and validate assumption that handles
223 // are contiguous.
224 Range range;
225 ErrorCode rval = mb.get_entities_by_type( 0, MBVERTEX, range );
226 CHECK_ERR(rval);
227 first_vert = range.front();
228 last_vert = range.back();
229 CHECK_EQUAL( (EntityHandle)1331, last_vert - first_vert + 1 );
230 range.clear();
231 rval = mb.get_entities_by_type( 0, MBHEX, range );
232 CHECK_ERR(rval);
233 first_hex = range.front();
234 last_hex = range.back();
235 CHECK_EQUAL( (EntityHandle)1000, last_hex - first_hex + 1 );
236 }
237
238
239 template <typename iter_type>
print_handles(std::ostream & str,const char * prefix,iter_type begin,iter_type end)240 void print_handles( std::ostream& str, const char* prefix, iter_type begin, iter_type end )
241 {
242 if (prefix)
243 str << prefix << ':';
244 if (begin == end) {
245 str << " (empty)" << std::endl;
246 return;
247 }
248
249 iter_type i = begin;
250 EntityType prev_type = TYPE_FROM_HANDLE(*i);
251 EntityHandle prev_ent = *i;
252 str << ' ' << CN::EntityTypeName(prev_type) << ' ' << ID_FROM_HANDLE(*i);
253 for (;;) {
254 iter_type j = i;
255 for (++j, ++prev_ent; j != end && *j == prev_ent; ++j, ++prev_ent);
256 --prev_ent;
257 if (prev_ent - *i > 1)
258 str << "-" << ID_FROM_HANDLE(prev_ent);
259 else if (prev_ent - *i == 1)
260 str << ", " << ID_FROM_HANDLE(prev_ent);
261
262 i = j;
263 if (i == end)
264 break;
265
266 str << ',';
267 if (TYPE_FROM_HANDLE(*i) != prev_type)
268 str << ' ' << CN::EntityTypeName(prev_type = TYPE_FROM_HANDLE(*i));
269 str << ' ' << ID_FROM_HANDLE(*i);
270 prev_ent = *i;
271 }
272 str << std::endl;
273 }
274
print_handle_vect(const char * prefix,const std::vector<EntityHandle> & vect)275 void print_handle_vect( const char* prefix, const std::vector<EntityHandle>& vect )
276 {
277 print_handles(std::cout, prefix, vect.begin(), vect.end());
278 }
279
print_mbrange(const char * prefix,const Range & range)280 void print_mbrange( const char* prefix, const Range& range )
281 {
282 print_handles(std::cout, prefix, range.begin(), range.end());
283 }
284
compare_set_contents(unsigned flags,const std::vector<EntityHandle> & expected,int set_count,std::vector<EntityHandle> & vect,const Range & range)285 bool compare_set_contents( unsigned flags,
286 const std::vector<EntityHandle>& expected,
287 int set_count,
288 std::vector<EntityHandle>& vect,
289 const Range& range )
290 {
291
292 std::vector<EntityHandle> sorted( expected );
293 std::sort( sorted.begin(), sorted.end() );
294 sorted.erase( std::unique( sorted.begin(), sorted.end() ), sorted.end() );
295
296 int expected_size = 0;
297 if (flags&MESHSET_ORDERED) {
298 if (expected != vect) {
299 std::cout << "Incorrect set contents from vector-based query" << std::endl;
300 print_handle_vect( "Expected", expected );
301 print_handle_vect( "Actual", vect );
302 return false;
303 }
304 expected_size = expected.size();
305 }
306 else {
307 if (sorted != vect) {
308 std::cout << "Incorrect set contents from vector-based query" << std::endl;
309 print_handle_vect( "Expected", sorted );
310 print_handle_vect( "Actual", vect );
311 return false;
312 }
313 expected_size = sorted.size();
314 }
315
316 if (expected_size != set_count) {
317 std::cout << "Incorrect size for entity set" << std::endl;
318 std::cout << "Expected: " << expected_size << std::endl;
319 std::cout << "Actual: " << set_count << std::endl;
320 return false;
321 }
322
323 vect.clear();
324 vect.resize( range.size() );
325 std::copy( range.begin(), range.end(), vect.begin() );
326 if (sorted != vect) {
327 std::cout << "Incorrect set contents from mbrange-based query" << std::endl;
328 print_handle_vect( "Expected", vect );
329 print_mbrange( "Actual", range );
330 return false;
331 }
332
333 return true;
334 }
335
check_set_contents(Core & mb,EntityHandle set,const std::vector<EntityHandle> & expected)336 bool check_set_contents( Core& mb, EntityHandle set, const std::vector<EntityHandle>& expected )
337 {
338 unsigned flags;
339 ErrorCode rval = mb.get_meshset_options( set, flags );
340 CHECK_ERR(rval);
341
342 int count;
343 std::vector<EntityHandle> vect;
344 Range range;
345 rval = mb.get_entities_by_handle( set, vect, false );
346 CHECK_ERR(rval);
347 rval = mb.get_entities_by_handle( set, range, false );
348 CHECK_ERR(rval);
349 rval = mb.get_number_entities_by_handle( set, count, false );
350 CHECK_ERR(rval);
351
352 if (!compare_set_contents( flags, expected, count, vect, range ))
353 return false;
354
355 if (!(flags&MESHSET_TRACK_OWNER))
356 return true;
357
358 // get all entitites with an adjacency to the set
359 std::vector<EntityHandle> adj;
360 Range all, adjacent;
361 Range::iterator in = adjacent.begin();
362 mb.get_entities_by_handle( 0, all );
363 for (Range::iterator i = all.begin(); i != all.end(); ++i) {
364 adj.clear();
365 rval = mb.a_entity_factory()->get_adjacencies( *i, adj );
366 CHECK_ERR(rval);
367 std::vector<EntityHandle>::iterator j = std::lower_bound( adj.begin(), adj.end(), set );
368 if (j != adj.end() && *j == set)
369 in = adjacent.insert( in, *i, *i );
370 }
371
372 if (range != adjacent) {
373 std::cout << "Incorrect adjacent entities for tracking set" << std::endl;
374 print_mbrange( "Expected", range );
375 print_mbrange( "Actual", adjacent );
376 return false;
377 }
378
379 return true;
380 }
381
check_set_contents(Core & mb,EntityType type,EntityHandle set,unsigned flags)382 bool check_set_contents( Core& mb, EntityType type, EntityHandle set, unsigned flags )
383 {
384 ErrorCode rval;
385 int count;
386 std::vector<EntityHandle> vect, expected;
387 Range range;
388
389 rval = mb.get_entities_by_handle( set, expected, false );
390 CHECK_ERR(rval);
391 std::vector<EntityHandle>::iterator i = expected.begin();
392 while (i != expected.end()) {
393 if (TYPE_FROM_HANDLE(*i) != type)
394 i = expected.erase( i );
395 else
396 ++i;
397 }
398
399 rval = mb.get_entities_by_type( set, type, range, false );
400 CHECK_ERR(rval);
401 rval = mb.get_number_entities_by_type( set, type, count, false );
402 CHECK_ERR(rval);
403
404 std::copy( range.begin(), range.end(), std::back_inserter(vect) );
405 return compare_set_contents( flags, expected, count, vect, range );
406 }
407
check_set_contents(Core & mb,int dim,EntityHandle set,unsigned flags)408 bool check_set_contents( Core& mb, int dim, EntityHandle set, unsigned flags )
409 {
410 ErrorCode rval;
411 int count;
412 std::vector<EntityHandle> vect, expected;
413 Range range;
414
415 rval = mb.get_entities_by_handle( set, expected, false );
416 CHECK_ERR(rval);
417 std::vector<EntityHandle>::iterator i = expected.begin();
418 while (i != expected.end()) {
419 if (CN::Dimension(TYPE_FROM_HANDLE(*i)) != dim)
420 i = expected.erase( i );
421 else
422 ++i;
423 }
424
425 rval = mb.get_entities_by_dimension( set, dim, range, false );
426 CHECK_ERR(rval);
427 rval = mb.get_number_entities_by_dimension( set, dim, count, false );
428 CHECK_ERR(rval);
429
430 std::copy( range.begin(), range.end(), std::back_inserter(vect) );
431 return compare_set_contents( flags, expected, count, vect, range );
432 }
433
test_add_entities(unsigned flags)434 void test_add_entities( unsigned flags )
435 {
436 Core mb; make_mesh( mb );
437
438 EntityHandle set;
439 ErrorCode rval = mb.create_meshset( flags, set );
440 CHECK_ERR(rval);
441
442 std::vector<EntityHandle> contents, vect;
443 Range range;
444
445 range.clear();
446 range.insert( 11, 20 );
447 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
448 rval = mb.add_entities( set, range );
449 CHECK_ERR(rval);
450 // [11,20]
451 CHECK( check_set_contents( mb, set, contents ) );
452
453 range.clear();
454 range.insert( 31, 40 );
455 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
456 rval = mb.add_entities( set, range );
457 CHECK_ERR(rval);
458 // [11,20],[31,40]
459 CHECK( check_set_contents( mb, set, contents ) );
460
461 range.clear();
462 range.insert( 51, 60 );
463 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
464 rval = mb.add_entities( set, range );
465 CHECK_ERR(rval);
466 // [11,20],[31,40],[51,60]
467 CHECK( check_set_contents( mb, set, contents ) );
468
469 range.clear();
470 range.insert( 71, 80 );
471 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
472 rval = mb.add_entities( set, range );
473 CHECK_ERR(rval);
474 // [11,20],[31,40],[51,60],[71,80]
475 CHECK( check_set_contents( mb, set, contents ) );
476
477 range.clear();
478 range.insert( 91, 100 );
479 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
480 rval = mb.add_entities( set, range );
481 CHECK_ERR(rval);
482 // [11,20],[31,40],[51,60],[71,80],[91,100]
483 CHECK( check_set_contents( mb, set, contents ) );
484
485 range.clear();
486 range.insert( 111, 120 );
487 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
488 rval = mb.add_entities( set, range );
489 CHECK_ERR(rval);
490 // [11,20],[31,40],[51,60],[71,80],[91,100],[111,120]
491 CHECK( check_set_contents( mb, set, contents ) );
492
493 range.clear();
494 range.insert( 6, 12 );
495 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
496 rval = mb.add_entities( set, range );
497 CHECK_ERR(rval);
498 // [6,20],[31,40],[51,60],[71,80],[91,100],[111,120]
499 CHECK( check_set_contents( mb, set, contents ) );
500
501 range.clear();
502 range.insert( 1, 3 );
503 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
504 rval = mb.add_entities( set, range );
505 CHECK_ERR(rval);
506 // [1,3],[6,20],[31,40],[51,60],[71,80],[91,100],[111,120]
507 CHECK( check_set_contents( mb, set, contents ) );
508
509 range.clear();
510 range.insert( 25, 25 );
511 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
512 rval = mb.add_entities( set, range );
513 CHECK_ERR(rval);
514 // [1,3],[6,20],[25,25],[31,40],[51,60],[71,80],[91,100],[111,120]
515 CHECK( check_set_contents( mb, set, contents ) );
516
517 range.clear();
518 range.insert( 30, 30 );
519 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
520 rval = mb.add_entities( set, range );
521 CHECK_ERR(rval);
522 // [1,3],[6,20],[25,25],[30,40],[51,60],[71,80],[91,100],[111,120]
523 CHECK( check_set_contents( mb, set, contents ) );
524
525 range.clear();
526 range.insert( 29, 31 );
527 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
528 rval = mb.add_entities( set, range );
529 CHECK_ERR(rval);
530 // [1,3],[6,20],[25,25],[29,40],[51,60],[71,80],[91,100],[111,120]
531 CHECK( check_set_contents( mb, set, contents ) );
532
533 range.clear();
534 range.insert( 41, 41 );
535 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
536 rval = mb.add_entities( set, range );
537 CHECK_ERR(rval);
538 // [1,3],[6,20],[25,25],[29,41],[51,60],[71,80],[91,100],[111,120]
539 CHECK( check_set_contents( mb, set, contents ) );
540
541 range.clear();
542 range.insert( 41, 45 );
543 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
544 rval = mb.add_entities( set, range );
545 CHECK_ERR(rval);
546 // [1,3],[6,20],[25,25],[29,45],[51,60],[71,80],[91,100],[111,120]
547 CHECK( check_set_contents( mb, set, contents ) );
548
549 range.clear();
550 range.insert( 47, 47 );
551 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
552 rval = mb.add_entities( set, range );
553 CHECK_ERR(rval);
554 // [1,3],[6,20],[25,25],[29,45],[47,47],[51,60],[71,80],[91,100],[111,120]
555 CHECK( check_set_contents( mb, set, contents ) );
556
557 range.clear();
558 range.insert( 51, 80 );
559 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
560 rval = mb.add_entities( set, range );
561 CHECK_ERR(rval);
562 // [1,3],[6,20],[25,25],[29,45],[47,47],[51,80],[91,100],[111,120]
563 CHECK( check_set_contents( mb, set, contents ) );
564
565 range.clear();
566 range.insert( 49, 105 );
567 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
568 rval = mb.add_entities( set, range );
569 CHECK_ERR(rval);
570 // [1,3],[6,20],[25,25],[29,45],[47,47],[49,105],[111,120]
571 CHECK( check_set_contents( mb, set, contents ) );
572
573 vect.clear();
574 for (EntityHandle h = 1; h < 100; ++h) {
575 vect.push_back(h);
576 contents.push_back(h);
577 }
578 rval = mb.add_entities( set, &vect[0], vect.size() );
579 CHECK_ERR(rval);
580 // [1,105],[111,120]
581 CHECK( check_set_contents( mb, set, contents ) );
582
583 vect.clear();
584 vect.push_back( 106 );
585 vect.push_back( 108 );
586 vect.push_back( 110 );
587 std::copy( vect.begin(), vect.end(), std::back_inserter(contents) );
588 rval = mb.add_entities( set, &vect[0], vect.size() );
589 CHECK_ERR(rval);
590 // [1,106],[108,108],[110,120]
591 CHECK( check_set_contents( mb, set, contents ) );
592
593 range.clear();
594 range.insert( 107, 200 );
595 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
596 rval = mb.add_entities( set, range );
597 CHECK_ERR(rval);
598 // [1,200]
599 CHECK( check_set_contents( mb, set, contents ) );
600
601 range.clear();
602 range.insert( 1, 1 );
603 range.insert( 5, 6 );
604 range.insert( 199, 200 );
605 range.insert( 201, 202 );
606 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
607 rval = mb.add_entities( set, range );
608 CHECK_ERR(rval);
609 // [1,202]
610 CHECK( check_set_contents( mb, set, contents ) );
611
612 range.clear();
613 range.insert( 300, 301 );
614 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
615 rval = mb.add_entities( set, range );
616 CHECK_ERR(rval);
617 // [1,202],[300,301]
618 CHECK( check_set_contents( mb, set, contents ) );
619
620 range.clear();
621 range.insert( 203,203 );
622 range.insert( 205,205 );
623 range.insert( 207,207 );
624 range.insert( 299,299 );
625 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
626 rval = mb.add_entities( set, range );
627 CHECK_ERR(rval);
628 // [1,203],[205,205],[207,207],[299,301]
629 CHECK( check_set_contents( mb, set, contents ) );
630 }
631
remove_from_back(std::vector<EntityHandle> & vect,const Range & range)632 void remove_from_back( std::vector<EntityHandle>& vect, const Range& range )
633 {
634 for (Range::const_iterator r = range.begin(); r != range.end(); ++r) {
635 std::vector<EntityHandle>::reverse_iterator i = find( vect.rbegin(), vect.rend(), *r );
636 if (i != vect.rend())
637 *i = 0;
638 }
639 std::vector<EntityHandle>::iterator j = vect.begin();
640 while (j != vect.end()) {
641 if (*j == 0)
642 j = vect.erase(j);
643 else
644 ++j;
645 }
646 }
647
test_remove_entities(unsigned flags)648 void test_remove_entities( unsigned flags )
649 {
650 Core mb; make_mesh( mb );
651
652 EntityHandle set;
653 ErrorCode rval = mb.create_meshset( flags, set );
654 CHECK_ERR(rval);
655
656 std::vector<EntityHandle> contents;
657 Range range;
658
659 range.clear();
660 range.insert( 1, 1000 );
661 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
662 rval = mb.add_entities( set, range );
663 CHECK_ERR(rval);
664 // [1,1000]
665 CHECK( check_set_contents( mb, set, contents ) );
666
667 range.clear();
668 range.insert( 1, 5 );
669 remove_from_back( contents, range );
670 rval = mb.remove_entities( set, range );
671 CHECK_ERR(rval);
672 // [6,1000]
673 CHECK( check_set_contents( mb, set, contents ) );
674
675 range.clear();
676 range.insert( 6, 6 );
677 remove_from_back( contents, range );
678 rval = mb.remove_entities( set, range );
679 CHECK_ERR(rval);
680 // [7,1000]
681 CHECK( check_set_contents( mb, set, contents ) );
682
683 range.clear();
684 range.insert( 7, 10 );
685 remove_from_back( contents, range );
686 rval = mb.remove_entities( set, range );
687 CHECK_ERR(rval);
688 // [11,1000]
689 CHECK( check_set_contents( mb, set, contents ) );
690
691 range.clear();
692 range.insert( 1, 20 );
693 remove_from_back( contents, range );
694 rval = mb.remove_entities( set, range );
695 CHECK_ERR(rval);
696 // [21,1000]
697 CHECK( check_set_contents( mb, set, contents ) );
698
699 range.clear();
700 range.insert( 1, 5 );
701 remove_from_back( contents, range );
702 rval = mb.remove_entities( set, range );
703 CHECK_ERR(rval);
704 // [21,1000]
705 CHECK( check_set_contents( mb, set, contents ) );
706
707 range.clear();
708 range.insert( 22, 30 );
709 remove_from_back( contents, range );
710 rval = mb.remove_entities( set, range );
711 CHECK_ERR(rval);
712 // [21,21],[31,1000]
713 CHECK( check_set_contents( mb, set, contents ) );
714
715 range.clear();
716 range.insert( 1000, 1000 );
717 remove_from_back( contents, range );
718 rval = mb.remove_entities( set, range );
719 CHECK_ERR(rval);
720 // [21,21],[31,999]
721 CHECK( check_set_contents( mb, set, contents ) );
722
723 range.clear();
724 range.insert( 901, 999 );
725 remove_from_back( contents, range );
726 rval = mb.remove_entities( set, range );
727 CHECK_ERR(rval);
728 // [21,21],[31,900]
729 CHECK( check_set_contents( mb, set, contents ) );
730
731 range.clear();
732 range.insert( 900, 999 );
733 remove_from_back( contents, range );
734 rval = mb.remove_entities( set, range );
735 CHECK_ERR(rval);
736 // [21,21],[31,899]
737 CHECK( check_set_contents( mb, set, contents ) );
738
739 range.clear();
740 range.insert( 1000, 1001 );
741 remove_from_back( contents, range );
742 rval = mb.remove_entities( set, range );
743 CHECK_ERR(rval);
744 // [21,21],[31,899]
745 CHECK( check_set_contents( mb, set, contents ) );
746
747 range.clear();
748 range.insert( 890, 898 );
749 remove_from_back( contents, range );
750 rval = mb.remove_entities( set, range );
751 CHECK_ERR(rval);
752 // [21,21],[31,889],[899,899]
753 CHECK( check_set_contents( mb, set, contents ) );
754
755 range.clear();
756 range.insert( 100, 149 );
757 remove_from_back( contents, range );
758 rval = mb.remove_entities( set, range );
759 CHECK_ERR(rval);
760 // [21,21],[31,99],[150,889],[899,899]
761 CHECK( check_set_contents( mb, set, contents ) );
762
763 range.clear();
764 range.insert( 31, 99 );
765 remove_from_back( contents, range );
766 rval = mb.remove_entities( set, range );
767 CHECK_ERR(rval);
768 // [21,21],[150,889],[899,899]
769 CHECK( check_set_contents( mb, set, contents ) );
770
771 range.clear();
772 range.insert( 200, 249 );
773 remove_from_back( contents, range );
774 rval = mb.remove_entities( set, range );
775 CHECK_ERR(rval);
776 // [21,21],[150,199],[250,889],[899,899]
777 CHECK( check_set_contents( mb, set, contents ) );
778
779 range.clear();
780 range.insert( 300, 349 );
781 remove_from_back( contents, range );
782 rval = mb.remove_entities( set, range );
783 CHECK_ERR(rval);
784 // [21,21],[150,199],[250,299],[350,889],[899,899]
785 CHECK( check_set_contents( mb, set, contents ) );
786
787 range.clear();
788 range.insert( 159, 399 );
789 remove_from_back( contents, range );
790 rval = mb.remove_entities( set, range );
791 CHECK_ERR(rval);
792 // [21,21],[150,158],[400,889],[899,899]
793 CHECK( check_set_contents( mb, set, contents ) );
794
795 range.clear();
796 range.insert( 450, 499 );
797 remove_from_back( contents, range );
798 rval = mb.remove_entities( set, range );
799 CHECK_ERR(rval);
800 // [21,21],[150,158],[400,449],[500,889],[899,899]
801 CHECK( check_set_contents( mb, set, contents ) );
802
803 range.clear();
804 range.insert( 550, 599 );
805 remove_from_back( contents, range );
806 rval = mb.remove_entities( set, range );
807 CHECK_ERR(rval);
808 // [21,21],[150,158],[400,449],[500,549],[600,889],[899,899]
809 CHECK( check_set_contents( mb, set, contents ) );
810
811 range.clear();
812 range.insert( 150, 549 );
813 remove_from_back( contents, range );
814 rval = mb.remove_entities( set, range );
815 CHECK_ERR(rval);
816 // [21,21],[600,889],[899,899]
817 CHECK( check_set_contents( mb, set, contents ) );
818
819 range.clear();
820 range.insert( 650, 699 );
821 remove_from_back( contents, range );
822 rval = mb.remove_entities( set, range );
823 CHECK_ERR(rval);
824 // [21,21],[600,649],[700,889],[899,899]
825 CHECK( check_set_contents( mb, set, contents ) );
826
827
828 // test vector-based remove
829 assert(contents.size() == 242);
830 std::vector<EntityHandle> remlist(5);
831 remlist[0] = contents[240]; contents.erase( contents.begin() + 240 );
832 remlist[1] = contents[200]; contents.erase( contents.begin() + 200 );
833 remlist[2] = contents[100]; contents.erase( contents.begin() + 100 );
834 remlist[3] = contents[ 25]; contents.erase( contents.begin() + 25 );
835 remlist[4] = contents[ 0]; contents.erase( contents.begin() + 0 );
836 rval = mb.remove_entities( set, &remlist[0], remlist.size() );
837 CHECK_ERR(rval);
838 // [600,623],[625,649],[700,748],[750,848],[850,888],[899,899]
839 CHECK( check_set_contents( mb, set, contents ) );
840
841 // remove everything
842 std::reverse( contents.begin(), contents.begin() + contents.size()/2 ); // mix up a bit
843 rval = mb.remove_entities( set, &contents[0], contents.size() );
844 CHECK_ERR(rval);
845 contents.clear();
846 CHECK( check_set_contents( mb, set, contents ) );
847
848 // try complicated range-based remove
849 range.clear();
850 contents.clear();
851 range.insert( 100, 200 );
852 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
853 rval = mb.add_entities( set, range );
854 CHECK_ERR(rval);
855 // [1000,2000]
856 CHECK( check_set_contents( mb, set, contents ) );
857
858 Range remove;
859 remove.insert( 1, 3 );
860 remove.insert( 10, 100 );
861 remove.insert( 110, 120 );
862 remove.insert( 130, 140 );
863 remove.insert( 150, 160 );
864 remove.insert( 190, 200 );
865 remove.insert( 210, 220 );
866 remove.insert( 230, 240 );
867 range = subtract( range, remove );
868
869 contents.clear();
870 std::copy( range.begin(), range.end(), std::back_inserter(contents) );
871 rval = mb.remove_entities( set, remove );
872 CHECK_ERR(rval);
873 CHECK( check_set_contents( mb, set, contents ) );
874 }
875
test_entities_by_type(unsigned flags)876 void test_entities_by_type( unsigned flags )
877 {
878 EntityHandle first_vert, last_vert, first_hex, last_hex;
879 Core mb; make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
880
881 // Create an entity set
882 EntityHandle set;
883 ErrorCode rval = mb.create_meshset( flags, set );
884 CHECK_ERR(rval);
885
886 // Test empty set
887 CHECK( check_set_contents( mb, MBVERTEX, set, flags ) );
888 CHECK( check_set_contents( mb, MBEDGE , set, flags ) );
889 CHECK( check_set_contents( mb, MBHEX , set, flags ) );
890
891 // Add stuff to set
892 Range range;
893 range.insert( first_vert , first_vert + 10 );
894 range.insert( first_vert + 100, first_vert + 110 );
895 range.insert( first_hex + 200, first_hex + 299 );
896 range.insert( last_hex , last_hex - 99 );
897 rval = mb.add_entities( set, range );
898 CHECK_ERR(rval);
899
900 // Test
901 CHECK( check_set_contents( mb, MBVERTEX, set, flags ) );
902 CHECK( check_set_contents( mb, MBEDGE , set, flags ) );
903 CHECK( check_set_contents( mb, MBHEX , set, flags ) );
904 }
905
test_entities_by_dimension(unsigned flags)906 void test_entities_by_dimension( unsigned flags )
907 {
908 EntityHandle first_vert, last_vert, first_hex, last_hex;
909 Core mb; make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
910
911 // Create an entity set
912 EntityHandle set;
913 ErrorCode rval = mb.create_meshset( flags, set );
914 CHECK_ERR(rval);
915
916 // Test empty set
917 CHECK( check_set_contents( mb, 0, set, flags ) );
918 CHECK( check_set_contents( mb, 1, set, flags ) );
919 CHECK( check_set_contents( mb, 2, set, flags ) );
920 CHECK( check_set_contents( mb, 3, set, flags ) );
921
922 // Add stuff to set
923 Range range;
924 range.insert( first_vert , first_vert + 10 );
925 range.insert( first_vert + 100, first_vert + 110 );
926 range.insert( first_hex + 200, first_hex + 299 );
927 range.insert( last_hex , last_hex - 99 );
928 rval = mb.add_entities( set, range );
929 CHECK_ERR(rval);
930
931 // Test
932 CHECK( check_set_contents( mb, 0, set, flags ) );
933 CHECK( check_set_contents( mb, 1, set, flags ) );
934 CHECK( check_set_contents( mb, 2, set, flags ) );
935 CHECK( check_set_contents( mb, 3, set, flags ) );
936 }
937
test_boolean(Core & mb,BoolOp op,unsigned flags1,const Range & set1_ents,unsigned flags2,const Range & set2_ents)938 bool test_boolean( Core& mb, BoolOp op,
939 unsigned flags1, const Range& set1_ents,
940 unsigned flags2, const Range& set2_ents )
941 {
942 ErrorCode rval;
943
944 // make sets
945 EntityHandle set1, set2;
946 rval = mb.create_meshset( flags1, set1 );
947 CHECK_ERR(rval);
948 rval = mb.create_meshset( flags2, set2 );
949 CHECK_ERR(rval);
950 rval = mb.add_entities( set1, set1_ents );
951 CHECK_ERR(rval);
952 rval = mb.add_entities( set2, set2_ents );
953 CHECK_ERR(rval);
954
955 Range tmp_range;
956 std::vector<EntityHandle> expected;
957 rval = MB_INDEX_OUT_OF_RANGE;
958 switch (op) {
959 case UNITE:
960 if (flags1 & MESHSET_SET) {
961 tmp_range = set1_ents;
962 tmp_range.merge( set2_ents );
963 expected.resize( tmp_range.size() );
964 std::copy( tmp_range.begin(), tmp_range.end(), expected.begin() );
965 }
966 else {
967 expected.clear();
968 std::copy( set1_ents.begin(), set1_ents.end(), std::back_inserter(expected) );
969 std::copy( set2_ents.begin(), set2_ents.end(), std::back_inserter(expected) );
970 }
971 rval = mb.unite_meshset( set1, set2 );
972 break;
973 case INTERSECT:
974 tmp_range = intersect( set1_ents, set2_ents );
975 expected.resize(tmp_range.size());
976 std::copy( tmp_range.begin(), tmp_range.end(), expected.begin() );
977 rval = mb.intersect_meshset( set1, set2 );
978 break;
979 case SUBTRACT:
980 tmp_range = subtract( set1_ents, set2_ents );
981 expected.resize(tmp_range.size());
982 std::copy( tmp_range.begin(), tmp_range.end(), expected.begin() );
983 rval = mb.subtract_meshset( set1, set2 );
984 break;
985 }
986 CHECK_ERR(rval);
987
988 return check_set_contents( mb, set1, expected );
989 }
990
991
test_intersect(unsigned flags1,unsigned flags2)992 void test_intersect( unsigned flags1, unsigned flags2 )
993 {
994 Range empty, set1_ents, set2_ents;
995 EntityHandle first_vert, last_vert, first_hex, last_hex;
996 Core mb; make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
997
998 // define contents of first set
999 set1_ents.insert( first_vert, first_vert + 10 );
1000 set1_ents.insert( first_vert+100, first_vert+199 );
1001 set1_ents.insert( first_hex+100, first_hex+200 );
1002
1003 // define contents of second set
1004 set2_ents.insert( first_vert, first_vert );
1005 set2_ents.insert( first_vert+10, first_vert+10 );
1006 set2_ents.insert( first_vert+90, first_vert+209 );
1007 set2_ents.insert( first_hex+50, first_hex+300 );
1008
1009 // check empty sets
1010 CHECK( test_boolean( mb, INTERSECT, flags1, empty, flags2, empty ) );
1011 // check intersection with 1 empty
1012 CHECK( test_boolean( mb, INTERSECT, flags1, empty, flags2, set2_ents ) );
1013 CHECK( test_boolean( mb, INTERSECT, flags1, set1_ents, flags2, empty ) );
1014 // check intersection of non-empty sets
1015 CHECK( test_boolean( mb, INTERSECT, flags1, set1_ents, flags2, set2_ents ) );
1016 }
1017
test_unite(unsigned flags1,unsigned flags2)1018 void test_unite( unsigned flags1, unsigned flags2 )
1019 {
1020 Range empty, set1_ents, set2_ents;
1021 EntityHandle first_vert, last_vert, first_hex, last_hex;
1022 Core mb; make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
1023
1024 // define contents of first set
1025 set1_ents.insert( first_vert, first_vert + 10 );
1026 set1_ents.insert( first_vert+100, first_vert+199 );
1027 set1_ents.insert( first_hex+100, first_hex+200 );
1028
1029 // define contents of second set
1030 set2_ents.insert( first_vert, first_vert );
1031 set2_ents.insert( first_vert+11, first_vert+99 );
1032 set2_ents.insert( first_vert+150, first_vert+209 );
1033 set2_ents.insert( first_vert+211, first_vert+211 );
1034 set2_ents.insert( first_hex+50, first_hex+99 );
1035
1036 // check empty sets
1037 CHECK( test_boolean( mb, UNITE, flags1, empty, flags2, empty ) );
1038 // check union with 1 empty
1039 CHECK( test_boolean( mb, UNITE, flags1, empty, flags2, set2_ents ) );
1040 CHECK( test_boolean( mb, UNITE, flags1, set1_ents, flags2, empty ) );
1041 // check union of non-empty sets
1042 CHECK( test_boolean( mb, UNITE, flags1, set1_ents, flags2, set2_ents ) );
1043 }
1044
test_subtract(unsigned flags1,unsigned flags2)1045 void test_subtract( unsigned flags1, unsigned flags2 )
1046 {
1047 Range empty, set1_ents, set2_ents;
1048 EntityHandle first_vert, last_vert, first_hex, last_hex;
1049 Core mb; make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
1050
1051 // define contents of first set
1052 set1_ents.insert( first_vert, first_vert + 10 );
1053 set1_ents.insert( first_vert+100, first_vert+199 );
1054 set1_ents.insert( first_hex+100, first_hex+200 );
1055
1056 // define contents of second set
1057 set2_ents.insert( first_vert, first_vert );
1058 set2_ents.insert( first_vert+9, first_vert+9 );
1059 set2_ents.insert( first_vert+11, first_vert+99 );
1060 set2_ents.insert( first_vert+150, first_vert+199 );
1061 set2_ents.insert( first_hex+50, first_hex+60 );
1062 set2_ents.insert( first_hex+90, first_hex+220 );
1063
1064 // check empty sets
1065 CHECK( test_boolean( mb, SUBTRACT, flags1, empty, flags2, empty ) );
1066 // check union with 1 empty
1067 CHECK( test_boolean( mb, SUBTRACT, flags1, empty, flags2, set2_ents ) );
1068 CHECK( test_boolean( mb, SUBTRACT, flags1, set1_ents, flags2, empty ) );
1069 // check union of non-empty sets
1070 CHECK( test_boolean( mb, SUBTRACT, flags1, set1_ents, flags2, set2_ents ) );
1071 }
1072
test_contains_entities(unsigned flags)1073 void test_contains_entities( unsigned flags )
1074 {
1075 CHECK( !(flags&MESHSET_TRACK_OWNER) );
1076 MeshSet set(flags);
1077 bool result;
1078
1079 const EntityHandle entities[] = { 1,2,3,6,10,11,25,100 };
1080 const int num_ents = sizeof(entities)/sizeof(EntityHandle);
1081 ErrorCode rval = set.add_entities( entities, num_ents, 0, 0 );
1082 CHECK_ERR(rval);
1083
1084 result = set.contains_entities( entities, num_ents, Interface::UNION );
1085 CHECK(result);
1086 result = set.contains_entities( entities, num_ents, Interface::INTERSECT );
1087 CHECK(result);
1088
1089 result = set.contains_entities( entities, 1, Interface::UNION );
1090 CHECK(result);
1091 result = set.contains_entities( entities, 1, Interface::INTERSECT );
1092 CHECK(result);
1093
1094 const EntityHandle entities2[] = { 3,4,5 };
1095 const int num_ents2 = sizeof(entities2)/sizeof(EntityHandle);
1096 result = set.contains_entities( entities2, num_ents2, Interface::UNION );
1097 CHECK(result);
1098 result = set.contains_entities( entities2, num_ents2, Interface::INTERSECT );
1099 CHECK(!result);
1100 }
1101
test_clear(unsigned flags)1102 void test_clear( unsigned flags )
1103 {
1104 std::vector<EntityHandle> contents(4);
1105 Core mb; make_mesh( mb, contents[0], contents[1], contents[2], contents[3] );
1106 EntityHandle set;
1107 ErrorCode rval = mb.create_meshset( flags, set );
1108 CHECK_ERR(rval);
1109 rval = mb.add_entities( set, &contents[0], contents.size() );
1110 CHECK_ERR(rval);
1111 CHECK( check_set_contents( mb, set, contents ) );
1112 rval = mb.clear_meshset( &set, 1 );
1113 CHECK_ERR(rval);
1114 contents.clear();
1115 CHECK( check_set_contents( mb, set, contents ) );
1116 }
1117
regression_insert_set_1()1118 void regression_insert_set_1()
1119 {
1120 EntityHandle e = CREATE_HANDLE(MBEDGE,0);
1121 EntityHandle q = CREATE_HANDLE(MBQUAD,0);
1122 const EntityHandle initial_ranges[] =
1123 { 0x7fe, 0x7fe,
1124 0x802, 0x80b,
1125 0xb3a, 0xb3c,
1126 0xb6b, 0xb6b,
1127 0xbed, 0xbee,
1128 0x19ff, 0x19ff,
1129 0x1a0b, 0x1a0b,
1130 0x1a16, 0x1a17,
1131 0x1a56, 0x1a57,
1132 0x2554, 0x255c,
1133 e+0x0099, e+0x009b,
1134 e+0x00c0, e+0x00c2,
1135 e+0x0729, e+0x0732,
1136 e+0x0a3b, e+0x0a3d,
1137 e+0x0ba9, e+0x0bab,
1138 e+0x2322, e+0x232b,
1139 q+0x00c, q+0x017,
1140 q+0x0e9, q+0x112,
1141 q+0x2f2, q+0x303,
1142 q+0x67e, q+0x6a5,
1143 q+0x866, q+0x871,
1144 q+0x8f5, q+0x900,
1145 q+0xc06, q+0xc17,
1146 q+0xc7e, q+0xc9b,
1147 q+0xce0, q+0xd07 };
1148
1149 const EntityHandle new_ranges[] = {
1150 0x7e1, 0x829,
1151 0xb37, 0xb63,
1152 0xb6b, 0xb6b,
1153 0xb73, 0xb75,
1154 0xbed, 0xbee,
1155 0xc0b, 0xc10,
1156 0x19fd, 0x19fd,
1157 0x19ff, 0x19ff,
1158 0x1a02, 0x1a04,
1159 0x1a0b, 0x1a0b,
1160 0x1a11, 0x1a17,
1161 0x1a1b, 0x1a23,
1162 0x1a56, 0x1a57,
1163 0x1a7c, 0x1a96,
1164 0x1bb5, 0x1bba,
1165 0x254b, 0x2565,
1166 0x25a5, 0x25bf };
1167
1168 Core moab;
1169 Interface& mb = moab;
1170 ErrorCode rval;
1171
1172 EntityHandle set;
1173 rval = mb.create_meshset( MESHSET_SET, set );
1174 CHECK_ERR(rval);
1175
1176 Range init, add;
1177 for (size_t i = 0; i < sizeof(initial_ranges)/sizeof(initial_ranges[0]); i += 2)
1178 init.insert( initial_ranges[i], initial_ranges[i+1] );
1179 for (size_t i = 0; i < sizeof(new_ranges)/sizeof(new_ranges[0]); i += 2)
1180 add.insert( new_ranges[i], new_ranges[i+1] );
1181
1182 rval = mb.add_entities( set, init );
1183 CHECK_ERR(rval);
1184 rval = mb.add_entities( set, add );
1185 CHECK_ERR(rval);
1186
1187 std::vector<EntityHandle> contents;
1188 rval = mb.get_entities_by_handle( set, contents );
1189 CHECK_ERR(rval);
1190
1191 init.merge( add );
1192 Range::iterator r = init.begin();
1193 std::vector<EntityHandle>::iterator v = contents.begin();
1194 for (;;) {
1195 if (r == init.end() || v == contents.end()) {
1196 CHECK( r == init.end() );
1197 CHECK( v == contents.end() );
1198 break;
1199 }
1200 CHECK_EQUAL( *r, *v );
1201 ++r;
1202 ++v;
1203 }
1204 }
1205
test_all_iterators()1206 void test_all_iterators()
1207 {
1208 test_iterators(MESHSET_SET, true, false);
1209 test_iterators(MESHSET_SET, false, true);
1210
1211 test_iterators(MESHSET_ORDERED, true, false);
1212 test_iterators(MESHSET_ORDERED, false, true);
1213 }
1214
test_iterators(unsigned int flags,bool test_type,bool test_dim)1215 void test_iterators(unsigned int flags, bool test_type, bool test_dim)
1216 {
1217 if (test_type && test_dim) CHECK_ERR(MB_FAILURE);
1218
1219 EntityHandle first_vert, last_vert, first_hex, last_hex;
1220 Core mb; make_mesh( mb, first_vert, last_vert, first_hex, last_hex );
1221
1222 // Create an entity set
1223 EntityHandle set;
1224 ErrorCode rval = mb.create_meshset(flags, set );
1225 CHECK_ERR(rval);
1226
1227 // Test iteration over empty set
1228 SetIterator *iter = NULL;
1229 rval = mb.create_set_iterator(set, MBMAXTYPE, -1, 1, false, iter);
1230 CHECK_ERR(rval);
1231 if (NULL != iter) {
1232 test_iterator(mb, iter, set, MBMAXTYPE, -1);
1233 delete iter;
1234 iter = NULL;
1235 }
1236
1237 rval = mb.create_set_iterator(set, MBMAXTYPE, -1, 100, false, iter);
1238 CHECK_ERR(rval);
1239 if (NULL != iter) {
1240 test_iterator(mb, iter, set, MBMAXTYPE, -1);
1241 delete iter;
1242 iter = NULL;
1243 }
1244
1245 rval = mb.create_set_iterator(set, MBMAXTYPE, 0, 1, false, iter);
1246 CHECK_ERR(rval);
1247 if (NULL != iter) {
1248 test_iterator(mb, iter, set, MBMAXTYPE, 0);
1249 delete iter;
1250 iter = NULL;
1251 }
1252
1253 rval = mb.create_set_iterator(set, MBMAXTYPE, 3, 1, false, iter);
1254 CHECK_ERR(rval);
1255 if (NULL != iter) {
1256 test_iterator(mb, iter, set, MBMAXTYPE, 3);
1257 delete iter;
1258 iter = NULL;
1259 }
1260
1261 // Add stuff to set
1262 Range range;
1263 range.insert( first_vert , first_vert + 10 );
1264 range.insert( first_vert + 100, first_vert + 110 );
1265 range.insert( first_hex + 200, first_hex + 299 );
1266 range.insert( last_hex , last_hex - 99 );
1267 rval = mb.add_entities( set, range );
1268 CHECK_ERR(rval);
1269
1270 EntityType etype = MBVERTEX;
1271 int edim = -1;
1272 if (test_dim && !test_type) {
1273 edim = 0;
1274 etype = MBMAXTYPE;
1275 }
1276
1277 // Test
1278 // chunk size 1
1279 rval = mb.create_set_iterator(set, etype, edim, 1, false, iter);
1280 CHECK_ERR(rval);
1281 if (NULL != iter) {
1282 test_iterator(mb, iter, set, etype, edim);
1283 delete iter;
1284 iter = NULL;
1285 }
1286
1287 // chunk size 3
1288 rval = mb.create_set_iterator(set, etype, edim, 3, false, iter);
1289 CHECK_ERR(rval);
1290 if (NULL != iter) {
1291 test_iterator(mb, iter, set, etype, edim);
1292 delete iter;
1293 iter = NULL;
1294 }
1295
1296 // chunk size 11
1297 rval = mb.create_set_iterator(set, etype, edim, 11, false, iter);
1298 CHECK_ERR(rval);
1299 if (NULL != iter) {
1300 test_iterator(mb, iter, set, etype, edim);
1301 delete iter;
1302 iter = NULL;
1303 }
1304
1305 // chunk size 100
1306 rval = mb.create_set_iterator(set, etype, edim, 100, false, iter);
1307 CHECK_ERR(rval);
1308 if (NULL != iter) {
1309 test_iterator(mb, iter, set, etype, edim);
1310 delete iter;
1311 iter = NULL;
1312 }
1313
1314 if (test_type) {
1315 // chunk size 1, all ents
1316 rval = mb.create_set_iterator(set, MBMAXTYPE, -1, 1, false, iter);
1317 CHECK_ERR(rval);
1318 if (NULL != iter) {
1319 test_iterator(mb, iter, set, MBMAXTYPE, -1);
1320 delete iter;
1321 iter = NULL;
1322 }
1323
1324 // chunk size 3, all ents
1325 rval = mb.create_set_iterator(set, MBMAXTYPE, -1, 3, false, iter);
1326 CHECK_ERR(rval);
1327 if (NULL != iter) {
1328 test_iterator(mb, iter, set, MBMAXTYPE, -1);
1329 delete iter;
1330 iter = NULL;
1331 }
1332
1333 // chunk size large, all ents
1334 rval = mb.create_set_iterator(set, MBMAXTYPE, -1, 100000, false, iter);
1335 CHECK_ERR(rval);
1336 if (NULL != iter) {
1337 test_iterator(mb, iter, set, MBMAXTYPE, -1);
1338 delete iter;
1339 iter = NULL;
1340 }
1341
1342 etype = MBEDGE;
1343 // edges, chunk size 1
1344 rval = mb.create_set_iterator(set, etype, edim, 1, false, iter);
1345 CHECK_ERR(rval);
1346 if (NULL != iter) {
1347 test_iterator(mb, iter, set, etype, edim);
1348 delete iter;
1349 iter = NULL;
1350 }
1351
1352 // edges, chunk size 100
1353 rval = mb.create_set_iterator(set, etype, edim, 100, false, iter);
1354 CHECK_ERR(rval);
1355 if (NULL != iter) {
1356 test_iterator(mb, iter, set, etype, edim);
1357 delete iter;
1358 iter = NULL;
1359 }
1360
1361 etype = MBHEX;
1362
1363 // hexes, chunk size 1
1364 rval = mb.create_set_iterator(set, etype, edim, 1, false, iter);
1365 CHECK_ERR(rval);
1366 if (NULL != iter) {
1367 test_iterator(mb, iter, set, etype, edim);
1368 delete iter;
1369 iter = NULL;
1370 }
1371
1372 // hexes, chunk size 3
1373 rval = mb.create_set_iterator(set, etype, edim, 3, false, iter);
1374 CHECK_ERR(rval);
1375 if (NULL != iter) {
1376 test_iterator(mb, iter, set, etype, edim);
1377 delete iter;
1378 iter = NULL;
1379 }
1380
1381 // hexes, chunk size 1000
1382 rval = mb.create_set_iterator(set, etype, edim, 1000, false, iter);
1383 CHECK_ERR(rval);
1384 if (NULL != iter) {
1385 test_iterator(mb, iter, set, etype, edim);
1386 delete iter;
1387 iter = NULL;
1388 }
1389 }
1390 }
1391
test_iterator(Interface & moab,SetIterator * iter,EntityHandle set,EntityType etype,int dim)1392 void test_iterator(Interface &moab, SetIterator *iter,
1393 EntityHandle set, EntityType etype, int dim)
1394 {
1395 // iterate over the set, adding to contents
1396 std::vector<EntityHandle> entities, entities2;
1397 bool atend = false;
1398 ErrorCode rval;
1399
1400 while (!atend) {
1401 rval = iter->get_next_arr(entities, atend);
1402 CHECK_ERR(rval);
1403 }
1404
1405 // check contents against what's in the set
1406 if (MBMAXTYPE != etype) {
1407 rval = moab.get_entities_by_type(set, etype, entities2);
1408 CHECK_ERR(rval);
1409 }
1410 else if (MBMAXTYPE == etype && -1 == dim) {
1411 rval = moab.get_entities_by_handle(set, entities2);
1412 CHECK_ERR(rval);
1413 }
1414 else if (-1 != dim) {
1415 rval = moab.get_entities_by_dimension(set, dim, entities2);
1416 CHECK_ERR(rval);
1417 }
1418 else {
1419 // error, one of those needs to be true
1420 CHECK_ERR(MB_FAILURE);
1421 }
1422
1423 CHECK_EQUAL(entities.size(), entities2.size());
1424 }
1425