Tempus  Version of the Day
Time Integration
Tempus_StepperHHTAlpha_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_StepperHHTAlpha_impl_hpp
10 #define Tempus_StepperHHTAlpha_impl_hpp
11 
12 #include "Tempus_config.hpp"
13 #include "Tempus_StepperFactory.hpp"
14 #include "Teuchos_VerboseObjectParameterListHelpers.hpp"
15 #include "NOX_Thyra.H"
16 
17 //#define VERBOSE_DEBUG_OUTPUT
18 //#define DEBUG_OUTPUT
19 
20 namespace Tempus {
21 
22 // Forward Declaration for recursive includes (this Stepper <--> StepperFactory)
23 template<class Scalar> class StepperFactory;
24 
25 template<class Scalar>
26 void StepperHHTAlpha<Scalar>::
27 predictVelocity(Thyra::VectorBase<Scalar>& vPred,
28  const Thyra::VectorBase<Scalar>& v,
29  const Thyra::VectorBase<Scalar>& a,
30  const Scalar dt) const
31 {
32 #ifdef VERBOSE_DEBUG_OUTPUT
33  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
34 #endif
35  //vPred = v + dt*(1.0-gamma_)*a
36  Thyra::V_StVpStV(Teuchos::ptrFromRef(vPred), 1.0, v, dt*(1.0-gamma_), a);
37 }
38 
39 template<class Scalar>
40 void StepperHHTAlpha<Scalar>::
41 predictDisplacement(Thyra::VectorBase<Scalar>& dPred,
42  const Thyra::VectorBase<Scalar>& d,
43  const Thyra::VectorBase<Scalar>& v,
44  const Thyra::VectorBase<Scalar>& a,
45  const Scalar dt) const
46 {
47 #ifdef VERBOSE_DEBUG_OUTPUT
48  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
49 #endif
50  Teuchos::RCP<const Thyra::VectorBase<Scalar> > tmp =
51  Thyra::createMember<Scalar>(dPred.space());
52  //dPred = dt*v + dt*dt/2.0*(1.0-2.0*beta_)*a
53  Scalar aConst = dt*dt/2.0*(1.0-2.0*beta_);
54  Thyra::V_StVpStV(Teuchos::ptrFromRef(dPred), dt, v, aConst, a);
55  //dPred += d;
56  Thyra::Vp_V(Teuchos::ptrFromRef(dPred), d, 1.0);
57 }
58 
59 
60 template<class Scalar>
61 void StepperHHTAlpha<Scalar>::
62 predictVelocity_alpha_f(Thyra::VectorBase<Scalar>& vPred,
63  const Thyra::VectorBase<Scalar>& v) const
64 {
65 #ifdef VERBOSE_DEBUG_OUTPUT
66  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
67 #endif
68  //vPred = (1-alpha_f)*vPred + alpha_f*v
69  Thyra::V_StVpStV(Teuchos::ptrFromRef(vPred), 1.0-alpha_f_, vPred, alpha_f_, v);
70 }
71 
72 
73 template<class Scalar>
74 void StepperHHTAlpha<Scalar>::
75 predictDisplacement_alpha_f(Thyra::VectorBase<Scalar>& dPred,
76  const Thyra::VectorBase<Scalar>& d) const
77 {
78 #ifdef VERBOSE_DEBUG_OUTPUT
79  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
80 #endif
81  //dPred = (1-alpha_f)*dPred + alpha_f*d
82  Thyra::V_StVpStV(Teuchos::ptrFromRef(dPred), 1.0-alpha_f_, dPred, alpha_f_, d);
83 }
84 
85 template<class Scalar>
86 void StepperHHTAlpha<Scalar>::
87 correctAcceleration(Thyra::VectorBase<Scalar>& a_n_plus1,
88  const Thyra::VectorBase<Scalar>& a_n) const
89 {
90 #ifdef VERBOSE_DEBUG_OUTPUT
91  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
92 #endif
93  Scalar c = 1.0/(1.0-alpha_m_);
94  //a_n_plus1 = 1.0/(1.0-alpha_m_)*a_n_plus1 - alpha_m/(1.0-alpha_m)*a_n = (1-alpha_f)*vPred + alpha_f*v
95  Thyra::V_StVpStV(Teuchos::ptrFromRef(a_n_plus1), c, a_n_plus1, -c*alpha_m_, a_n);
96 }
97 
98 
99 
100 template<class Scalar>
101 void StepperHHTAlpha<Scalar>::
102 correctVelocity(Thyra::VectorBase<Scalar>& v,
103  const Thyra::VectorBase<Scalar>& vPred,
104  const Thyra::VectorBase<Scalar>& a,
105  const Scalar dt) const
106 {
107 #ifdef VERBOSE_DEBUG_OUTPUT
108  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
109 #endif
110  //v = vPred + dt*gamma_*a
111  Thyra::V_StVpStV(Teuchos::ptrFromRef(v), 1.0, vPred, dt*gamma_, a);
112 }
113 
114 template<class Scalar>
115 void StepperHHTAlpha<Scalar>::
116 correctDisplacement(Thyra::VectorBase<Scalar>& d,
117  const Thyra::VectorBase<Scalar>& dPred,
118  const Thyra::VectorBase<Scalar>& a,
119  const Scalar dt) const
120 {
121 #ifdef VERBOSE_DEBUG_OUTPUT
122  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
123 #endif
124  //d = dPred + beta_*dt*dt*a
125  Thyra::V_StVpStV(Teuchos::ptrFromRef(d), 1.0, dPred, beta_*dt*dt, a);
126 }
127 
128 
129 template<class Scalar>
130 StepperHHTAlpha<Scalar>::StepperHHTAlpha(
131  const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel,
132  Teuchos::RCP<Teuchos::ParameterList> pList) :
133  out_(Teuchos::VerboseObjectBase::getDefaultOStream())
134 {
135 #ifdef VERBOSE_DEBUG_OUTPUT
136  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
137 #endif
138  using Teuchos::RCP;
139  using Teuchos::ParameterList;
140 
141  // Set all the input parameters and call initialize
142  this->setParameterList(pList);
143  this->setModel(appModel);
144  this->initialize();
145 }
146 
147 
148 template<class Scalar>
149 void StepperHHTAlpha<Scalar>::setModel(
150  const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel)
151 {
152 #ifdef VERBOSE_DEBUG_OUTPUT
153  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
154 #endif
155  this->validSecondOrderODE_DAE(appModel);
156  Teuchos::RCP<WrapperModelEvaluatorSecondOrder<Scalar> > wrapperModel =
157  Teuchos::rcp(new WrapperModelEvaluatorSecondOrder<Scalar>(appModel,
158  "HHT-Alpha"));
159  this->wrapperModel_ = wrapperModel;
160 }
161 
162 
163 template<class Scalar>
164 void StepperHHTAlpha<Scalar>::initialize()
165 {
166  TEUCHOS_TEST_FOR_EXCEPTION( this->wrapperModel_ == Teuchos::null,
167  std::logic_error,
168  "Error - Need to set the model, setModel(), before calling "
169  "StepperHHTAlpha::initialize()\n");
170 
171 #ifdef VERBOSE_DEBUG_OUTPUT
172  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
173 #endif
174  this->setParameterList(this->stepperPL_);
175  this->setSolver();
176 }
177 
178 
179 template<class Scalar>
180 void StepperHHTAlpha<Scalar>::takeStep(
181  const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory)
182 {
183 #ifdef VERBOSE_DEBUG_OUTPUT
184  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
185 #endif
186  using Teuchos::RCP;
187 
188  TEMPUS_FUNC_TIME_MONITOR("Tempus::StepperHHTAlpha::takeStep()");
189  {
190  TEUCHOS_TEST_FOR_EXCEPTION(solutionHistory->getNumStates() < 2,
191  std::logic_error,
192  "Error - StepperHHTAlpha<Scalar>::takeStep(...)\n"
193  "Need at least two SolutionStates for HHTAlpha.\n"
194  " Number of States = " << solutionHistory->getNumStates() << "\n"
195  "Try setting in \"Solution History\" \"Storage Type\" = \"Undo\"\n"
196  " or \"Storage Type\" = \"Static\" and \"Storage Limit\" = \"2\"\n");
197 
198  RCP<SolutionState<Scalar> > workingState=solutionHistory->getWorkingState();
199  RCP<SolutionState<Scalar> > currentState=solutionHistory->getCurrentState();
200 
201  Teuchos::RCP<WrapperModelEvaluatorSecondOrder<Scalar> > wrapperModel =
202  Teuchos::rcp_dynamic_cast<WrapperModelEvaluatorSecondOrder<Scalar> >(
203  this->wrapperModel_);
204 
205  //Get values of d, v and a from previous step
206  RCP<const Thyra::VectorBase<Scalar> > d_old = currentState->getX();
207  RCP<const Thyra::VectorBase<Scalar> > v_old = currentState->getXDot();
208  RCP<Thyra::VectorBase<Scalar> > a_old = currentState->getXDotDot();
209 
210 #ifdef DEBUG_OUTPUT
211  //IKT, 3/21/17, debug output: pring d_old, v_old, a_old to check for
212  // correctness.
213  *out_ << "IKT d_old = " << Thyra::max(*d_old) << "\n";
214  *out_ << "IKT v_old = " << Thyra::max(*v_old) << "\n";
215 #endif
216 
217  //Get new values of d, v and a from current workingState
218  //(to be updated here)
219  RCP<Thyra::VectorBase<Scalar> > d_new = workingState->getX();
220  RCP<Thyra::VectorBase<Scalar> > v_new = workingState->getXDot();
221  RCP<Thyra::VectorBase<Scalar> > a_new = workingState->getXDotDot();
222 
223  //Get time and dt
224  const Scalar time = currentState->getTime();
225  const Scalar dt = workingState->getTimeStep();
226  //Update time
227  Scalar t = time+dt;
228 
229  //Compute initial acceleration, a_old, using initial displacement (d_old) and initial
230  //velocity (v_old) if in 1st time step
231  if (time == solutionHistory->minTime()) {
232  RCP<Thyra::VectorBase<Scalar> > d_init = Thyra::createMember(d_old->space());
233  RCP<Thyra::VectorBase<Scalar> > v_init = Thyra::createMember(v_old->space());
234  RCP<Thyra::VectorBase<Scalar> > a_init = Thyra::createMember(a_old->space());
235  Thyra::copy(*d_old, d_init.ptr());
236  Thyra::copy(*v_old, v_init.ptr());
237  if (initial_guess_ != Teuchos::null) { //set initial guess for Newton, if provided
238  //Throw an exception if initial_guess is not compatible with solution
239  bool is_compatible = (a_init->space())->isCompatible(*initial_guess_->space());
240  TEUCHOS_TEST_FOR_EXCEPTION(
241  is_compatible != true, std::logic_error,
242  "Error in Tempus::NemwarkImplicitAForm takeStep(): user-provided initial guess'!\n"
243  << "for Newton is not compatible with solution vector!\n");
244  Thyra::copy(*initial_guess_, a_init.ptr());
245  }
246  else { //if no initial_guess_ provide, set 0 initial guess
247  Thyra::put_scalar(0.0, a_init.ptr());
248  }
249  wrapperModel->initializeNewmark(v_init,d_init,0.0,time,beta_,gamma_);
250  const Thyra::SolveStatus<Scalar> sStatus=this->solveImplicitODE(a_init);
251 
252  if (sStatus.solveStatus == Thyra::SOLVE_STATUS_CONVERGED )
253  workingState->setSolutionStatus(Status::PASSED);
254  else
255  workingState->setSolutionStatus(Status::FAILED);
256  Thyra::copy(*a_init, a_old.ptr());
257  }
258 #ifdef DEBUG_OUTPUT
259  //IKT, 3/30/17, debug output: pring a_old to check for correctness.
260  *out_ << "IKT a_old = " << Thyra::max(*a_old) << "\n";
261 #endif
262 
263 
264  //allocate d and v predictors
265  RCP<Thyra::VectorBase<Scalar> > d_pred =Thyra::createMember(d_old->space());
266  RCP<Thyra::VectorBase<Scalar> > v_pred =Thyra::createMember(v_old->space());
267 
268  //compute displacement and velocity predictors
269  predictDisplacement(*d_pred, *d_old, *v_old, *a_old, dt);
270  predictVelocity(*v_pred, *v_old, *a_old, dt);
271 
272  //compute second displacement and velocity predictors (those that are functions of alpha_f)
273  predictDisplacement_alpha_f(*d_pred, *d_old);
274  predictVelocity_alpha_f(*v_pred, *v_old);
275 
276  //inject d_pred, v_pred, a and other relevant data into wrapperModel
277  wrapperModel->initializeNewmark(v_pred,d_pred,dt,t,beta_,gamma_);
278 
279  //Solve for new acceleration
280  const Thyra::SolveStatus<Scalar> sStatus = this->solveImplicitODE(a_new);
281 
282  //correct acceleration (function of alpha_m)
283  correctAcceleration(*a_new, *a_old);
284 
285  //correct velocity and displacement
286  correctVelocity(*v_new, *v_pred, *a_new, dt);
287  correctDisplacement(*d_new, *d_pred, *a_new, dt);
288 
289  if (sStatus.solveStatus == Thyra::SOLVE_STATUS_CONVERGED )
290  workingState->setSolutionStatus(Status::PASSED);
291  else
292  workingState->setSolutionStatus(Status::FAILED);
293  workingState->setOrder(this->getOrder());
294  }
295  return;
296 }
297 
298 
299 
300 /** \brief Provide a StepperState to the SolutionState.
301  * This Stepper does not have any special state data,
302  * so just provide the base class StepperState with the
303  * Stepper description. This can be checked to ensure
304  * that the input StepperState can be used by this Stepper.
305  */
306 template<class Scalar>
307 Teuchos::RCP<Tempus::StepperState<Scalar> >
308 StepperHHTAlpha<Scalar>::
309 getDefaultStepperState()
310 {
311 #ifdef VERBOSE_DEBUG_OUTPUT
312  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
313 #endif
314  Teuchos::RCP<Tempus::StepperState<Scalar> > stepperState =
315  rcp(new StepperState<Scalar>(description()));
316  return stepperState;
317 }
318 
319 
320 template<class Scalar>
321 std::string StepperHHTAlpha<Scalar>::description() const
322 {
323 #ifdef VERBOSE_DEBUG_OUTPUT
324  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
325 #endif
326  std::string name = "HHT-Alpha";
327  return(name);
328 }
329 
330 
331 template<class Scalar>
332 void StepperHHTAlpha<Scalar>::describe(
333  Teuchos::FancyOStream &out,
334  const Teuchos::EVerbosityLevel verbLevel) const
335 {
336 #ifdef VERBOSE_DEBUG_OUTPUT
337  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
338 #endif
339  out << description() << "::describe:" << std::endl
340  << "wrapperModel_ = " << this->wrapperModel_->description() << std::endl;
341 }
342 
343 
344 template <class Scalar>
345 void StepperHHTAlpha<Scalar>::setParameterList(
346  Teuchos::RCP<Teuchos::ParameterList> const& pList)
347 {
348 #ifdef VERBOSE_DEBUG_OUTPUT
349  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
350 #endif
351  if (pList == Teuchos::null) {
352  // Create default parameters if null, otherwise keep current parameters.
353  if (this->stepperPL_ == Teuchos::null) this->stepperPL_ = this->getDefaultParameters();
354  } else {
355  this->stepperPL_ = pList;
356  }
357  // Can not validate because of optional Parameters.
358  //stepperPL_->validateParametersAndSetDefaults(*this->getValidParameters());
359  //Get beta and gamma from parameter list
360  //IKT, FIXME: does parameter list get validated somewhere? validateParameters above is commented out...
361 
362  Teuchos::RCP<Teuchos::ParameterList> stepperPL = this->stepperPL_;
363  std::string stepperType = stepperPL->get<std::string>("Stepper Type");
364  TEUCHOS_TEST_FOR_EXCEPTION( stepperType != "HHT-Alpha",
365  std::logic_error,
366  "\nError - Stepper Type is not 'HHT-Alpha'!\n" << "Stepper Type = "
367  << stepperPL->get<std::string>("Stepper Type") << "\n");
368  beta_ = 0.25; //default value
369  gamma_ = 0.5; //default value
370  //IKT, FIXME: test this scheme for alpha_f and alpha_m != 0.0.
371  //Once that is done, logic should be changed to allow user to select
372  //these options from the parameter list.
373  alpha_f_ = 0.0; //default value. Hard-coded for Newmark-Beta for now.
374  alpha_m_ = 0.0; //default value. Hard-coded for Newmark-Beta for now.
375  Teuchos::RCP<Teuchos::FancyOStream> out =
376  Teuchos::VerboseObjectBase::getDefaultOStream();
377  if (this->stepperPL_->isSublist("HHT-Alpha Parameters")) {
378  Teuchos::ParameterList &HHTalphaPL =
379  this->stepperPL_->sublist("HHT-Alpha Parameters", true);
380  std::string scheme_name = HHTalphaPL.get("Scheme Name", "Not Specified");
381  alpha_m_ = HHTalphaPL.get("Alpha_m", 0.0);
382  alpha_f_ = HHTalphaPL.get("Alpha_f", 0.0);
383  TEUCHOS_TEST_FOR_EXCEPTION( (alpha_m_ >= 1.0) || (alpha_m_ < 0.0),
384  std::logic_error,
385  "\nError in 'HHT-Alpha' stepper: invalid value of Alpha_m = "
386  << alpha_m_ << ". Please select Alpha_m >= 0 and < 1. \n");
387  TEUCHOS_TEST_FOR_EXCEPTION( (alpha_f_ > 1.0) || (alpha_f_ < 0.0),
388  std::logic_error,
389  "\nError in 'HHT-Alpha' stepper: invalid value of Alpha_f = "
390  << alpha_f_ << ". Please select Alpha_f >= 0 and <= 1. \n");
391  TEUCHOS_TEST_FOR_EXCEPTION( (alpha_m_ != 0.0) || (alpha_f_ != 0.0),
392  std::logic_error,
393  "\nError - 'HHT-Alpha' stepper has not been verified yet for "
394  "Alpha_m, Alpha_f != 0! \n" << "You have specified Alpha_m = "
395  << alpha_m_ << ", Alpha_f = " << alpha_f_ <<".\n");
396  if (scheme_name == "Newmark Beta") {
397  beta_ = HHTalphaPL.get("Beta", 0.25);
398  gamma_ = HHTalphaPL.get("Gamma", 0.5);
399  TEUCHOS_TEST_FOR_EXCEPTION( (beta_ > 1.0) || (beta_ < 0.0),
400  std::logic_error,
401  "\nError in 'HHT-Alpha' stepper: invalid value of Beta = "
402  << beta_ << ". Please select Beta >= 0 and <= 1. \n");
403  TEUCHOS_TEST_FOR_EXCEPTION( (gamma_ > 1.0) || (gamma_ < 0.0),
404  std::logic_error,
405  "\nError in 'HHT-Alpha' stepper: invalid value of Gamma = "
406  <<gamma_ << ". Please select Gamma >= 0 and <= 1. \n");
407  *out << "\n \nScheme Name = Newmark Beta. Setting Alpha_f = "
408  << "Alpha_m = 0. Setting \n" << "Beta = " << beta_
409  << " and Gamma = " << gamma_
410  << " from HHT-Alpha Parameters in input file.\n\n";
411  }
412  else {
413  *out << "\n \nScheme Name = " << scheme_name
414  << ". Using values of Alpha_m, Alpha_f, \n"
415  << "Beta and Gamma for this scheme (ignoring values of "
416  << "Alpha_m, Alpha_f, Beta and Gamma \n"
417  << "in input file, if provided).\n";
418  if (scheme_name == "Newmark Beta Average Acceleration") {
419  beta_ = 0.25; gamma_ = 0.5;
420  }
421  else if (scheme_name == "Newmark Beta Linear Acceleration") {
422  beta_ = 0.25; gamma_ = 1.0/6.0;
423  }
424  else if (scheme_name == "Newmark Beta Central Difference") {
425  beta_ = 0.0; gamma_ = 0.5;
426  }
427  else {
428  TEUCHOS_TEST_FOR_EXCEPTION(true,
429  std::logic_error,
430  "\nError in Tempus::StepperHHTAlpha! Invalid Scheme Name = "
431  << scheme_name <<". \n"
432  <<"Valid Scheme Names are: 'Newmark Beta', 'Newmark Beta "
433  <<"Average Acceleration', \n"
434  <<"'Newmark Beta Linear Acceleration', and 'Newmark Beta "
435  <<"Central Difference'.\n");
436  }
437  *out << "===> Alpha_m = " << alpha_m_ << ", Alpha_f = " << alpha_f_
438  << ", Beta = " << beta_ << ", Gamma = " << gamma_ << "\n";
439  }
440  if (beta_ == 0.0) {
441  *out << "\n \nRunning HHT-Alpha Stepper with Beta = 0.0, which \n"
442  << "specifies an explicit scheme. WARNING: code has not been "
443  << "optimized \nyet for this case (no mass lumping)\n";
444  }
445  }
446  else {
447  *out << "\n \nNo HHT-Alpha Parameters sublist found in input file; "
448  << "using default values of Beta = "
449  << beta_ << " and Gamma = " << gamma_ << ".\n\n";
450  }
451 }
452 
453 
454 template<class Scalar>
455 Teuchos::RCP<const Teuchos::ParameterList>
456 StepperHHTAlpha<Scalar>::getValidParameters() const
457 {
458 #ifdef VERBOSE_DEBUG_OUTPUT
459  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
460 #endif
461  Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
462  pl->setName("Default Stepper - " + this->description());
463  pl->set("Stepper Type", this->description());
464  pl->set("Zero Initial Guess", false);
465  pl->set("Solver Name", "",
466  "Name of ParameterList containing the solver specifications.");
467 
468  return pl;
469 }
470 template<class Scalar>
471 Teuchos::RCP<Teuchos::ParameterList>
472 StepperHHTAlpha<Scalar>::getDefaultParameters() const
473 {
474 #ifdef VERBOSE_DEBUG_OUTPUT
475  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
476 #endif
477  using Teuchos::RCP;
478  using Teuchos::ParameterList;
479 
480  RCP<ParameterList> pl = Teuchos::parameterList();
481  pl->setName("Default Stepper - " + this->description());
482  pl->set<std::string>("Stepper Type", this->description());
483  pl->set<bool> ("Zero Initial Guess", false);
484  pl->set<std::string>("Solver Name", "Default Solver");
485 
486  RCP<ParameterList> solverPL = this->defaultSolverParameters();
487  pl->set("Default Solver", *solverPL);
488 
489  return pl;
490 }
491 
492 
493 template <class Scalar>
494 Teuchos::RCP<Teuchos::ParameterList>
495 StepperHHTAlpha<Scalar>::getNonconstParameterList()
496 {
497 #ifdef VERBOSE_DEBUG_OUTPUT
498  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
499 #endif
500  return(this->stepperPL_);
501 }
502 
503 
504 template <class Scalar>
505 Teuchos::RCP<Teuchos::ParameterList>
506 StepperHHTAlpha<Scalar>::unsetParameterList()
507 {
508 #ifdef VERBOSE_DEBUG_OUTPUT
509  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
510 #endif
511  Teuchos::RCP<Teuchos::ParameterList> temp_plist = this->stepperPL_;
512  this->stepperPL_ = Teuchos::null;
513  return(temp_plist);
514 }
515 
516 
517 } // namespace Tempus
518 #endif // Tempus_StepperHHTAlpha_impl_hpp
Tempus::StepperState
StepperState is a simple class to hold state information about the stepper.
Definition: Tempus_StepperState.hpp:36
Tempus::StepperHHTAlpha::takeStep
virtual void takeStep(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Take the specified timestep, dt, and return true if successful.
Definition: Tempus_StepperHHTAlpha_impl.hpp:180
Tempus::StepperHHTAlpha::describe
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
Definition: Tempus_StepperHHTAlpha_impl.hpp:332
Tempus::solutionHistory
Teuchos::RCP< SolutionHistory< Scalar > > solutionHistory(Teuchos::RCP< Teuchos::ParameterList > pList=Teuchos::null)
Nonmember constructor.
Definition: Tempus_SolutionHistory_impl.hpp:504
Tempus::StepperHHTAlpha::unsetParameterList
Teuchos::RCP< Teuchos::ParameterList > unsetParameterList()
Definition: Tempus_StepperHHTAlpha_impl.hpp:506
Tempus::StepperHHTAlpha::getDefaultParameters
Teuchos::RCP< Teuchos::ParameterList > getDefaultParameters() const
Definition: Tempus_StepperHHTAlpha_impl.hpp:472
Tempus
Definition: Tempus_AdjointAuxSensitivityModelEvaluator_decl.hpp:20
Tempus::StepperHHTAlpha::correctVelocity
void correctVelocity(Thyra::VectorBase< Scalar > &v, const Thyra::VectorBase< Scalar > &vPred, const Thyra::VectorBase< Scalar > &a, const Scalar dt) const
Definition: Tempus_StepperHHTAlpha_impl.hpp:102
Tempus::StepperHHTAlpha::predictDisplacement
void predictDisplacement(Thyra::VectorBase< Scalar > &dPred, const Thyra::VectorBase< Scalar > &d, const Thyra::VectorBase< Scalar > &v, const Thyra::VectorBase< Scalar > &a, const Scalar dt) const
Definition: Tempus_StepperHHTAlpha_impl.hpp:41
Tempus::StepperHHTAlpha::predictDisplacement_alpha_f
void predictDisplacement_alpha_f(Thyra::VectorBase< Scalar > &dPred, const Thyra::VectorBase< Scalar > &d) const
Definition: Tempus_StepperHHTAlpha_impl.hpp:75
Tempus::StepperHHTAlpha::getValidParameters
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const
Definition: Tempus_StepperHHTAlpha_impl.hpp:456
Tempus::StepperHHTAlpha::predictVelocity
void predictVelocity(Thyra::VectorBase< Scalar > &vPred, const Thyra::VectorBase< Scalar > &v, const Thyra::VectorBase< Scalar > &a, const Scalar dt) const
Definition: Tempus_StepperHHTAlpha_impl.hpp:27
Tempus::StepperHHTAlpha::getDefaultStepperState
virtual Teuchos::RCP< Tempus::StepperState< Scalar > > getDefaultStepperState()
Get a default (initial) StepperState.
Definition: Tempus_StepperHHTAlpha_impl.hpp:309
Tempus::WrapperModelEvaluatorSecondOrder
A ModelEvaluator for residual evaluations given a state. This ModelEvaluator takes a state,...
Definition: Tempus_WrapperModelEvaluatorSecondOrder_decl.hpp:32
Tempus::StepperHHTAlpha::out_
Teuchos::RCP< Teuchos::FancyOStream > out_
Definition: Tempus_StepperHHTAlpha_decl.hpp:144
Tempus::StepperHHTAlpha::correctDisplacement
void correctDisplacement(Thyra::VectorBase< Scalar > &d, const Thyra::VectorBase< Scalar > &dPred, const Thyra::VectorBase< Scalar > &a, const Scalar dt) const
Definition: Tempus_StepperHHTAlpha_impl.hpp:116
Tempus::PASSED
Definition: Tempus_Types.hpp:17
Tempus::StepperHHTAlpha::setModel
virtual void setModel(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &appModel)
Definition: Tempus_StepperHHTAlpha_impl.hpp:149
Tempus::StepperHHTAlpha::StepperHHTAlpha
StepperHHTAlpha()
Default Constructor – not allowed.
Tempus::SolutionHistory
SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of...
Definition: Tempus_Integrator.hpp:25
Tempus::StepperHHTAlpha::description
virtual std::string description() const
Definition: Tempus_StepperHHTAlpha_impl.hpp:321
Tempus::FAILED
Definition: Tempus_Types.hpp:18
Tempus::StepperHHTAlpha::predictVelocity_alpha_f
void predictVelocity_alpha_f(Thyra::VectorBase< Scalar > &vPred, const Thyra::VectorBase< Scalar > &v) const
Definition: Tempus_StepperHHTAlpha_impl.hpp:62
Tempus::StepperHHTAlpha::getNonconstParameterList
Teuchos::RCP< Teuchos::ParameterList > getNonconstParameterList()
Definition: Tempus_StepperHHTAlpha_impl.hpp:495
Tempus::StepperHHTAlpha::correctAcceleration
void correctAcceleration(Thyra::VectorBase< Scalar > &a_n_plus1, const Thyra::VectorBase< Scalar > &a_n) const
Definition: Tempus_StepperHHTAlpha_impl.hpp:87
Tempus_StepperFactory.hpp
Teuchos
Definition: Tempus_Integrator.hpp:19
Tempus::StepperHHTAlpha::initialize
virtual void initialize()
Initialize during construction and after changing input parameters.
Definition: Tempus_StepperHHTAlpha_impl.hpp:164
Tempus::StepperHHTAlpha::setParameterList
void setParameterList(const Teuchos::RCP< Teuchos::ParameterList > &pl)
Definition: Tempus_StepperHHTAlpha_impl.hpp:345