VP1ExecutionScheduler Class Reference

#include <VP1ExecutionScheduler.h>

Inheritance diagram for VP1ExecutionScheduler:

Collaboration diagram for VP1ExecutionScheduler:

Classes
class	Imp

Public Types
enum	CruiseMode { NONE, TAB, EVENT, BOTH }

Signals
void	refreshingStatusChanged (bool)

Public Member Functions
void	setCruiseMode (const CruiseMode &)
bool	executeNewEvent (const int &runnumber, const unsigned long long &eventnumber, const unsigned &triggerType=0, const unsigned &time=0)
	VP1ExecutionScheduler (QObject *parent, StoreGateSvc *eventStore, StoreGateSvc *detStore, ISvcLocator *svcLocator, IToolSvc *toolSvc, VP1AvailEvents *availEvents)
virtual	~VP1ExecutionScheduler ()
void	bringFromConstructedToReady (IVP1ChannelWidget *)
void	uncreateAndDelete (IVP1ChannelWidget *)
bool	isRefreshing () const
bool	hasAllActiveSystemsRefreshed (IVP1ChannelWidget *) const
QString	nextRequestedEventFile () const
void	setNextRequestedEventFile (const QString &)
QStringList	userRequestedFiles ()
QString	saveSnaphsotToFile (IVP1System *s, bool batch=false)

Static Public Member Functions
static VP1ExecutionScheduler *	init (StoreGateSvc *eventStore, StoreGateSvc *detStore, ISvcLocator *svcLocator, IToolSvc *toolSvc, QStringList joboptions, QString initialCruiseMode="NONE", unsigned initialCruiseSeconds=10, QString singleEventSource="", QString singleEventLocalTmpDir="", unsigned localFileCacheLimit=10, QStringList availableLocalInputDirectories=QStringList())
static void	cleanup (VP1ExecutionScheduler *)

Private Slots
void	processSystemForRefresh ()
void	updateProgressBarDuringRefresh ()
void	channelCreated (IVP1ChannelWidget *)
void	channelUncreated (IVP1ChannelWidget *)
void	startRefreshQueueIfAppropriate ()
void	systemNeedErase ()
void	performCruise ()

Private Member Functions
void	refreshSystem (IVP1System *)
void	eraseSystem (IVP1System *)
void	actualUncreateAndDelete (IVP1ChannelWidget *)

Private Attributes
Imp *	m_d

Detailed Description

Definition at line 42 of file VP1ExecutionScheduler.h.

Member Enumeration Documentation

CruiseMode

enum VP1ExecutionScheduler::CruiseMode

Enumerator
NONE
TAB
EVENT
BOTH

Definition at line 49 of file VP1ExecutionScheduler.h.

                  { NONE,
            TAB, //Cycles to a new tab at a fixed interval (when it is loaded - gives soonvisible bonus)
            EVENT,//Proceeds to a new event at a fixed interval (counting from when all visible channels are refreshed)
            BOTH };//Cycles through all tabs and loads next event when they have all been shown.

Constructor & Destructor Documentation

VP1ExecutionScheduler()

VP1ExecutionScheduler::VP1ExecutionScheduler	(	QObject *	parent,
		StoreGateSvc *	eventStore,
		StoreGateSvc *	detStore,
		ISvcLocator *	svcLocator,
		IToolSvc *	toolSvc,
		VP1AvailEvents *	availEvents
	)

Definition at line 233 of file VP1ExecutionScheduler.cxx.

: QObject(parent), m_d(new Imp)
{
    m_d->availEvents = availEvents;
    VP1AthenaPtrs::setPointers(eventStore,detStore,svcLocator,toolSvc);
    m_d->eventsProcessed = 0;
 
    m_d->scheduler = this;
    m_d->prioritiser = new VP1Prioritiser(this);
    m_d->mainwindow = new VP1MainWindow(this,availEvents);//mainwindow takes ownership of available events
    
    m_d->batchMode = false;
    m_d->batchUtilities = nullptr;
    m_d->batchModeAllEvents = false;
    m_d->batchModeNEvents = 0;
    m_d->batchModeRandomConfig = false;
 
    m_d->allSystemsRefreshed = false;
    m_d->goingtonextevent=true;
    m_d->currentsystemrefreshing=0;
    m_d->eraseJustAfterRefresh=false;
    m_d->postponedUncreateAndDeleteCW=0;
    m_d->refreshtimer = new QTimer(this);
    connect(m_d->refreshtimer, SIGNAL(timeout()), this, SLOT(processSystemForRefresh()));
 
    //Connect signals to ensure that prioritiser knows about present channels and their visibility:
    connect(m_d->mainwindow->channelManager(),SIGNAL(newChannelCreated(IVP1ChannelWidget*)),m_d->prioritiser, SLOT(channelCreated(IVP1ChannelWidget*)));
    connect(m_d->mainwindow->channelManager(),SIGNAL(channelUncreated(IVP1ChannelWidget*)),m_d->prioritiser, SLOT(channelUncreated(IVP1ChannelWidget*)));
    connect(m_d->mainwindow->channelManager(),SIGNAL(newChannelCreated(IVP1ChannelWidget*)),this, SLOT(channelCreated(IVP1ChannelWidget*)));
    connect(m_d->mainwindow->channelManager(),SIGNAL(channelUncreated(IVP1ChannelWidget*)),this, SLOT(channelUncreated(IVP1ChannelWidget*)));
 
    connect(m_d->mainwindow->tabManager(),SIGNAL(visibleChannelsChanged(const QSet<IVP1ChannelWidget*>&,const QSet<IVP1ChannelWidget*>&,const double&)),
            m_d->prioritiser,SLOT(visibleChannelsChanged(const QSet<IVP1ChannelWidget*>&,const QSet<IVP1ChannelWidget*>&,const double&)));
 
 
    // Init and show the main window of VP1
    SoQt::init( m_d->mainwindow );// SoQt::init( "VP1" );
 
    // check if 'batch mode'
    bool batchMode = VP1QtUtils::environmentVariableIsSet("VP1_BATCHMODE"); // ::getenv("VP1_BATCHMODE");
    if(VP1Msg::debug()){
        qDebug() << "VP1ExecutionScheduler:: Do we run in 'batch' mode?" << batchMode;
    }
    if (batchMode) {
        VP1Msg::messageWarningAllRed("User has run VP1 in 'batch-mode', so the main window of the program will not be shown.");
        m_d->batchMode = true;
 
        // check if the user set the "all events" option as well
        m_d->batchModeAllEvents = VP1QtUtils::environmentVariableIsSet("VP1_BATCHMODE_ALLEVENTS");
 
        // check if the user set the "random configuration file" option as well
        m_d->batchModeRandomConfig = VP1QtUtils::environmentVariableIsSet("VP1_BATCHMODE_RANDOMCONFIG");
    }
    else {
        m_d->mainwindow->show();
    }
 
 
    m_d->pb = m_d->mainwindow->progressbar;
    m_d->pbtimer = new QTimer(this);
    connect(m_d->pbtimer, SIGNAL(timeout()), this, SLOT(updateProgressBarDuringRefresh()));
    m_d->calctimethisevent=0;
    m_d->currentrefreshsystemestimate=0;
 
    m_d->cruisemode = NONE;
    m_d->cruisetimer = new QTimer(this);
    connect(m_d->cruisetimer, SIGNAL(timeout()), this, SLOT(performCruise()));
    m_d->cruisetab_waitingtoproceed=false;
 
    #if defined BUILDVP1LIGHT
        bool checkDisplayMouseClicks = VP1QtUtils::expertSettingIsOn("general","ExpertSettings/VP1_DISPLAY_MOUSE_CLICKS");
    #else
        bool checkDisplayMouseClicks = VP1QtUtils::environmentVariableIsOn("VP1_DISPLAY_MOUSE_CLICKS");
    #endif
 
    if (checkDisplayMouseClicks) {
        m_d->globalEventFilter = new Imp::GlobalEventFilter;
        qApp->installEventFilter(m_d->globalEventFilter);
    } else {
        m_d->globalEventFilter = 0;
    }
 
    VP1AvailEvtsHttps* availEvtsHttps = dynamic_cast<VP1AvailEvtsHttps*>(availEvents);
    if(availEvtsHttps) {
        m_d->skipEvent = true;
        VP1Authenticator* auth = new VP1Authenticator(m_d->mainwindow,availEvtsHttps->fileinfoLocation());
 
        connect(auth,SIGNAL(authenticationSuccessful(QNetworkAccessManager*)),
                availEvtsHttps,SLOT(start(QNetworkAccessManager*)));
        connect(availEvtsHttps,SIGNAL(freshEventsChanged()),
                auth,SLOT(accept()));
 
        SoQt::init(auth);
        auth->exec();
        delete auth;
    }
    else
        m_d->skipEvent = false;
}

