Rythmos - Transient Integration for Differential Equations  Version of the Day
 All Classes Functions Variables Typedefs Pages
Rythmos_InterpolationBuffer_def.hpp
1 //@HEADER
2 // ***********************************************************************
3 //
4 // Rythmos Package
5 // Copyright (2006) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // This library is free software; you can redistribute it and/or modify
11 // it under the terms of the GNU Lesser General Public License as
12 // published by the Free Software Foundation; either version 2.1 of the
13 // License, or (at your option) any later version.
14 //
15 // This library is distributed in the hope that it will be useful, but
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 // Lesser General Public License for more details.
19 //
20 // You should have received a copy of the GNU Lesser General Public
21 // License along with this library; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
23 // USA
24 // Questions? Contact Todd S. Coffey (tscoffe@sandia.gov)
25 //
26 // ***********************************************************************
27 //@HEADER
28 
29 #ifndef Rythmos_INTERPOLATION_BUFFER_DEF_H
30 #define Rythmos_INTERPOLATION_BUFFER_DEF_H
31 
32 #include "Rythmos_InterpolationBuffer_decl.hpp"
33 #include "Rythmos_InterpolatorBaseHelpers.hpp"
34 #include "Rythmos_LinearInterpolator.hpp"
35 #include "Thyra_VectorStdOps.hpp"
36 #include "Teuchos_StandardParameterEntryValidators.hpp"
37 #include "Teuchos_VerboseObjectParameterListHelpers.hpp"
38 
39 namespace {
40 
41  static std::string IBPolicyTypeInvalid_name = "Invalid Policy";
42  static std::string IBPolicyTypeStatic_name = "Static Policy";
43  static std::string IBPolicyTypeKeepNewest_name = "Keep Newest Policy";
44  static std::string interpolationBufferPolicySelection_name = "InterpolationBufferPolicy";
45  static std::string interpolationBufferPolicySelection_default = IBPolicyTypeKeepNewest_name;
46 
47  static std::string interpolationBufferStorageLimit_name = "StorageLimit";
48  static int interpolationBufferStorageLimit_default = 0;
49 
50  Teuchos::Array<std::string>
51  S_InterpolationBufferPolicyTypes = Teuchos::tuple<std::string>(
52  IBPolicyTypeInvalid_name,
53  IBPolicyTypeStatic_name,
54  IBPolicyTypeKeepNewest_name
55  );
56 
57  const Teuchos::RCP<Teuchos::StringToIntegralParameterEntryValidator<Rythmos::IBPolicy> >
58  interpolationBufferPolicyValidator = Teuchos::rcp(
59  new Teuchos::StringToIntegralParameterEntryValidator<Rythmos::IBPolicy>(
60  S_InterpolationBufferPolicyTypes,
61  Teuchos::tuple<Rythmos::IBPolicy>(
62  Rythmos::BUFFER_POLICY_INVALID,
63  Rythmos::BUFFER_POLICY_STATIC,
64  Rythmos::BUFFER_POLICY_KEEP_NEWEST
65  ),
66  interpolationBufferPolicySelection_name
67  )
68  );
69 
70 } // namespace
71 
72 
73 namespace Rythmos {
74 
75 // ////////////////////////////
76 // Defintions
77 
78 
79 template<class Scalar>
81 {
82  this->defaultInitializeAll_();
83  initialize(Teuchos::null,0);
84 }
85 
86 template<class Scalar>
88 {
89  interpolator_ = Teuchos::null;
90  storage_limit_ = -1;
91  data_vec_ = Teuchos::null;
92  paramList_ = Teuchos::null;
93  policy_ = BUFFER_POLICY_INVALID;
94 }
95 
96 template<class Scalar>
97 RCP<const Thyra::VectorSpaceBase<Scalar> >
99 {
100  if (data_vec_->size() == 0) {
101  RCP<const Thyra::VectorSpaceBase<Scalar> > space;
102  return(space);
103  } else {
104  return((*data_vec_)[0].x->space());
105  }
106 }
107 
108 
109 template<class Scalar>
111  const RCP<InterpolatorBase<Scalar> >& interpolator
112  ,int storage
113  )
114 {
115  RCP<Teuchos::FancyOStream> out = this->getOStream();
116  Teuchos::OSTab ostab(out,1,"IB::initialize");
117  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
118  *out << "Initializing InterpolationBuffer" << std::endl;
119  *out << "Calling setInterpolator..." << std::endl;
120  }
121  data_vec_ = rcp(new typename DataStore<Scalar>::DataStoreVector_t);
122  setInterpolator(interpolator);
123  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
124  *out << "Calling setStorage..." << std::endl;
125  }
126  setStorage(storage);
127  policy_ = BUFFER_POLICY_KEEP_NEWEST;
128 }
129 
130 template<class Scalar>
132 {
133  int storage_limit = std::max(2,storage); // Minimum of two points so interpolation is possible
134  TEUCHOS_TEST_FOR_EXCEPTION(
135  Teuchos::as<int>(data_vec_->size()) > storage_limit,
136  std::logic_error,
137  "Error, specified storage = " << storage_limit
138  << " is below current number of vectors stored = " << data_vec_->size() << "!\n"
139  );
140  storage_limit_ = storage_limit;
141  RCP<Teuchos::FancyOStream> out = this->getOStream();
142  Teuchos::OSTab ostab(out,1,"IB::setStorage");
143  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
144  *out << "storage_limit = " << storage_limit_ << std::endl;
145  }
146 }
147 
148 
149 template<class Scalar>
151 {
152  return(storage_limit_);
153 }
154 
155 
156 template<class Scalar>
158  const RCP<InterpolatorBase<Scalar> >& interpolator
159  )
160 {
161  if (interpolator == Teuchos::null) {
162  interpolator_ = linearInterpolator<Scalar>();
163  } else {
164  interpolator_ = interpolator;
165  }
166  RCP<Teuchos::FancyOStream> out = this->getOStream();
167  Teuchos::OSTab ostab(out,1,"IB::setInterpolator");
168  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
169  *out << "interpolator = " << interpolator_->description() << std::endl;
170  }
171 }
172 
173 template<class Scalar>
174 RCP<InterpolatorBase<Scalar> >
176 {
177  return interpolator_;
178 }
179 
180 template<class Scalar>
181 RCP<const InterpolatorBase<Scalar> >
183 {
184  return interpolator_;
185 }
186 
187 template<class Scalar>
188 RCP<InterpolatorBase<Scalar> > InterpolationBuffer<Scalar>::unSetInterpolator()
189 {
190  RCP<InterpolatorBase<Scalar> > old_interpolator = interpolator_;
191  interpolator_ = linearInterpolator<Scalar>();
192  return old_interpolator;
193 }
194 
195 
196 template<class Scalar>
198  const Array<Scalar>& time_vec
199  ,const Array<RCP<const Thyra::VectorBase<Scalar> > >& x_vec
200  ,const Array<RCP<const Thyra::VectorBase<Scalar> > >& xdot_vec
201  )
202 {
203 #ifdef HAVE_RYTHMOS_DEBUG
204  // Check preconditions
205  assertTimePointsAreSorted(time_vec);
206  int tsize = Teuchos::as<int>(time_vec.size());
207  TEUCHOS_TEST_FOR_EXCEPTION(
208  tsize == 0, std::logic_error,
209  "Error, time_vec is empty!"
210  );
211  TEUCHOS_TEST_FOR_EXCEPTION(
212  Teuchos::as<int>(x_vec.size()) != tsize, std::logic_error,
213  "Error, size of x_vec = " << x_vec.size() << " != " << tsize << " = size of time_vec!\n"
214  );
215  TEUCHOS_TEST_FOR_EXCEPTION(
216  Teuchos::as<int>(xdot_vec.size()) != tsize, std::logic_error,
217  "Error, size of xdot_vec = " << x_vec.size() << " != " << tsize << " = size of time_vec!\n"
218  );
219  for (int i=0; i<tsize ; ++i) {
220  TEUCHOS_TEST_FOR_EXCEPTION(
221  x_vec[i] == Teuchos::null, std::logic_error,
222  "Error, x_vec[" << i << "] == null!\n"
223  );
224 // TEUCHOS_TEST_FOR_EXCEPTION(
225 // xdot_vec[i] == Teuchos::null, std::logic_error,
226 // "Error, xdot_vec[" << i << "] == null!\n"
227 // );
228  }
229  assertNoTimePointsInsideCurrentTimeRange(*this,time_vec);
230 #endif // HAVE_RYTHMOS_DEBUG
231  RCP<Teuchos::FancyOStream> out = this->getOStream();
232  Teuchos::OSTab ostab(out,1,"IB::addPoints");
233  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
234  *out << "time_vec = " << std::endl;
235  for (Teuchos::Ordinal i=0 ; i<time_vec.size() ; ++i) {
236  *out << "time_vec[" << i << "] = " << time_vec[i] << std::endl;
237  }
238  *out << "x_vec = " << std::endl;
239  for (Teuchos::Ordinal i=0 ; i<x_vec.size() ; ++i) {
240  *out << "x_vec[" << i << "] = " << std::endl;
241  x_vec[i]->describe(*out,Teuchos::VERB_EXTREME);
242  }
243  *out << "xdot_vec = " << std::endl;
244  for (Teuchos::Ordinal i=0 ; i<xdot_vec.size() ; ++i) {
245  if (!is_null(xdot_vec[i])) {
246  *out << "xdot_vec[" << i << "] = " << std::endl;
247  xdot_vec[i]->describe(*out,Teuchos::VERB_EXTREME);
248  }
249  }
250  }
251  typename DataStore<Scalar>::DataStoreList_t input_data_list;
252  vectorToDataStoreList<Scalar>(time_vec,x_vec,xdot_vec,&input_data_list);
253  // Check that we're not going to exceed our storage limit:
254  if (Teuchos::as<int>(data_vec_->size()+input_data_list.size()) > storage_limit_) {
255  if (policy_ == BUFFER_POLICY_STATIC) {
256  TEUCHOS_TEST_FOR_EXCEPTION(
257  true, std::logic_error,
258  "Error, buffer would be over-full and buffer policy is BUFFER_POLICY_STATIC, these points can not be added\n"
259  );
260  } else if (policy_ == BUFFER_POLICY_KEEP_NEWEST) {
261  if (input_data_list.front() > data_vec_->back()) {
262  // Case: all of new points are past end of existing points
263  // Remove points from the beginning of data_vec, then add new points
264  int num_extra_points = input_data_list.size()-(storage_limit_-data_vec_->size());
265 #ifdef HAVE_RYTHMOS_DEBUG
266  TEUCHOS_TEST_FOR_EXCEPTION( num_extra_points <= 0, std::logic_error,
267  "Error! Buffer policy is keep newest and input data size = " << input_data_list.size() << ", storage limit = " << storage_limit_ << ", and data_vec size = " << data_vec_->size() << ". Somehow number of points to delete = " << num_extra_points << " <= 0!"
268  );
269 #endif // HAVE_RYTHMOS_DEBUG
270  typename DataStore<Scalar>::DataStoreVector_t::iterator
271  data_it = data_vec_->begin();
272  for (int i=0 ; i < num_extra_points ; ++i) {
273  data_it++;
274  }
275  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
276  *out << "Removing " << num_extra_points
277  << " from beginning of data_vec to make room for new points." << std::endl;
278  }
279  data_vec_->erase(data_vec_->begin(),data_it);
280  } else if (input_data_list.back() < data_vec_->front()) {
281  // Case: all of new points are before beginning of existing points
282  // Remove points from end of data_vec, then add new points
283  int num_extra_points = input_data_list.size()-(storage_limit_-data_vec_->size());
284 #ifdef HAVE_RYTHMOS_DEBUG
285  TEUCHOS_TEST_FOR_EXCEPTION( num_extra_points <= 0, std::logic_error,
286  "Error! Buffer policy is keep newest and input data size = " << input_data_list.size() << ", storage limit = " << storage_limit_ << ", and data_vec size = " << data_vec_->size() << ". Somehow number of points to delete = " << num_extra_points << " <= 0!"
287  );
288 #endif // HAVE_RYTHMOS_DEBUG
289  typename DataStore<Scalar>::DataStoreVector_t::iterator
290  data_it = data_vec_->end();
291  for (int i=0 ; i < num_extra_points ; ++i) {
292  data_it--;
293  }
294  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
295  *out << "Removing " << num_extra_points
296  << " from end of data_vec to make room for new points." << std::endl;
297  }
298  data_vec_->erase(data_it,data_vec_->end());
299  } else {
300  // Case: Some points are before beginning of data_vec and some points are after end of data_vec
301  TEUCHOS_TEST_FOR_EXCEPTION(
302  true, std::logic_error,
303  "Error, incoming points are on both sides of TimeRange, I don't know which points are newest in this case.\n"
304  );
305  }
306  } else {
307  // Unknown Buffer policy:
308  TEUCHOS_TEST_FOR_EXCEPTION(
309  true, std::logic_error,
310  "Error, unknown buffer policy.\n"
311  );
312  }
313  }
314  // Clone the vectors in input_data_list
315  std::list<DataStore<Scalar> > internal_input_data_list;
316  typename DataStore<Scalar>::DataStoreList_t::iterator it_list;
317  for (it_list = input_data_list.begin() ; it_list != input_data_list.end() ; it_list++) {
318  RCP<DataStore<Scalar> > ds_clone = it_list->clone();
319  internal_input_data_list.push_back(*ds_clone);
320  }
321  // Now add all the remaining points to data_vec
322  data_vec_->insert(data_vec_->end(),internal_input_data_list.begin(),internal_input_data_list.end());
323  // And sort data_vec:
324  std::sort(data_vec_->begin(),data_vec_->end());
325  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
326  *out << "data_vec at end of addPoints:" << std::endl;
327  for (Teuchos::Ordinal i=0 ; i<data_vec_->size() ; ++i) {
328  *out << "data_vec[" << i << "] = " << std::endl;
329  (*data_vec_)[i].describe(*out,Teuchos::VERB_EXTREME);
330  }
331  }
332 }
333 
334 
335 template<class Scalar>
337  const Array<Scalar>& time_vec
338  ,Array<RCP<const Thyra::VectorBase<Scalar> > >* x_vec
339  ,Array<RCP<const Thyra::VectorBase<Scalar> > >* xdot_vec
340  ,Array<ScalarMag>* accuracy_vec
341  ) const
342 {
343  RCP<Teuchos::FancyOStream> out = this->getOStream();
344  Teuchos::OSTab ostab(out,1,"IB::getPoints");
345  typename DataStore<Scalar>::DataStoreVector_t data_out;
346  interpolate<Scalar>(*interpolator_, data_vec_, time_vec, &data_out);
347  Array<Scalar> time_out_vec;
348  dataStoreVectorToVector<Scalar>(data_out, &time_out_vec, x_vec, xdot_vec, accuracy_vec);
349  TEUCHOS_TEST_FOR_EXCEPTION(
350  (time_vec.size() != time_out_vec.size()), std::logic_error,
351  "Error, number of time points returned from interpolator = " <<
352  time_out_vec.size() << " != " << time_vec.size() <<
353  " = number of time points requested\n"
354  );
355  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
356  *out << "Conversion of DataStoreVector to Vector successful" << std::endl;
357  }
358 }
359 
360 
361 template<class Scalar>
363 {
364  TimeRange<Scalar> timerange;
365  if (data_vec_->size() > 0) {
366  timerange = TimeRange<Scalar>(data_vec_->front().time,data_vec_->back().time);
367  }
368  return(timerange);
369 }
370 
371 
372 template<class Scalar>
373 void InterpolationBuffer<Scalar>::getNodes( Array<Scalar>* time_vec ) const
374 {
375  int N = data_vec_->size();
376  time_vec->clear();
377  time_vec->reserve(N);
378  for (int i=0 ; i<N ; ++i) {
379  time_vec->push_back((*data_vec_)[i].time);
380  }
381  RCP<Teuchos::FancyOStream> out = this->getOStream();
382  Teuchos::OSTab ostab(out,1,"IB::getNodes");
383  if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
384  *out << this->description() << std::endl;
385  for (Teuchos::Ordinal i=0 ; i<time_vec->size() ; ++i) {
386  *out << "time_vec[" << i << "] = " << (*time_vec)[i] << std::endl;
387  }
388  }
389 }
390 
391 
392 template<class Scalar>
393 void InterpolationBuffer<Scalar>::removeNodes( Array<Scalar>& time_vec )
394 {
395  typedef Teuchos::ScalarTraits<Scalar> ST;
396  int N = time_vec.size();
397 #ifdef HAVE_RYTHMOS_DEBUG
398  // Check preconditions:
399  TimeRange<Scalar> range = this->getTimeRange();
400  for (int i=0; i<N ; ++i) {
401  TEUCHOS_TEST_FOR_EXCEPTION(
402  (range.lower() <= time_vec[i]) && (time_vec[i] <= range.upper()),
403  std::logic_error,
404  "Error, time_vec[" << i << "] = " << time_vec[i] <<
405  "is not in range of this interpolation buffer = [" <<
406  range.lower() << "," << range.upper() << "]!\n"
407  );
408  }
409 #endif // HAVE_RYTHMOS_DEBUG
410  RCP<Thyra::VectorBase<Scalar> > vec_temp;
411  ScalarMag z = ST::zero();
412  for (int i=0; i<N ; ++i) {
413  DataStore<Scalar> ds_temp(time_vec[i],vec_temp,vec_temp,z);
414  typename DataStore<Scalar>::DataStoreVector_t::iterator
415  data_it = std::find(data_vec_->begin(),data_vec_->end(),ds_temp);
416  TEUCHOS_TEST_FOR_EXCEPTION(
417  data_it == data_vec_->end(), std::logic_error,
418  "Error, time_vec[" << i << "] = " << time_vec[i] << "is not a node in the interpolation buffer!\n"
419  );
420  data_vec_->erase(data_it);
421  }
422 }
423 
424 
425 template<class Scalar>
427 {
428  return(interpolator_->order());
429 }
430 
431 
432 template<class Scalar>
434 {
435  std::string name = "Rythmos::InterpolationBuffer";
436  return(name);
437 }
438 
439 
440 template<class Scalar>
442  Teuchos::FancyOStream &out
443  ,const Teuchos::EVerbosityLevel verbLevel
444  ) const
445 {
446  if ( (Teuchos::as<int>(verbLevel) == Teuchos::as<int>(Teuchos::VERB_DEFAULT) ) ||
447  (Teuchos::as<int>(verbLevel) >= Teuchos::as<int>(Teuchos::VERB_LOW) )
448  ) {
449  out << description() << "::describe" << std::endl;
450  out << "interpolator = " << interpolator_->description() << std::endl;
451  out << "storage_limit = " << storage_limit_ << std::endl;
452  } else if (Teuchos::as<int>(verbLevel) >= Teuchos::as<int>(Teuchos::VERB_LOW)) {
453  } else if (Teuchos::as<int>(verbLevel) >= Teuchos::as<int>(Teuchos::VERB_MEDIUM)) {
454  } else if (Teuchos::as<int>(verbLevel) >= Teuchos::as<int>(Teuchos::VERB_HIGH)) {
455  out << "data_vec = " << std::endl;
456  for (Teuchos::Ordinal i=0; i<data_vec_->size() ; ++i) {
457  out << "data_vec[" << i << "] = " << std::endl;
458  (*data_vec_)[i].describe(out,this->getVerbLevel());
459  }
460  }
461 }
462 
463 
464 template <class Scalar>
465 void InterpolationBuffer<Scalar>::setParameterList(RCP<Teuchos::ParameterList> const& paramList)
466 {
467  TEUCHOS_TEST_FOR_EXCEPT( is_null(paramList) );
468  paramList->validateParameters(*this->getValidParameters());
469  paramList_ = paramList;
470 
471  Teuchos::readVerboseObjectSublist(&*paramList_,this);
472 
473  //int outputLevel = paramList_->get( "outputLevel", int(-1) );
474  //outputLevel = std::min(std::max(outputLevel,-1),4);
475  //this->setVerbLevel(static_cast<Teuchos::EVerbosityLevel>(outputLevel));
476  IBPolicy policyLevel = interpolationBufferPolicyValidator->getIntegralValue(
477  *paramList_, interpolationBufferPolicySelection_name, interpolationBufferPolicySelection_default
478  );
479  if (policyLevel != BUFFER_POLICY_INVALID) {
480  policy_ = policyLevel;
481  }
482  int storage_limit = paramList_->get( interpolationBufferStorageLimit_name, interpolationBufferStorageLimit_default);
483  setStorage(storage_limit);
484 }
485 
486 template<class Scalar>
487 RCP<const Teuchos::ParameterList> InterpolationBuffer<Scalar>::getValidParameters() const
488 {
489  static RCP<Teuchos::ParameterList> validPL;
490 
491  if (is_null(validPL)) {
492 
493  RCP<Teuchos::ParameterList>
494  pl = Teuchos::parameterList();
495 
496  Teuchos::setupVerboseObjectSublist(&*pl);
497 
498  pl->set(
499  interpolationBufferPolicySelection_name,
500  interpolationBufferPolicySelection_default,
501  "Interpolation Buffer Policy for when the maximum storage size is exceeded. Static will throw an exception when the storage limit is exceeded. Keep Newest will over-write the oldest data in the buffer when the storage limit is exceeded.",
502  interpolationBufferPolicyValidator
503  );
504 
505  pl->set(
506  interpolationBufferStorageLimit_name,
507  interpolationBufferStorageLimit_default,
508  "Storage limit for the interpolation buffer."
509  );
510 
511  validPL = pl;
512 
513  }
514  return validPL;
515 }
516 
517 
518 template <class Scalar>
519 RCP<Teuchos::ParameterList>
521 {
522  return(paramList_);
523 }
524 
525 
526 template <class Scalar>
528 {
529  RCP<Teuchos::ParameterList> temp_param_list = paramList_;
530  paramList_ = Teuchos::null;
531  return(temp_param_list);
532 }
533 
534 template <class Scalar>
536 {
537  return policy_;
538 }
539 
540 //
541 // Explicit Instantiation macro
542 //
543 // Must be expanded from within the Rythmos namespace!
544 //
545 
546 #define RYTHMOS_INTERPOLATION_BUFFER_INSTANT(SCALAR) \
547  \
548  template class InterpolationBuffer< SCALAR >; \
549  \
550  template RCP<InterpolationBuffer< SCALAR > > interpolationBuffer( \
551  const RCP<InterpolatorBase< SCALAR > >& interpolator, \
552  int storage \
553  );
554 
555 } // namespace Rythmos
556 
557 
558 #endif // Rythmos_INTERPOLATION_BUFFER_DEF_H
void addPoints(const Array< Scalar > &time_vec, const Array< RCP< const Thyra::VectorBase< Scalar > > > &x_vec, const Array< RCP< const Thyra::VectorBase< Scalar > > > &xdot_vec)
Add point to buffer.
Base strategy class for interpolation functionality.
RCP< Teuchos::ParameterList > getNonconstParameterList()
void setStorage(int storage)
Set the maximum storage of this buffer.
RCP< InterpolatorBase< Scalar > > unSetInterpolator()
Unset the interpolator for this buffer.
void removeNodes(Array< Scalar > &time_vec)
Remove interpolation nodes.
void getNodes(Array< Scalar > *time_vec) const
Get interpolation nodes.
RCP< const InterpolatorBase< Scalar > > getInterpolator() const
void initialize(const RCP< InterpolatorBase< Scalar > > &interpolator, int storage)
Initialize the buffer:
RCP< InterpolatorBase< Scalar > > getNonconstInterpolator()
int getOrder() const
Get order of interpolation.
void getPoints(const Array< Scalar > &time_vec, Array< RCP< const Thyra::VectorBase< Scalar > > > *x_vec, Array< RCP< const Thyra::VectorBase< Scalar > > > *xdot_vec, Array< ScalarMag > *accuracy_vec) const
Get value from buffer.
concrete class for interpolation buffer functionality.
RCP< const Thyra::VectorSpaceBase< Scalar > > get_x_space() const
Redefined from Rythmos::InterpolationBufferBase.
std::string description() const
Redefined from Teuchos::Describable.
int getStorage() const
Get the maximum storage of this buffer.
void setInterpolator(const RCP< InterpolatorBase< Scalar > > &interpolator)
Redefined from Rythmos::InterpolatorAcceptingObjectBase.
RCP< Teuchos::ParameterList > unsetParameterList()
void setParameterList(RCP< Teuchos::ParameterList > const &paramList)
Redefined from Teuchos::ParameterListAcceptor.
void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const