void QLogicCircuitShapeConnector::updatePosition()
{
    prepareGeometryChange();
    m_breakPoints = breakPoints();
    calcBoundingRect();
    update();
}
Esempio n. 2
0
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;
}
Esempio n. 3
0
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;
		}
	}
}
Esempio n. 4
0
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;
}