Tempus  Version of the Day
Time Integration
Tempus_StepperBackwardEuler_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_StepperBackwardEuler_impl_hpp
10 #define Tempus_StepperBackwardEuler_impl_hpp
11 
12 #include "Tempus_config.hpp"
13 #include "Tempus_StepperFactory.hpp"
14 #include "Tempus_WrapperModelEvaluatorBasic.hpp"
15 #include "Teuchos_VerboseObjectParameterListHelpers.hpp"
16 #include "NOX_Thyra.H"
17 
18 
19 namespace Tempus {
20 
21 // Forward Declaration for recursive includes (this Stepper <--> StepperFactory)
22 template<class Scalar> class StepperFactory;
23 
24 
25 // StepperBackwardEuler definitions:
26 template<class Scalar>
27 StepperBackwardEuler<Scalar>::StepperBackwardEuler(
28  const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel,
29  Teuchos::RCP<Teuchos::ParameterList> pList)
30 {
31  using Teuchos::RCP;
32  using Teuchos::ParameterList;
33 
34  // Set all the input parameters and call initialize
35  this->setParameterList(pList);
36  this->setModel(appModel);
37  this->initialize();
38 }
39 
40 
41 /** \brief Set the predictor to a pre-defined predictor in the ParameterList.
42  * The predictor is set to predictorName sublist in the Stepper's
43  * ParameterList. The predictorName sublist should already be defined
44  * in the Stepper's ParameterList. Otherwise it will fail.
45  */
46 template<class Scalar>
47 void StepperBackwardEuler<Scalar>::setPredictor(std::string predictorName)
48 {
49  using Teuchos::RCP;
50  using Teuchos::ParameterList;
51 
52  RCP<ParameterList> predPL =
53  Teuchos::sublist(this->stepperPL_, predictorName, true);
54  this->stepperPL_->set("Predictor Name", predictorName);
55  if (predictorStepper_ != Teuchos::null) predictorStepper_ = Teuchos::null;
56  RCP<StepperFactory<Scalar> > sf = Teuchos::rcp(new StepperFactory<Scalar>());
57 }
58 
59 
60 /** \brief Set the predictor to the supplied Parameter sublist.
61  * This adds a new predictor Parameter sublist to the Stepper's ParameterList.
62  * If the predictor sublist is null, it tests if the predictor is set in
63  * the Stepper's ParameterList.
64  */
65 template<class Scalar>
66 void StepperBackwardEuler<Scalar>::setPredictor(
67  Teuchos::RCP<Teuchos::ParameterList> predPL)
68 {
69  using Teuchos::RCP;
70  using Teuchos::ParameterList;
71 
72  Teuchos::RCP<Teuchos::ParameterList> stepperPL = this->stepperPL_;
73  std::string predictorName =
74  stepperPL->get<std::string>("Predictor Name","None");
75  if (is_null(predPL)) {
76  if (predictorName != "None") {
77  RCP<ParameterList> predPL =
78  Teuchos::sublist(stepperPL, predictorName, true);
79  RCP<StepperFactory<Scalar> > sf =
80  Teuchos::rcp(new StepperFactory<Scalar>());
81  predictorStepper_ =
82  sf->createStepper(this->wrapperModel_->getAppModel(), predPL);
83  }
84  } else {
85  TEUCHOS_TEST_FOR_EXCEPTION( predictorName == predPL->name(),
86  std::logic_error,
87  "Error - Trying to add a predictor that is already in ParameterList!\n"
88  << " Stepper Type = " << stepperPL->get<std::string>("Stepper Type")
89  << "\n" << " Predictor Name = "<<predictorName<<"\n");
90  predictorName = predPL->name();
91  stepperPL->set("Predictor Name", predictorName);
92  stepperPL->set(predictorName, *predPL); // Add sublist
93  if (predictorStepper_ != Teuchos::null) predictorStepper_ = Teuchos::null;
94  RCP<StepperFactory<Scalar> > sf =
95  Teuchos::rcp(new StepperFactory<Scalar>());
96  predictorStepper_ =
97  sf->createStepper(this->wrapperModel_->getAppModel(), predPL);
98  }
99 }
100 
101 
102 template<class Scalar>
103 void StepperBackwardEuler<Scalar>::setObserver(
104  Teuchos::RCP<StepperObserver<Scalar> > obs)
105 {
106  if (obs == Teuchos::null) {
107  // Create default observer, otherwise keep current observer.
108  if (stepperObserver_ == Teuchos::null) {
109  stepperBEObserver_ =
110  Teuchos::rcp(new StepperBackwardEulerObserver<Scalar>());
111  stepperObserver_ =
112  Teuchos::rcp_dynamic_cast<StepperObserver<Scalar> >(stepperBEObserver_);
113  }
114  } else {
115  stepperObserver_ = obs;
116  stepperBEObserver_ =
117  Teuchos::rcp_dynamic_cast<StepperBackwardEulerObserver<Scalar> >
118  (stepperObserver_);
119  }
120 }
121 
122 
123 template<class Scalar>
124 void StepperBackwardEuler<Scalar>::initialize()
125 {
126  TEUCHOS_TEST_FOR_EXCEPTION(
127  this->wrapperModel_ == Teuchos::null, std::logic_error,
128  "Error - Need to set the model, setModel(), before calling "
129  "StepperBackwardEuler::initialize()\n");
130 
131  this->setParameterList(this->stepperPL_);
132  this->setSolver();
133  this->setPredictor();
134  this->setObserver();
135 }
136 
137 
138 template<class Scalar>
139 void StepperBackwardEuler<Scalar>::takeStep(
140  const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory)
141 {
142  using Teuchos::RCP;
143 
144  TEMPUS_FUNC_TIME_MONITOR("Tempus::StepperBackwardEuler::takeStep()");
145  {
146  TEUCHOS_TEST_FOR_EXCEPTION(solutionHistory->getNumStates() < 2,
147  std::logic_error,
148  "Error - StepperBackwardEuler<Scalar>::takeStep(...)\n"
149  "Need at least two SolutionStates for Backward Euler.\n"
150  " Number of States = " << solutionHistory->getNumStates() << "\n"
151  "Try setting in \"Solution History\" \"Storage Type\" = \"Undo\"\n"
152  " or \"Storage Type\" = \"Static\" and \"Storage Limit\" = \"2\"\n");
153 
154  stepperObserver_->observeBeginTakeStep(solutionHistory, *this);
155  RCP<SolutionState<Scalar> > workingState=solutionHistory->getWorkingState();
156  RCP<SolutionState<Scalar> > currentState=solutionHistory->getCurrentState();
157 
158  RCP<const Thyra::VectorBase<Scalar> > xOld = currentState->getX();
159  RCP<Thyra::VectorBase<Scalar> > x = workingState->getX();
160  RCP<Thyra::VectorBase<Scalar> > xDot = workingState->getXDot();
161  if (xDot == Teuchos::null) xDot = getXDotTemp(x);
162 
163  computePredictor(solutionHistory);
164  if (workingState->getSolutionStatus() == Status::FAILED)
165  return;
166 
167  const Scalar time = workingState->getTime();
168  const Scalar dt = workingState->getTimeStep();
169 
170  // Setup TimeDerivative
171  Teuchos::RCP<TimeDerivative<Scalar> > timeDer =
172  Teuchos::rcp(new StepperBackwardEulerTimeDerivative<Scalar>(1.0/dt,xOld));
173 
174  // Setup InArgs and OutArgs
175  typedef Thyra::ModelEvaluatorBase MEB;
176  MEB::InArgs<Scalar> inArgs = this->wrapperModel_->getInArgs();
177  MEB::OutArgs<Scalar> outArgs = this->wrapperModel_->getOutArgs();
178  inArgs.set_x(x);
179  if (inArgs.supports(MEB::IN_ARG_x_dot )) inArgs.set_x_dot (xDot);
180  if (inArgs.supports(MEB::IN_ARG_t )) inArgs.set_t (time);
181  if (inArgs.supports(MEB::IN_ARG_step_size)) inArgs.set_step_size(dt);
182  if (inArgs.supports(MEB::IN_ARG_alpha )) inArgs.set_alpha (1.0/dt);
183  if (inArgs.supports(MEB::IN_ARG_beta )) inArgs.set_beta (1.0);
184 
185  this->wrapperModel_->setForSolve(timeDer, inArgs, outArgs);
186 
187  if (!Teuchos::is_null(stepperBEObserver_))
188  stepperBEObserver_->observeBeforeSolve(solutionHistory, *this);
189 
190  const Thyra::SolveStatus<Scalar> sStatus = this->solveImplicitODE(x);
191 
192  if (!Teuchos::is_null(stepperBEObserver_))
193  stepperBEObserver_->observeAfterSolve(solutionHistory, *this);
194 
195  if (workingState->getXDot() != Teuchos::null)
196  timeDer->compute(x, xDot);
197 
198  if (sStatus.solveStatus == Thyra::SOLVE_STATUS_CONVERGED)
199  workingState->setSolutionStatus(Status::PASSED);
200  else
201  workingState->setSolutionStatus(Status::FAILED);
202  workingState->setOrder(this->getOrder());
203  stepperObserver_->observeEndTakeStep(solutionHistory, *this);
204  }
205  return;
206 }
207 
208 template<class Scalar>
209 Teuchos::RCP<Thyra::VectorBase<Scalar> >
210 StepperBackwardEuler<Scalar>::
211 getXDotTemp(Teuchos::RCP<const Thyra::VectorBase<Scalar> > x) const
212 {
213  if (xDotTemp_ == Teuchos::null) {
214  xDotTemp_ = x->clone_v();
215  Thyra::assign(xDotTemp_.ptr(), Scalar(0.0));
216  }
217  return xDotTemp_;
218 }
219 
220 template<class Scalar>
221 void StepperBackwardEuler<Scalar>::computePredictor(
222  const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory)
223 {
224  if (predictorStepper_ == Teuchos::null) return;
225  predictorStepper_->takeStep(solutionHistory);
226 
227  if (solutionHistory->getWorkingState()->getSolutionStatus()==Status::FAILED) {
228  Teuchos::RCP<Teuchos::FancyOStream> out = this->getOStream();
229  Teuchos::OSTab ostab(out,1,"StepperBackwardEuler::computePredictor");
230  *out << "Warning - predictorStepper has failed." << std::endl;
231  } else {
232  // Reset status to WORKING since this is the predictor
233  solutionHistory->getWorkingState()->setSolutionStatus(Status::WORKING);
234  }
235 }
236 
237 
238 /** \brief Provide a StepperState to the SolutionState.
239  * This Stepper does not have any special state data,
240  * so just provide the base class StepperState with the
241  * Stepper description. This can be checked to ensure
242  * that the input StepperState can be used by this Stepper.
243  */
244 template<class Scalar>
245 Teuchos::RCP<Tempus::StepperState<Scalar> >
246 StepperBackwardEuler<Scalar>::
247 getDefaultStepperState()
248 {
249  Teuchos::RCP<Tempus::StepperState<Scalar> > stepperState =
250  rcp(new StepperState<Scalar>(description()));
251  return stepperState;
252 }
253 
254 
255 template<class Scalar>
256 std::string StepperBackwardEuler<Scalar>::description() const
257 {
258  std::string name = "Backward Euler";
259  return(name);
260 }
261 
262 
263 template<class Scalar>
264 void StepperBackwardEuler<Scalar>::describe(
265  Teuchos::FancyOStream &out,
266  const Teuchos::EVerbosityLevel verbLevel) const
267 {
268  out << description() << "::describe:" << std::endl
269  << "wrapperModel_ = " << this->wrapperModel_->description() << std::endl;
270 }
271 
272 
273 template <class Scalar>
274 void StepperBackwardEuler<Scalar>::setParameterList(
275  Teuchos::RCP<Teuchos::ParameterList> const& pList)
276 {
277  Teuchos::RCP<Teuchos::ParameterList> stepperPL = this->stepperPL_;
278  if (pList == Teuchos::null) {
279  // Create default parameters if null, otherwise keep current parameters.
280  if (stepperPL == Teuchos::null) stepperPL = this->getDefaultParameters();
281  } else {
282  stepperPL = pList;
283  }
284  if (!(stepperPL->isParameter("Solver Name"))) {
285  stepperPL->set<std::string>("Solver Name", "Default Solver");
286  Teuchos::RCP<Teuchos::ParameterList> solverPL =
287  this->defaultSolverParameters();
288  stepperPL->set("Default Solver", *solverPL);
289  }
290  // Can not validate because of optional Parameters (e.g., Solver Name).
291  // stepperPL->validateParametersAndSetDefaults(*this->getValidParameters());
292 
293  std::string stepperType = stepperPL->get<std::string>("Stepper Type");
294  TEUCHOS_TEST_FOR_EXCEPTION( stepperType != "Backward Euler",
295  std::logic_error,
296  "Error - Stepper Type is not 'Backward Euler'!\n"
297  << " Stepper Type = "<<stepperPL->get<std::string>("Stepper Type")<<"\n");
298 
299  this->stepperPL_ = stepperPL;
300 }
301 
302 
303 template<class Scalar>
304 Teuchos::RCP<const Teuchos::ParameterList>
305 StepperBackwardEuler<Scalar>::getValidParameters() const
306 {
307  Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
308  pl->setName("Default Stepper - " + this->description());
309  pl->set("Stepper Type", this->description());
310  pl->set("Zero Initial Guess", false);
311  pl->set("Solver Name", "",
312  "Name of ParameterList containing the solver specifications.");
313 
314  return pl;
315 }
316 
317 
318 template<class Scalar>
319 Teuchos::RCP<Teuchos::ParameterList>
320 StepperBackwardEuler<Scalar>::getDefaultParameters() const
321 {
322  using Teuchos::RCP;
323  using Teuchos::ParameterList;
324 
325  RCP<ParameterList> pl = Teuchos::parameterList();
326  pl->setName("Default Stepper - " + this->description());
327  pl->set<std::string>("Stepper Type", this->description());
328  pl->set<bool> ("Zero Initial Guess", false);
329  pl->set<std::string>("Solver Name", "Default Solver");
330 
331  RCP<ParameterList> solverPL = this->defaultSolverParameters();
332  pl->set("Default Solver", *solverPL);
333 
334  return pl;
335 }
336 
337 
338 template <class Scalar>
339 Teuchos::RCP<Teuchos::ParameterList>
340 StepperBackwardEuler<Scalar>::getNonconstParameterList()
341 {
342  return(this->stepperPL_);
343 }
344 
345 
346 template <class Scalar>
347 Teuchos::RCP<Teuchos::ParameterList>
348 StepperBackwardEuler<Scalar>::unsetParameterList()
349 {
350  Teuchos::RCP<Teuchos::ParameterList> temp_plist = this->stepperPL_;
351  this->stepperPL_ = Teuchos::null;
352  return(temp_plist);
353 }
354 
355 
356 template <class Scalar>
357 int
358 StepperBackwardEuler<Scalar>::stencilLength() const
359 {
360  return 2;
361 }
362 
363 
364 template <class Scalar>
365 void
366 StepperBackwardEuler<Scalar>::computeStepResidual(
367  Thyra::VectorBase<Scalar>& residual,
368  const Teuchos::Array< Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
369  const Teuchos::Array<Scalar>& t,
370  const Thyra::VectorBase<Scalar>& p,
371  const int param_index) const
372 {
373  typedef Thyra::ModelEvaluatorBase MEB;
374  MEB::OutArgs<Scalar> outArgs = this->wrapperModel_->getOutArgs();
375  outArgs.set_f(Teuchos::rcpFromRef(residual));
376  computeStepResidDerivImpl(outArgs, x, t, p, param_index);
377 }
378 
379 template <class Scalar>
380 void
381 StepperBackwardEuler<Scalar>::computeStepJacobian(
382  Thyra::LinearOpBase<Scalar>& jacobian,
383  const Teuchos::Array< Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
384  const Teuchos::Array<Scalar>& t,
385  const Thyra::VectorBase<Scalar>& p,
386  const int param_index,
387  const int deriv_index) const
388 {
389  typedef Thyra::ModelEvaluatorBase MEB;
390  MEB::OutArgs<Scalar> outArgs = this->wrapperModel_->getOutArgs();
391  TEUCHOS_ASSERT(outArgs.supports(MEB::OUT_ARG_W_op));
392  outArgs.set_W_op(Teuchos::rcpFromRef(jacobian));
393  computeStepResidDerivImpl(outArgs, x, t, p, param_index, deriv_index);
394 }
395 
396 template <class Scalar>
397 void
398 StepperBackwardEuler<Scalar>::computeStepParamDeriv(
399  Thyra::LinearOpBase<Scalar>& deriv,
400  const Teuchos::Array< Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
401  const Teuchos::Array<Scalar>& t,
402  const Thyra::VectorBase<Scalar>& p,
403  const int param_index) const
404 {
405  typedef Thyra::ModelEvaluatorBase MEB;
406  MEB::OutArgs<Scalar> outArgs = this->wrapperModel_->getOutArgs();
407  TEUCHOS_ASSERT(outArgs.supports(MEB::OUT_ARG_DfDp, param_index).supports(MEB::DERIV_LINEAR_OP));
408  outArgs.set_DfDp(param_index,
409  MEB::Derivative<Scalar>(Teuchos::rcpFromRef(deriv)));
410  computeStepResidDerivImpl(outArgs, x, t, p, param_index);
411 }
412 
413 template <class Scalar>
414 void
415 StepperBackwardEuler<Scalar>::computeStepSolver(
416  Thyra::LinearOpWithSolveBase<Scalar>& jacobian_solver,
417  const Teuchos::Array< Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
418  const Teuchos::Array<Scalar>& t,
419  const Thyra::VectorBase<Scalar>& p,
420  const int param_index) const
421 {
422  typedef Thyra::ModelEvaluatorBase MEB;
423  MEB::OutArgs<Scalar> outArgs = this->wrapperModel_->getOutArgs();
424  TEUCHOS_ASSERT(outArgs.supports(MEB::OUT_ARG_W));
425  outArgs.set_W(Teuchos::rcpFromRef(jacobian_solver));
426  computeStepResidDerivImpl(outArgs, x, t, p, param_index, 0);
427 }
428 
429 template <class Scalar>
430 void
431 StepperBackwardEuler<Scalar>::computeStepResidDerivImpl(
432  const Thyra::ModelEvaluatorBase::OutArgs<Scalar>& outArgs,
433  const Teuchos::Array< Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
434  const Teuchos::Array<Scalar>& t,
435  const Thyra::VectorBase<Scalar>& p,
436  const int param_index,
437  const int deriv_index) const
438 {
439  using Teuchos::RCP;
440  typedef Thyra::ModelEvaluatorBase MEB;
441 
442  TEUCHOS_ASSERT(x.size() == 2);
443  TEUCHOS_ASSERT(t.size() == 2);
444  RCP<const Thyra::VectorBase<Scalar> > xn = x[0];
445  RCP<const Thyra::VectorBase<Scalar> > xo = x[1];
446  const Scalar tn = t[0];
447  const Scalar to = t[1];
448  const Scalar dt = tn-to;
449 
450  // compute x_dot
451  RCP<Thyra::VectorBase<Scalar> > x_dot = getXDotTemp(xn);
452  Teuchos::RCP<TimeDerivative<Scalar> > timeDer =
453  Teuchos::rcp(new StepperBackwardEulerTimeDerivative<Scalar>(1.0/dt,xo));
454  timeDer->compute(xn, x_dot);
455 
456  // evaluate model
457  MEB::InArgs<Scalar> inArgs = this->wrapperModel_->getInArgs();
458  inArgs.set_x(xn);
459  if (inArgs.supports(MEB::IN_ARG_x_dot )) inArgs.set_x_dot (x_dot);
460  if (inArgs.supports(MEB::IN_ARG_t )) inArgs.set_t (tn);
461  if (inArgs.supports(MEB::IN_ARG_step_size )) inArgs.set_step_size(dt);
462  inArgs.set_p(param_index, Teuchos::rcpFromRef(p));
463  TEUCHOS_ASSERT(inArgs.supports(MEB::IN_ARG_alpha));
464  TEUCHOS_ASSERT(inArgs.supports(MEB::IN_ARG_beta));
465  if (deriv_index == 0) {
466  // df/dx_n = df/dx_dot * dx_dot/dx_n + df/dx_n = 1/dt*df/dx_dot + df/dx_n
467  inArgs.set_alpha(1.0/dt);
468  inArgs.set_beta(1.0);
469  }
470  else if (deriv_index == 1) {
471  // df/dx_{n-1} = df/dx_dot * dx_dot/dx_{n-1} = -1/dt*df/dx_dot
472  inArgs.set_alpha(-1.0/dt);
473  inArgs.set_beta(0.0);
474  }
475  this->wrapperModel_->getAppModel()->evalModel(inArgs, outArgs);
476 }
477 
478 } // namespace Tempus
479 #endif // Tempus_StepperBackwardEuler_impl_hpp
Tempus::StepperBackwardEuler::computeStepParamDeriv
virtual void computeStepParamDeriv(Thyra::LinearOpBase< Scalar > &deriv, const Teuchos::Array< Teuchos::RCP< const Thyra::VectorBase< Scalar > > > &x, const Teuchos::Array< Scalar > &t, const Thyra::VectorBase< Scalar > &p, const int param_index) const
Compute time step derivative w.r.t. model parameters.
Definition: Tempus_StepperBackwardEuler_impl.hpp:398
Tempus::StepperState
StepperState is a simple class to hold state information about the stepper.
Definition: Tempus_StepperState.hpp:36
Tempus::WORKING
Definition: Tempus_Types.hpp:19
Tempus::StepperBackwardEuler::computeStepResidDerivImpl
void computeStepResidDerivImpl(const Thyra::ModelEvaluatorBase::OutArgs< Scalar > &outArgs, const Teuchos::Array< Teuchos::RCP< const Thyra::VectorBase< Scalar > > > &x, const Teuchos::Array< Scalar > &t, const Thyra::VectorBase< Scalar > &p, const int param_index, const int deriv_index=0) const
Implementation of computeStep*() methods.
Definition: Tempus_StepperBackwardEuler_impl.hpp:431
Tempus::StepperBackwardEuler::getValidParameters
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const
Definition: Tempus_StepperBackwardEuler_impl.hpp:305
Tempus::solutionHistory
Teuchos::RCP< SolutionHistory< Scalar > > solutionHistory(Teuchos::RCP< Teuchos::ParameterList > pList=Teuchos::null)
Nonmember constructor.
Definition: Tempus_SolutionHistory_impl.hpp:504
Tempus::StepperBackwardEuler::setObserver
virtual void setObserver(Teuchos::RCP< StepperObserver< Scalar > > obs=Teuchos::null)
Set Observer.
Definition: Tempus_StepperBackwardEuler_impl.hpp:103
Tempus::StepperBackwardEuler::getDefaultParameters
Teuchos::RCP< Teuchos::ParameterList > getDefaultParameters() const
Definition: Tempus_StepperBackwardEuler_impl.hpp:320
Tempus
Definition: Tempus_AdjointAuxSensitivityModelEvaluator_decl.hpp:20
Tempus::StepperBackwardEuler::stencilLength
virtual int stencilLength() const
Return the number of solution vectors in the time step stencil.
Definition: Tempus_StepperBackwardEuler_impl.hpp:358
Tempus::StepperBackwardEulerTimeDerivative
Time-derivative interface for Backward Euler.
Definition: Tempus_StepperBackwardEuler_decl.hpp:165
Tempus::StepperBackwardEuler::unsetParameterList
Teuchos::RCP< Teuchos::ParameterList > unsetParameterList()
Definition: Tempus_StepperBackwardEuler_impl.hpp:348
Tempus::StepperBackwardEuler::StepperBackwardEuler
StepperBackwardEuler()
Default Constructor – not allowed.
Tempus::StepperBackwardEuler::initialize
virtual void initialize()
Initialize during construction and after changing input parameters.
Definition: Tempus_StepperBackwardEuler_impl.hpp:124
Tempus::StepperObserver
StepperObserver class for Stepper class.
Definition: Tempus_StepperObserver.hpp:38
Tempus::StepperBackwardEuler::setPredictor
void setPredictor(std::string predictorName)
Set the predictor.
Definition: Tempus_StepperBackwardEuler_impl.hpp:47
Tempus::StepperBackwardEulerObserver
StepperBackwardEulerObserver class for StepperBackwardEuler.
Definition: Tempus_StepperBackwardEulerObserver.hpp:35
Tempus::StepperBackwardEuler::description
virtual std::string description() const
Definition: Tempus_StepperBackwardEuler_impl.hpp:256
Tempus::PASSED
Definition: Tempus_Types.hpp:17
Tempus::StepperBackwardEuler::describe
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
Definition: Tempus_StepperBackwardEuler_impl.hpp:264
Tempus::SolutionHistory
SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of...
Definition: Tempus_Integrator.hpp:25
Tempus::StepperBackwardEuler::takeStep
virtual void takeStep(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Take the specified timestep, dt, and return true if successful.
Definition: Tempus_StepperBackwardEuler_impl.hpp:139
Tempus::StepperFactory
Stepper factory.
Definition: Tempus_StepperBackwardEuler_impl.hpp:22
Tempus::StepperBackwardEuler::computePredictor
virtual void computePredictor(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Compute predictor given the supplied stepper.
Definition: Tempus_StepperBackwardEuler_impl.hpp:221
Tempus::StepperBackwardEuler::computeStepSolver
virtual void computeStepSolver(Thyra::LinearOpWithSolveBase< Scalar > &jacobian_solver, const Teuchos::Array< Teuchos::RCP< const Thyra::VectorBase< Scalar > > > &x, const Teuchos::Array< Scalar > &t, const Thyra::VectorBase< Scalar > &p, const int param_index) const
Compute time step Jacobian solver.
Definition: Tempus_StepperBackwardEuler_impl.hpp:415
Tempus::FAILED
Definition: Tempus_Types.hpp:18
Tempus::StepperBackwardEuler::getXDotTemp
virtual Teuchos::RCP< Thyra::VectorBase< Scalar > > getXDotTemp(Teuchos::RCP< const Thyra::VectorBase< Scalar > > x) const
Provide temporary xDot memory for Stepper if SolutionState doesn't.
Definition: Tempus_StepperBackwardEuler_impl.hpp:211
Tempus::StepperBackwardEuler::computeStepJacobian
virtual void computeStepJacobian(Thyra::LinearOpBase< Scalar > &jacobian, const Teuchos::Array< Teuchos::RCP< const Thyra::VectorBase< Scalar > > > &x, const Teuchos::Array< Scalar > &t, const Thyra::VectorBase< Scalar > &p, const int param_index, const int deriv_index) const
Compute time step Jacobian.
Definition: Tempus_StepperBackwardEuler_impl.hpp:381
Tempus::StepperBackwardEuler::getNonconstParameterList
Teuchos::RCP< Teuchos::ParameterList > getNonconstParameterList()
Definition: Tempus_StepperBackwardEuler_impl.hpp:340
Tempus::StepperBackwardEuler::getDefaultStepperState
virtual Teuchos::RCP< Tempus::StepperState< Scalar > > getDefaultStepperState()
Get a default (initial) StepperState.
Definition: Tempus_StepperBackwardEuler_impl.hpp:247
Tempus_StepperFactory.hpp
Tempus::StepperBackwardEuler::computeStepResidual
virtual void computeStepResidual(Thyra::VectorBase< Scalar > &residual, const Teuchos::Array< Teuchos::RCP< const Thyra::VectorBase< Scalar > > > &x, const Teuchos::Array< Scalar > &t, const Thyra::VectorBase< Scalar > &p, const int param_index) const
Compute time step residual.
Definition: Tempus_StepperBackwardEuler_impl.hpp:366
Tempus::StepperBackwardEuler::setParameterList
void setParameterList(const Teuchos::RCP< Teuchos::ParameterList > &pl)
Definition: Tempus_StepperBackwardEuler_impl.hpp:274