Tempus  Version of the Day
Time Integration
Tempus_StepperNewmarkImplicitAForm_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_StepperNewmarkImplicitAForm_impl_hpp
10 #define Tempus_StepperNewmarkImplicitAForm_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 StepperNewmarkImplicitAForm<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 StepperNewmarkImplicitAForm<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 template<class Scalar>
60 void StepperNewmarkImplicitAForm<Scalar>::
61 correctVelocity(Thyra::VectorBase<Scalar>& v,
62  const Thyra::VectorBase<Scalar>& vPred,
63  const Thyra::VectorBase<Scalar>& a,
64  const Scalar dt) const
65 {
66 #ifdef VERBOSE_DEBUG_OUTPUT
67  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
68 #endif
69  //v = vPred + dt*gamma_*a
70  Thyra::V_StVpStV(Teuchos::ptrFromRef(v), 1.0, vPred, dt*gamma_, a);
71 }
72 
73 template<class Scalar>
74 void StepperNewmarkImplicitAForm<Scalar>::
75 correctDisplacement(Thyra::VectorBase<Scalar>& d,
76  const Thyra::VectorBase<Scalar>& dPred,
77  const Thyra::VectorBase<Scalar>& a,
78  const Scalar dt) const
79 {
80 #ifdef VERBOSE_DEBUG_OUTPUT
81  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
82 #endif
83  //d = dPred + beta_*dt*dt*a
84  Thyra::V_StVpStV(Teuchos::ptrFromRef(d), 1.0, dPred, beta_*dt*dt, a);
85 }
86 
87 
88 template<class Scalar>
89 StepperNewmarkImplicitAForm<Scalar>::StepperNewmarkImplicitAForm(
90  const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel,
91  Teuchos::RCP<Teuchos::ParameterList> pList) :
92  out_(Teuchos::VerboseObjectBase::getDefaultOStream())
93 {
94 #ifdef VERBOSE_DEBUG_OUTPUT
95  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
96 #endif
97  using Teuchos::RCP;
98  using Teuchos::ParameterList;
99 
100  // Set all the input parameters and call initialize
101  this->setParameterList(pList);
102  this->setModel(appModel);
103  this->initialize();
104 }
105 
106 
107 template<class Scalar>
108 void StepperNewmarkImplicitAForm<Scalar>::setModel(
109  const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel)
110 {
111 #ifdef VERBOSE_DEBUG_OUTPUT
112  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
113 #endif
114  this->validSecondOrderODE_DAE(appModel);
115  Teuchos::RCP<WrapperModelEvaluatorSecondOrder<Scalar> > wrapperModel =
116  Teuchos::rcp(new WrapperModelEvaluatorSecondOrder<Scalar>(appModel,
117  "Newmark Implicit a-Form"));
118  this->wrapperModel_ = wrapperModel;
119  inArgs_ = this->wrapperModel_->getNominalValues();
120  outArgs_ = this->wrapperModel_->createOutArgs();
121 }
122 
123 
124 template<class Scalar>
125 void StepperNewmarkImplicitAForm<Scalar>::initialize()
126 {
127  TEUCHOS_TEST_FOR_EXCEPTION( this->wrapperModel_ == Teuchos::null,
128  std::logic_error,
129  "Error - Need to set the model, setModel(), before calling "
130  "StepperNewmarkImplicitAForm::initialize()\n");
131 
132 #ifdef VERBOSE_DEBUG_OUTPUT
133  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
134 #endif
135  this->setParameterList(this->stepperPL_);
136  this->setSolver();
137 }
138 
139 
140 template<class Scalar>
141 void StepperNewmarkImplicitAForm<Scalar>::takeStep(
142  const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory)
143 {
144 #ifdef VERBOSE_DEBUG_OUTPUT
145  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
146 #endif
147  using Teuchos::RCP;
148 
149  TEMPUS_FUNC_TIME_MONITOR("Tempus::StepperNewmarkImplicitAForm::takeStep()");
150  {
151  TEUCHOS_TEST_FOR_EXCEPTION(solutionHistory->getNumStates() < 2,
152  std::logic_error,
153  "Error - StepperNewmarkImplicitAForm<Scalar>::takeStep(...)\n"
154  "Need at least two SolutionStates for NewmarkImplicitAForm.\n"
155  " Number of States = " << solutionHistory->getNumStates() << "\n"
156  "Try setting in \"Solution History\" \"Storage Type\" = \"Undo\"\n"
157  " or \"Storage Type\" = \"Static\" and \"Storage Limit\" = \"2\"\n");
158 
159  RCP<SolutionState<Scalar> > workingState=solutionHistory->getWorkingState();
160  RCP<SolutionState<Scalar> > currentState=solutionHistory->getCurrentState();
161 
162  Teuchos::RCP<WrapperModelEvaluatorSecondOrder<Scalar> > wrapperModel =
163  Teuchos::rcp_dynamic_cast<WrapperModelEvaluatorSecondOrder<Scalar> >(
164  this->wrapperModel_);
165 
166  //Get values of d, v and a from previous step
167  RCP<const Thyra::VectorBase<Scalar> > d_old = currentState->getX();
168  RCP<const Thyra::VectorBase<Scalar> > v_old = currentState->getXDot();
169  //RCP<const Thyra::VectorBase<Scalar> > a_old = currentState->getXDotDot();
170  RCP<Thyra::VectorBase<Scalar> > a_old = currentState->getXDotDot();
171 
172 #ifdef DEBUG_OUTPUT
173  //IKT, 3/21/17, debug output: pring d_old, v_old to check for
174  // correctness.
175  *out_ << "IKT d_old = " << Thyra::max(*d_old) << "\n";
176  *out_ << "IKT v_old = " << Thyra::max(*v_old) << "\n";
177 #endif
178 
179  //Get new values of d, v and a from current workingState
180  //(to be updated here)
181  RCP<Thyra::VectorBase<Scalar> > d_new = workingState->getX();
182  RCP<Thyra::VectorBase<Scalar> > v_new = workingState->getXDot();
183  RCP<Thyra::VectorBase<Scalar> > a_new = workingState->getXDotDot();
184 
185  //Get time and dt
186  const Scalar time = currentState->getTime();
187  const Scalar dt = workingState->getTimeStep();
188  //Update time
189  Scalar t = time+dt;
190 
191  //Compute initial acceleration, a_old, using initial displacement (d_old) and initial
192  //velocity (v_old) if in 1st time step
193  if (time == solutionHistory->minTime()) {
194  RCP<Thyra::VectorBase<Scalar> > d_init = Thyra::createMember(d_old->space());
195  RCP<Thyra::VectorBase<Scalar> > v_init = Thyra::createMember(v_old->space());
196  RCP<Thyra::VectorBase<Scalar> > a_init = Thyra::createMember(a_old->space());
197  Thyra::copy(*d_old, d_init.ptr());
198  Thyra::copy(*v_old, v_init.ptr());
199  if (initial_guess_ != Teuchos::null) { //set initial guess for Newton, if provided
200  //Throw an exception if initial_guess is not compatible with solution
201  bool is_compatible = (a_init->space())->isCompatible(*initial_guess_->space());
202  TEUCHOS_TEST_FOR_EXCEPTION(
203  is_compatible != true, std::logic_error,
204  "Error in Tempus::NemwarkImplicitAForm takeStep(): user-provided initial guess'!\n"
205  << "for Newton is not compatible with solution vector!\n");
206  Thyra::copy(*initial_guess_, a_init.ptr());
207  }
208  else { //if no initial_guess_ provide, set 0 initial guess
209  Thyra::put_scalar(0.0, a_init.ptr());
210  }
211  wrapperModel->initializeNewmark(v_init,d_init,0.0,time,beta_,gamma_);
212  const Thyra::SolveStatus<Scalar> sStatus =
213  this->solveImplicitODE(a_init);
214 
215  if (sStatus.solveStatus == Thyra::SOLVE_STATUS_CONVERGED )
216  workingState->setSolutionStatus(Status::PASSED);
217  else
218  workingState->setSolutionStatus(Status::FAILED);
219  Thyra::copy(*a_init, a_old.ptr());
220  }
221 #ifdef DEBUG_OUTPUT
222  //IKT, 3/30/17, debug output: pring a_old to check for correctness.
223  *out_ << "IKT a_old = " << Thyra::max(*a_old) << "\n";
224 #endif
225 
226 
227  //allocate d and v predictors
228  RCP<Thyra::VectorBase<Scalar> > d_pred =Thyra::createMember(d_old->space());
229  RCP<Thyra::VectorBase<Scalar> > v_pred =Thyra::createMember(v_old->space());
230 
231  //compute displacement and velocity predictors
232  predictDisplacement(*d_pred, *d_old, *v_old, *a_old, dt);
233  predictVelocity(*v_pred, *v_old, *a_old, dt);
234 
235  //inject d_pred, v_pred, a and other relevant data into wrapperModel
236  wrapperModel->initializeNewmark(v_pred,d_pred,dt,t,beta_,gamma_);
237 
238  //Solve nonlinear system with a_old as initial guess
239  const Thyra::SolveStatus<Scalar> sStatus = this->solveImplicitODE(a_old);
240 
241  if (sStatus.solveStatus == Thyra::SOLVE_STATUS_CONVERGED )
242  workingState->setSolutionStatus(Status::PASSED);
243  else
244  workingState->setSolutionStatus(Status::FAILED);
245 
246  //solveImplicitODE will return converged solution in a_old. Copy
247  //it here to a_new, the new acceleration.
248  Thyra::copy(*a_old, a_new.ptr());
249 
250  //Correct velocity, displacement.
251  correctVelocity(*v_new, *v_pred, *a_new, dt);
252  correctDisplacement(*d_new, *d_pred, *a_new, dt);
253 
254  workingState->setOrder(this->getOrder());
255  }
256  return;
257 }
258 
259 
260 
261 /** \brief Provide a StepperState to the SolutionState.
262  * This Stepper does not have any special state data,
263  * so just provide the base class StepperState with the
264  * Stepper description. This can be checked to ensure
265  * that the input StepperState can be used by this Stepper.
266  */
267 template<class Scalar>
268 Teuchos::RCP<Tempus::StepperState<Scalar> >
269 StepperNewmarkImplicitAForm<Scalar>::
270 getDefaultStepperState()
271 {
272 #ifdef VERBOSE_DEBUG_OUTPUT
273  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
274 #endif
275  Teuchos::RCP<Tempus::StepperState<Scalar> > stepperState =
276  rcp(new StepperState<Scalar>(description()));
277  return stepperState;
278 }
279 
280 
281 template<class Scalar>
282 std::string StepperNewmarkImplicitAForm<Scalar>::description() const
283 {
284 #ifdef VERBOSE_DEBUG_OUTPUT
285  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
286 #endif
287  std::string name = "Newmark Implicit a-Form";
288  return(name);
289 }
290 
291 
292 template<class Scalar>
293 void StepperNewmarkImplicitAForm<Scalar>::describe(
294  Teuchos::FancyOStream &out,
295  const Teuchos::EVerbosityLevel verbLevel) const
296 {
297 #ifdef VERBOSE_DEBUG_OUTPUT
298  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
299 #endif
300  out << description() << "::describe:" << std::endl
301  << "wrapperModel = " << this->wrapperModel_->description() << std::endl;
302 }
303 
304 
305 template <class Scalar>
306 void StepperNewmarkImplicitAForm<Scalar>::setParameterList(
307  Teuchos::RCP<Teuchos::ParameterList> const& pList)
308 {
309 #ifdef VERBOSE_DEBUG_OUTPUT
310  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
311 #endif
312  if (pList == Teuchos::null) {
313  // Create default parameters if null, otherwise keep current parameters.
314  if (this->stepperPL_ == Teuchos::null) this->stepperPL_ = this->getDefaultParameters();
315  } else {
316  this->stepperPL_ = pList;
317  }
318  // Can not validate because of optional Parameters.
319  //stepperPL_->validateParametersAndSetDefaults(*this->getValidParameters());
320  //Get beta and gamma from parameter list
321  //IKT, FIXME: does parameter list get validated somewhere? validateParameters above is commented out...
322 
323  Teuchos::RCP<Teuchos::ParameterList> stepperPL = this->stepperPL_;
324  std::string stepperType = stepperPL->get<std::string>("Stepper Type");
325  TEUCHOS_TEST_FOR_EXCEPTION( stepperType != "Newmark Implicit a-Form",
326  std::logic_error,
327  "Error - Stepper Type is not 'Newmark Implicit a-Form'!\n"
328  << " Stepper Type = "<< stepperPL->get<std::string>("Stepper Type")
329  << "\n");
330  beta_ = 0.25; //default value
331  gamma_ = 0.5; //default value
332  Teuchos::VerboseObjectBase::getDefaultOStream();
333  if (this->stepperPL_->isSublist("Newmark Parameters")) {
334  Teuchos::ParameterList &newmarkPL =
335  this->stepperPL_->sublist("Newmark Parameters", true);
336  std::string scheme_name = newmarkPL.get("Scheme Name", "Not Specified");
337  if (scheme_name == "Not Specified") {
338  beta_ = newmarkPL.get("Beta", 0.25);
339  gamma_ = newmarkPL.get("Gamma", 0.5);
340  TEUCHOS_TEST_FOR_EXCEPTION( (beta_ > 1.0) || (beta_ < 0.0),
341  std::logic_error,
342  "\nError in 'Newmark Implicit a-Form' stepper: invalid value of Beta = "
343  << beta_ << ". Please select Beta >= 0 and <= 1. \n");
344  TEUCHOS_TEST_FOR_EXCEPTION( (gamma_ > 1.0) || (gamma_ < 0.0),
345  std::logic_error,
346  "\nError in 'Newmark Implicit a-Form' stepper: invalid value of Gamma ="
347  <<gamma_ << ". Please select Gamma >= 0 and <= 1. \n");
348  *out_ << "\nSetting Beta = " << beta_ << " and Gamma = " << gamma_
349  << " from Newmark Parameters in input file.\n";
350  }
351  else {
352  *out_ << "\nScheme Name = " << scheme_name << ". Using values \n"
353  << "of Beta and Gamma for this scheme (ignoring values of "
354  << "Beta and Gamma \n"
355  << "in input file, if provided).\n";
356  if (scheme_name == "Average Acceleration") {
357  beta_ = 0.25; gamma_ = 0.5;
358  }
359  else if (scheme_name == "Linear Acceleration") {
360  beta_ = 0.25; gamma_ = 1.0/6.0;
361  }
362  else if (scheme_name == "Central Difference") {
363  beta_ = 0.0; gamma_ = 0.5;
364  }
365  else {
366  TEUCHOS_TEST_FOR_EXCEPTION(true,
367  std::logic_error,
368  "\nError in Tempus::StepperNewmarkImplicitAForm! "
369  <<"Invalid Scheme Name = " << scheme_name <<". \n"
370  <<"Valid Scheme Names are: 'Average Acceleration', "
371  <<"'Linear Acceleration', \n"
372  <<"'Central Difference' and 'Not Specified'.\n");
373  }
374  *out_ << "===> Beta = " << beta_ << ", Gamma = " << gamma_ << "\n";
375  }
376  if (beta_ == 0.0) {
377  *out_ << "\nWARNING: Running (implicit implementation of) Newmark "
378  << "Implicit a-Form Stepper with Beta = 0.0, which \n"
379  << "specifies an explicit scheme. Mass lumping is not possible, "
380  << "so this will be slow! To run explicit \n"
381  << "implementation of Newmark Implicit a-Form Stepper, please "
382  << "re-run with 'Stepper Type' = 'Newmark Explicit a-Form'.\n"
383  << "This stepper allows for mass lumping when called through "
384  << "Piro::TempusSolver.\n";
385  }
386  }
387  else {
388  *out_ << "\nNo Newmark Parameters sublist found in input file; using "
389  << "default values of Beta = "
390  << beta_ << " and Gamma = " << gamma_ << ".\n";
391  }
392 }
393 
394 
395 template<class Scalar>
396 Teuchos::RCP<const Teuchos::ParameterList>
397 StepperNewmarkImplicitAForm<Scalar>::getValidParameters() const
398 {
399 #ifdef VERBOSE_DEBUG_OUTPUT
400  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
401 #endif
402  Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
403  pl->setName("Default Stepper - " + this->description());
404  pl->set("Stepper Type", this->description());
405  pl->set("Zero Initial Guess", false);
406  pl->set("Solver Name", "",
407  "Name of ParameterList containing the solver specifications.");
408 
409  return pl;
410 }
411 template<class Scalar>
412 Teuchos::RCP<Teuchos::ParameterList>
413 StepperNewmarkImplicitAForm<Scalar>::getDefaultParameters() const
414 {
415 #ifdef VERBOSE_DEBUG_OUTPUT
416  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
417 #endif
418  using Teuchos::RCP;
419  using Teuchos::ParameterList;
420 
421  RCP<ParameterList> pl = Teuchos::parameterList();
422  pl->setName("Default Stepper - " + this->description());
423  pl->set<std::string>("Stepper Type", this->description());
424  pl->set<bool> ("Zero Initial Guess", false);
425  pl->set<std::string>("Solver Name", "Default Solver");
426 
427  RCP<ParameterList> solverPL = this->defaultSolverParameters();
428  pl->set("Default Solver", *solverPL);
429 
430  return pl;
431 }
432 
433 
434 template <class Scalar>
435 Teuchos::RCP<Teuchos::ParameterList>
436 StepperNewmarkImplicitAForm<Scalar>::getNonconstParameterList()
437 {
438 #ifdef VERBOSE_DEBUG_OUTPUT
439  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
440 #endif
441  return(this->stepperPL_);
442 }
443 
444 
445 template <class Scalar>
446 Teuchos::RCP<Teuchos::ParameterList>
447 StepperNewmarkImplicitAForm<Scalar>::unsetParameterList()
448 {
449 #ifdef VERBOSE_DEBUG_OUTPUT
450  *out_ << "DEBUG: " << __PRETTY_FUNCTION__ << "\n";
451 #endif
452  Teuchos::RCP<Teuchos::ParameterList> temp_plist = this->stepperPL_;
453  this->stepperPL_ = Teuchos::null;
454  return(temp_plist);
455 }
456 
457 
458 } // namespace Tempus
459 #endif // Tempus_StepperNewmarkImplicitAForm_impl_hpp
Tempus::StepperState
StepperState is a simple class to hold state information about the stepper.
Definition: Tempus_StepperState.hpp:36
Tempus::StepperNewmarkImplicitAForm::getNonconstParameterList
Teuchos::RCP< Teuchos::ParameterList > getNonconstParameterList()
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:436
Tempus::solutionHistory
Teuchos::RCP< SolutionHistory< Scalar > > solutionHistory(Teuchos::RCP< Teuchos::ParameterList > pList=Teuchos::null)
Nonmember constructor.
Definition: Tempus_SolutionHistory_impl.hpp:504
Tempus::StepperNewmarkImplicitAForm::initialize
virtual void initialize()
Initialize during construction and after changing input parameters.
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:125
Tempus
Definition: Tempus_AdjointAuxSensitivityModelEvaluator_decl.hpp:20
Tempus::StepperNewmarkImplicitAForm::predictVelocity
void predictVelocity(Thyra::VectorBase< Scalar > &vPred, const Thyra::VectorBase< Scalar > &v, const Thyra::VectorBase< Scalar > &a, const Scalar dt) const
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:27
Tempus::StepperNewmarkImplicitAForm::correctDisplacement
void correctDisplacement(Thyra::VectorBase< Scalar > &d, const Thyra::VectorBase< Scalar > &dPred, const Thyra::VectorBase< Scalar > &a, const Scalar dt) const
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:75
Tempus::StepperNewmarkImplicitAForm::getDefaultStepperState
virtual Teuchos::RCP< Tempus::StepperState< Scalar > > getDefaultStepperState()
Get a default (initial) StepperState.
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:270
Tempus::StepperNewmarkImplicitAForm::takeStep
virtual void takeStep(const Teuchos::RCP< SolutionHistory< Scalar > > &solutionHistory)
Take the specified timestep, dt, and return true if successful.
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:141
Tempus::StepperNewmarkImplicitAForm::StepperNewmarkImplicitAForm
StepperNewmarkImplicitAForm()
Default Constructor – not allowed.
Tempus::WrapperModelEvaluatorSecondOrder
A ModelEvaluator for residual evaluations given a state. This ModelEvaluator takes a state,...
Definition: Tempus_WrapperModelEvaluatorSecondOrder_decl.hpp:32
Tempus::StepperNewmarkImplicitAForm::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_StepperNewmarkImplicitAForm_impl.hpp:41
Tempus::StepperNewmarkImplicitAForm::out_
Teuchos::RCP< Teuchos::FancyOStream > out_
Definition: Tempus_StepperNewmarkImplicitAForm_decl.hpp:139
Tempus::StepperNewmarkImplicitAForm::setModel
virtual void setModel(const Teuchos::RCP< const Thyra::ModelEvaluator< Scalar > > &appModel)
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:108
Tempus::PASSED
Definition: Tempus_Types.hpp:17
Tempus::StepperNewmarkImplicitAForm::setParameterList
void setParameterList(const Teuchos::RCP< Teuchos::ParameterList > &pl)
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:306
Tempus::SolutionHistory
SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of...
Definition: Tempus_Integrator.hpp:25
Tempus::StepperNewmarkImplicitAForm::unsetParameterList
Teuchos::RCP< Teuchos::ParameterList > unsetParameterList()
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:447
Tempus::FAILED
Definition: Tempus_Types.hpp:18
Tempus::StepperNewmarkImplicitAForm::getValidParameters
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters() const
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:397
Tempus::StepperNewmarkImplicitAForm::correctVelocity
void correctVelocity(Thyra::VectorBase< Scalar > &v, const Thyra::VectorBase< Scalar > &vPred, const Thyra::VectorBase< Scalar > &a, const Scalar dt) const
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:61
Tempus_StepperFactory.hpp
Teuchos
Definition: Tempus_Integrator.hpp:19
Tempus::StepperNewmarkImplicitAForm::description
virtual std::string description() const
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:282
Tempus::StepperNewmarkImplicitAForm::getDefaultParameters
Teuchos::RCP< Teuchos::ParameterList > getDefaultParameters() const
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:413
Tempus::StepperNewmarkImplicitAForm::describe
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
Definition: Tempus_StepperNewmarkImplicitAForm_impl.hpp:293