TBBQEventManager.cxx

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Ref: http://root.cern.ch/root/html/tutorials/eve/alice_vsd.C.html
//------------------------------------------------------------------------------

#include "TBBQManager.h"
#include "TBBQEventManager.h"
#include "vistpc.h"

// C++

#include <string>
#include <sstream>
#include <iostream>

// ROOT

#include "TList.h"

#include "TGListBox.h"
#include "TGTextEntry.h"

#include "TEveEventManager.h"

// LCIO

#include "lcio.h"

#include "EVENT/LCIO.h"
#include "IO/LCReader.h"

//------------------------------------------------------------------------------
// Constructors & Destructor
//------------------------------------------------------------------------------

TBBQEventManager::TBBQEventManager(VisTPC*& visTPC) :
   fVisTPC(visTPC),
   fLCReader(lcio::LCFactory::getInstance()->createLCReader()),
   fCurrentEvent(0),
   fRunNumberEntry(0),
   fEventNumberEntry(0),
   fFirstEventNumber(0)
{
   SetElementNameTitle("Event", "Event");
}

//------------------------------------------------------------------------------
// Methods (alphabetical order)
//------------------------------------------------------------------------------

void TBBQEventManager::readFile(const std::string& filePath, bool clearEventCollections) {
   fCurrentFile  = filePath;
   fCurrentEvent = 0;

   fLCReader->open(fCurrentFile);

   // Only show the collections that is contained in the first event.
   // We don't care whether other events has other collections or not.

   EVENT::LCEvent* event = 0;
   if ( !(event = fLCReader->readNextEvent()) ) {
      std::cout << "No events.. breaking" << std::endl;
      return;
   }

   if (clearEventCollections) {
      gBBQ->clearEventCollections();
      gBBQ->displayEventCollections(event);
   }

   fCurrentEvent = event;
   fFirstEventNumber = event->getEventNumber();

   EventChanged();
   RunChanged();
}

void TBBQEventManager::DropEvent() {
   gBBQ->GetCurrentEvent()->DestroyElements();
}



void TBBQEventManager::EventChanged() {
   int number = fCurrentEvent->getEventNumber();

   std::stringstream eventNumber;
   eventNumber << number;

   //std::cout << "Emitting EventChanged(" << number << ")" << std::endl;

   EventChanged(fCurrentEvent->getEventNumber());
   EventChanged(eventNumber.str().c_str());

   // HACK
   // Should be done via Signal/Slot mechanism

   if (fEventNumberEntry)
      fEventNumberEntry->SetText(eventNumber.str().c_str(), kFALSE);

   // small hack: in case no collections have been loaded in the previous
   // events the collections are loaded now.
   // Attention: This means the collections are not available in all events.
   // (p.s. it is save because displayCollections doesn nothing if the 
   // collections are not empty, and they are not reset)
   gBBQ->displayEventCollections(fCurrentEvent);
}

void TBBQEventManager::EventChanged(int number) {
   Emit("EventChanged(int)", number);
}

void TBBQEventManager::EventChanged(const char* number) {
   Emit("EventChanged(const char*)", number);
}

void TBBQEventManager::handleEventEntry() {
   GotoEvent(fEventNumberEntry->GetText());
}

void TBBQEventManager::handleRunEntry() {
   // Not implemented yet.
}

