13 #include "Tempus_TimeStepControl.hpp"
15 #include "Tempus_StepperNewmarkImplicitAForm.hpp"
21 #include "../TestModels/HarmonicOscillatorModel.hpp"
23 namespace Tempus_Unit_Test {
28 using Teuchos::rcp_const_cast;
29 using Teuchos::rcp_dynamic_cast;
30 using Teuchos::sublist;
42 stepper->setModel(model);
43 stepper->initialize();
55 bool useFSAL = stepper->getUseFSAL();
56 std::string ICConsistency = stepper->getICConsistency();
57 bool ICConsistencyCheck = stepper->getICConsistencyCheck();
58 bool zeroInitialGuess = stepper->getZeroInitialGuess();
59 std::string schemeName =
"Average Acceleration";
64 stepper->setAppAction(modifier);
65 stepper->initialize();
67 stepper->setAppAction(modifierX);
68 stepper->initialize();
70 stepper->setSolver(solver);
71 stepper->initialize();
73 stepper->setUseFSAL(useFSAL);
74 stepper->initialize();
76 stepper->setICConsistency(ICConsistency);
77 stepper->initialize();
79 stepper->setICConsistencyCheck(ICConsistencyCheck);
80 stepper->initialize();
82 stepper->setZeroInitialGuess(zeroInitialGuess);
83 stepper->initialize();
86 stepper->setSchemeName(schemeName);
87 stepper->initialize();
89 stepper->setBeta(beta);
90 stepper->initialize();
92 stepper->setGamma(gamma);
93 stepper->initialize();
98 model, solver, useFSAL, ICConsistency, ICConsistencyCheck,
99 zeroInitialGuess, schemeName, beta, gamma, modifier));
119 std::vector<std::string> options;
120 options.push_back(
"Default Parameters");
121 options.push_back(
"ICConsistency and Check");
123 for (
const auto& option : options) {
126 "Tempus_NewmarkImplicitAForm_HarmonicOscillator_Damped_SecondOrder."
139 if (option ==
"ICConsistency and Check") {
140 stepper->setICConsistency(
"Consistent");
141 stepper->setICConsistencyCheck(
true);
143 stepper->initialize();
150 timeStepControl->setInitIndex(tscPL.
get<
int>(
"Initial Time Index"));
151 timeStepControl->setInitTime(tscPL.
get<
double>(
"Initial Time"));
152 timeStepControl->setFinalTime(tscPL.
get<
double>(
"Final Time"));
153 timeStepControl->setInitTimeStep(dt);
154 timeStepControl->initialize();
157 using Teuchos::rcp_const_cast;
158 auto inArgsIC = model->getNominalValues();
167 icState->setTime(timeStepControl->getInitTime());
168 icState->setIndex(timeStepControl->getInitIndex());
169 icState->setTimeStep(0.0);
170 icState->setOrder(stepper->getOrder());
176 solutionHistory->setName(
"Forward States");
178 solutionHistory->setStorageLimit(2);
179 solutionHistory->addState(icState);
182 stepper->setInitialConditions(solutionHistory);
186 Tempus::createIntegratorBasic<double>();
187 integrator->setStepper(stepper);
188 integrator->setTimeStepControl(timeStepControl);
189 integrator->setSolutionHistory(solutionHistory);
191 integrator->initialize();
194 bool integratorStatus = integrator->advanceTime();
198 double time = integrator->getTime();
199 double timeFinal = pl->
sublist(
"Default Integrator")
201 .
get<
double>(
"Final Time");
207 model->getExactSolution(time).get_x();
211 Thyra::V_StVpStV(xdiff.
ptr(), 1.0, *x_exact, -1.0, *(x));
214 out <<
" Stepper = " << stepper->description() <<
"\n with "
215 << option << std::endl;
216 out <<
" =========================" << std::endl;
217 out <<
" Exact solution : " << get_ele(*(x_exact), 0) << std::endl;
218 out <<
" Computed solution: " << get_ele(*(x), 0) << std::endl;
219 out <<
" Difference : " << get_ele(*(xdiff), 0) << std::endl;
220 out <<
" =========================" << std::endl;
221 TEST_FLOATING_EQUALITY(get_ele(*(x), 0), -0.222222, 1.0e-4);
227 class StepperNewmarkImplicitAFormModifierTest
231 StepperNewmarkImplicitAFormModifierTest()
232 : testBEGIN_STEP(false),
233 testBEFORE_SOLVE(false),
234 testAFTER_SOLVE(false),
236 testCurrentValue(-0.99),
243 virtual ~StepperNewmarkImplicitAFormModifierTest() {}
250 double>::ACTION_LOCATION actLoc)
254 testBEGIN_STEP =
true;
258 testBEFORE_SOLVE =
true;
259 testDt = sh->getWorkingState()->getTimeStep();
264 testAFTER_SOLVE =
true;
265 testName =
"Newmark Implicit A Form - Modifier";
266 stepper->setStepperName(testName);
271 auto x = sh->getWorkingState()->getX();
272 testCurrentValue = get_ele(*(x), 0);
277 "Error - unknown action location.\n");
282 bool testBEFORE_SOLVE;
283 bool testAFTER_SOLVE;
285 double testCurrentValue;
287 std::string testName;
292 class StepperNewmarkImplicitAFormModifierXTest
296 StepperNewmarkImplicitAFormModifierXTest()
297 : testX_BEGIN_STEP(false),
298 testX_BEFORE_SOLVE(false),
299 testX_AFTER_SOLVE(false),
300 testX_END_STEP(false),
309 virtual ~StepperNewmarkImplicitAFormModifierXTest() {}
316 double>::MODIFIER_TYPE modType)
320 testX_BEGIN_STEP =
true;
321 testX = get_ele(*(x), 0);
325 testX_BEFORE_SOLVE =
true;
330 testX_AFTER_SOLVE =
true;
332 testX = get_ele(*(x), 0);
336 testX_END_STEP =
true;
337 testX = get_ele(*(x), 0);
342 "Error - unknown action location.\n");
346 bool testX_BEGIN_STEP;
347 bool testX_BEFORE_SOLVE;
348 bool testX_AFTER_SOLVE;
360 using Teuchos::sublist;
366 "Tempus_NewmarkImplicitAForm_HarmonicOscillator_Damped_SecondOrder.xml");
378 auto modifier =
rcp(
new StepperNewmarkImplicitAFormModifierTest());
379 stepper->setAppAction(modifier);
380 stepper->initialize();
387 timeStepControl->setInitIndex(tscPL.
get<
int>(
"Initial Time Index"));
388 timeStepControl->setInitTime(tscPL.
get<
double>(
"Initial Time"));
389 timeStepControl->setFinalTime(dt);
390 timeStepControl->setInitTimeStep(dt);
391 timeStepControl->initialize();
394 using Teuchos::rcp_const_cast;
395 auto inArgsIC = model->getNominalValues();
404 icState->setTime(timeStepControl->getInitTime());
405 icState->setIndex(timeStepControl->getInitIndex());
406 icState->setTimeStep(0.0);
407 icState->setOrder(stepper->getOrder());
413 solutionHistory->setName(
"Forward States");
415 solutionHistory->setStorageLimit(2);
416 solutionHistory->addState(icState);
420 Tempus::createIntegratorBasic<double>();
421 integrator->setStepper(stepper);
422 integrator->setTimeStepControl(timeStepControl);
423 integrator->setSolutionHistory(solutionHistory);
424 integrator->initialize();
427 bool integratorStatus = integrator->advanceTime();
437 auto x = integrator->getX();
438 auto Dt = integrator->getTime();
441 TEST_COMPARE(modifier->testName, ==, stepper->getStepperName());
448 using Teuchos::sublist;
454 "Tempus_NewmarkImplicitAForm_HarmonicOscillator_Damped_SecondOrder.xml");
466 auto modifierX =
rcp(
new StepperNewmarkImplicitAFormModifierXTest());
467 stepper->setAppAction(modifierX);
468 stepper->initialize();
475 timeStepControl->setInitIndex(tscPL.
get<
int>(
"Initial Time Index"));
476 timeStepControl->setInitTime(tscPL.
get<
double>(
"Initial Time"));
477 timeStepControl->setFinalTime(dt);
478 timeStepControl->setInitTimeStep(dt);
479 timeStepControl->initialize();
482 using Teuchos::rcp_const_cast;
483 auto inArgsIC = model->getNominalValues();
492 icState->setTime(timeStepControl->getInitTime());
493 icState->setIndex(timeStepControl->getInitIndex());
494 icState->setTimeStep(0.0);
495 icState->setOrder(stepper->getOrder());
501 solutionHistory->setName(
"Forward States");
503 solutionHistory->setStorageLimit(2);
504 solutionHistory->addState(icState);
508 Tempus::createIntegratorBasic<double>();
509 integrator->setStepper(stepper);
510 integrator->setTimeStepControl(timeStepControl);
511 integrator->setSolutionHistory(solutionHistory);
512 integrator->initialize();
515 bool integratorStatus = integrator->advanceTime();
525 auto Dt = integrator->getTime();
528 const auto x = integrator->getX();
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.
Teuchos::RCP< StepperNewmarkImplicitAForm< Scalar > > createStepperNewmarkImplicitAForm(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &model, Teuchos::RCP< Teuchos::ParameterList > pl)
Nonmember constructor - ModelEvaluator and ParameterList.
void testFactoryConstruction(std::string stepperType, const Teuchos::RCP< const Thyra::ModelEvaluator< double > > &model)
Unit test utility for Stepper construction through StepperFactory.
T & get(const std::string &name, T def_value)
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
#define TEST_COMPARE(v1, comp, v2)
#define TEST_FLOATING_EQUALITY(v1, v2, tol)
Teuchos::RCP< Teuchos::ParameterList > defaultSolverParameters()
Returns the default solver ParameterList for implicit Steppers.
Consider the ODE: where is a constant, is a constant damping parameter, is a constant forcing par...
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)
TimeStepControl manages the time step size. There several mechanisms that effect the time step size a...
SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of...
Keep a fix number of states.
ParameterList & sublist(const std::string &name, bool mustAlreadyExist=false, const std::string &docString="")
#define TEUCHOS_ASSERT(assertion_test)
#define TEUCHOS_TEST_FOR_EXCEPT(throw_exception_test)