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 ); }