~VP1ExecutionScheduler()

VP1ExecutionScheduler::~VP1ExecutionScheduler ( )

virtual

Definition at line 339 of file VP1ExecutionScheduler.cxx.

{
    m_d->refreshtimer->stop();
    delete m_d->batchUtilities;
    delete m_d->mainwindow;
    delete m_d->prioritiser;
    delete m_d->globalEventFilter;
    delete m_d;
}

Member Function Documentation

actualUncreateAndDelete()

void VP1ExecutionScheduler::actualUncreateAndDelete ( IVP1ChannelWidget *  cw )

private

Definition at line 1110 of file VP1ExecutionScheduler.cxx.

{
    assert(cw->state()==IVP1ChannelWidget::READY);
    cw->setUpdatesEnabled(false);//Just because...
 
    //From this point on, we are not interested in signals from the channel (and its systems) that could disturb us:
    std::set<IVP1System *>::iterator itsys, itsysE = cw->systems().end();
    for (itsys = cw->systems().begin();itsys!=itsysE;++itsys) {
        (*itsys)->blockSignals(true);
        disconnect(*itsys,0,0,0);
    }
    cw->blockSignals(true);
    disconnect(cw,0,0,0);
 
    //Make sure that all systems gets in the ERASED state. Throw assert if any is presently refreshing (BAD PROGRAMMER!!)
    for (itsys = cw->systems().begin();itsys!=itsysE;++itsys) {
        assert(m_d->currentsystemrefreshing!=(*itsys));
        if ((*itsys)->state()==IVP1System::REFRESHED)
            eraseSystem(*itsys);
    }
 
    //Uncreate systems:
    for (itsys = cw->systems().begin();itsys!=itsysE;++itsys) {
        assert((*itsys)->state()==IVP1System::ERASED);
        (*itsys)->uncreate();
        (*itsys)->setState(IVP1System::UNCREATED);
    }
 
    //Uncreate channel:
    assert(cw->state()==IVP1ChannelWidget::READY);
    cw->uncreate();//Fixme: Return codes!!
    cw->setState(IVP1ChannelWidget::UNCREATED);
 
    assert(cw->state()==IVP1ChannelWidget::UNCREATED);
 
    cw->deleteControllers();//Also deletes system controllers.
 
    //Delete:
    cw->deleteLater();
 
}

bringFromConstructedToReady()

void VP1ExecutionScheduler::bringFromConstructedToReady

(

IVP1ChannelWidget *

cw

)

Definition at line 1069 of file VP1ExecutionScheduler.cxx.

{
    assert(cw->state()==IVP1ChannelWidget::CONSTRUCTED);
 
    connect(cw,SIGNAL(message(const QString&)),m_d->mainwindow,SLOT(channelAddToMessageBox(const QString&)));
 
    std::set<IVP1System *>::iterator itsys, itsysE = cw->systems().end();
    for (itsys = cw->systems().begin();itsys!=itsysE;++itsys) {
        assert((*itsys)->state()==IVP1System::CONSTRUCTED);
        connect((*itsys),SIGNAL(sysmessage(const QString&)),m_d->mainwindow,SLOT(systemAddToMessageBox(const QString&)));
    }
    itsysE = cw->systems().end();
    for (itsys = cw->systems().begin();itsys!=itsysE;++itsys) {
        (*itsys)->setCanRegisterController(true);
        (*itsys)->create(VP1AthenaPtrs::detectorStore());
        (*itsys)->setCanRegisterController(false);
        (*itsys)->setState(IVP1System::ERASED);
    }
    assert(cw->state()==IVP1ChannelWidget::CONSTRUCTED);
    cw->setCanRegister(true,false);//Ok to register controllers during create.
    cw->create();
    cw->setCanRegister(false,false);
    cw->setState(IVP1ChannelWidget::READY);
 
    assert(cw->state()==IVP1ChannelWidget::READY);
    //Fixme: statusbar!!!!!
}

