Tempus  Version of the Day
Time Integration
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Tempus_UnitTest_SolutionHistory.cpp
Go to the documentation of this file.
1 //@HEADER
2 // *****************************************************************************
3 // Tempus: Time Integration and Sensitivity Analysis Package
4 //
5 // Copyright 2017 NTESS and the Tempus contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 //@HEADER
9 
10 #include "Tempus_UnitTest_Utils.hpp"
11 
12 #include "Tempus_SolutionHistory.hpp"
13 #include "Tempus_InterpolatorFactory.hpp"
14 
15 #include "../TestModels/DahlquistTestModel.hpp"
16 
17 namespace Tempus_Unit_Test {
18 
19 using Teuchos::ParameterList;
20 using Teuchos::RCP;
21 using Teuchos::rcp;
22 using Teuchos::rcp_const_cast;
23 using Teuchos::rcp_dynamic_cast;
24 using Teuchos::sublist;
25 
26 // ************************************************************
27 // ************************************************************
28 TEUCHOS_UNIT_TEST(SolutionHistory, Default_Construction)
29 {
30  auto sh = rcp(new Tempus::SolutionHistory<double>());
31  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
32  // as no State is set.
33 
34  auto model = rcp(new Tempus_Test::SinCosModel<double>());
35  auto inArgsIC = model->getNominalValues();
36  auto icSolution =
37  rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
38  auto icState = Tempus::createSolutionStateX<double>(icSolution);
39  sh->addState(icState);
40  sh->initialize();
41  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
42 
43  // Test the get functions (i.e., defaults).
44  TEST_COMPARE(sh->getNumStates(), ==, 1);
45  TEST_COMPARE(sh->getInterpolator()->order(), ==, 0);
46  TEST_COMPARE(sh->getStorageType(), ==, Tempus::STORAGE_TYPE_UNDO);
47  TEST_COMPARE(sh->getStorageLimit(), ==, 2);
48 
49  // Test the set functions.
50  sh->setName("Testing");
51  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
52  sh->setStorageType(Tempus::STORAGE_TYPE_STATIC);
53  sh->initialize();
54  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
55  sh->setStorageTypeString("Static");
56  sh->initialize();
57  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
58  sh->setStorageLimit(99);
59  sh->initialize();
60  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
61 
62  TEST_COMPARE(sh->getName(), ==, "Testing");
63  TEST_COMPARE(sh->getStorageType(), ==, Tempus::STORAGE_TYPE_STATIC);
64  TEST_COMPARE(sh->getStorageTypeString(), ==, "Static");
65  TEST_COMPARE(sh->getStorageLimit(), ==, 99);
66 
67  TEST_FLOATING_EQUALITY(sh->minTime(), 0.0, 1.0e-14);
68  TEST_FLOATING_EQUALITY(sh->maxTime(), 0.0, 1.0e-14);
69 }
70 
71 // ************************************************************
72 // ************************************************************
73 TEUCHOS_UNIT_TEST(SolutionHistory, Full_Construction)
74 {
75  std::string name = "Unit Test";
76 
77  auto history = rcp(new std::vector<RCP<Tempus::SolutionState<double> > >);
78  auto model = rcp(new Tempus_Test::SinCosModel<double>());
79  auto inArgsIC = model->getNominalValues();
80  auto icSolution =
81  rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
82  Teuchos::RCP<Tempus::SolutionState<double> > icState =
83  Tempus::createSolutionStateX<double>(icSolution);
84  history->push_back(icState);
85 
86  auto interpolator = Tempus::InterpolatorFactory<double>::createInterpolator();
87 
88  Tempus::StorageType storageType = Tempus::STORAGE_TYPE_STATIC;
89  int storageLimit = 99;
90 
91  auto sh = rcp(new Tempus::SolutionHistory<double>(name, history, interpolator,
92  storageType, storageLimit));
93  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
94 
95  TEST_COMPARE(sh->getNumStates(), ==, 1);
96  TEST_COMPARE(sh->getInterpolator()->order(), ==, 0);
97  TEST_COMPARE(sh->getStorageType(), ==, Tempus::STORAGE_TYPE_STATIC);
98  TEST_COMPARE(sh->getStorageLimit(), ==, 99);
99 }
100 
101 // ************************************************************
102 // ************************************************************
103 TEUCHOS_UNIT_TEST(SolutionHistory, Create_Construction)
104 {
105  auto sh_temp = rcp(new Tempus::SolutionHistory<double>());
106  RCP<ParameterList> pl = sh_temp->getNonconstParameterList();
107 
108  pl->setName("Unit Test");
109  pl->set<std::string>("Storage Type", "Static");
110  pl->set<int>("Storage Limit", 99);
111 
112  pl->sublist("Interpolator").set("Interpolator Type", "Lagrange");
113  pl->sublist("Interpolator").set("Order", 1);
114 
115  auto sh = Tempus::createSolutionHistoryPL<double>(pl);
116  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
117  // as no State is set.
118 
119  TEST_COMPARE(sh->getNumStates(), ==, 0);
120  TEST_COMPARE(sh->getInterpolator()->order(), ==, 1);
121  TEST_COMPARE(sh->getStorageType(), ==, Tempus::STORAGE_TYPE_STATIC);
122  TEST_COMPARE(sh->getStorageLimit(), ==, 99);
123 }
124 
125 // ************************************************************
126 // ************************************************************
127 TEUCHOS_UNIT_TEST(SolutionHistory, addState_With_Keep_Newest)
128 {
129  // Setup SolutionHistory for testing.
130  auto sh = rcp(new Tempus::SolutionHistory<double>());
131  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
132  // as no State is set.
133 
134  auto model = rcp(new Tempus_Test::DahlquistTestModel<double>(-1.0, false));
135  auto inArgsIC = model->getNominalValues();
136  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
137  auto state0 = Tempus::createSolutionStateX<double>(icSoln);
138  state0->setTime(0.0);
139  state0->setIndex(0);
140 
141  sh->setStorageTypeString("Keep Newest");
142  sh->addState(state0);
143  sh->initialize();
144  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
145 
146  TEST_COMPARE(sh->getNumStates(), ==, 1);
147  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 0.0, 1.0e-14);
148  TEST_COMPARE(sh->getCurrentIndex(), ==, 0);
149  TEST_FLOATING_EQUALITY(sh->minTime(), 0.0, 1.0e-14);
150  TEST_FLOATING_EQUALITY(sh->maxTime(), 0.0, 1.0e-14);
151 
152  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
153  TEUCHOS_ASSERT(sh->getStateTimeIndexN(false) != Teuchos::null);
154  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1(false) == Teuchos::null);
155  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2(false) == Teuchos::null);
156  TEUCHOS_ASSERT(sh->getStateTimeIndex(0, false) != Teuchos::null);
157 
158  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 0);
159  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 0.0, 1.0e-14);
160 
161  // ---------------------------------------------------------------------------
162 
163  // Second State -- should replace first state.
164  auto state1 = Tempus::createSolutionStateX<double>(icSoln);
165  state1->setTime(1.0);
166  state1->setIndex(1);
167  sh->addState(state1);
168 
169  TEST_COMPARE(sh->getNumStates(), ==, 1); // Only 1 state!
170  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 1.0, 1.0e-14);
171  TEST_COMPARE(sh->getCurrentIndex(), ==, 1);
172  TEST_FLOATING_EQUALITY(sh->minTime(), 1.0, 1.0e-14);
173  TEST_FLOATING_EQUALITY(sh->maxTime(), 1.0, 1.0e-14);
174 
175  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
176  TEUCHOS_ASSERT(sh->getStateTimeIndexN(false) != Teuchos::null);
177  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1(false) == Teuchos::null);
178  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2(false) == Teuchos::null);
179  TEUCHOS_ASSERT(sh->getStateTimeIndex(0, false) == Teuchos::null);
180  TEUCHOS_ASSERT(sh->getStateTimeIndex(1, false) != Teuchos::null);
181 
182  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 1);
183  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 1.0, 1.0e-14);
184 
185  // ---------------------------------------------------------------------------
186 
187  // Third State -- old state should not be added.
188  auto state2 = Tempus::createSolutionStateX<double>(icSoln);
189  state2->setTime(-1.0);
190  state2->setIndex(-1);
191  sh->addState(state2);
192 
193  // Still second state.
194  TEST_COMPARE(sh->getNumStates(), ==, 1); // Only 1 state!
195  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 1.0, 1.0e-14);
196  TEST_COMPARE(sh->getCurrentIndex(), ==, 1);
197  TEST_FLOATING_EQUALITY(sh->minTime(), 1.0, 1.0e-14);
198  TEST_FLOATING_EQUALITY(sh->maxTime(), 1.0, 1.0e-14);
199 
200  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
201  TEUCHOS_ASSERT(sh->getStateTimeIndexN(false) != Teuchos::null);
202  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1(false) == Teuchos::null);
203  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2(false) == Teuchos::null);
204  TEUCHOS_ASSERT(sh->getStateTimeIndex(0, false) == Teuchos::null);
205  TEUCHOS_ASSERT(sh->getStateTimeIndex(1, false) != Teuchos::null);
206 
207  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 1);
208  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 1.0, 1.0e-14);
209 
210  // ---------------------------------------------------------------------------
211 }
212 
213 // ************************************************************
214 // ************************************************************
215 TEUCHOS_UNIT_TEST(SolutionHistory, addState_With_Undo)
216 {
217  // Setup SolutionHistory for testing.
218  auto sh = rcp(new Tempus::SolutionHistory<double>());
219  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
220  // as no State is set.
221 
222  auto model = rcp(new Tempus_Test::DahlquistTestModel<double>(-1.0, false));
223  auto inArgsIC = model->getNominalValues();
224  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
225  auto state0 = Tempus::createSolutionStateX<double>(icSoln);
226  state0->setTime(0.0);
227  state0->setIndex(0);
228  sh->addState(state0);
229  sh->initialize();
230  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
231 
232  TEST_COMPARE(sh->getNumStates(), ==, 1);
233  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 0.0, 1.0e-14);
234  TEST_COMPARE(sh->getCurrentIndex(), ==, 0);
235  TEST_FLOATING_EQUALITY(sh->minTime(), 0.0, 1.0e-14);
236  TEST_FLOATING_EQUALITY(sh->maxTime(), 0.0, 1.0e-14);
237 
238  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
239  TEUCHOS_ASSERT(sh->getStateTimeIndexN(false) != Teuchos::null);
240  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1(false) == Teuchos::null);
241  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2(false) == Teuchos::null);
242  TEUCHOS_ASSERT(sh->getStateTimeIndex(0, false) != Teuchos::null);
243 
244  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 0);
245  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 0.0, 1.0e-14);
246 
247  // ---------------------------------------------------------------------------
248 
249  // Second State
250  auto state1 = Tempus::createSolutionStateX<double>(icSoln);
251  state1->setTime(1.0);
252  state1->setIndex(1);
253  sh->addState(state1);
254 
255  TEST_COMPARE(sh->getNumStates(), ==, 2);
256  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 1.0, 1.0e-14);
257  TEST_COMPARE(sh->getCurrentIndex(), ==, 1);
258  TEST_FLOATING_EQUALITY(sh->minTime(), 0.0, 1.0e-14);
259  TEST_FLOATING_EQUALITY(sh->maxTime(), 1.0, 1.0e-14);
260 
261  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
262  TEUCHOS_ASSERT(sh->getStateTimeIndexN(false) != Teuchos::null);
263  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1(false) != Teuchos::null);
264  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2(false) == Teuchos::null);
265  TEUCHOS_ASSERT(sh->getStateTimeIndex(0, false) != Teuchos::null);
266  TEUCHOS_ASSERT(sh->getStateTimeIndex(1, false) != Teuchos::null);
267 
268  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 1);
269  TEST_COMPARE(sh->getStateTimeIndexNM1()->getIndex(), ==, 0);
270  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 1.0, 1.0e-14);
271  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexNM1()->getTime(), 0.0, 1.0e-14);
272 
273  // ---------------------------------------------------------------------------
274 
275  // Third State -- should be added and first state dropped.
276  auto state2 = Tempus::createSolutionStateX<double>(icSoln);
277  state2->setTime(2.0);
278  state2->setIndex(2);
279  sh->addState(state2);
280 
281  TEST_COMPARE(sh->getNumStates(), ==, 2); // Only 2 states!
282  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 2.0, 1.0e-14);
283  TEST_COMPARE(sh->getCurrentIndex(), ==, 2);
284  TEST_FLOATING_EQUALITY(sh->minTime(), 1.0, 1.0e-14);
285  TEST_FLOATING_EQUALITY(sh->maxTime(), 2.0, 1.0e-14);
286 
287  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
288  TEUCHOS_ASSERT(sh->getStateTimeIndexN(false) != Teuchos::null);
289  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1(false) != Teuchos::null);
290  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2(false) == Teuchos::null);
291  TEUCHOS_ASSERT(sh->getStateTimeIndex(1, false) != Teuchos::null);
292  TEUCHOS_ASSERT(sh->getStateTimeIndex(2, false) != Teuchos::null);
293 
294  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 2);
295  TEST_COMPARE(sh->getStateTimeIndexNM1()->getIndex(), ==, 1);
296  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 2.0, 1.0e-14);
297  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexNM1()->getTime(), 1.0, 1.0e-14);
298 
299  // ---------------------------------------------------------------------------
300 
301  // Fourth State -- old state should not be added.
302  sh->addState(state0);
303 
304  // Still third and second states.
305  TEST_COMPARE(sh->getNumStates(), ==, 2); // Only 2 states!
306  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 2.0, 1.0e-14);
307  TEST_COMPARE(sh->getCurrentIndex(), ==, 2);
308  TEST_FLOATING_EQUALITY(sh->minTime(), 1.0, 1.0e-14);
309  TEST_FLOATING_EQUALITY(sh->maxTime(), 2.0, 1.0e-14);
310 
311  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
312  TEUCHOS_ASSERT(sh->getStateTimeIndexN(false) != Teuchos::null);
313  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1(false) != Teuchos::null);
314  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2(false) == Teuchos::null);
315  TEUCHOS_ASSERT(sh->getStateTimeIndex(1, false) != Teuchos::null);
316  TEUCHOS_ASSERT(sh->getStateTimeIndex(2, false) != Teuchos::null);
317 
318  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 2);
319  TEST_COMPARE(sh->getStateTimeIndexNM1()->getIndex(), ==, 1);
320  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 2.0, 1.0e-14);
321  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexNM1()->getTime(), 1.0, 1.0e-14);
322 
323  // ---------------------------------------------------------------------------
324 }
325 
326 // ************************************************************
327 // ************************************************************
328 TEUCHOS_UNIT_TEST(SolutionHistory, addState_With_Static)
329 {
330  // Setup SolutionHistory for testing.
331  auto sh = rcp(new Tempus::SolutionHistory<double>());
332  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
333  // as no State is set.
334  sh->setStorageTypeString("Static");
335  sh->setStorageLimit(7);
336 
337  auto model = rcp(new Tempus_Test::DahlquistTestModel<double>(-1.0, false));
338  auto inArgsIC = model->getNominalValues();
339 
340  // Sequential insertion.
341  // ---------------------------------------------------------------------------
342  for (size_t i = 0; i < 13; ++i) {
343  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
344  auto stateI = Tempus::createSolutionStateX<double>(icSoln);
345  stateI->setTime(i * 0.9);
346  stateI->setTimeStep(0.9);
347  stateI->setIndex(i);
348  sh->addState(stateI);
349  }
350  sh->initialize();
351  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
352 
353  sh->describe(out, Teuchos::VERB_MEDIUM);
354 
355  TEST_COMPARE(sh->getNumStates(), ==, 7);
356  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 10.8, 1.0e-14);
357  TEST_COMPARE(sh->getCurrentIndex(), ==, 12);
358  TEST_FLOATING_EQUALITY(sh->minTime(), 5.4, 1.0e-14);
359  TEST_FLOATING_EQUALITY(sh->maxTime(), 10.8, 1.0e-14);
360 
361  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
362  TEUCHOS_ASSERT(sh->getStateTimeIndexN() != Teuchos::null);
363  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1() != Teuchos::null);
364  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2() != Teuchos::null);
365  TEUCHOS_ASSERT(sh->getStateTimeIndex(7) != Teuchos::null);
366 
367  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 12);
368  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 10.8, 1.0e-14);
369 
370  TEST_COMPARE(sh->getStateTimeIndexNM1()->getIndex(), ==, 11);
371  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexNM1()->getTime(), 9.9, 1.0e-14);
372 
373  TEST_COMPARE(sh->getStateTimeIndexNM2()->getIndex(), ==, 10);
374  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexNM2()->getTime(), 9.0, 1.0e-14);
375 
376  TEST_COMPARE(sh->getStateTimeIndex(7)->getIndex(), ==, 7);
377  TEST_FLOATING_EQUALITY(sh->getStateTimeIndex(7)->getTime(), 6.3, 1.0e-14);
378 
379  // ---------------------------------------------------------------------------
380 
381  // "Random" insertion.
382  // ---------------------------------------------------------------------------
383  sh->clear();
384  for (size_t i = 0; i < 3; ++i) {
385  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
386  auto stateI = Tempus::createSolutionStateX<double>(icSoln);
387  stateI->setTime(2 * i * 0.9 + 6.3);
388  stateI->setTimeStep(0.9);
389  stateI->setIndex(2 * i + 7);
390  sh->addState(stateI);
391  }
392  for (size_t i = 0; i < 4; ++i) {
393  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
394  auto stateI = Tempus::createSolutionStateX<double>(icSoln);
395  stateI->setTime(2 * i * 0.9 + 5.4);
396  stateI->setTimeStep(0.9);
397  stateI->setIndex(2 * i + 6);
398  sh->addState(stateI);
399  }
400  sh->initialize();
401  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
402 
403  sh->describe(out, Teuchos::VERB_MEDIUM);
404 
405  TEST_COMPARE(sh->getNumStates(), ==, 7);
406  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 10.8, 1.0e-14);
407  TEST_COMPARE(sh->getCurrentIndex(), ==, 12);
408  TEST_FLOATING_EQUALITY(sh->minTime(), 5.4, 1.0e-14);
409  TEST_FLOATING_EQUALITY(sh->maxTime(), 10.8, 1.0e-14);
410 
411  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
412  TEUCHOS_ASSERT(sh->getStateTimeIndexN() != Teuchos::null);
413  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1() != Teuchos::null);
414  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2() != Teuchos::null);
415  TEUCHOS_ASSERT(sh->getStateTimeIndex(7) != Teuchos::null);
416 
417  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 12);
418  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 10.8, 1.0e-14);
419 
420  TEST_COMPARE(sh->getStateTimeIndexNM1()->getIndex(), ==, 11);
421  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexNM1()->getTime(), 9.9, 1.0e-14);
422 
423  TEST_COMPARE(sh->getStateTimeIndexNM2()->getIndex(), ==, 10);
424  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexNM2()->getTime(), 9.0, 1.0e-14);
425 
426  TEST_COMPARE(sh->getStateTimeIndex(7)->getIndex(), ==, 7);
427  TEST_FLOATING_EQUALITY(sh->getStateTimeIndex(7)->getTime(), 6.3, 1.0e-14);
428 
429  // ---------------------------------------------------------------------------
430 }
431 
432 // ************************************************************
433 // ************************************************************
434 TEUCHOS_UNIT_TEST(SolutionHistory, removeState)
435 {
436  // Setup SolutionHistory for testing.
437  auto sh = rcp(new Tempus::SolutionHistory<double>());
438  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
439  // as no State is set.
440  sh->setStorageTypeString("Static");
441  sh->setStorageLimit(7);
442 
443  auto model = rcp(new Tempus_Test::DahlquistTestModel<double>(-1.0, false));
444  auto inArgsIC = model->getNominalValues();
445 
446  // ---------------------------------------------------------------------------
447  for (size_t i = 0; i < 13; ++i) {
448  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
449  auto stateI = Tempus::createSolutionStateX<double>(icSoln);
450  stateI->setTime(i * 0.9);
451  stateI->setTimeStep(0.9);
452  stateI->setIndex(i);
453  sh->addState(stateI);
454  }
455  sh->initialize();
456  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
457 
458  sh->describe(out, Teuchos::VERB_MEDIUM);
459 
460  sh->removeState(sh->getStateTimeIndex(6));
461  sh->removeState(7.2);
462  sh->removeState(sh->getStateTimeIndex(10));
463  sh->removeState(10.8);
464 
465  sh->describe(out, Teuchos::VERB_MEDIUM);
466 
467  TEST_COMPARE(sh->getNumStates(), ==, 3);
468  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 9.9, 1.0e-14);
469  TEST_COMPARE(sh->getCurrentIndex(), ==, 11);
470  TEST_FLOATING_EQUALITY(sh->minTime(), 6.3, 1.0e-14);
471  TEST_FLOATING_EQUALITY(sh->maxTime(), 9.9, 1.0e-14);
472 
473  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
474  TEUCHOS_ASSERT(sh->getStateTimeIndexN() != Teuchos::null);
475  TEUCHOS_ASSERT(sh->getStateTimeIndexNM1() == Teuchos::null);
476  TEUCHOS_ASSERT(sh->getStateTimeIndexNM2() != Teuchos::null);
477  TEUCHOS_ASSERT(sh->getStateTimeIndex(7) != Teuchos::null);
478 
479  TEST_COMPARE(sh->getStateTimeIndexN()->getIndex(), ==, 11);
480  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexN()->getTime(), 9.9, 1.0e-14);
481 
482  TEST_COMPARE(sh->getStateTimeIndexNM2()->getIndex(), ==, 9);
483  TEST_FLOATING_EQUALITY(sh->getStateTimeIndexNM2()->getTime(), 8.1, 1.0e-14);
484 
485  // ---------------------------------------------------------------------------
486 }
487 
488 // ************************************************************
489 // ************************************************************
490 TEUCHOS_UNIT_TEST(SolutionHistory, initWorkingState_Passing)
491 {
492  // Setup SolutionHistory for testing.
493  auto sh = rcp(new Tempus::SolutionHistory<double>());
494  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
495  // as no State is set.
496 
497  auto model = rcp(new Tempus_Test::DahlquistTestModel<double>(-1.0, false));
498  auto inArgsIC = model->getNominalValues();
499  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
500  auto state0 = Tempus::createSolutionStateX<double>(icSoln);
501  state0->setTime(0.0);
502  state0->setTimeStep(1.0);
503  state0->setIndex(0);
504  sh->addState(state0);
505  sh->initialize();
506  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
507 
508  // State before initializing workingState
509  // with sh->getWorkingState() == Teuchos::null, i.e., workingState
510  // was promoted from last time step or initial condition.
511  TEST_COMPARE(sh->getNumStates(), ==, 1);
512  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
513  TEUCHOS_ASSERT(sh->getCurrentState() == sh->getStateTimeIndexN());
514  TEUCHOS_ASSERT(sh->getWorkingState() == Teuchos::null);
515 
516  sh->initWorkingState();
517 
518  // State after initializing workingState.
519  TEST_COMPARE(sh->getNumStates(), ==, 2);
520  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 0.0, 1.0e-14);
521  TEST_COMPARE(sh->getCurrentIndex(), ==, 0);
522  TEST_FLOATING_EQUALITY(sh->minTime(), 0.0, 1.0e-14);
523  TEST_FLOATING_EQUALITY(sh->maxTime(), 1.0, 1.0e-14);
524 
525  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
526  TEUCHOS_ASSERT(sh->getCurrentState() == sh->getStateTimeIndexNM1());
527  TEUCHOS_ASSERT(sh->getWorkingState() != Teuchos::null);
528  TEUCHOS_ASSERT(sh->getWorkingState() == sh->getStateTimeIndexN());
529 
530  TEST_COMPARE(sh->getCurrentState()->getIndex(), ==, 0);
531  TEST_FLOATING_EQUALITY(sh->getCurrentState()->getTime(), 0.0, 1.0e-14);
532 
533  TEST_COMPARE(sh->getWorkingState()->getIndex(), ==, 1);
534  TEST_FLOATING_EQUALITY(sh->getWorkingState()->getTime(), 1.0, 1.0e-14);
535 
536  // ---------------------------------------------------------------------------
537 }
538 
539 // ************************************************************
540 // ************************************************************
541 TEUCHOS_UNIT_TEST(SolutionHistory, initWorkingState_Failing)
542 {
543  // Setup SolutionHistory for testing.
544  auto sh = rcp(new Tempus::SolutionHistory<double>());
545  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
546  // as no State is set.
547 
548  auto model = rcp(new Tempus_Test::DahlquistTestModel<double>(-1.0, false));
549  auto inArgsIC = model->getNominalValues();
550  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
551  auto state0 = Tempus::createSolutionStateX<double>(icSoln);
552  state0->setTime(0.0);
553  state0->setTimeStep(1.0);
554  state0->setIndex(0);
555  sh->addState(state0);
556  sh->initialize();
557  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
558 
559  auto state1 = Tempus::createSolutionStateX<double>(icSoln);
560  state1->setTime(1.0);
561  state1->setTimeStep(1.0);
562  state1->setIndex(1);
563  sh->addWorkingState(state1);
564  sh->getWorkingState()->setSolutionStatus(Tempus::Status::FAILED);
565 
566  // State before initializing workingState
567  // with sh->getWorkingState() != Teuchos::null, i.e., workingState
568  // was NOT promoted from last time step or initial condition.
569  TEST_COMPARE(sh->getNumStates(), ==, 2);
570  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 0.0, 1.0e-14);
571  TEST_COMPARE(sh->getCurrentIndex(), ==, 0);
572  TEST_FLOATING_EQUALITY(sh->minTime(), 0.0, 1.0e-14);
573  TEST_FLOATING_EQUALITY(sh->maxTime(), 1.0, 1.0e-14);
574 
575  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
576  TEUCHOS_ASSERT(sh->getCurrentState() == sh->getStateTimeIndexNM1());
577  TEUCHOS_ASSERT(sh->getWorkingState() != Teuchos::null);
578  TEUCHOS_ASSERT(sh->getWorkingState() == sh->getStateTimeIndexN());
579 
580  TEST_COMPARE(sh->getCurrentState()->getIndex(), ==, 0);
581  TEST_FLOATING_EQUALITY(sh->getCurrentState()->getTime(), 0.0, 1.0e-14);
582 
583  TEST_COMPARE(sh->getWorkingState()->getIndex(), ==, 1);
584  TEST_FLOATING_EQUALITY(sh->getWorkingState()->getTime(), 1.0, 1.0e-14);
585 
586  sh->initWorkingState();
587 
588  // State after initializing workingState.
589  // Should be unchanged as we are trying to redo FAILing time step.
590  TEST_COMPARE(sh->getNumStates(), ==, 2);
591  TEST_FLOATING_EQUALITY(sh->getCurrentTime(), 0.0, 1.0e-14);
592  TEST_COMPARE(sh->getCurrentIndex(), ==, 0);
593  TEST_FLOATING_EQUALITY(sh->minTime(), 0.0, 1.0e-14);
594  TEST_FLOATING_EQUALITY(sh->maxTime(), 1.0, 1.0e-14);
595 
596  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
597  TEUCHOS_ASSERT(sh->getCurrentState() == sh->getStateTimeIndexNM1());
598  TEUCHOS_ASSERT(sh->getWorkingState() != Teuchos::null);
599  TEUCHOS_ASSERT(sh->getWorkingState() == sh->getStateTimeIndexN());
600 
601  TEST_COMPARE(sh->getCurrentState()->getIndex(), ==, 0);
602  TEST_FLOATING_EQUALITY(sh->getCurrentState()->getTime(), 0.0, 1.0e-14);
603 
604  TEST_COMPARE(sh->getWorkingState()->getIndex(), ==, 1);
605  TEST_FLOATING_EQUALITY(sh->getWorkingState()->getTime(), 1.0, 1.0e-14);
606 
607  // ---------------------------------------------------------------------------
608 }
609 
610 // ************************************************************
611 // ************************************************************
612 TEUCHOS_UNIT_TEST(SolutionHistory, promoteWorkingState_Passing)
613 {
614  // Setup SolutionHistory for testing.
615  auto sh = rcp(new Tempus::SolutionHistory<double>());
616  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
617  // as no State is set.
618 
619  auto model = rcp(new Tempus_Test::DahlquistTestModel<double>(-1.0, false));
620  auto inArgsIC = model->getNominalValues();
621  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
622  auto state0 = Tempus::createSolutionStateX<double>(icSoln);
623  state0->setTime(0.0);
624  state0->setTimeStep(1.0);
625  state0->setIndex(0);
626  sh->addState(state0);
627  sh->initialize();
628  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
629  sh->initWorkingState();
630  sh->getWorkingState()->setSolutionStatus(Tempus::Status::PASSED);
631 
632  // State before promoting workingState.
633  // with workingState PASSing.
634  TEST_COMPARE(sh->getNumStates(), ==, 2);
635  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
636  TEUCHOS_ASSERT(sh->getCurrentState() == sh->getStateTimeIndexNM1());
637  TEUCHOS_ASSERT(sh->getWorkingState() != Teuchos::null);
638  TEUCHOS_ASSERT(sh->getWorkingState() == sh->getStateTimeIndexN());
639 
640  TEST_COMPARE(sh->getCurrentState()->getIndex(), ==, 0);
641  TEST_FLOATING_EQUALITY(sh->getCurrentState()->getTime(), 0.0, 1.0e-14);
642 
643  TEST_COMPARE(sh->getWorkingState()->getIndex(), ==, 1);
644  TEST_FLOATING_EQUALITY(sh->getWorkingState()->getTime(), 1.0, 1.0e-14);
645 
646  sh->promoteWorkingState();
647 
648  // State after promoting workingState.
649  TEST_COMPARE(sh->getNumStates(), ==, 2);
650  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
651  TEUCHOS_ASSERT(sh->getCurrentState() == sh->getStateTimeIndexN());
652  TEUCHOS_ASSERT(sh->getWorkingState() == Teuchos::null);
653 
654  // Current state is now at t=1.0!
655  TEST_COMPARE(sh->getCurrentState()->getIndex(), ==, 1);
656  TEST_FLOATING_EQUALITY(sh->getCurrentState()->getTime(), 1.0, 1.0e-14);
657 
658  // ---------------------------------------------------------------------------
659 }
660 
661 // ************************************************************
662 // ************************************************************
663 TEUCHOS_UNIT_TEST(SolutionHistory, promoteWorkingState_Failing)
664 {
665  // Setup SolutionHistory for testing.
666  auto sh = rcp(new Tempus::SolutionHistory<double>());
667  TEUCHOS_TEST_FOR_EXCEPT(sh->isInitialized()); // Should NOT be initialized
668  // as no State is set.
669 
670  auto model = rcp(new Tempus_Test::DahlquistTestModel<double>(-1.0, false));
671  auto inArgsIC = model->getNominalValues();
672  auto icSoln = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
673  auto state0 = Tempus::createSolutionStateX<double>(icSoln);
674  state0->setTime(0.0);
675  state0->setTimeStep(1.0);
676  state0->setIndex(0);
677  sh->addState(state0);
678  sh->initialize();
679  TEUCHOS_TEST_FOR_EXCEPT(!sh->isInitialized());
680  sh->initWorkingState();
681  sh->getWorkingState()->setSolutionStatus(Tempus::Status::FAILED);
682 
683  // State before promoting workingState.
684  // with workingState FAILing.
685  TEST_COMPARE(sh->getNumStates(), ==, 2);
686  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
687  TEUCHOS_ASSERT(sh->getCurrentState() == sh->getStateTimeIndexNM1());
688  TEUCHOS_ASSERT(sh->getWorkingState() != Teuchos::null);
689  TEUCHOS_ASSERT(sh->getWorkingState() == sh->getStateTimeIndexN());
690 
691  TEST_COMPARE(sh->getCurrentState()->getIndex(), ==, 0);
692  TEST_FLOATING_EQUALITY(sh->getCurrentState()->getTime(), 0.0, 1.0e-14);
693 
694  TEST_COMPARE(sh->getWorkingState()->getIndex(), ==, 1);
695  TEST_FLOATING_EQUALITY(sh->getWorkingState()->getTime(), 1.0, 1.0e-14);
696 
697  sh->promoteWorkingState();
698 
699  // State after promoting workingState.
700  // Should be unchanged as we are trying to redo FAILing time step.
701  TEST_COMPARE(sh->getNumStates(), ==, 2);
702  TEUCHOS_ASSERT(sh->getCurrentState() != Teuchos::null);
703  TEUCHOS_ASSERT(sh->getCurrentState() == sh->getStateTimeIndexNM1());
704  TEUCHOS_ASSERT(sh->getWorkingState() != Teuchos::null);
705  TEUCHOS_ASSERT(sh->getWorkingState() == sh->getStateTimeIndexN());
706 
707  // Current state is still at t=0.0!
708  TEST_COMPARE(sh->getCurrentState()->getIndex(), ==, 0);
709  TEST_FLOATING_EQUALITY(sh->getCurrentState()->getTime(), 0.0, 1.0e-14);
710 
711  // Working state is still at t=1.0!
712  TEST_COMPARE(sh->getWorkingState()->getIndex(), ==, 1);
713  TEST_FLOATING_EQUALITY(sh->getWorkingState()->getTime(), 1.0, 1.0e-14);
714 
715  // ---------------------------------------------------------------------------
716 }
717 
718 } // namespace Tempus_Unit_Test
Tempus_InterpolatorFactory.hpp
Tempus::STORAGE_TYPE_UNDO
Keep the 2 newest states for undo.
Definition: Tempus_SolutionHistory_decl.hpp:22
Tempus_Test::DahlquistTestModel
The classic Dahlquist Test Problem.
Definition: DahlquistTestModel_decl.hpp:35
Teuchos::ParameterList::set
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
TEST_COMPARE
#define TEST_COMPARE(v1, comp, v2)
TEST_FLOATING_EQUALITY
#define TEST_FLOATING_EQUALITY(v1, v2, tol)
Tempus_Test::SinCosModel
Sine-Cosine model problem from Rythmos. This is a canonical Sine-Cosine differential equation with a...
Definition: SinCosModel_decl.hpp:109
Teuchos::VERB_MEDIUM
Tempus::InterpolatorFactory::createInterpolator
static Teuchos::RCP< Interpolator< Scalar > > createInterpolator(std::string interpolatorType="")
Create default interpolator from interpolator type (e.g., &quot;Linear&quot;).
Definition: Tempus_InterpolatorFactory.hpp:28
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Tempus_UnitTest_Utils.hpp
Tempus_Unit_Test::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)
Definition: Tempus_UnitTest_BackwardEuler.cpp:33
Tempus::SolutionHistory
SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of...
Definition: Tempus_Integrator.hpp:28
Tempus::STORAGE_TYPE_STATIC
Keep a fix number of states.
Definition: Tempus_SolutionHistory_decl.hpp:23
Teuchos::ParameterList::sublist
ParameterList & sublist(const std::string &name, bool mustAlreadyExist=false, const std::string &docString="")
Teuchos::ParameterList::setName
ParameterList & setName(const std::string &name)
TEUCHOS_ASSERT
#define TEUCHOS_ASSERT(assertion_test)
TEUCHOS_TEST_FOR_EXCEPT
#define TEUCHOS_TEST_FOR_EXCEPT(throw_exception_test)
Tempus::SolutionState
Solution state for integrators and steppers.
Definition: Tempus_SolutionState_decl.hpp:137
Generated on Fri Jul 26 2024 09:25:00 for Tempus by   doxygen 1.8.5