Tempus  Version of the Day
Time Integration
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Tempus_UnitTest_TimeEventComposite.cpp
Go to the documentation of this file.
1 // @HEADER
2 // ****************************************************************************
3 // Tempus: Copyright (2017) Sandia Corporation
4 //
5 // Distributed under BSD 3-clause license (See accompanying file Copyright.txt)
6 // ****************************************************************************
7 // @HEADER
8 
10 
12 #include "Tempus_TimeEventRange.hpp"
13 #include "Tempus_TimeEventRangeIndex.hpp"
14 #include "Tempus_TimeEventList.hpp"
15 #include "Tempus_TimeEventListIndex.hpp"
16 
17 static double PI = M_PI;
18 
19 namespace Tempus_Unit_Test {
20 
21 using Teuchos::RCP;
22 using Teuchos::rcp;
23 using Teuchos::rcp_const_cast;
24 using Teuchos::rcp_dynamic_cast;
25 
26 // TimeEventRanges for testing.
27 // ------------------------------------------------------------
29 {
30  auto teRange1 = rcp(new Tempus::TimeEventRange<double>(
31  0.0, PI, 1.0, "teRange1", true, 1.0e-14));
32  return teRange1;
33 }
34 
36 {
37  auto teRange2 = rcp(new Tempus::TimeEventRange<double>(
38  -PI / 2.0, PI / 2.0, PI / 4.0, "teRange2", true, 1.0e-14));
39  return teRange2;
40 }
41 
43 {
44  auto teRange3 = rcp(new Tempus::TimeEventRange<double>(
45  4.0, 10.0, 4.0, "teRange3", true, 1.0e-14));
46  return teRange3;
47 }
48 
49 // TimeEventLists for testing.
50 // ------------------------------------------------------------
52 {
53  std::vector<double> testList1;
54  testList1.push_back(-1.0);
55  testList1.push_back(0.0);
56  testList1.push_back(5.0);
57  testList1.push_back(2.0);
58  testList1.push_back(PI);
59 
60  auto teList1 = rcp(
61  new Tempus::TimeEventList<double>(testList1, "teList1", true, 1.0e-14));
62  return teList1;
63 }
64 
66 {
67  std::vector<double> testList2;
68  testList2.push_back(-0.5);
69  testList2.push_back(1.25);
70  testList2.push_back(4.95);
71  testList2.push_back(12.34);
72 
73  auto teList2 = rcp(
74  new Tempus::TimeEventList<double>(testList2, "teList2", true, 1.0e-14));
75  return teList2;
76 }
77 
79 {
80  std::vector<double> testList3;
81  testList3.push_back(-5.0);
82  testList3.push_back(-PI);
83 
84  auto teList3 = rcp(
85  new Tempus::TimeEventList<double>(testList3, "teList3", true, 1.0e-14));
86  return teList3;
87 }
88 
89 // TimeEventRangeIndices for testing.
90 // ------------------------------------------------------------
92 {
93  auto teRangeIndex1 =
94  rcp(new Tempus::TimeEventRangeIndex<double>(-1, 10, 3, "teRangeIndex1"));
95  return teRangeIndex1;
96 }
97 
99 {
100  auto teRangeIndex2 =
101  rcp(new Tempus::TimeEventRangeIndex<double>(-5, 8, 4, "teRangeIndex2"));
102  return teRangeIndex2;
103 }
104 
106 {
107  auto teRangeIndex3 =
108  rcp(new Tempus::TimeEventRangeIndex<double>(10, 17, 5, "teRangeIndex3"));
109  return teRangeIndex3;
110 }
111 
112 // TimeEventRangeIndices for testing.
113 // ------------------------------------------------------------
115 {
116  std::vector<int> testListIndex1;
117  testListIndex1.push_back(-2);
118  testListIndex1.push_back(0);
119  testListIndex1.push_back(7);
120  testListIndex1.push_back(3);
121  testListIndex1.push_back(-5);
122 
123  auto teListIndex1 = rcp(
124  new Tempus::TimeEventListIndex<double>(testListIndex1, "teListIndex1"));
125  return teListIndex1;
126 }
127 
129 {
130  std::vector<int> testListIndex2;
131  testListIndex2.push_back(2);
132 
133  auto teListIndex2 = rcp(
134  new Tempus::TimeEventListIndex<double>(testListIndex2, "teListIndex2"));
135  return teListIndex2;
136 }
137 
139 {
140  std::vector<int> testListIndex3;
141  testListIndex3.push_back(14);
142  testListIndex3.push_back(9);
143 
144  auto teListIndex3 = rcp(
145  new Tempus::TimeEventListIndex<double>(testListIndex3, "teListIndex3"));
146 
147  return teListIndex3;
148 }
149 
150 // ************************************************************
151 // ************************************************************
152 TEUCHOS_UNIT_TEST(TimeEventComposite, Default_Construction)
153 {
154  auto tec = rcp(new Tempus::TimeEventComposite<double>());
155 
156  TEST_COMPARE(tec->getType(), ==, "Composite");
157  TEST_COMPARE(tec->getName(), ==, "TimeEventComposite");
158  TEST_COMPARE(tec->isTime(0.0), ==, false);
159  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(0.0), tec->getDefaultTime(),
160  1.0e-14);
161  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(0.0), tec->getDefaultTime(),
162  1.0e-14);
163  TEST_COMPARE(tec->eventInRange(0.0, 1.0), ==, false);
164 
165  TEST_COMPARE(tec->isIndex(0), ==, false);
166  TEST_COMPARE(tec->indexToNextEvent(0), ==, tec->getDefaultIndex());
167  TEST_COMPARE(tec->indexOfNextEvent(0), ==, tec->getDefaultIndex());
168  TEST_COMPARE(tec->eventInRange(0, 10), ==, false);
169 
170  auto timeEvents = tec->getTimeEvents();
171  TEST_COMPARE(timeEvents.size(), ==, 0);
172 }
173 
174 // ************************************************************
175 // ************************************************************
176 TEUCHOS_UNIT_TEST(TimeEventComposite, Full_Construction)
177 {
178  std::vector<Teuchos::RCP<Tempus::TimeEventBase<double> > > timeEvents;
179  timeEvents.push_back(getTestRange1());
180  timeEvents.push_back(getTestList1());
181  timeEvents.push_back(getTestRangeIndex1());
182  timeEvents.push_back(getTestListIndex1());
183 
185  timeEvents, "Test TimeEventComposite"));
186  // tec->describe(out, Teuchos::VERB_EXTREME);
187 
188  TEST_COMPARE(tec->getType(), ==, "Composite");
189  TEST_COMPARE(tec->getName(), ==, "Test TimeEventComposite");
190 
191  TEST_COMPARE(tec->isTime(3.0), ==, true);
192  TEST_COMPARE(tec->isTime(2.0), ==, true);
193  TEST_COMPARE(tec->isIndex(2), ==, true);
194  TEST_COMPARE(tec->isIndex(3), ==, true);
195 
196  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(-2.5), 1.5, 1.0e-14);
197  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(0.5), 0.5, 1.0e-14);
198  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(4.5), 0.5, 1.0e-14);
199  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(7.5), tec->getDefaultTime(),
200  1.0e-14);
201 
202  TEST_COMPARE(tec->indexToNextEvent(-6), ==, 1);
203  TEST_COMPARE(tec->indexToNextEvent(1), ==, 1);
204  TEST_COMPARE(tec->indexToNextEvent(7), ==, 1);
205  TEST_COMPARE(tec->indexToNextEvent(9), ==, tec->getDefaultIndex() - 9);
206 
207  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-PI), -1.0, 1.0e-14);
208  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-0.5), 0.0, 1.0e-14);
209  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(2.5), 3.0, 1.0e-14);
210  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(7.5), tec->getDefaultTime(),
211  1.0e-14);
212 
213  TEST_COMPARE(tec->indexOfNextEvent(-6), ==, -5);
214  TEST_COMPARE(tec->indexOfNextEvent(1), ==, 2);
215  TEST_COMPARE(tec->indexOfNextEvent(7), ==, 8);
216  TEST_COMPARE(tec->indexOfNextEvent(9), ==, tec->getDefaultIndex());
217 
218  TEST_COMPARE(tec->eventInRange(-5.0, -2.0), ==, false);
219  TEST_COMPARE(tec->eventInRange(-2.0, -0.5), ==, true);
220  TEST_COMPARE(tec->eventInRange(1.2, 1.8), ==, false);
221  TEST_COMPARE(tec->eventInRange(3.1, 4.0), ==, true);
222  TEST_COMPARE(tec->eventInRange(4.5, 6.0), ==, true);
223 
224  TEST_COMPARE(tec->eventInRangeIndex(-8, -6), ==, false);
225  TEST_COMPARE(tec->eventInRangeIndex(1, 1), ==, false);
226  TEST_COMPARE(tec->eventInRangeIndex(5, 7), ==, true);
227  TEST_COMPARE(tec->eventInRangeIndex(8, 10), ==, false);
228  TEST_COMPARE(tec->eventInRangeIndex(12, 14), ==, false);
229 
230  timeEvents = tec->getTimeEvents();
231  TEST_COMPARE(timeEvents.size(), ==, 4);
232 }
233 
234 // ************************************************************
235 // ************************************************************
236 TEUCHOS_UNIT_TEST(TimeEventComposite, setTimeEvents)
237 {
238  std::vector<Teuchos::RCP<Tempus::TimeEventBase<double> > > timeEvents;
239  timeEvents.push_back(getTestRange1());
240  timeEvents.push_back(getTestList1());
241  timeEvents.push_back(getTestRangeIndex1());
242  timeEvents.push_back(getTestListIndex1());
243 
244  auto tec = rcp(new Tempus::TimeEventComposite<double>());
245 
246  tec->setTimeEvents(timeEvents);
247 
248  auto timeEventsSet = tec->getTimeEvents();
249  TEST_COMPARE(timeEventsSet.size(), ==, 4);
250 }
251 
252 // ************************************************************
253 // ************************************************************
254 TEUCHOS_UNIT_TEST(TimeEventComposite, One_TimeEventRange)
255 {
256  auto tec = rcp(new Tempus::TimeEventComposite<double>());
257  auto teRange1 = getTestRange1();
258 
259  tec->add(teRange1);
260  // tec->describe(out, Teuchos::VERB_EXTREME);
261 
262  TEST_COMPARE(tec->isTime(0.0), ==, true);
263  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(0.0), 1.0, 1.0e-14);
264  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(1.1), 2.0, 1.0e-14);
265  TEST_COMPARE(tec->eventInRange(0.0, 1.0), ==, true);
266 
267  auto timeEvents = tec->getTimeEvents();
268  TEST_COMPARE(timeEvents.size(), ==, 1);
269 }
270 
271 // ************************************************************
272 // ************************************************************
273 TEUCHOS_UNIT_TEST(TimeEventComposite, TwoOverlapping_TimeEventRanges)
274 {
275  auto tec = rcp(new Tempus::TimeEventComposite<double>());
276  auto teRange1 = getTestRange1();
277  auto teRange2 = getTestRange2();
278 
279  tec->add(teRange1);
280  tec->add(teRange2);
281  // tec->describe(out, Teuchos::VERB_EXTREME);
282 
283  TEST_COMPARE(tec->isTime(0.0), ==, true);
284  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(0.1), PI / 4.0 - 0.1, 1.0e-14);
285  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(1.1), PI / 2.0, 1.0e-14);
286  TEST_COMPARE(tec->eventInRange(0.0, 1.0), ==, true);
287 
288  auto timeEvents = tec->getTimeEvents();
289  TEST_COMPARE(timeEvents.size(), ==, 2);
290 }
291 
292 // ************************************************************
293 // ************************************************************
294 TEUCHOS_UNIT_TEST(TimeEventComposite, TwoSeparated_TimeEventRanges)
295 {
296  auto tec = rcp(new Tempus::TimeEventComposite<double>());
297  auto teRange3 = getTestRange3();
298  auto teRange2 = getTestRange2();
299 
300  tec->add(teRange3);
301  tec->add(teRange2);
302  tec->describe(out, Teuchos::VERB_EXTREME);
303 
304  TEST_COMPARE(tec->isTime(4.0), ==, true);
305  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(1.1), PI / 2.0, 1.0e-14);
306  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(3.0), 4.0, 1.0e-14);
307  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(5.0), 8.0, 1.0e-14);
308  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(10.0), tec->getDefaultTime(),
309  1.0e-14);
310  TEST_COMPARE(tec->eventInRange(-3.0, -2.0), ==, false);
311  TEST_COMPARE(tec->eventInRange(-1.0, 0.0), ==, true);
312  TEST_COMPARE(tec->eventInRange(1.0, 2.0), ==, true);
313  TEST_COMPARE(tec->eventInRange(2.0, 3.0), ==, false);
314  TEST_COMPARE(tec->eventInRange(5.0, 7.0), ==, false);
315  TEST_COMPARE(tec->eventInRange(7.0, 9.0), ==, true);
316  TEST_COMPARE(tec->eventInRange(9.0, 11.0), ==, false);
317 
318  auto timeEvents = tec->getTimeEvents();
319  TEST_COMPARE(timeEvents.size(), ==, 2);
320 }
321 
322 // ************************************************************
323 // ************************************************************
324 TEUCHOS_UNIT_TEST(TimeEventComposite, One_TimeEventList)
325 {
326  auto tec = rcp(new Tempus::TimeEventComposite<double>());
327  auto teList1 = getTestList1();
328 
329  tec->add(teList1);
330  // tec->describe(out, Teuchos::VERB_EXTREME);
331 
332  TEST_COMPARE(tec->isTime(2.0), ==, true);
333  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(3.5), 1.5, 1.0e-14);
334  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-2.0), -1.0, 1.0e-14);
335  TEST_COMPARE(tec->eventInRange(4.99, 10.0), ==, true);
336 
337  auto timeEvents = tec->getTimeEvents();
338  TEST_COMPARE(timeEvents.size(), ==, 1);
339 }
340 
341 // ************************************************************
342 // ************************************************************
343 TEUCHOS_UNIT_TEST(TimeEventComposite, TwoOverlapping_TimeEventLists)
344 {
345  auto tec = rcp(new Tempus::TimeEventComposite<double>());
346  auto teList1 = getTestList1();
347  auto teList2 = getTestList2();
348 
349  tec->add(teList1);
350  tec->add(teList2);
351  // tec->describe(out, Teuchos::VERB_EXTREME);
352 
353  TEST_COMPARE(tec->isTime(1.25), ==, true);
354  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(4.0), 0.95, 1.0e-14);
355  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(6.5), 12.34, 1.0e-14);
356  TEST_COMPARE(tec->eventInRange(0.1, 1.0), ==, false);
357 
358  auto timeEvents = tec->getTimeEvents();
359  TEST_COMPARE(timeEvents.size(), ==, 2);
360 }
361 
362 // ************************************************************
363 // ************************************************************
364 TEUCHOS_UNIT_TEST(TimeEventComposite, TwoSeparated_TimeEventLists)
365 {
366  auto tec = rcp(new Tempus::TimeEventComposite<double>());
367  auto teList3 = getTestList3();
368  auto teList2 = getTestList2();
369 
370  tec->add(teList3);
371  tec->add(teList2);
372  // tec->describe(out, Teuchos::VERB_EXTREME);
373 
374  TEST_COMPARE(tec->isTime(4.0), ==, false);
375  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-8.9), -5.0, 1.0e-14);
376  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-0.3), 1.25, 1.0e-14);
377  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-4.0), -PI, 1.0e-14);
378  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(20.0), tec->getDefaultTime(),
379  1.0e-14);
380  TEST_COMPARE(tec->eventInRange(-6.0, -4.0), ==, true);
381  TEST_COMPARE(tec->eventInRange(-3.0, 0.0), ==, true);
382  TEST_COMPARE(tec->eventInRange(2.0, 3.0), ==, false);
383  TEST_COMPARE(tec->eventInRange(4.9, 5.1), ==, true);
384  TEST_COMPARE(tec->eventInRange(12.0, 12.4), ==, true);
385  TEST_COMPARE(tec->eventInRange(14.0, 15.0), ==, false);
386 
387  auto timeEvents = tec->getTimeEvents();
388  TEST_COMPARE(timeEvents.size(), ==, 2);
389 }
390 
391 // ************************************************************
392 // ************************************************************
393 TEUCHOS_UNIT_TEST(TimeEventComposite, One_TimeEventRangeIndex)
394 {
395  auto tec = rcp(new Tempus::TimeEventComposite<double>());
396  auto teRangeIndex1 = getTestRangeIndex1();
397 
398  tec->add(teRangeIndex1);
399  // tec->describe(out, Teuchos::VERB_EXTREME);
400 
401  TEST_COMPARE(tec->isIndex(5), ==, true);
402  TEST_COMPARE(tec->indexToNextEvent(3), ==, 2);
403  TEST_COMPARE(tec->indexOfNextEvent(3), ==, 5);
404  TEST_COMPARE(tec->eventInRangeIndex(3, 9), ==, true);
405 
406  auto timeEvents = tec->getTimeEvents();
407  TEST_COMPARE(timeEvents.size(), ==, 1);
408 }
409 
410 // ************************************************************
411 // ************************************************************
412 TEUCHOS_UNIT_TEST(TimeEventComposite, TwoOverlapping_TimeEventRangeIndex)
413 {
414  auto tec = rcp(new Tempus::TimeEventComposite<double>());
415  auto teRangeIndex1 = getTestRangeIndex1();
416  auto teRangeIndex2 = getTestRangeIndex2();
417 
418  tec->add(teRangeIndex1);
419  tec->add(teRangeIndex2);
420  // tec->describe(out, Teuchos::VERB_EXTREME);
421 
422  TEST_COMPARE(tec->isIndex(-1), ==, true);
423  TEST_COMPARE(tec->indexToNextEvent(-2), ==, 1);
424  TEST_COMPARE(tec->indexOfNextEvent(2), ==, 3);
425  TEST_COMPARE(tec->eventInRangeIndex(0, 1), ==, false);
426 
427  auto timeEvents = tec->getTimeEvents();
428  TEST_COMPARE(timeEvents.size(), ==, 2);
429 }
430 
431 // ************************************************************
432 // ************************************************************
433 TEUCHOS_UNIT_TEST(TimeEventComposite, TwoSeparate_TimeEventRangeIndex)
434 {
435  auto tec = rcp(new Tempus::TimeEventComposite<double>());
436  auto teRangeIndex3 = getTestRangeIndex3();
437  auto teRangeIndex2 = getTestRangeIndex2();
438 
439  tec->add(teRangeIndex3);
440  tec->add(teRangeIndex2);
441  // tec->describe(out, Teuchos::VERB_EXTREME);
442 
443  TEST_COMPARE(tec->isIndex(15), ==, true);
444  TEST_COMPARE(tec->indexOfNextEvent(9), ==, 10);
445  TEST_COMPARE(tec->indexOfNextEvent(-6), ==, -5);
446  TEST_COMPARE(tec->indexOfNextEvent(6), ==, 7);
447  TEST_COMPARE(tec->indexOfNextEvent(16), ==, tec->getDefaultIndex());
448  TEST_COMPARE(tec->eventInRangeIndex(-3, -2), ==, false);
449  TEST_COMPARE(tec->eventInRangeIndex(-2, 0), ==, true);
450  TEST_COMPARE(tec->eventInRangeIndex(1, 2), ==, false);
451  TEST_COMPARE(tec->eventInRangeIndex(6, 7), ==, true);
452  TEST_COMPARE(tec->eventInRangeIndex(7, 8), ==, false);
453  TEST_COMPARE(tec->eventInRangeIndex(10, 13), ==, false);
454  TEST_COMPARE(tec->eventInRangeIndex(14, 20), ==, true);
455 
456  auto timeEvents = tec->getTimeEvents();
457  TEST_COMPARE(timeEvents.size(), ==, 2);
458 }
459 
460 // ************************************************************
461 // ************************************************************
462 TEUCHOS_UNIT_TEST(TimeEventComposite, One_TimeEventListIndex)
463 {
464  auto tec = rcp(new Tempus::TimeEventComposite<double>());
465  auto teListIndex1 = getTestListIndex1();
466 
467  tec->add(teListIndex1);
468  // tec->describe(out, Teuchos::VERB_EXTREME);
469 
470  TEST_COMPARE(tec->isIndex(3), ==, true);
471  TEST_COMPARE(tec->indexToNextEvent(1), ==, 2);
472  TEST_COMPARE(tec->indexOfNextEvent(4), ==, 7);
473  TEST_COMPARE(tec->eventInRangeIndex(1, 3), ==, true);
474 
475  auto timeEvents = tec->getTimeEvents();
476  TEST_COMPARE(timeEvents.size(), ==, 1);
477 }
478 
479 // ************************************************************
480 // ************************************************************
481 TEUCHOS_UNIT_TEST(TimeEventComposite, TwoOverlapping_TimeEventListIndex)
482 {
483  auto tec = rcp(new Tempus::TimeEventComposite<double>());
484  auto teListIndex1 = getTestListIndex1();
485  auto teListIndex2 = getTestListIndex2();
486 
487  tec->add(teListIndex1);
488  tec->add(teListIndex2);
489  // tec->describe(out, Teuchos::VERB_EXTREME);
490 
491  TEST_COMPARE(tec->isIndex(2), ==, true);
492  TEST_COMPARE(tec->indexToNextEvent(0), ==, 2);
493  TEST_COMPARE(tec->indexOfNextEvent(1), ==, 2);
494  TEST_COMPARE(tec->eventInRangeIndex(-1, 3), ==, true);
495 
496  auto timeEvents = tec->getTimeEvents();
497  TEST_COMPARE(timeEvents.size(), ==, 2);
498 }
499 
500 // ************************************************************
501 // ************************************************************
502 TEUCHOS_UNIT_TEST(TimeEventComposite, TwoSeparate_TimeEventListIndex)
503 {
504  auto tec = rcp(new Tempus::TimeEventComposite<double>());
505  auto teListIndex3 = getTestListIndex3();
506  auto teListIndex2 = getTestListIndex2();
507 
508  tec->add(teListIndex3);
509  tec->add(teListIndex2);
510  // tec->describe(out, Teuchos::VERB_EXTREME);
511 
512  TEST_COMPARE(tec->isIndex(14), ==, true);
513  TEST_COMPARE(tec->indexOfNextEvent(2), ==, 9);
514  TEST_COMPARE(tec->indexOfNextEvent(5), ==, 9);
515  TEST_COMPARE(tec->indexOfNextEvent(19), ==, tec->getDefaultIndex());
516  TEST_COMPARE(tec->eventInRangeIndex(0, 1), ==, false);
517  TEST_COMPARE(tec->eventInRangeIndex(3, 10), ==, true);
518  TEST_COMPARE(tec->eventInRangeIndex(15, 20), ==, false);
519 
520  auto timeEvents = tec->getTimeEvents();
521  TEST_COMPARE(timeEvents.size(), ==, 2);
522 }
523 
524 // ************************************************************
525 // ************************************************************
526 TEUCHOS_UNIT_TEST(TimeEventComposite, OneOfEach_TimeEvent)
527 {
528  auto tec = rcp(new Tempus::TimeEventComposite<double>());
529  auto teRange1 = getTestRange1();
530  auto teList1 = getTestList1();
531  auto teRangeIndex1 = getTestRangeIndex1();
532  auto teListIndex1 = getTestListIndex1();
533 
534  tec->add(teRange1);
535  tec->add(teList1);
536  tec->add(teRangeIndex1);
537  tec->add(teListIndex1);
538  // tec->describe(out, Teuchos::VERB_EXTREME);
539 
540  TEST_COMPARE(tec->isTime(3.0), ==, true);
541  TEST_COMPARE(tec->isTime(2.0), ==, true);
542  TEST_COMPARE(tec->isIndex(2), ==, true);
543  TEST_COMPARE(tec->isIndex(3), ==, true);
544 
545  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(-2.5), 1.5, 1.0e-14);
546  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(0.5), 0.5, 1.0e-14);
547  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(4.5), 0.5, 1.0e-14);
548  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(7.5), tec->getDefaultTime(),
549  1.0e-14);
550 
551  TEST_COMPARE(tec->indexToNextEvent(-6), ==, 1);
552  TEST_COMPARE(tec->indexToNextEvent(1), ==, 1);
553  TEST_COMPARE(tec->indexToNextEvent(7), ==, 1);
554  TEST_COMPARE(tec->indexToNextEvent(9), ==, tec->getDefaultIndex() - 9);
555 
556  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-PI), -1.0, 1.0e-14);
557  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-0.5), 0.0, 1.0e-14);
558  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(2.5), 3.0, 1.0e-14);
559  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(7.5), tec->getDefaultTime(),
560  1.0e-14);
561 
562  TEST_COMPARE(tec->indexOfNextEvent(-6), ==, -5);
563  TEST_COMPARE(tec->indexOfNextEvent(1), ==, 2);
564  TEST_COMPARE(tec->indexOfNextEvent(7), ==, 8);
565  TEST_COMPARE(tec->indexOfNextEvent(9), ==, tec->getDefaultIndex());
566 
567  TEST_COMPARE(tec->eventInRange(-5.0, -2.0), ==, false);
568  TEST_COMPARE(tec->eventInRange(-2.0, -0.5), ==, true);
569  TEST_COMPARE(tec->eventInRange(1.2, 1.8), ==, false);
570  TEST_COMPARE(tec->eventInRange(3.1, 4.0), ==, true);
571  TEST_COMPARE(tec->eventInRange(4.5, 6.0), ==, true);
572 
573  TEST_COMPARE(tec->eventInRangeIndex(-8, -6), ==, false);
574  TEST_COMPARE(tec->eventInRangeIndex(1, 1), ==, false);
575  TEST_COMPARE(tec->eventInRangeIndex(5, 7), ==, true);
576  TEST_COMPARE(tec->eventInRangeIndex(7, 10), ==, true);
577  TEST_COMPARE(tec->eventInRangeIndex(12, 14), ==, false);
578 
579  auto timeEvents = tec->getTimeEvents();
580  TEST_COMPARE(timeEvents.size(), ==, 4);
581 }
582 
583 // ************************************************************
584 // ************************************************************
585 TEUCHOS_UNIT_TEST(TimeEventComposite, OneOfEach_Plus_TimeEvent)
586 {
587  auto tec = rcp(new Tempus::TimeEventComposite<double>());
588  auto teRange1 = getTestRange1();
589  auto teList1 = getTestList1();
590  auto teRangeIndex1 = getTestRangeIndex1();
591  auto teListIndex1 = getTestListIndex1();
592 
593  tec->add(teRange1);
594  tec->add(teList1);
595  tec->add(teRangeIndex1);
596  tec->add(teListIndex1);
597  // tec->describe(out, Teuchos::VERB_EXTREME);
598 
599  // Constraining TimeEvent(s)
600  std::vector<Teuchos::RCP<Tempus::TimeEventBase<double> > > teCons;
601 
602  TEST_COMPARE(tec->isTime(3.0, teCons), ==, true);
603  TEST_COMPARE(teCons.size(), ==, 1);
604  TEST_COMPARE(teCons[0]->getName(), ==, "teRange1");
605 
606  TEST_COMPARE(tec->isTime(-1.0, teCons), ==, true);
607  TEST_COMPARE(teCons.size(), ==, 1);
608  TEST_COMPARE(teCons[0]->getName(), ==, "teList1");
609 
610  TEST_COMPARE(tec->isIndex(2, teCons), ==, true);
611  TEST_COMPARE(teCons.size(), ==, 1);
612  TEST_COMPARE(teCons[0]->getName(), ==, "teRangeIndex1");
613 
614  TEST_COMPARE(tec->isIndex(-2, teCons), ==, true);
615  TEST_COMPARE(teCons.size(), ==, 1);
616  TEST_COMPARE(teCons[0]->getName(), ==, "teListIndex1");
617 
618  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(-2.5, teCons), 1.5, 1.0e-14);
619  TEST_COMPARE(teCons.size(), ==, 1);
620  TEST_COMPARE(teCons[0]->getName(), ==, "teList1");
621 
622  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(0.5, teCons), 0.5, 1.0e-14);
623  TEST_COMPARE(teCons.size(), ==, 1);
624  TEST_COMPARE(teCons[0]->getName(), ==, "teRange1");
625 
626  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(4.5, teCons), 0.5, 1.0e-14);
627  TEST_COMPARE(teCons.size(), ==, 1);
628  TEST_COMPARE(teCons[0]->getName(), ==, "teList1");
629 
630  TEST_FLOATING_EQUALITY(tec->timeToNextEvent(7.5, teCons),
631  tec->getDefaultTime(), 1.0e-14);
632  TEST_COMPARE(teCons.size(), ==, 0);
633 
634  TEST_COMPARE(tec->indexToNextEvent(-6, teCons), ==, 1);
635  TEST_COMPARE(teCons.size(), ==, 1);
636  TEST_COMPARE(teCons[0]->getName(), ==, "teListIndex1");
637 
638  TEST_COMPARE(tec->indexToNextEvent(1, teCons), ==, 1);
639  TEST_COMPARE(teCons.size(), ==, 1);
640  TEST_COMPARE(teCons[0]->getName(), ==, "teRangeIndex1");
641 
642  TEST_COMPARE(tec->indexToNextEvent(7, teCons), ==, 1);
643  TEST_COMPARE(teCons.size(), ==, 1);
644  TEST_COMPARE(teCons[0]->getName(), ==, "teRangeIndex1");
645 
646  TEST_COMPARE(tec->indexToNextEvent(9, teCons), ==,
647  tec->getDefaultIndex() - 9);
648  TEST_COMPARE(teCons.size(), ==, 0);
649 
650  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-PI, teCons), -1.0, 1.0e-14);
651  TEST_COMPARE(teCons.size(), ==, 1);
652  TEST_COMPARE(teCons[0]->getName(), ==, "teList1");
653 
654  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-0.5, teCons), 0.0, 1.0e-14);
655  TEST_COMPARE(teCons.size(), ==, 2);
656  TEST_COMPARE(teCons[0]->getName(), ==, "teRange1");
657  TEST_COMPARE(teCons[1]->getName(), ==, "teList1");
658 
659  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(2.5, teCons), 3.0, 1.0e-14);
660  TEST_COMPARE(teCons.size(), ==, 1);
661  TEST_COMPARE(teCons[0]->getName(), ==, "teRange1");
662 
663  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(7.5, teCons),
664  tec->getDefaultTime(), 1.0e-14);
665  TEST_COMPARE(teCons.size(), ==, 0);
666 
667  TEST_COMPARE(tec->indexOfNextEvent(-6, teCons), ==, -5);
668  TEST_COMPARE(teCons.size(), ==, 1);
669  TEST_COMPARE(teCons[0]->getName(), ==, "teListIndex1");
670 
671  TEST_COMPARE(tec->indexOfNextEvent(1, teCons), ==, 2);
672  TEST_COMPARE(teCons.size(), ==, 1);
673  TEST_COMPARE(teCons[0]->getName(), ==, "teRangeIndex1");
674 
675  TEST_COMPARE(tec->indexOfNextEvent(7, teCons), ==, 8);
676  TEST_COMPARE(teCons.size(), ==, 1);
677  TEST_COMPARE(teCons[0]->getName(), ==, "teRangeIndex1");
678 
679  TEST_COMPARE(tec->indexOfNextEvent(9, teCons), ==, tec->getDefaultIndex());
680  TEST_COMPARE(teCons.size(), ==, 0);
681 
682  TEST_COMPARE(tec->eventInRange(-5.0, -2.0, teCons), ==, false);
683  TEST_COMPARE(teCons.size(), ==, 0);
684  TEST_COMPARE(tec->eventInRange(-2.0, -0.5, teCons), ==, true);
685  TEST_COMPARE(teCons.size(), ==, 1);
686  TEST_COMPARE(tec->eventInRange(1.2, 1.8, teCons), ==, false);
687  TEST_COMPARE(teCons.size(), ==, 0);
688  TEST_COMPARE(tec->eventInRange(3.1, 4.0, teCons), ==, true);
689  TEST_COMPARE(teCons.size(), ==, 1);
690  TEST_COMPARE(tec->eventInRange(4.5, 6.0, teCons), ==, true);
691  TEST_COMPARE(teCons.size(), ==, 1);
692 
693  TEST_COMPARE(tec->eventInRangeIndex(-8, -6, teCons), ==, false);
694  TEST_COMPARE(teCons.size(), ==, 0);
695  TEST_COMPARE(tec->eventInRangeIndex(1, 1, teCons), ==, false);
696  TEST_COMPARE(teCons.size(), ==, 0);
697  TEST_COMPARE(tec->eventInRangeIndex(5, 7, teCons), ==, true);
698  TEST_COMPARE(teCons.size(), ==, 1);
699  TEST_COMPARE(tec->eventInRangeIndex(8, 10, teCons), ==, false);
700  TEST_COMPARE(teCons.size(), ==, 0);
701  TEST_COMPARE(tec->eventInRangeIndex(12, 14, teCons), ==, false);
702  TEST_COMPARE(teCons.size(), ==, 0);
703 
704  auto timeEvents = tec->getTimeEvents();
705  TEST_COMPARE(timeEvents.size(), ==, 4);
706 }
707 
708 // ************************************************************
709 // ************************************************************
710 TEUCHOS_UNIT_TEST(TimeEventComposite, Multiple_Simultaneous_Events)
711 {
712  // Define Events
713  auto ter1 = rcp(new Tempus::TimeEventRange<double>(0.0, 20.0, 5.0, "ter1",
714  true, 1.0e-14));
715  auto ter2 = rcp(new Tempus::TimeEventRange<double>(0.0, 20.0, 2.0, "ter2",
716  false, 1.0e-14));
717 
718  std::vector<double> testList1;
719  testList1.push_back(0.0);
720  testList1.push_back(4.0);
721  testList1.push_back(5.0);
722  testList1.push_back(9.0);
723  testList1.push_back(20.0);
724  auto tel1 =
725  rcp(new Tempus::TimeEventList<double>(testList1, "tel1", true, 1.0e-14));
726 
727  std::vector<double> testList2;
728  testList2.push_back(0.0);
729  testList2.push_back(3.0);
730  testList2.push_back(5.0);
731  testList2.push_back(13.0);
732  testList2.push_back(20.0);
733  auto tel2 =
734  rcp(new Tempus::TimeEventList<double>(testList2, "tel2", false, 1.0e-14));
735 
736  auto teri1 =
737  rcp(new Tempus::TimeEventRangeIndex<double>(0, 200, 50, "teri1"));
738  auto teri2 =
739  rcp(new Tempus::TimeEventRangeIndex<double>(0, 200, 20, "teri2"));
740 
741  std::vector<int> testListIndex1;
742  testListIndex1.push_back(0);
743  testListIndex1.push_back(40);
744  testListIndex1.push_back(50);
745  testListIndex1.push_back(90);
746  testListIndex1.push_back(200);
747  auto teli1 =
748  rcp(new Tempus::TimeEventListIndex<double>(testListIndex1, "teli1"));
749 
750  std::vector<int> testListIndex2;
751  testListIndex2.push_back(0);
752  testListIndex2.push_back(30);
753  testListIndex2.push_back(50);
754  testListIndex2.push_back(130);
755  testListIndex2.push_back(200);
756  auto teli2 =
757  rcp(new Tempus::TimeEventListIndex<double>(testListIndex2, "teli2"));
758 
759  auto tec = rcp(new Tempus::TimeEventComposite<double>());
760  tec->add(ter1);
761  tec->add(ter2);
762  tec->add(tel1);
763  tec->add(tel2);
764  tec->add(teri1);
765  tec->add(teri2);
766  tec->add(teli1);
767  tec->add(teli2);
768 
769  // tec->describe(out, Teuchos::VERB_EXTREME);
770 
771  // Constraining TimeEvent(s)
772  std::vector<Teuchos::RCP<Tempus::TimeEventBase<double> > > teCons;
773 
774  TEST_COMPARE(tec->isTime(0.0, teCons), ==, true);
775  TEST_COMPARE(teCons.size(), ==, 4);
776  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
777  TEST_COMPARE(teCons[1]->getName(), ==, "ter2");
778  TEST_COMPARE(teCons[2]->getName(), ==, "tel1");
779  TEST_COMPARE(teCons[3]->getName(), ==, "tel2");
780 
781  TEST_COMPARE(tec->isTime(5.0, teCons), ==, true);
782  TEST_COMPARE(teCons.size(), ==, 3);
783  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
784  TEST_COMPARE(teCons[1]->getName(), ==, "tel1");
785  TEST_COMPARE(teCons[2]->getName(), ==, "tel2");
786 
787  TEST_COMPARE(tec->isTime(10.0, teCons), ==, true);
788  TEST_COMPARE(teCons.size(), ==, 2);
789  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
790  TEST_COMPARE(teCons[1]->getName(), ==, "ter2");
791 
792  TEST_COMPARE(tec->isTime(20.0, teCons), ==, true);
793  TEST_COMPARE(teCons.size(), ==, 4);
794  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
795  TEST_COMPARE(teCons[1]->getName(), ==, "ter2");
796  TEST_COMPARE(teCons[2]->getName(), ==, "tel1");
797  TEST_COMPARE(teCons[3]->getName(), ==, "tel2");
798 
799  TEST_COMPARE(tec->isIndex(0, teCons), ==, true);
800  TEST_COMPARE(teCons.size(), ==, 4);
801  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
802  TEST_COMPARE(teCons[1]->getName(), ==, "teri2");
803  TEST_COMPARE(teCons[2]->getName(), ==, "teli1");
804  TEST_COMPARE(teCons[3]->getName(), ==, "teli2");
805 
806  TEST_COMPARE(tec->isIndex(50, teCons), ==, true);
807  TEST_COMPARE(teCons.size(), ==, 3);
808  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
809  TEST_COMPARE(teCons[1]->getName(), ==, "teli1");
810  TEST_COMPARE(teCons[2]->getName(), ==, "teli2");
811 
812  TEST_COMPARE(tec->isIndex(100, teCons), ==, true);
813  TEST_COMPARE(teCons.size(), ==, 2);
814  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
815  TEST_COMPARE(teCons[1]->getName(), ==, "teri2");
816 
817  TEST_COMPARE(tec->isIndex(200, teCons), ==, true);
818  TEST_COMPARE(teCons.size(), ==, 4);
819  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
820  TEST_COMPARE(teCons[1]->getName(), ==, "teri2");
821  TEST_COMPARE(teCons[2]->getName(), ==, "teli1");
822  TEST_COMPARE(teCons[3]->getName(), ==, "teli2");
823 
824  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(-1.0, teCons), 0.0, 1.0e-14);
825  TEST_COMPARE(teCons.size(), ==, 4);
826  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
827  TEST_COMPARE(teCons[1]->getName(), ==, "ter2");
828  TEST_COMPARE(teCons[2]->getName(), ==, "tel1");
829  TEST_COMPARE(teCons[3]->getName(), ==, "tel2");
830 
831  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(4.0, teCons), 5.0, 1.0e-14);
832  TEST_COMPARE(teCons.size(), ==, 3);
833  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
834  TEST_COMPARE(teCons[1]->getName(), ==, "tel1");
835  TEST_COMPARE(teCons[2]->getName(), ==, "tel2");
836 
837  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(9.0, teCons), 10.0, 1.0e-14);
838  TEST_COMPARE(teCons.size(), ==, 2);
839  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
840  TEST_COMPARE(teCons[1]->getName(), ==, "ter2");
841 
842  TEST_FLOATING_EQUALITY(tec->timeOfNextEvent(19.0, teCons), 20.0, 1.0e-14);
843  TEST_COMPARE(teCons.size(), ==, 4);
844  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
845  TEST_COMPARE(teCons[1]->getName(), ==, "ter2");
846  TEST_COMPARE(teCons[2]->getName(), ==, "tel1");
847  TEST_COMPARE(teCons[3]->getName(), ==, "tel2");
848 
849  TEST_COMPARE(tec->indexOfNextEvent(-1, teCons), ==, 0);
850  TEST_COMPARE(teCons.size(), ==, 4);
851  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
852  TEST_COMPARE(teCons[1]->getName(), ==, "teri2");
853  TEST_COMPARE(teCons[2]->getName(), ==, "teli1");
854  TEST_COMPARE(teCons[3]->getName(), ==, "teli2");
855 
856  TEST_COMPARE(tec->indexOfNextEvent(40, teCons), ==, 50);
857  TEST_COMPARE(teCons.size(), ==, 3);
858  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
859  TEST_COMPARE(teCons[1]->getName(), ==, "teli1");
860  TEST_COMPARE(teCons[2]->getName(), ==, "teli2");
861 
862  TEST_COMPARE(tec->indexOfNextEvent(90, teCons), ==, 100);
863  TEST_COMPARE(teCons.size(), ==, 2);
864  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
865  TEST_COMPARE(teCons[1]->getName(), ==, "teri2");
866 
867  TEST_COMPARE(tec->indexOfNextEvent(190, teCons), ==, 200);
868  TEST_COMPARE(teCons.size(), ==, 4);
869  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
870  TEST_COMPARE(teCons[1]->getName(), ==, "teri2");
871  TEST_COMPARE(teCons[2]->getName(), ==, "teli1");
872  TEST_COMPARE(teCons[3]->getName(), ==, "teli2");
873 
874  // Sorted order is still input order.
875  TEST_COMPARE(tec->eventInRange(-1.0, 21.0, teCons), ==, true);
876  TEST_COMPARE(teCons.size(), ==, 4);
877  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
878  TEST_COMPARE(teCons[1]->getName(), ==, "ter2");
879  TEST_COMPARE(teCons[2]->getName(), ==, "tel1");
880  TEST_COMPARE(teCons[3]->getName(), ==, "tel2");
881 
882  // Sorted order is based on "time of next event".
883  TEST_COMPARE(tec->eventInRange(0.0, 21.0, teCons), ==, true);
884  TEST_COMPARE(teCons.size(), ==, 4);
885  TEST_COMPARE(teCons[0]->getName(), ==, "ter2");
886  TEST_FLOATING_EQUALITY(teCons[0]->timeOfNextEvent(0.0), 2.0, 1.0e-14);
887  TEST_COMPARE(teCons[1]->getName(), ==, "tel2");
888  TEST_FLOATING_EQUALITY(teCons[1]->timeOfNextEvent(0.0), 3.0, 1.0e-14);
889  TEST_COMPARE(teCons[2]->getName(), ==, "tel1");
890  TEST_FLOATING_EQUALITY(teCons[2]->timeOfNextEvent(0.0), 4.0, 1.0e-14);
891  TEST_COMPARE(teCons[3]->getName(), ==, "ter1");
892  TEST_FLOATING_EQUALITY(teCons[3]->timeOfNextEvent(0.0), 5.0, 1.0e-14);
893 
894  TEST_COMPARE(tec->eventInRange(7.0, 21.0, teCons), ==, true);
895  TEST_COMPARE(teCons.size(), ==, 4);
896  TEST_COMPARE(teCons[0]->getName(), ==, "ter2");
897  TEST_FLOATING_EQUALITY(teCons[0]->timeOfNextEvent(7.0), 8.0, 1.0e-14);
898  TEST_COMPARE(teCons[1]->getName(), ==, "tel1");
899  TEST_FLOATING_EQUALITY(teCons[1]->timeOfNextEvent(7.0), 9.0, 1.0e-14);
900  TEST_COMPARE(teCons[2]->getName(), ==, "ter1");
901  TEST_FLOATING_EQUALITY(teCons[2]->timeOfNextEvent(7.0), 10.0, 1.0e-14);
902  TEST_COMPARE(teCons[3]->getName(), ==, "tel2");
903  TEST_FLOATING_EQUALITY(teCons[3]->timeOfNextEvent(7.0), 13.0, 1.0e-14);
904 
905  TEST_COMPARE(tec->eventInRange(19.0, 21.0, teCons), ==, true);
906  TEST_COMPARE(teCons.size(), ==, 4);
907  TEST_COMPARE(teCons[0]->getName(), ==, "ter1");
908  TEST_FLOATING_EQUALITY(teCons[0]->timeOfNextEvent(19.0), 20.0, 1.0e-14);
909  TEST_COMPARE(teCons[1]->getName(), ==, "ter2");
910  TEST_FLOATING_EQUALITY(teCons[1]->timeOfNextEvent(19.0), 20.0, 1.0e-14);
911  TEST_COMPARE(teCons[2]->getName(), ==, "tel1");
912  TEST_FLOATING_EQUALITY(teCons[2]->timeOfNextEvent(19.0), 20.0, 1.0e-14);
913  TEST_COMPARE(teCons[3]->getName(), ==, "tel2");
914  TEST_FLOATING_EQUALITY(teCons[3]->timeOfNextEvent(19.0), 20.0, 1.0e-14);
915 
916  // Sorted order is still input order.
917  TEST_COMPARE(tec->eventInRangeIndex(-10, 210, teCons), ==, true);
918  TEST_COMPARE(teCons.size(), ==, 4);
919  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
920  TEST_COMPARE(teCons[1]->getName(), ==, "teri2");
921  TEST_COMPARE(teCons[2]->getName(), ==, "teli1");
922  TEST_COMPARE(teCons[3]->getName(), ==, "teli2");
923 
924  // Sorted order is based on "time of next event".
925  TEST_COMPARE(tec->eventInRangeIndex(0, 210, teCons), ==, true);
926  TEST_COMPARE(teCons.size(), ==, 4);
927  TEST_COMPARE(teCons[0]->getName(), ==, "teri2");
928  TEST_COMPARE(teCons[0]->indexOfNextEvent(0), ==, 20);
929  TEST_COMPARE(teCons[1]->getName(), ==, "teli2");
930  TEST_COMPARE(teCons[1]->indexOfNextEvent(0), ==, 30);
931  TEST_COMPARE(teCons[2]->getName(), ==, "teli1");
932  TEST_COMPARE(teCons[2]->indexOfNextEvent(0), ==, 40);
933  TEST_COMPARE(teCons[3]->getName(), ==, "teri1");
934  TEST_COMPARE(teCons[3]->indexOfNextEvent(0), ==, 50);
935 
936  TEST_COMPARE(tec->eventInRangeIndex(70, 210, teCons), ==, true);
937  TEST_COMPARE(teCons.size(), ==, 4);
938  TEST_COMPARE(teCons[0]->getName(), ==, "teri2");
939  TEST_COMPARE(teCons[0]->indexOfNextEvent(70), ==, 80);
940  TEST_COMPARE(teCons[1]->getName(), ==, "teli1");
941  TEST_COMPARE(teCons[1]->indexOfNextEvent(70), ==, 90);
942  TEST_COMPARE(teCons[2]->getName(), ==, "teri1");
943  TEST_COMPARE(teCons[2]->indexOfNextEvent(70), ==, 100);
944  TEST_COMPARE(teCons[3]->getName(), ==, "teli2");
945  TEST_COMPARE(teCons[3]->indexOfNextEvent(70), ==, 130);
946 
947  TEST_COMPARE(tec->eventInRangeIndex(190, 210, teCons), ==, true);
948  TEST_COMPARE(teCons.size(), ==, 4);
949  TEST_COMPARE(teCons[0]->getName(), ==, "teri1");
950  TEST_COMPARE(teCons[0]->indexOfNextEvent(190), ==, 200);
951  TEST_COMPARE(teCons[1]->getName(), ==, "teri2");
952  TEST_COMPARE(teCons[1]->indexOfNextEvent(190), ==, 200);
953  TEST_COMPARE(teCons[2]->getName(), ==, "teli1");
954  TEST_COMPARE(teCons[2]->indexOfNextEvent(190), ==, 200);
955  TEST_COMPARE(teCons[3]->getName(), ==, "teli2");
956  TEST_COMPARE(teCons[3]->indexOfNextEvent(190), ==, 200);
957 }
958 
959 // ************************************************************
960 // ************************************************************
961 TEUCHOS_UNIT_TEST(TimeEventComposite, remove)
962 {
963  // Construct ParmeterList for testing.
964  auto tec = rcp(new Tempus::TimeEventComposite<double>());
965  auto ter = rcp(new Tempus::TimeEventRange<double>());
966  auto teri = rcp(new Tempus::TimeEventRangeIndex<double>());
967  auto tel = rcp(new Tempus::TimeEventList<double>());
968  auto teli = rcp(new Tempus::TimeEventListIndex<double>());
969 
970  ter->setName("Test Range");
971  teri->setName("Test Range Index");
972  tel->setName("Test List");
973  teli->setName("Test List Index");
974 
975  tec->add(ter);
976  tec->add(teri);
977  tec->add(tel);
978  tec->add(teli);
979  // tec->describe(out, Teuchos::VERB_EXTREME);
980 
981  tec->remove("Blah Blah");
982  TEST_COMPARE(tec->getSize(), ==, 4);
983 
984  tec->remove("Test Range Index");
985  TEST_COMPARE(tec->getSize(), ==, 3);
986  auto names = tec->getTimeEventNames();
987  TEST_COMPARE(names, ==, "Test Range, Test List, Test List Index");
988 
989  tec->remove("Test List Index");
990  TEST_COMPARE(tec->getSize(), ==, 2);
991  names = tec->getTimeEventNames();
992  TEST_COMPARE(names, ==, "Test Range, Test List");
993 
994  tec->remove("Test Range");
995  TEST_COMPARE(tec->getSize(), ==, 1);
996  names = tec->getTimeEventNames();
997  TEST_COMPARE(names, ==, "Test List");
998 
999  tec->remove("Test List");
1000  TEST_COMPARE(tec->getSize(), ==, 0);
1001  names = tec->getTimeEventNames();
1002  TEST_COMPARE(names, ==, "");
1003 }
1004 
1005 // ************************************************************
1006 // ************************************************************
1007 TEUCHOS_UNIT_TEST(TimeEventComposite, find)
1008 {
1009  // Construct ParmeterList for testing.
1010  auto tec = rcp(new Tempus::TimeEventComposite<double>());
1011  auto ter = rcp(new Tempus::TimeEventRange<double>());
1012  auto teri = rcp(new Tempus::TimeEventRangeIndex<double>());
1013  auto tel = rcp(new Tempus::TimeEventList<double>());
1014  auto teli = rcp(new Tempus::TimeEventListIndex<double>());
1015 
1016  ter->setName("Test Range");
1017  teri->setName("Test Range Index");
1018  tel->setName("Test List");
1019  teli->setName("Test List Index");
1020 
1021  tec->add(ter);
1022  tec->add(teri);
1023  tec->add(tel);
1024  tec->add(teli);
1025  // tec->describe(out, Teuchos::VERB_EXTREME);
1026 
1027  auto teTest = tec->find("Test Range");
1028  TEST_COMPARE(teTest->getName(), ==, "Test Range");
1029 
1030  teTest = tec->find("Test Range Index");
1031  TEST_COMPARE(teTest->getName(), ==, "Test Range Index");
1032 
1033  teTest = tec->find("Test List");
1034  TEST_COMPARE(teTest->getName(), ==, "Test List");
1035 
1036  teTest = tec->find("Test List Index");
1037  TEST_COMPARE(teTest->getName(), ==, "Test List Index");
1038 
1039  teTest = tec->find("Blah Blah");
1040  TEST_COMPARE(teTest, ==, Teuchos::null);
1041 }
1042 
1043 // ************************************************************
1044 // ************************************************************
1045 TEUCHOS_UNIT_TEST(TimeEventComposite, clear)
1046 {
1047  // Construct ParmeterList for testing.
1048  auto tec = rcp(new Tempus::TimeEventComposite<double>());
1049  auto ter = rcp(new Tempus::TimeEventRange<double>());
1050  auto teri = rcp(new Tempus::TimeEventRangeIndex<double>());
1051  auto tel = rcp(new Tempus::TimeEventList<double>());
1052  auto teli = rcp(new Tempus::TimeEventListIndex<double>());
1053 
1054  tec->add(ter);
1055  tec->add(teri);
1056  tec->add(tel);
1057  tec->add(teli);
1058  // tec->describe(out, Teuchos::VERB_EXTREME);
1059 
1060  TEST_COMPARE(tec->getSize(), ==, 4);
1061  tec->clear();
1062  TEST_COMPARE(tec->getSize(), ==, 0);
1063 }
1064 
1065 // ************************************************************
1066 // ************************************************************
1067 TEUCHOS_UNIT_TEST(TimeEventComposite, getValidParameters)
1068 {
1069  // Construct ParmeterList for testing.
1070  auto tec = rcp(new Tempus::TimeEventComposite<double>());
1071  auto ter = rcp(new Tempus::TimeEventRange<double>());
1072  auto teri = rcp(new Tempus::TimeEventRangeIndex<double>());
1073  auto tel = rcp(new Tempus::TimeEventList<double>());
1074  auto teli = rcp(new Tempus::TimeEventListIndex<double>());
1075 
1076  ter->setName("Test Range");
1077  teri->setName("Test Range Index");
1078  tel->setName("Test List");
1079  teli->setName("Test List Index");
1080 
1081  tec->add(ter);
1082  tec->add(teri);
1083  tec->add(tel);
1084  tec->add(teli);
1085  // tec->describe(out, Teuchos::VERB_EXTREME);
1086 
1087  auto timeEvents = tec->getTimeEvents();
1088  TEST_COMPARE(timeEvents.size(), ==, 4);
1089 
1090  auto pl = tec->getValidParameters();
1091 
1092  TEST_COMPARE(pl->get<std::string>("Name"), ==, "TimeEventComposite");
1093  TEST_COMPARE(pl->get<std::string>("Type"), ==, "Composite");
1094  TEST_COMPARE(pl->get<std::string>("Time Events"), ==,
1095  "Test Range, Test Range Index, Test List, Test List Index");
1096  TEST_COMPARE(pl->isSublist("Test Range"), ==, true);
1097  TEST_COMPARE(pl->isSublist("Test Range Index"), ==, true);
1098  TEST_COMPARE(pl->isSublist("Test List"), ==, true);
1099  TEST_COMPARE(pl->isSublist("Test List Index"), ==, true);
1100 
1101  { // Ensure that parameters are "used", excluding sublists.
1102  std::ostringstream unusedParameters;
1103  pl->unused(unusedParameters);
1104  TEST_COMPARE(
1105  unusedParameters.str(), ==,
1106  "WARNING: Parameter \"Test Range\" [unused] is unused\n"
1107  "WARNING: Parameter \"Test Range Index\" [unused] is unused\n"
1108  "WARNING: Parameter \"Test List\" [unused] is unused\n"
1109  "WARNING: Parameter \"Test List Index\" [unused] is unused\n");
1110  }
1111 
1112  auto terPL = pl->sublist("Test Range");
1113  TEST_COMPARE(terPL.get<std::string>("Type"), ==, "Range");
1114  TEST_COMPARE(terPL.get<std::string>("Name"), ==, "Test Range");
1115  TEST_FLOATING_EQUALITY(terPL.get<double>("Start Time"), 0.0, 1.0e-14);
1116  TEST_FLOATING_EQUALITY(terPL.get<double>("Stop Time"), 0.0, 1.0e-14);
1117  TEST_FLOATING_EQUALITY(terPL.get<double>("Stride Time"), 0.0, 1.0e-14);
1118  TEST_COMPARE(terPL.get<int>("Number of Events"), ==, 1);
1119  TEST_FLOATING_EQUALITY(terPL.get<double>("Relative Tolerance"),
1120  std::numeric_limits<double>::epsilon() * 100.0,
1121  1.0e-14);
1122 
1123  TEST_COMPARE(terPL.get<bool>("Land On Exactly"), ==, true);
1124 
1125  { // Ensure that parameters are "used", excluding sublists.
1126  std::ostringstream unusedParameters;
1127  terPL.unused(unusedParameters);
1128  TEST_COMPARE(unusedParameters.str(), ==, "");
1129  }
1130 
1131  auto teriPL = pl->sublist("Test Range Index");
1132  TEST_COMPARE(teriPL.get<std::string>("Type"), ==, "Range Index");
1133  TEST_COMPARE(teriPL.get<std::string>("Name"), ==, "Test Range Index");
1134  TEST_COMPARE(teriPL.get<int>("Start Index"), ==, 0);
1135  TEST_COMPARE(teriPL.get<int>("Stop Index"), ==, 0);
1136  TEST_COMPARE(teriPL.get<int>("Stride Index"), ==, 1);
1137 
1138  { // Ensure that parameters are "used", excluding sublists.
1139  std::ostringstream unusedParameters;
1140  teriPL.unused(unusedParameters);
1141  TEST_COMPARE(unusedParameters.str(), ==, "");
1142  }
1143 
1144  auto telPL = pl->sublist("Test List");
1145  TEST_COMPARE(telPL.get<std::string>("Type"), ==, "List");
1146  TEST_COMPARE(telPL.get<std::string>("Name"), ==, "Test List");
1147  TEST_FLOATING_EQUALITY(telPL.get<double>("Relative Tolerance"),
1148  std::numeric_limits<double>::epsilon() * 100.0,
1149  1.0e-14);
1150  TEST_COMPARE(telPL.get<bool>("Land On Exactly"), ==, true);
1151  TEST_COMPARE(telPL.get<std::string>("Time List"), ==, "");
1152 
1153  { // Ensure that parameters are "used", excluding sublists.
1154  std::ostringstream unusedParameters;
1155  telPL.unused(unusedParameters);
1156  TEST_COMPARE(unusedParameters.str(), ==, "");
1157  }
1158 
1159  auto teliPL = pl->sublist("Test List Index");
1160  TEST_COMPARE(teliPL.get<std::string>("Type"), ==, "List Index");
1161  TEST_COMPARE(teliPL.get<std::string>("Name"), ==, "Test List Index");
1162  TEST_COMPARE(teliPL.get<std::string>("Index List"), ==, "");
1163 
1164  { // Ensure that parameters are "used", excluding sublists.
1165  std::ostringstream unusedParameters;
1166  teliPL.unused(unusedParameters);
1167  TEST_COMPARE(unusedParameters.str(), ==, "");
1168  }
1169 }
1170 
1171 // ************************************************************
1172 // ************************************************************
1174 {
1175  using Teuchos::ParameterList;
1176  using Teuchos::rcp_const_cast;
1177 
1178  { // Construct from default ParameterList.
1179  auto tecTmp = rcp(new Tempus::TimeEventComposite<double>());
1180  auto pl = rcp_const_cast<ParameterList>(tecTmp->getValidParameters());
1181 
1182  auto tec = Tempus::createTimeEventComposite<double>(pl);
1183  // tec->describe(out, Teuchos::VERB_EXTREME);
1184 
1185  TEST_COMPARE(tec->getName(), ==, "TimeEventComposite");
1186  TEST_COMPARE(tec->getType(), ==, "Composite");
1187  TEST_COMPARE(tec->getSize(), ==, 0);
1188  TEST_COMPARE(tec->getTimeEventNames(), ==, "");
1189  }
1190 
1191  { // Construct with TimeEvents.
1192  auto tecTmp = rcp(new Tempus::TimeEventComposite<double>());
1193  auto ter = rcp(new Tempus::TimeEventRange<double>());
1194  auto teri = rcp(new Tempus::TimeEventRangeIndex<double>());
1195  auto tel = rcp(new Tempus::TimeEventList<double>());
1196  auto teli = rcp(new Tempus::TimeEventListIndex<double>());
1197 
1198  ter->setName("Test Range");
1199  teri->setName("Test Range Index");
1200  tel->setName("Test List");
1201  teli->setName("Test List Index");
1202 
1203  tecTmp->add(ter);
1204  tecTmp->add(teri);
1205  tecTmp->add(tel);
1206  tecTmp->add(teli);
1207 
1208  auto pl = rcp_const_cast<ParameterList>(tecTmp->getValidParameters());
1209 
1210  auto tec = Tempus::createTimeEventComposite<double>(pl);
1211  // tec->describe(out, Teuchos::VERB_EXTREME);
1212 
1213  TEST_COMPARE(tec->getName(), ==, "TimeEventComposite");
1214  TEST_COMPARE(tec->getType(), ==, "Composite");
1215  TEST_COMPARE(tec->getSize(), ==, 4);
1216  TEST_COMPARE(tec->getTimeEventNames(), ==,
1217  "Test Range, Test Range Index, Test List, Test List Index");
1218  }
1219 
1220  { // Construct with non-Tempus TimeEvent.
1221  auto tecTmp = rcp(new Tempus::TimeEventComposite<double>());
1222  auto pl = rcp_const_cast<ParameterList>(tecTmp->getValidParameters());
1223 
1224  auto nonTempusTE = Teuchos::parameterList("Application Time Event");
1225  nonTempusTE->set<std::string>("Name", "Application Time Event");
1226  nonTempusTE->set<std::string>("Type", "Application Time Event Type");
1227  nonTempusTE->set<double>("Secret Sauce", 1.2345);
1228  pl->set("Application Time Event", *nonTempusTE);
1229  pl->set("Time Events", "Application Time Event");
1230 
1231  auto tec = Tempus::createTimeEventComposite<double>(pl);
1232  // tec->describe(out, Teuchos::VERB_EXTREME);
1233 
1234  TEST_COMPARE(tec->getName(), ==, "TimeEventComposite");
1235  TEST_COMPARE(tec->getType(), ==, "Composite");
1236  TEST_COMPARE(tec->getSize(), ==, 0);
1237  TEST_COMPARE(tec->getTimeEventNames(), ==, "");
1238  }
1239 }
1240 
1241 } // namespace Tempus_Unit_Test
Teuchos::RCP< Tempus::TimeEventRange< double > > getTestRange3()
TimeEventRangeIndex specifies a start, stop and stride index.
Teuchos::RCP< Tempus::TimeEventRange< double > > getTestRange2()
Teuchos::RCP< Tempus::TimeEventListIndex< double > > getTestListIndex2()
TimeEventListIndex specifies a list of index events.
#define TEST_COMPARE(v1, comp, v2)
Teuchos::RCP< Tempus::TimeEventRangeIndex< double > > getTestRangeIndex3()
#define TEST_FLOATING_EQUALITY(v1, v2, tol)
Teuchos::RCP< Tempus::TimeEventList< double > > getTestList3()
Teuchos::RCP< Tempus::TimeEventRange< double > > getTestRange1()
TimeEventRange specifies a start, stop and stride time.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Teuchos::RCP< Tempus::TimeEventList< double > > getTestList1()
This composite TimeEvent loops over added TimeEvents.
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)
Teuchos::RCP< Tempus::TimeEventListIndex< double > > getTestListIndex3()
Teuchos::RCP< Tempus::TimeEventListIndex< double > > getTestListIndex1()
Teuchos::RCP< Tempus::TimeEventRangeIndex< double > > getTestRangeIndex1()
Teuchos::RCP< Tempus::TimeEventList< double > > getTestList2()
Teuchos::RCP< Tempus::TimeEventRangeIndex< double > > getTestRangeIndex2()
TimeEventList specifies a list of time events.
Teuchos::RCP< TimeEventComposite< Scalar > > createTimeEventComposite(Teuchos::RCP< Teuchos::ParameterList > const &pList)
TimeEventComposite nonmember constructor via ParameterList.