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"
23 template <
class Scalar>
29 this->setStepperName(
"Subcycling");
30 this->setStepperType(
"Subcycling");
31 this->setUseFSAL(
false);
32 this->setICConsistency(
"None");
33 this->setICConsistencyCheck(
false);
35 this->setAppAction(Teuchos::null);
38 scIntegrator_->setObserver(
42 scIntegrator_->getValidParameters());
45 tempusPL->
sublist(
"Default Integrator")
46 .
set(
"Stepper Name",
"Default Subcycling Stepper");
47 RCP<ParameterList> stepperPL = Teuchos::parameterList();
48 stepperPL->set(
"Stepper Type",
"Forward Euler");
49 tempusPL->set(
"Default Subcycling Stepper", *stepperPL);
52 setSubcyclingStepper(stepperFE);
68 tempusPL->sublist(
"Default Integrator")
69 .sublist(
"Time Step Control")
70 .set(
"Initial Time Step", std::numeric_limits<Scalar>::max());
73 scIntegrator_->setTimeStepControl();
74 this->setSubcyclingPrintDtChanges(
false);
77 template <
class Scalar>
81 std::string ICConsistency,
bool ICConsistencyCheck,
84 this->setStepperName(
"Subcycling");
85 this->setStepperType(
"Subcycling");
86 this->setUseFSAL(useFSAL);
87 this->setICConsistency(ICConsistency);
88 this->setICConsistencyCheck(ICConsistencyCheck);
89 this->setAppAction(stepperSCAppAction);
90 scIntegrator_ = scIntegrator;
91 this->setSubcyclingPrintDtChanges(
false);
93 if (appModel != Teuchos::null) {
94 this->setModel(appModel);
99 template <
class Scalar>
103 scIntegrator_->setStepper(stepper);
104 this->isInitialized_ =
false;
107 template <
class Scalar>
110 scIntegrator_->getNonConstTimeStepControl()->setMinTimeStep(MinTimeStep);
111 this->isInitialized_ =
false;
114 template <
class Scalar>
117 scIntegrator_->getNonConstTimeStepControl()->setInitTimeStep(InitTimeStep);
118 this->isInitialized_ =
false;
121 template <
class Scalar>
124 scIntegrator_->getNonConstTimeStepControl()->setMaxTimeStep(MaxTimeStep);
125 this->isInitialized_ =
false;
128 template <
class Scalar>
131 scIntegrator_->getNonConstTimeStepControl()->setMaxFailures(MaxFailures);
132 this->isInitialized_ =
false;
135 template <
class Scalar>
137 int MaxConsecFailures)
139 scIntegrator_->getNonConstTimeStepControl()->setMaxConsecFailures(
141 this->isInitialized_ =
false;
144 template <
class Scalar>
147 scIntegrator_->setScreenOutputIndexInterval(i);
148 this->isInitialized_ =
false;
151 template <
class Scalar>
155 scIntegrator_->setScreenOutputIndexList(s);
156 this->isInitialized_ =
false;
159 template <
class Scalar>
163 scIntegrator_->getNonConstTimeStepControl()->setTimeStepControlStrategy(tscs);
164 this->isInitialized_ =
false;
167 template <
class Scalar>
171 scIntegrator_->setObserver(obs);
172 this->isInitialized_ =
false;
175 template <
class Scalar>
178 scIntegrator_->getNonConstTimeStepControl()->setPrintDtChanges(
180 this->isInitialized_ =
false;
183 template <
class Scalar>
187 return scIntegrator_->getStepper();
190 template <
class Scalar>
193 return scIntegrator_->getTimeStepControl()->getMinTimeStep();
196 template <
class Scalar>
199 return scIntegrator_->getTimeStepControl()->getInitTimeStep();
202 template <
class Scalar>
205 return scIntegrator_->getTimeStepControl()->getMaxTimeStep();
208 template <
class Scalar>
211 return scIntegrator_->getTimeStepControl()->getStepType();
214 template <
class Scalar>
217 return scIntegrator_->getTimeStepControl()->getMaxFailures();
220 template <
class Scalar>
223 return scIntegrator_->getTimeStepControl()->getMaxConsecFailures();
226 template <
class Scalar>
229 return scIntegrator_->getScreenOutputIndexInterval();
232 template <
class Scalar>
236 return scIntegrator_->getScreenOutputIndexListString();
239 template <
class Scalar>
243 return scIntegrator_->getTimeStepControl()->getTimeStepControlStrategy();
246 template <
class Scalar>
250 return scIntegrator_->getObserver();
253 template <
class Scalar>
256 return scIntegrator_->getTimeStepControl()->getPrintDtChanges();
259 template <
class Scalar>
263 scIntegrator_->setModel(appModel);
264 this->isInitialized_ =
false;
267 template <
class Scalar>
272 this->isInitialized_ =
false;
275 template <
class Scalar>
279 if (appAction == Teuchos::null) {
281 stepperSCAppAction_ =
285 stepperSCAppAction_ = appAction;
287 this->isInitialized_ =
false;
290 template <
class Scalar>
294 bool isValidSetup =
true;
296 if (!(this->getICConsistency() ==
"None" ||
297 this->getICConsistency() ==
"Zero" ||
298 this->getICConsistency() ==
"App" ||
299 this->getICConsistency() ==
"Consistent")) {
300 isValidSetup =
false;
301 *out <<
"The IC consistency does not have a valid value!\n"
302 <<
"('None', 'Zero', 'App' or 'Consistent')\n"
303 <<
" ICConsistency = " << this->getICConsistency() <<
"\n";
307 if (stepperSCAppAction_ == Teuchos::null) {
308 isValidSetup =
false;
309 *out <<
"The Subcycling AppAction is not set!\n";
313 this->isInitialized_ =
true;
318 template <
class Scalar>
321 return scIntegrator_->getStepper()->isExplicit();
324 template <
class Scalar>
327 return scIntegrator_->getStepper()->isImplicit();
330 template <
class Scalar>
333 return scIntegrator_->getStepper()->isExplicitImplicit();
336 template <
class Scalar>
339 return scIntegrator_->getStepper()->isOneStepMethod();
342 template <
class Scalar>
345 return scIntegrator_->getStepper()->isMultiStepMethod();
348 template <
class Scalar>
351 return scIntegrator_->getStepper()->getOrder();
354 template <
class Scalar>
357 return scIntegrator_->getStepper()->getOrderMin();
360 template <
class Scalar>
363 return scIntegrator_->getStepper()->getOrderMax();
366 template <
class Scalar>
369 return scIntegrator_->getStepper()->getOrderODE();
372 template <
class Scalar>
376 return scIntegrator_->getStepper()->getInitTimeStep(solutionHistory);
379 template <
class Scalar>
383 scIntegrator_->getStepper()->setInitialGuess(initialGuess);
384 this->isInitialized_ =
false;
387 template <
class Scalar>
391 scIntegrator_->getStepper()->setInitialConditions(solutionHistory);
392 scIntegrator_->setSolutionHistory(solutionHistory);
395 template <
class Scalar>
399 scIntegrator_->getStepper()->setSolver(solver);
400 this->isInitialized_ =
false;
403 template <
class Scalar>
407 return scIntegrator_->getStepper()->getSolver();
410 template <
class Scalar>
416 TEMPUS_FUNC_TIME_MONITOR(
"Tempus::StepperSubcycling::takeStep()");
419 solutionHistory->getNumStates() < 2, std::logic_error,
420 "Error - StepperSubcycling<Scalar>::takeStep(...)\n"
421 <<
"Need at least two SolutionStates for Subcycling.\n"
422 <<
" Number of States = " << solutionHistory->getNumStates()
423 <<
"\nTry setting in \"Solution History\" \"Storage Type\" = "
425 <<
" or \"Storage Type\" = \"Static\" and \"Storage Limit\" = "
428 RCP<StepperSubcycling<Scalar> > thisStepper = Teuchos::rcpFromRef(*
this);
429 stepperSCAppAction_->execute(
430 solutionHistory, thisStepper,
432 RCP<SolutionState<Scalar> > currentState =
433 solutionHistory->getCurrentState();
434 RCP<SolutionState<Scalar> > workingState =
435 solutionHistory->getWorkingState();
437 auto scTSC = scIntegrator_->getNonConstTimeStepControl();
438 scTSC->setInitTime(currentState->getTime());
439 scTSC->setInitIndex(0);
440 scTSC->setFinalTime(workingState->getTime());
442 auto subcyclingState = currentState->clone();
443 subcyclingState->setTimeStep(scTSC->getInitTimeStep());
444 subcyclingState->setOrder(scIntegrator_->getStepper()->getOrder());
445 subcyclingState->setIndex(0);
446 subcyclingState->setNFailures(0);
447 subcyclingState->setNRunningFailures(0);
448 subcyclingState->setNConsecutiveFailures(0);
449 subcyclingState->setOutput(
false);
450 subcyclingState->setOutputScreen(
false);
453 !subcyclingState->getIsSynced(), std::logic_error,
454 "Error - StepperSubcycling<Scalar>::takeStep(...)\n"
455 " Subcycling requires the the solution is synced!\n"
456 " (i.e., x, xDot, and xDotDot at the same time level.\n");
459 scSH->setName(
"Subcycling States");
461 scSH->setStorageLimit(3);
462 scSH->addState(subcyclingState);
464 scIntegrator_->setSolutionHistory(scSH);
466 bool pass = scIntegrator_->advanceTime();
468 RCP<SolutionState<Scalar> > scCS = scSH->getCurrentState();
470 RCP<Thyra::VectorBase<Scalar> > x = workingState->getX();
471 RCP<Thyra::VectorBase<Scalar> > scX = scCS->getX();
472 Thyra::V_V(x.ptr(), *(scX));
474 RCP<Thyra::VectorBase<Scalar> > xDot = workingState->getXDot();
475 if (xDot != Teuchos::null) {
476 RCP<Thyra::VectorBase<Scalar> > scXDot = scCS->getXDot();
477 Thyra::V_V(xDot.ptr(), *(scXDot));
480 RCP<Thyra::VectorBase<Scalar> > xDotDot = workingState->getXDotDot();
481 if (xDotDot != Teuchos::null) {
482 RCP<Thyra::VectorBase<Scalar> > scXDotDot = scCS->getXDotDot();
483 Thyra::V_V(xDotDot.ptr(), *(scXDotDot));
490 workingState->setOrder(scCS->getOrder());
491 workingState->computeNorms(currentState);
493 stepperSCAppAction_->execute(
494 solutionHistory, thisStepper,
506 template <
class Scalar>
515 template <
class Scalar>
523 out <<
"--- StepperSubcycling ---\n";
524 out <<
" stepperSCAppAction = " << stepperSCAppAction_ << std::endl;
525 out <<
" scIntegrator = " << scIntegrator_ << std::endl;
526 out <<
"-------------------------" << std::endl;
527 scIntegrator_->getStepper()->describe(out, verbLevel);
530 template <
class Scalar>
535 true, std::logic_error,
536 "Error - StepperSubcycling<Scalar>::getValidParameters()\n"
537 " is not implemented yet.\n");
539 return this->getValidParametersBasic();
544 template <
class Scalar>
552 pl != Teuchos::null, std::logic_error,
553 "Error - Construction of StepperSubcycling with a ParameterList\n"
554 "is not implemented yet!\n");
556 if (pl != Teuchos::null) {
557 stepper->setStepperValues(pl);
560 if (model != Teuchos::null) {
561 stepper->setModel(model);
562 stepper->initialize();
569 #endif // Tempus_StepperSubcycling_impl_hpp
virtual int getSubcyclingMaxConsecFailures() const
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const
virtual bool isExplicitImplicit() const
virtual void setSubcyclingStepper(Teuchos::RCP< Stepper< Scalar > > stepper)
virtual void initialize()
Initialize during construction and after changing input parameters.
virtual void setSubcyclingMinTimeStep(Scalar MinTimeStep)
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
virtual void setSubcyclingScreenOutputIndexInterval(int i)
virtual void setSubcyclingMaxTimeStep(Scalar MaxTimeStep)
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
Forward Euler time stepper.
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Default modifier for StepperSubcycling.
virtual Scalar getSubcyclingMaxTimeStep() const
Teuchos::RCP< StepperSubcycling< Scalar > > createStepperSubcycling(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &model, Teuchos::RCP< Teuchos::ParameterList > pl)
Nonmember constructor - ModelEvaluator and ParameterList.
virtual Teuchos::RCP< Tempus::StepperState< Scalar > > getDefaultStepperState()
Get a default (initial) StepperState.
void initialize(const RCP< std::basic_ostream< char_type, traits_type > > &oStream, const std::basic_string< char_type, traits_type > &tabIndentStr=" ", const int startingTab=0, const bool showLinePrefix=false, const int maxLenLinePrefix=10, const bool showTabCount=false, const bool showProcRank=false)
virtual void takeStep(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Take the specified timestep, dt, and return true if successful.
virtual bool isOneStepMethod() const
virtual void setSolver(Teuchos::RCP< Thyra::NonlinearSolverBase< Scalar > > solver=Teuchos::null)
Set solver.
virtual void setSubcyclingMaxConsecFailures(int MaxConsecFailures)
virtual int getSubcyclingMaxFailures() const
virtual void setSubcyclingTimeStepControlStrategy(Teuchos::RCP< TimeStepControlStrategy< Scalar > > tscs)
Application Action for StepperSubcycling.
Thyra Base interface for time steppers.
virtual Teuchos::RCP< IntegratorObserver< Scalar > > getSubcyclingIntegratorObserver() const
virtual int getSubcyclingScreenOutputIndexInterval() const
virtual void setSubcyclingIntegratorObserver(Teuchos::RCP< IntegratorObserver< Scalar > > obs)
StepperState is a simple class to hold state information about the stepper.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
virtual bool isImplicit() const
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
IntegratorObserverNoOp class for time integrators. This basic class has simple no-op functions...
virtual Scalar getOrderMax() const
IntegratorObserver class for time integrators.
virtual Teuchos::RCP< Thyra::NonlinearSolverBase< Scalar > > getSolver() const
Get solver.
virtual void setSubcyclingScreenOutputIndexList(std::string s)
virtual std::string getSubcyclingStepType() const
virtual bool isExplicit() const
virtual bool isMultiStepMethod() const
SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of...
basic_FancyOStream & setOutputToRootOnly(const int rootRank)
virtual Scalar getInitTimeStep(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory) const
Keep a fix number of states.
virtual void setSubcyclingInitTimeStep(Scalar InitTimeStep)
virtual void setInitialGuess(Teuchos::RCP< const Thyra::VectorBase< Scalar > > initial_guess)
Pass initial guess to Newton solver (only relevant for implicit solvers)
virtual Teuchos::RCP< const Stepper< Scalar > > getSubcyclingStepper() const
virtual Scalar getOrderMin() const
virtual OrderODE getOrderODE() const
virtual Scalar getOrder() const
virtual void setModel(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &appModel)
ParameterList & sublist(const std::string &name, bool mustAlreadyExist=false, const std::string &docString="")
virtual void setSubcyclingPrintDtChanges(bool printDtChanges)
virtual std::string getSubcyclingScreenOutputIndexList() const
StepperSubcycling()
Default constructor.
virtual Scalar getSubcyclingMinTimeStep() const
virtual bool getSubcyclingPrintDtChanges() const
TimeStepControlStrategy class for TimeStepControl.
virtual Teuchos::RCP< TimeStepControlStrategy< Scalar > > getSubcyclingTimeStepControlStrategy() const
virtual Scalar getSubcyclingInitTimeStep() const
virtual void setInitialConditions(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Set the initial conditions, make them consistent, and set needed memory.
virtual void setNonConstModel(const Teuchos::RCP< Thyra::ModelEvaluator< Scalar > > &appModel)
virtual void setAppAction(Teuchos::RCP< StepperSubcyclingAppAction< Scalar > > appAction=Teuchos::null)
virtual void setSubcyclingMaxFailures(int MaxFailures)