11 #include "Tempus_StepperForwardEuler.hpp"
12 #include "Tempus_StepperBackwardEuler.hpp"
21 namespace Tempus_Unit_Test {
26 using Teuchos::rcp_const_cast;
27 using Teuchos::rcp_dynamic_cast;
28 using Teuchos::sublist;
38 stepper->setModel(model);
39 stepper->initialize();
53 predictorStepper->setModel(
55 predictorStepper->initialize();
58 bool useFSAL = defaultStepper->getUseFSAL();
59 std::string ICConsistency = defaultStepper->getICConsistency();
60 bool ICConsistencyCheck = defaultStepper->getICConsistencyCheck();
61 bool zeroInitialGuess = defaultStepper->getZeroInitialGuess();
64 stepper->setAppAction(modifier);
65 stepper->initialize();
67 stepper->setAppAction(modifierX);
68 stepper->initialize();
70 stepper->setAppAction(observer);
71 stepper->initialize();
73 stepper->setSolver(solver);
74 stepper->initialize();
76 stepper->setPredictor(predictorStepper);
77 stepper->initialize();
79 stepper->setUseFSAL(useFSAL);
80 stepper->initialize();
82 stepper->setICConsistency(ICConsistency);
83 stepper->initialize();
85 stepper->setICConsistencyCheck(ICConsistencyCheck);
86 stepper->initialize();
88 stepper->setZeroInitialGuess(zeroInitialGuess);
89 stepper->initialize();
94 model, solver, predictorStepper, useFSAL, ICConsistency,
95 ICConsistencyCheck, zeroInitialGuess, modifier));
112 class StepperBackwardEulerModifierTest
116 StepperBackwardEulerModifierTest()
117 : testBEGIN_STEP(false),
118 testBEFORE_SOLVE(false),
119 testAFTER_SOLVE(false),
121 testCurrentValue(-0.99),
122 testWorkingValue(-0.99),
129 virtual ~StepperBackwardEulerModifierTest() {}
136 double>::ACTION_LOCATION actLoc)
140 testBEGIN_STEP =
true;
141 auto x = sh->getCurrentState()->getX();
142 testCurrentValue = get_ele(*(x), 0);
146 testBEFORE_SOLVE =
true;
147 testDt = sh->getWorkingState()->getTimeStep() / 10.0;
148 sh->getWorkingState()->setTimeStep(testDt);
152 testAFTER_SOLVE =
true;
153 testName =
"Backward Euler - Modifier";
154 stepper->setStepperName(testName);
159 auto x = sh->getWorkingState()->getX();
160 testWorkingValue = get_ele(*(x), 0);
165 "Error - unknown action location.\n");
170 bool testBEFORE_SOLVE;
171 bool testAFTER_SOLVE;
173 double testCurrentValue;
174 double testWorkingValue;
176 std::string testName;
186 stepper->setModel(model);
187 auto modifier =
rcp(
new StepperBackwardEulerModifierTest());
188 stepper->setAppAction(modifier);
189 stepper->initialize();
195 stepper->setInitialConditions(solutionHistory);
196 solutionHistory->initWorkingState();
198 solutionHistory->getWorkingState()->setTimeStep(dt);
199 stepper->takeStep(solutionHistory);
208 auto x = solutionHistory->getCurrentState()->getX();
210 x = solutionHistory->getWorkingState()->getX();
212 auto Dt = solutionHistory->getWorkingState()->getTimeStep();
215 TEST_COMPARE(modifier->testName, ==,
"Backward Euler - Modifier");
220 class StepperBackwardEulerObserverTest
224 StepperBackwardEulerObserverTest()
225 : testBEGIN_STEP(false),
226 testBEFORE_SOLVE(false),
227 testAFTER_SOLVE(false),
229 testCurrentValue(-0.99),
230 testWorkingValue(-0.99),
237 virtual ~StepperBackwardEulerObserverTest() {}
240 virtual void observe(
244 double>::ACTION_LOCATION actLoc)
248 testBEGIN_STEP =
true;
249 auto x = sh->getCurrentState()->getX();
250 testCurrentValue = get_ele(*(x), 0);
254 testBEFORE_SOLVE =
true;
255 testDt = sh->getWorkingState()->getTimeStep();
259 testAFTER_SOLVE =
true;
260 testName = stepper->getStepperType();
265 auto x = sh->getWorkingState()->getX();
266 testWorkingValue = get_ele(*(x), 0);
271 "Error - unknown action location.\n");
276 bool testBEFORE_SOLVE;
277 bool testAFTER_SOLVE;
279 double testCurrentValue;
280 double testWorkingValue;
282 std::string testName;
292 stepper->setModel(model);
293 auto observer =
rcp(
new StepperBackwardEulerObserverTest());
294 stepper->setAppAction(observer);
295 stepper->initialize();
301 stepper->setInitialConditions(solutionHistory);
302 solutionHistory->initWorkingState();
304 solutionHistory->getWorkingState()->setTimeStep(dt);
305 stepper->takeStep(solutionHistory);
314 auto x = solutionHistory->getCurrentState()->getX();
316 x = solutionHistory->getWorkingState()->getX();
325 class StepperBackwardEulerModifierXTest
329 StepperBackwardEulerModifierXTest()
330 : testX_BEGIN_STEP(false),
331 testX_BEFORE_SOLVE(false),
332 testX_AFTER_SOLVE(false),
333 testXDOT_END_STEP(false),
342 virtual ~StepperBackwardEulerModifierXTest() {}
346 const double time,
const double dt,
348 double>::MODIFIER_TYPE modType)
352 testX_BEGIN_STEP =
true;
353 testX = get_ele(*(x), 0);
357 testX_BEFORE_SOLVE =
true;
362 testX_AFTER_SOLVE =
true;
367 testXDOT_END_STEP =
true;
368 testXDot = get_ele(*(x), 0);
373 "Error - unknown action location.\n");
377 bool testX_BEGIN_STEP;
378 bool testX_BEFORE_SOLVE;
379 bool testX_AFTER_SOLVE;
380 bool testXDOT_END_STEP;
394 stepper->setModel(model);
395 auto modifierX =
rcp(
new StepperBackwardEulerModifierXTest());
396 stepper->setAppAction(modifierX);
397 stepper->initialize();
403 stepper->setInitialConditions(solutionHistory);
404 solutionHistory->initWorkingState();
406 solutionHistory->getWorkingState()->setTimeStep(dt);
407 stepper->takeStep(solutionHistory);
416 auto x = solutionHistory->getCurrentState()->getX();
419 auto xDot = solutionHistory->getWorkingState()->getXDot();
420 if (xDot == Teuchos::null) xDot = stepper->getStepperXDot();
423 auto Dt = solutionHistory->getWorkingState()->getTimeStep();
426 auto time = solutionHistory->getWorkingState()->getTime();
436 Teuchos::getParametersFromXmlFile(
"Tempus_BackwardEuler_SinCos.xml");
447 Tempus::createIntegratorBasic<double>(tempusPL, model);
451 integrator->getStepper()->getValidParameters();
453 bool pass = haveSameValuesSorted(*stepperPL, *defaultPL,
true);
456 out <<
"stepperPL -------------- \n"
457 << *stepperPL << std::endl;
458 out <<
"defaultPL -------------- \n"
459 << *defaultPL << std::endl;
467 Tempus::createIntegratorBasic<double>(model,
468 std::string(
"Backward Euler"));
472 stepperPL->set(
"Predictor Stepper Type",
"None");
474 integrator->getStepper()->getValidParameters();
476 bool pass = haveSameValuesSorted(*stepperPL, *defaultPL,
true);
479 out <<
"stepperPL -------------- \n"
480 << *stepperPL << std::endl;
481 out <<
"defaultPL -------------- \n"
482 << *defaultPL << std::endl;
493 std::vector<std::string> options;
494 options.push_back(
"Default Parameters");
495 options.push_back(
"ICConsistency and Check");
497 for (
const auto& option : options) {
500 Teuchos::getParametersFromXmlFile(
"Tempus_BackwardEuler_SinCos.xml");
510 stepper->setModel(model);
511 if (option ==
"ICConsistency and Check") {
512 stepper->setICConsistency(
"Consistent");
513 stepper->setICConsistencyCheck(
true);
515 stepper->initialize();
521 timeStepControl->setInitIndex(tscPL.
get<
int>(
"Initial Time Index"));
522 timeStepControl->setInitTime(tscPL.
get<
double>(
"Initial Time"));
523 timeStepControl->setFinalTime(tscPL.
get<
double>(
"Final Time"));
524 timeStepControl->setInitTimeStep(dt);
525 timeStepControl->initialize();
528 auto inArgsIC = model->getNominalValues();
532 icState->setTime(timeStepControl->getInitTime());
533 icState->setIndex(timeStepControl->getInitIndex());
534 icState->setTimeStep(0.0);
535 icState->setOrder(stepper->getOrder());
540 solutionHistory->setName(
"Forward States");
542 solutionHistory->setStorageLimit(2);
543 solutionHistory->addState(icState);
546 stepper->setInitialConditions(solutionHistory);
550 Tempus::createIntegratorBasic<double>();
551 integrator->setStepper(stepper);
552 integrator->setTimeStepControl(timeStepControl);
553 integrator->setSolutionHistory(solutionHistory);
555 integrator->initialize();
558 bool integratorStatus = integrator->advanceTime();
562 double time = integrator->getTime();
563 double timeFinal = pl->
sublist(
"Default Integrator")
565 .
get<
double>(
"Final Time");
571 model->getExactSolution(time).get_x();
575 Thyra::V_StVpStV(xdiff.
ptr(), 1.0, *x_exact, -1.0, *(x));
578 out <<
" Stepper = " << stepper->description() <<
" with " << option
580 out <<
" =========================" << std::endl;
581 out <<
" Exact solution : " << get_ele(*(x_exact), 0) <<
" "
582 << get_ele(*(x_exact), 1) << std::endl;
583 out <<
" Computed solution: " << get_ele(*(x), 0) <<
" "
584 << get_ele(*(x), 1) << std::endl;
585 out <<
" Difference : " << get_ele(*(xdiff), 0) <<
" "
586 << get_ele(*(xdiff), 1) << std::endl;
587 out <<
" =========================" << std::endl;
588 TEST_FLOATING_EQUALITY(get_ele(*(x), 0), 0.798923, 1.0e-4);
589 TEST_FLOATING_EQUALITY(get_ele(*(x), 1), 0.516729, 1.0e-4);
Teuchos::RCP< SolutionState< Scalar > > createSolutionStateX(const Teuchos::RCP< Thyra::VectorBase< Scalar > > &x, const Teuchos::RCP< Thyra::VectorBase< Scalar > > &xdot=Teuchos::null, const Teuchos::RCP< Thyra::VectorBase< Scalar > > &xdotdot=Teuchos::null)
Nonmember constructor from non-const solution vectors, x.
void testFactoryConstruction(std::string stepperType, const Teuchos::RCP< const Thyra::ModelEvaluator< double > > &model)
Unit test utility for Stepper construction through StepperFactory.
Default observer for StepperBackwardEuler.
T & get(const std::string &name, T def_value)
Forward Euler time stepper.
Modify before the implicit solve.
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
#define TEST_COMPARE(v1, comp, v2)
After the implicit solve.
At the beginning of the step.
#define TEST_FLOATING_EQUALITY(v1, v2, tol)
Default modifier for StepperBackwardEuler.
Modify after the implicit solve.
Sine-Cosine model problem from Rythmos. This is a canonical Sine-Cosine differential equation with a...
Teuchos::RCP< Teuchos::ParameterList > defaultSolverParameters()
Returns the default solver ParameterList for implicit Steppers.
virtual void modify(Teuchos::RCP< Thyra::VectorBase< double > >, const double, const double, const MODIFIER_TYPE modType)=0
Modify solution based on the MODIFIER_TYPE.
Application Action for StepperBackwardEuler.
Base ModifierX for StepperBackwardEuler.
Teuchos::RCP< SolutionHistory< Scalar > > createSolutionHistoryME(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &model)
Nonmember contructor from a Thyra ModelEvaluator.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Modify at the beginning of the step.
Base observer for StepperBackwardEuler.
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)
TimeStepControl manages the time step size. There several mechanisms that effect the time step size a...
Backward Euler time stepper.
SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of...
Keep a fix number of states.
Modify at the end of the step.
Before the implicit solve.
Base modifier for StepperBackwardEuler.
ParameterList & sublist(const std::string &name, bool mustAlreadyExist=false, const std::string &docString="")
#define TEUCHOS_ASSERT(assertion_test)
Default ModifierX for StepperBackwardEuler.
#define TEUCHOS_TEST_FOR_EXCEPT(throw_exception_test)