GenericEventHandler.cpp

Go to the documentation of this file.

// $Id: $
//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================

// Framework include files
#include "DDEve/GenericEventHandler.h"
#include "DD4hep/Primitives.h"
#include "DD4hep/Factories.h"
#include "DD4hep/Plugins.h"
#include <stdexcept>

#include "TGMsgBox.h"
#include "TSystem.h"
#include <climits>

using namespace std;
using namespace DD4hep;

ClassImp(GenericEventHandler)

GenericEventHandler::GenericEventHandler() : m_current(0) {
}

GenericEventHandler::~GenericEventHandler()  {
  m_subscriptions.clear();
  deletePtr(m_current);
}

EventHandler* GenericEventHandler::current() const   {
  if ( m_current )  {
    return m_current;
  }
  throw runtime_error("Invalid event handler");
}

void GenericEventHandler::NotifySubscribers(void (EventConsumer::*pmf)(EventHandler*))   {
  for(Subscriptions::iterator i=m_subscriptions.begin(); i!=m_subscriptions.end();++i)
    ((*i)->*pmf)(this);
}

void GenericEventHandler::Subscribe(EventConsumer* consumer)  {
  m_subscriptions.insert(consumer);
}

void GenericEventHandler::Unsubscribe(EventConsumer* consumer)  {
  Subscriptions::iterator i=m_subscriptions.find(consumer);
  if ( i != m_subscriptions.end() ) m_subscriptions.erase(i);
}

long GenericEventHandler::numEvents() const   {
  return current()->numEvents();
}

string GenericEventHandler::datasourceName() const {
  return current()->datasourceName();
}

EventHandler::CollectionType GenericEventHandler::collectionType(const string& collection) const   {
  if ( m_current && m_current->hasEvent() )  {
    return m_current->collectionType(collection);
  }
  return NO_COLLECTION;
}

size_t GenericEventHandler::collectionLoop(const string& collection, DDEveHitActor& actor) {
  if ( m_current && m_current->hasEvent() )  {
    return m_current->collectionLoop(collection,actor);
  }
  return 0;
}

size_t GenericEventHandler::collectionLoop(const string& collection, DDEveParticleActor& actor)    {
  if ( m_current && m_current->hasEvent() )  {
    return m_current->collectionLoop(collection,actor);
  }
  return 0;
}

bool GenericEventHandler::Open(const string& file_type, const string& file_name)   {
  size_t idx = file_name.find("lcio");
  size_t idr = file_name.find("root");
  string err;
  m_hasFile = false;
  m_hasEvent = false;
  try  {
    deletePtr(m_current);
    //  prefer event handler configured in xml
    if ( file_type.find("FCC") != string::npos ) {
      m_current = (EventHandler*)PluginService::Create<void*>("DDEve_FCCEventHandler",(const char*)0);
    }
    // fall back to defaults according to file ending
    else if ( idx != string::npos )   {
      m_current = (EventHandler*)PluginService::Create<void*>("DDEve_LCIOEventHandler",(const char*)0);
    }
    else if ( idr != string::npos )   {
      m_current = (EventHandler*)PluginService::Create<void*>("DDEve_DDG4EventHandler",(const char*)0);
    }
    else   {
      throw runtime_error("Attempt to open file:"+file_name+" of unknown type:"+file_type);
    }
    if ( m_current )   {
      if ( m_current->Open(file_type, file_name) )   {
        m_hasFile = true;
        NotifySubscribers(&EventConsumer::OnFileOpen);
        return true;
      }
      err = "+++ Failed to open the data file:"+file_name;
      deletePtr(m_current);   
    }
    else  {
      err = "+++ Failed to create fikle reader for file '"+file_name+"' of type '"+file_type+"'";
    }
  }
  catch(const exception& e)  {
    err = "\nAn exception occurred \n"
      "while opening event data:\n" + string(e.what()) + "\n\n";
  }
  string path = TString::Format("%s/icons/stop_t.xpm", gSystem->Getenv("ROOTSYS")).Data();
  const TGPicture* pic = gClient->GetPicture(path.c_str());
  new TGMsgBox(gClient->GetRoot(),0,"Failed to open event data",err.c_str(),pic,
               kMBDismiss,0,kVerticalFrame,kTextLeft|kTextCenterY);
  return false;
}

bool GenericEventHandler::NextEvent()   {
  m_hasEvent = false;
  try {
    if ( m_hasFile )   {
      if ( current()->NextEvent() > 0 )   {
        m_hasEvent = true;
        NotifySubscribers(&EventConsumer::OnNewEvent);
        return 1;
      }
    }
    throw runtime_error("+++ EventHandler::readEvent: No file open!");
  }
  catch(const exception& e)  {
    string path = TString::Format("%s/icons/stop_t.xpm", gSystem->Getenv("ROOTSYS")).Data();
    string err = "\nAn exception occurred \n"
      "while reading a new event:\n" + string(e.what()) + "\n\n";
    const TGPicture* pic = gClient->GetPicture(path.c_str());
    new TGMsgBox(gClient->GetRoot(),0,"Failed to read event", err.c_str(),pic,
                 kMBDismiss,0,kVerticalFrame,kTextLeft|kTextCenterY);
  }
  return -1;
}

bool GenericEventHandler::PreviousEvent()    {
  m_hasEvent = false;
  if ( m_hasFile && current()->PreviousEvent() > 0 )   {
    m_hasEvent = true;
    NotifySubscribers(&EventConsumer::OnNewEvent);
    return 1;
  }
  return -1;
}

bool GenericEventHandler::GotoEvent(long event_number)   {
  m_hasEvent = false;
  if ( m_hasFile && current()->GotoEvent(event_number) > 0 )   {
    m_hasEvent = true;
    NotifySubscribers(&EventConsumer::OnNewEvent);
    return 1;
  }
  return -1;
}