channelCreated

void VP1ExecutionScheduler::channelCreated ( IVP1ChannelWidget *  cw )

privateslot

Definition at line 767 of file VP1ExecutionScheduler.cxx.

{
    std::set<IVP1System*>::const_iterator it, itE = cw->systems().end();
    for (it=cw->systems().begin();it!=itE;++it) {
        qInfo() << "System name:" << (*it)->name();
        connect(*it,SIGNAL(inactiveSystemTurnedActive()),this,SLOT(startRefreshQueueIfAppropriate()));
        connect(*it,SIGNAL(needErase()),this,SLOT(systemNeedErase()));
        #ifdef BUILDVP1LIGHT
            connect(*it,SIGNAL(signalLoadEvent(IVP1System*)),this,SLOT(passEvent(IVP1System*)));
        #endif // BUILDVP1LIGHT
    }
    startRefreshQueueIfAppropriate();
 
}

channelUncreated

void VP1ExecutionScheduler::channelUncreated ( IVP1ChannelWidget *  cw )

privateslot

Definition at line 783 of file VP1ExecutionScheduler.cxx.

{
    std::set<IVP1System*>::const_iterator it, itE = cw->systems().end();
    for (it=cw->systems().begin();it!=itE;++it)
        disconnect(*it,SIGNAL(inactiveSystemTurnedActive()),this,SLOT(startRefreshQueueIfAppropriate()));
}

cleanup()

void VP1ExecutionScheduler::cleanup ( VP1ExecutionScheduler *  scheduler )

static

Definition at line 506 of file VP1ExecutionScheduler.cxx.

{
    #if defined BUILDVP1LIGHT
    bool checkEnableInformOnEndOfJob = VP1QtUtils::expertSettingIsOn("expert","ExpertSettings/VP1_ENABLE_INFORM_ON_END_OF_JOB");
    #else
    bool checkEnableInformOnEndOfJob = VP1QtUtils::environmentVariableIsOn("VP1_ENABLE_INFORM_ON_END_OF_JOB");
    #endif
 
    if (checkEnableInformOnEndOfJob && ( !scheduler||!(scheduler->m_d->mainwindow->userRequestedExit()) ) )
        QMessageBox::information(0, "End of job reached",Qt::convertFromPlainText("Job about to end.\n\nThis is most"
                " likely since there are no more available events to process."),QMessageBox::Ok,QMessageBox::Ok);
 
    if (scheduler) {
        delete scheduler;
//      qApp->processEvents(QEventLoop::DeferredDeletion); // Qt 4
        qApp->processEvents(); // Qt 5
        qApp->deleteLater(); // Qt 5
 
        Imp::warnIfWidgetsAlive();
        VP1HelperClassBase::warnUndeletedInstances();
 
        delete qApp;
        SoQt::done();
    }
 
 
 
    const QString quickExitEnv("VP1_HARD_EXIT_AT_END");
 
    #if defined BUILDVP1LIGHT
        bool checkHardExitAtEnd = VP1QtUtils::expertSettingIsOn("expert","ExpertSettings/"+quickExitEnv);
    #else
        bool checkHardExitAtEnd = VP1QtUtils::environmentVariableIsOn(quickExitEnv);
    #endif
 
    if (checkHardExitAtEnd) {
        VP1Msg::message("Hard job exit (unset "+quickExitEnv+" to disable this behaviour).");
        exit(0);
    }
 
}

eraseSystem()

void VP1ExecutionScheduler::eraseSystem ( IVP1System *  s )

private

Definition at line 713 of file VP1ExecutionScheduler.cxx.

                                                    {
 
    VP1Msg::messageDebug("VP1ExecutionScheduler::eraseSystem()");
 
    assert(s->state()==IVP1System::REFRESHED);
        // cppcheck-suppress assertWithSideEffect
    assert(!s->isRefreshing());
 
    QString base =  QString(s->name())+" from channel "+s->channel()->unique_name();
    m_d->mainwindow->statusBar()->showMessage( "Erasing system ["+base+"]" );
    VP1Msg::messageDebug("ERASING - " + base);
 
    s->disallowUpdateGUI();
    s->erase();//fixme: time?
    s->setState(IVP1System::ERASED);
    m_d->mainwindow->statusBar()->showMessage( "Post-erase update to channel ["+base+"]" );
    s->channel()->systemErased(s);//fixme: time?
    m_d->mainwindow->statusBar()->clearMessage();
}

executeNewEvent()

bool VP1ExecutionScheduler::executeNewEvent	(	const int &	runnumber,
		const unsigned long long &	eventnumber,
		const unsigned &	triggerType = 0,
		const unsigned &	time = 0
	)

Definition at line 590 of file VP1ExecutionScheduler.cxx.

