Sierra Toolkit  Version of the Day
UnitTestSelector.cpp
1 /*------------------------------------------------------------------------*/
2 /* Copyright 2010 Sandia Corporation. */
3 /* Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive */
4 /* license for use of this work by or on behalf of the U.S. Government. */
5 /* Export of this program may require a license from the */
6 /* United States Government. */
7 /*------------------------------------------------------------------------*/
8 
9 
10 #include <stdexcept>
11 #include <stk_util/unit_test_support/stk_utest_macros.hpp>
12 
13 #include <stk_mesh/base/Selector.hpp>
14 #include <stk_mesh/base/Bucket.hpp>
15 #include <stk_mesh/base/Part.hpp>
16 #include <stk_mesh/base/Types.hpp>
17 #include <stk_mesh/base/GetBuckets.hpp>
18 #include <stk_util/environment/WallTime.hpp>
19 
20 #include <stk_util/parallel/Parallel.hpp>
21 
22 #include <stk_mesh/fixtures/SelectorFixture.hpp>
23 
24 // Unit test the Selector in isolation
25 
26 namespace {
27 
28 using stk_classic::mesh::fixtures::SelectorFixture ;
29 
30 void initialize(SelectorFixture& fixture)
31 {
32  fixture.m_meta_data.commit();
33  fixture.m_bulk_data.modification_begin();
34  fixture.generate_mesh();
35  STKUNIT_ASSERT(fixture.m_bulk_data.modification_end());
36 }
37 
73 STKUNIT_UNIT_TEST( UnitTestSelector, one_SelectorFixture )
74 {
75  {
76  SelectorFixture fix;
77  initialize(fix);
78  }
79  STKUNIT_EXPECT_TRUE(true);
80 }
81 
82 
86 STKUNIT_UNIT_TEST( UnitTestSelector, two_SelectorFixture )
87 {
88  {
89  SelectorFixture fix;
90  initialize(fix);
91  }
92  {
93  SelectorFixture fix;
94  initialize(fix);
95  }
96  STKUNIT_EXPECT_TRUE(true);
97 }
98 
99 
100 
106 STKUNIT_UNIT_TEST( UnitTestSelector, A_12345 )
107 {
108  SelectorFixture fix;
109  initialize(fix);
110 
111  stk_classic::mesh::Selector selector( fix.m_partA );
112  //std::cout << "Selector = " << selector << std::endl;
113 
114  {
115  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket() ;
116  bool result = selector(bucket);
117  STKUNIT_EXPECT_TRUE(result);
118  }
119  {
120  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
121  bool result = selector(bucket);
122  STKUNIT_EXPECT_TRUE(result);
123  }
124  {
125  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
126  bool result = selector(bucket);
127  STKUNIT_EXPECT_FALSE(result);
128  }
129  {
130  const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
131  bool result = selector(bucket);
132  STKUNIT_EXPECT_FALSE(result);
133  }
134  {
135  const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
136  bool result = selector(bucket);
137  STKUNIT_EXPECT_FALSE(result);
138  }
139 }
140 
146 STKUNIT_UNIT_TEST( UnitTestSelector, Ac_12345 )
147 {
148  SelectorFixture fix;
149  initialize(fix);
150 
151  stk_classic::mesh::Selector selector = ! fix.m_partA ;
152  //std::cout << "Selector = " << selector << std::endl;
153 
154  {
155  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
156  bool result = selector(bucket);
157  STKUNIT_EXPECT_FALSE(result);
158  }
159  {
160  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
161  bool result = selector(bucket);
162  STKUNIT_EXPECT_FALSE(result);
163  }
164  {
165  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
166  bool result = selector(bucket);
167  STKUNIT_EXPECT_TRUE(result);
168  }
169  {
170  const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
171  bool result = selector(bucket);
172  STKUNIT_EXPECT_TRUE(result);
173  }
174  {
175  const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
176  bool result = selector(bucket);
177  STKUNIT_EXPECT_TRUE(result);
178  }
179 
180 }
181 
185 STKUNIT_UNIT_TEST( UnitTestSelector, D_5 )
186 {
187  SelectorFixture fix;
188  initialize(fix);
189 
190  stk_classic::mesh::Selector selector( fix.m_partD );
191 
192  const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
193 
194  bool result = selector(bucket);
195  STKUNIT_EXPECT_FALSE(result);
196 }
197 
201 STKUNIT_UNIT_TEST( UnitTestSelector, Ac_15 )
202 {
203  SelectorFixture fix;
204  initialize(fix);
205 
206  stk_classic::mesh::Part & partA = fix.m_partA ;
207 
208  stk_classic::mesh::Selector selector(partA);
209  selector.complement();
210  //std::cout << "Selector = " << selector << std::endl;
211 
212  {
213  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
214  bool result = selector(bucket);
215  STKUNIT_EXPECT_FALSE(result);
216  }
217  {
218  const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
219  bool result = selector(bucket);
220  STKUNIT_EXPECT_TRUE(result);
221  }
222 }
223 
228 STKUNIT_UNIT_TEST( UnitTestSelector, AiB_12 )
229 {
230  SelectorFixture fix ;
231  initialize(fix);
232 
233  stk_classic::mesh::Part & partA = fix.m_partA ;
234  stk_classic::mesh::Part & partB = fix.m_partB ;
235 
236  stk_classic::mesh::Selector selector = partA & partB;
237  //std::cout << "Selector = " << selector << std::endl;
238 
239  {
240  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
241  bool result = selector(bucket);
242  STKUNIT_EXPECT_FALSE(result);
243  }
244  {
245  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
246  bool result = selector(bucket);
247  STKUNIT_EXPECT_TRUE(result);
248  }
249 }
250 
251 
255 STKUNIT_UNIT_TEST( UnitTestSelector, AuB_14 )
256 {
257  SelectorFixture fix ;
258  initialize(fix);
259 
260  stk_classic::mesh::Part & partA = fix.m_partA ;
261  stk_classic::mesh::Part & partB = fix.m_partB ;
262 
263  stk_classic::mesh::Selector selector = partA | partB;
264  //std::cout << "Selector = " << selector << std::endl;
265 
266  {
267  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
268  bool result = selector(bucket);
269  STKUNIT_EXPECT_TRUE(result);
270  }
271  {
272  const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
273  bool result = selector(bucket);
274  STKUNIT_EXPECT_FALSE(result);
275  }
276 }
277 
278 
282 STKUNIT_UNIT_TEST( UnitTestSelector, AiBc_12 )
283 {
284  SelectorFixture fix ;
285  initialize(fix);
286 
287  stk_classic::mesh::Part & partA = fix.m_partA ;
288  stk_classic::mesh::Part & partB = fix.m_partB ;
289 
290  stk_classic::mesh::Selector selector = partA & !partB;
291  //std::cout << "Selector = " << selector << std::endl;
292 
293  {
294  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
295  bool result = selector(bucket);
296  STKUNIT_EXPECT_TRUE(result);
297  }
298  {
299  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
300  bool result = selector(bucket);
301  STKUNIT_EXPECT_FALSE(result);
302  }
303 }
304 
305 
309 STKUNIT_UNIT_TEST( UnitTestSelector, AuBc_13 )
310 {
311  SelectorFixture fix ;
312  initialize(fix);
313 
314  stk_classic::mesh::Part & partA = fix.m_partA ;
315  stk_classic::mesh::Part & partB = fix.m_partB ;
316 
317  stk_classic::mesh::Selector selector = partA | !partB;
318  //std::cout << "Selector = " << selector << std::endl;
319 
320  {
321  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
322  bool result = selector(bucket);
323  STKUNIT_EXPECT_TRUE(result);
324  }
325  {
326  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
327  bool result = selector(bucket);
328  STKUNIT_EXPECT_FALSE(result);
329  }
330 }
331 
332 
333 // plus copy constructor
338 STKUNIT_UNIT_TEST( UnitTestSelector, Ai_BuC_c_12 )
339 {
340  SelectorFixture fix ;
341  initialize(fix);
342 
343  stk_classic::mesh::Part & partA = fix.m_partA ;
344  stk_classic::mesh::Part & partB = fix.m_partB ;
345  stk_classic::mesh::Part & partC = fix.m_partC ;
346 
347  stk_classic::mesh::Selector selector = partA & !(partB | partC);
348  //std::cout << "Selector = " << selector << std::endl;
349 
350  {
351  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
352  bool result = selector(bucket);
353  STKUNIT_EXPECT_TRUE(result);
354  }
355  {
356  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
357  bool result = selector(bucket);
358  STKUNIT_EXPECT_FALSE(result);
359  }
360 
361  stk_classic::mesh::Selector newSelector(selector);
362  // Should be the same:
363  {
364  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
365  bool result = newSelector(bucket);
366  STKUNIT_EXPECT_TRUE(result);
367  }
368  {
369  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
370  bool result = newSelector(bucket);
371  STKUNIT_EXPECT_FALSE(result);
372  }
373 
374 }
375 
376 
380 STKUNIT_UNIT_TEST( UnitTestSelector, entityTest )
381 {
382  {
383  SelectorFixture fix ;
384  initialize(fix);
385 
386  stk_classic::mesh::Part & partA = fix.m_partA ;
387  stk_classic::mesh::Part & partB = fix.m_partB ;
388  stk_classic::mesh::Selector selector = partA & !partB;
389 
390  const stk_classic::mesh::Entity & pEntity = *fix.m_entity5;
391  bool result = selector(pEntity);
392  STKUNIT_EXPECT_FALSE(result);
393  }
394 
395 }
396 
400 STKUNIT_UNIT_TEST( UnitTestSelector, defaultConstructor )
401 {
402  SelectorFixture fix ;
403  initialize(fix);
404 
406  //std::cout << "Selector = " << selector << std::endl;
407 
408  {
409  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
410  bool result = selector(bucket);
411  STKUNIT_EXPECT_FALSE(result);
412  }
413 }
414 
415 
423 STKUNIT_UNIT_TEST( UnitTestSelector, flipComplement_AuB_c )
424 {
425  SelectorFixture fix ;
426  initialize(fix);
427 
428  stk_classic::mesh::Part & partA = fix.m_partA ;
429  stk_classic::mesh::Part & partB = fix.m_partB ;
430  stk_classic::mesh::Selector notOrSelector = partA | partB;
431  //std::cout << "Or Selector = " << notOrSelector << std::endl;
432  notOrSelector.complement();
433  //std::cout << "Not Or Selector = " << notOrSelector << std::endl;
434 
435  {
436  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
437  bool result = notOrSelector(bucket);
438  STKUNIT_EXPECT_FALSE(result);
439  }
440  {
441  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
442  bool result = notOrSelector(bucket);
443  STKUNIT_EXPECT_FALSE(result);
444  }
445  {
446  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
447  bool result = notOrSelector(bucket);
448  STKUNIT_EXPECT_FALSE(result);
449  }
450  {
451  const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
452  bool result = notOrSelector(bucket);
453  STKUNIT_EXPECT_TRUE(result);
454  }
455 
456  stk_classic::mesh::Selector notNotOrSelector = !notOrSelector;
457  //std::cout << "Not Not Or Selector = " << notNotOrSelector << std::endl;
458  {
459  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
460  bool result = notNotOrSelector(bucket);
461  STKUNIT_EXPECT_TRUE(result);
462  }
463  {
464  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
465  bool result = notNotOrSelector(bucket);
466  STKUNIT_EXPECT_TRUE(result);
467  }
468  {
469  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
470  bool result = notNotOrSelector(bucket);
471  STKUNIT_EXPECT_TRUE(result);
472  }
473  {
474  const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
475  bool result = notNotOrSelector(bucket);
476  STKUNIT_EXPECT_FALSE(result);
477  }
478 }
479 
487 STKUNIT_UNIT_TEST( UnitTestSelector, flipComplement_AiB_c )
488 {
489  SelectorFixture fix ;
490  initialize(fix);
491 
492  stk_classic::mesh::Part & partA = fix.m_partA ;
493  stk_classic::mesh::Part & partB = fix.m_partB ;
494  stk_classic::mesh::Selector notAndSelector = partA & partB;
495  //std::cout << "And Selector = " << notAndSelector << std::endl;
496  notAndSelector.complement();
497  //std::cout << "Not And Selector = " << notAndSelector << std::endl;
498 
499  {
500  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
501  bool result = notAndSelector(bucket);
502  STKUNIT_EXPECT_TRUE(result);
503  }
504  {
505  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
506  bool result = notAndSelector(bucket);
507  STKUNIT_EXPECT_FALSE(result);
508  }
509  {
510  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
511  bool result = notAndSelector(bucket);
512  STKUNIT_EXPECT_TRUE(result);
513  }
514  {
515  const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
516  bool result = notAndSelector(bucket);
517  STKUNIT_EXPECT_TRUE(result);
518  }
519 
520  stk_classic::mesh::Selector notNotAndSelector = !notAndSelector;
521  //std::cout << "Not Not And Selector = " << notNotAndSelector << std::endl;
522  {
523  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
524  bool result = notNotAndSelector(bucket);
525  STKUNIT_EXPECT_FALSE(result);
526  }
527  {
528  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
529  bool result = notNotAndSelector(bucket);
530  STKUNIT_EXPECT_TRUE(result);
531  }
532  {
533  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
534  bool result = notNotAndSelector(bucket);
535  STKUNIT_EXPECT_FALSE(result);
536  }
537  {
538  const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
539  bool result = notNotAndSelector(bucket);
540  STKUNIT_EXPECT_FALSE(result);
541  }
542 }
543 
550 STKUNIT_UNIT_TEST( UnitTestSelector, complementEmpty ) {
551  SelectorFixture fix ;
552  initialize(fix);
553 
555  {
556  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
557  bool result = selector(bucket);
558  STKUNIT_EXPECT_FALSE(result);
559  }
560  selector.complement();
561  {
562  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
563  bool result = selector(bucket);
564  STKUNIT_EXPECT_TRUE(result);
565  }
566 }
567 
568 
573 STKUNIT_UNIT_TEST( UnitTestSelector, AuBuCuD )
574 {
575  SelectorFixture fix ;
576  initialize(fix);
577 
578  stk_classic::mesh::Part & partA = fix.m_partA ;
579  stk_classic::mesh::Part & partB = fix.m_partB ;
580  stk_classic::mesh::Part & partC = fix.m_partC ;
581  stk_classic::mesh::Part & partD = fix.m_partD ;
582  stk_classic::mesh::Selector selector = partA | partB | partC | partD;
583  std::cout << "A|B|C|D = " << selector << std::endl;
584  std::ostringstream msg;
585  msg << selector;
586  STKUNIT_EXPECT_EQUAL( "!(!PartA AND !PartB AND !PartC AND !PartD)" , msg.str() );
587 }
588 
589 
593 STKUNIT_UNIT_TEST( UnitTestSelector, AiBiC )
594 {
595  SelectorFixture fix ;
596  initialize(fix);
597 
598  stk_classic::mesh::Part & partA = fix.m_partA ;
599  stk_classic::mesh::Part & partB = fix.m_partB ;
600  stk_classic::mesh::Part & partC = fix.m_partC ;
601  stk_classic::mesh::Selector selector = partA & partB & partC;
602  std::cout << "A&B&C = " << selector << std::endl;
603  std::ostringstream msg;
604  msg << selector;
605  STKUNIT_EXPECT_TRUE( msg.str() == "PartA AND PartB AND PartC" );
606 }
607 
608 
612 STKUNIT_UNIT_TEST( UnitTestSelector, complicated )
613 {
614  SelectorFixture fix ;
615  initialize(fix);
616 
617  stk_classic::mesh::Part & partA = fix.m_partA ;
618  stk_classic::mesh::Part & partB = fix.m_partB ;
619  stk_classic::mesh::Part & partC = fix.m_partC ;
620  stk_classic::mesh::Part & partD = fix.m_partD ;
621  stk_classic::mesh::Selector selector = partA | ( !((partA & partB) | partC) & (!partD | partB));
622  std::cout << "complicated selector = " << selector << std::endl;
623  std::ostringstream msg;
624  msg << selector;
625  STKUNIT_EXPECT_EQUAL( "!(!PartA AND !((!(PartA AND PartB) AND !PartC) AND !(PartD AND !PartB)))" , msg.str() );
626 }
627 
628 
633 STKUNIT_UNIT_TEST( UnitTestSelector, selectIntersection )
634 {
635  SelectorFixture fix ;
636  initialize(fix);
637 
639  parts.push_back( & fix.m_partA );
640  parts.push_back( & fix.m_partB );
642 
643  {
644  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
645  bool result = selector(bucket);
646  STKUNIT_ASSERT_FALSE(result);
647  }
648  {
649  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
650  bool result = selector(bucket);
651  STKUNIT_ASSERT_TRUE(result);
652  }
653  {
654  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
655  bool result = selector(bucket);
656  STKUNIT_ASSERT_FALSE(result);
657  }
658  {
659  const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
660  bool result = selector(bucket);
661  STKUNIT_ASSERT_FALSE(result);
662  }
663  {
664  const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
665  bool result = selector(bucket);
666  STKUNIT_ASSERT_FALSE(result);
667  }
668 
669  std::ostringstream msg;
670  msg << selector;
671  STKUNIT_EXPECT_TRUE( msg.str() == "PartA AND PartB");
672 }
673 
674 
679 STKUNIT_UNIT_TEST( UnitTestSelector, selectUnion )
680 {
681  SelectorFixture fix ;
682  initialize(fix);
683 
685  parts.push_back( & fix.m_partA );
686  parts.push_back( & fix.m_partB );
687  parts.push_back( & fix.m_partC );
688  stk_classic::mesh::Selector selector = selectUnion(parts);
689 
690  {
691  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
692  bool result = selector(bucket);
693  STKUNIT_ASSERT_TRUE(result);
694  }
695  {
696  const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
697  bool result = selector(bucket);
698  STKUNIT_ASSERT_TRUE(result);
699  }
700  {
701  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
702  bool result = selector(bucket);
703  STKUNIT_ASSERT_TRUE(result);
704  }
705  {
706  const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
707  bool result = selector(bucket);
708  STKUNIT_ASSERT_TRUE(result);
709  }
710  {
711  const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
712  bool result = selector(bucket);
713  STKUNIT_ASSERT_FALSE(result);
714  }
715 
716  std::ostringstream msg;
717  msg << selector;
718  std::cout << "msg.str() = " << msg.str() << std::endl;
719  STKUNIT_EXPECT_EQUAL( "!(!PartA AND !PartB AND !PartC)", msg.str() );
720 }
721 
722 // Intersection first then union
723 // & before |
729 //STKUNIT_UNIT_TEST( UnitTestSelector, orderOfOperations )
730 //{
731 // SelectorFixture fix ;
732 // stk_classic::mesh::Part & partA = fix.m_partA ;
733 // stk_classic::mesh::Part & partB = fix.m_partB ;
734 // stk_classic::mesh::Part & partC = fix.m_partC ;
735 // {
736 // stk_classic::mesh::Selector selector = partA | partB & partC;
737 // //std::cout << "A|B&C selector = " << selector << std::endl;
738 // std::ostringstream msg;
739 // msg << selector;
740 // STKUNIT_EXPECT_EQUAL( "!(!PartA AND !(PartB AND PartC))", msg.str() );
741 // {
742 // const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
743 // bool result = selector(bucket);
744 // STKUNIT_EXPECT_TRUE(result);
745 // }
746 // {
747 // const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
748 // bool result = selector(bucket);
749 // STKUNIT_EXPECT_TRUE(result);
750 // }
751 // {
752 // const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
753 // bool result = selector(bucket);
754 // STKUNIT_EXPECT_TRUE(result);
755 // }
756 // {
757 // const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
758 // bool result = selector(bucket);
759 // STKUNIT_EXPECT_FALSE(result);
760 // }
761 // }
762 // {
763 // stk_classic::mesh::Selector selector = partB & partC | partA;
764 // //std::cout << "B&C|A selector = " << selector << std::endl;
765 // std::ostringstream msg;
766 // msg << selector;
767 // STKUNIT_EXPECT_EQUAL( "!(!(PartB AND PartC) AND !PartA)", msg.str() );
768 // {
769 // const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
770 // bool result = selector(bucket);
771 // STKUNIT_EXPECT_TRUE(result);
772 // }
773 // {
774 // const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
775 // bool result = selector(bucket);
776 // STKUNIT_EXPECT_TRUE(result);
777 // }
778 // {
779 // const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
780 // bool result = selector(bucket);
781 // STKUNIT_EXPECT_TRUE(result);
782 // }
783 // {
784 // const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
785 // bool result = selector(bucket);
786 // STKUNIT_EXPECT_FALSE(result);
787 // }
788 // }
789 //}
790 
791 
796 STKUNIT_UNIT_TEST( UnitTestSelector, ZeroiuZero ) {
797  SelectorFixture fix ;
798  initialize(fix);
799 
800  stk_classic::mesh::Selector selectNone;
801  stk_classic::mesh::Selector selectAll;
802  selectAll.complement();
803  {
804  stk_classic::mesh::Selector selector = selectNone & selectAll;
805  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
806  bool result = selector(bucket);
807  STKUNIT_EXPECT_FALSE(result);
808  }
809  {
810  stk_classic::mesh::Selector selector = selectNone | selectAll;
811  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
812  bool result = selector(bucket);
813  STKUNIT_EXPECT_TRUE(result);
814  }
815 
816 }
817 
827 STKUNIT_UNIT_TEST( UnitTestSelector, ZeroiuA )
828 {
829  SelectorFixture fix ;
830  initialize(fix);
831 
832  stk_classic::mesh::Part & partA = fix.m_partA ;
833  stk_classic::mesh::Selector selectNone;
834  stk_classic::mesh::Selector selectAll;
835  selectAll.complement();
836  stk_classic::mesh::Selector selectA = partA;
837  stk_classic::mesh::Selector selectNoneOrA = selectNone | selectA;
838  stk_classic::mesh::Selector selectAllAndA = selectAll & selectA;
839  {
840  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
841  bool result = selectNoneOrA(bucket);
842  STKUNIT_EXPECT_TRUE(result);
843  }
844  {
845  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
846  bool result = selectAllAndA(bucket);
847  STKUNIT_EXPECT_TRUE(result);
848  }
849 }
850 
851 
855 STKUNIT_UNIT_TEST( UnitTestSelector, copyConstructor )
856 {
857  SelectorFixture fix ;
858  initialize(fix);
859 
860  stk_classic::mesh::Part & partA = fix.m_partA ;
861  stk_classic::mesh::Part & partB = fix.m_partB ;
862  stk_classic::mesh::Part & partC = fix.m_partC ;
863  stk_classic::mesh::Selector selectA = (partA & partB) | partC;
864  stk_classic::mesh::Selector anotherSelectA(selectA);
865  std::ostringstream descriptionA;
866  descriptionA << selectA;
867  std::ostringstream descriptionAnotherA;
868  descriptionAnotherA << anotherSelectA;
869  STKUNIT_EXPECT_EQUAL( descriptionA.str() == descriptionAnotherA.str(), true );
870 }
871 
872 
879 STKUNIT_UNIT_TEST( UnitTestSelector, AlliuAll )
880 {
881  stk_classic::mesh::Selector selectAll;
882  selectAll.complement();
883 
884  stk_classic::mesh::Selector anotherSelectAll;
885  anotherSelectAll.complement();
886 
887  {
888  stk_classic::mesh::Selector selectAllANDAll = selectAll & anotherSelectAll;
889  std::ostringstream description;
890  description << selectAllANDAll;
891  STKUNIT_EXPECT_EQUAL( "!() AND !()", description.str() );
892  }
893  {
894  stk_classic::mesh::Selector selectAllORAll = selectAll | anotherSelectAll;
895  std::ostringstream description;
896  description << selectAllORAll;
897  STKUNIT_EXPECT_EQUAL( "!(())", description.str() );
898  }
899 }
900 
904 STKUNIT_UNIT_TEST( UnitTestSelector, selectField )
905 {
906  SelectorFixture fix ;
907  initialize(fix);
908 
909  stk_classic::mesh::Selector selectA = stk_classic::mesh::selectField(fix.m_fieldA);
910  stk_classic::mesh::Selector selectABC = stk_classic::mesh::selectField(fix.m_fieldABC);
911  {
912  //entity1 is in partA, so entity1's bucket should be selected by selectA:
913  const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
914  bool result = selectA(bucket);
915  STKUNIT_EXPECT_TRUE(result);
916  }
917  {
918  //entity3 is not in partA, so entity3's bucket should not be selected by selectA:
919  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
920  bool result = selectA(bucket);
921  STKUNIT_EXPECT_FALSE(result);
922  }
923  {
924  //entity3 is in partB, so entity3's bucket should be selected by selectABC:
925  const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
926  bool result = selectABC(bucket);
927  STKUNIT_EXPECT_TRUE(result);
928  }
929 }
930 
934 STKUNIT_UNIT_TEST( UnitTestSelector, select_part )
935 {
936  SelectorFixture fix ;
937  initialize(fix);
938 
939  stk_classic::mesh::Part & partA = fix.m_partA ;
940  stk_classic::mesh::Part & partB = fix.m_partB ;
941  stk_classic::mesh::Part & partC = fix.m_partC ;
942  stk_classic::mesh::Part & partD = fix.m_partD ;
943  stk_classic::mesh::Selector selector = partA | partB | (!partC) | partD;
944  std::cout << "select_part selector = " << selector << std::endl;
945  STKUNIT_EXPECT_TRUE(selector(partA));
946  STKUNIT_EXPECT_TRUE(selector(partB));
947  STKUNIT_EXPECT_FALSE(selector(partC));
948  STKUNIT_EXPECT_TRUE(selector(partD));
949 
950  selector =
951  partA |
952  ( !( (partA & partB) | partC)
953  &
954  (!partD | partB)
955  );
956 
957  STKUNIT_EXPECT_TRUE(selector(partA));
958  STKUNIT_EXPECT_TRUE(selector(partB));
959  STKUNIT_EXPECT_FALSE(selector(partC));
960  STKUNIT_EXPECT_FALSE(selector(partD));
961 
962  selector = partC & (!partD);
963  STKUNIT_EXPECT_FALSE(selector(partA));
964  STKUNIT_EXPECT_FALSE(selector(partB));
965  STKUNIT_EXPECT_TRUE(selector(partC));
966  STKUNIT_EXPECT_FALSE(selector(partD));
967 
968 }
969 
973 } // namespace
Selector selectIntersection(const PartVector &intersection_part_vector)
Definition: Selector.cpp:273
Selector & complement()
Complement: this = !(this) Postcondition: this is a compound expression.
Definition: Selector.cpp:42
This is a class for selecting buckets based on a set of meshparts and set logic.
Definition: Selector.hpp:112
An application-defined subset of a problem domain.
Definition: Part.hpp:49
Selector selectField(const FieldBase &field)
Return a selector for the union of the parts where field exists.
Definition: Selector.cpp:285
A fundamental unit within the discretization of a problem domain, including but not limited to nodes...
Definition: Entity.hpp:120
Selector selectUnion(const PartVector &union_part_vector)
Definition: Selector.cpp:260
std::vector< Part *> PartVector
Collections of parts are frequently maintained as a vector of Part pointers.
Definition: Types.hpp:31
A container for the field data of a homogeneous collection of entities.
Definition: Bucket.hpp:94