void QLogicCircuitShapeConnector::updatePosition()
{
prepareGeometryChange();
m_breakPoints = breakPoints();
calcBoundingRect();
update();
}
returnValue ShootingMethod::addStage( const DynamicSystem &dynamicSystem_,
const Grid &stageIntervals,
const IntegratorType &integratorType_ ){
// LOAD THE DIFFERENTIAL EQUATION FROM THE DYNAMIC SYSTEM:
// -------------------------------------------------------
DifferentialEquation differentialEquation_ = dynamicSystem_.getDifferentialEquation( );
int integratorTypeTmp = integratorType_;
// AUTOMATICALLY SWITCH TO DISCRETE TIME INTEGRATOR IF NECESSARY:
// --------------------------------------------------------------
if( differentialEquation_.isDiscretized() == BT_TRUE ){
if( integratorTypeTmp != INT_DISCRETE )
integratorTypeTmp = INT_DISCRETE;
}
else{
if( integratorTypeTmp == INT_DISCRETE )
return ACADOERROR( RET_CANNOT_TREAT_CONTINUOUS_DE );
}
// CONSTRUCT THE APPROPRIATE INTEGRATOR BASED ON THE OPTIONS:
// ----------------------------------------------------------
int run1 = N;
unionGrid = unionGrid & stageIntervals;
N = unionGrid.getNumIntervals();
integrator = (Integrator**)realloc(integrator,N*sizeof(Integrator*));
while( run1 < N ){
allocateIntegrator( run1, (IntegratorType) integratorTypeTmp );
integrator[run1]->init( differentialEquation_ );
run1++;
}
// STORE THE INFORMATION ABOUT STAGE-BREAK POINTS AND START/END TIMES:
// -------------------------------------------------------------------
int tmp = 0;
if( breakPoints.getNumRows() > 0 ){
addOptionsList( );
tmp = (int) breakPoints( breakPoints.getNumRows()-1, 0 );
}
Matrix stageIndices(1,5);
stageIndices(0,0) = stageIntervals.getNumIntervals() + tmp;
stageIndices(0,1) = differentialEquation_.getStartTimeIdx();
stageIndices(0,2) = differentialEquation_.getEndTimeIdx();
stageIndices(0,3) = differentialEquation_.getStartTime();
stageIndices(0,4) = differentialEquation_.getEndTime();
breakPoints.appendRows(stageIndices);
return SUCCESSFUL_RETURN;
}
bool RDOSimulatorBase::rdoNext()
{
if (m_mode == RTM_Pause || m_mode == RTM_BreakPoint)
{
boost::this_thread::sleep(boost::posix_time::milliseconds(1));
return true;
}
// Если нажата клавиша или активная область, то задержки надо проскачить
bool keyboard = isKeyDown();
if (!keyboard)
{
// Задержка общей скорости моделирования
// Это mode == RTM_Jump || mode == RTM_Sync
if (m_mode != RTM_MaxSpeed && m_next_delay_count)
{
++m_next_delay_current;
if (m_next_delay_current < m_next_delay_count) return true;
m_next_delay_current = 0;
}
// Задержка синхронной скорости моделирования (длительность операций)
// Тут не надо проверять mode == RTM_Sync, т.к. это уже заложено в msec_wait,
// который сбрасывается в setMode и не изменяется далее.
if (m_msec_wait > 1)
{
boost::posix_time::ptime systime_current = boost::posix_time::microsec_clock::local_time();
std::size_t msec_curr = getMSec(systime_current);
std::size_t msec_delta;
// Милисекунды считаются с учетом часов, но при смене суток часы сбрасываются на ноль,
// и текущее время в милисекундах становится меньше предыдущего. Учитываем этот момент
// через ветку ELSE. Теперь система сможет учесть переход на один день вперед между
// двумя соседники моментами времени, но не сможет учесть на два и более дня. Это
// является маразматической ситуаций (ждать слудующего события два дня), но запросто
// может потребоваться в системе мониторинга реального времени, которая работает в
// автоматическом режиме, обрабатывая информацию с контроллеров. РДО это делать не умеет.
// Как решение - отказ от синхронной работы в таких системах, и учет только скорости, или
// переход на работу с календарем дней, месяцев и лет. SYSTEMTIME содержит такую информацию.
if (msec_curr >= m_msec_prev)
{
msec_delta = msec_curr - m_msec_prev;
}
else
{
msec_delta = UINT_MAX - m_msec_prev + msec_curr;
}
if (msec_delta <= m_msec_wait) return true;
m_msec_wait -= msec_delta;
}
}
// Окончание моделирования - сработало событие конца
if (endCondition())
{
onEndCondition();
return false;
}
if (m_currentTime != m_nextTime)
{
m_currentTime = m_nextTime;
onNewTimeNow();
}
// Выполнение операции
if (doOperation())
{
if (breakPoints())
{
setMode(RTM_BreakPoint);
}
return true;
}
else
{
// Переход к следующей операции
if (!m_timePoints.empty())
{
BOPlannedMap::iterator begin = m_timePoints.begin();
double newTime = begin->first;
const BOPlannedList& list = begin->second;
if (list.empty())
{
m_timePoints.erase(begin);
}
if (m_currentTime > newTime)
{
newTime = m_currentTime;
}
if (m_mode == RTM_Sync)
{
m_msec_wait += (newTime - m_nextTime) * 3600.0 * 1000.0 / m_showRate;
if (m_msec_wait > 0)
{
if (newTime != m_startTime)
{
if (m_speed > DBL_MIN)
{
m_msec_wait = m_msec_wait / m_speed;
}
else
{
m_msec_wait = m_msec_wait / DBL_MIN;
}
boost::posix_time::ptime systime_current = boost::posix_time::microsec_clock::local_time();
m_msec_prev = getMSec(systime_current);
}
else
{
m_msec_wait = 0;
}
}
}
m_nextTime = newTime;
return true;
}
else
{
// Окончание моделирования - нет больше событий
onNothingMoreToDo();
return false;
}
}
}
returnValue ShootingMethod::logTrajectory( const OCPiterate &iter ){
if( integrator == 0 ) return SUCCESSFUL_RETURN;
int i, j;
double T,t1,t2,h;
BooleanType needToRescale = BT_FALSE;
VariablesGrid logX, logXA, logP, logU, logW, logI, tmp,tmp2;
Matrix intervalPoints(N+1,1);
intervalPoints(0,0) = 0.0;
j = 0;
for( i = 0; i < N; i++ ){
if( (int) breakPoints(j,0) <= i ) j++;
int i1 = (int) breakPoints(j,1);
int i2 = (int) breakPoints(j,2);
if( i1 >= 0 ) t1 = iter.p->operator()(0,i1);
else t1 = breakPoints(j,3);
if( i2 >= 0 ) t2 = iter.p->operator()(0,i2);
else t2 = breakPoints(j,4);
if( i == 0 ) T = t1;
integrator[i]->getX( tmp );
intervalPoints(i+1,0) = intervalPoints(i,0) + tmp.getNumPoints();
if ( ( i1 >= 0 ) || ( i2 >= 0 ) )
{
if ( iter.isInSimulationMode() == BT_FALSE )
{
h = t2-t1;
needToRescale = BT_TRUE;
}
}
else
{
h = 1.0;
needToRescale = BT_FALSE;
}
if( nx > 0 ){ if ( needToRescale == BT_TRUE ) rescale( &tmp, T, h );
logX .appendTimes( tmp );
}
if( na > 0 ){ integrator[i]->getXA( tmp );
if ( needToRescale == BT_TRUE ) rescale( &tmp, T, h );
logXA.appendTimes( tmp );
}
if( np > 0 ){ tmp2.init( np, tmp.getFirstTime(),tmp.getLastTime(),2 );
if ( iter.isInSimulationMode( ) == BT_FALSE )
tmp2.setAllVectors( iter.p->getVector(0) );
else
tmp2.setAllVectors( iter.p->getVector(i) );
logP .appendTimes( tmp2 );
}
if( nu > 0 ){ tmp2.init( nu, tmp.getFirstTime(),tmp.getLastTime(),2 );
tmp2.setAllVectors(iter.u->getVector(i));
logU .appendTimes( tmp2 );
}
if( nw > 0 ){ tmp.init( nw, tmp );
tmp.setAllVectors(iter.w->getVector(i));
logW .appendTimes( tmp );
}
integrator[i]->getI( tmp );
if ( needToRescale == BT_TRUE ) rescale( &tmp, T, h );
logI .appendTimes( tmp );
T = tmp.getLastTime();
}
// WRITE DATA TO THE LOG COLLECTION:
// ---------------------------------
if( nx > 0 ) setLast( LOG_DIFFERENTIAL_STATES, logX );
if( na > 0 ) setLast( LOG_ALGEBRAIC_STATES , logXA );
if( np > 0 ) setLast( LOG_PARAMETERS , logP );
if( nu > 0 ) setLast( LOG_CONTROLS , logU );
if( nw > 0 ) setLast( LOG_DISTURBANCES , logW );
setLast( LOG_INTERMEDIATE_STATES , logI );
setLast( LOG_DISCRETIZATION_INTERVALS, intervalPoints );
return SUCCESSFUL_RETURN;
}