{
    VP1Msg::messageDebug("VP1ExecutionScheduler::executeNewEvent()");
 
    m_d->nextRequestedEvent="";
 
#if defined BUILDVP1LIGHT
    unused(runnumber,eventnumber,triggerType,time); // silences the "unused parameter" warnings when building VP1Light. In this case, in fact, those variables will be used later in loadEvent().
    if ( !firstlaunch ) {
        if ( (getEvtNr() >= 0) && (getEvtNr() < m_totEvtNr) ) { // If selected event number is available in file
            loadEvent();
            //Pass the event to the AOD System
            std::set<IVP1System *>::iterator itsys, itsysE = m_d->mainwindow->tabManager()->selectedChannelWidget()->systems().end();
            for (itsys = m_d->mainwindow->tabManager()->selectedChannelWidget()->systems().begin();itsys!=itsysE;++itsys) {
                if((*itsys)->name()=="Analysis"){
                    passEvent(*itsys);
                }
            }
        }
        else if ( (getEvtNr() < 0) && (getEvtNr() >= m_totEvtNr) ) {
            QMessageBox msgBox;
            msgBox.setWindowTitle("No more events");
            msgBox.setText("There are no more events in this file. Returning to previous event.");
            msgBox.setIcon(QMessageBox::Icon::Information);
            msgBox.exec();
        }
    }
    else{
        firstlaunch = false;
    }
#else
    m_d->mainwindow->setRunEvtNumber(runnumber, eventnumber, triggerType, time, !m_d->skipEvent);
#endif
 
    m_d->goingtonextevent = false;
    m_d->calctimethisevent=0;
    m_d->currentrefreshsystemestimate=0;
    m_d->updateProgressBar();
 
    assert(!m_d->refreshtimer->isActive());//fixme: -> if.
 
 
    VP1Msg::messageDebug("calling refreshtimer->start()...");
    m_d->refreshtimer->start();
 
    VP1Msg::messageDebug("calling initCruise...");
    m_d->initCruise();
    VP1Msg::messageDebug("initCruise called.");
 
    //Flush event queue before reenabling controllers, etc.:
    qApp->processEvents();
    VP1Msg::messageDebug("qApp->processEvents() called.");
 
    //Enable various user input:
    m_d->mainwindow->groupBox_channelcontrols->setEnabled(true);
    m_d->mainwindow->groupBox_cruise->setEnabled(true);
    m_d->mainwindow->groupBox_event->setEnabled(true);
 
 
    VP1Msg::messageDebug("batch mode: " + QString::number(m_d->batchMode));
 
    if (m_d->batchModeRandomConfig) {
        VP1Msg::messageDebug("User chose 'batch' and 'batch-random-config'. So we now replace the configuration with a random one from the input set...");
        QString randomConfigFile = QString::fromStdString( m_d->batchUtilities->getRandomConfigFile() );
        m_d->mainwindow->replaceConfigurationFile(randomConfigFile);
    }
 
    if ( m_d->batchMode && m_d->allVisibleRefreshed() ) { // or m_d->allSystemsRefreshed ???
            VP1Msg::messageDebug("We're in batch mode, skipping the execution of the GUI...");
    } else {
        VP1Msg::messageDebug("skipEvent: " + QString::number(m_d->skipEvent));
        if(m_d->skipEvent) {
            VP1Msg::messageDebug("skipEvent");
            m_d->skipEvent=false;
            m_d->mainwindow->nextEvent();
        }
        else {
            VP1Msg::messageDebug("calling qApp->exec()...");
            qApp->exec();//NOTE!!! We then exit the exec() when someone pushes the "next event" button.
        }
    }
 
    VP1Msg::messageDebug("Disabling user inputs...");
    //Disable various user input:
    m_d->mainwindow->groupBox_channelcontrols->setEnabled(false);
    m_d->mainwindow->groupBox_cruise->setEnabled(false);
    m_d->mainwindow->groupBox_event->setEnabled(false);
 
    m_d->goingtonextevent = true;
 
    if (m_d->refreshtimer->isActive()) {
        m_d->refreshtimer->stop();
    }
    m_d->pb->hide();
    m_d->pb->reset();
    m_d->pbtimer->stop();
    //Fixme: Refresh all accumulators that still needs refresh (or just have the button disabled until now)
 
    //Fixme: wait here until end of any active refreshing...
 
    VP1Msg::messageDebug("Erasing systems...");
    assert(!m_d->currentsystemrefreshing);
    for (IVP1System*s : m_d->prioritiser->getSystemsToEraseByPriority()) {
        qApp->processEvents(QEventLoop::ExcludeUserInputEvents|QEventLoop::ExcludeSocketNotifiers);
        eraseSystem(s);
    }
 
    ++m_d->eventsProcessed; // we don't use Athena's tools for this, so we can use this in VP1Light as well.
    VP1Msg::messageDebug("event processed. " + QString::number(m_d->eventsProcessed) + " events processed so far.");
 
    //Let channels know we are going to the next event now:
    for (IVP1ChannelWidget*cw :  m_d->mainwindow->tabManager()->allChannels()) {
        cw->goingToNextEvent();
    }
 
    qApp->processEvents(QEventLoop::ExcludeUserInputEvents|QEventLoop::ExcludeSocketNotifiers);
 
 
    VP1Msg::messageDebug("mainwindow->mustQuit ? " + QString::number(m_d->mainwindow->mustQuit()) );
    return !m_d->mainwindow->mustQuit();
}

hasAllActiveSystemsRefreshed()

bool VP1ExecutionScheduler::hasAllActiveSystemsRefreshed

(

IVP1ChannelWidget *

cw

)

const

Definition at line 1186 of file VP1ExecutionScheduler.cxx.

{
    VP1Msg::messageDebug("VP1ExecutionScheduler::hasAllActiveSystemsRefreshed() - channelWidget: " + cw->name());
 
    std::set<IVP1System*>::const_iterator it, itE = cw->systems().end();
    int i=0;
    for (it=cw->systems().begin();it!=itE;++it) {
 
        /*
         * enum State { CONSTRUCTED=0, REFRESHED, ERASED, UNCREATED };
         * enum ActiveState { ON=0, OFF };//Whether it is part of the erase/refresh cycle.
         */
        if (VP1Msg::verbose()) {
            QString name = QString((*it)->name());
            QString active = QString::number((*it)->activeState());
            QString state = QString::number((*it)->state());
            std::cout << i << " - name: " << name.toStdString() << " - active: " << active.toStdString() << " - refreshed: " << state.toStdString() << std::endl;
        }
        if ((*it)->activeState()==IVP1System::ON&&(*it)->state()!=IVP1System::REFRESHED)
            return false;
 
        i++;
    }
 
    return true;
}

init()

VP1ExecutionScheduler * VP1ExecutionScheduler::init ( StoreGateSvc *  eventStore, StoreGateSvc *  detStore, ISvcLocator *  svcLocator, IToolSvc *  toolSvc, QStringList  joboptions, QString  initialCruiseMode = "NONE", unsigned  initialCruiseSeconds = 10, QString  singleEventSource = "", QString  singleEventLocalTmpDir = "", unsigned  localFileCacheLimit = 10, QStringList  availableLocalInputDirectories = QStringList()  )

static

Definition at line 350 of file VP1ExecutionScheduler.cxx.

