Tempus  Version of the Day
Time Integration
Tempus_SolutionState_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_SolutionState_impl_hpp
10 #define Tempus_SolutionState_impl_hpp
11 
12 #include "Thyra_VectorStdOps.hpp"
13 
14 namespace Tempus {
15 
16 
17 template<class Scalar>
18 SolutionState<Scalar>::SolutionState(
19  const Teuchos::RCP<Thyra::VectorBase<Scalar> >& x,
20  const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdot,
21  const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdotdot,
22  const Teuchos::RCP<StepperState<Scalar> >& stepperState,
23  const Teuchos::RCP<PhysicsState<Scalar> >& physicsState)
24  : x_ (x),
25  x_nc_ (x),
26  xdot_ (xdot),
27  xdot_nc_ (xdot),
28  xdotdot_ (xdotdot),
29  xdotdot_nc_ (xdotdot),
30  stepperState_ (stepperState),
31  stepperState_nc_(stepperState),
32  physicsState_ (physicsState),
33  physicsState_nc_(physicsState)
34 {
35  metaData_nc_ = Teuchos::rcp(new SolutionStateMetaData<Scalar>());
36  metaData_ = metaData_nc_;
37  if (stepperState_nc_ == Teuchos::null) {
38  stepperState_nc_ = Teuchos::rcp(new StepperState<Scalar>("Default"));
39  stepperState_ = stepperState_nc_;
40  }
41  if (physicsState_nc_ == Teuchos::null) {
42  physicsState_nc_ = Teuchos::rcp(new PhysicsState<Scalar> ());
43  physicsState_ = physicsState_nc_;
44  }
45 }
46 
47 template<class Scalar>
48 SolutionState<Scalar>::SolutionState(
49  const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& x,
50  const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdot,
51  const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdotdot,
52  const Teuchos::RCP<const StepperState<Scalar> >& stepperState,
53  const Teuchos::RCP<const PhysicsState<Scalar> >& physicsState)
54  : x_ (x),
55  x_nc_ (Teuchos::null),
56  xdot_ (xdot),
57  xdot_nc_ (Teuchos::null),
58  xdotdot_ (xdotdot),
59  xdotdot_nc_ (Teuchos::null),
60  stepperState_ (Teuchos::null),
61  stepperState_nc_(Teuchos::null),
62  physicsState_ (Teuchos::null),
63  physicsState_nc_(Teuchos::null)
64 {
65  metaData_nc_ = Teuchos::rcp(new SolutionStateMetaData<Scalar>());
66  metaData_ = metaData_nc_;
67  stepperState_nc_ = Teuchos::rcp(new StepperState<Scalar>("Default"));
68  stepperState_ = stepperState_nc_;
69  physicsState_nc_ = Teuchos::rcp(new PhysicsState<Scalar> ());
70  physicsState_ = physicsState_nc_;
71 }
72 
73 
74 template<class Scalar>
75 SolutionState<Scalar>::SolutionState(
76  const Teuchos::RCP<SolutionStateMetaData<Scalar> > metaData,
77  const Teuchos::RCP<Thyra::VectorBase<Scalar> >& x,
78  const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdot,
79  const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdotdot,
80  const Teuchos::RCP<StepperState<Scalar> >& stepperState,
81  const Teuchos::RCP<PhysicsState<Scalar> >& physicsState)
82  : metaData_ (metaData),
83  metaData_nc_ (metaData),
84  x_ (x),
85  x_nc_ (x),
86  xdot_ (xdot),
87  xdot_nc_ (xdot),
88  xdotdot_ (xdotdot),
89  xdotdot_nc_ (xdotdot),
90  stepperState_ (stepperState),
91  stepperState_nc_(stepperState),
92  physicsState_ (physicsState),
93  physicsState_nc_(physicsState)
94 {
95  if (stepperState_nc_ == Teuchos::null) {
96  stepperState_nc_ = Teuchos::rcp(new StepperState<Scalar>("Default"));
97  stepperState_ = stepperState_nc_;
98  }
99  if (physicsState_nc_ == Teuchos::null) {
100  physicsState_nc_ = Teuchos::rcp(new PhysicsState<Scalar> ());
101  physicsState_ = physicsState_nc_;
102  }
103 }
104 
105 template<class Scalar>
106 SolutionState<Scalar>::SolutionState(
107  const Teuchos::RCP<const SolutionStateMetaData<Scalar> > metaData,
108  const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& x,
109  const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdot,
110  const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdotdot,
111  const Teuchos::RCP<const StepperState<Scalar> >& stepperState,
112  const Teuchos::RCP<const PhysicsState<Scalar> >& physicsState)
113  : metaData_ (metaData),
114  metaData_nc_ (Teuchos::null),
115  x_ (x),
116  x_nc_ (Teuchos::null),
117  xdot_ (xdot),
118  xdot_nc_ (Teuchos::null),
119  xdotdot_ (xdotdot),
120  xdotdot_nc_ (Teuchos::null),
121  stepperState_ (stepperState),
122  stepperState_nc_(Teuchos::null),
123  physicsState_ (physicsState),
124  physicsState_nc_(Teuchos::null)
125 {
126  if (stepperState_ == Teuchos::null) {
127  stepperState_nc_ = Teuchos::rcp(new StepperState<Scalar>("Default"));
128  stepperState_ = stepperState_nc_;
129  }
130  if (physicsState_ == Teuchos::null) {
131  physicsState_nc_ = Teuchos::rcp(new PhysicsState<Scalar> ());
132  physicsState_ = physicsState_nc_;
133  }
134 }
135 
136 
137 template<class Scalar>
138 SolutionState<Scalar>::SolutionState(
139  const Scalar time,
140  const Scalar dt,
141  const int iStep,
142  const Scalar errorAbs,
143  const Scalar errorRel,
144  const int order,
145  const int nFailures,
146  const int nRunningFailures,
147  const int nConsecutiveFailures,
148  const Status solutionStatus,
149  const bool output,
150  const bool outputScreen,
151  const bool isSynced,
152  const bool isInterpolated,
153  const Scalar accuracy,
154  const Teuchos::RCP<Thyra::VectorBase<Scalar> >& x,
155  const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdot,
156  const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xdotdot,
157  const Teuchos::RCP<StepperState<Scalar> >& stepperState,
158  const Teuchos::RCP<PhysicsState<Scalar> >& physicsState)
159  : x_ (x),
160  x_nc_ (x),
161  xdot_ (xdot),
162  xdot_nc_ (xdot),
163  xdotdot_ (xdotdot),
164  xdotdot_nc_ (xdotdot),
165  stepperState_ (stepperState),
166  stepperState_nc_(stepperState),
167  physicsState_ (physicsState),
168  physicsState_nc_(physicsState)
169 {
170  metaData_nc_ =
171  Teuchos::rcp(new SolutionStateMetaData<Scalar> (time,
172  iStep,
173  dt,
174  errorAbs,
175  errorRel,
176  order,
177  nFailures,
178  nRunningFailures,
179  nConsecutiveFailures,
180  solutionStatus,
181  output,
182  outputScreen,
183  isSynced,
184  isInterpolated,
185  accuracy));
186  metaData_ = metaData_nc_;
187 
188  if (stepperState_nc_ == Teuchos::null) {
189  stepperState_nc_ = Teuchos::rcp(new StepperState<Scalar>("Default"));
190  stepperState_ = stepperState_nc_;
191  }
192  if (physicsState_nc_ == Teuchos::null) {
193  physicsState_nc_ = Teuchos::rcp(new PhysicsState<Scalar> ());
194  physicsState_ = physicsState_nc_;
195  }
196 }
197 
198 template<class Scalar>
199 SolutionState<Scalar>::SolutionState(
200  const Scalar time,
201  const Scalar dt,
202  const int iStep,
203  const Scalar errorAbs,
204  const Scalar errorRel,
205  const int order,
206  const int nFailures,
207  const int nRunningFailures,
208  const int nConsecutiveFailures,
209  const Status solutionStatus,
210  const bool output,
211  const bool outputScreen,
212  const bool isSynced,
213  const bool isInterpolated,
214  const Scalar accuracy,
215  const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& x,
216  const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdot,
217  const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& xdotdot,
218  const Teuchos::RCP<const StepperState<Scalar> >& stepperState,
219  const Teuchos::RCP<const PhysicsState<Scalar> >& physicsState)
220  : x_ (x),
221  x_nc_ (Teuchos::null),
222  xdot_ (xdot),
223  xdot_nc_ (Teuchos::null),
224  xdotdot_ (xdotdot),
225  xdotdot_nc_ (Teuchos::null),
226  stepperState_ (stepperState),
227  stepperState_nc_(Teuchos::null),
228  physicsState_ (physicsState),
229  physicsState_nc_(Teuchos::null)
230 {
231  metaData_nc_ =
232  Teuchos::rcp(new SolutionStateMetaData<Scalar> (time,
233  iStep,
234  dt,
235  errorAbs,
236  errorRel,
237  order,
238  nFailures,
239  nRunningFailures,
240  nConsecutiveFailures,
241  solutionStatus,
242  output,
243  outputScreen,
244  isSynced,
245  isInterpolated,
246  accuracy));
247  metaData_ = metaData_nc_;
248 
249  if (stepperState_ == Teuchos::null) {
250  stepperState_nc_ = Teuchos::rcp(new StepperState<Scalar>("Default"));
251  stepperState_ = stepperState_nc_;
252  }
253  if (physicsState_ == Teuchos::null) {
254  physicsState_nc_ = Teuchos::rcp(new PhysicsState<Scalar> ());
255  physicsState_ = physicsState_nc_;
256  }
257 }
258 
259 template<class Scalar>
260 SolutionState<Scalar>::SolutionState(
261  const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model,
262  const Teuchos::RCP<StepperState<Scalar> >& stepperState,
263  const Teuchos::RCP<PhysicsState<Scalar> >& physicsState)
264 {
265  typedef Thyra::ModelEvaluatorBase MEB;
266  using Teuchos::rcp_const_cast;
267 
268  metaData_nc_ = Teuchos::rcp(new SolutionStateMetaData<Scalar>());
269  metaData_nc_->setSolutionStatus(Status::PASSED);
270  metaData_ = metaData_nc_;
271 
272  MEB::InArgs<Scalar> inArgs = model->getNominalValues();
273 
274  // The solution vector, x, is required (usually).
275  x_nc_ = rcp_const_cast<Thyra::VectorBase<Scalar> > (inArgs.get_x());
276  x_ = x_nc_;
277 
278  // The solution derivative, xdot, can be optional provided, based on
279  // application needs. Here we will base it on "supports" IN_ARG_x_dot.
280  // Depending on the stepper used, a temporary xdot vector may be created
281  // within the Stepper, but not moved to the SolutionState.
282  if (inArgs.supports(MEB::IN_ARG_x_dot)) {
283  xdot_nc_ = rcp_const_cast<Thyra::VectorBase<Scalar> >(inArgs.get_x_dot());
284  xdot_ = xdot_nc_;
285  } else {
286  xdot_nc_ = Teuchos::null;
287  xdot_ = xdot_nc_;
288  }
289 
290  // Similar as xdot.
291  if (inArgs.supports(MEB::IN_ARG_x_dot_dot)) {
292  xdotdot_nc_ =
293  rcp_const_cast<Thyra::VectorBase<Scalar> > (inArgs.get_x_dot_dot());
294  xdotdot_ = xdotdot_nc_;
295  } else {
296  xdotdot_nc_ = Teuchos::null;
297  xdotdot_ = xdotdot_nc_;
298  }
299 
300  if (stepperState_ == Teuchos::null) {
301  stepperState_nc_ = Teuchos::rcp(new StepperState<Scalar> ()); // Use default
302  stepperState_ = stepperState_nc_;
303  } else {
304  stepperState_nc_ = stepperState;
305  stepperState_ = stepperState;
306  }
307 
308  if (physicsState_ == Teuchos::null) {
309  physicsState_nc_ = Teuchos::rcp(new PhysicsState<Scalar> ()); // Use default
310  physicsState_ = physicsState_nc_;
311  } else {
312  physicsState_nc_ = physicsState;
313  physicsState_ = physicsState;
314  }
315 }
316 
317 template<class Scalar>
318 SolutionState<Scalar>::SolutionState(const SolutionState<Scalar>& ss_)
319  :metaData_ (ss_.metaData_),
320  metaData_nc_ (ss_.metaData_nc_),
321  x_ (ss_.x_),
322  x_nc_ (ss_.x_nc_),
323  xdot_ (ss_.xdot_),
324  xdot_nc_ (ss_.xdot_nc_),
325  xdotdot_ (ss_.xdotdot_),
326  xdotdot_nc_ (ss_.xdotdot_nc_),
327  stepperState_ (ss_.stepperState_),
328  stepperState_nc_(ss_.stepperState_nc_),
329  physicsState_ (ss_.physicsState_),
330  physicsState_nc_(ss_.physicsState_nc_)
331 {}
332 
333 
334 template<class Scalar>
335 Teuchos::RCP<SolutionState<Scalar> > SolutionState<Scalar>::clone() const
336 {
337  using Teuchos::RCP;
338 
339  RCP<SolutionStateMetaData<Scalar> > metaData_out;
340  if (!Teuchos::is_null(metaData_)) metaData_out = metaData_->clone();
341 
342  RCP<Thyra::VectorBase<Scalar> > x_out;
343  if (!Teuchos::is_null(x_)) x_out = x_->clone_v();
344 
345  RCP<Thyra::VectorBase<Scalar> > xdot_out;
346  if (!Teuchos::is_null(xdot_)) xdot_out = xdot_->clone_v();
347 
348  RCP<Thyra::VectorBase<Scalar> > xdotdot_out;
349  if (!Teuchos::is_null(xdotdot_)) xdotdot_out = xdotdot_->clone_v();
350 
351  RCP<StepperState<Scalar> > sS_out;
352  if (!Teuchos::is_null(stepperState_)) sS_out=stepperState_->clone();
353 
354  RCP<PhysicsState<Scalar> > pS_out;
355  if (!Teuchos::is_null(physicsState_)) pS_out=physicsState_->clone();
356 
357  RCP<SolutionState<Scalar> > ss_out = Teuchos::rcp(new SolutionState<Scalar> (
358  metaData_out, x_out, xdot_out, xdotdot_out, sS_out, pS_out));
359 
360  return ss_out;
361 }
362 
363 
364 template<class Scalar>
365 void SolutionState<Scalar>::
366 copy(const Teuchos::RCP<const SolutionState<Scalar> >& ss)
367 {
368  metaData_nc_->copy(ss->metaData_);
369  this->copySolutionData(ss);
370 }
371 
372 
373 template<class Scalar>
374 void SolutionState<Scalar>::
375 copySolutionData(const Teuchos::RCP<const SolutionState<Scalar> >& ss)
376 {
377  Thyra::V_V(x_nc_.ptr(), *(ss->x_));
378  if (ss->xdot_ == Teuchos::null) xdot_nc_ = Teuchos::null;
379  else Thyra::V_V(xdot_nc_.ptr(), *(ss->xdot_));
380  if (ss->xdotdot_ == Teuchos::null) xdotdot_nc_ = Teuchos::null;
381  else Thyra::V_V(xdotdot_nc_.ptr(), *(ss->xdotdot_));
382  stepperState_nc_->copy(ss->stepperState_);
383  physicsState_nc_->copy(ss->physicsState_);
384 }
385 
386 template<class Scalar>
387 void SolutionState<Scalar>::
388 swapSolutionData(const Teuchos::RCP<SolutionState<Scalar> >& ss)
389 {
390  Teuchos::RCP<const Thyra::VectorBase<Scalar> > temp;
391  temp = x_;
392  x_ = ss->x_;
393  ss->x_ = temp;
394 
395  temp = xdot_;
396  xdot_ = ss->xdot_;
397  ss->xdot_ = temp;
398 
399  temp = xdotdot_;
400  xdotdot_ = ss->xdotdot_;
401  ss->xdotdot_ = temp;
402 
403  Teuchos::RCP<Thyra::VectorBase<Scalar> > temp_nc;
404  temp_nc = x_nc_;
405  x_nc_ = ss->x_nc_;
406  ss->x_nc_ = temp_nc;
407 
408  temp_nc = xdot_nc_;
409  xdot_nc_ = ss->xdot_nc_;
410  ss->xdot_nc_ = temp_nc;
411 
412  temp_nc = xdotdot_nc_;
413  xdotdot_nc_ = ss->xdotdot_nc_;
414  ss->xdotdot_nc_ = temp_nc;
415 
416  Teuchos::RCP<const StepperState< Scalar > > ssTemp = stepperState_;
417  stepperState_ = ss->stepperState_;
418  ss->stepperState_ = ssTemp;
419 
420  Teuchos::RCP<StepperState< Scalar > > ssTemp_nc = stepperState_nc_;
421  stepperState_nc_ = ss->stepperState_nc_;
422  ss->stepperState_nc_ = ssTemp_nc;
423 
424  Teuchos::RCP<const PhysicsState< Scalar > > psTemp = physicsState_;
425  physicsState_ = ss->physicsState_;
426  ss->physicsState_ = psTemp;
427 
428  Teuchos::RCP<PhysicsState< Scalar > > psTemp_nc = physicsState_nc_;
429  physicsState_nc_ = ss->physicsState_nc_;
430  ss->physicsState_nc_ = psTemp_nc;
431 }
432 
433 
434 template<class Scalar>
435 bool SolutionState<Scalar>::operator< (const SolutionState<Scalar>& ss) const
436 {
437  return (this->metaData_->getTime() < ss.metaData_->getTime());
438 }
439 
440 template<class Scalar>
441 bool SolutionState<Scalar>::operator<= (const SolutionState<Scalar>& ss) const
442 {
443  return (this->metaData_->getTime() <= ss.metaData_->getTime());
444 }
445 
446 template<class Scalar>
447 bool SolutionState<Scalar>::operator< (const Scalar& t) const
448 {
449  return (this->metaData_->getTime() < t);
450 }
451 
452 template<class Scalar>
453 bool SolutionState<Scalar>::operator<= (const Scalar& t) const
454 {
455  return (this->metaData_->getTime() <= t);
456 }
457 
458 template<class Scalar>
459 bool SolutionState<Scalar>::operator> (const SolutionState<Scalar>& ss) const
460 {
461  return (this->metaData_->getTime() > ss.metaData_->getTime());
462 }
463 
464 template<class Scalar>
465 bool SolutionState<Scalar>::operator>= (const SolutionState<Scalar>& ss) const
466 {
467  return (this->metaData_->getTime() >= ss.metaData_->getTime());
468 }
469 
470 template<class Scalar>
471 bool SolutionState<Scalar>::operator> (const Scalar& t) const
472 {
473  return (this->metaData_->getTime() > t);
474 }
475 
476 template<class Scalar>
477 bool SolutionState<Scalar>::operator>= (const Scalar& t) const
478 {
479  return (this->metaData_->getTime() >= t);
480 }
481 
482 template<class Scalar>
483 bool SolutionState<Scalar>::operator== (const SolutionState<Scalar>& ss) const
484 {
485  return (this->metaData_->getTime() == ss.metaData_->getTime());
486 }
487 
488 template<class Scalar>
489 bool SolutionState<Scalar>::operator== (const Scalar& t) const
490 {
491  return (this->metaData_->getTime() == t);
492 }
493 
494 template<class Scalar>
495 std::string SolutionState<Scalar>::description() const
496 {
497  std::string name = "Tempus::SolutionState";
498  return (name);
499 }
500 
501 template<class Scalar>
502 void SolutionState<Scalar>::describe(
503  Teuchos::FancyOStream &out,
504  const Teuchos::EVerbosityLevel verbLevel) const
505 {
506  if (verbLevel == Teuchos::VERB_EXTREME) {
507  out << description() << "::describe:" << std::endl
508  << "metaData = " << std::endl;
509  metaData_->describe(out,verbLevel);
510  out << "x = " << std::endl;
511  x_->describe(out,verbLevel);
512  if (xdot_ != Teuchos::null) {
513  out << "xdot_ = " << std::endl;
514  xdot_->describe(out,verbLevel);
515  }
516  if (xdotdot_ != Teuchos::null) {
517  out << "xdotdot = " << std::endl;
518  xdotdot_->describe(out,verbLevel);
519  }
520  if (stepperState_ != Teuchos::null) {
521  out << "stepperState = " << std::endl;
522  stepperState_->describe(out,verbLevel);
523  }
524  if (physicsState_ != Teuchos::null) {
525  out << "stepperState = " << std::endl;
526  physicsState_->describe(out,verbLevel);
527  }
528  }
529 }
530 
531 } // namespace Tempus
532 #endif // Tempus_SolutionState_impl_hpp
Tempus::SolutionStateMetaData
Solution state meta data.
Definition: Tempus_SolutionStateMetaData_decl.hpp:24
Tempus::StepperState
StepperState is a simple class to hold state information about the stepper.
Definition: Tempus_StepperState.hpp:36
Tempus::SolutionState::swapSolutionData
virtual void swapSolutionData(const Teuchos::RCP< SolutionState< Scalar > > &ss)
Swap solution data, but keep metaData untouched.
Definition: Tempus_SolutionState_impl.hpp:388
Tempus::SolutionState::metaData_nc_
Teuchos::RCP< SolutionStateMetaData< Scalar > > metaData_nc_
Definition: Tempus_SolutionState_decl.hpp:283
Tempus::SolutionState::clone
virtual Teuchos::RCP< SolutionState< Scalar > > clone() const
This is a deep copy constructor.
Definition: Tempus_SolutionState_impl.hpp:335
Tempus::SolutionState::stepperState_nc_
Teuchos::RCP< Tempus::StepperState< Scalar > > stepperState_nc_
Definition: Tempus_SolutionState_decl.hpp:299
Tempus::SolutionState::physicsState_nc_
Teuchos::RCP< Tempus::PhysicsState< Scalar > > physicsState_nc_
Definition: Tempus_SolutionState_decl.hpp:303
Tempus::SolutionState::operator<
bool operator<(const SolutionState< Scalar > &ss) const
Less than comparison for sorting based on time.
Definition: Tempus_SolutionState_impl.hpp:435
Tempus
Definition: Tempus_AdjointAuxSensitivityModelEvaluator_decl.hpp:20
Tempus::SolutionState::operator<=
bool operator<=(const SolutionState< Scalar > &ss) const
Less than comparison for sorting based on time.
Definition: Tempus_SolutionState_impl.hpp:441
Tempus::SolutionState::SolutionState
SolutionState(const Teuchos::RCP< Thyra::VectorBase< Scalar > > &x, const Teuchos::RCP< Thyra::VectorBase< Scalar > > &xdot=Teuchos::null, const Teuchos::RCP< Thyra::VectorBase< Scalar > > &xddot=Teuchos::null, const Teuchos::RCP< StepperState< Scalar > > &stepperState=Teuchos::null, const Teuchos::RCP< PhysicsState< Scalar > > &physicsState=Teuchos::null)
Definition: Tempus_SolutionState_impl.hpp:18
Tempus::SolutionState::stepperState_
Teuchos::RCP< const Tempus::StepperState< Scalar > > stepperState_
StepperState for this SolutionState.
Definition: Tempus_SolutionState_decl.hpp:298
Tempus::SolutionState::physicsState_
Teuchos::RCP< const Tempus::PhysicsState< Scalar > > physicsState_
PhysicsState for this SolutionState.
Definition: Tempus_SolutionState_decl.hpp:302
Tempus::SolutionState::operator>=
bool operator>=(const SolutionState< Scalar > &ss) const
Less than comparison for sorting based on time.
Definition: Tempus_SolutionState_impl.hpp:465
Tempus::SolutionState
Solution state for integrators and steppers. SolutionState contains the metadata for solutions and th...
Definition: Tempus_SolutionState_decl.hpp:56
Tempus::SolutionState::describe
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
Definition: Tempus_SolutionState_impl.hpp:502
Tempus::SolutionState::copySolutionData
virtual void copySolutionData(const Teuchos::RCP< const SolutionState< Scalar > > &s)
Deep copy solution data, but keep metaData untouched.
Definition: Tempus_SolutionState_impl.hpp:375
Tempus::PASSED
Definition: Tempus_Types.hpp:17
Tempus::SolutionState::description
virtual std::string description() const
Definition: Tempus_SolutionState_impl.hpp:495
Tempus::SolutionState::operator>
bool operator>(const SolutionState< Scalar > &ss) const
Less than comparison for sorting based on time.
Definition: Tempus_SolutionState_impl.hpp:459
Tempus::SolutionState::copy
virtual void copy(const Teuchos::RCP< const SolutionState< Scalar > > &ss)
This is a deep copy.
Definition: Tempus_SolutionState_impl.hpp:366
Tempus::PhysicsState
PhysicsState is a simple class to hold information about the physics.
Definition: Tempus_PhysicsState_decl.hpp:36
Teuchos
Definition: Tempus_Integrator.hpp:19
Tempus::Status
Status
Status for the Integrator, the Stepper and the SolutionState.
Definition: Tempus_Types.hpp:16
Tempus::SolutionState::operator==
bool operator==(const SolutionState< Scalar > &ss) const
Equality comparison for matching.
Definition: Tempus_SolutionState_impl.hpp:483
Tempus::SolutionState::metaData_
Teuchos::RCP< const SolutionStateMetaData< Scalar > > metaData_
Meta Data for the solution state.
Definition: Tempus_SolutionState_decl.hpp:282