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