9#ifndef Tempus_StepperSubcycling_impl_hpp
10#define Tempus_StepperSubcycling_impl_hpp
12#include "Thyra_VectorStdOps.hpp"
14#include "Tempus_StepperForwardEuler.hpp"
18#include "Tempus_IntegratorObserverSubcycling.hpp"
19#include "Tempus_IntegratorObserverNoOp.hpp"
29 using Teuchos::ParameterList;
31 this->setStepperName(
"Subcycling");
32 this->setStepperType(
"Subcycling");
33 this->setUseFSAL(
false);
34 this->setICConsistency(
"None");
35 this->setICConsistencyCheck(
false);
37 this->setAppAction(Teuchos::null);
40 scIntegrator_->setObserver(
43 RCP<ParameterList> tempusPL =
44 Teuchos::rcp_const_cast<Teuchos::ParameterList> (
45 scIntegrator_->getValidParameters());
48 tempusPL->sublist(
"Default Integrator")
49 .set(
"Stepper Name",
"Default Subcycling Stepper");
50 RCP<ParameterList> stepperPL = Teuchos::parameterList();
51 stepperPL->set(
"Stepper Type",
"Forward Euler");
52 tempusPL->set(
"Default Subcycling Stepper", *stepperPL);
55 setSubcyclingStepper(stepperFE);
71 tempusPL->sublist(
"Default Integrator")
72 .sublist(
"Time Step Control")
73 .set(
"Initial Time Step", std::numeric_limits<Scalar>::max());
76 scIntegrator_->setTimeStepControl();
77 this->setSubcyclingPrintDtChanges(
false);
87 std::string ICConsistency,
88 bool ICConsistencyCheck,
91 this->setStepperName(
"Subcycling");
92 this->setStepperType(
"Subcycling");
93 this->setUseFSAL( useFSAL);
94 this->setICConsistency( ICConsistency);
95 this->setICConsistencyCheck( ICConsistencyCheck);
96 this->setAppAction(stepperSCAppAction);
97 scIntegrator_ = scIntegrator;
98 this->setSubcyclingPrintDtChanges(
false);
100 if (appModel != Teuchos::null) {
101 this->setModel(appModel);
106template<
class Scalar>
110 scIntegrator_->setStepper(stepper);
111 this->isInitialized_ =
false;
115template<
class Scalar>
118 scIntegrator_->getNonConstTimeStepControl()->setMinTimeStep(MinTimeStep);
119 this->isInitialized_ =
false;
123template<
class Scalar>
126 scIntegrator_->getNonConstTimeStepControl()->setInitTimeStep(InitTimeStep);
127 this->isInitialized_ =
false;
131template<
class Scalar>
134 scIntegrator_->getNonConstTimeStepControl()->setMaxTimeStep(MaxTimeStep);
135 this->isInitialized_ =
false;
139template<
class Scalar>
142 scIntegrator_->getNonConstTimeStepControl()->setMaxFailures(MaxFailures);
143 this->isInitialized_ =
false;
147template<
class Scalar>
151 scIntegrator_->getNonConstTimeStepControl()->setMaxConsecFailures(MaxConsecFailures);
152 this->isInitialized_ =
false;
156template<
class Scalar>
160 scIntegrator_->setScreenOutputIndexInterval(i);
161 this->isInitialized_ =
false;
165template<
class Scalar>
169 scIntegrator_->setScreenOutputIndexList(s);
170 this->isInitialized_ =
false;
174template<
class Scalar>
179 scIntegrator_->getNonConstTimeStepControl()->setTimeStepControlStrategy(tscs);
180 this->isInitialized_ =
false;
184template<
class Scalar>
188 scIntegrator_->setObserver(obs);
189 this->isInitialized_ =
false;
193template<
class Scalar>
197 scIntegrator_->getNonConstTimeStepControl()->setPrintDtChanges(printDtChanges);
198 this->isInitialized_ =
false;
202template<
class Scalar>
203Teuchos::RCP<const Stepper<Scalar> >
205{
return scIntegrator_->getStepper(); }
208template<
class Scalar>
210{
return scIntegrator_->getTimeStepControl()->getMinTimeStep(); }
213template<
class Scalar>
215{
return scIntegrator_->getTimeStepControl()->getInitTimeStep(); }
218template<
class Scalar>
220{
return scIntegrator_->getTimeStepControl()->getMaxTimeStep(); }
223template<
class Scalar>
225{
return scIntegrator_->getTimeStepControl()->getStepType(); }
228template<
class Scalar>
230{
return scIntegrator_->getTimeStepControl()->getMaxFailures(); }
233template<
class Scalar>
235{
return scIntegrator_->getTimeStepControl()->getMaxConsecFailures(); }
238template<
class Scalar>
240{
return scIntegrator_->getScreenOutputIndexInterval(); }
243template<
class Scalar>
245{
return scIntegrator_->getScreenOutputIndexListString(); }
248template<
class Scalar>
249Teuchos::RCP<TimeStepControlStrategy<Scalar> >
251{
return scIntegrator_->getTimeStepControl()->getTimeStepControlStrategy(); }
253template<
class Scalar>
254Teuchos::RCP<IntegratorObserver<Scalar> >
256{
return scIntegrator_->getObserver(); }
258template<
class Scalar>
260{
return scIntegrator_->getTimeStepControl()->getPrintDtChanges(); }
263template<
class Scalar>
267 scIntegrator_->setModel(appModel);
268 this->isInitialized_ =
false;
272template<
class Scalar>
277 this->isInitialized_ =
false;
281template<
class Scalar>
285 if (appAction == Teuchos::null) {
287 stepperSCAppAction_ =
290 stepperSCAppAction_ = appAction;
292 this->isInitialized_ =
false;
295template<
class Scalar>
298 Teuchos::RCP<Teuchos::FancyOStream> out = this->getOStream();
299 bool isValidSetup =
true;
301 if ( !(this->getICConsistency() ==
"None" ||
302 this->getICConsistency() ==
"Zero" ||
303 this->getICConsistency() ==
"App" ||
304 this->getICConsistency() ==
"Consistent") ) {
305 isValidSetup =
false;
306 *out <<
"The IC consistency does not have a valid value!\n"
307 <<
"('None', 'Zero', 'App' or 'Consistent')\n"
308 <<
" ICConsistency = " << this->getICConsistency() <<
"\n";
310 scIntegrator_->initialize();
312 if (stepperSCAppAction_ == Teuchos::null) {
313 isValidSetup =
false;
314 *out <<
"The Subcycling AppAction is not set!\n";
318 this->isInitialized_ =
true;
320 this->describe(*out, Teuchos::VERB_MEDIUM);
324template<
class Scalar>
326{
return scIntegrator_->getStepper()->isExplicit(); }
329template<
class Scalar>
331{
return scIntegrator_->getStepper()->isImplicit(); }
334template<
class Scalar>
336{
return scIntegrator_->getStepper()->isExplicitImplicit(); }
339template<
class Scalar>
341{
return scIntegrator_->getStepper()->isOneStepMethod(); }
344template<
class Scalar>
346{
return scIntegrator_->getStepper()->isMultiStepMethod(); }
349template<
class Scalar>
351{
return scIntegrator_->getStepper()->getOrder(); }
354template<
class Scalar>
356{
return scIntegrator_->getStepper()->getOrderMin(); }
359template<
class Scalar>
361{
return scIntegrator_->getStepper()->getOrderMax(); }
364template<
class Scalar>
366{
return scIntegrator_->getStepper()->getOrderODE(); }
369template<
class Scalar>
372{
return scIntegrator_->getStepper()->getInitTimeStep(solutionHistory); }
375template<
class Scalar>
379 scIntegrator_->getStepper()->setInitialGuess(initialGuess);
380 this->isInitialized_ =
false;
384template<
class Scalar>
388 scIntegrator_->getStepper()->setInitialConditions(solutionHistory);
389 scIntegrator_->setSolutionHistory(solutionHistory);
393template<
class Scalar>
395 Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > solver)
397 scIntegrator_->getStepper()->setSolver(solver);
398 this->isInitialized_ =
false;
402template<
class Scalar>
403Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> >
405{
return scIntegrator_->getStepper()->getSolver(); }
408template<
class Scalar>
414 TEMPUS_FUNC_TIME_MONITOR(
"Tempus::StepperSubcycling::takeStep()");
416 TEUCHOS_TEST_FOR_EXCEPTION(solutionHistory->getNumStates() < 2,
418 "Error - StepperSubcycling<Scalar>::takeStep(...)\n"
419 "Need at least two SolutionStates for Subcycling.\n"
420 " Number of States = " << solutionHistory->getNumStates() <<
"\n"
421 "Try setting in \"Solution History\" \"Storage Type\" = \"Undo\"\n"
422 " or \"Storage Type\" = \"Static\" and \"Storage Limit\" = \"2\"\n");
424 RCP<StepperSubcycling<Scalar> > thisStepper = Teuchos::rcpFromRef(*
this);
425 stepperSCAppAction_->execute(solutionHistory, thisStepper,
427 RCP<SolutionState<Scalar> > currentState=solutionHistory->getCurrentState();
428 RCP<SolutionState<Scalar> > workingState=solutionHistory->getWorkingState();
430 auto scTSC = scIntegrator_->getNonConstTimeStepControl();
431 scTSC->setInitTime (currentState->getTime());
432 scTSC->setInitIndex (0);
433 scTSC->setFinalTime (workingState->getTime());
435 auto subcyclingState = currentState->clone();
436 subcyclingState->setTimeStep(scTSC->getInitTimeStep());
437 subcyclingState->setOrder(scIntegrator_->getStepper()->getOrder());
438 subcyclingState->setIndex(0);
439 subcyclingState->setNFailures(0);
440 subcyclingState->setNRunningFailures(0);
441 subcyclingState->setNConsecutiveFailures(0);
442 subcyclingState->setOutput(
false);
443 subcyclingState->setOutputScreen(
false);
445 TEUCHOS_TEST_FOR_EXCEPTION(!subcyclingState->getIsSynced(),std::logic_error,
446 "Error - StepperSubcycling<Scalar>::takeStep(...)\n"
447 " Subcycling requires the the solution is synced!\n"
448 " (i.e., x, xDot, and xDotDot at the same time level.\n");
451 scSH->setName(
"Subcycling States");
453 scSH->setStorageLimit(3);
454 scSH->addState(subcyclingState);
456 scIntegrator_->setSolutionHistory(scSH);
458 bool pass = scIntegrator_->advanceTime();
460 RCP<SolutionState<Scalar> > scCS = scSH->getCurrentState();
462 RCP<Thyra::VectorBase<Scalar> > x = workingState->getX();
463 RCP<Thyra::VectorBase<Scalar> > scX = scCS->getX();
464 Thyra::V_V(x.ptr(), *(scX));
466 RCP<Thyra::VectorBase<Scalar> > xDot = workingState->getXDot();
467 if (xDot != Teuchos::null) {
468 RCP<Thyra::VectorBase<Scalar> > scXDot = scCS->getXDot();
469 Thyra::V_V(xDot.ptr(), *(scXDot));
472 RCP<Thyra::VectorBase<Scalar> > xDotDot = workingState->getXDotDot();
473 if (xDotDot != Teuchos::null) {
474 RCP<Thyra::VectorBase<Scalar> > scXDotDot = scCS->getXDotDot();
475 Thyra::V_V(xDotDot.ptr(), *(scXDotDot));
478 if (pass ==
true) workingState->setSolutionStatus(
Status::PASSED);
480 workingState->setOrder(scCS->getOrder());
481 workingState->computeNorms(currentState);
483 stepperSCAppAction_->execute(solutionHistory, thisStepper,
496template<
class Scalar>
500 Teuchos::RCP<Tempus::StepperState<Scalar> > stepperState =
506template<
class Scalar>
508 Teuchos::FancyOStream &out,
509 const Teuchos::EVerbosityLevel verbLevel)
const
511 out.setOutputToRootOnly(0);
515 out <<
"--- StepperSubcycling ---\n";
516 out <<
" stepperSCAppAction = " << stepperSCAppAction_ << std::endl;
517 out <<
" scIntegrator = " << scIntegrator_ << std::endl;
518 out <<
"-------------------------" << std::endl;
519 scIntegrator_->getStepper()->describe(out, verbLevel);
523template<
class Scalar>
524Teuchos::RCP<const Teuchos::ParameterList>
527 TEUCHOS_TEST_FOR_EXCEPTION(
true, std::logic_error,
528 "Error - StepperSubcycling<Scalar>::getValidParameters()\n"
529 " is not implemented yet.\n");
531 return this->getValidParametersBasic();
537template<
class Scalar>
538Teuchos::RCP<StepperSubcycling<Scalar> >
541 Teuchos::RCP<Teuchos::ParameterList> pl)
545 TEUCHOS_TEST_FOR_EXCEPTION(pl != Teuchos::null, std::logic_error,
546 "Error - Construction of StepperSubcycling with a ParameterList\n"
547 "is not implemented yet!\n");
549 if (pl != Teuchos::null) {
550 stepper->setStepperValues(pl);
553 if (model != Teuchos::null) {
554 stepper->setModel(model);
555 stepper->initialize();
IntegratorObserverNoOp class for time integrators. This basic class has simple no-op functions,...
IntegratorObserver class for time integrators.
SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of...
Forward Euler time stepper.
StepperState is a simple class to hold state information about the stepper.
Application Action for StepperSubcycling.
Default modifier for StepperSubcycling.
virtual void setSubcyclingStepper(Teuchos::RCP< Stepper< Scalar > > stepper)
virtual Teuchos::RCP< IntegratorObserver< Scalar > > getSubcyclingIntegratorObserver() const
virtual Scalar getInitTimeStep(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory) const
virtual void setSubcyclingPrintDtChanges(bool printDtChanges)
virtual bool isExplicit() const
virtual OrderODE getOrderODE() const
virtual bool isImplicit() const
virtual Scalar getSubcyclingMaxTimeStep() const
virtual bool isExplicitImplicit() const
virtual Scalar getOrder() const
virtual void initialize()
Initialize during construction and after changing input parameters.
virtual Teuchos::RCP< const Stepper< Scalar > > getSubcyclingStepper() const
virtual int getSubcyclingMaxConsecFailures() const
virtual int getSubcyclingScreenOutputIndexInterval() const
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
virtual bool getSubcyclingPrintDtChanges() const
virtual void setAppAction(Teuchos::RCP< StepperSubcyclingAppAction< Scalar > > appAction=Teuchos::null)
StepperSubcycling()
Default constructor.
virtual void setSolver(Teuchos::RCP< Thyra::NonlinearSolverBase< Scalar > > solver=Teuchos::null)
Set solver.
virtual void setSubcyclingMaxTimeStep(Scalar MaxTimeStep)
virtual void setModel(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &appModel)
virtual void setNonConstModel(const Teuchos::RCP< Thyra::ModelEvaluator< Scalar > > &appModel)
virtual void setSubcyclingIntegratorObserver(Teuchos::RCP< IntegratorObserver< Scalar > > obs)
virtual void setSubcyclingInitTimeStep(Scalar InitTimeStep)
virtual Scalar getSubcyclingInitTimeStep() const
virtual bool isOneStepMethod() const
virtual Scalar getSubcyclingMinTimeStep() const
virtual int getSubcyclingMaxFailures() const
virtual std::string getSubcyclingStepType() const
virtual void setInitialGuess(Teuchos::RCP< const Thyra::VectorBase< Scalar > > initial_guess)
Pass initial guess to Newton solver (only relevant for implicit solvers)
virtual void setSubcyclingMinTimeStep(Scalar MinTimeStep)
virtual Teuchos::RCP< Thyra::NonlinearSolverBase< Scalar > > getSolver() const
Get solver.
virtual void takeStep(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Take the specified timestep, dt, and return true if successful.
virtual void setSubcyclingScreenOutputIndexInterval(int i)
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const
virtual Teuchos::RCP< TimeStepControlStrategy< Scalar > > getSubcyclingTimeStepControlStrategy() const
virtual std::string getSubcyclingScreenOutputIndexList() const
virtual Scalar getOrderMax() const
virtual void setSubcyclingMaxFailures(int MaxFailures)
virtual Scalar getOrderMin() const
virtual void setInitialConditions(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Set the initial conditions, make them consistent, and set needed memory.
virtual Teuchos::RCP< Tempus::StepperState< Scalar > > getDefaultStepperState()
Get a default (initial) StepperState.
virtual void setSubcyclingMaxConsecFailures(int MaxConsecFailures)
virtual void setSubcyclingScreenOutputIndexList(std::string s)
virtual void setSubcyclingTimeStepControlStrategy(Teuchos::RCP< TimeStepControlStrategy< Scalar > > tscs)
virtual bool isMultiStepMethod() const
Thyra Base interface for time steppers.
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
TimeStepControlStrategy class for TimeStepControl.
@ STORAGE_TYPE_STATIC
Keep a fix number of states.
Teuchos::RCP< StepperSubcycling< Scalar > > createStepperSubcycling(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &model, Teuchos::RCP< Teuchos::ParameterList > pl)
Nonmember constructor - ModelEvaluator and ParameterList.