{
    //First we make sure the DISPLAY variable is set (importing ROOT in
    //athena.py might cause it to be unset!).
    //
    //NB: The following might only be relevant in X11 build:
    if (VP1QtUtils::environmentVariableValue("DISPLAY").isEmpty()) {
        const bool unset(!VP1QtUtils::environmentVariableIsSet("DISPLAY"));
        QString alternative = VP1QtUtils::environmentVariableValue("DISPLAY_ORIG");
        if (alternative.isEmpty()) {
            VP1Msg::message("ERROR: The DISPLAY environment variable is "+QString(unset?"not set":"empty")+".");
            VP1Msg::message("This might be because something else in Athena has disabled it.");
            VP1Msg::message("You can work around this problem by setting "
                    "the DISPLAY_ORIG environment variable to the contents of DISPLAY before launching your job.");
            VP1Msg::message("E.g., in bash do:");
            VP1Msg::message("  export DISPLAY_ORIG=$DISPLAY");
            VP1Msg::message("");
            VP1Msg::message("For the current job, I will try with DISPLAY=\":0.0\", which is the correct value when running locally.");
            alternative=":0.0";
        } else {
            VP1Msg::message("WARNING: The DISPLAY environment variable is "+QString(unset?"not set":"empty")+". Setting to value found in DISPLAY_ORIG");
        }
        VP1Msg::message("WARNING: Setting DISPLAY variable to '"+alternative+"'");
        VP1QtUtils::setEnvironmentVariable("DISPLAY",alternative);
    }
 
 
 
    QCoreApplication::setOrganizationName("ATLAS");
    #if defined BUILDVP1LIGHT
        QCoreApplication::setApplicationName("VP1Light");
    #else
        QCoreApplication::setApplicationName("VP1");
    #endif
    QCoreApplication::setAttribute(Qt::AA_UseDesktopOpenGL);
 
 
 
    // here we check if the main (and unique!) Qt application has been initialized already. If not we initialize it.
    if (qApp) {
        VP1Msg::message("VP1ExecutionScheduler::init ERROR: QApplication already initialized. Expect problems!!!");
    } else {
        //NB: Static to avoid scope-problems:
        static int argc=1;
        static char execpath[] = "/some/fake/executable/vp1";
        static char *argv[2];
        //    VP1Msg::messageDebug("setting argv[0]...");
        argv[0] = execpath;
        //    VP1Msg::messageDebug("setting argv[1]...");
        argv[1] = NULL;
        // instead of using the default Qt QApplication class,
        // we now use our custom inherited class where we
        // reimplemented the notify() method, in order to catch
        // C++ exceptions, especially while running it inside Athena.
        //new QApplication(argc, argv);
        new VP1QtApplication(argc, argv);
    }
 
    VP1AvailEvents * availEvents(0);
    if (!singleEventSource.isEmpty()&&!singleEventLocalTmpDir.isEmpty()) {
        const bool httpmode = singleEventSource.startsWith("http://");
        const bool httpsmode = singleEventSource.startsWith("https://");
        //Create appropriate instance:
        if (httpmode) {
            availEvents = new VP1AvailEvtsHttp(singleEventSource, 60/*update interval*/, 30*60/*time cut for new*/, singleEventLocalTmpDir,localFileCacheLimit);
        } else if(httpsmode) {
            availEvents = new VP1AvailEvtsHttps(singleEventSource, 1000/*update interval*/, 30*60/*time cut for new*/, singleEventLocalTmpDir,localFileCacheLimit);
        } else {
            availEvents = new VP1AvailEvtsLocalDir(5*60/*time cut for new*/, singleEventSource,
                    singleEventLocalTmpDir,localFileCacheLimit);
            static_cast<VP1AvailEvtsLocalDir*>(availEvents)->setAvailableSourceDirectories(availableLocalInputDirectories);
 
        }
 
    }
 
    VP1ExecutionScheduler*scheduler = new VP1ExecutionScheduler(0,eventStore,detStore,svcLocator,toolSvc,availEvents);
 
    //Pass on "joboptions"
    if (joboptions.empty()) {
        //scheduler->m_d->mainwindow->tabManager()->addNewTab("My Tab");
    } else {
        qDebug() << "config files: " << joboptions; // DEBUG
        for (QString opt : joboptions)
              scheduler->m_d->mainwindow->loadConfigurationFromFile(opt);
 
        if ( scheduler->m_d->batchMode ) {
            if (scheduler->m_d->batchModeRandomConfig ) {
                if (joboptions.size() != 0 ) {
                    scheduler->m_d->batchUtilities = new VP1BatchUtilities( qstringlistToVecString(joboptions) );
                }
            }
            QString batchNevents = VP1QtUtils::environmentVariableValue("VP1_BATCHMODE_NEVENTS");
            if (batchNevents > 0 ) {
                scheduler->m_d->batchModeNEvents = batchNevents.toInt();
            }
        }
    }
 
 
    if (scheduler->m_d->mainwindow->tabWidget_central->count()<=1) {
        if (initialCruiseMode=="TAB") {
            VP1Msg::message("ERROR: Can not start in cruisemode TAB unless there are at least 2 tabs loaded from initial .vp1 files. Reverting to cruise mode NONE.");
            initialCruiseMode="NONE";
        } else if (initialCruiseMode=="BOTH") {
            VP1Msg::message("ERROR: Can not start in cruisemode BOTH unless there are at least 2 tabs loaded from initial .vp1 files. Reverting to cruise mode EVENT.");
            initialCruiseMode="EVENT";
        }
    }
 
    //Set default value of cruisemode (dont use setCruiseMode() since it starts timers):
    if (initialCruiseMode=="EVENT") {
        scheduler->m_d->cruisemode=EVENT;
        scheduler->m_d->mainwindow->radioButton_cruise_event->setChecked(true);
        scheduler->m_d->mainwindow->pushButton_cruise->setChecked(true);
 
    } else if (initialCruiseMode=="TAB") {
        scheduler->m_d->cruisemode=TAB;
        scheduler->m_d->mainwindow->radioButton_cruise_tab->setChecked(true);
        scheduler->m_d->mainwindow->pushButton_cruise->setChecked(true);
    } else if (initialCruiseMode=="BOTH") {
        scheduler->m_d->cruisemode=BOTH;
        scheduler->m_d->mainwindow->radioButton_cruise_both->setChecked(true);
        scheduler->m_d->mainwindow->pushButton_cruise->setChecked(true);
    } else {
        if (initialCruiseMode!="NONE")
            VP1Msg::message("ERROR: unknown initial cruise mode "+initialCruiseMode+" (valid are NONE/EVENT/TAB/BOTH). Assuming NONE.");
        scheduler->m_d->cruisemode=NONE;
        scheduler->m_d->mainwindow->radioButton_cruise_event->setChecked(true);
        scheduler->m_d->mainwindow->pushButton_cruise->setChecked(false);
    }
 
    scheduler->m_d->mainwindow->request_cruisemodechange();
 
    int cruisesecs = ( initialCruiseSeconds == 0 ? 0 :
            std::max(scheduler->m_d->mainwindow->spinBox_cruise->minimum(),
                    std::min(scheduler->m_d->mainwindow->spinBox_cruise->maximum(),
                            static_cast<int>(initialCruiseSeconds))));
    if ( cruisesecs>0 )
        scheduler->m_d->mainwindow->spinBox_cruise->setValue(cruisesecs);
 
 
    return scheduler;
}

