Tempus Version of the Day
Time Integration
Loading...
Searching...
No Matches
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
18static double PI = M_PI;
19
20namespace Tempus_Unit_Test {
21
22using Teuchos::RCP;
23using Teuchos::rcp;
24using Teuchos::rcp_const_cast;
25using Teuchos::rcp_dynamic_cast;
26
27
28// TimeEventRanges for testing.
29// ------------------------------------------------------------
30Teuchos::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
37Teuchos::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
44Teuchos::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// ------------------------------------------------------------
54Teuchos::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
68Teuchos::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
81Teuchos::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// ------------------------------------------------------------
95Teuchos::RCP<Tempus::TimeEventRangeIndex<double> > getTestRangeIndex1()
96{
97 auto teRangeIndex1 = rcp(new Tempus::TimeEventRangeIndex<double>(
98 -1, 10, 3, "teRangeIndex1"));
99 return teRangeIndex1;
100}
101
102Teuchos::RCP<Tempus::TimeEventRangeIndex<double> > getTestRangeIndex2()
103{
104 auto teRangeIndex2 = rcp(new Tempus::TimeEventRangeIndex<double>(
105 -5, 8, 4, "teRangeIndex2"));
106 return teRangeIndex2;
107}
108
109Teuchos::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// ------------------------------------------------------------
119Teuchos::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
133Teuchos::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
143Teuchos::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// ************************************************************
158TEUCHOS_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// ************************************************************
181TEUCHOS_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// ************************************************************
240TEUCHOS_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// ************************************************************
259TEUCHOS_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// ************************************************************
279TEUCHOS_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// ************************************************************
301TEUCHOS_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// ************************************************************
331TEUCHOS_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// ************************************************************
351TEUCHOS_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// ************************************************************
373TEUCHOS_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// ************************************************************
402TEUCHOS_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// ************************************************************
422TEUCHOS_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// ************************************************************
444TEUCHOS_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// ************************************************************
474TEUCHOS_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// ************************************************************
494TEUCHOS_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// ************************************************************
516TEUCHOS_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// ************************************************************
541TEUCHOS_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// ************************************************************
599TEUCHOS_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// ************************************************************
727TEUCHOS_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// ************************************************************
957TEUCHOS_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// ************************************************************
1005TEUCHOS_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// ************************************************************
1045TEUCHOS_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// ************************************************************
1069TEUCHOS_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// ************************************************************
1173TEUCHOS_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_Test
This composite TimeEvent loops over added TimeEvents.
TimeEventListIndex specifies a list of index events.
TimeEventList specifies a list of time events.
TimeEventRangeIndex specifies a start, stop and stride index.
TimeEventRange specifies a start, stop and stride time.
Teuchos::RCP< Tempus::TimeEventList< double > > getTestList3()
Teuchos::RCP< Tempus::TimeEventRange< double > > getTestRange2()
Teuchos::RCP< Tempus::TimeEventRangeIndex< double > > getTestRangeIndex1()
Teuchos::RCP< Tempus::TimeEventListIndex< double > > getTestListIndex3()
Teuchos::RCP< Tempus::TimeEventList< double > > getTestList2()
Teuchos::RCP< Tempus::TimeEventListIndex< double > > getTestListIndex2()
Teuchos::RCP< Tempus::TimeEventRange< double > > getTestRange1()
Teuchos::RCP< Tempus::TimeEventList< double > > getTestList1()
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)
Teuchos::RCP< Tempus::TimeEventRange< double > > getTestRange3()
Teuchos::RCP< Tempus::TimeEventRangeIndex< double > > getTestRangeIndex3()
Teuchos::RCP< Tempus::TimeEventRangeIndex< double > > getTestRangeIndex2()
Teuchos::RCP< Tempus::TimeEventListIndex< double > > getTestListIndex1()