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 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::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 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::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);
}
}
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 );
}
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;
}
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;
}
TEUCHOS_UNIT_TEST( Rythmos_TimeRange, invalidTimeRange ) {
TimeRange<double> tr = invalidTimeRange<double>();
TEST_EQUALITY_CONST( tr.isValid(), false );
TEST_COMPARE( tr.lower(), >, tr.upper() );
TEST_EQUALITY_CONST( tr.isInRange(0.5), false );
}