isRefreshing()

bool VP1ExecutionScheduler::isRefreshing

(

)

const

Definition at line 798 of file VP1ExecutionScheduler.cxx.

{
    return m_d->currentsystemrefreshing;
}

nextRequestedEventFile()

QString VP1ExecutionScheduler::nextRequestedEventFile

(

)

const

Definition at line 578 of file VP1ExecutionScheduler.cxx.

{
    return m_d->nextRequestedEvent;
}

performCruise

void VP1ExecutionScheduler::performCruise ( )

privateslot

Definition at line 1327 of file VP1ExecutionScheduler.cxx.

{
    //In any case, we should stop the timer (fixme: What if there are 0 visible channels - when will the timer get started again?):
    m_d->cruisetimer->stop();
 
    if (!m_d->mainwindow->okToProceedToNextEvent()) {
        //Hmm. Would like to cruise, but that is not ok. Check back in a few seconds.
        m_d->cruisetimer->start( (m_d->mainwindow->spinBox_cruise->value() > 5 ? 3000 : 1000) );
        return;
    }
 
    assert(!m_d->goingtonextevent);//Otherwise it is a bit silly?
 
    switch (m_d->cruisemode) {
    case NONE:
        assert(0&&"should never happen");
        break;
    case TAB:
        assert(m_d->cruisetab_waitingtoproceed==false);
        if (m_d->allSoonVisibleRefreshed()) {
            m_d->mainwindow->tabManager()->showNextTab();
            //If now all visible are refreshed, we start the timer again.
            if (m_d->allVisibleRefreshed())
                m_d->cruisetimer->start(m_d->mainwindow->spinBox_cruise->value()*1000);
        } else {
            m_d->cruisetab_waitingtoproceed=true;
        }
        break;
    case EVENT:
        m_d->mainwindow->goToNextEvent();
        VP1Msg::messageDebug("Crusing to next event");
        break;
    case BOTH:
        assert(0&&"Not implemented");
        VP1Msg::messageDebug("ERROR: BOTH cruise mode not implemented");
        break;
    default:
        assert(0&&"UNKNOWN CRUISE MODE");
        VP1Msg::messageDebug("ERROR: Unknown cruise mode");
        break;
    }
}

processSystemForRefresh

void VP1ExecutionScheduler::processSystemForRefresh ( )

privateslot

Definition at line 747 of file VP1ExecutionScheduler.cxx.

{
    assert(!m_d->goingtonextevent);
    if (m_d->currentsystemrefreshing)
        return;
 
    IVP1System * s = m_d->prioritiser->nextErasedActiveSystemByPriority();
    if (s) {
        refreshSystem(s);
    } else {
        assert(m_d->refreshtimer->isActive());//fixme: -> if. ???
        //if (refreshtimer->isActive())
        m_d->refreshtimer->stop();
        m_d->pb->hide();
        m_d->pb->reset();
        m_d->pbtimer->stop();
    }
}

refreshingStatusChanged

void VP1ExecutionScheduler::refreshingStatusChanged ( bool  )

signal

refreshSystem()

void VP1ExecutionScheduler::refreshSystem ( IVP1System *  s )

private

Definition at line 804 of file VP1ExecutionScheduler.cxx.

