Rythmos - Transient Integration for Differential Equations Version of the Day
Loading...
Searching...
No Matches
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
39namespace {
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
73namespace Rythmos {
74
75// ////////////////////////////
76// Defintions
77
78
79template<class Scalar>
81{
82 this->defaultInitializeAll_();
83 initialize(Teuchos::null,0);
84}
85
86template<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
96template<class Scalar>
97RCP<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
109template<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
130template<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
149template<class Scalar>
151{
152 return(storage_limit_);
153}
154
155
156template<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
173template<class Scalar>
174RCP<InterpolatorBase<Scalar> >
176{
177 return interpolator_;
178}
179
180template<class Scalar>
181RCP<const InterpolatorBase<Scalar> >
183{
184 return interpolator_;
185}
186
187template<class Scalar>
189{
190 RCP<InterpolatorBase<Scalar> > old_interpolator = interpolator_;
191 interpolator_ = linearInterpolator<Scalar>();
192 return old_interpolator;
193}
194
195
196template<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
335template<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
361template<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
372template<class Scalar>
373void 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
392template<class Scalar>
393void 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
425template<class Scalar>
427{
428 return(interpolator_->order());
429}
430
431
432template<class Scalar>
434{
435 std::string name = "Rythmos::InterpolationBuffer";
436 return(name);
437}
438
439
440template<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
464template <class Scalar>
465void 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
486template<class Scalar>
487RCP<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
518template <class Scalar>
519RCP<Teuchos::ParameterList>
521{
522 return(paramList_);
523}
524
525
526template <class Scalar>
528{
529 RCP<Teuchos::ParameterList> temp_param_list = paramList_;
530 paramList_ = Teuchos::null;
531 return(temp_param_list);
532}
533
534template <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
concrete class for interpolation buffer functionality.
RCP< Teuchos::ParameterList > getNonconstParameterList()
int getOrder() const
Get order of interpolation.
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.
void removeNodes(Array< Scalar > &time_vec)
Remove interpolation nodes.
void initialize(const RCP< InterpolatorBase< Scalar > > &interpolator, int storage)
Initialize the buffer:
RCP< InterpolatorBase< Scalar > > getNonconstInterpolator()
RCP< InterpolatorBase< Scalar > > unSetInterpolator()
Unset the interpolator for this buffer.
void setStorage(int storage)
Set the maximum storage of this buffer.
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.
void setInterpolator(const RCP< InterpolatorBase< Scalar > > &interpolator)
Redefined from Rythmos::InterpolatorAcceptingObjectBase.
std::string description() const
Redefined from Teuchos::Describable.
int getStorage() const
Get the maximum storage of this buffer.
RCP< const Thyra::VectorSpaceBase< Scalar > > get_x_space() const
Redefined from Rythmos::InterpolationBufferBase.
void setParameterList(RCP< Teuchos::ParameterList > const &paramList)
Redefined from Teuchos::ParameterListAcceptor.
RCP< const InterpolatorBase< Scalar > > getInterpolator() const
void getNodes(Array< Scalar > *time_vec) const
Get interpolation nodes.
RCP< Teuchos::ParameterList > unsetParameterList()
void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const
Base strategy class for interpolation functionality.
Represent a time range.