bool Rythmos::isInRange_cc(const TimeRange<TimeType> &tr, const TimeType &p)
{
return (
compareTimeValues(p,tr.lower()) >= 0
&& compareTimeValues(p,tr.upper()) <= 0
);
}
TEUCHOS_UNIT_TEST( Rythmos_TimeRange, copyAndScaleInvalid ) {
TimeRange<double> tr;
TimeRange<double> newTr = tr.copyAndScale(5.0);
TEST_EQUALITY_CONST( newTr.isValid(), false );
TEST_EQUALITY( newTr.lower(), tr.lower() );
TEST_EQUALITY( newTr.upper(), tr.upper() );
TEST_EQUALITY( newTr.length(), tr.length() );
}
TEUCHOS_UNIT_TEST( Rythmos_TimeRange, copyAndScale ) {
TimeRange<double> tr(1.0,2.0);
TimeRange<double> newTr = tr.copyAndScale(5.0);
TEST_EQUALITY_CONST( newTr.isValid(), true );
TEST_EQUALITY_CONST( newTr.lower(), 5.0 );
TEST_EQUALITY_CONST( newTr.upper(), 10.0 );
TEST_EQUALITY_CONST( newTr.length(), 5.0 );
}
Scalar translateTimeRange(
Scalar t,
const TimeRange<Scalar>& sourceRange,
const TimeRange<Scalar>& destinationRange
) {
Scalar r = destinationRange.length()/sourceRange.length();
return r*t+destinationRange.lower()-r*sourceRange.lower();
}
void ImplicitBDFStepperRampingStepControl<Scalar>::initialize(
const StepperBase<Scalar>& stepper)
{
// Initialize can be called from the stepper when setInitialCondition
// is called.
using Teuchos::as;
typedef Teuchos::ScalarTraits<Scalar> ST;
using Thyra::createMember;
// Set initial time:
TimeRange<Scalar> stepperRange = stepper.getTimeRange();
TEUCHOS_TEST_FOR_EXCEPTION(
!stepperRange.isValid(),
std::logic_error,
"Error, Stepper does not have valid time range for initialization "
"of ImplicitBDFStepperRampingStepControl!\n");
if (is_null(parameterList_)) {
RCP<Teuchos::ParameterList> emptyParameterList =
Teuchos::rcp(new Teuchos::ParameterList);
this->setParameterList(emptyParameterList);
}
if (is_null(errWtVecCalc_)) {
RCP<ImplicitBDFStepperErrWtVecCalc<Scalar> > IBDFErrWtVecCalc =
rcp(new ImplicitBDFStepperErrWtVecCalc<Scalar>());
errWtVecCalc_ = IBDFErrWtVecCalc;
}
stepControlState_ = UNINITIALIZED;
requestedStepSize_ = Scalar(-1.0);
currentStepSize_ = initialStepSize_;
currentOrder_ = 1;
nextStepSize_ = initialStepSize_;
nextOrder_ = 1;
numberOfSteps_ = 0;
totalNumberOfFailedSteps_ = 0;
countOfConstantStepsAfterFailure_ = 0;
if (is_null(delta_)) {
delta_ = createMember(stepper.get_x_space());
}
if (is_null(errWtVec_)) {
errWtVec_ = createMember(stepper.get_x_space());
}
V_S(delta_.ptr(),ST::zero());
if ( doOutput_(Teuchos::VERB_HIGH) ) {
RCP<Teuchos::FancyOStream> out = this->getOStream();
Teuchos::OSTab ostab(out,1,"initialize");
*out << "currentOrder_ = " << currentOrder_ << std::endl;
*out << "numberOfSteps_ = " << numberOfSteps_ << std::endl;
}
setStepControlState_(BEFORE_FIRST_STEP);
}
void AudioMarkerProviderKeyframes::GetMarkers(TimeRange const& range, AudioMarkerVector &out) const {
// Find first and last keyframes inside the range
auto a = lower_bound(markers.begin(), markers.end(), range.begin());
auto b = upper_bound(markers.begin(), markers.end(), range.end());
// Place pointers to the markers in the output vector
for (; a != b; ++a)
out.push_back(&*a);
}
void AudioController::PlayRange(const TimeRange &range)
{
if (!IsAudioOpen()) return;
player->Play(SamplesFromMilliseconds(range.begin()), SamplesFromMilliseconds(range.length()));
playback_mode = PM_Range;
playback_timer.Start(20);
AnnouncePlaybackPosition(range.begin());
}
string GenlistItemScenarioSchedule::getLabelItem(Evas_Object *obj, string part)
{
string text;
if (!scenario) return text;
if (part == "text")
{
text = scenario->ioScenario->params["name"];
}
else if (part == "time")
{
text = "N/A";
if (scenario->isScheduled())
{
auto getTimeForDate = [=,&text](vector<TimeRange> &range)
{
if (scheduleRangeNum >= 0 && scheduleRangeNum < range.size())
{
TimeRange tr = range[scheduleRangeNum];
text = tr.getStartTimeSec(scDate.tm_year + 1900, scDate.tm_mon + 1, scDate.tm_mday);
}
};
switch (scheduleRange)
{
case TimeRange::MONDAY: getTimeForDate(scenario->ioSchedule->range_infos.range_monday); break;
case TimeRange::TUESDAY: getTimeForDate(scenario->ioSchedule->range_infos.range_tuesday); break;
case TimeRange::WEDNESDAY: getTimeForDate(scenario->ioSchedule->range_infos.range_wednesday); break;
case TimeRange::THURSDAY: getTimeForDate(scenario->ioSchedule->range_infos.range_thursday); break;
case TimeRange::FRIDAY: getTimeForDate(scenario->ioSchedule->range_infos.range_friday); break;
case TimeRange::SATURDAY: getTimeForDate(scenario->ioSchedule->range_infos.range_saturday); break;
case TimeRange::SUNDAY: getTimeForDate(scenario->ioSchedule->range_infos.range_sunday); break;
default: break;
}
}
}
else if (part == "actions.text")
{
text = "Aucune actions.";
if (scenario->scenario_data.steps.size() > 1)
text = Utils::to_string(scenario->scenario_data.steps.size()) + " étapes.";
else if (scenario->scenario_data.steps.size() == 1 &&
scenario->scenario_data.steps[0].actions.size() > 0)
text = Utils::to_string(scenario->scenario_data.steps[0].actions.size()) + " actions.";
}
if (scenario->scenario_data.params["schedule"] != "false")
itemEmitSignal("schedule,true", "calaos");
else
itemEmitSignal("schedule,false", "calaos");
return text;
}
void AudioTimingControllerKaraoke::GetMarkers(TimeRange const& range, AudioMarkerVector &out) const {
size_t i;
for (i = 0; i < markers.size() && markers[i] < range.begin(); ++i) ;
for (; i < markers.size() && markers[i] < range.end(); ++i)
out.push_back(&markers[i]);
if (range.contains(start_marker)) out.push_back(&start_marker);
if (range.contains(end_marker)) out.push_back(&end_marker);
keyframes_provider.GetMarkers(range, out);
video_position_provider.GetMarkers(range, out);
}
void SecondsMarkerProvider::GetMarkers(TimeRange const& range, AudioMarkerVector &out) const {
if (!enabled->GetBool()) return;
if ((range.length() + 999) / 1000 > (int)markers.size())
markers.resize((range.length() + 999) / 1000, Marker(pen.get()));
size_t i = 0;
for (int time = ((range.begin() + 999) / 1000) * 1000; time < range.end(); time += 1000) {
markers[i].position = time;
out.push_back(&markers[i++]);
}
}
void Rythmos::asssertInTimeRange( const TimeRange<TimeType> &timeRange,
const TimeType &time )
{
TEUCHOS_TEST_FOR_EXCEPTION( !timeRange.isInRange(time), std::out_of_range,
"Error, the time = " << time
<< " is out of the range = " << timeRange << "!"
);
}
void Rythmos::assertNoTimePointsInsideCurrentTimeRange(
const InterpolationBufferBase<Scalar>& interpBuffer,
const Array<Scalar>& time_vec
)
{
typedef ScalarTraits<Scalar> ST;
const int numTimePoints = time_vec.size();
const TimeRange<Scalar> currentTimeRange = interpBuffer.getTimeRange();
if (currentTimeRange.length() >= ST::zero()) {
for ( int i = 0; i < numTimePoints; ++i ) {
TEST_FOR_EXCEPTION(
currentTimeRange.isInRange(time_vec[i]), std::out_of_range,
"Error, time_vec["<<i<<"] = " << time_vec[i] << " is in TimeRange of "
<< interpBuffer.description() << " = ["
<< currentTimeRange.lower() << "," << currentTimeRange.upper() << "]!"
);
}
}
}
void Rythmos::assertNoTimePointsBeforeCurrentTimeRange(
const InterpolationBufferBase<Scalar> &interpBuffer,
const Array<Scalar>& time_vec,
const int &startingTimePointIndex
)
{
typedef ScalarTraits<Scalar> ST;
const int numTimePoints = time_vec.size();
const TimeRange<Scalar> currentTimeRange = interpBuffer.getTimeRange();
if (currentTimeRange.length() >= ST::zero()) {
for ( int i = 0; i < numTimePoints; ++i ) {
TEST_FOR_EXCEPTION(
time_vec[i] < currentTimeRange.lower(), std::out_of_range,
"Error, time_vec["<<i<<"] = " << time_vec[i] << " < currentTimeRange.lower() = "
<< currentTimeRange.lower() << " for " << interpBuffer.description() << "!"
);
}
}
}
void AudioDisplay::PaintAudio(wxDC &dc, TimeRange updtime, wxRect updrect)
{
auto pt = style_ranges.upper_bound(updtime.begin());
auto pe = style_ranges.upper_bound(updtime.end());
if (pt != style_ranges.begin())
--pt;
while (pt != pe)
{
AudioRenderingStyle range_style = static_cast<AudioRenderingStyle>(pt->second);
int range_x1 = std::max(updrect.x, RelativeXFromTime(pt->first));
int range_x2 = (++pt == pe) ? updrect.x + updrect.width : RelativeXFromTime(pt->first);
if (range_x2 > range_x1)
{
audio_renderer->Render(dc, wxPoint(range_x1, audio_top), range_x1 + scroll_left, range_x2 - range_x1, range_style);
}
}
}
TEUCHOS_UNIT_TEST( Rythmos_TimeRange, newTimeRange ) {
TimeRange<double> tr;
// it should be initialized as [0,-1]
TEST_EQUALITY_CONST( tr.isValid(), false );
TEST_COMPARE( tr.lower(), >, tr.upper() );
TEST_EQUALITY_CONST( tr.isInRange(0.5), false );
TEST_EQUALITY_CONST( tr.isInRange(0.0), false );
TEST_EQUALITY_CONST( tr.isInRange(-1.0), false );
TEST_EQUALITY_CONST( tr.length(), -1.0 );
}
void AudioDisplay::ScrollTimeRangeInView(const TimeRange &range)
{
int client_width = GetClientRect().GetWidth();
int range_begin = AbsoluteXFromTime(range.begin());
int range_end = AbsoluteXFromTime(range.end());
int range_len = range_end - range_begin;
// Remove 5 % from each side of the client area.
int leftadjust = client_width / 20;
int client_left = scroll_left + leftadjust;
client_width = client_width * 9 / 10;
// Is everything already in view?
if (range_begin >= client_left && range_end <= client_left+client_width)
return;
// The entire range can fit inside the view, center it
if (range_len < client_width)
{
ScrollPixelToLeft(range_begin - (client_width-range_len)/2 - leftadjust);
}
// Range doesn't fit in view and we're viewing a middle part of it, just leave it alone
else if (range_begin < client_left && range_end > client_left+client_width)
{
// nothing
}
// Right edge is in view, scroll it as far to the right as possible
else if (range_end >= client_left && range_end < client_left+client_width)
{
ScrollPixelToLeft(range_end - client_width - leftadjust);
}
// Nothing is in view or the left edge is in view, scroll left edge as far to the left as possible
else
{
ScrollPixelToLeft(range_begin - leftadjust);
}
}
JoiningBoundedTimeline<void> webRtcDetectVoiceActivity(const AudioClip& audioClip, ProgressSink& progressSink) {
VadInst* vadHandle = WebRtcVad_Create();
if (!vadHandle) throw runtime_error("Error creating WebRTC VAD handle.");
auto freeHandle = gsl::finally([&]() {
WebRtcVad_Free(vadHandle);
});
int error = WebRtcVad_Init(vadHandle);
if (error) throw runtime_error("Error initializing WebRTC VAD handle.");
const int aggressiveness = 2; // 0..3. The higher, the more is cut off.
error = WebRtcVad_set_mode(vadHandle, aggressiveness);
if (error) throw runtime_error("Error setting WebRTC VAD aggressiveness.");
ProgressMerger progressMerger(progressSink);
ProgressSink& pass1ProgressSink = progressMerger.addSink(1.0);
ProgressSink& pass2ProgressSink = progressMerger.addSink(0.3);
// Detect activity
JoiningBoundedTimeline<void> activity(audioClip.getTruncatedRange());
centiseconds time = 0_cs;
const size_t bufferCapacity = audioClip.getSampleRate() / 100;
auto processBuffer = [&](const vector<int16_t>& buffer) {
// WebRTC is picky regarding buffer size
if (buffer.size() < bufferCapacity) return;
int result = WebRtcVad_Process(vadHandle, audioClip.getSampleRate(), buffer.data(), buffer.size()) == 1;
if (result == -1) throw runtime_error("Error processing audio buffer using WebRTC VAD.");
bool isActive = result != 0;
if (isActive) {
activity.set(time, time + 1_cs);
}
time += 1_cs;
};
process16bitAudioClip(audioClip, processBuffer, bufferCapacity, pass1ProgressSink);
// WebRTC adapts to the audio. This means results may not be correct at the very beginning.
// It sometimes returns false activity at the very beginning, mistaking the background noise for speech.
// So we delete the first recognized utterance and re-process the corresponding audio segment.
if (!activity.empty()) {
TimeRange firstActivity = activity.begin()->getTimeRange();
activity.clear(firstActivity);
unique_ptr<AudioClip> streamStart = audioClip.clone() | segment(TimeRange(0_cs, firstActivity.getEnd()));
time = 0_cs;
process16bitAudioClip(*streamStart, processBuffer, bufferCapacity, pass2ProgressSink);
}
return activity;
}
void Rythmos::selectPointsInTimeRange(
const Array<TimeType>& points_in,
const TimeRange<TimeType>& range,
const Ptr<Array<TimeType> >& points_out
)
{
points_out->clear();
int Nt = Teuchos::as<int>(points_in.size());
for (int i=0; i < Nt ; ++i) {
if (range.isInRange(points_in[i])) {
points_out->push_back(points_in[i]);
}
}
}
void AudioController::SaveClip(wxString const& filename, TimeRange const& range) const
{
int64_t start_sample = SamplesFromMilliseconds(range.begin());
int64_t end_sample = SamplesFromMilliseconds(range.end());
if (filename.empty() || start_sample > provider->GetNumSamples() || range.length() == 0) return;
agi::io::Save outfile(STD_STR(filename), true);
std::ofstream& out(outfile.Get());
size_t bytes_per_sample = provider->GetBytesPerSample() * provider->GetChannels();
size_t bufsize = (end_sample - start_sample) * bytes_per_sample;
int intval;
short shortval;
out << "RIFF";
out.write((char*)&(intval=bufsize+36),4);
out<< "WAVEfmt ";
out.write((char*)&(intval=16),4);
out.write((char*)&(shortval=1),2);
out.write((char*)&(shortval=provider->GetChannels()),2);
out.write((char*)&(intval=provider->GetSampleRate()),4);
out.write((char*)&(intval=provider->GetSampleRate()*provider->GetChannels()*provider->GetBytesPerSample()),4);
out.write((char*)&(intval=provider->GetChannels()*provider->GetBytesPerSample()),2);
out.write((char*)&(shortval=provider->GetBytesPerSample()<<3),2);
out << "data";
out.write((char*)&bufsize,4);
//samples per read
size_t spr = 65536 / bytes_per_sample;
std::vector<char> buf(bufsize);
for(int64_t i = start_sample; i < end_sample; i += spr) {
size_t len = std::min<size_t>(spr, end_sample - i);
provider->GetAudio(&buf[0], i, len);
out.write(&buf[0], len * bytes_per_sample);
}
}
void
PlayerSceneCreate::applyTransitionAnimation(SceneNodePtr start_node, SceneNodePtr end_node,
const PlayerItemPtr item, const TimeRange &time_range,
SceneNode *middle_node)
{
Time beginTime = time_range.getVisibleStartTime();
Time endTime = time_range.getVisibleEndTime();
// TODO: check for whether the difference between begin and end time is enough for the
// duration of the two transitions. Should have been checked by whoever set up the
// the PlayerTimeline earlier.
const TransitionPtr trans = item->getStartTransition();
// Add in the animations based on the begin transition
if (trans) {
trans->addKeysForNextItem(start_node.get(), beginTime, beginTime + Time::Seconds(trans->getDuration()), middle_node);
}
const TransitionPtr endTrans = item->getEndTransition();
// Add in the animations based on the end transition
if (endTrans) {
endTrans->addKeysForPreviousItem(end_node.get(), endTime - Time::Seconds(endTrans->getDuration()), endTime, middle_node);
}
}
void Rythmos::removePointsInTimeRange(
Array<TimeType>* points_in,
const TimeRange<TimeType>& range
)
{
Array<TimeType> values_to_remove;
for (int i=0 ; i<Teuchos::as<int>(points_in->size()) ; ++i) {
if (range.isInRange((*points_in)[i])) {
values_to_remove.push_back((*points_in)[i]);
}
}
typename Array<TimeType>::iterator point_it;
for (int i=0 ; i< Teuchos::as<int>(values_to_remove.size()) ; ++i) {
point_it = std::find(points_in->begin(),points_in->end(),values_to_remove[i]);
TEST_FOR_EXCEPTION(
point_it == points_in->end(), std::logic_error,
"Error, point to remove = " << values_to_remove[i] << " not found with std:find!\n"
);
points_in->erase(point_it);
}
}
RCP<Thyra::VectorBase<Scalar> > computeArea(
const Thyra::ModelEvaluator<Scalar>& me,
const TimeRange<Scalar>& tr,
const GaussQuadrature1D<Scalar>& gq
) {
typedef Teuchos::ScalarTraits<Scalar> ST;
RCP<Thyra::VectorBase<Scalar> > area = Thyra::createMember(me.get_x_space());
V_S(outArg(*area),ST::zero());
RCP<const TimeRange<Scalar> > sourceRange = gq.getRange();
RCP<const Array<Scalar> > sourcePts = gq.getPoints();
RCP<const Array<Scalar> > sourceWts = gq.getWeights();
Array<Scalar> destPts(*sourcePts);
for (unsigned int i=0 ; i<sourcePts->size() ; ++i) {
destPts[i] = translateTimeRange<Scalar>((*sourcePts)[i],*sourceRange,tr);
}
Scalar r = tr.length()/sourceRange->length();
for (unsigned int i=0 ; i<destPts.size() ; ++i) {
RCP<Thyra::VectorBase<Scalar> > tmpVec = eval_f_t<Scalar>(me,destPts[i]);
Vp_StV(outArg(*area),r*(*sourceWts)[i],*tmpVec);
}
return area;
}
TEUCHOS_UNIT_TEST( Rythmos_ExplicitRKStepper, getTimeRange ) {
{
RCP<SinCosModel> model = sinCosModel(false);
RCP<ExplicitRKStepper<double> > stepper = explicitRKStepper<double>(model);
Thyra::ModelEvaluatorBase::InArgs<double> ic = model->getNominalValues();
stepper->setInitialCondition(ic);
TimeRange<double> tr = stepper->getTimeRange();
TEST_EQUALITY_CONST( tr.isValid(), true );
TEST_EQUALITY_CONST( tr.lower(), 0.0 );
TEST_EQUALITY_CONST( tr.upper(), 0.0 );
TEST_EQUALITY_CONST( tr.length(), 0.0 );
}
{
RCP<SinCosModel> model = sinCosModel(false);
RCP<ExplicitRKStepper<double> > stepper = explicitRKStepper<double>();
stepper->setModel(model);
TimeRange<double> tr;
TEST_NOTHROW( tr = stepper->getTimeRange() );
TEST_EQUALITY_CONST( tr.isValid(), false );
}
}
TEUCHOS_UNIT_TEST( BasicDiscreteAdjointStepperTester, rawNonlinearAdjoint )
{
using Teuchos::outArg;
using Teuchos::describe;
using Teuchos::getParametersFromXmlString;
typedef Thyra::ModelEvaluatorBase MEB;
//
out << "\nA) Create the nonlinear ME ...\n";
//
RCP<VanderPolModel> stateModel = vanderPolModel(
getParametersFromXmlString(
"<ParameterList>"
" <Parameter name=\"Implicit model formulation\" type=\"bool\" value=\"1\"/>"
"</ParameterList>"
)
);
//
out << "\nB) Create the nonlinear solver ...\n";
//
RCP<TimeStepNonlinearSolver<double> > nlSolver = timeStepNonlinearSolver<double>(
getParametersFromXmlString(
"<ParameterList>"
" <Parameter name=\"Default Tol\" type=\"double\" value=\"1.0e-10\"/>"
" <Parameter name=\"Default Max Iters\" type=\"int\" value=\"20\"/>"
"</ParameterList>"
)
);
//
out << "\nC) Create the integrator for the forward state problem ...\n";
//
RCP<IntegratorBuilder<double> > ib = integratorBuilder<double>(
Teuchos::getParametersFromXmlString(
"<ParameterList>"
" <ParameterList name=\"Stepper Settings\">"
" <ParameterList name=\"Stepper Selection\">"
" <Parameter name=\"Stepper Type\" type=\"string\" value=\"Backward Euler\"/>"
" </ParameterList>"
" </ParameterList>"
" <ParameterList name=\"Integration Control Strategy Selection\">"
" <Parameter name=\"Integration Control Strategy Type\" type=\"string\""
" value=\"Simple Integration Control Strategy\"/>"
" <ParameterList name=\"Simple Integration Control Strategy\">"
" <Parameter name=\"Take Variable Steps\" type=\"bool\" value=\"false\"/>"
" <Parameter name=\"Fixed dt\" type=\"double\" value=\"0.5\"/>" // Gives 2 time steps!
" </ParameterList>"
" </ParameterList>"
" <ParameterList name=\"Interpolation Buffer Settings\">"
" <ParameterList name=\"Trailing Interpolation Buffer Selection\">"
" <Parameter name=\"Interpolation Buffer Type\" type=\"string\" value=\"Interpolation Buffer\"/>"
" </ParameterList>"
" </ParameterList>"
"</ParameterList>"
)
);
MEB::InArgs<double> ic = stateModel->getNominalValues();
RCP<IntegratorBase<double> > integrator = ib->create(stateModel, ic, nlSolver);
//integrator->setVerbLevel(Teuchos::VERB_EXTREME);
// ToDo: Set the trailing IB to pick up the entire state solution!
//
out << "\nD) Solve the basic forward problem ...\n";
//
const TimeRange<double> fwdTimeRange = integrator->getFwdTimeRange();
const double t_final = fwdTimeRange.upper();
RCP<const Thyra::VectorBase<double> > x_final, x_dot_final;
get_fwd_x_and_x_dot( *integrator, t_final, outArg(x_final), outArg(x_dot_final) );
out << "\nt_final = " << t_final << "\n";
out << "\nx_final: " << *x_final;
out << "\nx_dot_final: " << *x_dot_final;
//
out << "\nE) Create the basic adjoint model (no distributed response) ...\n";
//
RCP<AdjointModelEvaluator<double> > adjModel =
adjointModelEvaluator<double>(
stateModel, fwdTimeRange
);
adjModel->setFwdStateSolutionBuffer(integrator);
//
out << "\nF) Create a stepper and integrator for the adjoint ...\n";
//
RCP<Thyra::LinearNonlinearSolver<double> > adjTimeStepSolver =
Thyra::linearNonlinearSolver<double>();
RCP<Rythmos::StepperBase<double> > adjStepper =
integrator->getStepper()->cloneStepperAlgorithm();
//
out << "\nG) Set up the initial condition for the adjoint at the final time ...\n";
//
const RCP<const Thyra::VectorSpaceBase<double> >
f_space = stateModel->get_f_space();
// lambda(t_final) = x_final
const RCP<Thyra::VectorBase<double> > lambda_ic = createMember(f_space);
V_V( lambda_ic.ptr(), *x_final );
// lambda_dot(t_final,i) = 0.0
const RCP<Thyra::VectorBase<double> > lambda_dot_ic = createMember(f_space);
Thyra::V_S( lambda_dot_ic.ptr(), 0.0 );
MEB::InArgs<double> adj_ic = adjModel->getNominalValues();
adj_ic.set_x(lambda_ic);
adj_ic.set_x_dot(lambda_dot_ic);
out << "\nadj_ic: " << describe(adj_ic, Teuchos::VERB_EXTREME);
RCP<Rythmos::IntegratorBase<double> > adjIntegrator =
ib->create(adjModel, adj_ic, adjTimeStepSolver);
//
out << "\nH) Integrate the adjoint backwards in time (using backward time) ...\n";
//
adjStepper->setInitialCondition(adj_ic);
adjIntegrator->setStepper(adjStepper, fwdTimeRange.length());
const double adj_t_final = fwdTimeRange.length();
RCP<const Thyra::VectorBase<double> > lambda_final, lambda_dot_final;
get_fwd_x_and_x_dot( *adjIntegrator, adj_t_final,
outArg(lambda_final), outArg(lambda_dot_final) );
out << "\nadj_t_final = " << adj_t_final << "\n";
out << "\nlambda_final: " << *lambda_final;
out << "\nlambda_dot_final: " << *lambda_dot_final;
}
Session* SessionFactory::create( const SessionID& sessionID,
const Dictionary& settings ) throw( ConfigError )
{
std::string connectionType = settings.getString( CONNECTION_TYPE );
if ( connectionType != "acceptor" && connectionType != "initiator" )
throw ConfigError( "Invalid ConnectionType" );
if( connectionType == "acceptor" && settings.has(SESSION_QUALIFIER) )
throw ConfigError( "SessionQualifier cannot be used with acceptor." );
bool useDataDictionary = true;
if ( settings.has( USE_DATA_DICTIONARY ) )
useDataDictionary = settings.getBool( USE_DATA_DICTIONARY );
std::string defaultApplVerID;
if( sessionID.isFIXT() )
{
if( !settings.has(DEFAULT_APPLVERID) )
{
throw ConfigError("ApplVerID is required for FIXT transport");
}
defaultApplVerID = Message::toApplVerID( settings.getString(DEFAULT_APPLVERID) );
}
DataDictionaryProvider dataDictionaryProvider;
if( useDataDictionary )
{
if( sessionID.isFIXT() )
{
processFixtDataDictionaries(sessionID, settings, dataDictionaryProvider);
}
else
{
processFixDataDictionary(sessionID, settings, dataDictionaryProvider);
}
}
bool useLocalTime = false;
if( settings.has(USE_LOCAL_TIME) )
useLocalTime = settings.getBool( USE_LOCAL_TIME );
int startDay = -1;
int endDay = -1;
try
{
startDay = settings.getDay( START_DAY );
endDay = settings.getDay( END_DAY );
}
catch( ConfigError & ) {}
catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
UtcTimeOnly startTime;
UtcTimeOnly endTime;
try
{
startTime = UtcTimeOnlyConvertor::convert
( settings.getString( START_TIME ) );
endTime = UtcTimeOnlyConvertor::convert
( settings.getString( END_TIME ) );
}
catch ( FieldConvertError & e ) { throw ConfigError( e.what() ); }
TimeRange utcSessionTime
( startTime, endTime, startDay, endDay );
TimeRange localSessionTime
( LocalTimeOnly(startTime.getHour(), startTime.getMinute(), startTime.getSecond()),
LocalTimeOnly(endTime.getHour(), endTime.getMinute(), endTime.getSecond()),
startDay, endDay );
TimeRange sessionTimeRange = useLocalTime ? localSessionTime : utcSessionTime;
if( startDay >= 0 && endDay < 0 )
throw ConfigError( "StartDay used without EndDay" );
if( endDay >= 0 && startDay < 0 )
throw ConfigError( "EndDay used without StartDay" );
HeartBtInt heartBtInt( 0 );
if ( connectionType == "initiator" )
{
heartBtInt = HeartBtInt( settings.getLong( HEARTBTINT ) );
if ( heartBtInt <= 0 ) throw ConfigError( "Heartbeat must be greater than zero" );
}
Session* pSession = 0;
pSession = new Session( m_application, m_messageStoreFactory,
sessionID, dataDictionaryProvider, sessionTimeRange,
heartBtInt, m_pLogFactory );
pSession->setSenderDefaultApplVerID(defaultApplVerID);
int logonDay = startDay;
int logoutDay = endDay;
try
{
logonDay = settings.getDay( LOGON_DAY );
logoutDay = settings.getDay( LOGOUT_DAY );
}
catch( ConfigError & ) {}
catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
UtcTimeOnly logonTime( startTime );
UtcTimeOnly logoutTime( endTime );
try
{
logonTime = UtcTimeOnlyConvertor::convert
( settings.getString( LOGON_TIME ) );
}
catch( ConfigError & ) {}
catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
try
{
logoutTime = UtcTimeOnlyConvertor::convert
( settings.getString( LOGOUT_TIME ) );
}
catch( ConfigError & ) {}
catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
TimeRange utcLogonTime
( logonTime, logoutTime, logonDay, logoutDay );
TimeRange localLogonTime
( LocalTimeOnly(logonTime.getHour(), logonTime.getMinute(), logonTime.getSecond()),
LocalTimeOnly(logoutTime.getHour(), logoutTime.getMinute(), logoutTime.getSecond()),
logonDay, logoutDay );
TimeRange logonTimeRange = useLocalTime ? localLogonTime : utcLogonTime;
if( !sessionTimeRange.isInRange(logonTime) )
throw ConfigError( "LogonTime must be between StartTime and EndTime" );
if( !sessionTimeRange.isInRange(logoutTime) )
throw ConfigError( "LogoutTime must be between StartTime and EndTime" );
pSession->setLogonTime( logonTimeRange );
if ( settings.has( SEND_REDUNDANT_RESENDREQUESTS ) )
pSession->setSendRedundantResendRequests( settings.getBool( SEND_REDUNDANT_RESENDREQUESTS ) );
if ( settings.has( CHECK_COMPID ) )
pSession->setCheckCompId( settings.getBool( CHECK_COMPID ) );
if ( settings.has( CHECK_LATENCY ) )
pSession->setCheckLatency( settings.getBool( CHECK_LATENCY ) );
if ( settings.has( MAX_LATENCY ) )
pSession->setMaxLatency( settings.getLong( MAX_LATENCY ) );
if ( settings.has( LOGON_TIMEOUT ) )
pSession->setLogonTimeout( settings.getLong( LOGON_TIMEOUT ) );
if ( settings.has( LOGOUT_TIMEOUT ) )
pSession->setLogoutTimeout( settings.getLong( LOGOUT_TIMEOUT ) );
if ( settings.has( RESET_ON_LOGON ) )
pSession->setResetOnLogon( settings.getBool( RESET_ON_LOGON ) );
if ( settings.has( RESET_ON_LOGOUT ) )
pSession->setResetOnLogout( settings.getBool( RESET_ON_LOGOUT ) );
if ( settings.has( RESET_ON_DISCONNECT ) )
pSession->setResetOnDisconnect( settings.getBool( RESET_ON_DISCONNECT ) );
if ( settings.has( REFRESH_ON_LOGON ) )
pSession->setRefreshOnLogon( settings.getBool( REFRESH_ON_LOGON ) );
if ( settings.has( MILLISECONDS_IN_TIMESTAMP ) )
pSession->setMillisecondsInTimeStamp( settings.getBool( MILLISECONDS_IN_TIMESTAMP ) );
if ( settings.has( PERSIST_MESSAGES ) )
pSession->setPersistMessages( settings.getBool( PERSIST_MESSAGES ) );
return pSession;
}
bool DefaultIntegrator<Scalar>::advanceStepperToTime( const Scalar& advance_to_t )
{
#ifdef ENABLE_RYTHMOS_TIMERS
TEUCHOS_FUNC_TIME_MONITOR_DIFF("Rythmos:DefaultIntegrator::advanceStepperToTime",
TopLevel);
#endif
using std::endl;
typedef std::numeric_limits<Scalar> NL;
using Teuchos::incrVerbLevel;
#ifndef _MSC_VER
using Teuchos::Describable;
#endif
using Teuchos::OSTab;
typedef Teuchos::ScalarTraits<Scalar> ST;
RCP<Teuchos::FancyOStream> out = this->getOStream();
Teuchos::EVerbosityLevel verbLevel = this->getVerbLevel();
if (!is_null(integrationControlStrategy_)) {
integrationControlStrategy_->setOStream(out);
integrationControlStrategy_->setVerbLevel(incrVerbLevel(verbLevel,-1));
}
if (!is_null(integrationObserver_)) {
integrationObserver_->setOStream(out);
integrationObserver_->setVerbLevel(incrVerbLevel(verbLevel,-1));
}
if ( includesVerbLevel(verbLevel,Teuchos::VERB_LOW) )
*out << "\nEntering " << this->Describable::description()
<< "::advanceStepperToTime("<<advance_to_t<<") ...\n";
// Remember what timestep index we are on so we can report it later
const int initCurrTimeStepIndex = currTimeStepIndex_;
// Take steps until we the requested time is reached (or passed)
TimeRange<Scalar> currStepperTimeRange = stepper_->getTimeRange();
// Start by assume we can reach the time advance_to_t
bool return_val = true;
while ( !currStepperTimeRange.isInRange(advance_to_t) ) {
// Halt immediatly if exceeded max iterations
if (currTimeStepIndex_ >= maxNumTimeSteps_) {
if ( includesVerbLevel(verbLevel,Teuchos::VERB_LOW) )
*out
<< "\n***"
<< "\n*** NOTICE: currTimeStepIndex = "<<currTimeStepIndex_
<< " >= maxNumTimeSteps = "<<maxNumTimeSteps_<< ", halting time integration!"
<< "\n***\n";
return_val = false;
break; // Exit the loop immediately!
}
if ( includesVerbLevel(verbLevel,Teuchos::VERB_LOW) )
*out << "\nTake step: current_stepper_t = " << currStepperTimeRange.upper()
<< ", currTimeStepIndex = " << currTimeStepIndex_ << endl;
//
// A) Reinitialize if a hard breakpoint was reached on the last time step
//
if (stepCtrlInfoLast_.limitedByBreakPoint) {
if ( stepCtrlInfoLast_.breakPointType == BREAK_POINT_TYPE_HARD ) {
#ifdef ENABLE_RYTHMOS_TIMERS
TEUCHOS_FUNC_TIME_MONITOR("Rythmos:DefaultIntegrator::restart");
#endif
if ( includesVerbLevel(verbLevel,Teuchos::VERB_LOW) )
*out << "\nAt a hard-breakpoint, restarting time integrator ...\n";
restart(&*stepper_);
}
else {
if ( includesVerbLevel(verbLevel,Teuchos::VERB_LOW) )
*out << "\nAt a soft-breakpoint, NOT restarting time integrator ...\n";
}
}
//
// B) Get the trial step control info
//
StepControlInfo<Scalar> trialStepCtrlInfo;
{
#ifdef ENABLE_RYTHMOS_TIMERS
TEUCHOS_FUNC_TIME_MONITOR("Rythmos:DefaultIntegrator::advanceStepperToTime: getStepCtrl");
#endif
if (!is_null(integrationControlStrategy_)) {
// Let an external strategy object determine the step size and type.
// Note that any breakpoint info is also related through this call.
trialStepCtrlInfo = integrationControlStrategy_->getNextStepControlInfo(
*stepper_, stepCtrlInfoLast_, currTimeStepIndex_
);
}
else {
// Take a variable step if we have no control strategy
trialStepCtrlInfo.stepType = STEP_TYPE_VARIABLE;
trialStepCtrlInfo.stepSize = NL::max();
}
}
// Print the initial trial step
if ( includesVerbLevel(verbLevel,Teuchos::VERB_MEDIUM) ) {
*out << "\nTrial step:\n";
OSTab tab(out);
*out << trialStepCtrlInfo;
}
// Halt immediately if we where told to do so
if (trialStepCtrlInfo.stepSize < ST::zero()) {
if ( includesVerbLevel(verbLevel,Teuchos::VERB_MEDIUM) )
*out
<< "\n***"
<< "\n*** NOTICE: The IntegrationControlStrategy object return stepSize < 0.0, halting time integration!"
<< "\n***\n";
return_val = false;
break; // Exit the loop immediately!
}
// Make sure we don't step past the final time if asked not to
bool updatedTrialStepCtrlInfo = false;
{
const Scalar finalTime = integrationTimeDomain_.upper();
if (landOnFinalTime_ && trialStepCtrlInfo.stepSize + currStepperTimeRange.upper() > finalTime) {
if ( includesVerbLevel(verbLevel,Teuchos::VERB_LOW) )
*out << "\nCutting trial step to avoid stepping past final time ...\n";
trialStepCtrlInfo.stepSize = finalTime - currStepperTimeRange.upper();
updatedTrialStepCtrlInfo = true;
}
}
// Print the modified trial step
if ( updatedTrialStepCtrlInfo
&& includesVerbLevel(verbLevel,Teuchos::VERB_MEDIUM) )
{
*out << "\nUpdated trial step:\n";
OSTab tab(out);
*out << trialStepCtrlInfo;
}
//
// C) Take the step
//
// Print step type and size
if ( includesVerbLevel(verbLevel,Teuchos::VERB_MEDIUM) ) {
if (trialStepCtrlInfo.stepType == STEP_TYPE_VARIABLE)
*out << "\nTaking a variable time step with max step size = "
<< trialStepCtrlInfo.stepSize << " ....\n";
else
*out << "\nTaking a fixed time step of size = "
<< trialStepCtrlInfo.stepSize << " ....\n";
}
// Take step
Scalar stepSizeTaken;
{
#ifdef ENABLE_RYTHMOS_TIMERS
TEUCHOS_FUNC_TIME_MONITOR("Rythmos:DefaultIntegrator::advanceStepperToTime: takeStep");
#endif
stepSizeTaken = stepper_->takeStep(
trialStepCtrlInfo.stepSize, trialStepCtrlInfo.stepType
);
}
// Validate step taken
if (trialStepCtrlInfo.stepType == STEP_TYPE_VARIABLE) {
TEST_FOR_EXCEPTION(
stepSizeTaken < ST::zero(), std::logic_error,
"Error, stepper took negative step of dt = " << stepSizeTaken << "!\n"
);
TEST_FOR_EXCEPTION(
stepSizeTaken > trialStepCtrlInfo.stepSize, std::logic_error,
"Error, stepper took step of dt = " << stepSizeTaken
<< " > max step size of = " << trialStepCtrlInfo.stepSize << "!\n"
);
}
else { // STEP_TYPE_FIXED
TEST_FOR_EXCEPTION(
stepSizeTaken != trialStepCtrlInfo.stepSize, std::logic_error,
"Error, stepper took step of dt = " << stepSizeTaken
<< " when asked to take step of dt = " << trialStepCtrlInfo.stepSize << "\n"
);
}
// Update info about this step
currStepperTimeRange = stepper_->getTimeRange();
const StepControlInfo<Scalar> stepCtrlInfo =
stepCtrlInfoTaken(trialStepCtrlInfo,stepSizeTaken);
// Print the step actually taken
if ( includesVerbLevel(verbLevel,Teuchos::VERB_MEDIUM) ) {
*out << "\nStep actually taken:\n";
OSTab tab(out);
*out << stepCtrlInfo;
}
// Append the trailing interpolation buffer (if defined)
if (!is_null(trailingInterpBuffer_)) {
interpBufferAppender_->append(*stepper_,currStepperTimeRange,
trailingInterpBuffer_.ptr() );
}
//
// D) Output info about step
//
{
#ifdef ENABLE_RYTHMOS_TIMERS
TEUCHOS_FUNC_TIME_MONITOR("Rythmos:DefaultIntegrator::advanceStepperToTime: output");
#endif
// Print our own brief output
if ( includesVerbLevel(verbLevel,Teuchos::VERB_MEDIUM) ) {
StepStatus<Scalar> stepStatus = stepper_->getStepStatus();
*out << "\nTime point reached = " << stepStatus.time << endl;
*out << "\nstepStatus:\n" << stepStatus;
if ( includesVerbLevel(verbLevel,Teuchos::VERB_EXTREME) ) {
RCP<const Thyra::VectorBase<Scalar> >
solution = stepStatus.solution,
solutionDot = stepStatus.solutionDot;
if (!is_null(solution))
*out << "\nsolution = \n" << Teuchos::describe(*solution,verbLevel);
if (!is_null(solutionDot))
*out << "\nsolutionDot = \n" << Teuchos::describe(*solutionDot,verbLevel);
}
}
// Output to the observer
if (!is_null(integrationObserver_))
integrationObserver_->observeCompletedTimeStep(
*stepper_, stepCtrlInfo, currTimeStepIndex_
);
}
//
// E) Update info for next time step
//
stepCtrlInfoLast_ = stepCtrlInfo;
++currTimeStepIndex_;
}
if ( includesVerbLevel(verbLevel,Teuchos::VERB_LOW) )
*out << "\nNumber of steps taken in this call to advanceStepperToTime(...) = "
<< (currTimeStepIndex_ - initCurrTimeStepIndex) << endl
<< "\nLeaving" << this->Describable::description()
<< "::advanceStepperToTime("<<advance_to_t<<") ...\n";
return return_val;
}
void PointwiseInterpolationBufferAppender<Scalar>::append(
const InterpolationBufferBase<Scalar>& interpBuffSource,
const TimeRange<Scalar>& appendRange,
const Ptr<InterpolationBufferBase<Scalar> > &interpBuffSink
)
{
TEUCHOS_ASSERT( !is_null(interpBuffSink) );
#ifdef RYTHMOS_DEBUG
this->assertAppendPreconditions(interpBuffSource,appendRange,*interpBuffSink);
#endif // RYTHMOS_DEBUG
RCP<Teuchos::FancyOStream> out = this->getOStream();
Teuchos::OSTab ostab(out,1,"PointwiseInterpolationBufferAppender::append");
if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
*out << "Interpolation Buffer source range = [" << interpBuffSource.getTimeRange().lower() << "," <<
interpBuffSource.getTimeRange().upper() << "]" << std::endl;
*out << "Append range = [" << appendRange.lower() << "," << appendRange.upper() << "]" << std::endl;
*out << "Interpolation Buffer sink range = [" << interpBuffSink->getTimeRange().lower() << "," <<
interpBuffSink->getTimeRange().upper() << "]" << std::endl;
}
// Set up appendRange correctly to be either (] or [):
RCP<const TimeRange<Scalar> > correctedAppendRange = Teuchos::rcp(&appendRange,false);
if (compareTimeValues<Scalar>(interpBuffSink->getTimeRange().upper(),appendRange.lower()) == 0) {
// adding to end of buffer
correctedAppendRange = Teuchos::rcp(new TimeRange_oc<Scalar>(appendRange));
if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
*out << "Corrected append range = (" << correctedAppendRange->lower() << "," <<
correctedAppendRange->upper() << "]" << std::endl;
}
}
else if (compareTimeValues<Scalar>(interpBuffSink->getTimeRange().lower(),appendRange.upper()) == 0) {
// adding to beginning of buffer
correctedAppendRange = Teuchos::rcp(new TimeRange_co<Scalar>(appendRange));
if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
*out << "Corrected append range = [" << correctedAppendRange->lower() << "," <<
correctedAppendRange->upper() << ")" << std::endl;
}
}
Array<Scalar> time_vec_in;
interpBuffSource.getNodes(&time_vec_in);
Array<Scalar> time_vec;
selectPointsInTimeRange(time_vec_in,*correctedAppendRange,Teuchos::outArg(time_vec));
if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
*out << "Selected points for appending to sink buffer: " << time_vec << std::endl;
}
Array<RCP<const Thyra::VectorBase<Scalar> > > x_vec;
Array<RCP<const Thyra::VectorBase<Scalar> > > xdot_vec;
Array<ScalarMag> accuracy_vec;
interpBuffSource.getPoints(time_vec, &x_vec, &xdot_vec, &accuracy_vec);
if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
*out << "Sink buffer range before addPoints = [" << interpBuffSink->getTimeRange().lower() << "," <<
interpBuffSink->getTimeRange().upper() << "]" << std::endl;
}
interpBuffSink->addPoints(time_vec, x_vec, xdot_vec);
if ( Teuchos::as<int>(this->getVerbLevel()) >= Teuchos::as<int>(Teuchos::VERB_HIGH) ) {
*out << "Sink buffer range after addPoints = [" << interpBuffSink->getTimeRange().lower() << "," <<
interpBuffSink->getTimeRange().upper() << "]" << std::endl;
}
}
Timeline<Phone> utteranceToPhones(
const AudioClip& audioClip,
TimeRange utteranceTimeRange,
ps_decoder_t& decoder,
ProgressSink& utteranceProgressSink)
{
ProgressMerger utteranceProgressMerger(utteranceProgressSink);
ProgressSink& wordRecognitionProgressSink = utteranceProgressMerger.addSink(1.0);
ProgressSink& alignmentProgressSink = utteranceProgressMerger.addSink(0.5);
// Pad time range to give Pocketsphinx some breathing room
TimeRange paddedTimeRange = utteranceTimeRange;
const centiseconds padding(3);
paddedTimeRange.grow(padding);
paddedTimeRange.trim(audioClip.getTruncatedRange());
const unique_ptr<AudioClip> clipSegment = audioClip.clone() | segment(paddedTimeRange) | resample(sphinxSampleRate);
const auto audioBuffer = copyTo16bitBuffer(*clipSegment);
// Get words
BoundedTimeline<string> words = recognizeWords(audioBuffer, decoder);
wordRecognitionProgressSink.reportProgress(1.0);
// Log utterance text
string text;
for (auto& timedWord : words) {
string word = timedWord.getValue();
// Skip details
if (word == "<s>" || word == "</s>" || word == "<sil>") {
continue;
}
word = regex_replace(word, regex("\\(\\d\\)"), "");
if (text.size() > 0) {
text += " ";
}
text += word;
}
logTimedEvent("utterance", utteranceTimeRange, text);
// Log words
for (Timed<string> timedWord : words) {
timedWord.getTimeRange().shift(paddedTimeRange.getStart());
logTimedEvent("word", timedWord);
}
// Convert word strings to word IDs using dictionary
vector<s3wid_t> wordIds;
for (const auto& timedWord : words) {
wordIds.push_back(getWordId(timedWord.getValue(), *decoder.dict));
}
if (wordIds.empty()) return {};
// Align the words' phones with speech
#if BOOST_VERSION < 105600 // Support legacy syntax
#define value_or get_value_or
#endif
Timeline<Phone> utterancePhones = getPhoneAlignment(wordIds, audioBuffer, decoder)
.value_or(ContinuousTimeline<Phone>(clipSegment->getTruncatedRange(), Phone::Noise));
alignmentProgressSink.reportProgress(1.0);
utterancePhones.shift(paddedTimeRange.getStart());
// Log raw phones
for (const auto& timedPhone : utterancePhones) {
logTimedEvent("rawPhone", timedPhone);
}
// Guess positions of noise sounds
JoiningTimeline<void> noiseSounds = getNoiseSounds(utteranceTimeRange, utterancePhones);
for (const auto& noiseSound : noiseSounds) {
utterancePhones.set(noiseSound.getTimeRange(), Phone::Noise);
}
// Log phones
for (const auto& timedPhone : utterancePhones) {
logTimedEvent("phone", timedPhone);
}
return utterancePhones;
}
void VideoPositionMarkerProvider::GetMarkers(const TimeRange &range, AudioMarkerVector &out) const {
if (marker && range.contains(*marker))
out.push_back(marker.get());
}
bool Rythmos::getCurrentPoints(
const InterpolationBufferBase<Scalar> &interpBuffer,
const Array<Scalar>& time_vec,
Array<RCP<const Thyra::VectorBase<Scalar> > >* x_vec,
Array<RCP<const Thyra::VectorBase<Scalar> > >* xdot_vec,
int *nextTimePointIndex_inout
)
{
typedef ScalarTraits<Scalar> ST;
using Teuchos::as;
const int numTotalTimePoints = time_vec.size();
// Validate input
#ifdef RYTHMOS_DEBUG
TEST_FOR_EXCEPT(nextTimePointIndex_inout==0);
TEUCHOS_ASSERT( 0 <= *nextTimePointIndex_inout && *nextTimePointIndex_inout < numTotalTimePoints );
TEUCHOS_ASSERT( x_vec == 0 || as<int>(x_vec->size()) == numTotalTimePoints );
TEUCHOS_ASSERT( xdot_vec == 0 || as<int>(xdot_vec->size()) == numTotalTimePoints );
#endif // RYTHMOS_DEBUG
int &nextTimePointIndex = *nextTimePointIndex_inout;
const int initNextTimePointIndex = nextTimePointIndex;
const TimeRange<Scalar> currentTimeRange = interpBuffer.getTimeRange();
if (currentTimeRange.length() >= ST::zero()) {
// Load a temp array with all of the current time points that fall in the
// current time range.
Array<Scalar> current_time_vec;
{ // scope for i to remove shadow warning.
int i;
for ( i = 0; i < numTotalTimePoints-nextTimePointIndex; ++i ) {
const Scalar t = time_vec[nextTimePointIndex];
#ifdef RYTHMOS_DEBUG
TEUCHOS_ASSERT( t >= currentTimeRange.lower() );
#endif // RYTHMOS_DEBUG
if ( currentTimeRange.isInRange(t) ) {
++nextTimePointIndex;
current_time_vec.push_back(t);
}
else {
break;
}
}
#ifdef RYTHMOS_DEBUG
// Here I am just checking that the loop worked as expected with the data
// in the current time range all comming first.
TEUCHOS_ASSERT( nextTimePointIndex-initNextTimePointIndex == i );
#endif
}
// Get points in current time range if any such points exist
const int numCurrentTimePoints = current_time_vec.size();
if ( numCurrentTimePoints > 0 ) {
// Get the state(s) for current time points from the stepper and put
// them into temp arrays
Array<RCP<const Thyra::VectorBase<Scalar> > > current_x_vec;
Array<RCP<const Thyra::VectorBase<Scalar> > > current_xdot_vec;
if (x_vec || xdot_vec) {
interpBuffer.getPoints(
current_time_vec,
x_vec ? ¤t_x_vec : 0,
xdot_vec ? ¤t_xdot_vec : 0,
0 // accuracy_vec
);
}
// Copy the gotten x and xdot vectors from the temp arrays to the output
// arrays.
for ( int i = initNextTimePointIndex; i < nextTimePointIndex; ++i ) {
if (x_vec)
(*x_vec)[i] = current_x_vec[i-initNextTimePointIndex];
if (xdot_vec)
(*xdot_vec)[i] = current_xdot_vec[i-initNextTimePointIndex];
}
}
}
return ( nextTimePointIndex == initNextTimePointIndex ? false : true );
}