{
    QString sysname = s->name();
    VP1Msg::messageDebug("VP1ExecutionScheduler::refreshSystem() - system: " + sysname);
 
    m_d->updateProgressBar();
 
    assert(s->state()==IVP1System::ERASED);
    assert(s->activeState()==IVP1System::ON);
    assert(!m_d->currentsystemrefreshing);
 
    m_d->currentrefreshsystemestimate = m_d->prioritiser->beginTiming_Refresh(s);
    m_d->currentsystemrefreshing = s;
 
    QString base =  QString(s->name())+" from channel "+s->channel()->unique_name();
    m_d->mainwindow->statusBar()->showMessage( "Refreshing system ["+base+"]" );
 
    s->allowUpdateGUI();
    s->setRefreshing(true);
    refreshingStatusChanged(true);
    s->channel()->emitRefreshInfoChanged();
    s->refresh(VP1AthenaPtrs::eventStore());
    s->setState(IVP1System::REFRESHED);
    s->setRefreshing(false);
    s->disallowUpdateGUI();
 
    m_d->mainwindow->statusBar()->showMessage( "Post-refresh update to channel ["+base+"]" );
    s->channel()->systemRefreshed(s);//fixme: time independently?
 
    m_d->mainwindow->statusBar()->clearMessage();
    m_d->currentsystemrefreshing = 0;
    m_d->calctimethisevent += m_d->prioritiser->endTiming_Refresh();
    m_d->currentrefreshsystemestimate=0;
    m_d->updateProgressBar();
 
    refreshingStatusChanged(false);
    s->channel()->emitRefreshInfoChanged();
 
    VP1Msg::messageDebug("checking if all systems have refreshed...");
    if (hasAllActiveSystemsRefreshed(s->channel())) {
 
        VP1Msg::messageDebug("All systems refreshed! - last system refreshed! - system: " + sysname);
        s->channel()->lastOfActiveSystemsRefreshed();
 
        m_d->allSystemsRefreshed = true; // check if that is fine for multiple channels window: i.e. VP1 instances with a couple of 3DCkocktail windows, for example.
 
    } // end of hasAllActiveSystemsRefreshed()
 
    m_d->performPostRefreshCruiseActions(s->channel());
 
    if (m_d->eraseJustAfterRefresh) {
        //Someone asked to erase the system while it was refreshing!
        m_d->eraseJustAfterRefresh=false;
        //Check that it still needs to (maybe it was flicked back to ON by the impatient user)
        if (s->activeState()==IVP1System::OFF)
            eraseSystem(s);
    }
    if (m_d->postponedUncreateAndDeleteCW) {
        actualUncreateAndDelete(m_d->postponedUncreateAndDeleteCW);
        m_d->postponedUncreateAndDeleteCW=0;
    }
 
    VP1Msg::messageDebug("end of refreshing the system: " + sysname);
 
//  // if in "batch mode", now exit from VP1
//  if (m_d->batchMode) {
//
//
//      VP1Msg::messageWarningRed("'batch mode'. Now exiting VP1");
//
//      // N.B. calling QApplication::quit() here it makes move to the next event;
//      // NOTE!!!! It can be useful for a batch mode on all events of one single file!!
//      // TODO: An additional switch to the command line batch option should be implemented
//      //QApplication::quit();
//
//      //for the moment, we only quit VP1.
//      //To quit the application completely, we have to call "MainWindow::close()"
//      m_d->mainwindow->close();
//
//  }
 
    // ***************************
    // we now run all the things
    // that need to be done
    // after all tabs are drawn...
    // ***************************
    if ( hasAllActiveSystemsRefreshed(s->channel()) ) {
 
 
        if (m_d->batchMode) {
 
            VP1Msg::messageDebug("we are in 'batch-mode'...");
            VP1Msg::messageDebug("batchModeNEvents: " + QString::number(m_d->batchModeNEvents) + " - m_d->eventsProcessed: " + QString::number(m_d->eventsProcessed) );
 
            // saving the snapshot of the 3D window to a file
            QString save_ok = saveSnaphsotToFile(s, true);
            if (save_ok == "") {
                VP1Msg::messageWarningAllRed("FAILED! The snapshot for the channel '" + s->channel()->name() + "' has not been saved!");
            } else {
                VP1Msg::message("OK! Snapshot saved to file: " + save_ok);
            }
 
 
            if (m_d->batchModeAllEvents) {
                VP1Msg::messageWarningAllRed("******************************************************************");
                VP1Msg::messageWarningAllRed("'batch mode' with 'all events' option. Moving to the next event...");
                VP1Msg::messageWarningAllRed("******************************************************************");
                // N.B. calling QApplication::quit() here it makes VP1 move to the next event;
                QApplication::quit();
                // Now, VP1ExecutionScheduler::executeNewEvent() will end, then VP1Gui::executeNewEvent() will end, then they will start again: first VP1Gui then VP1ExecutionScheduler.
            } else if ( m_d->batchModeNEvents > 0 ) {
                if ( m_d->batchModeNEvents == m_d->eventsProcessed+1) { // here we use +1 because this is performed after the creation of the event snapshot. //TODO: maybe we can move this to a more natural place, at the beginning or at the end of an event
                    VP1Msg::messageWarningAllRed("******************************************************************");
                    VP1Msg::messageWarningAllRed("'batch mode' with 'batch-n-events' option. Processed the " + QString::number(m_d->eventsProcessed+1) + " events set by the user. Now exiting VP1");
                    VP1Msg::messageWarningAllRed("******************************************************************");
                    m_d->mainwindow->close();
                } else {
                    VP1Msg::messageWarningAllRed("'batch mode' with 'batch-n-events' option. Moving to the next event...");
                    // N.B. calling QApplication::quit() here it makes VP1 move to the next event;
                    QApplication::quit();
                    // Now, VP1ExecutionScheduler::executeNewEvent() will end, then VP1Gui::executeNewEvent() will end, then they will start again: first VP1Gui then VP1ExecutionScheduler.
                }
            }
            else {
                // We come here if the user did not choose to run batch mode on all events.
                // Thus, we want to close VP1 completely.
                // So, in order to do that, we have to call "MainWindow::close()"
                VP1Msg::messageWarningRed("'batch mode'. Done. Now exiting VP1");
                m_d->mainwindow->close();
            }
 
 
        }
    }
}

saveSnaphsotToFile()

QString VP1ExecutionScheduler::saveSnaphsotToFile	(	IVP1System *	s,
		bool	batch = false
	)

Definition at line 944 of file VP1ExecutionScheduler.cxx.

