Tempus Version of the Day
Time Integration
Loading...
Searching...
No Matches
Tempus_UnitTest_HHTAlpha.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_StepperHHTAlpha.hpp"
13#include "Tempus_StepperHHTAlphaModifierBase.hpp"
14#include "Tempus_StepperHHTAlphaModifierXBase.hpp"
15#include "Tempus_StepperHHTAlphaObserverBase.hpp"
16#include "Tempus_StepperHHTAlphaModifierDefault.hpp"
17#include "Tempus_StepperHHTAlphaModifierXDefault.hpp"
18#include "Tempus_StepperHHTAlphaObserverDefault.hpp"
19
20#include "../TestModels/HarmonicOscillatorModel.hpp"
21
22namespace Tempus_Unit_Test {
23
24using Teuchos::ParameterList;
25using Teuchos::RCP;
26using Teuchos::rcp;
27using Teuchos::rcp_const_cast;
28using Teuchos::rcp_dynamic_cast;
29using Teuchos::sublist;
30
31// ************************************************************
32// ************************************************************
33TEUCHOS_UNIT_TEST(HHTAlpha, Default_Construction)
34{
35 auto model = rcp(new Tempus_Test::HarmonicOscillatorModel<double>());
36
37 // Default construction.
38 auto stepper = rcp(new Tempus::StepperHHTAlpha<double>());
39 stepper->setModel(model);
40 stepper->initialize();
41 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
42
43 // Default values for construction.
44 auto solver = rcp(new Thyra::NOXNonlinearSolver());
45 solver->setParameterList(Tempus::defaultSolverParameters());
46
47 bool useFSAL = stepper->getUseFSAL();
48 std::string ICConsistency = stepper->getICConsistency();
49 bool ICConsistencyCheck = stepper->getICConsistencyCheck();
50 bool zeroInitialGuess = stepper->getZeroInitialGuess();
51 std::string schemeName = "Newmark Beta User Defined";
52 double beta = 0.25;
53 double gamma = 0.5;
54 double alpha_f = 0.0;
55 double alpha_m = 0.0;
56
57 auto modifier = rcp(new Tempus::StepperHHTAlphaModifierDefault<double>());
58 auto modifierX = rcp(new Tempus::StepperHHTAlphaModifierXDefault<double>());
59 auto observer = rcp(new Tempus::StepperHHTAlphaObserverDefault<double>());
60
61 // Test the set functions.
62 stepper->setSolver(solver);
63 stepper->initialize();
64 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
65 stepper->setUseFSAL(useFSAL);
66 stepper->initialize();
67 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
68 stepper->setICConsistency(ICConsistency);
69 stepper->initialize();
70 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
71 stepper->setICConsistencyCheck(ICConsistencyCheck);
72 stepper->initialize();
73 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
74 stepper->setZeroInitialGuess(zeroInitialGuess);
75 stepper->initialize();
76 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
77
78 stepper->setAppAction(modifier);
79 stepper->initialize();
80 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
81 stepper->setAppAction(modifierX);
82 stepper->initialize();
83 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
84 stepper->setAppAction(observer);
85 stepper->initialize();
86 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
87
88 stepper->setSchemeName(schemeName);
89 stepper->initialize();
90 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
91 stepper->setBeta(beta);
92 stepper->initialize();
93 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
94 stepper->setGamma(gamma);
95 stepper->initialize();
96 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
97 stepper->setAlphaF(alpha_f);
98 stepper->initialize();
99 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
100 stepper->setAlphaM(alpha_m);
101 stepper->initialize();
102 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
103
104 // Full argument list construction.
105 stepper = rcp(new Tempus::StepperHHTAlpha<double>(
106 model, solver, useFSAL, ICConsistency, ICConsistencyCheck,
107 zeroInitialGuess, schemeName, beta, gamma, alpha_f, alpha_m, modifier));
108 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
109
110 // Test stepper properties.
111 TEUCHOS_ASSERT(stepper->getOrder() == 2);
112}
113
114// ************************************************************
115// ************************************************************
116TEUCHOS_UNIT_TEST(HHTAlpha, StepperFactory_Construction)
117{
118 auto model = rcp(new Tempus_Test::HarmonicOscillatorModel<double>());
119 testFactoryConstruction("HHT-Alpha", model);
120}
121
122// ************************************************************
123// ************************************************************
124TEUCHOS_UNIT_TEST(HHTAlpha, StepperGetter_UserDefinedSchemeParameters)
125{
126 auto model = rcp(new Tempus_Test::HarmonicOscillatorModel<double>());
127
128 // Default construction.
129 auto stepper = rcp(new Tempus::StepperHHTAlpha<double>());
130 stepper->setModel(model);
131 stepper->initialize();
132 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
133
134 stepper->setSchemeName("Newmark Beta User Defined");
135 stepper->setBeta(0.3025);
136 stepper->setGamma(0.6);
137 stepper->setAlphaF(0.1);
138 stepper->setAlphaM(0.0);
139 stepper->initialize();
140 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
141
142 TEST_COMPARE(stepper->getSchemeName(), ==, "Newmark Beta User Defined");
143 TEST_FLOATING_EQUALITY(stepper->getBeta(), 0.3025, 1.0e-14);
144 TEST_FLOATING_EQUALITY(stepper->getGamma(), 0.6, 1.0e-14);
145 TEST_FLOATING_EQUALITY(stepper->getAlphaF(), 0.1, 1.0e-14);
146 TEST_FLOATING_EQUALITY(stepper->getAlphaM(), 0.0, 1.0e-14);
147}
148
149// ************************************************************
150// ************************************************************
151TEUCHOS_UNIT_TEST(HHTAlpha, StepperGetter_DefaultSchemeIgnoresUserBetaGamma)
152{
153 auto model = rcp(new Tempus_Test::HarmonicOscillatorModel<double>());
154
155 // Default construction.
156 auto stepper = rcp(new Tempus::StepperHHTAlpha<double>());
157 stepper->setModel(model);
158 stepper->initialize();
159 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
160
161 stepper->setSchemeName("Newmark Beta Average Acceleration");
162 stepper->setBeta(0.3025); // should be ignored
163 stepper->setGamma(0.6); // should be ignored
164 stepper->setAlphaF(0.1);
165 stepper->setAlphaM(0.0);
166 stepper->initialize();
167 TEUCHOS_TEST_FOR_EXCEPT(!stepper->isInitialized());
168
169 TEST_COMPARE(stepper->getSchemeName(), ==, "Newmark Beta Average Acceleration");
170 TEST_FLOATING_EQUALITY(stepper->getBeta(), 0.25, 1.0e-14);
171 TEST_FLOATING_EQUALITY(stepper->getGamma(), 0.5, 1.0e-14);
172 TEST_FLOATING_EQUALITY(stepper->getAlphaF(), 0.1, 1.0e-14);
173 TEST_FLOATING_EQUALITY(stepper->getAlphaM(), 0.0, 1.0e-14);
174}
175
176// ************************************************************
177// ************************************************************
178TEUCHOS_UNIT_TEST(HHTAlpha, ValidateSchemeParameters_NoWarningWhenConsistent)
179{
180 auto model = rcp(new Tempus_Test::HarmonicOscillatorModel<double>());
181
182 std::ostringstream oss;
183 auto captured = Teuchos::fancyOStream(Teuchos::rcpFromRef(oss));
184 auto oldOut = Teuchos::VerboseObjectBase::getDefaultOStream();
185 Teuchos::VerboseObjectBase::setDefaultOStream(captured);
186
187 auto stepper = rcp(new Tempus::StepperHHTAlpha<double>());
188 stepper->setModel(model);
189 stepper->setSchemeName("Newmark Beta User Defined");
190 stepper->setAlphaF(0.1);
191 stepper->setAlphaM(0.0);
192 stepper->setGamma(0.6);
193 stepper->setBeta(0.3025);
194 stepper->validateSchemeParameters();
195
196 Teuchos::VerboseObjectBase::setDefaultOStream(oldOut);
197
198 const std::string output = oss.str();
199 TEST_ASSERT(output.find("WARNING: For HHT-Alpha") == std::string::npos);
200}
201
202// ************************************************************
203// ************************************************************
204TEUCHOS_UNIT_TEST(HHTAlpha, ValidateSchemeParameters_WarnsWhenInconsistent)
205{
206 auto model = rcp(new Tempus_Test::HarmonicOscillatorModel<double>());
207
208 std::ostringstream oss;
209 auto captured = Teuchos::fancyOStream(Teuchos::rcpFromRef(oss));
210 auto oldOut = Teuchos::VerboseObjectBase::getDefaultOStream();
211 Teuchos::VerboseObjectBase::setDefaultOStream(captured);
212
213 auto stepper = rcp(new Tempus::StepperHHTAlpha<double>());
214 stepper->setModel(model);
215 stepper->setSchemeName("Newmark Beta User Defined");
216 stepper->setAlphaF(0.1);
217 stepper->setAlphaM(0.0);
218 stepper->setGamma(0.5);
219 stepper->setBeta(0.25);
220 stepper->validateSchemeParameters();
221
222 Teuchos::VerboseObjectBase::setDefaultOStream(oldOut);
223
224 const std::string output = oss.str();
225 TEST_ASSERT(output.find("WARNING: For HHT-Alpha") != std::string::npos);
226 TEST_ASSERT(output.find("gamma_ (0.5)") != std::string::npos);
227 TEST_ASSERT(output.find("beta_ (0.25)") != std::string::npos);
228 TEST_ASSERT(output.find("0.5+alpha_f_ (0.6)") != std::string::npos);
229 TEST_ASSERT(output.find("0.25*(1.0+alpha_f_)^2 (0.3025)") !=
230 std::string::npos);
231}
232
233// ************************************************************
234// ************************************************************
235class StepperHHTAlphaModifierTest
236 : virtual public Tempus::StepperHHTAlphaModifierBase<double> {
237 public:
239 StepperHHTAlphaModifierTest()
240 : testBEGIN_STEP(false),
241 testBEFORE_SOLVE(false),
242 testAFTER_SOLVE(false),
243 testEND_STEP(false),
244 testCurrentValue(-0.99),
245 testWorkingValue(-0.99),
246 testDt(-1.5),
247 testName("")
248 {
249 }
250
252 virtual ~StepperHHTAlphaModifierTest() {}
253
255 virtual void modify(
256 Teuchos::RCP<Tempus::SolutionHistory<double> > sh,
257 Teuchos::RCP<Tempus::StepperHHTAlpha<double> > stepper,
258 const typename Tempus::StepperHHTAlphaAppAction<double>::ACTION_LOCATION
259 actLoc)
260 {
261 switch (actLoc) {
262 case StepperHHTAlphaAppAction<double>::BEGIN_STEP: {
263 testBEGIN_STEP = true;
264 auto x = sh->getCurrentState()->getX();
265 testCurrentValue = get_ele(*(x), 0);
266 break;
267 }
268 case StepperHHTAlphaAppAction<double>::BEFORE_SOLVE: {
269 testBEFORE_SOLVE = true;
270 testDt = sh->getWorkingState()->getTimeStep() / 10.0;
271 sh->getWorkingState()->setTimeStep(testDt);
272 break;
273 }
274 case StepperHHTAlphaAppAction<double>::AFTER_SOLVE: {
275 testAFTER_SOLVE = true;
276 testName = "HHT Alpha - Modifier";
277 stepper->setStepperName(testName);
278 break;
279 }
280 case StepperHHTAlphaAppAction<double>::END_STEP: {
281 testEND_STEP = true;
282 auto x = sh->getWorkingState()->getX();
283 testWorkingValue = get_ele(*(x), 0);
284 break;
285 }
286 default:
287 TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
288 "Error - unknown action location.\n");
289 }
290 }
291 bool testBEGIN_STEP;
292 bool testBEFORE_SOLVE;
293 bool testAFTER_SOLVE;
294 bool testEND_STEP;
295 double testCurrentValue;
296 double testWorkingValue;
297 double testDt;
298 std::string testName;
299};
300
301TEUCHOS_UNIT_TEST(HHTAlpha, AppAction_Modifier)
302{
303 Teuchos::RCP<const Thyra::ModelEvaluator<double> > model =
304 rcp(new Tempus_Test::HarmonicOscillatorModel<double>());
305
306 // Setup Stepper for field solve ----------------------------
307 auto stepper = rcp(new Tempus::StepperHHTAlpha<double>());
308 stepper->setModel(model);
309 auto modifier = rcp(new StepperHHTAlphaModifierTest());
310 stepper->setAppAction(modifier);
311 stepper->initialize();
312
313 // Create a SolutionHistory.
314 auto solutionHistory = Tempus::createSolutionHistoryME(model);
315
316 // Take one time step.
317 stepper->setInitialConditions(solutionHistory);
318 solutionHistory->initWorkingState();
319 double dt = 0.1;
320 solutionHistory->getWorkingState()->setTimeStep(dt);
321 stepper->takeStep(solutionHistory);
322
323 // Testing that each ACTION_LOCATION has been called.
324 TEST_COMPARE(modifier->testBEGIN_STEP, ==, true);
325 TEST_COMPARE(modifier->testBEFORE_SOLVE, ==, true);
326 TEST_COMPARE(modifier->testAFTER_SOLVE, ==, true);
327 TEST_COMPARE(modifier->testEND_STEP, ==, true);
328
329 // Testing that values can be set through the Modifier.
330 auto x = solutionHistory->getCurrentState()->getX();
331 TEST_FLOATING_EQUALITY(modifier->testCurrentValue, get_ele(*(x), 0), 1.0e-14);
332 x = solutionHistory->getWorkingState()->getX();
333 TEST_FLOATING_EQUALITY(modifier->testWorkingValue, get_ele(*(x), 0), 1.0e-14);
334 auto Dt = solutionHistory->getWorkingState()->getTimeStep();
335 TEST_FLOATING_EQUALITY(modifier->testDt, Dt, 1.0e-14);
336 TEST_COMPARE(modifier->testName, ==, "HHT Alpha - Modifier");
337}
338
339// ************************************************************
340// ************************************************************
341class StepperHHTAlphaObserverTest
342 : virtual public Tempus::StepperHHTAlphaObserverBase<double> {
343 public:
345 StepperHHTAlphaObserverTest()
346 : testBEGIN_STEP(false),
347 testBEFORE_SOLVE(false),
348 testAFTER_SOLVE(false),
349 testEND_STEP(false),
350 testCurrentValue(-0.99),
351 testWorkingValue(-0.99),
352 testDt(-1.5),
353 testName("")
354 {
355 }
356
358 virtual ~StepperHHTAlphaObserverTest() {}
359
361 virtual void observe(
362 Teuchos::RCP<const Tempus::SolutionHistory<double> > sh,
363 Teuchos::RCP<const Tempus::StepperHHTAlpha<double> > stepper,
364 const typename Tempus::StepperHHTAlphaAppAction<double>::ACTION_LOCATION
365 actLoc)
366 {
367 switch (actLoc) {
368 case StepperHHTAlphaAppAction<double>::BEGIN_STEP: {
369 testBEGIN_STEP = true;
370 auto x = sh->getCurrentState()->getX();
371 testCurrentValue = get_ele(*(x), 0);
372 break;
373 }
374 case StepperHHTAlphaAppAction<double>::BEFORE_SOLVE: {
375 testBEFORE_SOLVE = true;
376 testDt = sh->getWorkingState()->getTimeStep();
377 break;
378 }
379 case StepperHHTAlphaAppAction<double>::AFTER_SOLVE: {
380 testAFTER_SOLVE = true;
381 testName = stepper->getStepperType();
382 break;
383 }
384 case StepperHHTAlphaAppAction<double>::END_STEP: {
385 testEND_STEP = true;
386 auto x = sh->getWorkingState()->getX();
387 testWorkingValue = get_ele(*(x), 0);
388 break;
389 }
390 default:
391 TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
392 "Error - unknown action location.\n");
393 }
394 }
395
396 bool testBEGIN_STEP;
397 bool testBEFORE_SOLVE;
398 bool testAFTER_SOLVE;
399 bool testEND_STEP;
400 double testCurrentValue;
401 double testWorkingValue;
402 double testDt;
403 std::string testName;
404};
405
406TEUCHOS_UNIT_TEST(HHTAlpha, AppAction_Observer)
407{
408 Teuchos::RCP<const Thyra::ModelEvaluator<double> > model =
409 rcp(new Tempus_Test::HarmonicOscillatorModel<double>());
410
411 // Setup Stepper for field solve ----------------------------
412 auto stepper = rcp(new Tempus::StepperHHTAlpha<double>());
413 stepper->setModel(model);
414 auto observer = rcp(new StepperHHTAlphaObserverTest());
415 stepper->setAppAction(observer);
416 stepper->initialize();
417
418 // Setup a SolutionHistory.
419 auto solutionHistory = Tempus::createSolutionHistoryME(model);
420
421 // Take one time step.
422 stepper->setInitialConditions(solutionHistory);
423 solutionHistory->initWorkingState();
424 double dt = 0.1;
425 solutionHistory->getWorkingState()->setTimeStep(dt);
426 stepper->takeStep(solutionHistory);
427
428 // Testing that each ACTION_LOCATION has been called.
429 TEST_COMPARE(observer->testBEGIN_STEP, ==, true);
430 TEST_COMPARE(observer->testBEFORE_SOLVE, ==, true);
431 TEST_COMPARE(observer->testAFTER_SOLVE, ==, true);
432 TEST_COMPARE(observer->testEND_STEP, ==, true);
433 // Testing that values can be observed through the observer.
434 auto x = solutionHistory->getCurrentState()->getX();
435 TEST_FLOATING_EQUALITY(observer->testCurrentValue, get_ele(*(x), 0), 1.0e-14);
436 x = solutionHistory->getWorkingState()->getX();
437 TEST_FLOATING_EQUALITY(observer->testWorkingValue, get_ele(*(x), 0), 1.0e-14);
438 TEST_FLOATING_EQUALITY(observer->testDt, dt, 1.0e-14);
439
440 TEST_COMPARE(observer->testName, ==, "HHT-Alpha");
441}
442
443// ************************************************************
444// ************************************************************
445class StepperHHTAlphaModifierXTest
446 : virtual public Tempus::StepperHHTAlphaModifierXBase<double> {
447 public:
449 StepperHHTAlphaModifierXTest()
450 : testX_BEGIN_STEP(false),
451 testX_BEFORE_SOLVE(false),
452 testX_AFTER_SOLVE(false),
453 testX_END_STEP(false),
454 testXbegin(-0.99),
455 testXend(-0.99),
456 testDt(-1.5),
457 testTime(-1.5)
458 {
459 }
460
462 virtual ~StepperHHTAlphaModifierXTest() {}
463
465 virtual void modify(
466 Teuchos::RCP<Thyra::VectorBase<double> > x, const double time,
467 const double dt,
468 const typename Tempus::StepperHHTAlphaModifierXBase<double>::MODIFIER_TYPE
469 modType)
470 {
471 switch (modType) {
472 case StepperHHTAlphaModifierXBase<double>::X_BEGIN_STEP: {
473 testX_BEGIN_STEP = true;
474 testXbegin = get_ele(*(x), 0);
475 break;
476 }
477 case StepperHHTAlphaModifierXBase<double>::X_BEFORE_SOLVE: {
478 testX_BEFORE_SOLVE = true;
479 testDt = dt;
480 break;
481 }
482 case StepperHHTAlphaModifierXBase<double>::X_AFTER_SOLVE: {
483 testX_AFTER_SOLVE = true;
484 testTime = time;
485 break;
486 }
487 case StepperHHTAlphaModifierXBase<double>::X_END_STEP: {
488 testX_END_STEP = true;
489 testXend = get_ele(*(x), 0);
490 break;
491 }
492 default:
493 TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
494 "Error - unknown action location.\n");
495 }
496 }
497
498 bool testX_BEGIN_STEP;
499 bool testX_BEFORE_SOLVE;
500 bool testX_AFTER_SOLVE;
501 bool testX_END_STEP;
502 double testXbegin;
503 double testXend;
504 double testDt;
505 double testTime;
506};
507
508TEUCHOS_UNIT_TEST(HHTAlpha, AppAction_ModifierX)
509{
510 Teuchos::RCP<const Thyra::ModelEvaluator<double> > model =
511 rcp(new Tempus_Test::HarmonicOscillatorModel<double>());
512
513 // Setup Stepper for field solve ----------------------------
514 auto stepper = rcp(new Tempus::StepperHHTAlpha<double>());
515 stepper->setModel(model);
516 auto modifierX = rcp(new StepperHHTAlphaModifierXTest());
517 stepper->setAppAction(modifierX);
518 stepper->initialize();
519
520 // Setup a SolutionHistory.
521 auto solutionHistory = Tempus::createSolutionHistoryME(model);
522 // Take one time step.
523 stepper->setInitialConditions(solutionHistory);
524 solutionHistory->initWorkingState();
525 double dt = 0.1;
526 solutionHistory->getWorkingState()->setTimeStep(dt);
527 stepper->takeStep(solutionHistory);
528
529 // Testing that each ACTION_LOCATION has been called.
530 TEST_COMPARE(modifierX->testX_BEGIN_STEP, ==, true);
531 TEST_COMPARE(modifierX->testX_BEFORE_SOLVE, ==, true);
532 TEST_COMPARE(modifierX->testX_AFTER_SOLVE, ==, true);
533 TEST_COMPARE(modifierX->testX_END_STEP, ==, true);
534
535 // Testing that values can be set through the Modifier.
536 auto xbegin = solutionHistory->getCurrentState()->getX();
537 TEST_FLOATING_EQUALITY(modifierX->testXbegin, get_ele(*(xbegin), 0), 1.0e-14);
538 auto xend = solutionHistory->getWorkingState()->getX();
539 TEST_FLOATING_EQUALITY(modifierX->testXend, get_ele(*(xend), 0), 1.0e-14);
540 auto Dt = solutionHistory->getWorkingState()->getTimeStep();
541 TEST_FLOATING_EQUALITY(modifierX->testDt, Dt, 1.0e-14);
542 auto time = solutionHistory->getWorkingState()->getTime();
543 TEST_FLOATING_EQUALITY(modifierX->testTime, time, 1.0e-14);
544}
545
546} // namespace Tempus_Unit_Test
Tempus_StepperHHTAlphaModifierBase.hpp
Tempus_StepperHHTAlphaModifierDefault.hpp
Tempus_StepperHHTAlphaModifierXBase.hpp
Tempus_StepperHHTAlphaModifierXDefault.hpp
Tempus_StepperHHTAlphaObserverBase.hpp
Tempus_StepperHHTAlphaObserverDefault.hpp
Tempus_UnitTest_Utils.hpp
Tempus::StepperHHTAlphaAppAction::ACTION_LOCATION
ACTION_LOCATION
Indicates the location of application action (see algorithm).
Definition Tempus_StepperHHTAlphaAppAction.hpp:34
Tempus::StepperHHTAlphaModifierXBase::MODIFIER_TYPE
MODIFIER_TYPE
Indicates the location of application action (see algorithm).
Definition Tempus_StepperHHTAlphaModifierXBase.hpp:95
Tempus_Test::HarmonicOscillatorModel
Consider the ODE:
Definition HarmonicOscillatorModel_decl.hpp:54
Tempus_Unit_Test
Definition Tempus_UnitTest_BackwardEuler.cpp:22
Tempus_Unit_Test::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)
Definition Tempus_UnitTest_BackwardEuler.cpp:33
Tempus_Unit_Test::testFactoryConstruction
void testFactoryConstruction(std::string stepperType, const Teuchos::RCP< const Thyra::ModelEvaluator< double > > &model)
Unit test utility for Stepper construction through StepperFactory.
Definition Tempus_UnitTest_Utils.hpp:42
Tempus::createSolutionHistoryME
Teuchos::RCP< SolutionHistory< Scalar > > createSolutionHistoryME(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &model)
Nonmember contructor from a Thyra ModelEvaluator.
Definition Tempus_SolutionHistory_impl.hpp:754
Tempus::defaultSolverParameters
Teuchos::RCP< Teuchos::ParameterList > defaultSolverParameters()
Returns the default solver ParameterList for implicit Steppers.
Definition Tempus_Stepper_impl.hpp:413
Generated by doxygen 1.15.0