Tempus Version of the Day
Time Integration
Loading...
Searching...
No Matches
Tempus_StepperForwardEuler_impl.hpp
Go to the documentation of this file.
1// @HEADER
2// ****************************************************************************
3// Tempus: Copyright (2017) Sandia Corporation
4//
5// Distributed under BSD 3-clause license (See accompanying file Copyright.txt)
6// ****************************************************************************
7// @HEADER
8
9#ifndef Tempus_StepperForwardEuler_impl_hpp
10#define Tempus_StepperForwardEuler_impl_hpp
11
12#include "Thyra_VectorStdOps.hpp"
13
15
16
17namespace Tempus {
18
19template<class Scalar>
21{
22 this->setStepperName( "Forward Euler");
23 this->setStepperType( "Forward Euler");
24 this->setUseFSAL( true);
25 this->setICConsistency( "Consistent");
26 this->setICConsistencyCheck( false);
27 this->setAppAction(Teuchos::null);
28}
29
30template<class Scalar>
32 const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel,
33 bool useFSAL,
34 std::string ICConsistency,
35 bool ICConsistencyCheck,
36 const Teuchos::RCP<StepperForwardEulerAppAction<Scalar> >& stepperFEAppAction)
37{
38 this->setStepperName( "Forward Euler");
39 this->setStepperType( "Forward Euler");
40 this->setUseFSAL( useFSAL);
41 this->setICConsistency( ICConsistency);
42 this->setICConsistencyCheck( ICConsistencyCheck);
43
44 this->setAppAction(stepperFEAppAction);
45 if (appModel != Teuchos::null) {
46 this->setModel(appModel);
47 this->initialize();
48 }
49}
50
51template<class Scalar>
53 Teuchos::RCP<StepperForwardEulerAppAction<Scalar> > appAction)
54{
55 if (appAction == Teuchos::null) {
56 // Create default appAction
57 stepperFEAppAction_ =
58 Teuchos::rcp(new StepperForwardEulerModifierDefault<Scalar>());
59 }
60 else {
61 stepperFEAppAction_ = appAction;
62 }
63}
64
65
66template<class Scalar>
68 const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory)
69{
70 using Teuchos::RCP;
71
72 RCP<SolutionState<Scalar> > initialState = solutionHistory->getCurrentState();
73
74 // Check if we need Stepper storage for xDot
75 if (initialState->getXDot() == Teuchos::null)
76 this->setStepperXDot(initialState->getX()->clone_v());
77 else
78 this->setStepperXDot(initialState->getXDot());
79
81}
82
83template<class Scalar>
85 const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory)
86{
87 this->checkInitialized();
88
89 using Teuchos::RCP;
90
91 TEMPUS_FUNC_TIME_MONITOR("Tempus::StepperForwardEuler::takeStep()");
92 {
93 TEUCHOS_TEST_FOR_EXCEPTION(solutionHistory->getNumStates() < 2,
94 std::logic_error,
95 "Error - StepperForwardEuler<Scalar>::takeStep(...)\n"
96 "Need at least two SolutionStates for Forward Euler.\n"
97 " Number of States = " << solutionHistory->getNumStates() << "\n"
98 "Try setting in \"Solution History\" \"Storage Type\" = \"Undo\"\n"
99 " or \"Storage Type\" = \"Static\" and \"Storage Limit\" = \"2\"\n");
100
101 RCP<StepperForwardEuler<Scalar> > thisStepper = Teuchos::rcpFromRef(*this);
102 stepperFEAppAction_->execute(solutionHistory, thisStepper,
104
105 RCP<SolutionState<Scalar> > currentState=solutionHistory->getCurrentState();
106 RCP<SolutionState<Scalar> > workingState=solutionHistory->getWorkingState();
107 if (currentState->getXDot() != Teuchos::null)
108 this->setStepperXDot(currentState->getXDot());
109 RCP<Thyra::VectorBase<Scalar> > xDot = this->getStepperXDot();
110 const Scalar dt = workingState->getTimeStep();
111
112 if (!(this->getUseFSAL()) || workingState->getNConsecutiveFailures() != 0) {
113 // Need to compute XDotOld.
114 stepperFEAppAction_->execute(solutionHistory, thisStepper,
116
117 auto p = Teuchos::rcp(new ExplicitODEParameters<Scalar>(dt));
118
119 // Evaluate xDot = f(x,t).
120 this->evaluateExplicitODE(xDot, currentState->getX(),
121 currentState->getTime(), p);
122
123 // For UseFSAL=false, x and xDot are now sync'ed or consistent
124 // at the same time level for the currentState.
125 currentState->setIsSynced(true);
126 }
127
128
129 // Forward Euler update, x^n = x^{n-1} + dt^n * xDot^{n-1}
130 Thyra::V_VpStV(Teuchos::outArg(*(workingState->getX())),
131 *(currentState->getX()),dt,*(xDot));
132
133
134 if (workingState->getXDot() != Teuchos::null)
135 this->setStepperXDot(workingState->getXDot());
136 xDot = this->getStepperXDot();
137
138 if (this->getUseFSAL()) {
139 // Get consistent xDot^n.
140 stepperFEAppAction_->execute(solutionHistory, thisStepper,
142
143 auto p = Teuchos::rcp(new ExplicitODEParameters<Scalar>(dt));
144
145 // Evaluate xDot = f(x,t).
146 this->evaluateExplicitODE(xDot, workingState->getX(),
147 workingState->getTime(), p);
148
149 // For UseFSAL=true, x and xDot are now sync'ed or consistent
150 // for the workingState.
151 workingState->setIsSynced(true);
152 } else {
153 assign(xDot.ptr(), Teuchos::ScalarTraits<Scalar>::zero());
154 workingState->setIsSynced(false);
155 }
156
157 workingState->setSolutionStatus(Status::PASSED);
158 workingState->setOrder(this->getOrder());
159 workingState->computeNorms(currentState);
160 stepperFEAppAction_->execute(solutionHistory, thisStepper,
162 }
163 return;
164}
165
166
173template<class Scalar>
174Teuchos::RCP<Tempus::StepperState<Scalar> > StepperForwardEuler<Scalar>::
176{
177 Teuchos::RCP<Tempus::StepperState<Scalar> > stepperState =
178 rcp(new StepperState<Scalar>(this->getStepperType()));
179 return stepperState;
180}
181
182
183template<class Scalar>
185 Teuchos::FancyOStream &out,
186 const Teuchos::EVerbosityLevel verbLevel) const
187{
188 auto l_out = Teuchos::fancyOStream( out.getOStream() );
189 Teuchos::OSTab ostab(*l_out, 2, this->description());
190 l_out->setOutputToRootOnly(0);
191
192 *l_out << std::endl;
193 Stepper<Scalar>::describe(*l_out, verbLevel);
194 StepperExplicit<Scalar>::describe(*l_out, verbLevel);
195 *l_out << " stepperFEAppAction_ = "
196 << stepperFEAppAction_ << std::endl
197 << "----------------------------" << std::endl;
198}
199
200
201template<class Scalar>
202bool StepperForwardEuler<Scalar>::isValidSetup(Teuchos::FancyOStream & out) const
203{
204 out.setOutputToRootOnly(0);
205
206 bool isValidSetup = true;
207
208 if ( !Stepper<Scalar>::isValidSetup(out) ) isValidSetup = false;
209 if ( !StepperExplicit<Scalar>::isValidSetup(out) ) isValidSetup = false;
210 if (stepperFEAppAction_ == Teuchos::null) {
211 isValidSetup = false;
212 out << "The Forward Euler AppAction is not set!\n";
213 }
214 return isValidSetup;
215}
216
217
218// Nonmember constructor - ModelEvaluator and ParameterList
219// ------------------------------------------------------------------------
220template<class Scalar>
221Teuchos::RCP<StepperForwardEuler<Scalar> >
223 const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model,
224 Teuchos::RCP<Teuchos::ParameterList> pl)
225{
226 auto stepper = Teuchos::rcp(new StepperForwardEuler<Scalar>());
227 stepper->setStepperExplicitValues(pl);
228
229 if (model != Teuchos::null) {
230 stepper->setModel(model);
231 stepper->initialize();
232 }
233
234 return stepper;
235}
236
237
238} // namespace Tempus
239#endif // Tempus_StepperForwardEuler_impl_hpp
Thyra Base interface for implicit time steppers.
virtual void setInitialConditions(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Set the initial conditions, make them consistent, and set needed memory.
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
Application Action for StepperForwardEuler.
virtual void setInitialConditions(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Set the initial conditions, make them consistent, and set needed memory.
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
virtual bool isValidSetup(Teuchos::FancyOStream &out) const
virtual Teuchos::RCP< Tempus::StepperState< Scalar > > getDefaultStepperState()
Get a default (initial) StepperState.
virtual void takeStep(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Take the specified timestep, dt, and return true if successful.
virtual void setAppAction(Teuchos::RCP< StepperForwardEulerAppAction< Scalar > > appAction)
Thyra Base interface for time steppers.
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
Teuchos::RCP< StepperForwardEuler< Scalar > > createStepperForwardEuler(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &model, Teuchos::RCP< Teuchos::ParameterList > pl)
Nonmember constructor - ModelEvaluator and ParameterList.