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