{
    QString chnlname = s->name().toLower();
    VP1Msg::messageDebug("VP1ExecutionScheduler::saveSnaphsotToFile() - taking the snapshot of the channel " + chnlname );
 
    QString currentsaveimagepath = VP1Settings::defaultFileSelectDirectory() + QDir::separator();
 
 
    if (batch) {
 
        VP1Msg::messageDebug("Note: 'batch-mode'");
 
 
        // A FOLDER CONTAINER
        QString folderName = "";
 
        // check if use specified an output folder for the batch job
        QString batchOutFolder = VP1QtUtils::environmentVariableValue("VP1_BATCHMODE_OUT_FOLDER"); // ::getenv("VP1_BATCHMODE");
        if ( ! (batchOutFolder == "") ) {
            VP1Msg::messageDebug("Setting 'batch' output folder from user's settings");
            folderName = batchOutFolder;
        }
        else
            folderName = "atlas_vp1_batch_images";
 
        // check if the folder already exists, if not make a new folder
        QDir dir(folderName);
        if (!dir.exists()) {
            dir.mkpath(".");
        }
 
        QString folder;
        if (folderName.startsWith("/"))
            folder = folderName + QDir::separator();
        else
            folder = currentsaveimagepath + folderName + QDir::separator();
 
        VP1Msg::messageDebug("folder set: " + folder);
 
 
        // EVENT INFO AND TIMESTAMP
 
        QString runnumb = QString::number(m_d->mainwindow->getRunNumber());
        QString evnumb = QString::number(m_d->mainwindow->getEventNumber());
        QString evtimestamp = QString::number(m_d->mainwindow->getEventTimestamp());
 
        time_t t_evttimestamp = m_d->mainwindow->getEventTimestamp();
        tm * human_evtimestamp = localtime(&t_evttimestamp);
 
        std::ostringstream h_evtimestamp_ostri;
        h_evtimestamp_ostri  << 1900 + human_evtimestamp->tm_year
                       << "-" << 1 + human_evtimestamp->tm_mon  // tm_mon is in the range [0, 11], so 1 must be added to get real months
                       << "-" << human_evtimestamp->tm_mday
                       << "T" << human_evtimestamp->tm_hour << "-" << human_evtimestamp->tm_min << "-" << human_evtimestamp->tm_sec << "CEST";
 
        std::string h_evtimestamp_str = h_evtimestamp_ostri.str();
        QString h_evtimestamp = QString::fromStdString(h_evtimestamp_str);
 
        // IMAGE TIMESTAMP
 
        time_t t_timestamp = time(0);   // get time now;
        tm *ltm = localtime(&t_timestamp);
 
        // print various components of tm structure.
        VP1Msg::messageDebug(  "Year: "+ QString::number(1900 + ltm->tm_year)
                        + " - " + "Month: " + QString::number(1 + ltm->tm_mon) + " - "  // tm_mon is in the range [0, 11], so 1 must be added to get real months
                        + "Day: " +  QString::number(ltm->tm_mday)
                        + " - " "Time: " + QString::number(ltm->tm_hour) + ":" + QString::number(ltm->tm_min) + ":" + QString::number(ltm->tm_sec) + "CEST");
 
        std::ostringstream ostri_unix;
        ostri_unix << t_timestamp;
 
        std::ostringstream ostri;
        ostri  << 1900 + ltm->tm_year
               << "-" << 1 + ltm->tm_mon  // tm_mon is in the range [0, 11], so 1 must be added to get real months
               << "-" << ltm->tm_mday
               << "T" << ltm->tm_hour << "-" << ltm->tm_min << "-" << ltm->tm_sec << "CEST";
 
        std::string unixTimestamp = ostri_unix.str();
        std::string humanTimestamp = ostri.str();
        QString q_unixTimestamp = QString::fromStdString(unixTimestamp);
        QString q_humanTimestamp = QString::fromStdString(humanTimestamp);
        VP1Msg::messageDebug("Unix timestamp: " + q_unixTimestamp );
        VP1Msg::messageDebug("'human readable' timestamp: " + q_humanTimestamp );
 
        /* channel's name is the name of the last channel updated by the executer,
         * i.e. the name changes according to the order the channels are refreshed.
         * Thus, we don't use the channel's name in the filename,
         * because it could be misleading.
         */
        //QString filename = currentsaveimagepath + "vp1_" + chnlname + "_snapshot_" + q_humanTimestamp + ".png";
        QString filename = folder + "vp1_batch_snapshot_r" + runnumb + "_ev" + evnumb + "_evtime_H" + h_evtimestamp + "_U" + evtimestamp + "___imgtime_H" + q_humanTimestamp + "_U" + q_unixTimestamp + ".png";
 
        // taking the actual snapshot
        QPixmap pm = s->channel()->getSnapshot();
        if (pm.isNull()) {
            VP1Msg::messageDebug("QPixmap is null! returning...");
            return QString();
        }
 
        // saving to file
        pm.save(filename);
 
        // save last-saved image filename to working dir
        QString latestImageFileName = currentsaveimagepath + QString("latest_vp1image");
        QFile latestImage(latestImageFileName);
        if(latestImage.exists() && !latestImage.remove())
            throw std::runtime_error("Unable to overwrite the existing latest image file");
        if(!latestImage.open(QIODevice::WriteOnly | QIODevice::Text))
            throw std::runtime_error("Unable to create new latest image file");
        latestImage.write(filename.toStdString().c_str());
        latestImage.close();
 
 
        return filename;
    }
 
    // default exit
    return QString();//filename;
 
}

setCruiseMode()

void VP1ExecutionScheduler::setCruiseMode

(

const CruiseMode &

m

)

Definition at line 1312 of file VP1ExecutionScheduler.cxx.

{
    if (m_d->cruisemode == m)
        return;
    m_d->cruisemode = m;
 
    m_d->mainwindow->tabManager()->setTabCruiseMode(m==TAB||m==BOTH);
 
    m_d->initCruise();
 
}

setNextRequestedEventFile()

void VP1ExecutionScheduler::setNextRequestedEventFile

(

const QString &

f

)

Definition at line 584 of file VP1ExecutionScheduler.cxx.

{
    m_d->nextRequestedEvent = f;
}

startRefreshQueueIfAppropriate

void VP1ExecutionScheduler::startRefreshQueueIfAppropriate ( )

privateslot

Definition at line 791 of file VP1ExecutionScheduler.cxx.

{
    if (!m_d->goingtonextevent&&!m_d->refreshtimer->isActive())
        m_d->refreshtimer->start();
}

systemNeedErase

void VP1ExecutionScheduler::systemNeedErase ( )

privateslot

Definition at line 734 of file VP1ExecutionScheduler.cxx.

                                            {
    IVP1System*s = static_cast<IVP1System*>(sender());
    assert(s);
    if (m_d->currentsystemrefreshing!=s) {
        eraseSystem(s);
    } else {
                // cppcheck-suppress assertWithSideEffect
        assert(s->isRefreshing());
        m_d->eraseJustAfterRefresh=true;
    }
}

uncreateAndDelete()

void VP1ExecutionScheduler::uncreateAndDelete

(

IVP1ChannelWidget *

cw

)

Definition at line 1098 of file VP1ExecutionScheduler.cxx.

{
    assert(cw->state()==IVP1ChannelWidget::READY);
    if (m_d->currentsystemrefreshing&&cw->systems().find(m_d->currentsystemrefreshing)!=cw->systems().end()) {
        assert(!m_d->postponedUncreateAndDeleteCW);
        m_d->postponedUncreateAndDeleteCW=cw;
    } else {
        actualUncreateAndDelete(cw);
    }
}

updateProgressBarDuringRefresh

void VP1ExecutionScheduler::updateProgressBarDuringRefresh ( )

privateslot

Definition at line 566 of file VP1ExecutionScheduler.cxx.

{
    if (m_d->currentrefreshsystemestimate<1.0)
        return;
    double timing=(m_d->prioritiser->elapsedTiming_Refresh())*0.95;//The *0.95 is to give a smoother overall impression.
    if (timing>m_d->currentrefreshsystemestimate)
        return;
    m_d->pb->setValue(static_cast<int>((m_d->calctimethisevent+timing)*10.0));
}

userRequestedFiles()

QStringList VP1ExecutionScheduler::userRequestedFiles

(

)

Definition at line 1371 of file VP1ExecutionScheduler.cxx.

{
    return m_d->mainwindow->userRequestedFiles();
}

Member Data Documentation

m_d

Imp* VP1ExecutionScheduler::m_d

private

Definition at line 117 of file VP1ExecutionScheduler.h.

---

The documentation for this class was generated from the following files:

• VP1ExecutionScheduler.h
• VP1ExecutionScheduler.cxx