void TBBQEventManager::GotoEvent(int eventNumber) {

   //===================================
   // 1. Checks
   // 2. If we already have read an event.
   //    a. Navigate backward to event.
   //    b. Reload event.
   // 3. Navigate forward to new event.
   // 4. Do stuff with the event.

   //===================================
   // 1. Checks

   if (fCurrentFile.empty()) {
      std::cout << "First open a file to read!" << std::endl;
      return;
   }

   if (eventNumber < 0) {
      std::cout << "Need positive event number." << std::endl;
      return;
   }

   //===================================
   // 2. If we already have read an event.

   // This is initialized to -1 because the event numbers start from 0.
   // Otherwise it will get into trouble with the fast forward code below.
   int currentEventNumber = -1;
   int lastRunNumber      = -1;

   if (fCurrentEvent) {

      currentEventNumber = fCurrentEvent->getEventNumber();

      // 2a. Navigate backward to event.

      if (eventNumber - currentEventNumber < 0) {
         std::cout << "We can go backwards. Let me reopen the file." << std::endl;

         fLCReader->close();
         readFile(fCurrentFile, false);
         GotoEvent(eventNumber > fFirstEventNumber ? eventNumber : fFirstEventNumber);

         return;
      }

      // 2b. Reload event

      if (eventNumber - currentEventNumber == 0) {
         std::cout << "Sure, we will stay on the same event." << std::endl;
         //return;
      }

      lastRunNumber = fCurrentEvent->getRunNumber();
   }

   //===================================
   // 3. Navigate forward to new event.

   EVENT::LCEvent* event = fCurrentEvent; // For reload.

   while (eventNumber - currentEventNumber) {

      if ( !(event = fLCReader->readNextEvent()) )
         break;

      ++currentEventNumber;

      if (currentEventNumber > fLastEventNumber)
         fLastEventNumber = currentEventNumber;

   }

   // For the future
   // event = fLCReader->readEvent(0, eventNumber);

   //===================================
   // 4. Do stuff with the event.

   if (event) {

      DropEvent();

      std::cout << "Run #: "   << event->getRunNumber()   << ", "
                << "Event #: " << event->getEventNumber() << std::endl;

      try {

         fCurrentEvent = event;

         TList selectedEntries;

         gBBQ->getHitsCollections()->GetSelectedEntries(&selectedEntries);
         gBBQ->getPulsesCollections()->GetSelectedEntries(&selectedEntries);
         gBBQ->getTracksCollections()->GetSelectedEntries(&selectedEntries);

         fVisTPC->drawEvent(event, selectedEntries, NULL);

         // Emit signals. These methods uses fCurrentEvent.

         EventChanged();
         if (event->getRunNumber() != lastRunNumber)
            RunChanged();

      } catch (...) {
         // Do nothing
      }

   } else {

      std::cout << "No more events. Going back to the first one." << std::endl;

      fLCReader->close();
      readFile(fCurrentFile, false);
      GotoEvent(fFirstEventNumber);

   }
}

void TBBQEventManager::GotoEvent(const char* eventNumberStr) {
   std::stringstream sstr;

   sstr << eventNumberStr;

   int eventNumber;

   if (sstr >> eventNumber)
      GotoEvent(eventNumber);
   else
      std::cout << "\"" << eventNumberStr << "\""
                << "is not a number." << std::endl;
}

void TBBQEventManager::NextEvent() {
   GotoEvent(fCurrentEvent ? fCurrentEvent->getEventNumber() + 1 : fFirstEventNumber);
}

void TBBQEventManager::PrevEvent() {
   GotoEvent(fCurrentEvent ? fCurrentEvent->getEventNumber() - 1 : fFirstEventNumber);
}

void TBBQEventManager::ReloadEvent() {
   GotoEvent(fCurrentEvent ? fCurrentEvent->getEventNumber() : fFirstEventNumber);
}

void TBBQEventManager::RunChanged() {
   int number = fCurrentEvent->getRunNumber();

   std::stringstream runNumber;
   runNumber << number;

   //std::cout << "Emitting RunChanged(" << number << ")" << std::endl;

   RunChanged(fCurrentEvent->getRunNumber());
   RunChanged(runNumber.str().c_str());

   // HACK
   // Should be done via Signal/Slot mechanism

   if (fRunNumberEntry)
      fRunNumberEntry->SetText(runNumber.str().c_str(), kFALSE);
}

void TBBQEventManager::RunChanged(int number) {
   Emit("RunChanged(int)", number);
}

void TBBQEventManager::RunChanged(const char* number) {
   Emit("RunChanged(const char*)", number);
}